下面列出了怎么用org.bukkit.scoreboard.Team的API类实例代码及写法,或者点击链接到github查看源代码。
protected void updatePartyScoreboardTeam(Party party, Team team, boolean forObservers) {
match.getLogger().fine("Updating scoreboard team " + toString(team) + " for party " + party);
team.setDisplayName(TextTranslations.translateLegacy(party.getName(), null));
team.setPrefix(party.getColor().toString());
team.setSuffix(ChatColor.WHITE.toString());
team.setCanSeeFriendlyInvisibles(true);
team.setAllowFriendlyFire(false);
if (!forObservers && party instanceof Competitor) {
NameTagVisibility nameTags = ((Competitor) party).getNameTagVisibility();
team.setNameTagVisibility(nameTags);
} else {
team.setNameTagVisibility(NameTagVisibility.ALWAYS);
}
}
@Override
public void setOption(Option option, OptionStatus status) throws IllegalStateException {
checkState();
switch (option) {
case NAME_TAG_VISIBILITY:
team.setNameTagVisibility(EnumVisible.values()[status.ordinal()]);
break;
case DEATH_MESSAGE_VISIBILITY:
team.setDeathMessageVisibility(EnumVisible.values()[status.ordinal()]);
break;
case COLLISION_RULE:
team.setCollisionRule(net.minecraft.scoreboard.Team.CollisionRule.values()[status.ordinal()]);
break;
default:
throw new IllegalArgumentException("Unrecognised option " + option);
}
}
/**
* Connect the player to the scoreboard
* - Disconnects from any existing scoreboards
* - Creates a new scoreboard for the world if required
*/
public void connect(GPlayer gPlayer) {
if (gPlayer != null && isEnabled) {
//Disconnect the player from the current scoreboard (if required):
disconnect(gPlayer);
//Connect online players to their associated-world scoreboards:
Player onlinePlayer = gPlayer.getOnlinePlayer();
if (onlinePlayer != null) {
Scoreboard scoreboard = getScoreboard(gPlayer);
onlinePlayer.setScoreboard(scoreboard);
Team team = scoreboard.registerNewTeam(onlinePlayer.getName());
team.addEntry(onlinePlayer.getName());
update(gPlayer);
}
}
}
/**
* Disconnect the player from the scoreboard
* - Removes the player from their team (i.e., player-color)
* - Removes their score from the scoreboard
* - The scoreboard will still be displayed on the player's client
* until a new scoreboard is assigned or the user exits
*/
public void disconnect(GPlayer gPlayer) {
if (!isEnabled) {
return;
}
UUID associatedWorldId = gPlayer.getAssociatedWorldId();
Scoreboard scoreboard = getScoreboard(associatedWorldId, false);
if (scoreboard != null) {
//Remove the team (i.e., player-color)
OfflinePlayer player = Bukkit.getOfflinePlayer(gPlayer.getUuid());
Team team = scoreboard.getTeam(player.getName());
if (team != null) {
team.removeEntry(player.getName());
team.unregister();
}
//Remove the player's score:
scoreboard.resetScores(player.getName());
//Delete unused scoreboards:
if (scoreboard.getEntries().size() == 0) {
scoreboards.remove(associatedWorldId);
}
}
}
/**
* Display a player's score
* - Uses the player's associated-world scoreboard
* - Note: the player may be in a different world, that's ok
* - Player names are mapped to color warmth (based on their score)
*/
private void updatePlayerScore(GPlayer gPlayer) {
if (gPlayer != null) {
//Do not update associated-worlds with disabled climate-engines:
// - Ignore offline players (e.g., someone completing an offline player's bounty)
Player onlinePlayer = gPlayer.getOnlinePlayer();
if (onlinePlayer != null && ClimateEngine.getInstance().isClimateEngineEnabled(gPlayer.getAssociatedWorldId())) {
//Update the player's score:
Scoreboard scoreboard = getScoreboard(gPlayer);
if (scoreboard != null) {
Objective objective = scoreboard.getObjective(GLOBAL_WARMING);
if (objective != null) {
Team team = scoreboard.getPlayerTeam(onlinePlayer);
if (team != null) {
team.setColor(Colorizer.getScoreColor(gPlayer.getCarbonScore()));
objective.getScore(onlinePlayer).setScore(gPlayer.getCarbonScore());
}
}
}
}
}
}
private void updateTeamVariable(Scoreboard scoreboard, TagPlayerData playerData) {
Team entryTeam = TagUtils.getTeamComputeIfAbsent(scoreboard, playerData.getTeamHash());
if (!entryTeam.getEntries().contains(playerData.getNameDisplay())) {
entryTeam.addEntry(playerData.getNameDisplay());
}
if (entryTeam.getPrefix() == null || !entryTeam.getPrefix().equals(playerData.getPrefix())) {
entryTeam.setPrefix(playerData.getPrefix());
}
if (entryTeam.getSuffix() == null || !entryTeam.getSuffix().equals(playerData.getSuffix())) {
entryTeam.setSuffix(playerData.getSuffix());
}
Team.OptionStatus option = entryTeam.getOption(Team.Option.NAME_TAG_VISIBILITY);
if (option == Team.OptionStatus.ALWAYS && !playerData.isNameVisibility()) {
entryTeam.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.NEVER);
} else if (option == Team.OptionStatus.NEVER && playerData.isNameVisibility()) {
entryTeam.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
}
if (TabooLib.getConfig().getBoolean("TABLIST-AUTO-CLEAN-TEAM", true)) {
TagUtils.cleanEmptyTeamInScoreboard(scoreboard);
}
}
@Override
protected Team.OptionStatus parseInternal(Node node, String text) throws FormatException, InvalidXMLException {
switch(node.getValue()) {
case "yes":
case "on":
case "true":
return Team.OptionStatus.ALWAYS;
case "no":
case "off":
case "false":
return Team.OptionStatus.NEVER;
case "ally":
case "allies":
return Team.OptionStatus.FOR_OWN_TEAM;
case "enemy":
case "enemies":
return Team.OptionStatus.FOR_OTHER_TEAMS;
default:
throw new InvalidXMLException("Invalid team relationship", node);
}
}
/**
* GUNLIST:
* <p>
* 2: P30 3 PKP 4 MP5K 5 AK47 6: AK 7 M16 8 Remmington 9 FNFal 10 RPG 11 UMP 12
* SW1911 13 M40 14 Ammo 556 15 9mm 16 buckshot 17 rocketRPG 18 Enfield 19 Henry
* 20 MouserC96
* <p>
* 22 Grenades
*/
@Override
public void onDisable() {
for (Entry<MaterialStorage, CustomBaseObject> misc : miscRegister.entrySet()) {
if (misc instanceof ThrowableItems) {
for (Entry<Entity, ThrowableHolder> e : ThrowableItems.throwItems.entrySet()) {
if (e.getKey() instanceof Item)
e.getKey().remove();
}
}
}
for (Scoreboard s : coloredGunScoreboard)
for (Team t : s.getTeams())
t.unregister();
for (Gunner g : gunners) {
g.dispose();
}
}
@Override
public boolean isTarget(LivingEntity ent, String prefix, String value) {
try {
if (prefix.equals("sbteam") && ent instanceof Player) {
Team t = Bukkit.getScoreboardManager().getMainScoreboard().getTeam(value);
if (t != null) {
if (t.hasEntry(((Player) ent).getName())) {
return true;
}
}
}
}
catch (Exception ex) {
ex.printStackTrace();
}
return false;
}
public void renderObjective(GameObjective objective) {
if (!objective.showOnScoreboard()) return;
int score = currentScore;
Team team = scoreboard.getTeam(objective.getScoreboardHandler().getNumber() + "-o");
String prefix = objective.getScoreboardHandler().getPrefix(this.team);
team.setPrefix(prefix);
if (team.getEntries().size() > 0) {
setScore(this.objective, new ArrayList<>(team.getEntries()).get(0), score);
} else {
String raw = (objective instanceof HillObjective ? "" : ChatColor.RESET) + " " + WordUtils.capitalizeFully(objective.getName().replaceAll("_", " "));
while (used.contains(raw)) {
raw = raw + ChatColor.RESET;
}
team.addEntry(raw);
setScore(this.objective, raw, score);
used.add(raw);
}
currentScore++;
}
@Override
public void deactivate() {
if (!activated) return;
activated = false;
// Set to the main scoreboard
if (holder.isOnline()) {
synchronized (this) {
holder.setScoreboard((Bukkit.getScoreboardManager().getMainScoreboard()));
}
}
// Unregister teams that are created for this scoreboard
for (Team team : teamCache.rowKeySet()) {
team.unregister();
}
// Stop updating
updateTask.cancel();
}
public void renderTeamTitle(TeamModule teamModule) {
Team team = scoreboard.getTeam(teamModule.getId() + "-t");
team.setPrefix(teamModule.getColor() + Strings.trimTo(teamModule.getName(), 0, 14));
team.setSuffix(Strings.trimTo(teamModule.getName(), 14, 30));
if (team.getEntries().size() > 0) {
setScore(objective, new ArrayList<>(team.getEntries()).get(0), currentScore);
} else {
String name = teamModule.getColor() + "";
while (used.contains(name)) {
name = teamModule.getColor() + name;
}
team.addEntry(name);
setScore(objective, name, currentScore);
used.add(name);
}
currentScore++;
}
@Override
protected boolean runCommand(CommandSender sender, OptionSet options) {
final Team team = teamSpec.value(options);
final Set<OfflinePlayer> players = Sets.newHashSet(playersSpec.values(options));
players.removeAll(team.getPlayers());
for (final OfflinePlayer player : players) {
team.addPlayer(player);
}
final Set<OfflinePlayer> finalTeam = team.getPlayers();
final String members = finalTeam.size() == 0
? ChatColor.DARK_GRAY + "No members"
: Joiner.on(", ").join(Iterables.transform(team.getPlayers(), FunctionalUtil.PLAYER_NAME_FETCHER));
sender.sendMessage(messages.evalTemplate(
"added",
ImmutableMap.of(
"count", players.size(),
"players", members
)
));
return false;
}
@Override
protected boolean runCommand(CommandSender sender, OptionSet options) {
int count = 0;
for (final OfflinePlayer player : playersSpec.values(options)) {
final Team team = scoreboard.getPlayerTeam(player);
if (team == null) {
continue;
}
count++;
team.removePlayer(player);
}
sender.sendMessage(messages.evalTemplate("removed", ImmutableMap.of("count", count)));
return true;
}
@Override
protected boolean runCommand(CommandSender sender, OptionSet options) {
Collection<Team> teams = teamSpec.values(options);
if (teams.size() == 0) {
teams = options.has(allSpec) ? module.getScoreboard().getTeams() : module.getTeams().values();
}
int count = 0;
for (final Team team : teams) {
for (final OfflinePlayer player : team.getPlayers()) {
team.removePlayer(player);
count++;
}
}
sender.sendMessage(messages.evalTemplate("cleared", ImmutableMap.of("teams", teams.size(), "players", count)));
return true;
}
/**
* Create a empty team.
*
* @param teamName The reference name of the team.
*/
public void createTeam(String teamName) {
if (!teamMap.containsKey(teamName)) {
Team team = teamBoard.registerNewTeam(teamName);
teamMap.put(teamName, team);
for (Object p : Bukkit.getServer().getOnlinePlayers().toArray()) {
Player tempPlayer = (Player) p;
if (!(tempPlayer.getScoreboard().getTeams().contains(teamMap.get(teamName)))) {
// Debug
Bukkit.broadcastMessage("Team Reg!");
tempPlayer.getScoreboard().registerNewTeam(teamName);
}
}
}
}
/**
* Puts a player into a team of their own and sets the team suffix to be the level
* @param playerUUID - the player's UUID
*/
public void setLevel(UUID playerUUID) {
Player player = plugin.getServer().getPlayer(playerUUID);
if (player == null) {
// Player is offline...
return;
}
// The default team name is their own name
String teamName = player.getName();
String level = String.valueOf(plugin.getPlayers().getIslandLevel(playerUUID));
Team team = board.getTeam(teamName);
if (team == null) {
//Team does not exist
team = board.registerNewTeam(teamName);
}
// Add the suffix
team.setSuffix(Settings.teamSuffix.replace("[level]",String.valueOf(level)));
//Adding player to team
team.addPlayer(player);
// Assign scoreboard to player
player.setScoreboard(board);
}
/**
* Sets the player's level explicitly
* @param playerUUID - the player's UUID
* @param l
*/
public void setLevel(UUID playerUUID, long l) {
Player player = plugin.getServer().getPlayer(playerUUID);
if (player == null) {
// Player is offline...
return;
}
// The default team name is their own name - must be 16 chars or less
String teamName = player.getName();
Team team = board.getTeam(teamName);
if (team == null) {
//Team does not exist
team = board.registerNewTeam(teamName);
}
// Add the suffix
team.setSuffix(Settings.teamSuffix.replace("[level]",String.valueOf(l)));
//Adding player to team
team.addPlayer(player);
// Assign scoreboard to player
player.setScoreboard(board);
}
public IslandGuard1_9(final ASkyBlock plugin) {
this.plugin = plugin;
this.thrownPotions = new HashMap<>();
if (!Settings.allowPushing) {
// try to remove the team from the scoreboard
try {
ScoreboardManager manager = plugin.getServer().getScoreboardManager();
if (manager != null) {
Scoreboard scoreboard = manager.getMainScoreboard();
if (scoreboard != null) {
Team pTeam = scoreboard.getTeam(NO_PUSH_TEAM_NAME);
if (pTeam != null) {
pTeam.unregister();
}
}
}
} catch (Exception e) {
plugin.getLogger().warning("Problem removing no push from scoreboard.");
}
}
}
/**
* Handles cleaning push protection on player quit
* @param player
*/
private void removePush(Player player)
{
try {
scoreboard = player.getScoreboard();
if(scoreboard !=null)
{
//Player Remove
Team pTeam = scoreboard.getTeam(NO_PUSH_TEAM_NAME);
if (pTeam != null) {
pTeam.removeEntry(player.getName());
}
}
} catch (Exception e) {
plugin.getLogger().severe("Error trying to remove player from push scoreboard");
plugin.getLogger().severe(player.getName() + " : " + e.getMessage());
e.printStackTrace();
}
}
protected Team createPartyScoreboardTeam(
Party party, Scoreboard scoreboard, boolean forObservers) {
match
.getLogger()
.fine("Creating team for party " + party + " on scoreboard " + toString(scoreboard));
Team team = scoreboard.registerNewTeam(getScoreboardTeamName(party));
updatePartyScoreboardTeam(party, team, forObservers);
for (MatchPlayer player : party.getPlayers()) {
team.addPlayer(player.getBukkit());
}
return team;
}
public void updateObjectivePrefix(GameObjective objective) {
if (!objective.showOnScoreboard()) return;
if (getSlots() < 16) {
Team team = scoreboard.getTeam(objective.getScoreboardHandler().getNumber() + "-o");
String prefix = objective.getScoreboardHandler().getPrefix(this.team);
team.setPrefix(prefix);
} else {
update();
}
}
private String renderBlitz(Competitor competitor, Party viewingParty) {
BlitzMatchModule bmm = match.needModule(BlitzMatchModule.class);
if (competitor instanceof tc.oc.pgm.teams.Team) {
return ChatColor.WHITE.toString() + bmm.getRemainingPlayers(competitor);
} else if (competitor instanceof Tribute && bmm.getConfig().getNumLives() > 1) {
return ChatColor.WHITE.toString()
+ bmm.getNumOfLives(competitor.getPlayers().iterator().next().getId());
} else {
return "";
}
}
protected void removeGuild(Guild guild) {
if (guild == null || guild.getTag() == null || guild.getTag().isEmpty()) {
return;
}
Team team = this.getUser().getCache().getScoreboard().getTeam(guild.getTag());
if (team != null) {
team.unregister();
}
}
public ImmutableSet<Team> getTeams() {
return ImmutableSet.copyOf(Iterables.transform((Collection<ScorePlayerTeam>) this.board.getTeams(), new Function<ScorePlayerTeam, Team>() {
@Override
public Team apply(ScorePlayerTeam input) {
return new CraftTeam(CraftScoreboard.this, input);
}
}));
}
public UHTeam(String name, String displayName, ChatColor color, UHPlugin plugin) {
this.name = name;
this.displayName = displayName;
this.color = color;
this.plugin = plugin;
Scoreboard sb = this.plugin.getScoreboard();
sb.registerNewTeam(this.name);
Team t = sb.getTeam(this.name);
t.setDisplayName(this.displayName);
t.setCanSeeFriendlyInvisibles(true);
t.setPrefix(this.color+"");
}
public static void cleanTeamInScoreboard(Scoreboard scoreboard) {
try {
scoreboard.getTeams().forEach(Team::unregister);
} catch (Exception e) {
TLogger.getGlobalLogger().error("TagUtils.cleanTeamInScoreboard() 异常: " + e.toString());
}
}
public static void cleanEmptyTeamInScoreboard(Scoreboard scoreboard) {
try {
scoreboard.getTeams().stream().filter(team -> team.getEntries().size() == 0).forEach(Team::unregister);
} catch (Exception e) {
TLogger.getGlobalLogger().error("TagUtils.cleanEmptyTeamInScoreboard() 异常: " + e.toString());
}
}
public static Team getTeamComputeIfAbsent(Scoreboard scoreboard, String teamName) {
Team team = scoreboard.getTeam(teamName);
if (team == null) {
scoreboard.registerNewTeam(teamName);
}
return scoreboard.getTeam(teamName);
}
private void updatePlayer(Player player, String oldName) {
Validate.isTrue(enabled, "NameTagChanger is disabled");
GameProfileWrapper newProfile = gameProfiles.get(player.getUniqueId());
if (newProfile == null) {
newProfile = packetHandler.getDefaultPlayerProfile(player);
}
List<Team> scoreboardTeamsToUpdate = Lists.newArrayList();
sendingPackets = true;
for (Player otherPlayer : Bukkit.getOnlinePlayers()) {
if (otherPlayer.equals(player)) {
if (otherPlayer.getScoreboard().getEntryTeam(player.getName()) != null) {
scoreboardTeamsToUpdate.add(otherPlayer.getScoreboard().getEntryTeam(player.getName()));
}
continue;
}
if (otherPlayer.canSee(player)) {
packetHandler.sendTabListRemovePacket(player, otherPlayer);
packetHandler.sendTabListAddPacket(player, newProfile, otherPlayer);
if (otherPlayer.getWorld().equals(player.getWorld())) {
packetHandler.sendEntityDestroyPacket(player, otherPlayer);
packetHandler.sendNamedEntitySpawnPacket(player, otherPlayer);
packetHandler.sendEntityEquipmentPacket(player, otherPlayer);
}
}
// The player we want to rename is in a scoreboard team.
if (otherPlayer.getScoreboard().getEntryTeam(player.getName()) != null) {
scoreboardTeamsToUpdate.add(otherPlayer.getScoreboard().getEntryTeam(player.getName()));
}
}
if (oldName != null) {
String newName = newProfile.getName();
for (Team team : scoreboardTeamsToUpdate) {
Bukkit.getOnlinePlayers().stream().filter(p -> p.getScoreboard() == team.getScoreboard()).forEach(p -> {
packetHandler.sendScoreboardRemovePacket(oldName, p, team.getName());
packetHandler.sendScoreboardAddPacket(newName, p, team.getName());
});
}
}
sendingPackets = false;
}