Advertisement
Guest User

Untitled

a guest
Jan 21st, 2017
106
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.47 KB | None | 0 0
  1. package server.wenjapvp.hcf.faction.type;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Collections;
  6. import java.util.HashMap;
  7. import java.util.HashSet;
  8. import java.util.Iterator;
  9. import java.util.LinkedHashMap;
  10. import java.util.List;
  11. import java.util.Map;
  12. import java.util.Set;
  13. import java.util.TreeSet;
  14. import java.util.UUID;
  15.  
  16. import javax.annotation.Nullable;
  17.  
  18. import com.doctordark.util.BukkitUtils;
  19. import com.doctordark.util.GenericUtils;
  20. import com.doctordark.util.JavaUtils;
  21. import com.doctordark.util.PersistableLocation;
  22. import com.google.common.base.Predicate;
  23. import org.bukkit.Bukkit;
  24. import org.bukkit.ChatColor;
  25. import org.bukkit.Location;
  26. import org.bukkit.command.CommandSender;
  27. import org.bukkit.entity.Player;
  28.  
  29. import com.google.common.base.Objects;
  30. import com.google.common.base.Preconditions;
  31. import com.google.common.collect.ImmutableMap;
  32. import com.google.common.collect.Maps;
  33. import com.google.common.collect.Sets;
  34.  
  35. import lombok.Getter;
  36. import lombok.Setter;
  37.  
  38. import net.minecraft.util.org.apache.commons.lang3.StringUtils;
  39. import net.minecraft.util.org.apache.commons.lang3.time.DurationFormatUtils;
  40. import server.wenjapvp.hcf.ConfigurationService;
  41. import server.wenjapvp.hcf.HCF;
  42. import server.wenjapvp.hcf.deathban.Deathban;
  43. import server.wenjapvp.hcf.faction.FactionMember;
  44. import server.wenjapvp.hcf.faction.event.*;
  45. import server.wenjapvp.hcf.faction.event.cause.FactionLeaveCause;
  46. import server.wenjapvp.hcf.faction.struct.Raidable;
  47. import server.wenjapvp.hcf.faction.struct.RegenStatus;
  48. import server.wenjapvp.hcf.faction.struct.Relation;
  49. import server.wenjapvp.hcf.faction.struct.Role;
  50. import server.wenjapvp.hcf.faction.type.ClaimableFaction;
  51. import server.wenjapvp.hcf.timer.type.TeleportTimer;
  52. import server.wenjapvp.hcf.user.FactionUser;
  53.  
  54. public class PlayerFaction extends ClaimableFaction implements Raidable {
  55.  
  56. // The UUID is the Faction unique ID.
  57. protected final Map<UUID, Relation> requestedRelations = new HashMap<>();
  58. protected final Map<UUID, Relation> relations = new HashMap<>();
  59.  
  60. protected final Map<UUID, FactionMember> members = new HashMap<>();
  61. protected final Set<String> invitedPlayerNames = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); // we are storing names as offline lookups are slow
  62.  
  63. protected PersistableLocation home;
  64. protected String announcement;
  65. protected boolean open;
  66. protected int balance;
  67. protected int lives;
  68. protected double deathsUntilRaidable = 1.0D;
  69. protected long regenCooldownTimestamp;
  70. @Getter
  71. @Setter
  72. private transient UUID focused;
  73.  
  74. public PlayerFaction(String name) {
  75. super(name);
  76. }
  77.  
  78. public PlayerFaction(Map<String, Object> map) {
  79. super(map);
  80.  
  81. for (Map.Entry<String, FactionMember> entry : GenericUtils.castMap(map.get("members"), String.class, FactionMember.class).entrySet()) {
  82. if (entry.getValue() != null) {
  83. this.members.put(UUID.fromString(entry.getKey()), entry.getValue());
  84. }
  85. }
  86.  
  87. this.invitedPlayerNames.addAll(GenericUtils.createList(map.get("invitedPlayerNames"), String.class));
  88.  
  89. Object object = map.get("home");
  90. if (object != null)
  91. this.home = ((PersistableLocation) object);
  92.  
  93. object = map.get("announcement");
  94. if (object != null)
  95. this.announcement = (String) object;
  96.  
  97. for (Map.Entry<String, String> entry : GenericUtils.castMap(map.get("relations"), String.class, String.class).entrySet()) {
  98. relations.put(UUID.fromString(entry.getKey()), Relation.valueOf(entry.getValue()));
  99. }
  100.  
  101. for (Map.Entry<String, String> entry : GenericUtils.castMap(map.get("requestedRelations"), String.class, String.class).entrySet()) {
  102. requestedRelations.put(UUID.fromString(entry.getKey()), Relation.valueOf(entry.getValue()));
  103. }
  104.  
  105. this.open = (Boolean) map.get("open");
  106. this.balance = (Integer) map.get("balance");
  107. this.lives = (Integer) map.get("lives");
  108. this.deathsUntilRaidable = (Double) map.get("deathsUntilRaidable");
  109. this.regenCooldownTimestamp = Long.parseLong((String) map.get("regenCooldownTimestamp"));
  110. this.lastDtrUpdateTimestamp = Long.parseLong((String) map.get("lastDtrUpdateTimestamp"));
  111. }
  112.  
  113. @Override
  114. public Map<String, Object> serialize() {
  115. Map<String, Object> map = super.serialize();
  116.  
  117. Map<String, String> relationSaveMap = new HashMap<>(relations.size());
  118. for (Map.Entry<UUID, Relation> entry : relations.entrySet()) {
  119. relationSaveMap.put(entry.getKey().toString(), entry.getValue().name());
  120. }
  121. map.put("relations", relationSaveMap);
  122.  
  123. Map<String, String> requestedRelationsSaveMap = new HashMap<>(requestedRelations.size());
  124. for (Map.Entry<UUID, Relation> entry : requestedRelations.entrySet()) {
  125. requestedRelationsSaveMap.put(entry.getKey().toString(), entry.getValue().name());
  126. }
  127. map.put("requestedRelations", requestedRelationsSaveMap);
  128.  
  129. Set<Map.Entry<UUID, FactionMember>> entrySet = this.members.entrySet();
  130. Map<String, FactionMember> saveMap = new LinkedHashMap<>(this.members.size());
  131. for (Map.Entry<UUID, FactionMember> entry : entrySet) {
  132. saveMap.put(entry.getKey().toString(), entry.getValue());
  133. }
  134.  
  135. map.put("members", saveMap);
  136. map.put("invitedPlayerNames", new ArrayList<>(invitedPlayerNames));
  137. if (home != null)
  138. map.put("home", home);
  139. if (announcement != null)
  140. map.put("announcement", announcement);
  141. map.put("open", open);
  142. map.put("balance", balance);
  143. map.put("lives", lives);
  144. map.put("deathsUntilRaidable", deathsUntilRaidable);
  145. map.put("regenCooldownTimestamp", Long.toString(regenCooldownTimestamp));
  146. map.put("lastDtrUpdateTimestamp", Long.toString(lastDtrUpdateTimestamp));
  147.  
  148. return map;
  149. }
  150.  
  151. public boolean addMember(CommandSender sender, @Nullable Player player, UUID playerUUID, FactionMember factionMember) {
  152. if (members.containsKey(playerUUID)) {
  153. return false;
  154. }
  155.  
  156. PlayerJoinFactionEvent eventPre = new PlayerJoinFactionEvent(sender, player, playerUUID, this);
  157. Bukkit.getPluginManager().callEvent(eventPre);
  158. if (eventPre.isCancelled()) {
  159. return false;
  160. }
  161.  
  162. // Set the player as a member before calling the
  163. // event so we can change the scoreboard.
  164. lastDtrUpdateTimestamp = System.currentTimeMillis();
  165. invitedPlayerNames.remove(factionMember.getName());
  166. members.put(playerUUID, factionMember);
  167. Bukkit.getPluginManager().callEvent(new PlayerJoinedFactionEvent(sender, player, playerUUID, this));
  168.  
  169. return true;
  170. }
  171.  
  172. public boolean removeMember(CommandSender sender, @Nullable Player player, UUID playerUUID, boolean kick, boolean force) {
  173. if (!this.members.containsKey(playerUUID)) {
  174. return true;
  175. }
  176.  
  177. // Call pre event.
  178. PlayerLeaveFactionEvent preEvent = new PlayerLeaveFactionEvent(sender, player, playerUUID, this, FactionLeaveCause.LEAVE, kick, false);
  179. Bukkit.getPluginManager().callEvent(preEvent);
  180. if (preEvent.isCancelled()) {
  181. return false;
  182. }
  183.  
  184. this.members.remove(playerUUID);
  185. this.setDeathsUntilRaidable(Math.min(this.deathsUntilRaidable, this.getMaximumDeathsUntilRaidable()));
  186.  
  187. // Call after event.
  188. PlayerLeftFactionEvent event = new PlayerLeftFactionEvent(sender, player, playerUUID, this, FactionLeaveCause.LEAVE, kick, false);
  189. Bukkit.getPluginManager().callEvent(event);
  190.  
  191. return true;
  192. }
  193.  
  194. /**
  195. * Gets a list of faction UUIDs that are allied to this {@link PlayerFaction}.
  196. *
  197. * @return mutable list of UUIDs
  198. */
  199. public Collection<UUID> getAllied() {
  200. return Maps.filterValues(relations, new Predicate<Relation>() {
  201. @Override
  202. public boolean apply(@Nullable Relation relation) {
  203. return relation == Relation.ALLY;
  204. }
  205. }).keySet();
  206. }
  207.  
  208. /**
  209. * Gets a list of {@link PlayerFaction}s that are allied to this {@link PlayerFaction}.
  210. *
  211. * @return mutable list of {@link PlayerFaction}s
  212. */
  213. public List<PlayerFaction> getAlliedFactions() {
  214. Collection<UUID> allied = getAllied();
  215. Iterator<UUID> iterator = allied.iterator();
  216. List<PlayerFaction> results = new ArrayList<>(allied.size());
  217. while (iterator.hasNext()) {
  218. Faction faction = HCF.getPlugin().getFactionManager().getFaction(iterator.next());
  219. if (faction instanceof PlayerFaction) {
  220. results.add((PlayerFaction) faction);
  221. } else
  222. iterator.remove();
  223. }
  224.  
  225. return results;
  226. }
  227.  
  228. public Map<UUID, Relation> getRequestedRelations() {
  229. return requestedRelations;
  230. }
  231.  
  232. public Map<UUID, Relation> getRelations() {
  233. return relations;
  234. }
  235.  
  236. /**
  237. * Gets the members in this {@link PlayerFaction}.
  238. * <p>
  239. * The key is the {@link UUID} of the member
  240. * </p>
  241. * <p>
  242. * The value is the {@link FactionMember}
  243. * </p>
  244. *
  245. * @return map of members.
  246. */
  247. public Map<UUID, FactionMember> getMembers() {
  248. return ImmutableMap.copyOf(members);
  249. }
  250.  
  251. /**
  252. * Gets the online {@link Player}s in this {@link Faction}.
  253. *
  254. * @return set of online {@link Player}s
  255. */
  256. public Set<Player> getOnlinePlayers() {
  257. return getOnlinePlayers(null);
  258. }
  259.  
  260. /**
  261. * Gets the online {@link Player}s in this {@link Faction} that are visible to a {@link CommandSender}.
  262. *
  263. * @param sender
  264. * the {@link CommandSender} to get for
  265. * @return a set of online players visible to sender
  266. */
  267. public Set<Player> getOnlinePlayers(CommandSender sender) {
  268. Set<Map.Entry<UUID, FactionMember>> entrySet = getOnlineMembers(sender).entrySet();
  269. Set<Player> results = new HashSet<>(entrySet.size());
  270. for (Map.Entry<UUID, FactionMember> entry : entrySet) {
  271. results.add(Bukkit.getPlayer(entry.getKey()));
  272. }
  273.  
  274. return results;
  275. }
  276.  
  277. /**
  278. * Gets the online members in this {@link Faction}.
  279. * <p>
  280. * The key is the {@link UUID} of the member
  281. * </p>
  282. * <p>
  283. * The value is the {@link FactionMember}
  284. * </p>
  285. *
  286. * @return an immutable set of online members
  287. */
  288. public Map<UUID, FactionMember> getOnlineMembers() {
  289. return getOnlineMembers(null);
  290. }
  291.  
  292. /**
  293. * Gets the online members in this {@link Faction} that are visible to a {@link CommandSender}.
  294. * <p>
  295. * The key is the {@link UUID} of the member
  296. * </p>
  297. * <p>
  298. * The value is the {@link FactionMember}
  299. * </p>
  300. *
  301. * @param sender
  302. * the {@link CommandSender} to get for
  303. * @return a set of online members visible to sender
  304. */
  305. public Map<UUID, FactionMember> getOnlineMembers(CommandSender sender) {
  306. Player senderPlayer = sender instanceof Player ? ((Player) sender) : null;
  307. Map<UUID, FactionMember> results = new HashMap<>();
  308. for (Map.Entry<UUID, FactionMember> entry : members.entrySet()) {
  309. Player target = Bukkit.getPlayer(entry.getKey());
  310. if (target == null || (senderPlayer != null && !senderPlayer.canSee(target))) {
  311. continue;
  312. }
  313.  
  314. results.put(entry.getKey(), entry.getValue());
  315. }
  316.  
  317. return results;
  318. }
  319.  
  320. /**
  321. * Gets the leading {@link FactionMember} of this {@link Faction}.
  322. *
  323. * @return the leading {@link FactionMember}
  324. */
  325. public FactionMember getLeader() {
  326. Map<UUID, FactionMember> members = this.members;
  327. for (Map.Entry<UUID, FactionMember> entry : members.entrySet()) {
  328. if (entry.getValue().getRole() == Role.LEADER) {
  329. return entry.getValue();
  330. }
  331. }
  332.  
  333. return null;
  334. }
  335.  
  336. /**
  337. * Gets the {@link FactionMember} with a specific name.
  338. *
  339. * @param memberName
  340. * the id to search for
  341. * @return the {@link FactionMember} or null if is not a member
  342. * @deprecated uses hanging offline player method
  343. */
  344. @Deprecated
  345. public FactionMember getMember(String memberName) {
  346. UUID uuid = Bukkit.getOfflinePlayer(memberName).getUniqueId(); // TODO: breaking
  347. return uuid == null ? null : members.get(uuid);
  348. }
  349.  
  350. /**
  351. * Gets the {@link FactionMember} of a {@link Player}.
  352. *
  353. * @param player
  354. * the {@link Player} to get for
  355. * @return the {@link FactionMember} or null if is not a member
  356. */
  357. public FactionMember getMember(Player player) {
  358. return this.getMember(player.getUniqueId());
  359. }
  360.  
  361. /**
  362. * Gets the {@link FactionMember} with a specific {@link UUID}.
  363. *
  364. * @param memberUUID
  365. * the {@link UUID} to get for
  366. * @return the {@link FactionMember} or null if is not a member
  367. */
  368. public FactionMember getMember(UUID memberUUID) {
  369. return members.get(memberUUID);
  370. }
  371.  
  372. /**
  373. * Gets the names of the players that have been invited to join this {@link PlayerFaction}.
  374. *
  375. * @return set of invited player names
  376. */
  377. public Set<String> getInvitedPlayerNames() {
  378. return invitedPlayerNames;
  379. }
  380.  
  381. public Location getHome() {
  382. return home == null ? null : home.getLocation();
  383. }
  384.  
  385. public void setHome(@Nullable Location home) {
  386. if (home == null && this.home != null) {
  387. TeleportTimer timer = HCF.getPlugin().getTimerManager().getTeleportTimer();
  388. for (Player player : getOnlinePlayers()) {
  389. Location destination = timer.getDestination(player);
  390. if (Objects.equal(destination, this.home.getLocation())) {
  391. timer.clearCooldown(player);
  392. player.sendMessage(ChatColor.RED + "Your faction home was unset, so your " + timer.getDisplayName() + ChatColor.RED + " timer has been cancelled");
  393. }
  394. }
  395. }
  396.  
  397. this.home = home == null ? null : new PersistableLocation(home);
  398. }
  399.  
  400. public String getAnnouncement() {
  401. return announcement;
  402. }
  403.  
  404. public void setAnnouncement(@Nullable String announcement) {
  405. this.announcement = announcement;
  406. }
  407.  
  408. public boolean isOpen() {
  409. return open;
  410. }
  411.  
  412. public void setOpen(boolean open) {
  413. this.open = open;
  414. }
  415.  
  416. public int getBalance() {
  417. return balance;
  418. }
  419.  
  420. public void setBalance(int balance) {
  421. this.balance = balance;
  422. }
  423.  
  424. public int getLives() {
  425. return lives;
  426. }
  427.  
  428. public void setLives(int lives) {
  429. this.lives = lives;
  430. }
  431.  
  432. @Override
  433. public boolean isRaidable() {
  434. return deathsUntilRaidable <= 0;
  435. }
  436.  
  437. @Override
  438. public double getDeathsUntilRaidable() {
  439. return this.getDeathsUntilRaidable(true);
  440. }
  441.  
  442. @Override
  443. public double getMaximumDeathsUntilRaidable() {
  444. if (members.size() == 1) {
  445. return 1.1;
  446. }
  447. if (members.size() == 2){
  448. return 2.1;
  449. }
  450.  
  451. return Math.min(ConfigurationService.MAXIMUM_DTR, members.size() * 0.9);
  452. }
  453.  
  454. public double getDeathsUntilRaidable(boolean updateLastCheck) {
  455. if (updateLastCheck)
  456. this.updateDeathsUntilRaidable();
  457. return deathsUntilRaidable;
  458. }
  459.  
  460. public ChatColor getDtrColour() {
  461. this.updateDeathsUntilRaidable();
  462. if (deathsUntilRaidable < 0) {
  463. return ChatColor.RED;
  464. } else if (deathsUntilRaidable < 1) {
  465. return ChatColor.YELLOW;
  466. } else {
  467. return ChatColor.GREEN;
  468. }
  469. }
  470.  
  471. @Getter
  472. private long lastDtrUpdateTimestamp;
  473.  
  474. /**
  475. * Updates the deaths until raidable value depending how much is gained every x seconds as set in configuration.
  476. */
  477. private void updateDeathsUntilRaidable() {
  478. if (this.getRegenStatus() == RegenStatus.REGENERATING) {
  479. long now = System.currentTimeMillis();
  480. long millisPassed = now - this.lastDtrUpdateTimestamp;
  481. if (millisPassed >= ConfigurationService.DTR_MILLIS_BETWEEN_UPDATES) {
  482. long remainder = millisPassed % ConfigurationService.DTR_MILLIS_BETWEEN_UPDATES; // the remaining time until the next update
  483. int multiplier = (int) (((double) millisPassed + remainder) / ConfigurationService.DTR_MILLIS_BETWEEN_UPDATES);
  484. double increase = multiplier * ConfigurationService.DTR_INCREMENT_BETWEEN_UPDATES;
  485.  
  486. this.lastDtrUpdateTimestamp = now - remainder;
  487. this.setDeathsUntilRaidable(this.deathsUntilRaidable + increase);
  488. }
  489. }
  490. }
  491.  
  492. @Override
  493. public double setDeathsUntilRaidable(double deathsUntilRaidable) {
  494. return this.setDeathsUntilRaidable(deathsUntilRaidable, true);
  495. }
  496.  
  497. private double setDeathsUntilRaidable(double deathsUntilRaidable, boolean limit) {
  498. deathsUntilRaidable = Math.round(deathsUntilRaidable * 100.0) / 100.0; // remove trailing numbers after decimal
  499. if (limit) {
  500. deathsUntilRaidable = Math.min(deathsUntilRaidable, getMaximumDeathsUntilRaidable());
  501. }
  502.  
  503. // the DTR is the same, don't call an event
  504. if (Math.abs(deathsUntilRaidable - this.deathsUntilRaidable) != 0) {
  505. FactionDtrChangeEvent event = new FactionDtrChangeEvent(FactionDtrChangeEvent.DtrUpdateCause.REGENERATION, this, this.deathsUntilRaidable, deathsUntilRaidable);
  506. Bukkit.getPluginManager().callEvent(event);
  507. if (!event.isCancelled()) {
  508. deathsUntilRaidable = Math.round(event.getNewDtr() * 100.0) / 100.0;
  509. if (deathsUntilRaidable > 0 && this.deathsUntilRaidable <= 0) {
  510. // Inform the server for easier log lookups for 'insiding' etc.
  511. HCF.getPlugin().getLogger().info("Faction " + getName() + " is now raidable.");
  512. }
  513.  
  514. this.lastDtrUpdateTimestamp = System.currentTimeMillis();
  515. return this.deathsUntilRaidable = deathsUntilRaidable;
  516. }
  517. }
  518.  
  519. return this.deathsUntilRaidable;
  520. }
  521.  
  522. protected long getRegenCooldownTimestamp() {
  523. return regenCooldownTimestamp;
  524. }
  525.  
  526. @Override
  527. public long getRemainingRegenerationTime() {
  528. return regenCooldownTimestamp == 0L ? 0L : regenCooldownTimestamp - System.currentTimeMillis();
  529. }
  530.  
  531. @Override
  532. public void setRemainingRegenerationTime(long millis) {
  533. long systemMillis = System.currentTimeMillis();
  534. this.regenCooldownTimestamp = systemMillis + millis;
  535.  
  536. // needs to be multiplied by 2 because as soon as they lose regeneration delay, the timestamp will update
  537. this.lastDtrUpdateTimestamp = systemMillis + (ConfigurationService.DTR_MILLIS_BETWEEN_UPDATES * 2);
  538. }
  539.  
  540. @Override
  541. public RegenStatus getRegenStatus() {
  542. if (getRemainingRegenerationTime() > 0L) {
  543. return RegenStatus.PAUSED;
  544. } else if (getMaximumDeathsUntilRaidable() > this.deathsUntilRaidable) {
  545. return RegenStatus.REGENERATING;
  546. } else {
  547. return RegenStatus.FULL;
  548. }
  549. }
  550.  
  551. public void printDetails(CommandSender sender) {
  552. String leaderName = null;
  553. HashSet allyNames = new HashSet(1);
  554. Iterator combinedKills = this.relations.entrySet().iterator();
  555.  
  556. PlayerFaction playerFaction;
  557. while(combinedKills.hasNext()) {
  558. Map.Entry memberNames = (Map.Entry) combinedKills.next();
  559. Faction captainNames = HCF.getPlugin().getFactionManager().getFaction((UUID) memberNames.getKey());
  560. if(captainNames instanceof PlayerFaction) {
  561. playerFaction = (PlayerFaction) captainNames;
  562. allyNames.add(playerFaction.getDisplayName(sender) + ChatColor.GRAY + '[' + ChatColor.GRAY + playerFaction.getOnlinePlayers(sender).size() + ChatColor.GRAY + '/' + ChatColor.GRAY + playerFaction.members.size() + ChatColor.GRAY + ']');
  563. }
  564. }
  565.  
  566. HashSet memberNames = new HashSet();
  567. HashSet<String> captainNames = new HashSet();
  568. Iterator playerFaction1 = this.members.entrySet().iterator();
  569.  
  570. while(playerFaction1.hasNext()) {
  571. final Map.Entry entry = (Map.Entry) playerFaction1.next();
  572. final FactionMember factionMember = (FactionMember) entry.getValue();
  573. final Player target = factionMember.toOnlinePlayer();
  574. final FactionUser user = HCF.getPlugin().getUserManager().getUser((UUID) entry.getKey());
  575. int kills = user.getKills();
  576. final Deathban deathban = user.getDeathban();
  577. ChatColor colour;
  578. if (deathban != null && deathban.isActive()) {
  579. colour = ChatColor.RED;
  580. }
  581. else if (target == null || (sender instanceof Player && !((Player)sender).canSee(target))) {
  582. colour = ChatColor.GRAY;
  583. }
  584. else {
  585. colour = ChatColor.GREEN;
  586. }
  587. final String memberName = colour + factionMember.getName() + ChatColor.GRAY + '[' + ChatColor.GREEN + kills + ChatColor.GRAY + ']';
  588. switch (factionMember.getRole()) {
  589. case LEADER: {
  590. leaderName = memberName;
  591. continue;
  592. }
  593. case CAPTAIN: {
  594. captainNames.add(memberName);
  595. continue;
  596. }
  597. case MEMBER: {
  598. memberNames.add(memberName);
  599. continue;
  600. }
  601. }
  602. }
  603.  
  604. sender.sendMessage(ChatColor.GRAY + BukkitUtils.STRAIGHT_LINE_DEFAULT);
  605. sender.sendMessage(ChatColor.AQUA + this.getDisplayName(sender)+ ChatColor.GRAY+" ["+this.getOnlineMembers().size()+"/"+this.getMembers().size()+"] "+ ChatColor.GREEN + " - " + ChatColor.YELLOW + "Home: " + ChatColor.WHITE + (this.home == null ? "None" : ChatColor.WHITE.toString() + this.home.getLocation().getBlockX() + " | " + this.home.getLocation().getBlockZ()));
  606.  
  607.  
  608.  
  609. if(!allyNames.isEmpty()) {
  610. sender.sendMessage(ChatColor.YELLOW + "Allies: " + StringUtils.join(allyNames, ChatColor.GRAY + ", "));
  611. }
  612.  
  613. if(leaderName != null) {
  614. sender.sendMessage(ChatColor.YELLOW + "Leader: " + ChatColor.RED + leaderName);
  615. }
  616.  
  617. if(!captainNames.isEmpty()) {
  618. sender.sendMessage(ChatColor.YELLOW + "Captains: " + ChatColor.RED + StringUtils.join(captainNames, ChatColor.GRAY + ", "));
  619. }
  620.  
  621. if(!memberNames.isEmpty()) {
  622. sender.sendMessage(ChatColor.YELLOW + "Members: " + ChatColor.RED + StringUtils.join(memberNames, ChatColor.GRAY + ", "));
  623. }
  624.  
  625. if (sender instanceof Player) {
  626. final Faction playerFaction2 = HCF.getPlugin().getFactionManager().getPlayerFaction((Player)sender);
  627. if (playerFaction2 != null && playerFaction2.equals(this) && this.announcement != null) {
  628. sender.sendMessage(ChatColor.YELLOW + " Announcement: " + ChatColor.GREEN + this.announcement);
  629. }
  630. }
  631.  
  632. sender.sendMessage(ChatColor.YELLOW + "Balance: " + ChatColor.GREEN + '$' + this.balance);
  633.  
  634. if (sender instanceof Player) {
  635. final Faction playerFaction2 = HCF.getPlugin().getFactionManager().getPlayerFaction((Player)sender);
  636. if (playerFaction2 != null && playerFaction2.equals(this)) {
  637. sender.sendMessage(ChatColor.YELLOW + "Lives: " + ChatColor.GREEN + this.lives);;
  638. }
  639. }
  640.  
  641. sender.sendMessage(ChatColor.YELLOW + "Deaths until Raidable: "+ this.getRegenStatus().getSymbol() + this.getDtrColour() + JavaUtils.format(getDeathsUntilRaidable(false)));
  642. long dtrRegenRemaining = this.getRemainingRegenerationTime();
  643. if(dtrRegenRemaining > 0L) {
  644. sender.sendMessage(ChatColor.YELLOW+ "Time until Regen: " + ChatColor.GREEN + DurationFormatUtils.formatDurationWords(dtrRegenRemaining, true, true));
  645. }
  646.  
  647. sender.sendMessage(ChatColor.GRAY + BukkitUtils.STRAIGHT_LINE_DEFAULT);
  648. }
  649.  
  650. private static final UUID[] EMPTY_UUID_ARRAY = {};
  651.  
  652. /**
  653. * Sends a message to all online {@link FactionMember}s.
  654. *
  655. * @param message
  656. * the message to send
  657. */
  658. public void broadcast(String message) {
  659. broadcast(message, EMPTY_UUID_ARRAY);
  660. }
  661.  
  662. /**
  663. * Sends an array of messages to all online {@link FactionMember}s.
  664. *
  665. * @param messages
  666. * the messages to send.
  667. */
  668. public void broadcast(String[] messages) {
  669. broadcast(messages, EMPTY_UUID_ARRAY);
  670. }
  671.  
  672. /**
  673. * Sends a message to all online {@link FactionMember}s ignoring those selected in the var-args.
  674. *
  675. * @param message
  676. * the message to send.
  677. * @param ignore
  678. * the {@link FactionMember} with {@link UUID}s not to send message to
  679. */
  680. public void broadcast(String message, @Nullable UUID... ignore) {
  681. this.broadcast(new String[] { message }, ignore);
  682. }
  683.  
  684. /**
  685. * Sends an array of messages to all online {@link FactionMember}s ignoring those selected in the var-args.
  686. *
  687. * @param messages
  688. * the message to send
  689. * @param ignore
  690. * the {@link FactionMember} with {@link UUID}s not to send message to
  691. */
  692. public void broadcast(String[] messages, UUID... ignore) {
  693. Preconditions.checkNotNull(messages, "Messages cannot be null");
  694. Preconditions.checkArgument(messages.length > 0, "Message array cannot be empty");
  695. Collection<Player> players = getOnlinePlayers();
  696. Collection<UUID> ignores = ignore.length == 0 ? Collections.emptySet() : Sets.newHashSet(ignore);
  697. for (Player player : players) {
  698. if (!ignores.contains(player.getUniqueId())) {
  699. player.sendMessage(messages);
  700. }
  701. }
  702. }
  703. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement