import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public void setScore(int score) {
    if (this.score == score) {
        return;
    }
    this.score = score;
    final Multimap<Scoreboard, Objective> scoreboards = HashMultimap.create();
    for (Objective objective : this.objectives) {
        for (Scoreboard scoreboard : ((LanternObjective) objective).scoreboards) {
            scoreboards.put(scoreboard, objective);
        }
    }
    if (!scoreboards.isEmpty()) {
        final Map<Objective, Message> messages = new HashMap<>();
        for (Map.Entry<Scoreboard, Objective> entry : scoreboards.entries()) {
            ((LanternScoreboard) entry.getKey()).sendToPlayers(() -> Collections.singletonList(
                    messages.computeIfAbsent(entry.getValue(), obj -> new MessagePlayOutScoreboardScore.CreateOrUpdate(
                            obj.getName(), this.legacyName, score))));
        }
    }
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public void updateDisplaySlot(@Nullable Objective objective, DisplaySlot displaySlot) throws IllegalStateException {
    checkNotNull(displaySlot, "displaySlot");
    if (objective == null) {
        final Objective oldObjective = this.objectivesInSlot.remove(displaySlot);
        if (oldObjective != null) {
            // Clear the display slot on the client
            this.sendToPlayers(() -> Collections.singletonList(
                    new MessagePlayOutScoreboardDisplayObjective(null, displaySlot)));
        }
    } else {
        checkState(this.objectives.containsValue(objective),
                "The specified objective does not exist in this scoreboard.");
        if (this.objectivesInSlot.put(displaySlot, objective) != objective) {
            // Update the displayed objective on the client
            this.sendToPlayers(() -> Collections.singletonList(
                    new MessagePlayOutScoreboardDisplayObjective(objective.getName(), displaySlot)));
        }
    }
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Listener
//Scoreboards are loaded when the world is loaded so load it here
public void onGameStarted(GameStartedServerEvent gameStartedServerEvent) {
    Optional<Scoreboard> serverScoreboard = Sponge.getServer().getServerScoreboard();
    if (serverScoreboard.isPresent()) {
        Scoreboard globalScoreboard = serverScoreboard.get();
        if (configuration.getConfig().isNametagHealth()) {
            globalScoreboard.getObjective(PomData.ARTIFACT_ID).ifPresent(globalScoreboard::removeObjective);

            Objective objective = Objective.builder()
                    .name(PomData.ARTIFACT_ID)
                    .displayName(Text.of(TextColors.DARK_RED, "Health"))
                    .criterion(Criteria.DUMMY)
                    .objectiveDisplayMode(ObjectiveDisplayModes.INTEGER)
                    .build();
            globalScoreboard.addObjective(objective);
            globalScoreboard.updateDisplaySlot(objective, DisplaySlots.BELOW_NAME);
        }
    } else {
        logger.warn("Global scoreboard couldn't be loaded");
    }
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public org.bukkit.scoreboard.Objective registerNewObjective(String name, String criteria)
        throws IllegalArgumentException {
    checkArgument(name != null, "Name must not be null");
    Objective.Builder builder = Objective.builder();
    //noinspection ConstantConditions
    builder.name(name);
    if (criteria != null) {
        //TODO: no idea whether this is right
        Optional<Criterion> criterion = Pore.getGame().getRegistry().getType(Criterion.class, criteria);
        if (criterion.isPresent()) {
            builder.criterion(criterion.get());
        }
    }
    return PoreObjective.of(builder.build());
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private void swapBuffers() {
    this.scoreboard.updateDisplaySlot(this.buffer, DisplaySlots.SIDEBAR);

    Objective temp = this.buffer;

    this.buffer = this.objective;
    this.objective = temp;
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public boolean addObjective(EPlayer player, int priority, DisplaySlot display, Objective objective) {
	Optional<Objective> objective_player = player.getScoreboard().getObjective(display);
	if (!objective_player.isPresent() || getPriority(display, objective_player.get()) <= priority) {
		// Supprime l'ancien
		if (objective_player.isPresent()) {
			player.getScoreboard().removeObjective(objective_player.get());
		}
		
		// Ajoute le nouveau
		if (!player.getScoreboard().getObjective(objective.getName()).isPresent()) {
			player.getScoreboard().addObjective(objective);
			player.getScoreboard().updateDisplaySlot(objective, display);
			
			// Event
			if (objective_player.isPresent()) {
				this.postReplace(player, objective_player.get(), objective, display);
			} else {
				this.postAdd(player, objective, display);
			}
			
			return true;
		} else {
			this.plugin.getELogger().warn("Multi-Objective (player='" + player.getIdentifier() + "';objective='" + objective.getName() + "')");
		}
	}
	return false;
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public boolean removeObjective(EPlayer player, DisplaySlot display, String identifier) {
	Optional<Objective> objective = player.getScoreboard().getObjective(display);
	if (objective.isPresent() && objective.get().getName().equals(identifier)) {
		player.getScoreboard().removeObjective(objective.get());
		
		// Event 
		this.postRemove(player, objective.get(), display);
		return true;
	}
	return false;
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private void postAdd(EPlayer player, Objective objective, DisplaySlot display) {
	this.plugin.getELogger().debug("Event ScoreBoardEvent.Add : ("
			+ "uuid='" + player.getUniqueId() + "';"
			+ "objective='" + objective.getName() + "';"
			+ "display='" + display.getName() + "')");
	this.plugin.getGame().getEventManager().post(ESpongeEventFactory.createScoreBoardEventAdd(player, objective, display, Cause.source(this.plugin).build()));
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private void postRemove(EPlayer player, Objective objective, DisplaySlot display) {
	this.plugin.getELogger().debug("Event ScoreBoardEvent.Remove : ("
			+ "uuid='" + player.getUniqueId() + "';"
			+ "objective='" + objective.getName() + "';"
			+ "display='" + display.getName() + "')");
	this.plugin.getGame().getEventManager().post(ESpongeEventFactory.createScoreBoardEventRemove(player, objective, display, Cause.source(this.plugin).build()));
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private void postReplace(EPlayer player, Objective objective, Objective new_objective, DisplaySlot display) {
	this.plugin.getELogger().debug("Event ScoreBoardEvent.Replace : ("
			+ "uuid='" + player.getUniqueId() + "';"
			+ "objective='" + objective.getName() + "';"
			+ "new_objective='" + new_objective.getName() + "';"
			+ "display='" + display.getName() + "')");
	this.plugin.getGame().getEventManager().post(ESpongeEventFactory.createScoreBoardEventReplace(player, objective, new_objective, display, Cause.source(this.plugin).build()));
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
public ScoreBoardEvent(EPlayer player, Action action, Objective objective, String identifier,
		DisplaySlot displaySlot, Cause cause) {
	super();
	this.player = player;
	this.action = action;
	this.objective = objective;
	this.identifier = identifier;
	this.displaySlot = displaySlot;
	this.cause = cause;
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private static Score addToObjective(Objective objective, @Nullable Score score, Text name, int value) {
    if (score == null) {
        score = objective.getOrCreateScore(name);
        score.setScore(value);
    } else {
        objective.addScore(score);
    }
    return score;
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public ScoreText deserialize(JsonElement element, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    final JsonObject obj = element.getAsJsonObject();
    final Text name = LanternTexts.fromLegacy(obj.get(SCORE_NAME).getAsString());
    // Try to parse the value
    int value = 0;
    try {
        value = Integer.parseInt(obj.get(SCORE_VALUE).getAsString());
    } catch (NumberFormatException ignored) {
    }
    final String baseObjective = obj.get(SCORE_MAIN_OBJECTIVE).getAsString();
    final Set<Objective> objectives = new HashSet<>();
    if (!baseObjective.isEmpty()) {
        this.tryAddObjective(baseObjective, objectives);
    }
    if ((element = obj.get(SCORE_EXTRA_OBJECTIVES)) != null) {
        final JsonArray array = element.getAsJsonArray();
        for (JsonElement jsonElement : array) {
            this.tryAddObjective(jsonElement.getAsString(), objectives);
        }
    }
    String override = null;
    if ((element = obj.get(SCORE_OVERRIDE)) != null) {
        override = element.getAsString();
    }

    final Score score = new LanternScore(name);
    // TODO: How to handle the objectives?
    // We cannot add them to the score without attaching the
    // score to the objective
    score.setScore(value);

    final ScoreText.Builder builder = Text.builder(score).override(override);
    deserialize(obj, builder, context);
    return builder.build();
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public LanternObjectiveBuilder from(Objective value) {
    this.name(value.getName())
            .criterion(value.getCriterion())
            .displayName(value.getDisplayName())
            .objectiveDisplayMode(value.getDisplayMode());
    return this;
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public Objective build() throws IllegalStateException {
    checkState(this.name != null, "name is not set");
    checkState(this.displayName != null, "displayName is not set");
    checkState(this.criterion != null, "criterion is not set");
    return new LanternObjective(this.name, this.criterion, this.objectiveDisplayMode, this.displayName);
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private void updateClientAfterRemove(Score score) {
    final Map<Objective, Message> messages = new HashMap<>();
    for (Scoreboard scoreboard : this.scoreboards) {
        ((LanternScoreboard) scoreboard).sendToPlayers(() -> Collections.singletonList(
                messages.computeIfAbsent(this, obj -> new MessagePlayOutScoreboardScore.Remove(
                        this.getName(), ((LanternScore) score).getLegacyName()))));
    }
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
public void removePlayer(LanternPlayer player) {
    this.players.remove(player);
    for (Objective objective : this.objectives.values()) {
        player.getConnection().send(new MessagePlayOutScoreboardObjective.Remove(objective.getName()));
    }
    for (Team team : this.teams.values()) {
        player.getConnection().send(new MessagePlayOutTeams.Remove(team.getName()));
    }
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
public void addPlayer(LanternPlayer player) {
    this.players.add(player);
    for (Objective objective : this.objectives.values()) {
        player.getConnection().send(this.createObjectiveInitMessages(objective));
    }
    for (Map.Entry<DisplaySlot, Objective> entry : this.objectivesInSlot.entrySet()) {
        player.getConnection().send(new MessagePlayOutScoreboardDisplayObjective(entry.getValue().getName(), entry.getKey()));
    }
    for (Team team : this.teams.values()) {
        player.getConnection().send(((LanternTeam) team).toCreateOrUpdateMessage(true));
    }
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
@Override
public void addObjective(Objective objective) throws IllegalArgumentException {
    checkNotNull(objective, "objective");
    checkArgument(!this.objectives.containsKey(objective.getName()), "A score with the name %s already exists!",
            objective.getName());
    this.objectives.put(objective.getName(), objective);
    this.objectivesByCriterion.put(objective.getCriterion(), objective);
    ((LanternObjective) objective).addScoreboard(this);
    // Create the scoreboard objective on the client
    this.sendToPlayers(() -> this.createObjectiveInitMessages(objective));
}
 

import org.spongepowered.api.scoreboard.objective.Objective; //导入依赖的package包/类
private List<Message> createObjectiveInitMessages(Objective objective) {
    final List<Message> messages = new ArrayList<>();
    messages.add(new MessagePlayOutScoreboardObjective.Create(
            objective.getName(), ((LanternObjective) objective).getLegacyDisplayName(), objective.getDisplayMode()));
    for (Score score : ((LanternObjective) objective).scores.values()) {
        messages.add(new MessagePlayOutScoreboardScore.CreateOrUpdate(objective.getName(),
                LanternTexts.toLegacy(score.getName()), score.getScore()));
    }
    return messages;
}