diff --git a/dependency-reduced-pom.xml b/dependency-reduced-pom.xml new file mode 100644 index 0000000..baee9b2 --- /dev/null +++ b/dependency-reduced-pom.xml @@ -0,0 +1,53 @@ + + + 4.0.0 + us.noksdev.practice + kPractice + 1.0-SNAPSHOT + + + + maven-compiler-plugin + + 1.8 + 1.8 + + + + maven-shade-plugin + 2.1 + + + package + + shade + + + + + + + + + org.github.paperspigot + noksiospigot + 1.7.10-R0.1-SNAPSHOT + system + C:\Users\William\Desktop\Vexus Dev Work\kPractice/libs/spigot.jar + + + us.noksdev.permissions + nPermissions + 1.0-SNAPSHOT + system + C:\Users\William\Desktop\Vexus Dev Work\kPractice/libs/nPermissions-1.0-SNAPSHOT.jar + + + org.projectlombok + lombok + 1.14.8 + provided + + + + diff --git a/kPractice.iml b/kPractice.iml new file mode 100644 index 0000000..149654c --- /dev/null +++ b/kPractice.iml @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/kPractice.ipr b/kPractice.ipr new file mode 100644 index 0000000..4175711 --- /dev/null +++ b/kPractice.ipr @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/kPractice.iws b/kPractice.iws new file mode 100644 index 0000000..72d1f2d --- /dev/null +++ b/kPractice.iws @@ -0,0 +1,749 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Entity + � + + + + + + C:\Users\William\Desktop\Vexus Dev Work\kPractice + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + C:\Users\William\AppData\Roaming\Subversion + + + + + 1536512551012 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1.8 + + + + + + + + 1.8 + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/libs/Practice.jar b/libs/Practice.jar new file mode 100644 index 0000000..98eba19 Binary files /dev/null and b/libs/Practice.jar differ diff --git a/libs/break.jar b/libs/break.jar new file mode 100644 index 0000000..f8e5f79 Binary files /dev/null and b/libs/break.jar differ diff --git a/libs/nPermissions-1.0-SNAPSHOT.jar b/libs/nPermissions-1.0-SNAPSHOT.jar new file mode 100644 index 0000000..53f474d Binary files /dev/null and b/libs/nPermissions-1.0-SNAPSHOT.jar differ diff --git a/libs/spigot.jar b/libs/spigot.jar new file mode 100644 index 0000000..920aad1 Binary files /dev/null and b/libs/spigot.jar differ diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..c79cb8d --- /dev/null +++ b/pom.xml @@ -0,0 +1,83 @@ + + + 4.0.0 + + us.noksdev.practice + kPractice + 1.0-SNAPSHOT + + + + + + + org.github.paperspigot + noksiospigot + 1.7.10-R0.1-SNAPSHOT + system + ${project.basedir}/libs/spigot.jar + + + us.noksdev.permissions + nPermissions + 1.0-SNAPSHOT + system + ${project.basedir}/libs/nPermissions-1.0-SNAPSHOT.jar + + + + com.google.code.gson + gson + 2.3.1 + compile + + + + org.projectlombok + lombok + 1.14.8 + provided + + + redis.clients + jedis + 2.8.1 + jar + compile + + + + org.mongodb + mongodb-driver + LATEST + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.8 + 1.8 + + + + org.apache.maven.plugins + maven-shade-plugin + 2.1 + + + package + + shade + + + + + + + \ No newline at end of file diff --git a/src/main/java/us/centile/practice/arena/Arena.java b/src/main/java/us/centile/practice/arena/Arena.java new file mode 100644 index 0000000..f636384 --- /dev/null +++ b/src/main/java/us/centile/practice/arena/Arena.java @@ -0,0 +1,62 @@ +package us.centile.practice.arena; + +import org.bukkit.*; + +public class Arena +{ + private boolean enabled; + private String name; + private Location firstTeamLocation; + private Location secondTeamLocation; + private boolean open; + private transient BlockChangeTracker blockChangeTracker; + + public Arena(final String name, final Location firstTeamLocation, final Location secondTeamLocation) { + this.open = true; + this.blockChangeTracker = new BlockChangeTracker(); + this.enabled = false; + this.name = name; + this.firstTeamLocation = firstTeamLocation; + this.secondTeamLocation = secondTeamLocation; + } + + public boolean isEnabled() { + return this.enabled; + } + + public String getName() { + return this.name; + } + + public Location getFirstTeamLocation() { + return this.firstTeamLocation; + } + + public Location getSecondTeamLocation() { + return this.secondTeamLocation; + } + + public void setEnabled(final boolean enabled) { + this.enabled = enabled; + } + + public void setFirstTeamLocation(final Location firstTeamLocation) { + this.firstTeamLocation = firstTeamLocation; + } + + public void setSecondTeamLocation(final Location secondTeamLocation) { + this.secondTeamLocation = secondTeamLocation; + } + + public boolean isOpen() { + return this.open; + } + + public void setOpen(final boolean open) { + this.open = open; + } + + public BlockChangeTracker getBlockChangeTracker() { + return this.blockChangeTracker; + } +} diff --git a/src/main/java/us/centile/practice/arena/BlockChangeTracker.java b/src/main/java/us/centile/practice/arena/BlockChangeTracker.java new file mode 100644 index 0000000..a23d1dd --- /dev/null +++ b/src/main/java/us/centile/practice/arena/BlockChangeTracker.java @@ -0,0 +1,37 @@ +package us.centile.practice.arena; + +import org.bukkit.block.*; +import java.util.*; +import org.bukkit.*; +import com.google.common.collect.*; + +public class BlockChangeTracker +{ + private LinkedList changeTrackers; + private Set playerPlacedBlocks; + + public BlockChangeTracker() { + this.changeTrackers = Lists.newLinkedList(); + this.playerPlacedBlocks = Sets.newHashSet(); + } + + public void rollback() { + BlockState blockState; + while ((blockState = this.changeTrackers.pollLast()) != null) { + blockState.update(true, false); + } + this.playerPlacedBlocks.clear(); + } + + public void setPlayerPlacedBlock(final Location location) { + this.playerPlacedBlocks.add(location); + } + + public boolean isPlayerPlacedBlock(final Location location) { + return this.playerPlacedBlocks.contains(location); + } + + public void add(final BlockState blockState) { + this.changeTrackers.add(blockState); + } +} diff --git a/src/main/java/us/centile/practice/commands/AcceptCommand.java b/src/main/java/us/centile/practice/commands/AcceptCommand.java new file mode 100644 index 0000000..83846eb --- /dev/null +++ b/src/main/java/us/centile/practice/commands/AcceptCommand.java @@ -0,0 +1,97 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.bukkit.*; +import us.centile.practice.tournament.*; +import us.centile.practice.util.*; +import us.centile.practice.events.*; +import org.bukkit.event.*; +import us.centile.practice.player.*; +import us.centile.practice.duel.*; +import us.centile.practice.kit.*; +import java.util.*; +import us.centile.practice.party.*; + +public class AcceptCommand implements CommandExecutor +{ + private nPractice plugin; + + public AcceptCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) { + if (!(sender instanceof Player)) { + return false; + } + if (args.length != 1) { + return false; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(ChatColor.RED + "Unable to accept a duel within your duel"); + return true; + } + if (Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + } + } + if (!this.plugin.getManagerHandler().getRequestManager().hasDuelRequests(player)) { + player.sendMessage(Messages.NO_REQUESTS_FOUND); + return true; + } + final Player target = this.plugin.getServer().getPlayer(args[0]); + if (target == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + return true; + } + if (!this.plugin.getManagerHandler().getRequestManager().hasDuelRequestFromPlayer(player, target)) { + player.sendMessage(Messages.NO_REQUESTS_FOUND); + return true; + } + final PracticePlayer practiceTarget = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(target); + if (practiceTarget.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(Messages.PLAYER_BUSY); + return true; + } + final DuelRequest request = this.plugin.getManagerHandler().getRequestManager().getDuelRequest(player, target); + if (request == null) { + player.sendMessage(Messages.NO_REQUESTS_FOUND); + return true; + } + this.plugin.getManagerHandler().getRequestManager().removeDuelRequest(player, target); + player.sendMessage(ChatColor.YELLOW + "Accepted duel request from " + ChatColor.GREEN + target.getName()); + final String kitName = request.getKitName(); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + final List firstTeam = new ArrayList(); + final List secondTeam = new ArrayList(); + firstTeam.add(player.getUniqueId()); + secondTeam.add(target.getUniqueId()); + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + final Party targetParty = this.plugin.getManagerHandler().getPartyManager().getParty(target.getUniqueId()); + if (party != null && targetParty != null) { + for (final UUID member : party.getMembers()) { + firstTeam.add(member); + } + for (final UUID member : targetParty.getMembers()) { + secondTeam.add(member); + } + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, false, party.getLeader(), targetParty.getLeader(), firstTeam, secondTeam, false)); + } + else { + if ((party != null && targetParty == null) || (targetParty != null && party == null)) { + player.sendMessage(ChatColor.RED + "Either you or the target player is in a party"); + return true; + } + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, false, null, null, firstTeam, secondTeam, false)); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/ArenaCommand.java b/src/main/java/us/centile/practice/commands/ArenaCommand.java new file mode 100644 index 0000000..264a2fc --- /dev/null +++ b/src/main/java/us/centile/practice/commands/ArenaCommand.java @@ -0,0 +1,92 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import net.md_5.bungee.api.*; +import us.centile.practice.util.*; +import us.centile.practice.arena.*; + +public class ArenaCommand implements CommandExecutor +{ + private nPractice plugin; + + public ArenaCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] commandArgs) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + if (commandArgs.length == 0) { + player.sendMessage(ChatColor.RED + "Incorrect usage"); + return true; + } + if (!player.hasPermission("practice.commands.arena")) { + player.sendMessage(Messages.NO_PERMISSION); + return true; + } + if (commandArgs[0].equalsIgnoreCase("create")) { + if (commandArgs.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /arena create "); + return true; + } + final String arenaName = commandArgs[1]; + if (this.plugin.getManagerHandler().getArenaManager().getArena(arenaName) != null) { + player.sendMessage(ChatColor.RED + "This arena already exists!"); + return true; + } + this.plugin.getManagerHandler().getArenaManager().createArena(arenaName); + player.sendMessage(ChatColor.YELLOW + "Successfully created the arena " + ChatColor.GREEN + arenaName + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("setfirstteamlocation")) { + if (commandArgs.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /arena setfirstteamlocation "); + return true; + } + final String arenaName = commandArgs[1]; + final Arena arena = this.plugin.getManagerHandler().getArenaManager().getArena(arenaName); + arena.setFirstTeamLocation(player.getLocation()); + player.sendMessage(ChatColor.YELLOW + "Successfully set the first team's location in arena " + ChatColor.GREEN + arenaName + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("setsecondteamlocation")) { + if (commandArgs.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /arena setsecondteamlocation "); + return true; + } + final String arenaName = commandArgs[1]; + final Arena arena = this.plugin.getManagerHandler().getArenaManager().getArena(arenaName); + arena.setSecondTeamLocation(player.getLocation()); + player.sendMessage(ChatColor.YELLOW + "Successfully set the second team's location in arena " + ChatColor.GREEN + arenaName + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("enable") || commandArgs[1].equalsIgnoreCase("disable")) { + if (commandArgs.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /arena enable "); + return true; + } + final String arenaName = commandArgs[1]; + final Arena arena = this.plugin.getManagerHandler().getArenaManager().getArena(arenaName); + arena.setEnabled(!arena.isEnabled()); + player.sendMessage(ChatColor.YELLOW + "Arena " + ChatColor.GREEN + arenaName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (arena.isEnabled() ? "enabled" : "disabled") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("remove")) { + if (commandArgs.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /arena remove "); + return true; + } + final String arenaName = commandArgs[1]; + if (this.plugin.getManagerHandler().getArenaManager().getArena(arenaName) == null) { + player.sendMessage(ChatColor.RED + "This arena does not exist!"); + return true; + } + this.plugin.getManagerHandler().getArenaManager().destroyArena(arenaName); + player.sendMessage(ChatColor.YELLOW + "Arena " + ChatColor.GREEN + arenaName + ChatColor.YELLOW + " has been removed!"); + } + else { + player.sendMessage(ChatColor.RED + "Incorrect usage"); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/BuilderCommand.java b/src/main/java/us/centile/practice/commands/BuilderCommand.java new file mode 100644 index 0000000..356de4d --- /dev/null +++ b/src/main/java/us/centile/practice/commands/BuilderCommand.java @@ -0,0 +1,42 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import org.bukkit.*; +import us.centile.practice.player.*; + +public class BuilderCommand implements CommandExecutor +{ + private nPractice plugin; + + public BuilderCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return false; + } + final Player player = (Player)sender; + if (!player.hasPermission("practice.commands.builder")) { + player.sendMessage(Messages.NO_PERMISSION); + return true; + } + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() == PlayerState.BUILDER) { + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + player.sendMessage(ChatColor.RED + "Builder mode has been deactivated"); + return true; + } + if (practicePlayer.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + practicePlayer.setCurrentState(PlayerState.BUILDER); + player.setGameMode(GameMode.CREATIVE); + player.sendMessage(ChatColor.GREEN + "Builder mode has been activated"); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/CreditsCommand.java b/src/main/java/us/centile/practice/commands/CreditsCommand.java new file mode 100644 index 0000000..a2abc38 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/CreditsCommand.java @@ -0,0 +1,68 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import us.centile.practice.player.*; +import org.bukkit.*; +import org.bukkit.plugin.*; +import org.bukkit.entity.*; +import java.util.*; + +public class CreditsCommand implements CommandExecutor +{ + private nPractice plugin; + + public CreditsCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!sender.hasPermission("command.credits.admin")) { + return true; + } + if (args.length == 0) { + sender.sendMessage("Incorrect Usage."); + return true; + } + if (args.length == 2) { + String name = ""; + final Player player = Bukkit.getPlayer(args[0]); + UUID uuid; + if (player != null) { + uuid = player.getUniqueId(); + name = player.getName(); + } + else { + try { + final Map.Entry recipient = PracticePlayer.getExternalPlayerInformation(args[0]); + uuid = recipient.getKey(); + name = recipient.getValue(); + } + catch (Exception e) { + sender.sendMessage(ChatColor.RED + "Failed to find player."); + return true; + } + } + final int amount = Integer.parseInt(args[1]); + final PracticePlayer practicePlayer = PracticePlayer.getByUuid(uuid); + if (practicePlayer == null) { + return true; + } + Bukkit.getScheduler().runTaskAsynchronously(this.plugin, new Runnable() { + @Override + public void run() { + practicePlayer.setCredits(practicePlayer.getCredits() + amount); + practicePlayer.save(); + } + }); + if (Bukkit.getPlayer(uuid) != null && Bukkit.getPlayer(uuid).isOnline()) { + Bukkit.getPlayer(uuid).sendMessage(ChatColor.GREEN + "You have received (" + amount + ") ELO Reset Credit(s)."); + } + sender.sendMessage(ChatColor.YELLOW + "Given " + ChatColor.GREEN + amount + ChatColor.YELLOW + " credit(s) to " + ChatColor.GREEN + name + ChatColor.YELLOW + "."); + } + else { + sender.sendMessage(ChatColor.RED + "Incorrect Usage."); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/DuelCommand.java b/src/main/java/us/centile/practice/commands/DuelCommand.java new file mode 100644 index 0000000..5b68d6a --- /dev/null +++ b/src/main/java/us/centile/practice/commands/DuelCommand.java @@ -0,0 +1,90 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.bukkit.*; +import us.centile.practice.util.*; +import us.centile.practice.tournament.*; +import us.centile.practice.player.*; +import us.centile.practice.party.*; +import java.util.*; + +public class DuelCommand implements CommandExecutor +{ + private nPractice plugin; + + public DuelCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + if (args.length != 1) { + player.sendMessage(ChatColor.RED + "Usage: /duel "); + return true; + } + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return false; + } + if (Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + } + } + final Player target = this.plugin.getServer().getPlayer(args[0]); + if (target == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + return true; + } + if (target.getName().equals(player.getName())) { + player.sendMessage(Messages.CANNOT_DUEL_YOURSELF); + return true; + } + final PracticePlayer practiceTarget = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(target); + if (practiceTarget.getCurrentState() != PlayerState.LOBBY || !practiceTarget.getSettings().isDuelRequests()) { + player.sendMessage(Messages.PLAYER_BUSY); + return true; + } + if (this.plugin.getManagerHandler().getRequestManager().hasDuelRequests(target) && this.plugin.getManagerHandler().getRequestManager().hasDuelRequestFromPlayer(target, player)) { + player.sendMessage(Messages.WAIT_SENDING_DUEL); + return true; + } + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + final Party targetParty = this.plugin.getManagerHandler().getPartyManager().getParty(target.getUniqueId()); + if (party != null) { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + return true; + } + if (targetParty == null) { + player.sendMessage(ChatColor.RED + "This player is not in a party!"); + return true; + } + if (!targetParty.getLeader().equals(target.getUniqueId())) { + player.sendMessage(ChatColor.RED + "This player is not the leader of that party!"); + return true; + } + if (targetParty.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "This party is currently busy"); + return true; + } + } + else if (targetParty != null) { + player.sendMessage(ChatColor.RED + "This player is in a party!"); + return true; + } + final UUID uuid = player.getUniqueId(); + this.plugin.getManagerHandler().getInventoryManager().setSelectingDuel(uuid, target.getUniqueId()); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getRequestInventory()); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/HostCommand.java b/src/main/java/us/centile/practice/commands/HostCommand.java new file mode 100644 index 0000000..a5123a6 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/HostCommand.java @@ -0,0 +1,97 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import java.text.*; +import java.util.*; +import us.centile.practice.tournament.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.bukkit.*; +import org.apache.commons.lang.*; +import us.centile.practice.player.*; +import us.centile.practice.kit.*; +import us.centile.practice.util.*; + +public class HostCommand implements CommandExecutor +{ + private nPractice plugin; + private DecimalFormat SECONDS_FORMATTER; + private static HashMap runningTournaments; + + public HostCommand(final nPractice plugin) { + this.plugin = plugin; + this.SECONDS_FORMATTER = new DecimalFormat("#0.0"); + HostCommand.runningTournaments = new HashMap(); + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY && practicePlayer.getCurrentState() != PlayerState.SPECTATING) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + if (!player.hasPermission("practice.commands.host")) { + sender.sendMessage(ChatColor.RED + "You don't have permission to do this!"); + return true; + } + if (args.length == 0) { + player.sendMessage(ChatColor.RED + "Usage: /host start "); + player.sendMessage(ChatColor.RED + "Usage: /host list"); + return true; + } + if (args[0].toLowerCase().equalsIgnoreCase("start")) { + final String kitName = args[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist."); + return true; + } + if (HostCommand.runningTournaments.containsKey(player.getUniqueId())) { + sender.sendMessage(ChatColor.RED + "You are already running a tournament."); + return true; + } + if (practicePlayer.getHostCooldown() != 0L && practicePlayer.getHostCooldown() > System.currentTimeMillis()) { + final String timeLeft = this.getTimeLeft(practicePlayer); + sender.sendMessage(ChatColor.RED + "You must wait " + timeLeft + " to start another tournament."); + return true; + } + if (Tournament.getTournaments().size() >= 1) { + sender.sendMessage(ChatColor.RED + "There is a tournament currently running."); + return true; + } + this.plugin.getManagerHandler().getInventoryManager().setTournamentInventory(kit, true); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getTournamentInventory()); + } + else if (args[0].toLowerCase().equalsIgnoreCase("active") || args[0].toLowerCase().equalsIgnoreCase("list")) { + if (!HostCommand.runningTournaments.containsKey(player.getUniqueId())) { + sender.sendMessage(ChatColor.RED + "You are not running a tournament."); + return true; + } + final Tournament tournament = HostCommand.runningTournaments.get(player.getUniqueId()); + if (tournament != null) { + player.sendMessage(ChatColor.AQUA + "(*) Tournament (" + tournament.getMaximumPerTeam() + "v" + tournament.getMaximumPerTeam() + ")"); + player.sendMessage(ChatColor.GRAY + "-> Kit: " + tournament.getDefaultKit().getName()); + player.sendMessage(ChatColor.GRAY + "-> Stage: " + ((tournament.getTournamentStage() == null) ? "Waiting for players" : StringUtils.capitalize(tournament.getTournamentStage().name().replace("_", " ")))); + player.sendMessage(ChatColor.GRAY + "-> Current Matches: " + tournament.getCurrentMatches().size()); + player.sendMessage(ChatColor.GRAY + "-> Total Teams: " + tournament.getTeams().size()); + player.sendMessage(ChatColor.GRAY + "-> Players Limit: " + tournament.getPlayersLimit()); + } + } + return true; + } + + private String getTimeLeft(final PracticePlayer player) { + if (player.getHostCooldown() - System.currentTimeMillis() >= 60000L) { + return DateUtil.readableTime(player.getHostCooldown() - System.currentTimeMillis()).trim(); + } + return this.SECONDS_FORMATTER.format((player.getHostCooldown() - System.currentTimeMillis()) / 1000.0f); + } + + public static HashMap getRunningTournaments() { + return HostCommand.runningTournaments; + } +} diff --git a/src/main/java/us/centile/practice/commands/InventoryCommand.java b/src/main/java/us/centile/practice/commands/InventoryCommand.java new file mode 100644 index 0000000..c94d2ec --- /dev/null +++ b/src/main/java/us/centile/practice/commands/InventoryCommand.java @@ -0,0 +1,39 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import java.util.*; +import us.centile.practice.player.*; + +public class InventoryCommand implements CommandExecutor +{ + private nPractice plugin; + + public InventoryCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return false; + } + if (args.length != 1) { + return false; + } + final Player player = (Player)sender; + if (!args[0].matches(nPractice.UUID_PATTER.pattern())) { + player.sendMessage(Messages.CANNOT_FIND_SNAPSHOT); + return true; + } + final UUID invUUID = UUID.fromString(args[0]); + final PlayerInventorySnapshot playerInventorySnapshot = this.plugin.getManagerHandler().getInventorySnapshotManager().getSnapshotFromUUID(invUUID); + if (playerInventorySnapshot == null) { + player.sendMessage(Messages.CANNOT_FIND_SNAPSHOT); + return true; + } + player.openInventory(playerInventorySnapshot.getInventory()); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/JoinCommand.java b/src/main/java/us/centile/practice/commands/JoinCommand.java new file mode 100644 index 0000000..e15ea18 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/JoinCommand.java @@ -0,0 +1,109 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import org.bukkit.*; +import us.centile.practice.tournament.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.plugin.*; +import us.centile.practice.player.*; +import java.util.*; +import us.centile.practice.party.*; + +public class JoinCommand implements CommandExecutor +{ + private nPractice plugin; + + public JoinCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY && practicePlayer.getCurrentState() != PlayerState.SPECTATING) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + if (Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(ChatColor.RED + "You are already in a tournament."); + return true; + } + } + } + if (args.length == 0) { + if (Tournament.getTournaments().size() == 0) { + player.sendMessage(ChatColor.RED + "There are no tournaments available."); + return true; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getJoinTournamentInventory()); + } + else if (args.length == 1) { + if (Tournament.getTournaments().size() == 0) { + player.sendMessage(ChatColor.RED + "There are no tournaments available."); + return true; + } + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(ChatColor.RED + "You are currently in another tournament."); + return true; + } + } + final int id = Integer.parseInt(args[0]); + Tournament tournament = Tournament.getTournaments().get(id - 1); + if (tournament == null) { + player.sendMessage(ChatColor.RED + "That tournament id doesn't exist."); + return true; + } + if (tournament.isStarted()) { + player.sendMessage(ChatColor.RED + "Sorry! The tournament already started."); + return true; + } + if (tournament.getTotalPlayersInTournament() == tournament.getPlayersLimit()) { + player.sendMessage(ChatColor.RED + "Sorry! The tournament is already full."); + return true; + } + if (tournament.isInTournament(player)) { + player.sendMessage(ChatColor.RED + "You are already in the tournament."); + return true; + } + if (tournament.getMaximumPerTeam() == 1) { + final TournamentTeam tournamentTeam = new TournamentTeam(); + tournamentTeam.setPlayers(Collections.singletonList(player.getUniqueId())); + tournament.getTeams().add(tournamentTeam); + tournament.sendMessage(ChatColor.YELLOW + player.getName() + " has joined the tournament. (" + tournament.getTotalPlayersInTournament() + "/" + tournament.getPlayersLimit() + ")"); + } + else if (tournament.getMaximumPerTeam() >= 2) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You must be in a party to join this tournament."); + return true; + } + if (party.getLeader() != player.getUniqueId()) { + player.sendMessage(ChatColor.RED + "Only the leader can join the tournament."); + return true; + } + if (party.getSize() != tournament.getMaximumPerTeam()) { + player.sendMessage(ChatColor.RED + "The party must have only " + tournament.getMaximumPerTeam() + " players."); + return true; + } + final TournamentTeam tournamentTeam2 = new TournamentTeam(); + tournamentTeam2.setPlayers(party.getAllMembersOnline()); + tournament.getTeams().add(tournamentTeam2); + tournament.sendMessage(ChatColor.YELLOW + player.getName() + "'s Party has joined the tournament. (" + tournament.getTotalPlayersInTournament() + "/" + tournament.getPlayersLimit() + ")"); + this.plugin.getServer().getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.TOURNAMENT)); + } + } + else { + player.sendMessage(ChatColor.RED + "Usage: /join"); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/KitCommand.java b/src/main/java/us/centile/practice/commands/KitCommand.java new file mode 100644 index 0000000..c2d2ad5 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/KitCommand.java @@ -0,0 +1,203 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.*; +import org.bukkit.entity.*; +import us.centile.practice.kit.*; + +public class KitCommand implements CommandExecutor +{ + private nPractice plugin; + + public KitCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] commandArgs) { + if (commandArgs.length == 0) { + sender.sendMessage(ChatColor.RED + "Incorrect usage"); + return true; + } + if (!(sender instanceof Player)) { + sender.sendMessage(ChatColor.RED + "Sorry, only players can execute this command!"); + return true; + } + final Player player = (Player)sender; + if (!player.hasPermission("practice.commands.kit")) { + sender.sendMessage(ChatColor.RED + "You don't have permission to do this!"); + return true; + } + if (commandArgs[0].equalsIgnoreCase("create")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit create "); + return true; + } + final String kitName = commandArgs[1]; + if (this.plugin.getManagerHandler().getKitManager().getKit(kitName) != null) { + sender.sendMessage(ChatColor.RED + "This kit already exists!"); + return true; + } + this.plugin.getManagerHandler().getKitManager().createKit(kitName); + player.sendMessage(ChatColor.YELLOW + "Successfully created a kit with the name " + ChatColor.GREEN + kitName + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("combo")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit combo "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setCombo(!kit.isCombo()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (kit.isCombo() ? "combo mode" : "not combo mode") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("ranked")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit ranked "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setRanked(!kit.isRanked()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (kit.isRanked() ? "ranked mode" : "not ranked mode") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("premium")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit premium "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setPremium(!kit.isPremium()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (kit.isPremium() ? "premium mode" : "non premium mode") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("editable")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit editable "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setEditable(!kit.isEditable()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (kit.isEditable() ? "editable" : "not editable") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("builduhc")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit builduhc "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setBuilduhc(!kit.isBuilduhc()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (kit.isBuilduhc() ? "builduhc mode" : "not builduhcmode") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("enable")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit enable "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setEnabled(!kit.isEnabled()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " is now " + ChatColor.GREEN + (kit.isEnabled() ? "enabled" : "disabled") + ChatColor.YELLOW + "!"); + } + else if (commandArgs[0].equalsIgnoreCase("setinventory")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit setinventory "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setMainContents(player.getInventory().getContents()); + kit.setArmorContents(player.getInventory().getArmorContents()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " now has your inventory setup!"); + } + else if (commandArgs[0].equalsIgnoreCase("retrieve")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit retrieve "); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + player.getInventory().setContents(kit.getMainContents()); + player.getInventory().setArmorContents(kit.getArmorContents()); + player.updateInventory(); + player.sendMessage(ChatColor.YELLOW + "You have retrieved kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + "'s inventory setup!"); + } + else if (commandArgs[0].equalsIgnoreCase("seticon")) { + if (commandArgs.length != 2) { + sender.sendMessage(ChatColor.RED + "Usage: /kit seticon "); + return true; + } + if (player.getItemInHand() == null) { + sender.sendMessage(ChatColor.RED + "You need something in your hand!"); + return true; + } + final String kitName = commandArgs[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist!"); + return true; + } + kit.setIcon(player.getItemInHand()); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " now has an icon as the item in your hand!"); + } + else { + if (!commandArgs[0].equalsIgnoreCase("remove")) { + player.sendMessage(ChatColor.RED + "Incorrect usage"); + return true; + } + if (commandArgs.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /kit remove "); + return true; + } + final String kitName = commandArgs[1]; + if (this.plugin.getManagerHandler().getKitManager().getKit(kitName) == null) { + player.sendMessage(ChatColor.RED + "This kit does not exist!"); + return true; + } + this.plugin.getManagerHandler().getKitManager().destroyKit(kitName); + player.sendMessage(ChatColor.YELLOW + "Kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + " has been removed!"); + } + this.plugin.getManagerHandler().getInventoryManager().setUnrankedInventory(); + this.plugin.getManagerHandler().getInventoryManager().setRankedInventory(); + this.plugin.getManagerHandler().getInventoryManager().setPremiumInventory(); + this.plugin.getManagerHandler().getInventoryManager().setEditorInventory(); + this.plugin.getManagerHandler().getInventoryManager().setRequestInventory(); + this.plugin.getManagerHandler().getInventoryManager().setSplitFightInventory(); + this.plugin.getManagerHandler().getInventoryManager().setFfaPartyInventory(); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/LeaveCommand.java b/src/main/java/us/centile/practice/commands/LeaveCommand.java new file mode 100644 index 0000000..1bc8e78 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/LeaveCommand.java @@ -0,0 +1,63 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import org.bukkit.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.plugin.*; +import us.centile.practice.player.*; +import us.centile.practice.tournament.*; + +public class LeaveCommand implements CommandExecutor +{ + private nPractice plugin; + + public LeaveCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY && practicePlayer.getCurrentState() != PlayerState.SPECTATING) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + if (args.length == 0) { + if (Tournament.getTournaments().size() == 0) { + player.sendMessage(ChatColor.RED + "There are no tournaments available."); + return true; + } + final Tournament tournament = Tournament.getTournaments().get(0); + if (tournament.getTotalPlayersInTournament() == tournament.getPlayersLimit()) { + player.sendMessage(ChatColor.RED + "Sorry! The tournament is already full."); + return true; + } + if (!tournament.isInTournament(player)) { + player.sendMessage(ChatColor.RED + "You are not in any tournament."); + return true; + } + final TournamentTeam tournamentTeam = tournament.getTournamentTeam(player); + if (tournamentTeam == null) { + player.sendMessage(ChatColor.RED + "You are not in any tournament."); + return true; + } + if (tournament.getTournamentMatch(player) != null) { + player.sendMessage(ChatColor.RED + "You can't leave during a match."); + return true; + } + final String reason = (tournamentTeam.getPlayers().size() > 1) ? "Someone in your party left the tournament" : "You left the tournament"; + tournamentTeam.sendMessage(ChatColor.RED + "You have been removed from the tournament."); + tournamentTeam.sendMessage(ChatColor.RED + "Reason: " + ChatColor.GRAY + reason); + tournament.getCurrentQueue().remove(tournamentTeam); + tournament.getTeams().remove(tournamentTeam); + this.plugin.getServer().getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.TOURNAMENT)); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/MatchesCommand.java b/src/main/java/us/centile/practice/commands/MatchesCommand.java new file mode 100644 index 0000000..beaef86 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/MatchesCommand.java @@ -0,0 +1,68 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import us.centile.practice.player.*; +import org.bukkit.*; +import org.bukkit.plugin.*; +import org.bukkit.entity.*; +import java.util.*; + +public class MatchesCommand implements CommandExecutor +{ + private nPractice plugin; + + public MatchesCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!sender.hasPermission("command.matches.admin")) { + return true; + } + if (args.length == 0) { + sender.sendMessage("Incorrect Usage."); + return true; + } + if (args.length == 2) { + String name = ""; + final Player player = Bukkit.getPlayer(args[0]); + UUID uuid; + if (player != null) { + uuid = player.getUniqueId(); + name = player.getName(); + } + else { + try { + final Map.Entry recipient = PracticePlayer.getExternalPlayerInformation(args[0]); + uuid = recipient.getKey(); + name = recipient.getValue(); + } + catch (Exception e) { + sender.sendMessage(ChatColor.RED + "Failed to find player."); + return true; + } + } + final int amount = Integer.parseInt(args[1]); + final PracticePlayer practicePlayer = PracticePlayer.getByUuid(uuid); + if (practicePlayer == null) { + return true; + } + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new Runnable() { + @Override + public void run() { + practicePlayer.setPremiumTokens(practicePlayer.getPremiumTokens() + amount); + practicePlayer.save(); + } + }); + sender.sendMessage(ChatColor.YELLOW + "Given " + ChatColor.GREEN + amount + ChatColor.YELLOW + " matches to " + ChatColor.GREEN + name + ChatColor.YELLOW + "."); + if (Bukkit.getPlayer(uuid) != null && Bukkit.getPlayer(uuid).isOnline()) { + Bukkit.getPlayer(uuid).sendMessage(ChatColor.YELLOW + "You have received " + amount + " premium matches."); + } + } + else { + sender.sendMessage("Incorrect Usage."); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/PartyCommand.java b/src/main/java/us/centile/practice/commands/PartyCommand.java new file mode 100644 index 0000000..407d216 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/PartyCommand.java @@ -0,0 +1,261 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.tournament.*; +import us.centile.practice.util.*; +import us.centile.practice.player.*; +import java.util.*; +import us.centile.practice.party.*; + +public class PartyCommand implements CommandExecutor +{ + private final String[] HELP_COMMAND; + private nPractice plugin; + + public PartyCommand(final nPractice plugin) { + this.HELP_COMMAND = new String[] { ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------", ChatColor.RED + "Party Commands:", ChatColor.GOLD + "(*) /party help " + ChatColor.GRAY + "- Displays the help menu", ChatColor.GOLD + "(*) /party create " + ChatColor.GRAY + "- Creates a party instance", ChatColor.GOLD + "(*) /party leave " + ChatColor.GRAY + "- Leave your current party", ChatColor.GOLD + "(*) /party info " + ChatColor.GRAY + "- Displays your party information", ChatColor.GOLD + "(*) /party join (player) " + ChatColor.GRAY + "- Join a party (invited or unlocked)", "", ChatColor.RED + "Leader Commands:", ChatColor.GOLD + "(*) /party open " + ChatColor.GRAY + "- Open your party for others to join", ChatColor.GOLD + "(*) /party lock " + ChatColor.GRAY + "- Lock your party for others to join", ChatColor.GOLD + "(*) /party invite (player) " + ChatColor.GRAY + "- Invites a player to your party", ChatColor.GOLD + "(*) /party kick (player) " + ChatColor.GRAY + "- Kicks a player from your party", ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------" }; + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + if (args.length == 0) { + player.sendMessage(this.HELP_COMMAND); + return true; + } + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + if (Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + } + } + if (args[0].equalsIgnoreCase("help")) { + player.sendMessage(this.HELP_COMMAND); + return true; + } + if (args[0].equalsIgnoreCase("create")) { + if (this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()) != null) { + player.sendMessage(ChatColor.RED + "You are already in a party!"); + return true; + } + final Party party = this.plugin.getManagerHandler().getPartyManager().createParty(player.getUniqueId(), player.getName()); + player.sendMessage(ChatColor.YELLOW + "You have created a party!"); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + this.plugin.getManagerHandler().getInventoryManager().addParty(party); + } + else if (args[0].equalsIgnoreCase("info")) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You are not in a party!"); + return true; + } + final Player leader = this.plugin.getServer().getPlayer(party.getLeader()); + final StringJoiner members = new StringJoiner(", "); + for (final UUID memberUUID : party.getMembers()) { + final Player member = this.plugin.getServer().getPlayer(memberUUID); + members.add(member.getName()); + } + final String[] information = { ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------", ChatColor.RED + "Party Information:", ChatColor.GOLD + "Leader: " + ChatColor.GRAY + leader.getName(), ChatColor.GOLD + "Members (" + (party.getMembers().size() + 1) + "): " + ChatColor.GRAY + leader.getName() + ", " + members, ChatColor.GOLD + "Party State: " + ChatColor.GRAY + (party.isOpen() ? "Open" : "Locked"), ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------" }; + player.sendMessage(information); + } + else if (args[0].equalsIgnoreCase("leave")) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You are not in a party!"); + return true; + } + if (party.getLeader().equals(player.getUniqueId())) { + this.plugin.getManagerHandler().getPartyManager().destroyParty(player.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "You have disbanded your party!"); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + for (final UUID member2 : party.getMembers()) { + final Player pLayer = this.plugin.getServer().getPlayer(member2); + pLayer.sendMessage(ChatColor.YELLOW + "The party has been disbanded."); + final PracticePlayer ppLayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(pLayer); + if (ppLayer.getCurrentState() == PlayerState.LOBBY) { + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(pLayer); + } + } + this.plugin.getManagerHandler().getInventoryManager().delParty(party); + } + else { + this.plugin.getManagerHandler().getPartyManager().notifyParty(party, ChatColor.GOLD + "[-] " + ChatColor.GREEN + player.getName() + " has left the party"); + this.plugin.getManagerHandler().getPartyManager().leaveParty(player.getUniqueId()); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + this.plugin.getManagerHandler().getInventoryManager().updateParty(party); + } + } + else if (args[0].equalsIgnoreCase("open")) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You are not in a party!"); + return true; + } + if (party.getLeader().equals(player.getUniqueId())) { + if (party.isOpen()) { + player.sendMessage(ChatColor.RED + "Your party is already open."); + return true; + } + party.setOpen(true); + player.sendMessage(ChatColor.YELLOW + "You have opened your party!"); + } + else { + player.sendMessage(ChatColor.RED + "You are not the leader of the party!"); + } + } + else if (args[0].equalsIgnoreCase("lock")) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You are not in a party!"); + return true; + } + if (party.getLeader().equals(player.getUniqueId())) { + if (!party.isOpen()) { + player.sendMessage(ChatColor.RED + "Your party is already locked."); + return true; + } + party.setOpen(false); + player.sendMessage(ChatColor.YELLOW + "You have locked your party!"); + } + else { + player.sendMessage(ChatColor.RED + "You are not the leader of the party!"); + } + } + else if (args[0].equalsIgnoreCase("join") || args[0].equalsIgnoreCase("accept")) { + if (args.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /party join "); + return true; + } + if (this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()) != null) { + player.sendMessage(ChatColor.RED + "You are already in a party!"); + return true; + } + final Player target = this.plugin.getServer().getPlayer(args[1]); + if (target == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + return true; + } + final Party party2 = this.plugin.getManagerHandler().getPartyManager().getParty(target.getUniqueId()); + if (party2 == null || !party2.getLeader().equals(target.getUniqueId())) { + player.sendMessage(ChatColor.RED + "Party does not exist!"); + return true; + } + if (!party2.isOpen()) { + if (!this.plugin.getManagerHandler().getRequestManager().hasPartyRequests(player)) { + player.sendMessage(Messages.NO_REQUESTS_FOUND); + return true; + } + if (!this.plugin.getManagerHandler().getRequestManager().hasPartyRequestFromPlayer(player, target)) { + player.sendMessage(Messages.NO_REQUESTS_FOUND); + return true; + } + this.plugin.getManagerHandler().getRequestManager().removePartyRequest(player, target); + } + if (party2.getMembers().size() >= 15) { + player.sendMessage(ChatColor.RED + "Party size has reached it's limit"); + return true; + } + this.plugin.getManagerHandler().getPartyManager().joinParty(party2.getLeader(), player.getUniqueId()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party2, ChatColor.GOLD + "[+] " + ChatColor.GREEN + player.getName() + " has joined the party"); + player.sendMessage(ChatColor.YELLOW + "You have joined the party!"); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + this.plugin.getManagerHandler().getInventoryManager().updateParty(party2); + } + else if (args[0].equalsIgnoreCase("kick")) { + if (args.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /party kick "); + return true; + } + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You are not in a party!"); + return true; + } + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + return true; + } + final Player target2 = this.plugin.getServer().getPlayer(args[1]); + if (target2 == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + return true; + } + if (party.getLeader() == target2.getUniqueId()) { + player.sendMessage(ChatColor.RED + "You can't kick the leader!"); + return true; + } + if (!party.getMembers().contains(target2.getUniqueId())) { + player.sendMessage(ChatColor.RED + "This player is not in your party!"); + return true; + } + this.plugin.getManagerHandler().getPartyManager().leaveParty(target2.getUniqueId()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party, ChatColor.GOLD + "[-] " + ChatColor.GREEN + target2.getName() + " has been kicked from the party"); + target2.sendMessage(ChatColor.YELLOW + "You were kicked from the party."); + final PracticePlayer ptarget = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(target2); + if (ptarget.getCurrentState() == PlayerState.LOBBY) { + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(target2); + } + player.sendMessage(ChatColor.GREEN + target2.getName() + ChatColor.YELLOW + " was kicked from your party."); + this.plugin.getManagerHandler().getInventoryManager().updateParty(party); + } + else if (args[0].equalsIgnoreCase("invite")) { + if (args.length != 2) { + player.sendMessage(ChatColor.RED + "Usage: /party invite "); + return true; + } + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.sendMessage(ChatColor.RED + "You are not in a party!"); + return true; + } + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + return true; + } + if (party.isOpen()) { + player.sendMessage(ChatColor.RED + "This party is open, so anyone can join."); + return true; + } + if (party.getMembers().size() >= 15) { + player.sendMessage(ChatColor.RED + "Party size has reached it's limit"); + return true; + } + final Player target2 = this.plugin.getServer().getPlayer(args[1]); + if (target2 == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + return true; + } + if (this.plugin.getManagerHandler().getPartyManager().getParty(target2.getUniqueId()) != null) { + player.sendMessage(ChatColor.RED + "That player is already in a party"); + return true; + } + if (this.plugin.getManagerHandler().getRequestManager().hasPartyRequests(target2) && this.plugin.getManagerHandler().getRequestManager().hasPartyRequestFromPlayer(target2, player)) { + player.sendMessage(ChatColor.RED + "You have already sent a party invitation to this player, please wait!"); + return true; + } + player.sendMessage(ChatColor.YELLOW + "Sent a party request to " + ChatColor.GREEN + target2.getName() + ChatColor.YELLOW + "!"); + this.plugin.getManagerHandler().getRequestManager().addPartyRequest(target2, player); + final UtilActionMessage actionMessage = new UtilActionMessage(); + actionMessage.addText(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has invited you to their party! "); + actionMessage.addText(" " + ChatColor.RED + "[Click here to accept]").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/party join " + player.getName()); + actionMessage.sendToPlayer(target2); + } + else { + player.sendMessage(this.HELP_COMMAND); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/PingCommand.java b/src/main/java/us/centile/practice/commands/PingCommand.java new file mode 100644 index 0000000..5cd6baa --- /dev/null +++ b/src/main/java/us/centile/practice/commands/PingCommand.java @@ -0,0 +1,55 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.apache.commons.lang.*; +import org.bukkit.*; +import org.bukkit.craftbukkit.v1_8_R3.entity.*; + +public class PingCommand implements CommandExecutor +{ + private nPractice plugin; + + public PingCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + Player toCheck; + if (args.length == 0) { + if (!(sender instanceof Player)) { + sender.sendMessage(ChatColor.RED + "Usage: /ping "); + return true; + } + toCheck = (Player)sender; + } + else { + toCheck = Bukkit.getPlayer(StringUtils.join((Object[])args)); + } + if (toCheck == null) { + sender.sendMessage(ChatColor.RED + "No player named '" + StringUtils.join((Object[])args) + "' found online."); + return true; + } + sender.sendMessage(ChatColor.BLUE + toCheck.getName() + (toCheck.getName().endsWith("s") ? "'" : "'s") + ChatColor.GRAY + " current ping is " + ChatColor.WHITE + this.getPing(toCheck) + "ms" + ChatColor.GRAY + "."); + if (sender instanceof Player && !toCheck.getName().equals(sender.getName())) { + final Player senderPlayer = (Player)sender; + sender.sendMessage(ChatColor.GRAY + "Ping difference: " + ChatColor.WHITE + (Math.max(this.getPing(senderPlayer), this.getPing(toCheck)) - Math.min(this.getPing(senderPlayer), this.getPing(toCheck))) + "ms" + ChatColor.GRAY + "."); + } + return true; + } + + private int getPing(final Player player) { + final int ping = ((CraftPlayer)player).getHandle().ping; + if (ping >= 100) { + return ping - 30; + } + if (ping >= 50) { + return ping - 20; + } + if (ping >= 20) { + return ping - 10; + } + return ping; + } +} diff --git a/src/main/java/us/centile/practice/commands/PremiumTokensCommand.java b/src/main/java/us/centile/practice/commands/PremiumTokensCommand.java new file mode 100644 index 0000000..15dde98 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/PremiumTokensCommand.java @@ -0,0 +1,65 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import us.centile.practice.player.*; +import org.bukkit.*; +import org.bukkit.plugin.*; +import org.bukkit.entity.*; +import java.util.*; + +public class PremiumTokensCommand implements CommandExecutor +{ + private nPractice plugin; + + public PremiumTokensCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!sender.hasPermission("command.tokens.admin")) { + return true; + } + if (args.length == 0) { + sender.sendMessage("Incorrect Usage."); + return true; + } + if (args.length == 2) { + String name = ""; + final Player player = Bukkit.getPlayer(args[0]); + UUID uuid; + if (player != null) { + uuid = player.getUniqueId(); + name = player.getName(); + } + else { + try { + final Map.Entry recipient = PracticePlayer.getExternalPlayerInformation(args[0]); + uuid = recipient.getKey(); + name = recipient.getValue(); + } + catch (Exception e) { + sender.sendMessage(ChatColor.RED + "Failed to find player."); + return true; + } + } + final int amount = Integer.parseInt(args[1]); + final PracticePlayer practicePlayer = PracticePlayer.getByUuid(uuid); + if (practicePlayer == null) { + return true; + } + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new Runnable() { + @Override + public void run() { + practicePlayer.setRankPremiumTokens(amount); + practicePlayer.save(); + } + }); + sender.sendMessage(ChatColor.YELLOW + "Set " + ChatColor.GREEN + amount + ChatColor.YELLOW + " tokens to " + ChatColor.GREEN + name + ChatColor.YELLOW + "."); + } + else { + sender.sendMessage(ChatColor.RED + "Incorrect Usage."); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/ResetEloCommand.java b/src/main/java/us/centile/practice/commands/ResetEloCommand.java new file mode 100644 index 0000000..8323929 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/ResetEloCommand.java @@ -0,0 +1,42 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import org.bukkit.*; +import us.centile.practice.kit.*; +import us.centile.practice.player.*; +import java.util.*; + +public class ResetEloCommand implements CommandExecutor +{ + private nPractice plugin; + + public ResetEloCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return false; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + if (practicePlayer.getCredits() <= 0) { + player.sendMessage(ChatColor.RED + "You don't have enough credits."); + return true; + } + practicePlayer.setCredits(practicePlayer.getCredits() - 1); + for (final Kit kit : this.plugin.getManagerHandler().getKitManager().getKitMap().values()) { + practicePlayer.addElo(kit.getName(), 1000); + practicePlayer.addPartyElo(practicePlayer.getUUID(), kit.getName(), 1000); + } + player.sendMessage(ChatColor.GREEN + "Your ELO has been reset."); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/ScoreboardCommand.java b/src/main/java/us/centile/practice/commands/ScoreboardCommand.java new file mode 100644 index 0000000..71640f6 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/ScoreboardCommand.java @@ -0,0 +1,50 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.bukkit.*; +import us.centile.practice.scoreboard.provider.*; +import us.centile.practice.player.*; +import us.centile.practice.scoreboard.*; + +public class ScoreboardCommand implements CommandExecutor +{ + private nPractice plugin; + + public ScoreboardCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return false; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + final boolean toggle = practicePlayer.isScoreboard(); + final PlayerBoard playerBoard = this.plugin.getManagerHandler().getScoreboardHandler().getPlayerBoard(player.getUniqueId()); + if (toggle) { + if (playerBoard != null) { + playerBoard.setSidebarVisible(false); + } + practicePlayer.setScoreboard(false); + } + else { + if (playerBoard != null) { + playerBoard.setSidebarVisible(true); + } + practicePlayer.setScoreboard(true); + } + player.sendMessage(ChatColor.YELLOW + "Your scoreboard has been toggled. " + ChatColor.DARK_GRAY + "(" + (practicePlayer.isScoreboard() ? (ChatColor.GREEN + "true") : (ChatColor.RED + "false")) + ChatColor.DARK_GRAY + ")"); + if (practicePlayer.getCurrentState() == PlayerState.LOBBY || practicePlayer.getCurrentState() == PlayerState.QUEUE) { + if (playerBoard != null) { + playerBoard.setDefaultSidebar(new LobbyScoreboardProvider(this.plugin), 2L); + } + } + else if ((practicePlayer.getCurrentState() == PlayerState.FIGHTING || practicePlayer.getCurrentState() == PlayerState.WAITING) && playerBoard != null) { + playerBoard.setDefaultSidebar(new DuelScoreboardProvider(this.plugin), 2L); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/SetSpawnCommand.java b/src/main/java/us/centile/practice/commands/SetSpawnCommand.java new file mode 100644 index 0000000..a1e21c7 --- /dev/null +++ b/src/main/java/us/centile/practice/commands/SetSpawnCommand.java @@ -0,0 +1,34 @@ +package us.centile.practice.commands; + +import org.bukkit.event.*; +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import org.bukkit.*; + +public class SetSpawnCommand implements CommandExecutor, Listener +{ + private nPractice plugin; + + public SetSpawnCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return false; + } + final Player player = (Player)sender; + if (!player.hasPermission("practice.admin")) { + player.sendMessage(ChatColor.RED + "You don't have enough permissions."); + return true; + } + this.plugin.getConfig().set("spawn", LocationSerializer.serializeLocation(player.getLocation())); + this.plugin.saveConfig(); + this.plugin.reloadConfig(); + this.plugin.setSpawn(player.getLocation()); + player.sendMessage(ChatColor.YELLOW + "Spawn is now set."); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/SortPremiumEloCommand.java b/src/main/java/us/centile/practice/commands/SortPremiumEloCommand.java new file mode 100644 index 0000000..c9b668b --- /dev/null +++ b/src/main/java/us/centile/practice/commands/SortPremiumEloCommand.java @@ -0,0 +1,38 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.scheduler.*; +import us.centile.practice.player.*; +import com.mongodb.*; +import org.bson.conversions.*; +import org.bson.*; +import org.bukkit.*; +import java.util.*; +import org.bukkit.plugin.*; + +public class SortPremiumEloCommand implements CommandExecutor +{ + private nPractice plugin; + + public SortPremiumEloCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) { + new BukkitRunnable() { + public void run() { + final List documents = (List)PracticePlayer.main.getPracticeDatabase().getProfiles().find().limit(10).sort(new BasicDBObject("globalPremiumElo", -1)).into(new ArrayList()); + sender.sendMessage(ChatColor.WHITE + "Listing top premium elos "); + int index = 1; + for (final Document document : documents) { + final UUID uuid = UUID.fromString(document.getString("uuid")); + final String name = Bukkit.getOfflinePlayer(uuid).getName(); + final int premiumElo = document.getInteger("globalPremiumElo"); + sender.sendMessage(ChatColor.AQUA.toString() + index++ + ". " + name + ": " + premiumElo); + } + } + }.runTaskAsynchronously(this.plugin); + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/SpectateCommand.java b/src/main/java/us/centile/practice/commands/SpectateCommand.java new file mode 100644 index 0000000..5783a2c --- /dev/null +++ b/src/main/java/us/centile/practice/commands/SpectateCommand.java @@ -0,0 +1,66 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import us.centile.practice.util.*; +import us.centile.practice.tournament.*; +import org.bukkit.*; +import us.centile.practice.player.*; +import java.util.*; + +public class SpectateCommand implements CommandExecutor +{ + private nPractice plugin; + + public SpectateCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String s, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() != PlayerState.LOBBY && practicePlayer.getCurrentState() != PlayerState.SPECTATING) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + if (Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return true; + } + } + } + if (practicePlayer.getCurrentState() == PlayerState.SPECTATING) { + this.plugin.getManagerHandler().getSpectatorManager().removeSpectator(player, true); + } + if (args.length == 0) { + this.plugin.getManagerHandler().getSpectatorManager().toggleSpectatorMode(player); + player.sendMessage(ChatColor.YELLOW + "You are now in spectator mode."); + } + else if (args.length == 1) { + final Player target = this.plugin.getServer().getPlayer(args[0]); + if (target == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + return true; + } + final PracticePlayer practiceTarget = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(target); + if (practiceTarget.getCurrentState() != PlayerState.FIGHTING) { + player.sendMessage(Messages.REQUESTED_PLAYER_NOT_IN_FIGHT); + return true; + } + if (!this.plugin.getManagerHandler().getSpectatorManager().isSpectatorMode(player)) { + this.plugin.getManagerHandler().getSpectatorManager().toggleSpectatorMode(player); + } + this.plugin.getManagerHandler().getSpectatorManager().addSpectator(player, target); + } + else { + player.sendMessage(ChatColor.RED + "Usage: /spectate (player)"); + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/commands/TournamentCommand.java b/src/main/java/us/centile/practice/commands/TournamentCommand.java new file mode 100644 index 0000000..fb4961f --- /dev/null +++ b/src/main/java/us/centile/practice/commands/TournamentCommand.java @@ -0,0 +1,98 @@ +package us.centile.practice.commands; + +import us.centile.practice.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.bukkit.*; +import us.centile.practice.tournament.*; +import org.apache.commons.lang.*; +import us.centile.practice.kit.*; +import java.util.*; + +public class TournamentCommand implements CommandExecutor +{ + private nPractice plugin; + + public TournamentCommand(final nPractice plugin) { + this.plugin = plugin; + } + + public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) { + if (!(sender instanceof Player)) { + return true; + } + final Player player = (Player)sender; + if (!player.hasPermission("practice.commands.tournament.admin")) { + sender.sendMessage(ChatColor.RED + "You don't have permission to do this!"); + return true; + } + if (args.length == 0) { + player.sendMessage(ChatColor.RED + "Usage: /tournament start "); + player.sendMessage(ChatColor.RED + "Usage: /tournament stop "); + player.sendMessage(ChatColor.RED + "Usage: /tournament forcestart "); + player.sendMessage(ChatColor.RED + "Usage: /tournament active"); + return true; + } + if (args[0].toLowerCase().equalsIgnoreCase("start")) { + final String kitName = args[1]; + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(kitName); + if (kit == null) { + sender.sendMessage(ChatColor.RED + "This kit doesn't exist."); + return true; + } + this.plugin.getManagerHandler().getInventoryManager().setTournamentInventory(kit, false); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getTournamentInventory()); + } + else if (args[0].toLowerCase().equalsIgnoreCase("stop")) { + final int id = Integer.parseInt(args[1]); + if (Tournament.getTournaments().size() > id) { + sender.sendMessage(ChatColor.RED + "Available tournaments to stop:"); + int count = 1; + for (final Tournament tournament : Tournament.getTournaments()) { + sender.sendMessage(ChatColor.RED + "ID: " + count + ChatColor.GRAY + " (" + tournament.getMaximumPerTeam() + "v" + tournament.getMaximumPerTeam() + ")"); + ++count; + } + return true; + } + final Tournament tournament2 = Tournament.getTournaments().get(id - 1); + if (tournament2 == null) { + sender.sendMessage(ChatColor.RED + "That tournament id doesn't exist."); + return true; + } + tournament2.stopTournament(); + } + else if (args[0].toLowerCase().equalsIgnoreCase("forcestart")) { + final int id = Integer.parseInt(args[1]); + if (Tournament.getTournaments().size() > id) { + sender.sendMessage(ChatColor.RED + "Available tournaments to force start:"); + int count = 1; + for (final Tournament tournament : Tournament.getTournaments()) { + sender.sendMessage(ChatColor.RED + "ID: " + count + ChatColor.GRAY + " (" + tournament.getMaximumPerTeam() + "v" + tournament.getMaximumPerTeam() + ")"); + ++count; + } + return true; + } + final Tournament tournament2 = Tournament.getTournaments().get(id - 1); + if (tournament2 == null) { + sender.sendMessage(ChatColor.RED + "That tournament id doesn't exist."); + return true; + } + tournament2.setForceStarted(true); + } + else if (args[0].toLowerCase().equalsIgnoreCase("active") || args[0].toLowerCase().equalsIgnoreCase("list")) { + if (Tournament.getTournaments().size() == 0) { + player.sendMessage(ChatColor.RED + "There are no tournaments available."); + return true; + } + for (final Tournament tournament2 : Tournament.getTournaments()) { + player.sendMessage(ChatColor.AQUA + "(*) Tournament (" + tournament2.getMaximumPerTeam() + "v" + tournament2.getMaximumPerTeam() + ")"); + player.sendMessage(ChatColor.GRAY + "-> Kit: " + tournament2.getDefaultKit().getName()); + player.sendMessage(ChatColor.GRAY + "-> Stage: " + ((tournament2.getTournamentStage() == null) ? "Waiting for players" : StringUtils.capitalize(tournament2.getTournamentStage().name().replace("_", " ")))); + player.sendMessage(ChatColor.GRAY + "-> Current Matches: " + tournament2.getCurrentMatches().size()); + player.sendMessage(ChatColor.GRAY + "-> Total Teams: " + tournament2.getTeams().size()); + player.sendMessage(ChatColor.GRAY + "-> Players Limit: " + tournament2.getPlayersLimit()); + } + } + return true; + } +} diff --git a/src/main/java/us/centile/practice/duel/Duel.java b/src/main/java/us/centile/practice/duel/Duel.java new file mode 100644 index 0000000..92c212a --- /dev/null +++ b/src/main/java/us/centile/practice/duel/Duel.java @@ -0,0 +1,221 @@ +package us.centile.practice.duel; + +import us.centile.practice.player.*; +import java.util.*; +import org.bukkit.entity.*; +import com.google.common.base.*; + +public class Duel +{ + private String arenaName; + private String kitName; + private UUID uuid; + private boolean ranked; + private boolean premium; + private DuelState duelState; + private UUID firstTeamPartyLeaderUUID; + private UUID secondTeamPartyLeaderUUID; + private List firstTeam; + private List secondTeam; + private List firstTeamAlive; + private List secondTeamAlive; + private UUID ffaPartyLeaderUUID; + private List ffaPlayers; + private List ffaPlayersAlive; + private List spectators; + private Map playerUUIDToSnapshot; + private Map playerUUIDtoSnapshotUUID; + private long startMatchTime; + private long endMatchTime; + private boolean tournament; + + public Duel(final String arenaName, final String kitName, final UUID uuid, final boolean ranked, final UUID firstTeamPartyLeaderUUID, final UUID secondTeamPartyLeaderUUID, final List firstTeam, final List secondTeam, final boolean torunament, final boolean premium) { + this.spectators = new ArrayList(); + this.playerUUIDToSnapshot = new HashMap(); + this.playerUUIDtoSnapshotUUID = new HashMap(); + this.arenaName = arenaName; + this.kitName = kitName; + this.uuid = uuid; + this.ranked = ranked; + this.firstTeamPartyLeaderUUID = firstTeamPartyLeaderUUID; + this.secondTeamPartyLeaderUUID = secondTeamPartyLeaderUUID; + this.firstTeam = new ArrayList(firstTeam); + this.secondTeam = new ArrayList(secondTeam); + this.firstTeamAlive = new ArrayList(firstTeam); + this.secondTeamAlive = new ArrayList(secondTeam); + this.duelState = DuelState.STARTING; + this.premium = premium; + this.tournament = torunament; + } + + public Duel(final String arenaName, final String kitName, final UUID uuid, final UUID ffaPartyLeaderUUID, final List ffaPlayers) { + this.spectators = new ArrayList(); + this.playerUUIDToSnapshot = new HashMap(); + this.playerUUIDtoSnapshotUUID = new HashMap(); + this.arenaName = arenaName; + this.kitName = kitName; + this.uuid = uuid; + this.ffaPartyLeaderUUID = ffaPartyLeaderUUID; + this.ffaPlayers = new ArrayList(ffaPlayers); + this.ffaPlayersAlive = new ArrayList(ffaPlayers); + this.duelState = DuelState.STARTING; + } + + public void addSnapshot(final UUID uuid, final PlayerInventorySnapshot playerInventorySnapshot) { + this.playerUUIDToSnapshot.put(uuid, playerInventorySnapshot); + } + + public void addUUIDSnapshot(final UUID playerUUID, final UUID snapshotUUID) { + this.playerUUIDtoSnapshotUUID.put(playerUUID, snapshotUUID); + } + + public void addSpectator(final UUID uuid) { + this.spectators.add(uuid); + } + + public void removeSpectator(final UUID uuid) { + this.spectators.remove(uuid); + } + + public void killPlayerFFA(final UUID uuid) { + this.ffaPlayersAlive.remove(uuid); + } + + public void killPlayerFirstTeam(final UUID uuid) { + this.firstTeamAlive.remove(uuid); + } + + public void killPlayerSecondTeam(final UUID uuid) { + this.secondTeamAlive.remove(uuid); + } + + public void setDuelState(final DuelState duelState) { + this.duelState = duelState; + } + + public String getArenaName() { + return this.arenaName; + } + + public String getKitName() { + return this.kitName; + } + + public UUID getUUID() { + return this.uuid; + } + + public boolean isRanked() { + return this.ranked; + } + + public DuelState getDuelState() { + return this.duelState; + } + + public UUID getFirstTeamPartyLeaderUUID() { + return this.firstTeamPartyLeaderUUID; + } + + public UUID getSecondTeamPartyLeaderUUID() { + return this.secondTeamPartyLeaderUUID; + } + + public UUID getFfaPartyLeaderUUID() { + return this.ffaPartyLeaderUUID; + } + + public List getFfaPlayers() { + return this.ffaPlayers; + } + + public List getFfaPlayersAlive() { + return this.ffaPlayersAlive; + } + + public List getFirstTeam() { + return this.firstTeam; + } + + public List getSecondTeam() { + return this.secondTeam; + } + + public List getFirstTeamAlive() { + return this.firstTeamAlive; + } + + public List getSecondTeamAlive() { + return this.secondTeamAlive; + } + + public List getSpectators() { + return this.spectators; + } + + public boolean isPremium() { + return this.premium; + } + + public Map getPlayerUUIDToSnapshotMap() { + return this.playerUUIDToSnapshot; + } + + public Map getPlayerUUIDtoSnapshotUUIDMap() { + return this.playerUUIDtoSnapshotUUID; + } + + public long getStartDuration() { + return System.currentTimeMillis() - this.startMatchTime; + } + + public long getEndMatchTime() { + return this.endMatchTime; + } + + public long getFinalDuration() { + return this.endMatchTime - this.startMatchTime; + } + + public void setStartMatchTime(final long startMatchTime) { + this.startMatchTime = startMatchTime; + } + + public void setEndMatchTime(final long endMatchTime) { + this.endMatchTime = endMatchTime; + } + + public boolean isTournament() { + return this.tournament; + } + + public UUID getOtherTeamLeader(final Player player) { + Preconditions.checkNotNull((Object)player, (Object)"Player cannot be null"); + if (this.firstTeam.contains(player.getUniqueId())) { + return this.secondTeamPartyLeaderUUID; + } + if (this.secondTeam.contains(player.getUniqueId())) { + return this.firstTeamPartyLeaderUUID; + } + throw new IllegalArgumentException("Player " + player.getName() + " is not in duel."); + } + + public List getDuelTeam(final Player player) { + Preconditions.checkNotNull((Object)player, (Object)"Player cannot be null"); + if (this.firstTeam.contains(player.getUniqueId())) { + return this.firstTeam; + } + if (this.secondTeam.contains(player.getUniqueId())) { + return this.secondTeam; + } + throw new IllegalArgumentException("Player " + player.getName() + " is not in duel."); + } + + public List getOtherDuelTeam(final Player player) { + return this.getOtherDuelTeam(this.getDuelTeam(player)); + } + + public List getOtherDuelTeam(final List duelTeam) { + return (duelTeam == null) ? null : (duelTeam.equals(this.firstTeam) ? this.secondTeam : this.firstTeam); + } +} diff --git a/src/main/java/us/centile/practice/duel/DuelRequest.java b/src/main/java/us/centile/practice/duel/DuelRequest.java new file mode 100644 index 0000000..ba0bafe --- /dev/null +++ b/src/main/java/us/centile/practice/duel/DuelRequest.java @@ -0,0 +1,14 @@ +package us.centile.practice.duel; + +public class DuelRequest +{ + private String kitName; + + public DuelRequest(final String kitName) { + this.kitName = kitName; + } + + public String getKitName() { + return this.kitName; + } +} diff --git a/src/main/java/us/centile/practice/duel/DuelState.java b/src/main/java/us/centile/practice/duel/DuelState.java new file mode 100644 index 0000000..0ecd603 --- /dev/null +++ b/src/main/java/us/centile/practice/duel/DuelState.java @@ -0,0 +1,8 @@ +package us.centile.practice.duel; + +public enum DuelState +{ + STARTING, + FIGHTING, + ENDING; +} diff --git a/src/main/java/us/centile/practice/events/DuelCreateEvent.java b/src/main/java/us/centile/practice/events/DuelCreateEvent.java new file mode 100644 index 0000000..c9acb05 --- /dev/null +++ b/src/main/java/us/centile/practice/events/DuelCreateEvent.java @@ -0,0 +1,30 @@ +package us.centile.practice.events; + +import org.bukkit.event.*; +import us.centile.practice.duel.*; + +public class DuelCreateEvent extends Event +{ + private static HandlerList handlerList; + private Duel duel; + + public DuelCreateEvent(final Duel duel) { + this.duel = duel; + } + + public Duel getDuel() { + return this.duel; + } + + public HandlerList getHandlers() { + return DuelCreateEvent.handlerList; + } + + public static HandlerList getHandlerList() { + return DuelCreateEvent.handlerList; + } + + static { + DuelCreateEvent.handlerList = new HandlerList(); + } +} diff --git a/src/main/java/us/centile/practice/events/DuelEndEvent.java b/src/main/java/us/centile/practice/events/DuelEndEvent.java new file mode 100644 index 0000000..62e4422 --- /dev/null +++ b/src/main/java/us/centile/practice/events/DuelEndEvent.java @@ -0,0 +1,30 @@ +package us.centile.practice.events; + +import org.bukkit.event.*; +import us.centile.practice.duel.*; + +public class DuelEndEvent extends Event +{ + private static HandlerList handlerList; + private Duel duel; + + public DuelEndEvent(final Duel duel) { + this.duel = duel; + } + + public Duel getDuel() { + return this.duel; + } + + public HandlerList getHandlers() { + return DuelEndEvent.handlerList; + } + + public static HandlerList getHandlerList() { + return DuelEndEvent.handlerList; + } + + static { + DuelEndEvent.handlerList = new HandlerList(); + } +} diff --git a/src/main/java/us/centile/practice/events/DuelEndingEvent.java b/src/main/java/us/centile/practice/events/DuelEndingEvent.java new file mode 100644 index 0000000..9f73a1c --- /dev/null +++ b/src/main/java/us/centile/practice/events/DuelEndingEvent.java @@ -0,0 +1,40 @@ +package us.centile.practice.events; + +import org.bukkit.event.*; +import us.centile.practice.duel.*; + +public class DuelEndingEvent extends Event +{ + private static HandlerList handlerList; + private Duel duel; + private int teamNumber; + + public DuelEndingEvent(final Duel duel, final int teamNumber) { + this.duel = duel; + this.teamNumber = teamNumber; + } + + public DuelEndingEvent(final Duel duel) { + this.duel = duel; + } + + public int getTeamNumber() { + return this.teamNumber; + } + + public Duel getDuel() { + return this.duel; + } + + public HandlerList getHandlers() { + return DuelEndingEvent.handlerList; + } + + public static HandlerList getHandlerList() { + return DuelEndingEvent.handlerList; + } + + static { + DuelEndingEvent.handlerList = new HandlerList(); + } +} diff --git a/src/main/java/us/centile/practice/events/DuelPreCreateEvent.java b/src/main/java/us/centile/practice/events/DuelPreCreateEvent.java new file mode 100644 index 0000000..5055975 --- /dev/null +++ b/src/main/java/us/centile/practice/events/DuelPreCreateEvent.java @@ -0,0 +1,83 @@ +package us.centile.practice.events; + +import org.bukkit.event.*; +import us.centile.practice.kit.*; +import java.util.*; + +public class DuelPreCreateEvent extends Event +{ + private static HandlerList handlerList; + private Kit kit; + private boolean ranked; + private boolean premium; + private UUID firstTeamPartyLeaderUUID; + private UUID secondTeamPartyLeaderUUID; + private List firstTeam; + private List secondTeam; + private UUID ffaPartyLeaderUUID; + private List ffaPlayers; + + public DuelPreCreateEvent(final Kit kit, final boolean ranked, final UUID firstTeamPartyLeaderUUID, final UUID secondTeamPartyLeaderUUID, final List firstTeam, final List secondTeam, final boolean premium) { + this.kit = kit; + this.ranked = ranked; + this.premium = premium; + this.firstTeamPartyLeaderUUID = firstTeamPartyLeaderUUID; + this.secondTeamPartyLeaderUUID = secondTeamPartyLeaderUUID; + this.firstTeam = new ArrayList(firstTeam); + this.secondTeam = new ArrayList(secondTeam); + } + + public DuelPreCreateEvent(final Kit kit, final UUID ffaPartyLeaderUUID, final List ffaPlayers) { + this.kit = kit; + this.ffaPartyLeaderUUID = ffaPartyLeaderUUID; + this.ffaPlayers = new ArrayList(ffaPlayers); + } + + public Kit getKit() { + return this.kit; + } + + public boolean isRanked() { + return this.ranked; + } + + public UUID getFirstTeamPartyLeaderUUID() { + return this.firstTeamPartyLeaderUUID; + } + + public UUID getSecondTeamPartyLeaderUUID() { + return this.secondTeamPartyLeaderUUID; + } + + public List getFirstTeam() { + return this.firstTeam; + } + + public boolean isPremium() { + return this.premium; + } + + public List getSecondTeam() { + return this.secondTeam; + } + + public UUID getFfaPartyLeaderUUID() { + return this.ffaPartyLeaderUUID; + } + + public List getFfaPlayers() { + return this.ffaPlayers; + } + + public static HandlerList getHandlerList() { + return DuelPreCreateEvent.handlerList; + } + + public HandlerList getHandlers() { + return DuelPreCreateEvent.handlerList; + } + + static { + DuelPreCreateEvent.handlerList = new HandlerList(); + } +} diff --git a/src/main/java/us/centile/practice/kit/Kit.java b/src/main/java/us/centile/practice/kit/Kit.java new file mode 100644 index 0000000..d6f9c2a --- /dev/null +++ b/src/main/java/us/centile/practice/kit/Kit.java @@ -0,0 +1,116 @@ +package us.centile.practice.kit; + +import org.bukkit.inventory.*; +import java.util.*; + +public class Kit +{ + private boolean enabled; + private String name; + private ItemStack icon; + private boolean combo; + private boolean editable; + private boolean ranked; + private boolean premium; + private boolean builduhc; + private ItemStack[] mainContents; + private ItemStack[] armorContents; + + public Kit(final String name, final ItemStack icon, final boolean combo, final boolean editable, final boolean ranked, final ItemStack[] mainContents, final ItemStack[] armorContents, final boolean premium, final boolean build) { + this.name = name; + this.icon = icon; + this.combo = combo; + this.editable = editable; + this.ranked = ranked; + this.premium = premium; + this.mainContents = mainContents; + this.armorContents = armorContents; + this.builduhc = build; + } + + public boolean isEnabled() { + return this.enabled; + } + + public String getName() { + return this.name; + } + + public ItemStack getIcon() { + return this.icon; + } + + public boolean isCombo() { + return this.combo; + } + + public boolean isEditable() { + return this.editable; + } + + public boolean isRanked() { + return this.ranked; + } + + public boolean isPremium() { + return this.premium; + } + + public ItemStack[] getMainContents() { + return this.mainContents; + } + + public ItemStack[] getArmorContents() { + return this.armorContents; + } + + public void setEnabled(final boolean enabled) { + this.enabled = enabled; + } + + public void setIcon(final ItemStack icon) { + this.icon = icon; + } + + public void setCombo(final boolean combo) { + this.combo = combo; + } + + public void setEditable(final boolean editable) { + this.editable = editable; + } + + public void setRanked(final boolean ranked) { + this.ranked = ranked; + } + + public void setPremium(final boolean premium) { + this.premium = premium; + } + + public void setMainContents(final ItemStack[] mainContents) { + this.mainContents = mainContents; + } + + public void setArmorContents(final ItemStack[] armorContents) { + this.armorContents = armorContents; + } + + public List getEditableContents() { + final List items = new ArrayList(); + for (final ItemStack item : this.getMainContents()) { + if (!items.contains(item)) { + items.add(item); + } + } + return items; + } + + public boolean isBuilduhc() { + return this.builduhc; + } + + public void setBuilduhc(final boolean builduhc) { + this.builduhc = builduhc; + } +} diff --git a/src/main/java/us/centile/practice/listeners/BlockListener.java b/src/main/java/us/centile/practice/listeners/BlockListener.java new file mode 100644 index 0000000..a83826c --- /dev/null +++ b/src/main/java/us/centile/practice/listeners/BlockListener.java @@ -0,0 +1,84 @@ +package us.centile.practice.listeners; + +import us.centile.practice.*; +import org.bukkit.event.player.*; +import us.centile.practice.arena.*; +import org.bukkit.event.*; +import org.bukkit.block.*; +import us.centile.practice.player.*; +import us.centile.practice.duel.*; +import org.bukkit.event.block.*; + +public class BlockListener implements Listener +{ + private nPractice plugin; + + public BlockListener(final nPractice plugin) { + this.plugin = plugin; + } + + @EventHandler + public void onBlockForm(final BlockSpreadEvent event) { + event.setCancelled(true); + } + + @EventHandler + public void onBlockBurn(final BlockBurnEvent event) { + event.setCancelled(true); + } + + @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) + public void onPlayerBucketEmpty(final PlayerBucketEmptyEvent event) { + final Arena arena = this.plugin.getManagerHandler().getArenaManager().closest(event.getBlockClicked().getLocation()); + if (arena != null) { + arena.getBlockChangeTracker().add(event.getBlockClicked().getRelative(event.getBlockFace()).getState()); + } + } + + @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) + public void onBlockForm(final BlockFromToEvent event) { + final Arena arena = this.plugin.getManagerHandler().getArenaManager().closest(event.getToBlock().getLocation()); + if (arena != null) { + arena.getBlockChangeTracker().add(event.getToBlock().getState()); + arena.getBlockChangeTracker().add(event.getToBlock().getRelative(BlockFace.DOWN).getState()); + } + } + + @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) + public void onBlockBreak(final BlockBreakEvent e) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(e.getPlayer()); + if (practicePlayer.getCurrentState() == PlayerState.BUILDER) { + return; + } + final Duel duel = this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(e.getPlayer().getUniqueId()); + if (duel != null) { + final Arena arena = this.plugin.getManagerHandler().getArenaManager().getArena(duel.getArenaName()); + if (arena.getBlockChangeTracker().isPlayerPlacedBlock(e.getBlock().getLocation())) { + arena.getBlockChangeTracker().add(e.getBlock().getState()); + return; + } + } + e.setCancelled(true); + } + + @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) + public void onBlockPlace(final BlockPlaceEvent e) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(e.getPlayer()); + if (practicePlayer.getCurrentState() == PlayerState.BUILDER) { + return; + } + final Duel duel = this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(e.getPlayer().getUniqueId()); + if (duel == null) { + e.setCancelled(true); + return; + } + final Arena arena = this.plugin.getManagerHandler().getArenaManager().getArena(duel.getArenaName()); + final double averageY = (arena.getFirstTeamLocation().getY() + arena.getSecondTeamLocation().getY()) / 2.0; + if (Math.abs(e.getBlock().getY() - averageY) > 5.0) { + e.setCancelled(true); + return; + } + arena.getBlockChangeTracker().setPlayerPlacedBlock(e.getBlock().getLocation()); + arena.getBlockChangeTracker().add(e.getBlockReplacedState()); + } +} diff --git a/src/main/java/us/centile/practice/listeners/DuelListener.java b/src/main/java/us/centile/practice/listeners/DuelListener.java new file mode 100644 index 0000000..1ee0fad --- /dev/null +++ b/src/main/java/us/centile/practice/listeners/DuelListener.java @@ -0,0 +1,494 @@ +package us.centile.practice.listeners; + +import org.bukkit.scoreboard.Scoreboard; +import us.centile.practice.*; +import us.centile.practice.arena.*; +import us.centile.practice.kit.*; +import org.bukkit.entity.*; +import com.google.common.collect.*; +import org.bukkit.*; +import net.minecraft.server.v1_8_R3.*; +import org.bukkit.craftbukkit.v1_8_R3.entity.*; +import org.bukkit.scoreboard.*; +import java.lang.reflect.*; +import org.bukkit.scheduler.*; +import us.centile.practice.duel.*; +import org.bukkit.event.*; +import us.centile.practice.player.*; +import org.bukkit.plugin.*; +import us.centile.practice.runnables.other.*; +import us.centile.practice.events.*; +import us.centile.practice.tournament.*; +import us.centile.practice.util.*; +import java.util.*; +import us.centile.practice.scoreboard.*; +import us.centile.practice.party.*; + +public class DuelListener implements Listener +{ + private nPractice plugin; + private final String NO_ARENA_AVAILABLE; + private Map duelTickThreadMap; + private Map duelCountdownMap; + + public DuelListener(final nPractice plugin) { + this.NO_ARENA_AVAILABLE = ChatColor.RED + "There are no arenas available at this moment"; + this.duelTickThreadMap = new HashMap(); + this.duelCountdownMap = new HashMap(); + this.plugin = plugin; + } + + @EventHandler + public void onDuelPreCreate(final DuelPreCreateEvent e) { + final Arena arena = this.plugin.getManagerHandler().getArenaManager().getRandomArena(); + final Kit kit = e.getKit(); + if (arena == null || kit == null) { + for (final UUID uuid : e.getFirstTeam()) { + final Player player = this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + player.sendMessage(this.NO_ARENA_AVAILABLE); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + } + for (final UUID uuid : e.getSecondTeam()) { + final Player player = this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + player.sendMessage(this.NO_ARENA_AVAILABLE); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + } + } + else if (e.getFfaPlayers() != null) { + this.plugin.getManagerHandler().getDuelManager().createDuel(arena, kit, e.getFfaPartyLeaderUUID(), e.getFfaPlayers()); + } + else { + this.plugin.getManagerHandler().getDuelManager().createDuel(arena, kit, e.isRanked(), e.getFirstTeamPartyLeaderUUID(), e.getSecondTeamPartyLeaderUUID(), e.getFirstTeam(), e.getSecondTeam(), false, e.isPremium()); + } + } + + public void unSetHealthBars(final Duel duel) { + final List allPlayers = Lists.newArrayList(); + if (duel.getFirstTeam() != null) { + for (final UUID uuid : duel.getFirstTeam()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + allPlayers.add(player); + } + } + } + if (duel.getSecondTeam() != null) { + for (final UUID uuid : duel.getSecondTeam()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + allPlayers.add(player); + } + } + } + if (duel.getFfaPlayers() != null) { + for (final UUID uuid : duel.getFfaPlayers()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + allPlayers.add(player); + } + } + } + for (final Player player2 : allPlayers) { + final Scoreboard sb = player2.getScoreboard(); + if (sb == Bukkit.getScoreboardManager().getMainScoreboard()) { + continue; + } + final Objective objective = sb.getObjective("showhealth"); + if (objective == null) { + continue; + } + objective.unregister(); + } + } + + public void setHealthBars(final Duel duel) { + final List allPlayers = Lists.newArrayList(); + if (duel.getFirstTeam() != null) { + for (final UUID uuid : duel.getFirstTeam()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + allPlayers.add(player); + } + } + } + if (duel.getSecondTeam() != null) { + for (final UUID uuid : duel.getSecondTeam()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + allPlayers.add(player); + } + } + } + if (duel.getFfaPlayers() != null) { + for (final UUID uuid : duel.getFfaPlayers()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + allPlayers.add(player); + } + } + } + for (final Player player2 : allPlayers) { + final Scoreboard sb = player2.getScoreboard(); + if (sb == Bukkit.getScoreboardManager().getMainScoreboard()) { + continue; + } + Objective objective = sb.getObjective("showhealth"); + if (objective != null) { + continue; + } + try { + final Field field = EntityPlayer.class.getDeclaredField("bP"); + field.setAccessible(true); + for (final Player other : allPlayers) { + field.setFloat(((CraftPlayer)other).getHandle(), Float.MIN_VALUE); + } + } + catch (ReflectiveOperationException ex) { + ex.printStackTrace(); + } + objective = sb.registerNewObjective("showhealth", "health"); + objective.setDisplaySlot(DisplaySlot.BELOW_NAME); + objective.setDisplayName(ChatColor.RED + "\u2764"); + } + } + + @EventHandler + public void onDuelCreate(final DuelCreateEvent e) { + final Duel duel = e.getDuel(); + this.plugin.getManagerHandler().getArenaManager().getArena(duel.getArenaName()).setOpen(false); + if (this.plugin.getManagerHandler().getKitManager().getKit(duel.getKitName()).isBuilduhc()) { + this.setHealthBars(duel); + } + this.duelCountdownMap.put(duel.getUUID(), 6); + final BukkitTask tickThread = new BukkitRunnable() { + public void run() { + int countdown = DuelListener.this.duelCountdownMap.get(duel.getUUID()); + if (duel.getDuelState() == DuelState.STARTING) { + if (--countdown == 0) { + duel.setDuelState(DuelState.FIGHTING); + if (duel.getFfaPlayers() != null) { + for (final UUID uuid : duel.getFfaPlayersAlive()) { + final Player player = DuelListener.this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + final PracticePlayer practicePlayer = DuelListener.this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + practicePlayer.setCurrentState(PlayerState.FIGHTING); + player.sendMessage(ChatColor.GREEN + "The match has started, good luck!"); + } + } + else { + for (final UUID uuid : duel.getFirstTeamAlive()) { + final Player player = DuelListener.this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + final PracticePlayer practicePlayer = DuelListener.this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + practicePlayer.setCurrentState(PlayerState.FIGHTING); + player.sendMessage(ChatColor.GREEN + "The match has started, good luck!"); + } + for (final UUID uuid : duel.getSecondTeamAlive()) { + final Player player = DuelListener.this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + final PracticePlayer practicePlayer = DuelListener.this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + practicePlayer.setCurrentState(PlayerState.FIGHTING); + player.sendMessage(ChatColor.GREEN + "The match has started, good luck!"); + } + } + return; + } + if (duel.getFfaPlayers() != null) { + for (final UUID uuid : duel.getFfaPlayersAlive()) { + final Player player = DuelListener.this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + player.sendMessage(ChatColor.YELLOW + "The match starts in " + ChatColor.GREEN + countdown + ChatColor.YELLOW + "..."); + } + } + else { + for (final UUID uuid : duel.getFirstTeamAlive()) { + final Player player = DuelListener.this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + player.sendMessage(ChatColor.YELLOW + "The match starts in " + ChatColor.GREEN + countdown + ChatColor.YELLOW + "..."); + } + for (final UUID uuid : duel.getSecondTeamAlive()) { + final Player player = DuelListener.this.plugin.getServer().getPlayer(uuid); + if (player == null) { + continue; + } + player.sendMessage(ChatColor.YELLOW + "The match starts in " + ChatColor.GREEN + countdown + ChatColor.YELLOW + "..."); + } + } + } + else if (duel.getDuelState() == DuelState.ENDING) { + countdown -= 2; + if (countdown <= 0) { + DuelListener.this.plugin.getServer().getPluginManager().callEvent(new DuelEndEvent(duel)); + } + } + DuelListener.this.duelCountdownMap.put(duel.getUUID(), countdown); + } + }.runTaskTimer(this.plugin, 20L, 20L); + duel.setStartMatchTime(System.currentTimeMillis()); + Bukkit.getScheduler().runTaskAsynchronously(this.plugin, new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.SPECTATOR)); + this.duelTickThreadMap.put(duel.getUUID(), tickThread); + } + + @EventHandler + public void onDuelEnd(final DuelEndingEvent e) { + final Duel duel = e.getDuel(); + this.plugin.getManagerHandler().getArenaManager().getArena(duel.getArenaName()).setOpen(true); + if (this.plugin.getManagerHandler().getKitManager().getKit(duel.getKitName()).isBuilduhc()) { + this.unSetHealthBars(duel); + } + this.plugin.getManagerHandler().getArenaManager().getArena(duel.getArenaName()).getBlockChangeTracker().rollback(); + this.duelCountdownMap.put(duel.getUUID(), 6); + final UtilActionMessage winnerMessage = new UtilActionMessage(); + final UtilActionMessage loserMessage = new UtilActionMessage(); + final Set duelPlayers = new HashSet(); + if (duel.getFfaPlayers() != null) { + final Player lastPlayer = this.plugin.getServer().getPlayer(duel.getFfaPlayersAlive().get(0)); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(lastPlayer); + practicePlayer.setCurrentState(PlayerState.WAITING); + winnerMessage.addText(ChatColor.GREEN + lastPlayer.getName() + " ").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/inventory " + duel.getPlayerUUIDtoSnapshotUUIDMap().get(lastPlayer.getUniqueId())); + for (final UUID uuidPlayer : duel.getFfaPlayers()) { + if (uuidPlayer.equals(lastPlayer.getUniqueId())) { + continue; + } + final Player player = this.plugin.getServer().getPlayer(uuidPlayer); + if (player == null) { + continue; + } + duelPlayers.add(player); + loserMessage.addText(ChatColor.RED + player.getName() + " ").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/inventory " + duel.getPlayerUUIDtoSnapshotUUIDMap().get(player.getUniqueId())); + } + duelPlayers.add(lastPlayer); + } + else { + List winningTeam = null; + List losingTeam = null; + final int teamNumber = e.getTeamNumber(); + switch (teamNumber) { + case 1: { + winningTeam = duel.getFirstTeam(); + losingTeam = duel.getSecondTeam(); + break; + } + case 2: { + winningTeam = duel.getSecondTeam(); + losingTeam = duel.getFirstTeam(); + break; + } + } + for (final UUID uuidPlayer2 : duel.getFirstTeamAlive()) { + final Player player2 = this.plugin.getServer().getPlayer(uuidPlayer2); + if (player2 == null) { + continue; + } + final PracticePlayer practicePlayer2 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player2); + practicePlayer2.setCurrentState(PlayerState.WAITING); + } + for (final UUID uuidPlayer2 : duel.getSecondTeamAlive()) { + final Player player2 = this.plugin.getServer().getPlayer(uuidPlayer2); + if (player2 == null) { + continue; + } + final PracticePlayer practicePlayer2 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player2); + practicePlayer2.setCurrentState(PlayerState.WAITING); + } + if (duel.isTournament() && Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament != null) { + final Iterator iterator = tournament.getCurrentMatches().iterator(); + while (iterator.hasNext()) { + final TournamentMatch match = iterator.next(); + if (match.getFirstTeam().getPlayers().equals(duel.getFirstTeam()) && match.getSecondTeam().getPlayers().equals(duel.getSecondTeam())) { + final String winningTeamOne = ChatColor.YELLOW.toString() + ChatColor.BOLD + "\u272a " + ChatColor.GREEN + Bukkit.getOfflinePlayer(duel.getFirstTeamPartyLeaderUUID()).getName() + ((duel.getFirstTeam().size() > 1) ? "'s Team" : "") + ChatColor.GOLD + " has eliminated " + ChatColor.RED + Bukkit.getOfflinePlayer(duel.getSecondTeamPartyLeaderUUID()).getName() + ((duel.getSecondTeam().size() > 1) ? "'s Team" : ""); + final String winningTeamTwo = ChatColor.YELLOW.toString() + ChatColor.BOLD + "\u272a " + ChatColor.GREEN + Bukkit.getOfflinePlayer(duel.getSecondTeamPartyLeaderUUID()).getName() + ((duel.getSecondTeam().size() > 1) ? "'s Team" : "") + ChatColor.GOLD + " has eliminated " + ChatColor.RED + Bukkit.getOfflinePlayer(duel.getFirstTeamPartyLeaderUUID()).getName() + ((duel.getFirstTeam().size() > 1) ? "'s Team" : ""); + this.plugin.getServer().broadcastMessage((e.getTeamNumber() == 1) ? winningTeamOne : winningTeamTwo); + match.setWinndingId(e.getTeamNumber()); + match.setMatchState(TournamentMatch.MatchState.ENDING); + tournament.getTeams().remove((e.getTeamNumber() == 1) ? match.getSecondTeam() : match.getFirstTeam()); + tournament.getCurrentQueue().remove((e.getTeamNumber() == 1) ? match.getSecondTeam() : match.getFirstTeam()); + iterator.remove(); + } + } + } + } + } + String winnerElo = ""; + String loserElo = ""; + if (duel.isRanked()) { + if (duel.getFirstTeam().size() == 1 && duel.getSecondTeam().size() == 1) { + final PracticePlayer winnerPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(winningTeam.get(0)); + final PracticePlayer loserPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(losingTeam.get(0)); + final int currentWinnerElo = winnerPracPlayer.getEloMap().get(duel.getKitName()); + final int currentLoserElo = loserPracPlayer.getEloMap().get(duel.getKitName()); + final int[] newElos = UtilElo.getNewRankings(currentWinnerElo, currentLoserElo, true); + winnerElo = ChatColor.GREEN + " +" + (newElos[0] - currentWinnerElo) + " (" + newElos[0] + ")"; + loserElo = ChatColor.RED + " -" + (currentLoserElo - newElos[1]) + " (" + newElos[1] + ")"; + winnerPracPlayer.addElo(duel.getKitName(), newElos[0]); + loserPracPlayer.addElo(duel.getKitName(), newElos[1]); + winnerPracPlayer.setRankedWins(winnerPracPlayer.getRankedWins() + 1); + loserPracPlayer.setRankedLosses(loserPracPlayer.getRankedLosses() + 1); + } + else if (duel.getFirstTeam().size() == 2 && duel.getSecondTeam().size() == 2 && duel.getFirstTeamPartyLeaderUUID() != null && duel.getSecondTeamPartyLeaderUUID() != null) { + final PracticePlayer winnerLeaderPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(winningTeam.get(0)); + final PracticePlayer winnerMemberPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(winningTeam.get(1)); + final PracticePlayer loserLeaderPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(losingTeam.get(0)); + final PracticePlayer loserMemberPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(losingTeam.get(1)); + final int currentWinnerElo2 = winnerLeaderPracPlayer.getPartyEloMap().get(winnerMemberPracPlayer.getUUID()).get(duel.getKitName()); + final int currentLoserElo2 = loserLeaderPracPlayer.getPartyEloMap().get(loserMemberPracPlayer.getUUID()).get(duel.getKitName()); + final int[] newElos2 = UtilElo.getNewRankings(currentWinnerElo2, currentLoserElo2, true); + winnerElo = ChatColor.GREEN + " +" + (newElos2[0] - currentWinnerElo2) + " (" + newElos2[0] + ")"; + loserElo = ChatColor.RED + " -" + (currentLoserElo2 - newElos2[1]) + " (" + newElos2[1] + ")"; + winnerLeaderPracPlayer.addPartyElo(winnerMemberPracPlayer.getUUID(), duel.getKitName(), newElos2[0]); + winnerMemberPracPlayer.addPartyElo(winnerLeaderPracPlayer.getUUID(), duel.getKitName(), newElos2[0]); + loserLeaderPracPlayer.addPartyElo(loserMemberPracPlayer.getUUID(), duel.getKitName(), newElos2[1]); + loserMemberPracPlayer.addPartyElo(loserLeaderPracPlayer.getUUID(), duel.getKitName(), newElos2[1]); + } + } + if (duel.isPremium() && duel.getFirstTeam().size() == 1 && duel.getSecondTeam().size() == 1) { + final PracticePlayer winnerPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(winningTeam.get(0)); + final PracticePlayer loserPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(losingTeam.get(0)); + final int currentWinnerElo = winnerPracPlayer.getPremiumEloMap().get(duel.getKitName()); + final int currentLoserElo = loserPracPlayer.getPremiumEloMap().get(duel.getKitName()); + final int[] newElos = UtilElo.getNewRankings(currentWinnerElo, currentLoserElo, true); + winnerElo = ChatColor.GREEN + " +" + (newElos[0] - currentWinnerElo) + " (" + newElos[0] + ")"; + loserElo = ChatColor.RED + " -" + (currentLoserElo - newElos[1]) + " (" + newElos[1] + ")"; + winnerPracPlayer.addPremiumElo(duel.getKitName(), newElos[0]); + loserPracPlayer.addPremiumElo(duel.getKitName(), newElos[1]); + winnerPracPlayer.setPremiumWins(winnerPracPlayer.getPremiumWins() + 1); + loserPracPlayer.setPremiumLosses(loserPracPlayer.getPremiumLosses() + 1); + } + boolean partyMatch = false; + if (duel.getFirstTeam() != null && duel.getFirstTeam().size() > 1) { + partyMatch = true; + } + for (final UUID uuidPlayer3 : winningTeam) { + final Player player3 = this.plugin.getServer().getPlayer(uuidPlayer3); + if (player3 == null) { + continue; + } + if (!duel.isRanked() && !duel.isPremium()) { + final PracticePlayer practicePlayer3 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player3.getUniqueId()); + if (practicePlayer3 != null) { + practicePlayer3.setUnrankedWins(practicePlayer3.getUnrankedWins() + 1); + } + } + duelPlayers.add(player3); + winnerMessage.addText(ChatColor.GREEN + (partyMatch ? "Winners: " : "Winner: ") + ChatColor.GRAY + player3.getName() + winnerElo + " ").addHoverText(ChatColor.GRAY + "Click here to view inventory").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/inventory " + duel.getPlayerUUIDtoSnapshotUUIDMap().get(player3.getUniqueId())); + } + for (final UUID uuidPlayer3 : losingTeam) { + final Player player3 = this.plugin.getServer().getPlayer(uuidPlayer3); + if (player3 == null) { + continue; + } + if (!duel.isRanked() && !duel.isPremium()) { + final PracticePlayer practicePlayer3 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player3.getUniqueId()); + if (practicePlayer3 != null) { + practicePlayer3.setUnrankedLosses(practicePlayer3.getUnrankedLosses() + 1); + } + } + duelPlayers.add(player3); + loserMessage.addText(ChatColor.RED + (partyMatch ? "Losers: " : "Loser: ") + ChatColor.GRAY + player3.getName() + loserElo + " ").addHoverText(ChatColor.GRAY + "Click here to view inventory").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/inventory " + duel.getPlayerUUIDtoSnapshotUUIDMap().get(player3.getUniqueId())); + } + } + for (final UUID spectatorUUID : duel.getSpectators()) { + final Player player4 = this.plugin.getServer().getPlayer(spectatorUUID); + if (player4 == null) { + continue; + } + duelPlayers.add(player4); + } + for (final Player player5 : duelPlayers) { + final String[] information = { ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------", ChatColor.GOLD + "Match Results: " + ChatColor.GRAY + "(Clickable Inventories)" }; + player5.sendMessage(information); + winnerMessage.sendToPlayer(player5); + loserMessage.sendToPlayer(player5); + player5.sendMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + for (final Player playerInDuel : duelPlayers) { + final PlayerBoard playerBoard = this.plugin.getManagerHandler().getScoreboardHandler().getPlayerBoard(playerInDuel.getUniqueId()); + if (playerBoard != null) { + playerBoard.addUpdates(playerInDuel); + } + } + duelPlayers.clear(); + } + + @EventHandler + public void onDuelEnd(final DuelEndEvent e) { + final Duel duel = e.getDuel(); + this.duelCountdownMap.remove(duel.getUUID()); + final BukkitTask task = this.duelTickThreadMap.get(duel.getUUID()); + task.cancel(); + this.duelTickThreadMap.remove(duel.getUUID()); + if (duel.getFfaPlayers() != null) { + if (duel.getFfaPartyLeaderUUID() != null) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(duel.getFfaPartyLeaderUUID()); + if (party != null) { + party.setPartyState(PartyState.LOBBY); + } + } + final Player player = this.plugin.getServer().getPlayer(duel.getFfaPlayersAlive().get(0)); + if (player == null) { + return; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + } + else { + if (duel.getFirstTeamPartyLeaderUUID() != null) { + final Party firstTeamParty = this.plugin.getManagerHandler().getPartyManager().getParty(duel.getFirstTeamPartyLeaderUUID()); + if (firstTeamParty != null) { + firstTeamParty.setPartyState(PartyState.LOBBY); + } + } + if (duel.getSecondTeamPartyLeaderUUID() != null) { + final Party secondTeamParty = this.plugin.getManagerHandler().getPartyManager().getParty(duel.getSecondTeamPartyLeaderUUID()); + if (secondTeamParty != null) { + secondTeamParty.setPartyState(PartyState.LOBBY); + } + } + for (final UUID uuid : duel.getFirstTeamAlive()) { + final Player player2 = this.plugin.getServer().getPlayer(uuid); + if (player2 == null) { + continue; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player2); + } + for (final UUID uuid : duel.getSecondTeamAlive()) { + final Player player2 = this.plugin.getServer().getPlayer(uuid); + if (player2 == null) { + continue; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player2); + } + if (duel.getSpectators().size() > 0) { + final Iterator iterator = duel.getSpectators().iterator(); + while (iterator.hasNext()) { + final UUID value = iterator.next(); + final Player player2 = this.plugin.getServer().getPlayer(value); + if (player2 == null) { + continue; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player2); + this.plugin.getManagerHandler().getSpectatorManager().removeSpectator(player2, false); + iterator.remove(); + } + } + } + this.plugin.getManagerHandler().getDuelManager().destroyDuel(duel); + } +} diff --git a/src/main/java/us/centile/practice/listeners/EntityListener.java b/src/main/java/us/centile/practice/listeners/EntityListener.java new file mode 100644 index 0000000..e8823b8 --- /dev/null +++ b/src/main/java/us/centile/practice/listeners/EntityListener.java @@ -0,0 +1,55 @@ +package us.centile.practice.listeners; + +import us.centile.practice.*; +import org.bukkit.entity.*; +import us.centile.practice.player.*; +import org.bukkit.event.*; +import org.bukkit.event.entity.*; + +public class EntityListener implements Listener +{ + private nPractice plugin; + + public EntityListener(final nPractice plugin) { + this.plugin = plugin; + } + + @EventHandler + public void onEntityDamageByEntity(final EntityDamageByEntityEvent e) { + if (e.getDamager() instanceof Player && e.getEntity() instanceof Player) { + final Player damagedPlayer = (Player)e.getEntity(); + final Player attackerPlayer = (Player)e.getDamager(); + final PracticePlayer damagedPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(damagedPlayer); + final PracticePlayer attackerPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(attackerPlayer); + if (damagedPracPlayer.getCurrentState() != PlayerState.FIGHTING || attackerPracPlayer.getCurrentState() != PlayerState.FIGHTING) { + e.setCancelled(true); + } + if (damagedPracPlayer.getTeamNumber() == 0) { + return; + } + final int damagedTeamNumber = damagedPracPlayer.getTeamNumber(); + final int attackerTeamNumber = attackerPracPlayer.getTeamNumber(); + if (damagedTeamNumber == attackerTeamNumber) { + e.setCancelled(true); + } + } + } + + @EventHandler + public void onEntityDamage(final EntityDamageEvent e) { + if (e.getEntity() instanceof Player) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer((Player)e.getEntity()); + if (practicePlayer.getCurrentState() != PlayerState.FIGHTING) { + if (e.getCause() == EntityDamageEvent.DamageCause.VOID) { + if (this.plugin.getSpawn() == null) { + e.getEntity().teleport(e.getEntity().getWorld().getSpawnLocation()); + } + else { + e.getEntity().teleport(this.plugin.getSpawn()); + } + } + e.setCancelled(true); + } + } + } +} diff --git a/src/main/java/us/centile/practice/listeners/HitDetectionListener.java b/src/main/java/us/centile/practice/listeners/HitDetectionListener.java new file mode 100644 index 0000000..35e5768 --- /dev/null +++ b/src/main/java/us/centile/practice/listeners/HitDetectionListener.java @@ -0,0 +1,30 @@ +package us.centile.practice.listeners; + +import us.centile.practice.*; +import org.bukkit.*; +import org.bukkit.plugin.*; +import org.bukkit.entity.*; +import java.util.*; +import org.bukkit.event.player.*; +import org.bukkit.event.*; + +public class HitDetectionListener implements Listener +{ + private final nPractice plugin; + + public HitDetectionListener(final nPractice plugin) { + this.plugin = plugin; + } + + public void onEnable() { + Bukkit.getPluginManager().registerEvents(this, nPractice.getInstance()); + for (final Player player : Bukkit.getOnlinePlayers()) { + player.setMaximumNoDamageTicks(19); + } + } + + @EventHandler + public void onJoin(final PlayerJoinEvent event) { + event.getPlayer().setMaximumNoDamageTicks(19); + } +} diff --git a/src/main/java/us/centile/practice/listeners/InventoryListener.java b/src/main/java/us/centile/practice/listeners/InventoryListener.java new file mode 100644 index 0000000..53cc1cc --- /dev/null +++ b/src/main/java/us/centile/practice/listeners/InventoryListener.java @@ -0,0 +1,682 @@ +package us.centile.practice.listeners; + +import us.centile.practice.*; +import org.bukkit.entity.*; +import us.centile.practice.kit.*; +import us.centile.practice.events.*; +import us.centile.practice.duel.*; +import org.bukkit.*; +import us.centile.practice.commands.*; +import us.centile.practice.tournament.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.plugin.*; +import org.bukkit.command.*; +import us.centile.practice.util.*; +import us.centile.practice.player.*; +import us.centile.practice.party.*; +import us.centile.practice.manager.managers.*; +import org.bukkit.event.*; +import org.bukkit.event.inventory.*; +import org.bukkit.inventory.*; +import java.util.*; + +public class InventoryListener implements Listener +{ + private nPractice plugin; + + public InventoryListener(final nPractice plugin) { + this.plugin = plugin; + } + + @EventHandler + public void onInvClick(final InventoryClickEvent e) { + final Player player = (Player)e.getWhoClicked(); + if (player.getGameMode() == GameMode.CREATIVE && player.isOp()) { + return; + } + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + final String invTitle = e.getInventory().getTitle().toLowerCase(); + if (invTitle.contains("inventory")) { + e.setCancelled(true); + return; + } + final ItemStack itemClicked = e.getCurrentItem(); + final Inventory inventory = e.getInventory(); + if (practicePlayer.getCurrentState() == PlayerState.LOBBY || practicePlayer.getCurrentState() == PlayerState.QUEUE) { + e.setCancelled(true); + if (itemClicked == null || !itemClicked.hasItemMeta() || !itemClicked.getItemMeta().hasDisplayName()) { + e.setCancelled(true); + return; + } + if (invTitle.contains("party events")) { + e.setCancelled(true); + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party == null) { + player.closeInventory(); + player.sendMessage(ChatColor.RED + "You must be in a party in order for this feature to work."); + return; + } + switch (itemClicked.getType()) { + case GOLD_SWORD: { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + break; + } + if (party.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "Your party is currently busy and cannot fight"); + break; + } + if (party.getMembers().size() == 0) { + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + break; + } + player.closeInventory(); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getSplitFightInventory()); + break; + } + case SLIME_BALL: { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + break; + } + if (party.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "Your party is currently busy and cannot fight"); + break; + } + if (party.getMembers().size() == 0) { + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + break; + } + player.closeInventory(); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getFfaPartyInventory()); + break; + } + } + } + if (invTitle.contains("unranked queue")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + final String kitName = kit.getName(); + final QueueManager queueManager = this.plugin.getManagerHandler().getQueueManager(); + final Party party2 = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party2 != null) { + if (party2.getSize() != 2) { + player.closeInventory(); + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + return; + } + if (queueManager.isUnrankedPartyQueueEmpty(kitName)) { + player.closeInventory(); + queueManager.addToPartyUnrankedQueue(kitName, player.getUniqueId()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party2, ChatColor.YELLOW + "Your party has been added to the " + ChatColor.GREEN + "Unranked 2v2 " + kitName + ChatColor.YELLOW + " queue!"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + final PracticePlayer partyMember = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(party2.getMembers().get(0)); + partyMember.setCurrentState(PlayerState.QUEUE); + final Player partyPlayer = this.plugin.getServer().getPlayer(partyMember.getUUID()); + partyPlayer.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + partyPlayer.updateInventory(); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + else { + player.closeInventory(); + final UUID targetLeaderUUID = queueManager.getQueuedForPartyUnrankedQueue(kitName); + queueManager.removePartyFromPartyUnrankedQueue(kitName); + final List firstTeam = new ArrayList(); + final List secondTeam = new ArrayList(); + final Party targetParty = this.plugin.getManagerHandler().getPartyManager().getParty(targetLeaderUUID); + firstTeam.add(player.getUniqueId()); + firstTeam.add(party2.getMembers().get(0)); + secondTeam.add(targetLeaderUUID); + secondTeam.add(targetParty.getMembers().get(0)); + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, false, player.getUniqueId(), targetLeaderUUID, firstTeam, secondTeam, false)); + } + } + else if (queueManager.isUnrankedQueueEmpty(kitName)) { + player.closeInventory(); + queueManager.addToUnrankedQueue(kitName, player.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "You have been added to the " + ChatColor.GOLD + "Unranked " + kitName + ChatColor.YELLOW + " queue."); + practicePlayer.setCurrentState(PlayerState.QUEUE); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + else { + player.closeInventory(); + final UUID queuedUuid = queueManager.getQueuedForUnrankedQueue(kitName); + queueManager.removePlayerFromUnrankedQueue(kitName); + final List firstTeam = new ArrayList(); + final List secondTeam = new ArrayList(); + firstTeam.add(queuedUuid); + secondTeam.add(player.getUniqueId()); + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, false, null, null, firstTeam, secondTeam, false)); + } + } + } + else if (invTitle.contains("ranked queue")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + final String kitName = kit.getName(); + final QueueManager queueManager = this.plugin.getManagerHandler().getQueueManager(); + final Party party2 = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party2 != null) { + if (party2.getSize() != 2) { + player.closeInventory(); + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + return; + } + Map partyEloMap = practicePlayer.getPartyEloMap().get(party2.getMembers().get(0)); + final PracticePlayer memberPracPlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(party2.getMembers().get(0)); + if (partyEloMap == null) { + practicePlayer.addPartyElo(party2.getMembers().get(0), kitName, 1000); + memberPracPlayer.addPartyElo(practicePlayer.getUUID(), kitName, 1000); + partyEloMap = practicePlayer.getPartyEloMap().get(party2.getMembers().get(0)); + } + final int partyElo = partyEloMap.get(kitName); + if (queueManager.isRankedPartyQueueEmpty(kitName)) { + player.closeInventory(); + queueManager.addToPartyRankedQueue(kitName, player.getUniqueId()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party2, ChatColor.YELLOW + "Your party has been added to the " + ChatColor.GREEN + "Ranked 2v2 " + kitName + ChatColor.YELLOW + " queue with " + ChatColor.GREEN + partyElo + " elo" + ChatColor.YELLOW + "!"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + final PracticePlayer partyMember2 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(party2.getMembers().get(0)); + partyMember2.setCurrentState(PlayerState.QUEUE); + final Player partyPlayer2 = this.plugin.getServer().getPlayer(partyMember2.getUUID()); + partyPlayer2.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + partyPlayer2.updateInventory(); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + else { + player.closeInventory(); + for (final UUID queuedUuid2 : queueManager.getQueuedForPartyRankedQueue(kitName)) { + final PracticePlayer queuedPracticePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(queuedUuid2); + final Party queuedParty = this.plugin.getManagerHandler().getPartyManager().getParty(queuedUuid2); + final Map queuedPartyEloMap = queuedPracticePlayer.getPartyEloMap().get(queuedParty.getMembers().get(0)); + final int queuedPartyElo = queuedPartyEloMap.get(kitName); + final int diff = Math.abs(queuedPartyElo - partyElo); + if (diff < 325) { + this.plugin.getManagerHandler().getQueueManager().removePlayerFromPartyRankedQueue(kitName, queuedUuid2); + final List firstTeam2 = new ArrayList(); + final List secondTeam2 = new ArrayList(); + firstTeam2.add(player.getUniqueId()); + firstTeam2.add(party2.getMembers().get(0)); + secondTeam2.add(queuedUuid2); + secondTeam2.add(queuedParty.getMembers().get(0)); + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, true, player.getUniqueId(), queuedUuid2, firstTeam2, secondTeam2, false)); + return; + } + } + queueManager.addToPartyRankedQueue(kitName, player.getUniqueId()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party2, ChatColor.YELLOW + "Party has been added to the " + ChatColor.GOLD + "Ranked " + kitName + ChatColor.YELLOW + " queue. " + ChatColor.GREEN + "[" + partyElo + "]"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + final PracticePlayer partyMember2 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(party2.getMembers().get(0)); + partyMember2.setCurrentState(PlayerState.QUEUE); + final Player partyPlayer2 = this.plugin.getServer().getPlayer(partyMember2.getUUID()); + partyPlayer2.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + partyPlayer2.updateInventory(); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + } + else { + final int playerElo = practicePlayer.getEloMap().get(kitName); + if (queueManager.isRankedQueueEmpty(kitName)) { + player.closeInventory(); + queueManager.addToRankedQueue(kitName, player.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "You have been added to the " + ChatColor.GOLD + "Ranked " + kitName + ChatColor.YELLOW + " queue. " + ChatColor.GREEN + "[" + playerElo + "]"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + else { + player.closeInventory(); + for (final UUID queuedUuid3 : queueManager.getQueuedForRankedQueue(kitName)) { + final PracticePlayer queuedPracticePlayer2 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(queuedUuid3); + final int queuedElo = queuedPracticePlayer2.getEloMap().get(kitName); + final int diff2 = Math.abs(queuedElo - playerElo); + if (diff2 < 325) { + this.plugin.getManagerHandler().getQueueManager().removePlayerFromRankedQueue(kitName, queuedUuid3); + final List firstTeam3 = new ArrayList(); + final List secondTeam3 = new ArrayList(); + firstTeam3.add(queuedUuid3); + secondTeam3.add(player.getUniqueId()); + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, true, null, null, firstTeam3, secondTeam3, false)); + return; + } + } + queueManager.addToRankedQueue(kitName, player.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "You have been added to the " + ChatColor.GOLD + "Ranked " + kitName + ChatColor.YELLOW + " queue. " + ChatColor.GREEN + "[" + playerElo + "]"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + } + } + } + else if (invTitle.contains("premium queue")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + if (practicePlayer.getPremiumTokens() <= 0) { + player.closeInventory(); + player.sendMessage(ChatColor.RED + "You don't have enough Premium Matches."); + player.sendMessage(ChatColor.RED + "You currently have 0 matches."); + return; + } + final String kitName = kit.getName(); + final QueueManager queueManager = this.plugin.getManagerHandler().getQueueManager(); + final int playerElo2 = practicePlayer.getPremiumEloMap().get(kitName); + if (queueManager.isPremiumQueueEmpty(kitName)) { + player.closeInventory(); + queueManager.addToPremiumQueue(kitName, player.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "You have been added to the " + ChatColor.GOLD + "Premium " + kitName + ChatColor.YELLOW + " queue. " + ChatColor.GREEN + "[" + playerElo2 + "]"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + else { + player.closeInventory(); + for (final UUID queuedUuid4 : queueManager.getQueuedForPremiumQueue(kitName)) { + final PracticePlayer queuedPracticePlayer3 = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(queuedUuid4); + final int queuedElo2 = queuedPracticePlayer3.getPremiumEloMap().get(kitName); + final int diff3 = Math.abs(queuedElo2 - playerElo2); + if (diff3 < 325) { + this.plugin.getManagerHandler().getQueueManager().removePlayerFromPremiumQueue(kitName, queuedUuid4); + final List firstTeam4 = new ArrayList(); + final List secondTeam4 = new ArrayList(); + firstTeam4.add(queuedUuid4); + secondTeam4.add(player.getUniqueId()); + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, false, null, null, firstTeam4, secondTeam4, true)); + practicePlayer.setPremiumTokens(practicePlayer.getPremiumTokens() - 1); + player.sendMessage(ChatColor.RED + "(*) You currently have " + ChatColor.BOLD + practicePlayer.getPremiumTokens() + ChatColor.RED + " tokens left."); + queuedPracticePlayer3.setPremiumTokens(queuedPracticePlayer3.getPremiumTokens() - 1); + Bukkit.getPlayer(queuedUuid4).sendMessage(ChatColor.RED + "(*) You currently have " + ChatColor.BOLD + queuedPracticePlayer3.getPremiumTokens() + ChatColor.RED + " tokens left."); + return; + } + } + queueManager.addToPremiumQueue(kitName, player.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "You have been added to the " + ChatColor.GOLD + "Premium " + kitName + ChatColor.YELLOW + " queue. " + ChatColor.GREEN + "[" + playerElo2 + "]"); + practicePlayer.setCurrentState(PlayerState.QUEUE); + player.getInventory().setContents(this.plugin.getManagerHandler().getItemManager().getQueueItems()); + player.updateInventory(); + } + } + } + else if (invTitle.contains("kit editor")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + this.plugin.getManagerHandler().getEditorManager().addEditingKit(player.getUniqueId(), kit); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditKitKitsInventory(player.getUniqueId())); + } + } + else if (invTitle.contains("send request")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + final String kitName = kit.getName(); + final Player target = this.plugin.getServer().getPlayer(this.plugin.getManagerHandler().getInventoryManager().getSelectingDuelPlayerUUID(player.getUniqueId())); + if (target == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + player.closeInventory(); + return; + } + final PracticePlayer practiceTarget = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(target); + player.closeInventory(); + this.plugin.getManagerHandler().getInventoryManager().removeSelectingDuel(player.getUniqueId()); + if (practiceTarget.getCurrentState() != PlayerState.LOBBY) { + player.sendMessage(Messages.PLAYER_BUSY); + return; + } + final Party party3 = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + final Party targetParty2 = this.plugin.getManagerHandler().getPartyManager().getParty(target.getUniqueId()); + player.sendMessage(ChatColor.YELLOW + "Sent a duel request to " + ChatColor.GREEN + target.getName() + ((targetParty2 != null) ? (ChatColor.YELLOW + "'s party " + ChatColor.GREEN + "(" + (targetParty2.getMembers().size() + 1) + ")") : "") + ChatColor.YELLOW + " with the kit " + ChatColor.GREEN + kitName + ChatColor.YELLOW + "!"); + this.plugin.getManagerHandler().getRequestManager().addDuelRequest(target, player, new DuelRequest(kitName)); + final UtilActionMessage actionMessage = new UtilActionMessage(); + actionMessage.addText(ChatColor.GREEN + player.getName() + ((party3 != null) ? (ChatColor.YELLOW + "'s party " + ChatColor.GREEN + "(" + (party3.getMembers().size() + 1) + ")") : "") + ChatColor.YELLOW + " has requested a duel with the kit " + ChatColor.GOLD + kitName + ChatColor.YELLOW + "."); + actionMessage.addText(" " + ChatColor.RED + "[Click here to accept]").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/accept " + player.getName()); + actionMessage.sendToPlayer(target); + } + } + else if (invTitle.contains("split fights")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + final Party party4 = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + player.closeInventory(); + final List firstTeam5 = new ArrayList(); + final List secondTeam5 = new ArrayList(); + firstTeam5.add(party4.getLeader()); + for (final UUID member : party4.getMembers()) { + if (firstTeam5.size() == secondTeam5.size()) { + firstTeam5.add(member); + } + else { + if (firstTeam5.size() <= secondTeam5.size()) { + continue; + } + secondTeam5.add(member); + } + } + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, false, party4.getLeader(), party4.getLeader(), firstTeam5, secondTeam5, false)); + } + } + else if (invTitle.contains("tournament size")) { + e.setCancelled(true); + if (itemClicked.getType() != Material.NETHER_STAR) { + player.closeInventory(); + return; + } + final boolean isPlayerTournament = ChatColor.stripColor(itemClicked.getItemMeta().getLore().get(0).split(": ")[1]).equalsIgnoreCase("Player"); + final Kit kit2 = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getLore().get(1).split(": ")[1])); + final int size = Integer.parseInt(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName().split("v")[0])); + if (!player.hasPermission("host.event." + size)) { + player.sendMessage(ChatColor.RED + "You don't have permissions to host (" + size + "v" + size + ")"); + player.closeInventory(); + return; + } + if (isPlayerTournament && Tournament.getTournaments().size() >= 1) { + player.sendMessage(ChatColor.RED + "There is a tournament currently running."); + player.closeInventory(); + return; + } + if (!isPlayerTournament) { + Tournament.forceEndPlayerTournaments(); + } + final Tournament tournament = new Tournament(size, kit2, isPlayerTournament); + if (isPlayerTournament) { + practicePlayer.setHostCooldown(System.currentTimeMillis() + 3600000L); + HostCommand.getRunningTournaments().put(player.getUniqueId(), tournament); + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.RED.toString() + ChatColor.BOLD + (isPlayerTournament ? "PLAYER " : "") + "TOURNAMENT (" + tournament.getMaximumPerTeam() + "v" + tournament.getMaximumPerTeam() + ") IS STARTING SOON."); + final UtilActionMessage actionMessage2 = new UtilActionMessage(); + actionMessage2.addText(ChatColor.YELLOW + "Join the tournament using the command /join or [Click Here]").addHoverText(ChatColor.GRAY + "Click to join the tournament").setClickEvent(UtilActionMessage.ClickableType.RunCommand, "/join " + Tournament.getTournaments().size()); + for (final Player online : PlayerUtility.getOnlinePlayers()) { + actionMessage2.sendToPlayer(online); + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + player.closeInventory(); + } + else if (invTitle.contains("available tournaments")) { + e.setCancelled(true); + if (itemClicked.getType() != Material.NETHER_STAR) { + player.closeInventory(); + return; + } + final Tournament tournament2 = Tournament.getTournaments().get(e.getSlot()); + if (tournament2 == null) { + player.sendMessage(ChatColor.RED + "That tournament doesn't exist."); + player.closeInventory(); + return; + } + for (final Tournament tourney : Tournament.getTournaments()) { + if (tourney.isInTournament(player)) { + player.sendMessage(ChatColor.RED + "You are currently in another tournament."); + player.closeInventory(); + return; + } + } + if (tournament2.isStarted()) { + player.sendMessage(ChatColor.RED + "Sorry! The tournament already started."); + return; + } + if (tournament2.getTotalPlayersInTournament() == tournament2.getPlayersLimit()) { + player.sendMessage(ChatColor.RED + "Sorry! The tournament is already full."); + player.closeInventory(); + return; + } + if (tournament2.isInTournament(player)) { + player.sendMessage(ChatColor.RED + "You are already in the tournament."); + player.closeInventory(); + return; + } + if (tournament2.getMaximumPerTeam() == 1) { + final TournamentTeam tournamentTeam = new TournamentTeam(); + tournamentTeam.setPlayers(Collections.singletonList(player.getUniqueId())); + tournament2.getTeams().add(tournamentTeam); + tournament2.sendMessage(ChatColor.YELLOW + player.getName() + " has joined the tournament. (" + tournament2.getTotalPlayersInTournament() + "/" + tournament2.getPlayersLimit() + ")"); + this.plugin.getServer().getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.TOURNAMENT)); + player.closeInventory(); + } + else if (tournament2.getMaximumPerTeam() >= 2) { + final Party party5 = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party5 == null) { + player.sendMessage(ChatColor.RED + "You must be in a party to join this tournament."); + player.closeInventory(); + return; + } + if (party5.getLeader() != player.getUniqueId()) { + player.sendMessage(ChatColor.RED + "Only the leader can join the tournament."); + player.closeInventory(); + return; + } + if (party5.getSize() != tournament2.getMaximumPerTeam()) { + player.sendMessage(ChatColor.RED + "The party must have only " + tournament2.getMaximumPerTeam() + " players."); + player.closeInventory(); + return; + } + final TournamentTeam tournamentTeam2 = new TournamentTeam(); + tournamentTeam2.setPlayers(party5.getAllMembersOnline()); + tournament2.getTeams().add(tournamentTeam2); + tournament2.sendMessage(ChatColor.YELLOW + player.getName() + "'s Party has joined the tournament. (" + tournament2.getTotalPlayersInTournament() + "/" + tournament2.getPlayersLimit() + ")"); + this.plugin.getServer().getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.TOURNAMENT)); + player.closeInventory(); + } + } + else if (invTitle.contains("party ffa")) { + e.setCancelled(true); + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKitMap().get(ChatColor.stripColor(itemClicked.getItemMeta().getDisplayName())); + if (kit != null) { + player.closeInventory(); + final Party party4 = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + final List members = new ArrayList(party4.getMembers()); + members.add(player.getUniqueId()); + this.plugin.getServer().getPluginManager().callEvent((Event)new DuelPreCreateEvent(kit, party4.getLeader(), members)); + } + } + else if (invTitle.contains("fight other parties") && itemClicked.getType() == Material.SKULL_ITEM) { + e.setCancelled(true); + final String[] itemName = UtilString.splitString(itemClicked.getItemMeta().getDisplayName()); + itemName[0] = ChatColor.stripColor(itemName[0]); + player.closeInventory(); + this.plugin.getServer().dispatchCommand((CommandSender)player, "duel " + itemName[0]); + } + else if (invTitle.toLowerCase().contains("kit layout")) { + final String kitName2 = this.plugin.getManagerHandler().getEditorManager().getPlayerEditingKit(player.getUniqueId()); + final Map kitMap = practicePlayer.getKitMap().get(kitName2); + e.setCancelled(true); + if (!itemClicked.hasItemMeta() || !itemClicked.getItemMeta().hasDisplayName()) { + return; + } + if (itemClicked.getType() == Material.CHEST && e.getSlot() < 9) { + final int kitIndex = e.getSlot(); + final ItemStack loadedKit = UtilItem.createItem(Material.ENDER_CHEST, 1, (short)0, ChatColor.YELLOW + "KIT: " + ChatColor.GREEN + kitName2 + " #" + kitIndex); + final ItemStack load = UtilItem.createItem(Material.BOOK, 1, (short)0, ChatColor.YELLOW + "Load/Edit Kit " + ChatColor.GREEN + kitName2 + " #" + kitIndex); + final ItemStack rename = UtilItem.createItem(Material.NAME_TAG, 1, (short)0, ChatColor.YELLOW + "Rename Kit " + ChatColor.GREEN + kitName2 + " #" + kitIndex); + final ItemStack delete = UtilItem.createItem(Material.FLINT, 1, (short)0, ChatColor.YELLOW + "Delete Kit " + ChatColor.GREEN + kitName2 + " #" + kitIndex); + final PlayerKit playerKit = new PlayerKit(kitName2, kitIndex, ChatColor.GREEN + "KIT: " + kitName2 + " #" + kitIndex, new ItemStack[0], new ItemStack[0]); + playerKit.setMainContents(this.plugin.getManagerHandler().getKitManager().getKit(kitName2).getMainContents()); + playerKit.setArmorContents(this.plugin.getManagerHandler().getKitManager().getKit(kitName2).getArmorContents()); + practicePlayer.addKit(kitName2, kitIndex, playerKit); + player.sendMessage(ChatColor.GREEN + "Successfully created Kit: " + ChatColor.GREEN + "#" + kitIndex); + inventory.setItem(e.getSlot(), loadedKit); + inventory.setItem(e.getSlot() + 9, load); + inventory.setItem(e.getSlot() + 18, rename); + inventory.setItem(e.getSlot() + 27, delete); + } + else if (itemClicked.getType() == Material.BOOK && e.getSlot() > 9 && e.getSlot() < 18) { + final int kitIndex = e.getSlot() - 9; + if (kitMap != null && kitMap.containsKey(kitIndex)) { + practicePlayer.setCurrentState(PlayerState.EDITING); + UtilPlayer.clear(player); + if (kitMap.get(kitIndex).getMainContents().length > 0) { + player.getInventory().setContents(kitMap.get(kitIndex).getMainContents()); + player.getInventory().setArmorContents(kitMap.get(kitIndex).getArmorContents()); + } + else { + player.getInventory().setContents(this.plugin.getManagerHandler().getKitManager().getKit(kitName2).getMainContents()); + player.getInventory().setArmorContents(kitMap.get(kitIndex).getArmorContents()); + } + player.updateInventory(); + this.plugin.getManagerHandler().getKitManager().openEditiKitsInventory(player, this.plugin.getManagerHandler().getKitManager().getKit(kitName2), kitMap.get(kitIndex)); + } + } + else if (itemClicked.getType() == Material.NAME_TAG && e.getSlot() > 18 && e.getSlot() < 27) { + final int kitIndex = e.getSlot() - 18; + if (kitMap != null && kitMap.containsKey(kitIndex)) { + this.plugin.getManagerHandler().getEditorManager().addRenamingKit(player.getUniqueId(), kitMap.get(kitIndex)); + player.closeInventory(); + player.sendMessage(ChatColor.GREEN + "Enter the name you want this kit to be."); + } + } + else if (itemClicked.getType() == Material.FLINT && e.getSlot() > 27 && e.getSlot() < 36) { + final int kitIndex = e.getSlot() - 27; + if (kitMap != null && kitMap.containsKey(kitIndex)) { + this.plugin.getManagerHandler().getEditorManager().removeRenamingKit(player.getUniqueId()); + kitMap.remove(kitIndex); + player.sendMessage(ChatColor.GREEN + "Successfully removed Kit: " + ChatColor.GREEN + "#" + kitIndex); + final ItemStack save = UtilItem.createItem(Material.CHEST, 1, (short)0, ChatColor.YELLOW + "Create Kit " + ChatColor.GREEN + kitName2 + " #" + kitIndex); + inventory.setItem(kitIndex, save); + inventory.setItem(e.getSlot(), (ItemStack)null); + inventory.setItem(e.getSlot() - 9, (ItemStack)null); + inventory.setItem(e.getSlot() - 18, (ItemStack)null); + } + } + else if (itemClicked.getType() == Material.STAINED_GLASS_PANE) { + this.plugin.getManagerHandler().getEditorManager().removeEditingKit(player.getUniqueId()); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditorInventory()); + } + } + } + else if (practicePlayer.getCurrentState() == PlayerState.EDITING) { + if (invTitle.toLowerCase().contains("editing kit")) { + if (e.getClickedInventory() == null) { + if (e.getCursor() != null) { + e.setCursor((ItemStack)null); + player.updateInventory(); + } + return; + } + if (e.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY && e.getView().getBottomInventory() != null && e.getView().getBottomInventory().equals(e.getClickedInventory())) { + e.setCancelled(true); + return; + } + if (e.getView().getTopInventory() == null || !e.getClickedInventory().equals(e.getView().getTopInventory())) { + return; + } + e.setCancelled(true); + final String[] parse = ChatColor.stripColor(e.getView().getTopInventory().getItem(0).getItemMeta().getDisplayName()).split(" "); + final String kitName = parse[3].replace("(", ""); + final int id = Integer.parseInt(parse[4].replace(")", "").replace("#", "")); + final Map kitMap2 = practicePlayer.getKitMap().get(kitName); + if (itemClicked.getType() == Material.STAINED_CLAY && itemClicked.getDurability() == 13) { + if (kitMap2 != null && kitMap2.containsKey(id)) { + kitMap2.get(id).setMainContents(e.getView().getBottomInventory().getContents()); + kitMap2.get(id).setArmorContents(reverse(new ItemStack[] { e.getView().getTopInventory().getItem(18), e.getView().getTopInventory().getItem(27), e.getView().getTopInventory().getItem(36), e.getView().getTopInventory().getItem(45) })); + player.sendMessage(ChatColor.GREEN + "Successfully saved Kit: " + ChatColor.GREEN + "#" + id); + player.closeInventory(); + } + } + else if (itemClicked.getType() == Material.STAINED_CLAY && itemClicked.getDurability() == 14) { + player.closeInventory(); + } + else if (itemClicked.getType() == Material.STAINED_CLAY && itemClicked.getDurability() == 4) { + e.getView().getBottomInventory().clear(); + } + else if (itemClicked.getType() == Material.STAINED_CLAY && itemClicked.getDurability() == 0) { + player.getInventory().setContents(this.plugin.getManagerHandler().getKitManager().getKit(kitName).getMainContents()); + } + else if (itemClicked.getType() == Material.BUCKET) { + if (e.getCursor() != null) { + e.setCursor((ItemStack)null); + player.updateInventory(); + } + } + else if (itemClicked.getType() == Material.POTION && itemClicked.getDurability() == 16421 && itemClicked.hasItemMeta() && itemClicked.getItemMeta().hasDisplayName()) { + while (e.getView().getBottomInventory().firstEmpty() != -1) { + e.getView().getBottomInventory().addItem(new ItemStack[] { new ItemStack(Material.POTION, 1, (short)16421) }); + } + } + else { + if (itemClicked.getType() == Material.AIR || itemClicked.getType() == Material.BOOK || itemClicked.getType() == Material.STAINED_GLASS_PANE || (itemClicked.hasItemMeta() && itemClicked.getItemMeta().hasLore() && itemClicked.getItemMeta().getLore().get(1).contains("equipped"))) { + return; + } + if (e.getClick().isShiftClick()) { + if (e.getView().getBottomInventory().firstEmpty() != -1) { + e.getView().getBottomInventory().addItem(new ItemStack[] { itemClicked }); + } + } + else if (e.getClick() == ClickType.NUMBER_KEY) { + if (e.getView().getBottomInventory().firstEmpty() != -1) { + e.getView().getBottomInventory().setItem(e.getHotbarButton(), itemClicked); + } + } + else { + e.setCursor(itemClicked); + } + } + } + } + else if (practicePlayer.getCurrentState() == PlayerState.SPECTATING) { + if (invTitle.toLowerCase().contains("spectator menu")) { + e.setCancelled(true); + this.plugin.getManagerHandler().getInventoryManager().getSpectatorInventory().executeClickEvent(this.plugin, player, e.getSlot(), e); + } + } + else if (practicePlayer.getCurrentState() == PlayerState.WAITING || practicePlayer.getCurrentState() == PlayerState.FIGHTING) { + if (itemClicked != null && itemClicked.getType() == Material.BOOK) { + e.setCancelled(true); + } + if (e.getClick() == ClickType.NUMBER_KEY && player.getInventory().getItem(e.getHotbarButton()) != null && player.getInventory().getItem(e.getHotbarButton()).getType() == Material.BOOK) { + e.setCancelled(true); + } + } + } + + @EventHandler + public void onInventoryDrag(final InventoryDragEvent event) { + if (this.isTopInventory(event) && event.getView().getTopInventory().getTitle().toLowerCase().contains("editing kit")) { + event.setCancelled(true); + } + } + + @EventHandler + public void onInvClose(final InventoryCloseEvent e) { + if (e.getInventory().getTitle().toLowerCase().contains("send request")) { + this.plugin.getManagerHandler().getInventoryManager().removeSelectingDuel(e.getPlayer().getUniqueId()); + } + if (e.getInventory().getTitle().toLowerCase().contains("kit layout") && !this.plugin.getManagerHandler().getEditorManager().getRenamingKit().containsKey(e.getPlayer().getUniqueId())) { + this.plugin.getManagerHandler().getEditorManager().removeEditingKit(e.getPlayer().getUniqueId()); + } + if (e.getInventory().getTitle().toLowerCase().contains("editing kit")) { + this.plugin.getManagerHandler().getEditorManager().removeEditingKit(e.getPlayer().getUniqueId()); + this.plugin.getManagerHandler().getPracticePlayerManager().returnItems((Player)e.getPlayer()); + } + } + + public static ItemStack[] reverse(final ItemStack[] x) { + final ItemStack[] d = new ItemStack[x.length]; + for (int i = x.length - 1; i >= 0; --i) { + d[x.length - i - 1] = x[i]; + } + return d; + } + + private boolean isTopInventory(final InventoryDragEvent event) { + final InventoryView view = event.getView(); + if (event.getView().getTopInventory() == null) { + return false; + } + final Set> items = event.getNewItems().entrySet(); + boolean isInventory = false; + for (final Map.Entry item : items) { + if (item.getKey() < event.getView().getTopInventory().getSize()) { + isInventory = true; + break; + } + } + return isInventory; + } +} diff --git a/src/main/java/us/centile/practice/listeners/PlayerListener.java b/src/main/java/us/centile/practice/listeners/PlayerListener.java new file mode 100644 index 0000000..7a02537 --- /dev/null +++ b/src/main/java/us/centile/practice/listeners/PlayerListener.java @@ -0,0 +1,625 @@ +package us.centile.practice.listeners; + +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.inventory.ItemStack; +import us.centile.practice.*; +import java.text.*; +import org.bukkit.event.*; +import org.bukkit.potion.*; +import org.bukkit.entity.*; +import us.centile.practice.duel.*; +import org.bukkit.*; +import us.centile.practice.runnables.*; +import org.bukkit.plugin.*; +import java.util.*; +import org.bukkit.inventory.*; +import org.bukkit.scheduler.*; +import org.bukkit.event.block.*; +import us.centile.practice.tournament.*; +import org.bukkit.command.*; +import us.centile.practice.party.*; +import us.centile.practice.player.*; +import org.bukkit.block.*; +import us.centile.practice.kit.*; +import org.bukkit.event.entity.*; +import org.bukkit.craftbukkit.v1_8_R3.entity.*; +import us.centile.practice.util.*; +import net.minecraft.server.v1_8_R3.*; +import org.bukkit.event.player.*; +import java.lang.reflect.*; + +public class PlayerListener implements Listener +{ + private nPractice plugin; + private static Map lastPearl; + private DecimalFormat formatter; + + public PlayerListener(final nPractice plugin) { + this.formatter = new DecimalFormat("0.0"); + PlayerListener.lastPearl = new HashMap(); + this.plugin = plugin; + } + + @EventHandler(priority = EventPriority.MONITOR) + public void onPlayerJoin(final PlayerJoinEvent e) { + this.plugin.getManagerHandler().getPracticePlayerManager().createPracticePlayer(e.getPlayer()); + } + + @EventHandler + public void onPlayerItemConsume(final PlayerItemConsumeEvent event) { + final ItemStack itemStack = event.getItem(); + if (itemStack.getType() == Material.GOLDEN_APPLE && ChatColor.stripColor(UtilItem.getTitle(itemStack)).equalsIgnoreCase("Golden Head")) { + final PotionEffect effect = new PotionEffect(PotionEffectType.REGENERATION, 200, 1); + UtilPlayer.addConcideringLevel(event.getPlayer(), effect); + } + } + + @EventHandler(ignoreCancelled = true) + public void onBuildUHCArrow(final EntityDamageByEntityEvent event) { + if (event.getDamager() instanceof Arrow) { + final Projectile projectile = (Projectile)event.getDamager(); + if (projectile.getShooter() instanceof Player && event.getEntity() instanceof Player) { + final Player player = (Player)projectile.getShooter(); + final Duel duel = this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(event.getEntity().getUniqueId()); + if (duel != null && this.plugin.getManagerHandler().getKitManager().getKit(duel.getKitName()).isBuilduhc()) { + final Player target = (Player)event.getEntity(); + player.sendMessage(ChatColor.GREEN + target.getName() + ChatColor.YELLOW + " now has " + ChatColor.LIGHT_PURPLE + this.formatter.format((target.getHealth() - event.getFinalDamage()) / 2.0) + "/10" + ChatColor.YELLOW + " health."); + } + } + } + } + + @EventHandler(ignoreCancelled = true) + public void onEntityDamage(final EntityDamageEvent event) { + if (event.getCause() == EntityDamageEvent.DamageCause.VOID) { + event.setDamage(100.0); + } + } + + @EventHandler + public void onPlayerRegainHealth(final EntityRegainHealthEvent event) { + if (event.getRegainReason() == EntityRegainHealthEvent.RegainReason.SATIATED && event.getEntity() instanceof Player) { + final Duel duel = this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(event.getEntity().getUniqueId()); + if (duel != null && this.plugin.getManagerHandler().getKitManager().getKit(duel.getKitName()).isBuilduhc()) { + event.setCancelled(true); + } + } + } + + @EventHandler + public void onPlayerQuit(final PlayerQuitEvent e) { + final Player player = e.getPlayer(); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer != null) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party != null) { + if (party.getLeader().equals(player.getUniqueId())) { + this.plugin.getManagerHandler().getPartyManager().destroyParty(player.getUniqueId()); + for (final UUID member : party.getMembers()) { + final Player pLayer = this.plugin.getServer().getPlayer(member); + pLayer.sendMessage(ChatColor.YELLOW + "Your party leader has left, so the party has been disbanded!"); + final PracticePlayer ppLayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(pLayer); + if (ppLayer.getCurrentState() == PlayerState.LOBBY) { + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(pLayer); + } + } + this.plugin.getManagerHandler().getInventoryManager().delParty(party); + } + else { + this.plugin.getManagerHandler().getPartyManager().leaveParty(player.getUniqueId()); + this.plugin.getManagerHandler().getInventoryManager().updateParty(party); + } + } + switch (practicePlayer.getCurrentState()) { + case WAITING: + case FIGHTING: { + this.plugin.getManagerHandler().getDuelManager().removePlayerFromDuel(e.getPlayer()); + break; + } + case QUEUE: { + if (party == null) { + this.plugin.getManagerHandler().getQueueManager().unqueueSingleQueue(e.getPlayer().getUniqueId()); + break; + } + for (final UUID uuid : party.getMembers()) { + final Player memberPlayer = this.plugin.getServer().getPlayer(uuid); + if (memberPlayer == null) { + continue; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(memberPlayer); + } + this.plugin.getManagerHandler().getQueueManager().unqueuePartyQueue(party.getLeader()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party, ChatColor.YELLOW + "Your party has left the queue"); + final Player leaderPlayer = this.plugin.getServer().getPlayer(party.getLeader()); + if (leaderPlayer != null) { + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(leaderPlayer); + break; + } + break; + } + case EDITING: { + this.plugin.getManagerHandler().getEditorManager().removeEditingKit(e.getPlayer().getUniqueId()); + break; + } + case SPECTATING: { + this.plugin.getManagerHandler().getSpectatorManager().removeSpectatorMode(player); + break; + } + } + } + Bukkit.getServer().getScheduler().runTaskAsynchronously(nPractice.getInstance(), new RemovePlayerTask(e.getPlayer())); + this.plugin.getManagerHandler().getPracticePlayerManager().removePracticePlayer(e.getPlayer()); + } + + @EventHandler + public void onPlayerInteractSoup(final PlayerInteractEvent e) { + final Player p = e.getPlayer(); + if (!p.isDead() && p.getItemInHand().getType() == Material.MUSHROOM_SOUP && p.getHealth() < 19.0) { + final double newHealth = (p.getHealth() + 7.0 > 20.0) ? 20.0 : (p.getHealth() + 7.0); + p.setHealth(newHealth); + p.getItemInHand().setType(Material.BOWL); + } + } + + @EventHandler + public void onPlayerInteractEntityEvent(final PlayerInteractEntityEvent e) { + if (e.getRightClicked() instanceof Player && e.getPlayer().getItemInHand().getType() == Material.COMPASS) { + e.getPlayer().openInventory(((Player)e.getRightClicked()).getInventory()); + } + } + + @EventHandler + public void onPlayerPreCommand(final PlayerCommandPreprocessEvent e) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(e.getPlayer()); + if (practicePlayer.getCurrentState() == PlayerState.LOADING) { + e.getPlayer().sendMessage(ChatColor.RED + "\u00c2�l(LOADING) \u00c2�7Your data is currently loading..."); + e.setCancelled(true); + } + else if (practicePlayer.getCurrentState() == PlayerState.EDITING) { + e.getPlayer().sendMessage(ChatColor.RED + "You can't execute commands while editing a kit."); + e.setCancelled(true); + } + } + + @EventHandler + public void onPlayerInteract(final PlayerJoinEvent e) { + e.setJoinMessage(null); + new BukkitRunnable() { + public void run() { + final PracticePlayer practicePlayer = PlayerListener.this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(e.getPlayer()); + PlayerListener.this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(e.getPlayer()); + } + }.runTaskLater(this.plugin, 20L); + } + + @EventHandler + public void onPlayerInteract(final PlayerQuitEvent e) { + e.setQuitMessage(null); + } + + @EventHandler + public void onPlayerInteract(final PlayerDropItemEvent e) { + if (e.getItemDrop().getItemStack().getType() == Material.DIAMOND_SWORD) { + e.setCancelled(true); + } + } + + @EventHandler + public void onPlayerInteract(final ProjectileLaunchEvent e) { + if (e.getEntity().getShooter() instanceof Player) { + final Player player = (Player)e.getEntity().getShooter(); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + practicePlayer.getProjectileQueue().add(e.getEntity()); + } + } + + @EventHandler + public void onPlayerInteract(final PlayerInteractEvent e) { + if (e.getAction() == Action.RIGHT_CLICK_BLOCK || e.getAction() == Action.RIGHT_CLICK_AIR) { + final Player player = e.getPlayer(); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + final ItemStack interactedItem = e.getItem(); + final Block interactedBlock = e.getClickedBlock(); + if (practicePlayer.getCurrentState() == PlayerState.LOADING) { + e.getPlayer().sendMessage(ChatColor.RED + "\u00c2�l(LOADING) \u00c2�7Your data is currently loading..."); + return; + } + if (interactedItem != null) { + if (practicePlayer.getCurrentState() == PlayerState.LOBBY) { + if (Tournament.getTournaments().size() > 0) { + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + player.sendMessage(Messages.CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE); + return; + } + } + } + if (this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()) != null) { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + switch (interactedItem.getType()) { + case SKULL_ITEM: { + this.plugin.getServer().dispatchCommand(player, "party info"); + break; + } + case NETHER_STAR: { + this.plugin.getServer().dispatchCommand(player, "party leave"); + break; + } + case BOOK: { + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditorInventory()); + break; + } + case PAPER: { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + break; + } + if (party.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "Your party is currently busy and cannot fight"); + break; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getPartiesInventory()); + break; + } + case GOLD_AXE: { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + break; + } + if (party.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "Your party is currently busy and cannot fight"); + break; + } + if (party.getMembers().size() == 0) { + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + break; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getPartyEventsInventory()); + break; + } + case IRON_SWORD: { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + break; + } + if (party.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "Your party is currently busy and cannot fight"); + break; + } + if (party.getSize() != 2) { + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + break; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getUnrankedInventory()); + break; + } + case DIAMOND_SWORD: { + if (!party.getLeader().equals(player.getUniqueId())) { + player.sendMessage(ChatColor.RED + "You are not the leader of this party!"); + break; + } + if (party.getPartyState() == PartyState.DUELING) { + player.sendMessage(ChatColor.RED + "Your party is currently busy and cannot fight"); + break; + } + if (party.getSize() != 2) { + player.sendMessage(ChatColor.RED + "There must be at least 2 players in your party to do this."); + break; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getRankedInventory()); + break; + } + } + } + else { + switch (interactedItem.getType()) { + case WATCH: { + player.chat("/settings"); + break; + } + case BLAZE_POWDER: { + player.chat("/duel " + practicePlayer.getLastDuelPlayer()); + break; + } + case IRON_SWORD: { + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getUnrankedInventory()); + break; + } + case DIAMOND_SWORD: { + if (practicePlayer.getUnrankedWins() < 20 && !player.isOp()) { + player.sendMessage(ChatColor.RED + "You must win 20 Unranked Matches to play in Ranked Matches."); + player.sendMessage(ChatColor.RED + "You need (" + (20 - practicePlayer.getUnrankedWins()) + ") more win" + ((practicePlayer.getUnrankedWins() == 19) ? "" : "s") + " to play."); + return; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getRankedInventory()); + break; + } + case GOLD_SWORD: { + if (practicePlayer.getPremiumTokens() <= 0 && !player.hasPermission("practice.premium.bypass")) { + player.sendMessage(ChatColor.RED + "You don't have enough Premium Matches."); + player.sendMessage(ChatColor.RED + "You currently have 0 matches."); + return; + } + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getPremiumInventory()); + break; + } + case BOOK: { + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditorInventory()); + break; + } + case NAME_TAG: { + this.plugin.getServer().dispatchCommand(player, "party create"); + break; + } + case COMPASS: { + this.plugin.getServer().dispatchCommand(player, "spectate"); + break; + } + } + } + } + else if (practicePlayer.getCurrentState() == PlayerState.QUEUE) { + switch (interactedItem.getType()) { + case REDSTONE: { + final Party party = this.plugin.getManagerHandler().getPartyManager().getParty(player.getUniqueId()); + if (party != null) { + for (final UUID uuid : party.getMembers()) { + final Player memberPlayer = this.plugin.getServer().getPlayer(uuid); + if (memberPlayer == null) { + continue; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(memberPlayer); + } + this.plugin.getManagerHandler().getQueueManager().unqueuePartyQueue(party.getLeader()); + this.plugin.getManagerHandler().getPartyManager().notifyParty(party, ChatColor.YELLOW + "Your party has left the queue"); + final Player leaderPlayer = this.plugin.getServer().getPlayer(party.getLeader()); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(leaderPlayer); + break; + } + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + this.plugin.getManagerHandler().getQueueManager().unqueueSingleQueue(player.getUniqueId()); + player.sendMessage(ChatColor.RED + "You have left the queue."); + break; + } + } + } + else if (practicePlayer.getCurrentState() == PlayerState.FIGHTING || practicePlayer.getCurrentState() == PlayerState.WAITING) { + switch (interactedItem.getType()) { + case BOOK: { + final Kit kit = this.plugin.getManagerHandler().getKitManager().getKit(this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(player.getUniqueId()).getKitName()); + final Map playerKitMap = practicePlayer.getKitMap().get(kit.getName()); + for (int i = 0; i < 9; ++i) { + final ItemStack item = player.getInventory().getItem(i); + if (item != null) { + if (item.equals(interactedItem) && i == 0) { + player.getInventory().setContents(kit.getMainContents()); + player.getInventory().setArmorContents(kit.getArmorContents()); + player.updateInventory(); + break; + } + if (item.equals(interactedItem)) { + final PlayerKit playerKit = playerKitMap.get(i - 1); + if (playerKit != null) { + player.getInventory().setContents(playerKit.getMainContents()); + player.getInventory().setArmorContents(playerKit.getArmorContents()); + player.updateInventory(); + break; + } + break; + } + } + } + break; + } + case ENDER_PEARL: { + if (practicePlayer.getCurrentState() != PlayerState.FIGHTING) { + player.sendMessage(ChatColor.RED + "You can't throw enderpearls in your current state!"); + e.setCancelled(true); + break; + } + final long now = System.currentTimeMillis(); + final double diff = PlayerListener.lastPearl.containsKey(player.getUniqueId()) ? (now - PlayerListener.lastPearl.get(player.getUniqueId())) : ((double)now); + if (diff < 15000.0) { + player.sendMessage(ChatColor.RED + "Pearl cooldown: " + ChatColor.GRAY + new DecimalFormat(".#").format(15.0 - diff / 1000.0) + " seconds"); + e.setCancelled(true); + player.updateInventory(); + break; + } + PlayerListener.lastPearl.put(player.getUniqueId(), now); + break; + } + case POTION: { + if (interactedItem.getAmount() > 1) { + e.setCancelled(true); + interactedItem.setAmount(1); + player.sendMessage("\u00c2�cYou can't use stacked potions."); + break; + } + break; + } + } + } + else if (practicePlayer.getCurrentState() == PlayerState.SPECTATING) { + switch (interactedItem.getType()) { + case REDSTONE: { + this.plugin.getManagerHandler().getSpectatorManager().removeSpectator(player, true); + break; + } + case NETHER_STAR: { + this.plugin.getManagerHandler().getSpectatorManager().removeSpectatorMode(player); + break; + } + case EMERALD: { + this.plugin.getManagerHandler().getInventoryManager().getSpectatorInventory().openInventory(player); + break; + } + case PAPER: { + if (this.plugin.getManagerHandler().getDuelManager().getUuidIdentifierToDuel().values().size() == 0) { + player.sendMessage(ChatColor.RED + "There are currently no matches to spectate."); + return; + } + final Duel duel = this.plugin.getManagerHandler().getDuelManager().getRandomDuel(); + if (duel == null) { + player.sendMessage(ChatColor.RED + "Please try again, an error occured."); + return; + } + final Player spectator = Bukkit.getPlayer(duel.getFirstTeam().get(0)); + if (spectator == null) { + player.sendMessage(ChatColor.RED + "Please try again, an error occured."); + return; + } + this.plugin.getManagerHandler().getSpectatorManager().addSpectator(player, spectator); + break; + } + } + } + else if (practicePlayer.getCurrentState() == PlayerState.EDITING) { + switch (interactedItem.getType()) { + case POTION: { + e.setCancelled(true); + break; + } + case ENDER_PEARL: { + e.setCancelled(true); + break; + } + } + } + } + if (interactedBlock != null && practicePlayer.getCurrentState() == PlayerState.EDITING) { + switch (interactedBlock.getType()) { + case SIGN_POST: + case WALL_SIGN: + case SIGN: { + this.plugin.getManagerHandler().getEditorManager().removeEditingKit(player.getUniqueId()); + this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(player); + break; + } + case CHEST: { + e.setCancelled(true); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditKitItemsInventory(player.getUniqueId())); + break; + } + case ANVIL: { + e.setCancelled(true); + player.openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditKitKitsInventory(player.getUniqueId())); + break; + } + } + } + } + } + + @EventHandler + public void onPlayerChat(final AsyncPlayerChatEvent e) { + final Iterator recipents = e.getRecipients().iterator(); + while (recipents.hasNext()) { + final PracticePlayer practicePlayer = nPractice.getInstance().getManagerHandler().getPracticePlayerManager().getPracticePlayer(recipents.next()); + if (!practicePlayer.getSettings().isPublicChat()) { + recipents.remove(); + } + } + final PlayerKit kitRenaming = this.plugin.getManagerHandler().getEditorManager().getKitRenaming(e.getPlayer().getUniqueId()); + if (kitRenaming != null) { + kitRenaming.setDisplayName(e.getMessage().replaceAll("&", "\u00c2�")); + e.setCancelled(true); + e.getPlayer().sendMessage(ChatColor.YELLOW + "Successfully set kit " + ChatColor.GREEN + kitRenaming.getKitIndex() + ChatColor.YELLOW + "'s name to " + ChatColor.GREEN + kitRenaming.getDisplayName()); + this.plugin.getManagerHandler().getEditorManager().removeRenamingKit(e.getPlayer().getUniqueId()); + e.getPlayer().openInventory(this.plugin.getManagerHandler().getInventoryManager().getEditKitKitsInventory(e.getPlayer().getUniqueId())); + } + } + + @EventHandler + public void onPlayerDropItem(final PlayerDropItemEvent e) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(e.getPlayer()); + if (practicePlayer.getCurrentState() != PlayerState.FIGHTING && practicePlayer.getCurrentState() != PlayerState.WAITING && practicePlayer.getCurrentState() != PlayerState.BUILDER) { + e.setCancelled(true); + } + if ((practicePlayer.getCurrentState() == PlayerState.FIGHTING || practicePlayer.getCurrentState() == PlayerState.WAITING) && e.getItemDrop().getItemStack().getType() == Material.BOOK) { + e.setCancelled(true); + } + } + + @EventHandler + public void onPlayerPickupItem(final PlayerPickupItemEvent e) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(e.getPlayer()); + if (practicePlayer.getCurrentState() != PlayerState.FIGHTING && practicePlayer.getCurrentState() != PlayerState.WAITING && practicePlayer.getCurrentState() != PlayerState.BUILDER) { + e.setCancelled(true); + } + if ((practicePlayer.getCurrentState() == PlayerState.FIGHTING || practicePlayer.getCurrentState() == PlayerState.WAITING) && e.getItem().getItemStack().getType() == Material.BOOK) { + e.setCancelled(true); + } + } + + @EventHandler + public void onFoodLevelChange(final FoodLevelChangeEvent e) { + if (e.getEntity() instanceof Player) { + final Player player = (Player)e.getEntity(); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer != null && (practicePlayer.getCurrentState() != PlayerState.FIGHTING || player.getInventory().contains(Material.MUSHROOM_SOUP))) { + e.setCancelled(true); + } + } + } + + @EventHandler + public void onPlayerDeath(final PlayerDeathEvent e) { + final Player player = e.getEntity(); + PlayerListener.lastPearl.remove(player.getUniqueId()); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer.getCurrentState() == PlayerState.FIGHTING || practicePlayer.getCurrentState() == PlayerState.WAITING) { + this.plugin.getManagerHandler().getDuelManager().removePlayerFromDuel(player); + } + if (e.getEntity() instanceof CraftPlayer) { + final PacketPlayOutSpawnEntityWeather entityWeather = new PacketPlayOutSpawnEntityWeather(new EntityLightning(((CraftPlayer)e.getEntity()).getHandle().getWorld(), player.getLocation().getX(), player.getLocation().getY(), player.getLocation().getZ(), true)); + final PacketPlayOutNamedSoundEffect soundEffect = new PacketPlayOutNamedSoundEffect("ambient.weather.thunder", player.getLocation().getX(), player.getLocation().getY(), player.getLocation().getZ(), 10000.0f, 63.0f); + final Packet packet = null; + final Packet packet2 = null; + PlayerUtility.getOnlinePlayers().stream().filter(p -> p.canSee(player)).forEach(p -> { + if (p instanceof CraftPlayer) { + ((CraftPlayer) p).getHandle().playerConnection.sendPacket(packet); + ((CraftPlayer) p).getHandle().playerConnection.sendPacket(packet2); + } + return; + }); + this.autoRespawn(e); + } + e.setDeathMessage(null); + } + + @EventHandler + public void onPlayerRespawn(final PlayerRespawnEvent e) { + this.plugin.getServer().getScheduler().runTaskLater(this.plugin, new Runnable() { + @Override + public void run() { + PlayerListener.this.plugin.getManagerHandler().getPracticePlayerManager().sendToLobby(e.getPlayer()); + } + }, 2L); + } + + private void autoRespawn(final PlayerDeathEvent e) { + new BukkitRunnable() { + public void run() { + try { + final Object nmsPlayer = e.getEntity().getClass().getMethod("getHandle", (Class[])new Class[0]).invoke(e.getEntity()); + final Object con = nmsPlayer.getClass().getDeclaredField("playerConnection").get(nmsPlayer); + final Class EntityPlayer = Class.forName(nmsPlayer.getClass().getPackage().getName() + ".EntityPlayer"); + final Field minecraftServer = con.getClass().getDeclaredField("minecraftServer"); + minecraftServer.setAccessible(true); + final Object mcserver = minecraftServer.get(con); + final Object playerlist = mcserver.getClass().getDeclaredMethod("getPlayerList", (Class[])new Class[0]).invoke(mcserver); + final Method moveToWorld = playerlist.getClass().getMethod("moveToWorld", EntityPlayer, Integer.TYPE, Boolean.TYPE); + moveToWorld.invoke(playerlist, nmsPlayer, 0, false); + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + }.runTaskLater(this.plugin, 2L); + } + + public static Map getLastPearl() { + return PlayerListener.lastPearl; + } +} diff --git a/src/main/java/us/centile/practice/manager/Manager.java b/src/main/java/us/centile/practice/manager/Manager.java new file mode 100644 index 0000000..4948e0f --- /dev/null +++ b/src/main/java/us/centile/practice/manager/Manager.java @@ -0,0 +1,10 @@ +package us.centile.practice.manager; + +public class Manager +{ + protected ManagerHandler handler; + + public Manager(final ManagerHandler handler) { + this.handler = handler; + } +} diff --git a/src/main/java/us/centile/practice/manager/ManagerHandler.java b/src/main/java/us/centile/practice/manager/ManagerHandler.java new file mode 100644 index 0000000..d3e8c2e --- /dev/null +++ b/src/main/java/us/centile/practice/manager/ManagerHandler.java @@ -0,0 +1,114 @@ +package us.centile.practice.manager; + +import us.centile.practice.*; +import us.centile.practice.manager.managers.*; +import us.centile.practice.scoreboard.*; +import org.bukkit.plugin.java.*; +import us.centile.practice.schedule.*; +import us.noksdev.permissions.util.file.ConfigFile; + +public class ManagerHandler +{ + private nPractice plugin; + private ConfigFile scheduleConfig; + private ArenaManager arenaManager; + private DuelManager duelManager; + private KitManager kitManager; + private EditorManager editorManager; + private ItemManager itemManager; + private PracticePlayerManager practicePlayerManager; + private InventoryManager inventoryManager; + private QueueManager queueManager; + private RequestManager requestManager; + private SpectatorManager spectatorManager; + private InventorySnapshotManager inventorySnapshotManager; + private PartyManager partyManager; + private ScoreboardHandler scoreboardHandler; + + public ManagerHandler(final nPractice plugin) { + this.plugin = plugin; + this.loadManagers(); + } + + private void loadManagers() { + this.scheduleConfig = new ConfigFile((JavaPlugin)this.plugin, "schedule"); + this.arenaManager = new ArenaManager(this); + this.duelManager = new DuelManager(this.plugin, this); + this.kitManager = new KitManager(this); + this.editorManager = new EditorManager(this); + this.itemManager = new ItemManager(this); + this.practicePlayerManager = new PracticePlayerManager(this); + this.queueManager = new QueueManager(this); + this.inventoryManager = new InventoryManager(this); + this.requestManager = new RequestManager(this); + this.spectatorManager = new SpectatorManager(this); + this.inventorySnapshotManager = new InventorySnapshotManager(this); + this.partyManager = new PartyManager(this); + this.scoreboardHandler = new ScoreboardHandler(this.plugin); + ScheduleHandler.setSchedules(this.scheduleConfig); + new ScheduleTimer(this.plugin); + } + + public void disable() { + this.arenaManager.disable(); + this.kitManager.disable(); + this.practicePlayerManager.disable(); + this.scoreboardHandler.clearBoards(); + } + + public nPractice getPlugin() { + return this.plugin; + } + + public ArenaManager getArenaManager() { + return this.arenaManager; + } + + public DuelManager getDuelManager() { + return this.duelManager; + } + + public KitManager getKitManager() { + return this.kitManager; + } + + public EditorManager getEditorManager() { + return this.editorManager; + } + + public ItemManager getItemManager() { + return this.itemManager; + } + + public PracticePlayerManager getPracticePlayerManager() { + return this.practicePlayerManager; + } + + public InventoryManager getInventoryManager() { + return this.inventoryManager; + } + + public QueueManager getQueueManager() { + return this.queueManager; + } + + public RequestManager getRequestManager() { + return this.requestManager; + } + + public SpectatorManager getSpectatorManager() { + return this.spectatorManager; + } + + public InventorySnapshotManager getInventorySnapshotManager() { + return this.inventorySnapshotManager; + } + + public PartyManager getPartyManager() { + return this.partyManager; + } + + public ScoreboardHandler getScoreboardHandler() { + return this.scoreboardHandler; + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/ArenaManager.java b/src/main/java/us/centile/practice/manager/managers/ArenaManager.java new file mode 100644 index 0000000..cab6e93 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/ArenaManager.java @@ -0,0 +1,109 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.arena.*; +import us.centile.practice.manager.*; +import org.bukkit.plugin.java.*; +import org.bukkit.*; +import org.bukkit.configuration.file.*; +import org.bukkit.configuration.*; +import java.util.*; +import java.util.stream.*; +import us.centile.practice.util.*; + +public class ArenaManager extends Manager +{ + private Map arenaMap; + private Config mainConfig; + + public ArenaManager(final ManagerHandler handler) { + super(handler); + this.arenaMap = new HashMap(); + this.mainConfig = new Config(handler.getPlugin(), "", "arena"); + this.loadArenas(); + } + + public void disable() { + this.saveArenas(); + } + + public Map getArenaMap() { + return this.arenaMap; + } + + public Arena getArena(final String arenaName) { + return this.getArenaMap().get(arenaName); + } + + public Arena createArena(final String arenaName) { + final Arena arena = new Arena(arenaName, null, null); + this.arenaMap.put(arenaName, arena); + return arena; + } + + public Arena closest(final Location location) { + double distancee = 262144.0; + Arena closest = null; + for (final Arena arena : this.getArenaMap().values()) { + if (location.getWorld() == arena.getFirstTeamLocation().getWorld() && arena.getFirstTeamLocation().distanceSquared(location) < distancee) { + distancee = arena.getFirstTeamLocation().distanceSquared(location); + closest = arena; + } + if (location.getWorld() == arena.getSecondTeamLocation().getWorld() && arena.getSecondTeamLocation().distanceSquared(location) < distancee) { + distancee = arena.getSecondTeamLocation().distanceSquared(location); + closest = arena; + } + } + return closest; + } + + public void destroyArena(final String arenaName) { + this.arenaMap.remove(arenaName); + } + + public void loadArenas() { + final FileConfiguration fileConfig = this.mainConfig.getConfig(); + final ConfigurationSection arenaSection = fileConfig.getConfigurationSection("arenas"); + if (arenaSection == null) { + return; + } + for (final String arenaName : arenaSection.getKeys(false)) { + final String serializedFirstTeamLocation = arenaSection.getString(arenaName + ".firstTeamLocation"); + final String serializedSecondTeamLocation = arenaSection.getString(arenaName + ".secondTeamLocation"); + final boolean enabled = arenaSection.getBoolean(arenaName + ".enabled"); + final Location firstTeamLocation = LocationSerializer.deserializeLocation(serializedFirstTeamLocation); + final Location secondTeamLocation = LocationSerializer.deserializeLocation(serializedSecondTeamLocation); + final Arena arena = new Arena(arenaName, firstTeamLocation, secondTeamLocation); + arena.setEnabled(enabled); + this.arenaMap.put(arenaName, arena); + } + } + + public void saveArenas() { + final FileConfiguration fileConfig = this.mainConfig.getConfig(); + fileConfig.set("arenas", (Object)null); + for (final Map.Entry arenaEntry : this.arenaMap.entrySet()) { + final String arenaName = arenaEntry.getKey(); + final Arena arena = arenaEntry.getValue(); + if (arena.getFirstTeamLocation() != null) { + if (arena.getSecondTeamLocation() == null) { + continue; + } + final boolean enabled = arena.isEnabled(); + final String serializedFirstTeamLocation = LocationSerializer.serializeLocation(arena.getFirstTeamLocation()); + final String serializedSecondTeamLocation = LocationSerializer.serializeLocation(arena.getSecondTeamLocation()); + fileConfig.set("arenas." + arenaName + ".firstTeamLocation", (Object)serializedFirstTeamLocation); + fileConfig.set("arenas." + arenaName + ".secondTeamLocation", (Object)serializedSecondTeamLocation); + fileConfig.set("arenas." + arenaName + ".enabled", (Object)enabled); + } + } + this.mainConfig.save(); + } + + public Arena getRandomArena() { + final List arenas = this.arenaMap.values().stream().filter(Arena::isEnabled).filter(Arena::isOpen).collect(Collectors.toList()); + if (arenas.isEmpty()) { + return null; + } + return arenas.get(UtilMath.getRandom().nextInt(arenas.size())); + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/DuelManager.java b/src/main/java/us/centile/practice/manager/managers/DuelManager.java new file mode 100644 index 0000000..7b3f94d --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/DuelManager.java @@ -0,0 +1,438 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.*; +import us.centile.practice.manager.*; +import us.centile.practice.arena.*; +import us.centile.practice.kit.*; +import org.bukkit.entity.*; +import us.centile.practice.scoreboard.provider.*; +import us.centile.practice.util.*; +import org.bukkit.event.*; +import org.bukkit.inventory.*; +import us.centile.practice.scoreboard.*; +import us.centile.practice.party.*; +import us.centile.practice.player.*; +import org.bukkit.*; +import us.centile.practice.duel.*; +import us.centile.practice.events.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.plugin.*; +import java.util.*; + +public class DuelManager extends Manager +{ + private nPractice plugin; + private Map uuidIdentifierToDuel; + private Map playerUUIDToDuelUUID; + private Random random; + + public DuelManager(final nPractice plugin, final ManagerHandler handler) { + super(handler); + this.plugin = plugin; + this.uuidIdentifierToDuel = new HashMap(); + this.playerUUIDToDuelUUID = new HashMap(); + this.random = new Random(); + } + + public Duel getDuelByUUID(final UUID uuid) { + return this.uuidIdentifierToDuel.get(uuid); + } + + public void createDuel(final Arena arena, final Kit kit, final UUID ffaPartyLeaderUUID, final List ffaPlayers) { + final UUID matchUUID = UUID.randomUUID(); + final Duel duel = new Duel(arena.getName(), kit.getName(), matchUUID, ffaPartyLeaderUUID, ffaPlayers); + this.uuidIdentifierToDuel.put(matchUUID, duel); + final List duelPlayers = new ArrayList(); + boolean lastLocation = false; + final ItemStack defaultBook = UtilItem.createItem(Material.BOOK, 1, (short)1, ChatColor.GREEN + "KIT: Default"); + for (final UUID uuid : ffaPlayers) { + final Player player = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player == null) { + continue; + } + final PlayerBoard playerBoard = this.handler.getScoreboardHandler().getPlayerBoard(player.getUniqueId()); + if (playerBoard != null) { + playerBoard.setDefaultSidebar(new DuelScoreboardProvider(this.handler.getPlugin()), 2L); + playerBoard.addUpdates(player); + } + UtilPlayer.clear(player); + this.playerUUIDToDuelUUID.put(player.getUniqueId(), matchUUID); + if (lastLocation) { + lastLocation = false; + player.teleport(arena.getSecondTeamLocation()); + } + else { + lastLocation = true; + player.teleport(arena.getFirstTeamLocation()); + } + final PracticePlayer practicePlayer = this.handler.getPracticePlayerManager().getPracticePlayer(player); + final String kitName = kit.getName(); + final Map playerKitMap = practicePlayer.getKitMap().get(kitName); + player.getInventory().setItem(0, defaultBook); + if (playerKitMap != null) { + int i = 2; + for (final PlayerKit playerKit : playerKitMap.values()) { + player.getInventory().setItem(i, UtilItem.createItem(Material.BOOK, 1, (short)0, playerKit.getDisplayName())); + ++i; + } + } + player.updateInventory(); + practicePlayer.setCurrentState(PlayerState.WAITING); + player.sendMessage(ChatColor.YELLOW + "Starting ffa duel against party"); + duelPlayers.add(player); + } + if (ffaPartyLeaderUUID != null) { + final Party party = this.handler.getPartyManager().getParty(ffaPartyLeaderUUID); + if (party != null) { + party.setPartyState(PartyState.DUELING); + } + } + for (final Player player2 : duelPlayers) { + for (final Player player3 : duelPlayers) { + player2.showPlayer(player3); + } + } + duelPlayers.clear(); + this.handler.getPlugin().getServer().getPluginManager().callEvent((Event)new DuelCreateEvent(duel)); + } + + public void createDuel(final Arena arena, final Kit kit, final boolean ranked, final UUID firstTeamPartyLeaderUUID, final UUID secondTeamPartyLeaderUUID, final List firstTeam, final List secondTeam, final boolean tournament, final boolean premium) { + final UUID matchUUID = UUID.randomUUID(); + final Duel duel = new Duel(arena.getName(), kit.getName(), matchUUID, ranked, firstTeamPartyLeaderUUID, secondTeamPartyLeaderUUID, firstTeam, secondTeam, tournament, premium); + this.uuidIdentifierToDuel.put(matchUUID, duel); + final List duelPlayers = new ArrayList(); + final ItemStack defaultBook = UtilItem.createItem(Material.BOOK, 1, (short)1, ChatColor.GREEN + "KIT: Default"); + String firstTeamRanked = ""; + String secondTeamRanked = ""; + if (ranked) { + if (firstTeam.size() == 1 && secondTeam.size() == 1) { + firstTeamRanked = ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer((UUID)firstTeam.get(0)).getName() + ChatColor.YELLOW + " with " + ChatColor.GREEN + "" + this.handler.getPracticePlayerManager().getPracticePlayer(firstTeam.get(0)).getEloMap().get(kit.getName()) + " elo"; + secondTeamRanked = ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer((UUID)secondTeam.get(0)).getName() + ChatColor.YELLOW + " with " + ChatColor.GREEN + "" + this.handler.getPracticePlayerManager().getPracticePlayer(secondTeam.get(0)).getEloMap().get(kit.getName()) + " elo"; + } + else if (firstTeam.size() == 2 && secondTeam.size() == 2 && firstTeamPartyLeaderUUID != null && secondTeamPartyLeaderUUID != null) { + final Party firstTeamParty = this.handler.getPartyManager().getParty(firstTeamPartyLeaderUUID); + final Party secondTeamParty = this.handler.getPartyManager().getParty(secondTeamPartyLeaderUUID); + firstTeamRanked = ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer(firstTeamPartyLeaderUUID).getName() + ChatColor.YELLOW + ", " + ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer((UUID)firstTeamParty.getMembers().get(0)).getName() + ChatColor.YELLOW + " with " + ChatColor.GREEN + this.handler.getPracticePlayerManager().getPracticePlayer(firstTeamPartyLeaderUUID).getPartyEloMap().get(firstTeamParty.getMembers().get(0)).get(kit.getName()) + " elo"; + secondTeamRanked = ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer(secondTeamPartyLeaderUUID).getName() + ChatColor.YELLOW + ", " + ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer((UUID)secondTeamParty.getMembers().get(0)).getName() + ChatColor.YELLOW + " with " + ChatColor.GREEN + this.handler.getPracticePlayerManager().getPracticePlayer(secondTeamPartyLeaderUUID).getPartyEloMap().get(secondTeamParty.getMembers().get(0)).get(kit.getName()) + " elo"; + } + } + for (final UUID uuid : firstTeam) { + final Player player = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player == null) { + continue; + } + UtilPlayer.clear(player); + this.playerUUIDToDuelUUID.put(player.getUniqueId(), matchUUID); + player.teleport(arena.getFirstTeamLocation()); + final PracticePlayer practicePlayer = this.handler.getPracticePlayerManager().getPracticePlayer(player); + final String kitName = kit.getName(); + final Map playerKitMap = practicePlayer.getKitMap().get(kitName); + player.getInventory().setItem(0, defaultBook); + if (playerKitMap != null && !duel.isTournament()) { + int i = 2; + for (final PlayerKit playerKit : playerKitMap.values()) { + player.getInventory().setItem(i, UtilItem.createItem(Material.BOOK, 1, (short)0, playerKit.getDisplayName())); + ++i; + } + } + player.updateInventory(); + practicePlayer.setCurrentState(PlayerState.WAITING); + practicePlayer.setTeamNumber(1); + if (kit.isCombo()) { + player.setNoDamageTicks(0); + player.setMaximumNoDamageTicks(2); + } + final boolean party = secondTeam.size() >= 2; + practicePlayer.setShowRematchItemFlag(true); + practicePlayer.setLastDuelPlayer(this.handler.getPlugin().getServer().getPlayer((UUID)secondTeam.get(0)).getName()); + player.sendMessage(ChatColor.YELLOW + "Starting duel against " + (ranked ? secondTeamRanked : (ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer((UUID)secondTeam.get(0)).getName())) + (party ? (ChatColor.YELLOW + "'s party.") : "")); + duelPlayers.add(player); + } + for (final UUID uuid : secondTeam) { + final Player player = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player == null) { + continue; + } + UtilPlayer.clear(player); + this.playerUUIDToDuelUUID.put(player.getUniqueId(), matchUUID); + player.teleport(arena.getSecondTeamLocation()); + final PracticePlayer practicePlayer = this.handler.getPracticePlayerManager().getPracticePlayer(player); + final String kitName = kit.getName(); + final Map playerKitMap = practicePlayer.getKitMap().get(kitName); + player.getInventory().setItem(0, defaultBook); + if (playerKitMap != null && !duel.isTournament()) { + int i = 2; + for (final PlayerKit playerKit : playerKitMap.values()) { + player.getInventory().setItem(i, UtilItem.createItem(Material.BOOK, 1, (short)0, playerKit.getDisplayName())); + ++i; + } + } + player.updateInventory(); + practicePlayer.setCurrentState(PlayerState.WAITING); + practicePlayer.setTeamNumber(2); + if (kit.isCombo()) { + player.setNoDamageTicks(0); + player.setMaximumNoDamageTicks(2); + } + final boolean party = firstTeam.size() >= 2; + practicePlayer.setShowRematchItemFlag(true); + practicePlayer.setLastDuelPlayer(this.handler.getPlugin().getServer().getPlayer((UUID)firstTeam.get(0)).getName()); + player.sendMessage(ChatColor.YELLOW + "Starting duel against " + (ranked ? firstTeamRanked : (ChatColor.GREEN + this.handler.getPlugin().getServer().getPlayer((UUID)firstTeam.get(0)).getName())) + (party ? (ChatColor.YELLOW + "'s party.") : "")); + duelPlayers.add(player); + } + if (firstTeamPartyLeaderUUID != null) { + final Party party2 = this.handler.getPartyManager().getParty(firstTeamPartyLeaderUUID); + if (party2 != null) { + party2.setPartyState(PartyState.DUELING); + } + } + if (secondTeamPartyLeaderUUID != null) { + final Party party2 = this.handler.getPartyManager().getParty(secondTeamPartyLeaderUUID); + if (party2 != null) { + party2.setPartyState(PartyState.DUELING); + } + } + for (final Player player2 : duelPlayers) { + for (final Player player3 : duelPlayers) { + player2.showPlayer(player3); + } + } + for (final UUID uuid : firstTeam) { + final Player player = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player == null) { + continue; + } + final PlayerBoard playerBoard = this.handler.getScoreboardHandler().getPlayerBoard(player.getUniqueId()); + if (playerBoard == null) { + continue; + } + playerBoard.setDefaultSidebar(new DuelScoreboardProvider(this.handler.getPlugin()), 2L); + } + for (final UUID uuid : secondTeam) { + final Player player = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player == null) { + continue; + } + final PlayerBoard playerBoard = this.handler.getScoreboardHandler().getPlayerBoard(player.getUniqueId()); + if (playerBoard == null) { + continue; + } + playerBoard.setDefaultSidebar(new DuelScoreboardProvider(this.handler.getPlugin()), 2L); + } + for (final Player playerInDuel : duelPlayers) { + final PlayerBoard playerBoard2 = this.handler.getScoreboardHandler().getPlayerBoard(playerInDuel.getUniqueId()); + if (playerBoard2 != null) { + playerBoard2.addUpdates(playerInDuel); + } + } + duelPlayers.clear(); + this.handler.getPlugin().getServer().getPluginManager().callEvent((Event)new DuelCreateEvent(duel)); + } + + public Duel getDuelFromPlayer(final UUID uuid) { + final UUID matchUUID = this.playerUUIDToDuelUUID.get(uuid); + return this.uuidIdentifierToDuel.get(matchUUID); + } + + public void removePlayerFromDuel(final Player player) { + final Duel currentDuel = this.getDuelFromPlayer(player.getUniqueId()); + this.playerUUIDToDuelUUID.remove(player.getUniqueId()); + if (currentDuel == null) { + return; + } + final PlayerBoard playerBoard = nPractice.getInstance().getManagerHandler().getScoreboardHandler().getPlayerBoard(player.getUniqueId()); + final PlayerInventorySnapshot playerInventorySnapshot = new PlayerInventorySnapshot(player); + currentDuel.addSnapshot(player.getUniqueId(), playerInventorySnapshot); + if (currentDuel.getFfaPlayers() != null) { + currentDuel.killPlayerFFA(player.getUniqueId()); + for (final UUID uuid : currentDuel.getFfaPlayers()) { + final Player other = Bukkit.getPlayer(uuid); + if (playerBoard != null) { + playerBoard.addUpdates(other); + } + if (other != null) { + if (player.getKiller() != null) { + other.sendMessage(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has been killed by " + ChatColor.GREEN + player.getKiller().getName() + ChatColor.YELLOW + "."); + } + else { + other.sendMessage(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has been killed" + ChatColor.YELLOW + "."); + } + } + } + if (currentDuel.getFfaPlayersAlive().size() == 1) { + final Player lastPlayer = this.handler.getPlugin().getServer().getPlayer((UUID)currentDuel.getFfaPlayersAlive().get(0)); + final PlayerInventorySnapshot lastPlayerSnapshot = new PlayerInventorySnapshot(lastPlayer); + final UUID lastPlayerSnapUUID = UUID.randomUUID(); + currentDuel.addUUIDSnapshot(lastPlayer.getUniqueId(), lastPlayerSnapUUID); + this.handler.getInventorySnapshotManager().addSnapshot(lastPlayerSnapUUID, lastPlayerSnapshot); + for (final Map.Entry entry : currentDuel.getPlayerUUIDToSnapshotMap().entrySet()) { + final UUID playerUUID = entry.getKey(); + final PlayerInventorySnapshot pSnapshot = entry.getValue(); + final UUID snapUUID = UUID.randomUUID(); + currentDuel.addUUIDSnapshot(playerUUID, snapUUID); + this.handler.getInventorySnapshotManager().addSnapshot(snapUUID, pSnapshot); + } + currentDuel.setDuelState(DuelState.ENDING); + currentDuel.setEndMatchTime(System.currentTimeMillis()); + this.playerUUIDToDuelUUID.remove(currentDuel.getFfaPlayersAlive().get(0)); + this.handler.getPlugin().getServer().getPluginManager().callEvent((Event)new DuelEndingEvent(currentDuel)); + } + return; + } + for (final UUID uuid : currentDuel.getFirstTeam()) { + final Player other = Bukkit.getPlayer(uuid); + if (other != null) { + if (playerBoard != null) { + playerBoard.addUpdates(other); + } + if (player.getKiller() != null) { + other.sendMessage(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has been killed by " + ChatColor.GREEN + player.getKiller().getName() + ChatColor.YELLOW + "."); + } + else { + other.sendMessage(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has been killed" + ChatColor.YELLOW + "."); + } + } + } + for (final UUID uuid : currentDuel.getSecondTeam()) { + final Player other = Bukkit.getPlayer(uuid); + if (other != null) { + if (playerBoard != null) { + playerBoard.addUpdates(other); + } + if (player.getKiller() != null) { + other.sendMessage(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has been killed by " + ChatColor.GREEN + player.getKiller().getName() + ChatColor.YELLOW + "."); + } + else { + other.sendMessage(ChatColor.GREEN + player.getName() + ChatColor.YELLOW + " has been killed" + ChatColor.YELLOW + "."); + } + } + } + final int teamNumber = this.handler.getPracticePlayerManager().getPracticePlayer(player).getTeamNumber(); + if (teamNumber == 1) { + currentDuel.killPlayerFirstTeam(player.getUniqueId()); + } + else { + currentDuel.killPlayerSecondTeam(player.getUniqueId()); + } + if (currentDuel.getFirstTeamAlive().size() == 0) { + for (final UUID lastPlayersUUID : currentDuel.getSecondTeamAlive()) { + final Player lastPlayers = this.handler.getPlugin().getServer().getPlayer(lastPlayersUUID); + final PlayerInventorySnapshot lastPlayerSnapshot2 = new PlayerInventorySnapshot(lastPlayers); + currentDuel.addSnapshot(lastPlayers.getUniqueId(), lastPlayerSnapshot2); + } + for (final Map.Entry entry2 : currentDuel.getPlayerUUIDToSnapshotMap().entrySet()) { + final UUID playerUUID2 = entry2.getKey(); + final PlayerInventorySnapshot pSnapshot2 = entry2.getValue(); + final UUID snapUUID2 = UUID.randomUUID(); + currentDuel.addUUIDSnapshot(playerUUID2, snapUUID2); + this.handler.getInventorySnapshotManager().addSnapshot(snapUUID2, pSnapshot2); + } + currentDuel.setDuelState(DuelState.ENDING); + currentDuel.setEndMatchTime(System.currentTimeMillis()); + this.handler.getPlugin().getServer().getPluginManager().callEvent((Event)new DuelEndingEvent(currentDuel, 2)); + this.playerUUIDToDuelUUID.remove(currentDuel.getSecondTeamAlive().get(0)); + } + else if (currentDuel.getSecondTeamAlive().size() == 0) { + for (final UUID lastPlayersUUID : currentDuel.getFirstTeamAlive()) { + final Player lastPlayers = this.handler.getPlugin().getServer().getPlayer(lastPlayersUUID); + final PlayerInventorySnapshot lastPlayerSnapshot2 = new PlayerInventorySnapshot(lastPlayers); + currentDuel.addSnapshot(lastPlayers.getUniqueId(), lastPlayerSnapshot2); + } + for (final Map.Entry entry2 : currentDuel.getPlayerUUIDToSnapshotMap().entrySet()) { + final UUID playerUUID2 = entry2.getKey(); + final PlayerInventorySnapshot pSnapshot2 = entry2.getValue(); + final UUID snapUUID2 = UUID.randomUUID(); + currentDuel.addUUIDSnapshot(playerUUID2, snapUUID2); + this.handler.getInventorySnapshotManager().addSnapshot(snapUUID2, pSnapshot2); + } + currentDuel.setDuelState(DuelState.ENDING); + currentDuel.setEndMatchTime(System.currentTimeMillis()); + this.handler.getPlugin().getServer().getPluginManager().callEvent((Event)new DuelEndingEvent(currentDuel, 1)); + this.playerUUIDToDuelUUID.remove(currentDuel.getFirstTeamAlive().get(0)); + } + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.RANKED_SOLO)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.RANKED_PARTY)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.UNRANKED_PARTY)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.UNRANKED_SOLO)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.PREMIUM_SOLO)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.SPECTATOR)); + } + + public void destroyDuel(final Duel duel) { + this.uuidIdentifierToDuel.remove(duel.getUUID()); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.RANKED_SOLO)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.RANKED_PARTY)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.UNRANKED_PARTY)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.UNRANKED_SOLO)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.PREMIUM_SOLO)); + Bukkit.getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.SPECTATOR)); + } + + public int getRankedDuelsFromKit(final String kitName) { + int count = 0; + for (final Duel duel : this.uuidIdentifierToDuel.values()) { + if (duel.getKitName().equalsIgnoreCase(kitName) && duel.isRanked()) { + ++count; + } + } + return count; + } + + public int getRankedPartyDuelsFromKit(final String kitName) { + int count = 0; + for (final Duel duel : this.uuidIdentifierToDuel.values()) { + if (duel.getKitName().equalsIgnoreCase(kitName) && duel.isRanked() && duel.getFirstTeam().size() >= 2) { + ++count; + } + } + return count; + } + + public int getUnRankedDuelsFromKit(final String kitName) { + int count = 0; + for (final Duel duel : this.uuidIdentifierToDuel.values()) { + if (duel.getKitName().equalsIgnoreCase(kitName) && !duel.isRanked()) { + ++count; + } + } + return count; + } + + public int getPremiumDuelsFromKit(final String kitName) { + int count = 0; + for (final Duel duel : this.uuidIdentifierToDuel.values()) { + if (duel.getKitName().equalsIgnoreCase(kitName) && duel.isPremium()) { + ++count; + } + } + return count; + } + + public int getUnRankedPartyDuelsFromKit(final String kitName) { + int count = 0; + for (final Duel duel : this.uuidIdentifierToDuel.values()) { + if (duel.getKitName().equalsIgnoreCase(kitName) && !duel.isRanked() && duel.getFirstTeam().size() >= 2) { + ++count; + } + } + return count; + } + + public Duel getRandomDuel() { + final List list = new ArrayList(this.uuidIdentifierToDuel.values()); + Collections.shuffle(list); + final Duel duel = list.get(this.random.nextInt(list.size())); + if (duel != null) { + return duel; + } + return null; + } + + public Map getUuidIdentifierToDuel() { + return this.uuidIdentifierToDuel; + } + + public Map getPlayerUUIDToDuelUUID() { + return this.playerUUIDToDuelUUID; + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/EditorManager.java b/src/main/java/us/centile/practice/manager/managers/EditorManager.java new file mode 100644 index 0000000..3b253d0 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/EditorManager.java @@ -0,0 +1,51 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.player.*; +import us.centile.practice.manager.*; +import java.util.*; +import us.centile.practice.kit.*; + +public class EditorManager extends Manager +{ + private Map editingKit; + private Map renamingKit; + + public EditorManager(final ManagerHandler handler) { + super(handler); + this.editingKit = new HashMap(); + this.renamingKit = new HashMap(); + } + + public String getPlayerEditingKit(final UUID uuid) { + return this.editingKit.get(uuid); + } + + public PlayerKit getKitRenaming(final UUID uuid) { + return this.renamingKit.get(uuid); + } + + public void addEditingKit(final UUID uuid, final Kit kit) { + this.editingKit.put(uuid, kit.getName()); + this.handler.getInventoryManager().addEditKitItemsInventory(uuid, kit); + this.handler.getInventoryManager().addEditKitKitsInventory(uuid, kit); + } + + public void addRenamingKit(final UUID uuid, final PlayerKit playerKit) { + this.renamingKit.put(uuid, playerKit); + } + + public void removeEditingKit(final UUID uuid) { + this.editingKit.remove(uuid); + this.renamingKit.remove(uuid); + this.handler.getInventoryManager().destroyEditKitItemsInventory(uuid); + this.handler.getInventoryManager().destroyEditKitKitsInventory(uuid); + } + + public void removeRenamingKit(final UUID uuid) { + this.renamingKit.remove(uuid); + } + + public Map getRenamingKit() { + return this.renamingKit; + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/InventoryManager.java b/src/main/java/us/centile/practice/manager/managers/InventoryManager.java new file mode 100644 index 0000000..64a4519 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/InventoryManager.java @@ -0,0 +1,455 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.manager.*; +import us.centile.practice.kit.*; +import us.centile.practice.util.*; +import org.bukkit.inventory.*; +import us.centile.practice.duel.*; +import org.bukkit.*; +import us.centile.practice.tournament.*; +import us.centile.practice.party.*; +import org.bukkit.entity.*; +import java.util.*; +import org.bukkit.inventory.meta.*; +import us.centile.practice.player.*; + +public class InventoryManager extends Manager +{ + private Inventory unrankedInventory; + private Inventory rankedInventory; + private Inventory premiumInventory; + private Inventory unrankedPartyInventory; + private Inventory rankedPartyInventory; + private Inventory editorInventory; + private Inventory requestInventory; + private Inventory splitFightInventory; + private Inventory partyEventsInventory; + private Inventory partiesInventory; + private Inventory ffaPartyInventory; + private Inventory tournamentInventory; + private Inventory joinTournamentInventory; + private Sinventory spectatorInventory; + private Map selectingDuel; + private Map editingKitItems; + private Map editingKitKits; + + public InventoryManager(final ManagerHandler handler) { + super(handler); + this.selectingDuel = new HashMap(); + this.editingKitItems = new HashMap(); + this.editingKitKits = new HashMap(); + this.unrankedInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Unranked Queue"); + this.rankedInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Ranked Queue"); + this.premiumInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Premium Queue"); + this.unrankedPartyInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Unranked Queue"); + this.rankedPartyInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Ranked Queue"); + this.editorInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Kit Editor"); + this.requestInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Send Request"); + this.splitFightInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Split Fights"); + this.partyEventsInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Party Events"); + this.partiesInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 54, "Fight other parties"); + this.ffaPartyInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Party FFA"); + this.tournamentInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Tournament Size"); + this.joinTournamentInventory = handler.getPlugin().getServer().createInventory((InventoryHolder)null, 9, "Available Tournaments"); + this.spectatorInventory = new Sinventory("Spectator Menu"); + this.setUnrankedInventory(); + this.setRankedInventory(); + this.setPremiumInventory(); + this.setUnrankedPartyInventory(); + this.setRankedPartyInventory(); + this.setEditorInventory(); + this.setRequestInventory(); + this.setPartyEventsInventory(); + this.setSplitFightInventory(); + this.setFfaPartyInventory(); + this.setSpectatorInventory(); + this.setJoinTournamentInventory(); + } + + public void setUnrankedInventory() { + this.unrankedInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + final int inGame = this.handler.getDuelManager().getUnRankedDuelsFromKit(kitName); + final int inQueue = (this.handler.getQueueManager().getQueuedForUnrankedQueue(kitName) != null) ? 1 : 0; + final List lore = Arrays.asList(ChatColor.YELLOW + "In Game: " + ChatColor.WHITE + inGame, ChatColor.YELLOW + "In Queue: " + ChatColor.WHITE + inQueue); + final ItemStack kitIcon = UtilItem.createItem(kit.getIcon().getType(), (inGame > 64) ? 64 : ((inGame == 0) ? 1 : inGame), kit.getIcon().getDurability(), ChatColor.GREEN + kitName, lore); + this.unrankedInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setPremiumInventory() { + this.premiumInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + if (!kit.isPremium()) { + continue; + } + final int inGame = this.handler.getDuelManager().getPremiumDuelsFromKit(kitName); + final int inQueue = this.handler.getQueueManager().getPremiumKitQueueMap().containsKey(kitName) ? this.handler.getQueueManager().getPremiumKitQueueMap().get(kitName).size() : 0; + final List lore = Arrays.asList(ChatColor.YELLOW + "In Game: " + ChatColor.WHITE + inGame, ChatColor.YELLOW + "In Queue: " + ChatColor.WHITE + inQueue); + final ItemStack kitIcon = UtilItem.createItem(kit.getIcon().getType(), (inGame > 64) ? 64 : ((inGame == 0) ? 1 : inGame), kit.getIcon().getDurability(), ChatColor.GREEN + kitName, lore); + this.premiumInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setUnrankedPartyInventory() { + this.unrankedInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + final int inGame = this.handler.getDuelManager().getUnRankedPartyDuelsFromKit(kitName); + final int inQueue = (this.handler.getQueueManager().getQueuedForPartyUnrankedQueue(kitName) != null) ? 1 : 0; + final List lore = Arrays.asList(ChatColor.YELLOW + "In Game: " + ChatColor.WHITE + inGame, ChatColor.YELLOW + "In Queue: " + ChatColor.WHITE + inQueue); + final ItemStack kitIcon = UtilItem.createItem(kit.getIcon().getType(), (inGame > 64) ? 64 : ((inGame == 0) ? 1 : inGame), kit.getIcon().getDurability(), ChatColor.GREEN + kitName, lore); + this.unrankedInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setRankedInventory() { + this.rankedInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + if (!kit.isRanked()) { + continue; + } + final int inGame = this.handler.getDuelManager().getRankedDuelsFromKit(kitName); + final int inQueue = this.handler.getQueueManager().getRankedKitQueueMap().containsKey(kitName) ? this.handler.getQueueManager().getRankedKitQueueMap().get(kitName).size() : 0; + final List lore = Arrays.asList(ChatColor.YELLOW + "In Game: " + ChatColor.WHITE + inGame, ChatColor.YELLOW + "In Queue: " + ChatColor.WHITE + inQueue); + final ItemStack kitIcon = UtilItem.createItem(kit.getIcon().getType(), (inGame > 64) ? 64 : ((inGame == 0) ? 1 : inGame), kit.getIcon().getDurability(), ChatColor.GREEN + kitName, lore); + this.rankedInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setRankedPartyInventory() { + this.rankedInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + if (!kit.isRanked()) { + continue; + } + final int inGame = this.handler.getDuelManager().getRankedPartyDuelsFromKit(kitName); + final int inQueue = this.handler.getQueueManager().getPartyRankedKitQueueMap().containsKey(kitName) ? this.handler.getQueueManager().getPartyRankedKitQueueMap().get(kitName).size() : 0; + final List lore = Arrays.asList(ChatColor.YELLOW + "In Game: " + ChatColor.WHITE + inGame, ChatColor.YELLOW + "In Queue: " + ChatColor.WHITE + inQueue); + final ItemStack kitIcon = UtilItem.createItem(kit.getIcon().getType(), (inGame > 64) ? 64 : ((inGame == 0) ? 1 : inGame), kit.getIcon().getDurability(), ChatColor.GREEN + kitName, lore); + this.rankedInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setSpectatorInventory() { + this.spectatorInventory.getContents().clear(); + if (this.handler.getDuelManager().getUuidIdentifierToDuel().values().size() == 0) { + final ItemStack item = UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)14, ChatColor.RED + "There is no matches to display."); + for (int i = 0; i <= 8; ++i) { + this.spectatorInventory.addItem(item); + } + return; + } + int count = 1; + for (final Duel duel : this.handler.getDuelManager().getUuidIdentifierToDuel().values()) { + String firstTeam; + if (duel.getFfaPlayers() != null && duel.getFfaPlayers().size() > 0) { + firstTeam = Bukkit.getOfflinePlayer((UUID)duel.getFfaPlayers().get(0)).getName() + "'s Party"; + } + else if (duel.getFirstTeam() != null && duel.getFirstTeam().size() >= 2) { + firstTeam = Bukkit.getOfflinePlayer((UUID)duel.getFirstTeam().get(0)).getName() + "'s Party"; + } + else { + firstTeam = Bukkit.getOfflinePlayer((UUID)duel.getFirstTeam().get(0)).getName(); + } + String secondTeam; + if (duel.getFfaPlayers() != null && duel.getFfaPlayers().size() > 0) { + secondTeam = Bukkit.getOfflinePlayer((UUID)duel.getFfaPlayers().get(0)).getName() + "'s Party"; + } + else if (duel.getFirstTeam() != null && duel.getSecondTeam().size() >= 2) { + secondTeam = Bukkit.getOfflinePlayer((UUID)duel.getSecondTeam().get(0)).getName() + "'s Party"; + } + else { + secondTeam = Bukkit.getOfflinePlayer((UUID)duel.getSecondTeam().get(0)).getName(); + } + final ItemStack item2 = UtilItem.createItem(Material.PAPER, 1, (short)0, ChatColor.GOLD + "Duel Match (#" + count + ")", Arrays.asList(ChatColor.YELLOW + firstTeam + " vs. " + secondTeam, ChatColor.GRAY + "(" + (duel.isRanked() ? "Ranked Match" : "Unranked Match") + ")", "", ChatColor.RED + "Kit: " + ChatColor.WHITE + duel.getKitName(), ChatColor.RED + "Arena: " + ChatColor.WHITE + duel.getArenaName(), "", ChatColor.GRAY + "Click to spectate this match")); + this.spectatorInventory.addItem(item2); + ++count; + } + } + + public void setEditorInventory() { + this.editorInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + if (!kit.isEditable()) { + continue; + } + final ItemStack kitIcon = UtilItem.createItem(kit.getIcon().getType(), 1, kit.getIcon().getDurability(), ChatColor.YELLOW + kitName); + this.editorInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setRequestInventory() { + this.requestInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + final ItemStack kitIcon = UtilItem.name(kit.getIcon(), ChatColor.GREEN + kitName); + this.requestInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setJoinTournamentInventory() { + this.joinTournamentInventory.clear(); + if (Tournament.getTournaments().size() == 0) { + return; + } + int count = 1; + for (final Tournament tournament : Tournament.getTournaments()) { + final ItemStack item = UtilItem.createItem(Material.NETHER_STAR, 1, (short)0, ChatColor.RED.toString() + ChatColor.BOLD + tournament.getMaximumPerTeam() + "v" + tournament.getMaximumPerTeam(), Arrays.asList(ChatColor.YELLOW + "Players: (" + tournament.getTeams().size() + "/" + tournament.getPlayersLimit() + ")", ChatColor.GRAY + "Stage: " + ChatColor.GOLD + ((tournament.getTournamentStage() == null) ? "Waiting for players" : tournament.getTournamentStage().name().replace("_", " ")), ChatColor.GRAY + "Click here to join the tournament")); + this.joinTournamentInventory.addItem(new ItemStack[] { item }); + ++count; + } + } + + public void setTournamentInventory(final Kit kit, final boolean isPlayer) { + this.tournamentInventory.clear(); + for (int i = 1; i <= 5; ++i) { + final ItemStack item = UtilItem.createItem(Material.NETHER_STAR, 1, (short)0, ChatColor.RED.toString() + ChatColor.BOLD + i + "v" + i, Arrays.asList(ChatColor.GRAY + "Type: " + (isPlayer ? "Player" : "System"), ChatColor.GRAY + "Kit: " + kit.getName())); + this.tournamentInventory.addItem(new ItemStack[] { item }); + } + } + + private void setPartyEventsInventory() { + final ItemStack goldSword = UtilItem.createItem(Material.GOLD_SWORD, 1, (short)0, ChatColor.RED + "Split Fights"); + final ItemStack slimeBall = UtilItem.createItem(Material.SLIME_BALL, 1, (short)0, ChatColor.AQUA + "Team FFA"); + this.partyEventsInventory.addItem(new ItemStack[] { goldSword, slimeBall }); + } + + public void setSplitFightInventory() { + this.splitFightInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + final ItemStack kitIcon = UtilItem.name(kit.getIcon(), ChatColor.GREEN + kitName); + this.splitFightInventory.setItem(count, kitIcon); + ++count; + } + } + + public void setFfaPartyInventory() { + this.ffaPartyInventory.clear(); + int count = 0; + for (final Map.Entry mapEntry : this.handler.getKitManager().getKitMap().entrySet()) { + final String kitName = mapEntry.getKey(); + final Kit kit = mapEntry.getValue(); + if (!kit.isEnabled()) { + continue; + } + final ItemStack kitIcon = UtilItem.name(kit.getIcon(), ChatColor.GREEN + kitName); + this.ffaPartyInventory.setItem(count, kitIcon); + ++count; + } + } + + public void addParty(final Party party) { + final Player player = this.handler.getPlugin().getServer().getPlayer(party.getLeader()); + final ItemStack skull = UtilItem.createItem(Material.SKULL_ITEM, 1, (short)3, ChatColor.GOLD + player.getName()); + this.partiesInventory.addItem(new ItemStack[] { skull }); + } + + public void delParty(final Party party) { + final Player player = this.handler.getPlugin().getServer().getPlayer(party.getLeader()); + final String leaderName = (player == null) ? party.getLeaderName() : player.getName(); + for (final ItemStack itemStack : this.partiesInventory.getContents()) { + if (itemStack != null && itemStack.getItemMeta().hasDisplayName() && itemStack.getItemMeta().getDisplayName().contains(leaderName)) { + this.partiesInventory.remove(itemStack); + break; + } + } + } + + public void updateParty(final Party party) { + final Player player = this.handler.getPlugin().getServer().getPlayer(party.getLeader()); + final String leaderName = (player == null) ? party.getLeaderName() : player.getName(); + final List lores = new ArrayList(); + for (final UUID uuid : party.getMembers()) { + final Player memberPlayer = this.handler.getPlugin().getServer().getPlayer(uuid); + if (memberPlayer == null) { + continue; + } + lores.add(ChatColor.GREEN + memberPlayer.getName()); + } + for (final ItemStack itemStack : this.partiesInventory.getContents()) { + if (itemStack != null && itemStack.getItemMeta().hasDisplayName() && itemStack.getItemMeta().getDisplayName().contains(leaderName)) { + final ItemMeta itemMeta = itemStack.getItemMeta(); + itemMeta.setLore((List)lores); + itemMeta.setDisplayName(ChatColor.GOLD + leaderName + ChatColor.GREEN + " (" + (party.getMembers().size() + 1) + ")"); + itemStack.setItemMeta(itemMeta); + break; + } + } + } + + public void setSelectingDuel(final UUID uuid, final UUID uuid1) { + this.selectingDuel.put(uuid, uuid1); + } + + public UUID getSelectingDuelPlayerUUID(final UUID uuid) { + return this.selectingDuel.get(uuid); + } + + public void removeSelectingDuel(final UUID uuid) { + this.selectingDuel.remove(uuid); + } + + public Inventory getEditKitItemsInventory(final UUID uuid) { + return this.editingKitItems.get(uuid); + } + + public void addEditKitItemsInventory(final UUID uuid, final Kit kit) { + final Inventory inventory = this.handler.getPlugin().getServer().createInventory((InventoryHolder)null, 54, kit.getName()); + for (final ItemStack itemStack : kit.getMainContents()) { + if (itemStack != null) { + inventory.addItem(new ItemStack[] { itemStack }); + } + } + for (final ItemStack itemStack : kit.getArmorContents()) { + if (itemStack != null) { + inventory.addItem(new ItemStack[] { itemStack }); + } + } + inventory.addItem(new ItemStack[] { new ItemStack(Material.COOKED_BEEF, 64) }); + this.editingKitItems.put(uuid, inventory); + } + + public void destroyEditKitItemsInventory(final UUID uuid) { + this.editingKitItems.remove(uuid); + } + + public Inventory getEditKitKitsInventory(final UUID uuid) { + return this.editingKitKits.get(uuid); + } + + public void addEditKitKitsInventory(final UUID uuid, final Kit kit) { + final PracticePlayer practicePlayer = this.handler.getPracticePlayerManager().getPracticePlayer(uuid); + final Map kitMap = practicePlayer.getKitMap().get(kit.getName()); + final Inventory inventory = this.handler.getPlugin().getServer().createInventory((InventoryHolder)null, 36, "Kit Layout"); + for (int i = 1; i <= 7; ++i) { + final ItemStack save = UtilItem.createItem(Material.CHEST, 1, (short)0, ChatColor.YELLOW + "Create Kit " + ChatColor.GREEN + kit.getName() + " #" + i); + inventory.setItem(i, save); + if (kitMap != null && kitMap.containsKey(i)) { + final ItemStack loadedKit = UtilItem.createItem(Material.ENDER_CHEST, 1, (short)0, ChatColor.YELLOW + "KIT: " + ChatColor.GREEN + kit.getName() + " #" + i); + final ItemStack load = UtilItem.createItem(Material.BOOK, 1, (short)0, ChatColor.YELLOW + "Load/Edit Kit " + ChatColor.GREEN + kit.getName() + " #" + i); + final ItemStack rename = UtilItem.createItem(Material.NAME_TAG, 1, (short)0, ChatColor.YELLOW + "Rename Kit " + ChatColor.GREEN + kit.getName() + " #" + i); + final ItemStack delete = UtilItem.createItem(Material.FLINT, 1, (short)0, ChatColor.YELLOW + "Delete Kit " + ChatColor.GREEN + kit.getName() + " #" + i); + inventory.setItem(i, loadedKit); + inventory.setItem(i + 9, load); + inventory.setItem(i + 18, rename); + inventory.setItem(i + 27, delete); + } + } + final ItemStack back = UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)14, ChatColor.RED + "\u23ce Go Back"); + inventory.setItem(0, back); + inventory.setItem(9, back); + inventory.setItem(18, back); + inventory.setItem(27, back); + inventory.setItem(8, back); + inventory.setItem(17, back); + inventory.setItem(26, back); + inventory.setItem(35, back); + this.editingKitKits.put(uuid, inventory); + } + + public void destroyEditKitKitsInventory(final UUID uuid) { + this.editingKitKits.remove(uuid); + } + + public Inventory getUnrankedInventory() { + return this.unrankedInventory; + } + + public Inventory getRankedInventory() { + return this.rankedInventory; + } + + public Inventory getEditorInventory() { + return this.editorInventory; + } + + public Inventory getRequestInventory() { + return this.requestInventory; + } + + public Inventory getSplitFightInventory() { + return this.splitFightInventory; + } + + public Inventory getPremiumInventory() { + return this.premiumInventory; + } + + public Inventory getPartiesInventory() { + return this.partiesInventory; + } + + public Inventory getFfaPartyInventory() { + return this.ffaPartyInventory; + } + + public Inventory getPartyEventsInventory() { + return this.partyEventsInventory; + } + + public Sinventory getSpectatorInventory() { + return this.spectatorInventory; + } + + public Inventory getTournamentInventory() { + return this.tournamentInventory; + } + + public Inventory getJoinTournamentInventory() { + return this.joinTournamentInventory; + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/InventorySnapshotManager.java b/src/main/java/us/centile/practice/manager/managers/InventorySnapshotManager.java new file mode 100644 index 0000000..a7ab341 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/InventorySnapshotManager.java @@ -0,0 +1,25 @@ +package us.centile.practice.manager.managers; + +import java.util.*; +import us.centile.practice.player.*; +import us.centile.practice.manager.*; +import java.util.concurrent.*; +import us.centile.practice.util.*; + +public class InventorySnapshotManager extends Manager +{ + private Map snapshotMap; + + public InventorySnapshotManager(final ManagerHandler handler) { + super(handler); + this.snapshotMap = new TtlHashMap(TimeUnit.MINUTES, 1L); + } + + public void addSnapshot(final UUID uuid, final PlayerInventorySnapshot playerInventorySnapshot) { + this.snapshotMap.put(uuid, playerInventorySnapshot); + } + + public PlayerInventorySnapshot getSnapshotFromUUID(final UUID uuid) { + return this.snapshotMap.get(uuid); + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/ItemManager.java b/src/main/java/us/centile/practice/manager/managers/ItemManager.java new file mode 100644 index 0000000..942d992 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/ItemManager.java @@ -0,0 +1,65 @@ +package us.centile.practice.manager.managers; + +import org.bukkit.inventory.*; +import us.centile.practice.manager.*; +import org.bukkit.*; +import us.centile.practice.util.*; +import org.bukkit.enchantments.*; + +public class ItemManager extends Manager +{ + private ItemStack[] spawnItems; + private ItemStack[] queueItems; + private ItemStack[] specItems; + private ItemStack[] partyItems; + private ItemStack[] spectatorModeItems; + + public ItemManager(final ManagerHandler handler) { + super(handler); + this.loadSpawnItems(); + this.loadQueueItems(); + this.loadPartyItems(); + this.loadSpecItems(); + this.loadSpectatorModeItems(); + } + + private void loadSpawnItems() { + this.spawnItems = new ItemStack[] { UtilItem.createItem(Material.IRON_SWORD, 1, (short)0, ChatColor.DARK_GREEN + "Unranked Queue"), UtilItem.createItem(Material.DIAMOND_SWORD, 1, (short)0, ChatColor.GREEN + "Ranked Queue"), UtilItem.createItem(Material.GOLD_SWORD, 1, (short)0, ChatColor.RED.toString() + ChatColor.BOLD + "Premium Queue", Enchantment.DURABILITY, 1), null, UtilItem.createItem(Material.NAME_TAG, 1, (short)0, ChatColor.AQUA + "Create Party"), null, UtilItem.createItem(Material.WATCH, 1, (short)0, ChatColor.AQUA + "Settings"), UtilItem.createItem(Material.BOOK, 1, (short)0, ChatColor.GOLD + "Edit Kits"), UtilItem.createItem(Material.COMPASS, 1, (short)0, ChatColor.YELLOW + "Spectator Mode") }; + } + + private void loadPartyItems() { + this.partyItems = new ItemStack[] { UtilItem.createItem(Material.IRON_SWORD, 1, (short)0, ChatColor.DARK_GREEN + "Unranked 2v2 Queue"), UtilItem.createItem(Material.DIAMOND_SWORD, 1, (short)0, ChatColor.GREEN + "Ranked 2v2 Queue"), null, UtilItem.createItem(Material.PAPER, 1, (short)0, ChatColor.YELLOW + "Fight Other Parties"), UtilItem.createItem(Material.SKULL_ITEM, 1, (short)0, ChatColor.GOLD + "Party Information"), UtilItem.createItem(Material.BOOK, 1, (short)0, ChatColor.GOLD + "Edit Kits"), null, UtilItem.createItem(Material.GOLD_AXE, 1, (short)0, ChatColor.GREEN + "Party Events"), UtilItem.createItem(Material.NETHER_STAR, 1, (short)0, ChatColor.RED + "Leave Party") }; + } + + private void loadSpecItems() { + this.specItems = new ItemStack[] { UtilItem.createItem(Material.COMPASS, 1, (short)0, ChatColor.GREEN + "Inspect Inventory"), null, null, null, null, null, null, null, UtilItem.createItem(Material.REDSTONE, 1, (short)0, ChatColor.RED + "Return to Lobby") }; + } + + private void loadSpectatorModeItems() { + this.spectatorModeItems = new ItemStack[] { null, null, null, UtilItem.createItem(Material.EMERALD, 1, (short)0, ChatColor.GOLD + "Spectate Match (Menu)"), UtilItem.createItem(Material.PAPER, 1, (short)0, ChatColor.YELLOW + "Spectate Random Match"), UtilItem.createItem(Material.NETHER_STAR, 1, (short)0, ChatColor.RED + "Leave Spectator Mode"), null, null, null }; + } + + private void loadQueueItems() { + this.queueItems = new ItemStack[] { UtilItem.createItem(Material.REDSTONE, 1, (short)0, ChatColor.YELLOW + "Leave Queue"), null, null, null, null, null, null, null, null }; + } + + public ItemStack[] getSpawnItems() { + return this.spawnItems; + } + + public ItemStack[] getQueueItems() { + return this.queueItems; + } + + public ItemStack[] getSpecItems() { + return this.specItems; + } + + public ItemStack[] getPartyItems() { + return this.partyItems; + } + + public ItemStack[] getSpectatorModeItems() { + return this.spectatorModeItems; + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/KitManager.java b/src/main/java/us/centile/practice/manager/managers/KitManager.java new file mode 100644 index 0000000..0bc9e33 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/KitManager.java @@ -0,0 +1,139 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.kit.*; +import us.centile.practice.manager.*; +import org.bukkit.plugin.java.*; +import org.bukkit.configuration.file.*; +import org.bukkit.configuration.*; +import org.bukkit.entity.*; +import us.centile.practice.player.*; +import org.bukkit.*; +import java.util.*; +import us.centile.practice.util.*; +import org.bukkit.inventory.*; +import org.bukkit.inventory.meta.*; +import org.bson.*; +import com.mongodb.client.model.*; + +public class KitManager extends Manager +{ + private Map kitMap; + private Config mainConfig; + + public KitManager(final ManagerHandler handler) { + super(handler); + this.kitMap = new HashMap(); + this.mainConfig = new Config(handler.getPlugin(), "", "kit"); + this.loadKits(); + this.saveMongo(); + } + + public void disable() { + this.saveKits(); + } + + public Map getKitMap() { + return this.kitMap; + } + + public Kit getKit(final String kitName) { + return this.getKitMap().get(kitName); + } + + public Kit createKit(final String kitName) { + final Kit kit = new Kit(kitName, null, false, true, true, new ItemStack[36], new ItemStack[36], false, false); + this.kitMap.put(kitName, kit); + return kit; + } + + public void destroyKit(final String kitName) { + this.kitMap.remove(kitName); + } + + public void loadKits() { + final FileConfiguration fileConfig = this.mainConfig.getConfig(); + final ConfigurationSection arenaSection = fileConfig.getConfigurationSection("kits"); + if (arenaSection == null) { + return; + } + for (final String kitName : arenaSection.getKeys(false)) { + final boolean enabled = arenaSection.getBoolean(kitName + ".enabled"); + final ItemStack icon = (ItemStack)arenaSection.get(kitName + ".icon"); + final boolean combo = arenaSection.getBoolean(kitName + ".combo"); + final boolean editable = arenaSection.getBoolean(kitName + ".editable"); + final boolean ranked = arenaSection.getBoolean(kitName + ".ranked"); + final boolean premium = arenaSection.getBoolean(kitName + ".premium"); + final boolean builduhc = arenaSection.getBoolean(kitName + ".builduhc"); + final ItemStack[] mainContents = (ItemStack[]) ((List)arenaSection.get(kitName + ".mainContents")).toArray(new ItemStack[0]); + final ItemStack[] armorContents = (ItemStack[]) ((List)arenaSection.get(kitName + ".armorContents")).toArray(new ItemStack[0]); + final Kit kit = new Kit(kitName, icon, combo, editable, ranked, mainContents, armorContents, premium, builduhc); + kit.setEnabled(enabled); + this.kitMap.put(kitName, kit); + } + } + + public void saveKits() { + final FileConfiguration fileConfig = this.mainConfig.getConfig(); + fileConfig.set("kits", null); + for (final Map.Entry kitEntry : this.kitMap.entrySet()) { + final String kitName = kitEntry.getKey(); + final Kit kit = kitEntry.getValue(); + if (kit.getIcon() != null && kit.getMainContents() != null && kit.getArmorContents() != null) { + fileConfig.set("kits." + kitName + ".enabled", kit.isEnabled()); + fileConfig.set("kits." + kitName + ".icon", kit.getIcon()); + fileConfig.set("kits." + kitName + ".combo", kit.isCombo()); + fileConfig.set("kits." + kitName + ".editable", kit.isEditable()); + fileConfig.set("kits." + kitName + ".ranked", kit.isRanked()); + fileConfig.set("kits." + kitName + ".premium", kit.isPremium()); + fileConfig.set("kits." + kitName + ".mainContents", kit.getMainContents()); + fileConfig.set("kits." + kitName + ".armorContents", kit.getArmorContents()); + fileConfig.set("kits." + kitName + ".builduhc", kit.isBuilduhc()); + } + } + this.mainConfig.save(); + } + + public void openEditiKitsInventory(final Player player, final Kit defaultKit, final PlayerKit kit) { + final Inventory inventory = Bukkit.createInventory(null, 54, "Editing Kit"); + inventory.setItem(0, UtilItem.createItem(Material.BOOK, 1, (short)0, ChatColor.YELLOW + "You are Editing (" + ChatColor.GREEN + defaultKit.getName() + " #" + kit.getKitIndex() + ChatColor.YELLOW + ")", Arrays.asList("", ChatColor.GRAY + "Kit Name:", kit.getDisplayName()))); + for (int i = 1; i <= 4; ++i) { + inventory.setItem(i, UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)7, " ")); + } + inventory.setItem(5, UtilItem.createItem(Material.STAINED_CLAY, 1, (short)13, ChatColor.GREEN.toString() + ChatColor.BOLD + "SAVE")); + inventory.setItem(6, UtilItem.createItem(Material.STAINED_CLAY, 1, (short)14, ChatColor.RED.toString() + ChatColor.BOLD + "CANCEL")); + inventory.setItem(7, UtilItem.createItem(Material.STAINED_CLAY, 1, (short)4, ChatColor.YELLOW.toString() + "Clear Inventory")); + inventory.setItem(8, UtilItem.createItem(Material.STAINED_CLAY, 1, (short)0, ChatColor.GRAY.toString() + "Load Default Kit")); + for (int i = 9; i <= 17; ++i) { + inventory.setItem(i, UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)7, " ")); + } + inventory.setItem(19, UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)7, " ")); + inventory.setItem(28, UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)7, " ")); + inventory.setItem(37, UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)7, " ")); + inventory.setItem(46, UtilItem.createItem(Material.STAINED_GLASS_PANE, 1, (short)7, " ")); + int i = 45; + for (final ItemStack armor : defaultKit.getArmorContents()) { + final ItemMeta meta = armor.getItemMeta(); + meta.setLore(Arrays.asList("", ChatColor.RED + "This is automatically equipped")); + armor.setItemMeta(meta); + inventory.setItem(i, armor); + i -= 9; + } + for (final ItemStack item : defaultKit.getEditableContents()) { + final int availableSlot = inventory.firstEmpty(); + if (availableSlot != -1) { + inventory.setItem(availableSlot, item); + } + } + inventory.setItem(53, UtilItem.createItem(Material.POTION, 64, (short)16421, ChatColor.LIGHT_PURPLE + "Fill Empty Spots")); + inventory.setItem(52, UtilItem.createItem(Material.BUCKET, 1, (short)0, ChatColor.RED + "Throw items here")); + player.openInventory(inventory); + } + + private void saveMongo() { + for (final Kit kit : this.kitMap.values()) { + final Document document = new Document(); + document.put("name", kit.getName()); + this.handler.getPlugin().getPracticeDatabase().getKits().replaceOne(Filters.eq("name", kit.getName()), document, new UpdateOptions().upsert(true)); + } + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/PartyManager.java b/src/main/java/us/centile/practice/manager/managers/PartyManager.java new file mode 100644 index 0000000..d7f10a6 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/PartyManager.java @@ -0,0 +1,72 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.party.*; +import us.centile.practice.manager.*; +import java.util.*; +import org.bukkit.entity.*; + +public class PartyManager extends Manager +{ + private Map leaderUUIDtoParty; + private Map playerUUIDtoLeaderUUID; + + public PartyManager(final ManagerHandler handler) { + super(handler); + this.leaderUUIDtoParty = new HashMap(); + this.playerUUIDtoLeaderUUID = new HashMap(); + } + + public Party getParty(final UUID player) { + if (this.leaderUUIDtoParty.containsKey(player)) { + return this.leaderUUIDtoParty.get(player); + } + if (this.playerUUIDtoLeaderUUID.containsKey(player)) { + final UUID leader = this.playerUUIDtoLeaderUUID.get(player); + return this.leaderUUIDtoParty.get(leader); + } + return null; + } + + public Map getPartyMap() { + return this.leaderUUIDtoParty; + } + + public Party createParty(final UUID leader, final String leadername) { + final Party party = new Party(leader, leadername); + this.leaderUUIDtoParty.put(leader, party); + return party; + } + + public void destroyParty(final UUID leader) { + final Party party = this.leaderUUIDtoParty.get(leader); + this.leaderUUIDtoParty.remove(leader); + for (final UUID member : party.getMembers()) { + this.playerUUIDtoLeaderUUID.remove(member); + } + } + + public void leaveParty(final UUID player) { + final UUID leader = this.playerUUIDtoLeaderUUID.get(player); + this.playerUUIDtoLeaderUUID.remove(player); + final Party party = this.leaderUUIDtoParty.get(leader); + party.removeMember(player); + } + + public void joinParty(final UUID leader, final UUID player) { + final Party party = this.leaderUUIDtoParty.get(leader); + party.addMember(player); + this.playerUUIDtoLeaderUUID.put(player, leader); + } + + public void notifyParty(final Party party, final String message) { + final Player leaderPlayer = this.handler.getPlugin().getServer().getPlayer(party.getLeader()); + leaderPlayer.sendMessage(message); + for (final UUID uuid : party.getMembers()) { + final Player memberPlayer = this.handler.getPlugin().getServer().getPlayer(uuid); + if (memberPlayer == null) { + continue; + } + memberPlayer.sendMessage(message); + } + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/PracticePlayerManager.java b/src/main/java/us/centile/practice/manager/managers/PracticePlayerManager.java new file mode 100644 index 0000000..a5fd0da --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/PracticePlayerManager.java @@ -0,0 +1,168 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.manager.*; +import us.centile.practice.player.*; +import us.centile.practice.runnables.*; +import org.bukkit.plugin.*; +import org.bukkit.craftbukkit.v1_8_R3.entity.*; +import org.bukkit.entity.*; +import org.bukkit.inventory.*; +import org.bukkit.*; +import us.centile.practice.util.*; +import us.centile.practice.scoreboard.provider.*; +import us.centile.practice.scoreboard.*; +import us.centile.practice.kit.*; +import java.util.*; + +public class PracticePlayerManager extends Manager +{ + public PracticePlayerManager(final ManagerHandler handler) { + super(handler); + } + + public void disable() { + for (final PracticePlayer profile : PracticePlayer.getProfiles()) { + profile.save(); + } + for (final Player player : PlayerUtility.getOnlinePlayers()) { + new SavePlayerConfig(player.getUniqueId(), this.handler.getPlugin()).run(); + } + } + + private void loadPlayerData(final PracticePlayer player) { + player.setCurrentState(PlayerState.LOADING); + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new LoadPlayerTask(this.handler.getPlugin(), player)); + } + + public void createPracticePlayer(final Player player) { + final PracticePlayer practicePlayer = new PracticePlayer(player.getUniqueId(), true); + this.sendToLobby(player); + this.loadPlayerData(practicePlayer); + } + + public PracticePlayer getPracticePlayer(final Player player) { + return PracticePlayer.getByUuid(player.getUniqueId()); + } + + public PracticePlayer getPracticePlayer(final UUID uuid) { + return PracticePlayer.getByUuid(uuid); + } + + public void removePracticePlayer(final Player player) { + this.handler.getPlugin().getServer().getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new SavePlayerConfig(player.getUniqueId(), this.handler.getPlugin())); + } + + public void sendToLobby(final Player player) { + for (final Player onlinePlayer : PlayerUtility.getOnlinePlayers()) { + onlinePlayer.showPlayer(player); + player.showPlayer(onlinePlayer); + } + ((CraftPlayer)player).getHandle().p(); + UtilPlayer.clear(player); + final PracticePlayer practicePlayer = PracticePlayer.getByUuid(player.getUniqueId()); + if (practicePlayer == null) { + return; + } + Projectile current; + while ((current = practicePlayer.getProjectileQueue().poll()) != null) { + current.remove(); + } + practicePlayer.setCurrentState(PlayerState.LOBBY); + practicePlayer.setTeamNumber(0); + if (this.handler.getPlugin().getSpawn() != null) { + player.teleport(this.handler.getPlugin().getSpawn()); + } + if (this.handler.getPartyManager().getParty(player.getUniqueId()) != null) { + player.getInventory().setContents(this.handler.getItemManager().getPartyItems()); + player.updateInventory(); + } + else if (this.handler.getSpectatorManager().isSpectatorMode(player)) { + player.getInventory().setContents(this.handler.getItemManager().getSpectatorModeItems()); + player.updateInventory(); + practicePlayer.setCurrentState(PlayerState.SPECTATING); + } + else { + player.getInventory().setContents(this.handler.getItemManager().getSpawnItems()); + if (practicePlayer.isShowRematchItemFlag()) { + practicePlayer.setShowRematchItemFlag(false); + final ItemStack itemStack = new ItemStack(Material.BLAZE_POWDER); + UtilItem.name(itemStack, ChatColor.GOLD + "Request Rematch"); + player.getInventory().setItem(3, itemStack); + } + player.updateInventory(); + } + final PlayerBoard playerBoard = this.handler.getScoreboardHandler().getPlayerBoard(player.getUniqueId()); + if (playerBoard != null) { + playerBoard.setDefaultSidebar(new LobbyScoreboardProvider(this.handler.getPlugin()), 2L); + playerBoard.setSidebarVisible(practicePlayer.isScoreboard()); + } + } + + public void returnItems(final Player player) { + Bukkit.getScheduler().runTaskLaterAsynchronously(this.handler.getPlugin(), new Runnable() { + @Override + public void run() { + UtilPlayer.clear(player); + final PracticePlayer practicePlayer = PracticePlayer.getByUuid(player.getUniqueId()); + if (practicePlayer != null) { + practicePlayer.setCurrentState(PlayerState.LOBBY); + practicePlayer.setTeamNumber(0); + if (PracticePlayerManager.this.handler.getPartyManager().getParty(player.getUniqueId()) != null) { + player.getInventory().setContents(PracticePlayerManager.this.handler.getItemManager().getPartyItems()); + player.updateInventory(); + } + else { + player.getInventory().setContents(PracticePlayerManager.this.handler.getItemManager().getSpawnItems()); + player.updateInventory(); + } + } + } + }, 1L); + } + + public int getGlobalElo(final PracticePlayer player, final boolean solo) { + int i = 0; + int count = 0; + for (final Kit kit : this.handler.getKitManager().getKitMap().values()) { + if (solo) { + i += player.getEloMap().get(kit.getName()); + ++count; + } + else { + if (!player.getPartyEloMap().containsKey(player.getUUID())) { + continue; + } + if (!player.getPartyEloMap().get(player.getUUID()).containsKey(kit.getName())) { + continue; + } + i += player.getPartyEloMap().get(player.getUUID()).get(kit.getName()); + ++count; + } + } + if (i == 0) { + i = 1; + } + if (count == 0) { + count = 1; + } + return Math.round(i / count); + } + + public int getPremiumElo(final PracticePlayer player) { + int i = 0; + int count = 0; + for (final Kit kit : this.handler.getKitManager().getKitMap().values()) { + if (kit.isPremium()) { + i += player.getPremiumEloMap().get(kit.getName()); + ++count; + } + } + if (i == 0) { + i = 1; + } + if (count == 0) { + count = 1; + } + return Math.round(i / count); + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/QueueManager.java b/src/main/java/us/centile/practice/manager/managers/QueueManager.java new file mode 100644 index 0000000..7ef9096 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/QueueManager.java @@ -0,0 +1,246 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.manager.*; +import java.util.concurrent.*; +import org.bukkit.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.plugin.*; +import java.util.*; + +public class QueueManager extends Manager +{ + private Map unrankedKitQueueMap; + private Map> rankedKitQueueMap; + private Map partyUnrankedKitQueueMap; + private Map> partyRankedKitQueueMap; + private Map> premiumKitQueueMap; + private int rankedQueueCount; + private int unrankedQueueCount; + private int premiumQueueCount; + + public QueueManager(final ManagerHandler handler) { + super(handler); + this.unrankedKitQueueMap = new ConcurrentHashMap(); + this.rankedKitQueueMap = new ConcurrentHashMap>(); + this.partyUnrankedKitQueueMap = new ConcurrentHashMap(); + this.partyRankedKitQueueMap = new ConcurrentHashMap>(); + this.premiumKitQueueMap = new ConcurrentHashMap>(); + this.rankedQueueCount = 0; + this.unrankedQueueCount = 0; + this.premiumQueueCount = 0; + } + + public boolean isUnrankedQueueEmpty(final String kitName) { + return !this.unrankedKitQueueMap.containsKey(kitName); + } + + public void addToUnrankedQueue(final String kitName, final UUID uuid) { + this.unrankedKitQueueMap.put(kitName, uuid); + ++this.unrankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.UNRANKED_SOLO)); + } + + public UUID getQueuedForUnrankedQueue(final String kitName) { + return this.unrankedKitQueueMap.get(kitName); + } + + public void removePlayerFromUnrankedQueue(final String kitName) { + this.unrankedKitQueueMap.remove(kitName); + --this.unrankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.UNRANKED_SOLO)); + } + + public boolean isRankedQueueEmpty(final String kitName) { + return !this.rankedKitQueueMap.containsKey(kitName) || this.rankedKitQueueMap.get(kitName).size() == 0; + } + + public void addToRankedQueue(final String kitName, final UUID uuid) { + if (!this.rankedKitQueueMap.containsKey(kitName)) { + this.rankedKitQueueMap.put(kitName, new ArrayList()); + } + final List uuidList = this.rankedKitQueueMap.get(kitName); + uuidList.add(uuid); + this.rankedKitQueueMap.put(kitName, uuidList); + ++this.rankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.RANKED_SOLO)); + } + + public List getQueuedForRankedQueue(final String kitName) { + if (!this.rankedKitQueueMap.containsKey(kitName)) { + return null; + } + return this.rankedKitQueueMap.get(kitName); + } + + public void removePlayerFromRankedQueue(final String kitName, final UUID playerUuid) { + if (!this.rankedKitQueueMap.containsKey(kitName)) { + this.rankedKitQueueMap.put(kitName, new ArrayList()); + } + final List uuidList = this.rankedKitQueueMap.get(kitName); + uuidList.remove(playerUuid); + this.rankedKitQueueMap.put(kitName, uuidList); + --this.rankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.RANKED_SOLO)); + } + + public boolean isPremiumQueueEmpty(final String kitName) { + return !this.premiumKitQueueMap.containsKey(kitName) || this.premiumKitQueueMap.get(kitName).size() == 0; + } + + public void addToPremiumQueue(final String kitName, final UUID uuid) { + if (!this.premiumKitQueueMap.containsKey(kitName)) { + this.premiumKitQueueMap.put(kitName, new ArrayList()); + } + final List uuidList = this.premiumKitQueueMap.get(kitName); + uuidList.add(uuid); + this.premiumKitQueueMap.put(kitName, uuidList); + ++this.premiumQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.PREMIUM_SOLO)); + } + + public List getQueuedForPremiumQueue(final String kitName) { + if (!this.premiumKitQueueMap.containsKey(kitName)) { + return null; + } + return this.premiumKitQueueMap.get(kitName); + } + + public void removePlayerFromPremiumQueue(final String kitName, final UUID playerUuid) { + if (!this.premiumKitQueueMap.containsKey(kitName)) { + this.premiumKitQueueMap.put(kitName, new ArrayList()); + } + final List uuidList = this.premiumKitQueueMap.get(kitName); + uuidList.remove(playerUuid); + this.premiumKitQueueMap.put(kitName, uuidList); + --this.premiumQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.PREMIUM_SOLO)); + } + + public void unqueueSingleQueue(final UUID playerUuid) { + for (final Map.Entry mapEntry : this.unrankedKitQueueMap.entrySet()) { + final String kitName = mapEntry.getKey(); + final UUID queued = mapEntry.getValue(); + if (queued != playerUuid) { + continue; + } + --this.unrankedQueueCount; + this.unrankedKitQueueMap.remove(kitName); + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.UNRANKED_SOLO)); + } + for (final Map.Entry> mapEntry2 : this.rankedKitQueueMap.entrySet()) { + final String kitName = mapEntry2.getKey(); + final List queuedUuidList = mapEntry2.getValue(); + if (!queuedUuidList.contains(playerUuid)) { + continue; + } + queuedUuidList.remove(playerUuid); + this.rankedKitQueueMap.put(kitName, queuedUuidList); + --this.rankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.RANKED_SOLO)); + } + for (final Map.Entry> mapEntry2 : this.premiumKitQueueMap.entrySet()) { + final String kitName = mapEntry2.getKey(); + final List queuedUuidList = mapEntry2.getValue(); + if (!queuedUuidList.contains(playerUuid)) { + continue; + } + queuedUuidList.remove(playerUuid); + this.premiumKitQueueMap.put(kitName, queuedUuidList); + --this.premiumQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.PREMIUM_SOLO)); + } + } + + public boolean isUnrankedPartyQueueEmpty(final String kitName) { + return !this.partyUnrankedKitQueueMap.containsKey(kitName); + } + + public void addToPartyUnrankedQueue(final String kitName, final UUID uuid) { + this.partyUnrankedKitQueueMap.put(kitName, uuid); + ++this.unrankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.UNRANKED_PARTY)); + } + + public UUID getQueuedForPartyUnrankedQueue(final String kitName) { + return this.partyUnrankedKitQueueMap.get(kitName); + } + + public void removePartyFromPartyUnrankedQueue(final String kitName) { + this.partyUnrankedKitQueueMap.remove(kitName); + --this.unrankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.UNRANKED_PARTY)); + } + + public boolean isRankedPartyQueueEmpty(final String kitName) { + return !this.partyRankedKitQueueMap.containsKey(kitName) || this.partyRankedKitQueueMap.get(kitName).size() == 0; + } + + public void addToPartyRankedQueue(final String kitName, final UUID uuid) { + if (!this.partyRankedKitQueueMap.containsKey(kitName)) { + this.partyRankedKitQueueMap.put(kitName, new ArrayList()); + } + final List uuidList = this.partyRankedKitQueueMap.get(kitName); + uuidList.add(uuid); + this.partyRankedKitQueueMap.put(kitName, uuidList); + ++this.rankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.RANKED_PARTY)); + } + + public List getQueuedForPartyRankedQueue(final String kitName) { + if (!this.partyRankedKitQueueMap.containsKey(kitName)) { + return null; + } + return this.partyRankedKitQueueMap.get(kitName); + } + + public void removePlayerFromPartyRankedQueue(final String kitName, final UUID playerUuid) { + if (!this.partyRankedKitQueueMap.containsKey(kitName)) { + this.partyRankedKitQueueMap.put(kitName, new ArrayList()); + } + final List uuidList = this.partyRankedKitQueueMap.get(kitName); + uuidList.remove(playerUuid); + this.partyRankedKitQueueMap.put(kitName, uuidList); + --this.rankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.RANKED_PARTY)); + } + + public void unqueuePartyQueue(final UUID leaderUuid) { + for (final Map.Entry mapEntry : this.partyUnrankedKitQueueMap.entrySet()) { + final String kitName = mapEntry.getKey(); + final UUID queued = mapEntry.getValue(); + if (queued != leaderUuid) { + continue; + } + this.partyUnrankedKitQueueMap.remove(kitName); + --this.unrankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.UNRANKED_PARTY)); + } + for (final Map.Entry> mapEntry2 : this.partyRankedKitQueueMap.entrySet()) { + final String kitName = mapEntry2.getKey(); + final List queuedUuidList = mapEntry2.getValue(); + if (!queuedUuidList.contains(leaderUuid)) { + continue; + } + queuedUuidList.remove(leaderUuid); + this.partyRankedKitQueueMap.put(kitName, queuedUuidList); + --this.rankedQueueCount; + Bukkit.getScheduler().runTaskAsynchronously(this.handler.getPlugin(), new UpdateInventoryTask(this.handler.getPlugin(), UpdateInventoryTask.InventoryTaskType.RANKED_PARTY)); + } + } + + public Map> getRankedKitQueueMap() { + return this.rankedKitQueueMap; + } + + public Map> getPartyRankedKitQueueMap() { + return this.partyRankedKitQueueMap; + } + + public Map> getPremiumKitQueueMap() { + return this.premiumKitQueueMap; + } + + public int getTotalInQueues() { + return this.rankedQueueCount + this.unrankedQueueCount + this.premiumQueueCount; + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/RequestManager.java b/src/main/java/us/centile/practice/manager/managers/RequestManager.java new file mode 100644 index 0000000..7fda1d7 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/RequestManager.java @@ -0,0 +1,62 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.duel.*; +import us.centile.practice.manager.*; +import java.util.*; +import org.bukkit.entity.*; +import java.util.concurrent.*; +import us.centile.practice.util.*; + +public class RequestManager extends Manager +{ + private Map> duelRequestMap; + private Map> partyRequestMap; + + public RequestManager(final ManagerHandler handler) { + super(handler); + this.duelRequestMap = new HashMap>(); + this.partyRequestMap = new HashMap>(); + } + + public void addDuelRequest(final Player requested, final Player requester, final DuelRequest request) { + if (!this.hasDuelRequests(requested)) { + this.duelRequestMap.put(requested.getUniqueId(), new TtlHashMap(TimeUnit.SECONDS, 15L)); + } + this.duelRequestMap.get(requested.getUniqueId()).put(requester.getUniqueId(), request); + } + + public boolean hasDuelRequestFromPlayer(final Player requested, final Player requester) { + return this.duelRequestMap.get(requested.getUniqueId()).containsKey(requester.getUniqueId()); + } + + public boolean hasDuelRequests(final Player player) { + return this.duelRequestMap.containsKey(player.getUniqueId()); + } + + public void removeDuelRequest(final Player player, final Player requester) { + this.duelRequestMap.get(player.getUniqueId()).remove(requester.getUniqueId()); + } + + public DuelRequest getDuelRequest(final Player requested, final Player requester) { + return this.duelRequestMap.get(requested.getUniqueId()).get(requester.getUniqueId()); + } + + public void addPartyRequest(final Player requested, final Player requester) { + if (!this.hasPartyRequests(requested)) { + this.partyRequestMap.put(requested.getUniqueId(), new TtlArrayList(TimeUnit.SECONDS, 15L)); + } + this.partyRequestMap.get(requested.getUniqueId()).add(requester.getUniqueId()); + } + + public boolean hasPartyRequestFromPlayer(final Player requested, final Player requester) { + return this.partyRequestMap.get(requested.getUniqueId()).contains(requester.getUniqueId()); + } + + public boolean hasPartyRequests(final Player player) { + return this.partyRequestMap.containsKey(player.getUniqueId()); + } + + public void removePartyRequest(final Player requested, final Player requester) { + this.partyRequestMap.get(requested.getUniqueId()).remove(requester.getUniqueId()); + } +} diff --git a/src/main/java/us/centile/practice/manager/managers/SpectatorManager.java b/src/main/java/us/centile/practice/manager/managers/SpectatorManager.java new file mode 100644 index 0000000..282f0f5 --- /dev/null +++ b/src/main/java/us/centile/practice/manager/managers/SpectatorManager.java @@ -0,0 +1,100 @@ +package us.centile.practice.manager.managers; + +import us.centile.practice.manager.*; +import org.bukkit.entity.*; +import us.centile.practice.player.*; +import us.centile.practice.util.*; +import us.centile.practice.duel.*; +import java.util.*; + +public class SpectatorManager extends Manager +{ + private HashSet spectators; + private Map spectatingMatchUUID; + + public SpectatorManager(final ManagerHandler handler) { + super(handler); + this.spectators = new HashSet(); + this.spectatingMatchUUID = new HashMap(); + } + + public void toggleSpectatorMode(final Player player) { + if (this.spectators.contains(player.getUniqueId())) { + this.spectators.remove(player.getUniqueId()); + this.removeSpectator(player, true); + return; + } + final PracticePlayer practicePlayer = this.handler.getPracticePlayerManager().getPracticePlayer(player); + this.spectators.add(player.getUniqueId()); + practicePlayer.setCurrentState(PlayerState.SPECTATING); + player.getInventory().setContents(this.handler.getItemManager().getSpectatorModeItems()); + player.updateInventory(); + player.setAllowFlight(true); + player.setFlying(true); + } + + public void removeSpectatorMode(final Player player) { + if (this.spectators.contains(player.getUniqueId())) { + this.spectators.remove(player.getUniqueId()); + this.removeSpectator(player, true); + } + } + + public void addSpectator(final Player player, final Player target) { + final Duel duel = this.handler.getDuelManager().getDuelFromPlayer(target.getUniqueId()); + if (duel == null) { + return; + } + this.spectatingMatchUUID.put(player.getUniqueId(), duel.getUUID()); + duel.addSpectator(player.getUniqueId()); + if (duel.getFfaPlayers() != null) { + for (final UUID uuid : duel.getFfaPlayersAlive()) { + final Player player2 = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player2 == null) { + continue; + } + player.showPlayer(player2); + player2.hidePlayer(player); + } + } + else { + for (final UUID uuid : duel.getFirstTeamAlive()) { + final Player player2 = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player2 == null) { + continue; + } + player.showPlayer(player2); + player2.hidePlayer(player); + } + for (final UUID uuid : duel.getSecondTeamAlive()) { + final Player player2 = this.handler.getPlugin().getServer().getPlayer(uuid); + if (player2 == null) { + continue; + } + player.showPlayer(player2); + player2.hidePlayer(player); + } + } + UtilPlayer.clear(player); + player.setAllowFlight(true); + player.setFlying(true); + player.teleport(target.getLocation().add(0.0, 3.5, 0.0)); + player.getInventory().setContents(this.handler.getItemManager().getSpecItems()); + player.updateInventory(); + } + + public void removeSpectator(final Player player, final boolean forced) { + if (this.spectatingMatchUUID.containsKey(player.getUniqueId())) { + final Duel duel = this.handler.getDuelManager().getDuelByUUID(this.spectatingMatchUUID.get(player.getUniqueId())); + if (duel != null && forced) { + duel.getSpectators().remove(player.getUniqueId()); + } + } + this.spectatingMatchUUID.remove(player.getUniqueId()); + this.handler.getPracticePlayerManager().sendToLobby(player); + } + + public boolean isSpectatorMode(final Player player) { + return this.spectators.contains(player.getUniqueId()); + } +} diff --git a/src/main/java/us/centile/practice/nPractice.java b/src/main/java/us/centile/practice/nPractice.java new file mode 100644 index 0000000..73f42e7 --- /dev/null +++ b/src/main/java/us/centile/practice/nPractice.java @@ -0,0 +1,122 @@ +package us.centile.practice; + +import org.bukkit.plugin.java.*; +import us.centile.practice.manager.*; +import us.centile.practice.util.database.*; +import java.util.regex.*; +import org.bukkit.*; +import us.centile.practice.scoreboard.*; +import us.centile.practice.util.*; +import org.bukkit.event.*; +import us.centile.practice.listeners.*; +import us.centile.practice.tournament.*; +import org.bukkit.plugin.*; +import org.bukkit.command.*; +import us.centile.practice.commands.*; +import us.centile.practice.settings.*; + +public class nPractice extends JavaPlugin +{ + private static nPractice instance; + private ManagerHandler managerHandler; + private Location spawn; + PracticeDatabase practiceDatabase; + public static Pattern splitPattern; + public static final Pattern UUID_PATTER; + public static String MAIN_COLOR; + public static String SIDE_COLOR; + public static String EXTRA_COLOR; + + public void onEnable() { + nPractice.instance = this; + this.getConfig().options().copyDefaults(true); + this.saveConfig(); + SidebarProvider.SCOREBOARD_TITLE = ChatColor.translateAlternateColorCodes('&', this.getConfig().getString("SCOREBOARD_TITLE")); + this.practiceDatabase = new PracticeDatabase(this); + this.managerHandler = new ManagerHandler(this); + if (this.getConfig().contains("spawn")) { + this.spawn = LocationSerializer.deserializeLocation(this.getConfig().getString("spawn")); + } + try { + nPractice.MAIN_COLOR = ChatColor.valueOf(this.getConfig().getString("COLORS.MAIN_COLOR").toUpperCase()).toString(); + nPractice.SIDE_COLOR = ChatColor.valueOf(this.getConfig().getString("COLORS.SIDE_COLOR").toUpperCase()).toString(); + nPractice.EXTRA_COLOR = ChatColor.valueOf(this.getConfig().getString("COLORS.EXTRA_COLOR").toUpperCase()).toString(); + } + catch (Exception e) { + System.out.print(e.getClass() + ": " + e.getMessage()); + System.out.print("Oops your config colors are invalid, colors has been set to default."); + System.out.print("Oops your config colors are invalid, colors has been set to default."); + System.out.print("Oops your config colors are invalid, colors has been set to default."); + } + this.registerListeners(); + this.registerCommands(); + nPractice.splitPattern = Pattern.compile("\\s"); + } + + public void onDisable() { + this.reloadConfig(); + this.managerHandler.disable(); + } + + private void registerListeners() { + final PluginManager pm = this.getServer().getPluginManager(); + pm.registerEvents(new PlayerListener(this), this); + pm.registerEvents(new HitDetectionListener(this), this); + pm.registerEvents(new InventoryListener(this), this); + pm.registerEvents(new EntityListener(this), this); + pm.registerEvents(new DuelListener(this), this); + pm.registerEvents(new BlockListener(this), this); + pm.registerEvents(new TournamentListener(), this); + } + + private void registerCommands() { + this.getCommand("arena").setExecutor(new ArenaCommand(this)); + this.getCommand("duel").setExecutor(new DuelCommand(this)); + this.getCommand("accept").setExecutor(new AcceptCommand(this)); + this.getCommand("kit").setExecutor(new KitCommand(this)); + this.getCommand("spectate").setExecutor(new SpectateCommand(this)); + this.getCommand("builder").setExecutor(new BuilderCommand(this)); + this.getCommand("inventory").setExecutor(new InventoryCommand(this)); + this.getCommand("party").setExecutor(new PartyCommand(this)); + this.getCommand("reset").setExecutor(new ResetEloCommand(this)); + this.getCommand("join").setExecutor(new JoinCommand(this)); + this.getCommand("leave").setExecutor(new LeaveCommand(this)); + this.getCommand("credits").setExecutor(new CreditsCommand(this)); + this.getCommand("tournament").setExecutor(new TournamentCommand(this)); + this.getCommand("scoreboard").setExecutor(new ScoreboardCommand(this)); + this.getCommand("setspawn").setExecutor(new SetSpawnCommand(this)); + this.getCommand("tokens").setExecutor(new PremiumTokensCommand(this)); + this.getCommand("matches").setExecutor(new MatchesCommand(this)); + this.getCommand("host").setExecutor(new HostCommand(this)); + this.getCommand("ping").setExecutor(new PingCommand(this)); + this.getCommand("premiumtop").setExecutor(new SortPremiumEloCommand(this)); + this.getCommand("setting").setExecutor(new SettingsHandler(this)); + } + + public ManagerHandler getManagerHandler() { + return this.managerHandler; + } + + public static nPractice getInstance() { + return nPractice.instance; + } + + public PracticeDatabase getPracticeDatabase() { + return this.practiceDatabase; + } + + public Location getSpawn() { + return this.spawn; + } + + public void setSpawn(final Location spawn) { + this.spawn = spawn; + } + + static { + nPractice.MAIN_COLOR = ChatColor.DARK_GREEN.toString(); + nPractice.SIDE_COLOR = ChatColor.GREEN.toString(); + nPractice.EXTRA_COLOR = ChatColor.GRAY.toString(); + UUID_PATTER = Pattern.compile("[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}"); + } +} diff --git a/src/main/java/us/centile/practice/party/Party.java b/src/main/java/us/centile/practice/party/Party.java new file mode 100644 index 0000000..7aa2575 --- /dev/null +++ b/src/main/java/us/centile/practice/party/Party.java @@ -0,0 +1,73 @@ +package us.centile.practice.party; + +import org.bukkit.*; +import java.util.*; +import org.bukkit.entity.*; + +public class Party +{ + private List memberUUIDs; + private UUID partyLeader; + private String leaderName; + private PartyState partyState; + private boolean open; + + public Party(final UUID partyLeader, final String leaderName) { + this.memberUUIDs = new ArrayList(); + this.partyLeader = partyLeader; + this.leaderName = leaderName; + this.partyState = PartyState.LOBBY; + } + + public void addMember(final UUID uuid) { + this.memberUUIDs.add(uuid); + } + + public void removeMember(final UUID uuid) { + this.memberUUIDs.remove(uuid); + } + + public void setOpen(final boolean open) { + this.open = open; + } + + public void setPartyState(final PartyState state) { + this.partyState = state; + } + + public List getMembers() { + return this.memberUUIDs; + } + + public UUID getLeader() { + return this.partyLeader; + } + + public String getLeaderName() { + return this.leaderName; + } + + public boolean isOpen() { + return this.open; + } + + public PartyState getPartyState() { + return this.partyState; + } + + public int getSize() { + return this.getMembers().size() + 1; + } + + public List getAllMembersOnline() { + final List membersOnline = new ArrayList(); + for (final UUID memberUUID : this.memberUUIDs) { + final Player member = Bukkit.getPlayer(memberUUID); + if (member != null) { + membersOnline.add(member.getUniqueId()); + } + } + membersOnline.add(this.partyLeader); + return membersOnline; + } +} diff --git a/src/main/java/us/centile/practice/party/PartyState.java b/src/main/java/us/centile/practice/party/PartyState.java new file mode 100644 index 0000000..83149eb --- /dev/null +++ b/src/main/java/us/centile/practice/party/PartyState.java @@ -0,0 +1,7 @@ +package us.centile.practice.party; + +public enum PartyState +{ + LOBBY, + DUELING; +} diff --git a/src/main/java/us/centile/practice/player/Match.java b/src/main/java/us/centile/practice/player/Match.java new file mode 100644 index 0000000..67f5a8d --- /dev/null +++ b/src/main/java/us/centile/practice/player/Match.java @@ -0,0 +1,97 @@ +package us.centile.practice.player; + +import java.util.*; + +public class Match +{ + UUID matchId; + private String firstTeam; + private String secondTeam; + boolean ranked; + String items; + String armor; + String potions; + int eloChangeWinner; + int eloChangeLoser; + int winningTeamId; + + public UUID getMatchId() { + return this.matchId; + } + + public void setMatchId(final UUID matchId) { + this.matchId = matchId; + } + + public String getFirstTeam() { + return this.firstTeam; + } + + public void setFirstTeam(final String firstTeam) { + this.firstTeam = firstTeam; + } + + public String getSecondTeam() { + return this.secondTeam; + } + + public void setSecondTeam(final String secondTeam) { + this.secondTeam = secondTeam; + } + + public boolean isRanked() { + return this.ranked; + } + + public void setRanked(final boolean ranked) { + this.ranked = ranked; + } + + public String getItems() { + return this.items; + } + + public void setItems(final String items) { + this.items = items; + } + + public String getArmor() { + return this.armor; + } + + public void setArmor(final String armor) { + this.armor = armor; + } + + public String getPotions() { + return this.potions; + } + + public void setPotions(final String potions) { + this.potions = potions; + } + + public int getEloChangeWinner() { + return this.eloChangeWinner; + } + + public void setEloChangeWinner(final int eloChangeWinner) { + this.eloChangeWinner = eloChangeWinner; + } + + public int getEloChangeLoser() { + return this.eloChangeLoser; + } + + public void setEloChangeLoser(final int eloChangeLoser) { + this.eloChangeLoser = eloChangeLoser; + } + + public int getWinningTeamId() { + return this.winningTeamId; + } + + public void setWinningTeamId(final int winningTeamId) { + this.winningTeamId = winningTeamId; + } +} diff --git a/src/main/java/us/centile/practice/player/PlayerInventorySnapshot.java b/src/main/java/us/centile/practice/player/PlayerInventorySnapshot.java new file mode 100644 index 0000000..b14bc13 --- /dev/null +++ b/src/main/java/us/centile/practice/player/PlayerInventorySnapshot.java @@ -0,0 +1,92 @@ +package us.centile.practice.player; + +import org.bukkit.potion.*; +import org.bukkit.entity.*; +import org.bukkit.inventory.*; +import org.bukkit.*; +import us.centile.practice.util.*; +import java.util.*; + +public class PlayerInventorySnapshot +{ + private String playerName; + private UUID uuid; + private ItemStack[] mainContent; + private ItemStack[] armorContent; + private Collection potionEffects; + private int food; + private double health; + private Inventory inventory; + + public PlayerInventorySnapshot(final Player player) { + this.playerName = player.getName(); + this.uuid = player.getUniqueId(); + this.mainContent = player.getInventory().getContents(); + this.armorContent = player.getInventory().getArmorContents(); + this.potionEffects = (Collection)player.getActivePotionEffects(); + this.food = player.getFoodLevel(); + this.health = player.getHealth(); + this.initInventory(); + } + + private void initInventory() { + this.inventory = Bukkit.createInventory((InventoryHolder)null, 54, this.playerName + "'s inventory"); + final double roundedHealth = Math.round(this.health / 2.0 * 2.0) / 2.0; + final ItemStack skull = UtilItem.createItem(Material.SKULL_ITEM, (int)Math.round(this.health), (short)0, ChatColor.RED.toString() + ChatColor.BOLD + "\u2764 " + roundedHealth + " HP"); + this.inventory.setItem(44, skull); + final ItemStack melon = UtilItem.createItem(Material.COOKED_BEEF, this.food, (short)0, ChatColor.GREEN.toString() + ChatColor.BOLD + "" + this.food + " Hunger"); + this.inventory.setItem(43, melon); + final List lores = new ArrayList(); + for (final PotionEffect effect : this.potionEffects) { + final int duration = effect.getDuration(); + final String durationMinuteSecond = UtilMath.convertTicksToMinutes(duration); + final String effectAmplifierRoman = UtilString.romanNumerals(effect.getAmplifier() + 1); + String effectName = effect.getType().getName().toLowerCase(); + effectName = effectName.replace('_', ' '); + effectName = effectName.substring(0, 1).toUpperCase() + effectName.substring(1); + lores.add(ChatColor.RESET + effectName + " " + effectAmplifierRoman + " (" + durationMinuteSecond + ")"); + } + final ItemStack brewingStand = UtilItem.createItem(Material.BREWING_STAND_ITEM, this.potionEffects.size(), (short)0, ChatColor.GOLD.toString() + ChatColor.BOLD + "Potion Effects", lores); + this.inventory.setItem(42, brewingStand); + int healthPotAmount = 0; + for (int i = 0; i < 36; ++i) { + if (this.mainContent[i] != null && this.mainContent[i].getType() == Material.POTION && this.mainContent[i].getDurability() == 16421) { + ++healthPotAmount; + } + } + if (healthPotAmount > 0) { + final ItemStack healthPot = UtilItem.createItem(Material.POTION, healthPotAmount, (short)16421, ChatColor.LIGHT_PURPLE.toString() + ChatColor.BOLD + "" + healthPotAmount + " Health Pot(s)"); + this.inventory.setItem(49, healthPot); + } + for (int i = 0; i < 36; ++i) { + if (this.mainContent[i] != null) { + this.inventory.setItem(i, this.mainContent[i]); + } + } + for (int i = 36; i <= 39; ++i) { + if (this.armorContent[39 - i] != null) { + this.inventory.setItem(i, this.armorContent[39 - i]); + } + } + } + + public Collection getPotionEffects() { + return this.potionEffects; + } + + public ItemStack[] getArmorContent() { + return this.armorContent; + } + + public ItemStack[] getMainContent() { + return this.mainContent; + } + + public UUID getUUID() { + return this.uuid; + } + + public Inventory getInventory() { + return this.inventory; + } +} diff --git a/src/main/java/us/centile/practice/player/PlayerKit.java b/src/main/java/us/centile/practice/player/PlayerKit.java new file mode 100644 index 0000000..ff8f096 --- /dev/null +++ b/src/main/java/us/centile/practice/player/PlayerKit.java @@ -0,0 +1,52 @@ +package us.centile.practice.player; + +import org.bukkit.inventory.*; + +public class PlayerKit +{ + private String kitName; + private int kitIndex; + private String displayName; + private ItemStack[] mainContents; + private ItemStack[] armorContents; + + public PlayerKit(final String kitName, final int kitIndex, final String displayName, final ItemStack[] mainContents, final ItemStack[] armorContents) { + this.kitName = kitName; + this.kitIndex = kitIndex; + this.displayName = displayName; + this.mainContents = mainContents; + this.armorContents = armorContents; + } + + public String getKitName() { + return this.kitName; + } + + public int getKitIndex() { + return this.kitIndex; + } + + public String getDisplayName() { + return this.displayName; + } + + public ItemStack[] getMainContents() { + return this.mainContents; + } + + public ItemStack[] getArmorContents() { + return this.armorContents; + } + + public void setDisplayName(final String displayName) { + this.displayName = displayName; + } + + public void setMainContents(final ItemStack[] mainContents) { + this.mainContents = mainContents; + } + + public void setArmorContents(final ItemStack[] armorContents) { + this.armorContents = armorContents; + } +} diff --git a/src/main/java/us/centile/practice/player/PlayerState.java b/src/main/java/us/centile/practice/player/PlayerState.java new file mode 100644 index 0000000..d392679 --- /dev/null +++ b/src/main/java/us/centile/practice/player/PlayerState.java @@ -0,0 +1,13 @@ +package us.centile.practice.player; + +public enum PlayerState +{ + LOADING, + LOBBY, + QUEUE, + WAITING, + FIGHTING, + SPECTATING, + BUILDER, + EDITING; +} diff --git a/src/main/java/us/centile/practice/player/PracticePlayer.java b/src/main/java/us/centile/practice/player/PracticePlayer.java new file mode 100644 index 0000000..f8cfb6e --- /dev/null +++ b/src/main/java/us/centile/practice/player/PracticePlayer.java @@ -0,0 +1,460 @@ +package us.centile.practice.player; + +import us.centile.practice.*; +import us.centile.practice.settings.*; +import com.google.common.collect.*; +import org.bukkit.entity.*; +import org.bukkit.*; +import org.bson.*; +import com.google.gson.*; +import com.mongodb.client.model.*; +import org.json.simple.*; +import java.net.*; +import java.io.*; +import org.json.simple.parser.*; +import java.util.*; + +public class PracticePlayer +{ + private static Set profiles; + public static nPractice main; + private UUID uuid; + private String name; + private PlayerState currentState; + private int teamNumber; + private int rankPremiumTokens; + private int premiumTokens; + private int premiumWins; + private int premiumLosses; + private int rankedWins; + private int rankedLosses; + private int unrankedWins; + private int unrankedLosses; + private int globalPersonalElo; + private int globalPartyElo; + private int globalPremiumElo; + private int credits; + private boolean scoreboard; + private long hostCooldown; + private List matches; + private Map> playerKitMap; + private Map playerEloMap; + private Map premiumEloMap; + private Map> partyEloMap; + private Settings settings; + private transient LinkedList projectileQueue; + private transient boolean showRematchItemFlag; + private transient String lastDuelPlayer; + + public PracticePlayer(final UUID uuid, final boolean cache) { + this.settings = new Settings(); + this.projectileQueue = Lists.newLinkedList(); + this.playerEloMap = new HashMap(); + this.playerKitMap = new HashMap>(); + this.premiumEloMap = new HashMap(); + this.partyEloMap = new HashMap>(); + this.matches = new ArrayList(); + this.uuid = uuid; + this.currentState = PlayerState.LOBBY; + this.premiumTokens = 0; + this.rankPremiumTokens = 0; + this.rankedWins = 0; + this.unrankedWins = 0; + this.premiumWins = 0; + this.rankedLosses = 0; + this.unrankedLosses = 0; + this.premiumLosses = 0; + this.credits = 0; + this.globalPartyElo = 0; + this.globalPersonalElo = 0; + this.globalPremiumElo = 0; + this.hostCooldown = 0L; + this.scoreboard = true; + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + this.name = player.getName(); + } + else { + final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid); + if (offlinePlayer != null) { + this.name = offlinePlayer.getName(); + } + } + this.load(); + if (cache) { + PracticePlayer.profiles.add(this); + } + } + + public int getCredits() { + return this.credits; + } + + public long getHostCooldown() { + return this.hostCooldown; + } + + public void setHostCooldown(final long hostCooldown) { + this.hostCooldown = hostCooldown; + } + + public boolean isScoreboard() { + return this.scoreboard; + } + + public void setScoreboard(final boolean scoreboard) { + this.scoreboard = scoreboard; + } + + public void setCredits(final int credits) { + this.credits = credits; + } + + public int getTeamNumber() { + return this.teamNumber; + } + + public UUID getUUID() { + return this.uuid; + } + + public String getName() { + return this.name; + } + + public PlayerState getCurrentState() { + return this.currentState; + } + + public void setTeamNumber(final int i) { + this.teamNumber = i; + } + + public void addElo(final String kitName, final int elo) { + this.playerEloMap.put(kitName, elo); + } + + public void addPremiumElo(final String kitName, final int elo) { + this.premiumEloMap.put(kitName, elo); + } + + public void addPartyElo(final UUID uuid, final String kitName, final int elo) { + if (!this.partyEloMap.containsKey(uuid)) { + this.partyEloMap.put(uuid, new HashMap()); + } + this.partyEloMap.get(uuid).put(kitName, elo); + } + + public void addKit(final String kitName, final Integer kitIndex, final PlayerKit playerKit) { + if (!this.playerKitMap.containsKey(kitName)) { + this.playerKitMap.put(kitName, new HashMap()); + } + this.playerKitMap.get(kitName).put(kitIndex, playerKit); + } + + public void setCurrentState(final PlayerState playerState) { + this.currentState = playerState; + } + + public Map getEloMap() { + return this.playerEloMap; + } + + public List getMatches() { + return this.matches; + } + + public Map getPremiumEloMap() { + return this.premiumEloMap; + } + + public Map> getKitMap() { + return this.playerKitMap; + } + + public Map> getPartyEloMap() { + return this.partyEloMap; + } + + public void load() { + final Document document = (Document)PracticePlayer.main.getPracticeDatabase().getProfiles().find(Filters.eq("uuid", this.uuid.toString())).first(); + if (document != null) { + for (final JsonElement element : new JsonParser().parse(document.getString("player_elo")).getAsJsonArray()) { + final JsonObject practiceDocument = element.getAsJsonObject(); + if (practiceDocument.has("kit_personal_name")) { + this.addElo(practiceDocument.get("kit_personal_name").getAsString(), practiceDocument.get("kit_personal_elo").getAsInt()); + } + if (practiceDocument.has("kit_premium_name")) { + this.addPremiumElo(practiceDocument.get("kit_premium_name").getAsString(), practiceDocument.get("kit_premium_elo").getAsInt()); + } + if (practiceDocument.has("kit_party_uuid")) { + this.addPartyElo(UUID.fromString(practiceDocument.get("kit_party_uuid").getAsString()), practiceDocument.get("kit_party_name").getAsString(), practiceDocument.get("kit_party_elo").getAsInt()); + } + } + if (document.containsKey("rankedWins")) { + this.rankedWins = document.getInteger("rankedWins"); + } + if (document.containsKey("rankedLosses")) { + this.rankedLosses = document.getInteger("rankedLosses"); + } + if (document.containsKey("unrankedWins")) { + this.unrankedWins = document.getInteger("unrankedWins"); + } + if (document.containsKey("unrankedLosses")) { + this.unrankedLosses = document.getInteger("unrankedLosses"); + } + if (document.containsKey("premiumWins")) { + this.premiumWins = document.getInteger("premiumWins"); + } + if (document.containsKey("premiumLosses")) { + this.premiumLosses = document.getInteger("premiumLosses"); + } + if (document.containsKey("hostCooldown")) { + this.hostCooldown = document.getLong("hostCooldown"); + } + if (document.containsKey("globalPersonalElo")) { + this.globalPersonalElo = document.getInteger("globalPersonalElo"); + } + if (document.containsKey("globalPartyElo")) { + this.globalPartyElo = document.getInteger("globalPartyElo"); + } + if (document.containsKey("globalPremiumElo")) { + this.globalPremiumElo = document.getInteger("globalPremiumElo"); + } + if (document.containsKey("premiumTokens")) { + this.premiumTokens = document.getInteger("premiumTokens"); + } + if (document.containsKey("rankPremiumTokens")) { + this.rankPremiumTokens = document.getInteger("rankPremiumTokens"); + } + if (document.containsKey("credits")) { + this.credits = document.getInteger("credits"); + } + if (document.containsKey("scoreboard")) { + this.scoreboard = document.getBoolean("scoreboard"); + } + if (document.containsKey("recentName")) { + this.name = document.getString("recentName"); + } + } + } + + public void save() { + final Document document = new Document(); + final JsonArray eloDocument = new JsonArray(); + final JsonArray matchesDocument = new JsonArray(); + for (final Map.Entry entry : this.playerEloMap.entrySet()) { + final JsonObject practiceDocument = new JsonObject(); + practiceDocument.addProperty("kit_personal_name", entry.getKey()); + practiceDocument.addProperty("kit_personal_elo", entry.getValue()); + eloDocument.add(practiceDocument); + } + for (final Map.Entry entry : this.premiumEloMap.entrySet()) { + final JsonObject practiceDocument = new JsonObject(); + practiceDocument.addProperty("kit_premium_name", entry.getKey()); + practiceDocument.addProperty("kit_premium_elo", entry.getValue()); + eloDocument.add(practiceDocument); + } + for (final Map.Entry> entry2 : this.partyEloMap.entrySet()) { + final JsonObject practiceDocument = new JsonObject(); + practiceDocument.addProperty("kit_party_uuid", entry2.getKey().toString()); + for (final Map.Entry sideEntry : entry2.getValue().entrySet()) { + practiceDocument.addProperty("kit_party_name", sideEntry.getKey()); + practiceDocument.addProperty("kit_party_elo", sideEntry.getValue()); + } + eloDocument.add(practiceDocument); + } + for (final Match match : this.matches) { + final JsonObject practiceDocument = new JsonObject(); + practiceDocument.addProperty("matchId", match.getMatchId().toString()); + practiceDocument.addProperty("items", match.getItems()); + practiceDocument.addProperty("armor", match.getArmor()); + practiceDocument.addProperty("potions", match.getPotions()); + practiceDocument.addProperty("eloChangeLoser", match.getEloChangeLoser()); + practiceDocument.addProperty("eloChangeWinner", match.getEloChangeWinner()); + practiceDocument.addProperty("winningTeamId", match.getWinningTeamId()); + practiceDocument.addProperty("firstTeam", match.getFirstTeam()); + practiceDocument.addProperty("secondTeam", match.getSecondTeam()); + matchesDocument.add(practiceDocument); + } + document.put("uuid", this.uuid.toString()); + document.put("credits", this.credits); + document.put("scoreboard", this.scoreboard); + document.put("premiumTokens", this.premiumTokens); + document.put("rankPremiumTokens", this.rankPremiumTokens); + document.put("rankedWins", this.rankedWins); + document.put("rankedLosses", this.rankedLosses); + document.put("unrankedWins", this.unrankedWins); + document.put("unrankedLosses", this.unrankedLosses); + document.put("premiumWins", this.premiumWins); + document.put("premiumLosses", this.premiumLosses); + document.put("globalPersonalElo", this.globalPersonalElo); + document.put("globalPartyElo", this.globalPartyElo); + document.put("globalPremiumElo", this.globalPremiumElo); + document.put("hostCooldown", this.hostCooldown); + if (this.name != null) { + document.put("recentName", this.name); + document.put("recentNameLowercase", this.name.toLowerCase()); + document.put("recentNameLength", this.name.length()); + } + document.put("player_elo", eloDocument.toString()); + document.put("matches", matchesDocument.toString()); + PracticePlayer.main.getPracticeDatabase().getProfiles().replaceOne(Filters.eq("uuid", this.uuid.toString()), document, new UpdateOptions().upsert(true)); + } + + public static PracticePlayer getByUuid(final UUID uuid) { + for (final PracticePlayer profile : PracticePlayer.profiles) { + if (profile.getUUID().equals(uuid)) { + return profile; + } + } + return getExternalByUuid(uuid); + } + + private static PracticePlayer getExternalByUuid(final UUID uuid) { + final PracticePlayer profile = new PracticePlayer(uuid, false); + return profile; + } + + public static Map.Entry getExternalPlayerInformation(String name) throws IOException, ParseException { + final Document document = (Document)PracticePlayer.main.getPracticeDatabase().getProfiles().find(Filters.eq("recentName", name)).first(); + if (document != null && document.containsKey("recentName")) { + return new AbstractMap.SimpleEntry(UUID.fromString(document.getString("uuid")), document.getString("recentName")); + } + final URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + name); + final URLConnection conn = url.openConnection(); + conn.setDoOutput(true); + final BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream())); + final JSONParser parser = new JSONParser(); + final JSONObject obj = (JSONObject)parser.parse(reader.readLine()); + final UUID uuid = UUID.fromString(String.valueOf(obj.get("id")).replaceAll("(\\w{8})(\\w{4})(\\w{4})(\\w{4})(\\w{12})", "$1-$2-$3-$4-$5")); + name = String.valueOf(obj.get("name")); + reader.close(); + return new AbstractMap.SimpleEntry(uuid, name); + } + + public static Set getProfiles() { + return PracticePlayer.profiles; + } + + public int getRankPremiumTokens() { + return this.rankPremiumTokens; + } + + public void setRankPremiumTokens(final int rankPremiumTokens) { + this.rankPremiumTokens = rankPremiumTokens; + } + + public int getPremiumTokens() { + return this.premiumTokens; + } + + public void setPremiumTokens(final int premiumTokens) { + this.premiumTokens = premiumTokens; + } + + public int getPremiumWins() { + return this.premiumWins; + } + + public void setPremiumWins(final int premiumWins) { + this.premiumWins = premiumWins; + } + + public int getPremiumLosses() { + return this.premiumLosses; + } + + public void setPremiumLosses(final int premiumLosses) { + this.premiumLosses = premiumLosses; + } + + public int getRankedWins() { + return this.rankedWins; + } + + public void setRankedWins(final int rankedWins) { + this.rankedWins = rankedWins; + } + + public int getRankedLosses() { + return this.rankedLosses; + } + + public void setRankedLosses(final int rankedLosses) { + this.rankedLosses = rankedLosses; + } + + public int getUnrankedWins() { + return this.unrankedWins; + } + + public void setUnrankedWins(final int unrankedWins) { + this.unrankedWins = unrankedWins; + } + + public int getUnrankedLosses() { + return this.unrankedLosses; + } + + public void setUnrankedLosses(final int unrankedLosses) { + this.unrankedLosses = unrankedLosses; + } + + public int getGlobalPersonalElo() { + return this.globalPersonalElo; + } + + public void setGlobalPersonalElo(final int globalPersonalElo) { + this.globalPersonalElo = globalPersonalElo; + } + + public int getGlobalPartyElo() { + return this.globalPartyElo; + } + + public void setGlobalPartyElo(final int globalPartyElo) { + this.globalPartyElo = globalPartyElo; + } + + public int getGlobalPremiumElo() { + return this.globalPremiumElo; + } + + public void setGlobalPremiumElo(final int globalPremiumElo) { + this.globalPremiumElo = globalPremiumElo; + } + + public Settings getSettings() { + return this.settings; + } + + public void setSettings(final Settings settings) { + this.settings = settings; + } + + public LinkedList getProjectileQueue() { + return this.projectileQueue; + } + + public boolean isShowRematchItemFlag() { + return this.showRematchItemFlag; + } + + public void setShowRematchItemFlag(final boolean showRematchItemFlag) { + this.showRematchItemFlag = showRematchItemFlag; + } + + public String getLastDuelPlayer() { + return this.lastDuelPlayer; + } + + public void setLastDuelPlayer(final String lastDuelPlayer) { + this.lastDuelPlayer = lastDuelPlayer; + } + + static { + PracticePlayer.profiles = new HashSet(); + PracticePlayer.main = nPractice.getInstance(); + } +} diff --git a/src/main/java/us/centile/practice/runnables/LoadPlayerTask.java b/src/main/java/us/centile/practice/runnables/LoadPlayerTask.java new file mode 100644 index 0000000..6225be1 --- /dev/null +++ b/src/main/java/us/centile/practice/runnables/LoadPlayerTask.java @@ -0,0 +1,65 @@ +package us.centile.practice.runnables; + +import us.centile.practice.*; +import us.centile.practice.kit.*; +import us.centile.practice.util.*; +import org.bukkit.plugin.java.*; +import org.bukkit.inventory.*; +import us.centile.practice.player.*; +import us.centile.practice.tournament.*; +import org.bukkit.*; +import java.util.*; +import org.bukkit.configuration.*; +import org.bukkit.entity.*; + +public class LoadPlayerTask implements Runnable +{ + private PracticePlayer practicePlayer; + private nPractice plugin; + + public LoadPlayerTask(final nPractice plugin, final PracticePlayer practicePlayer) { + this.plugin = plugin; + this.practicePlayer = practicePlayer; + } + + @Override + public void run() { + if (this.practicePlayer == null) { + return; + } + for (final Kit kit : this.plugin.getManagerHandler().getKitManager().getKitMap().values()) { + if (!this.practicePlayer.getEloMap().containsKey(kit.getName())) { + this.practicePlayer.addElo(kit.getName(), 1000); + } + if (!this.practicePlayer.getPremiumEloMap().containsKey(kit.getName())) { + this.practicePlayer.addPremiumElo(kit.getName(), 1000); + } + if (!this.practicePlayer.getPartyEloMap().containsKey(this.practicePlayer.getUUID())) { + this.practicePlayer.getPartyEloMap().put(this.practicePlayer.getUUID(), new HashMap()); + } + this.practicePlayer.addPartyElo(this.practicePlayer.getUUID(), kit.getName(), 1000); + } + final Config config = new Config(this.plugin, "/players", this.practicePlayer.getUUID().toString()); + final ConfigurationSection playerKitsSection = config.getConfig().getConfigurationSection("playerkits"); + if (playerKitsSection != null) { + for (final Kit kit2 : this.plugin.getManagerHandler().getKitManager().getKitMap().values()) { + final ConfigurationSection kitSection = playerKitsSection.getConfigurationSection(kit2.getName()); + if (kitSection != null) { + for (final String kitKey : kitSection.getKeys(false)) { + final Integer kitIndex = Integer.parseInt(kitKey); + final String displayName = kitSection.getString(kitKey + ".displayName"); + final ItemStack[] mainContents = (ItemStack[]) ((List)kitSection.get(kitKey + ".mainContents")).toArray(new ItemStack[0]); + final ItemStack[] armorContents = (ItemStack[]) ((List)kitSection.get(kitKey + ".armorContents")).toArray(new ItemStack[0]); + final PlayerKit playerKit = new PlayerKit(kit2.getName(), kitIndex, displayName, mainContents, armorContents); + this.practicePlayer.addKit(kit2.getName(), kitIndex, playerKit); + } + } + } + } + this.practicePlayer.setCurrentState(PlayerState.LOBBY); + final Player player = Bukkit.getPlayer(this.practicePlayer.getUUID()); + if (player != null && Tournament.getTournaments().size() > 0) { + player.sendMessage(ChatColor.YELLOW + "\u00c2�l(ACTIVE) \u00c2�7Tournament is currently available. (/join)"); + } + } +} diff --git a/src/main/java/us/centile/practice/runnables/RemovePlayerTask.java b/src/main/java/us/centile/practice/runnables/RemovePlayerTask.java new file mode 100644 index 0000000..29c332d --- /dev/null +++ b/src/main/java/us/centile/practice/runnables/RemovePlayerTask.java @@ -0,0 +1,26 @@ +package us.centile.practice.runnables; + +import org.bukkit.entity.*; +import us.centile.practice.player.*; +import us.centile.practice.*; + +public class RemovePlayerTask implements Runnable +{ + private Player player; + + public RemovePlayerTask(final Player player) { + this.player = player; + } + + @Override + public void run() { + final PracticePlayer profile = PracticePlayer.getByUuid(this.player.getUniqueId()); + if (profile != null) { + profile.setGlobalPersonalElo(nPractice.getInstance().getManagerHandler().getPracticePlayerManager().getGlobalElo(profile, true)); + profile.setGlobalPremiumElo(nPractice.getInstance().getManagerHandler().getPracticePlayerManager().getPremiumElo(profile)); + profile.setGlobalPartyElo(nPractice.getInstance().getManagerHandler().getPracticePlayerManager().getGlobalElo(profile, false)); + profile.save(); + PracticePlayer.getProfiles().remove(profile); + } + } +} diff --git a/src/main/java/us/centile/practice/runnables/SavePlayerConfig.java b/src/main/java/us/centile/practice/runnables/SavePlayerConfig.java new file mode 100644 index 0000000..05d94d6 --- /dev/null +++ b/src/main/java/us/centile/practice/runnables/SavePlayerConfig.java @@ -0,0 +1,39 @@ +package us.centile.practice.runnables; + +import us.centile.practice.*; +import us.centile.practice.util.*; +import org.bukkit.plugin.java.*; +import us.centile.practice.kit.*; +import us.centile.practice.player.*; +import java.util.*; + +public class SavePlayerConfig implements Runnable +{ + private UUID uuid; + private nPractice plugin; + + public SavePlayerConfig(final UUID uuid, final nPractice plugin) { + this.uuid = uuid; + this.plugin = plugin; + } + + @Override + public void run() { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(this.uuid); + if (practicePlayer == null) { + return; + } + final Config config = new Config(this.plugin, "/players", this.uuid.toString()); + for (final Kit kit : this.plugin.getManagerHandler().getKitManager().getKitMap().values()) { + if (practicePlayer.getKitMap().containsKey(kit.getName())) { + final Map playerKits = practicePlayer.getKitMap().get(kit.getName()); + for (final PlayerKit playerKit : playerKits.values()) { + config.getConfig().set("playerkits." + kit.getName() + "." + playerKit.getKitIndex() + ".displayName", (Object)playerKit.getDisplayName()); + config.getConfig().set("playerkits." + kit.getName() + "." + playerKit.getKitIndex() + ".mainContents", (Object)playerKit.getMainContents()); + config.getConfig().set("playerkits." + kit.getName() + "." + playerKit.getKitIndex() + ".armorContents", (Object)playerKit.getArmorContents()); + } + } + } + config.save(); + } +} diff --git a/src/main/java/us/centile/practice/runnables/other/InsertMatchTask.java b/src/main/java/us/centile/practice/runnables/other/InsertMatchTask.java new file mode 100644 index 0000000..b44570a --- /dev/null +++ b/src/main/java/us/centile/practice/runnables/other/InsertMatchTask.java @@ -0,0 +1,28 @@ +package us.centile.practice.runnables.other; + +import us.centile.practice.*; +import org.bukkit.entity.*; +import us.centile.practice.duel.*; +import us.centile.practice.player.*; + +public class InsertMatchTask implements Runnable +{ + private nPractice plugin; + private Player player; + private Duel duel; + private int winningTeamId; + private String elo_change; + + public InsertMatchTask(final nPractice plugin, final Player player, final Duel duel, final int winningTeamId, final String elo_change) { + this.player = player; + this.plugin = plugin; + this.winningTeamId = winningTeamId; + this.elo_change = elo_change; + } + + @Override + public void run() { + final PracticePlayer practicePlayer = PracticePlayer.getByUuid(this.player.getUniqueId()); + if (practicePlayer != null) {} + } +} diff --git a/src/main/java/us/centile/practice/runnables/other/UpdateInventoryTask.java b/src/main/java/us/centile/practice/runnables/other/UpdateInventoryTask.java new file mode 100644 index 0000000..98eab14 --- /dev/null +++ b/src/main/java/us/centile/practice/runnables/other/UpdateInventoryTask.java @@ -0,0 +1,50 @@ +package us.centile.practice.runnables.other; + +import us.centile.practice.*; + +public class UpdateInventoryTask implements Runnable +{ + private nPractice plugin; + private InventoryTaskType inventoryTaskType; + + public UpdateInventoryTask(final nPractice plugin, final InventoryTaskType inventoryTaskType) { + this.plugin = plugin; + this.inventoryTaskType = inventoryTaskType; + } + + @Override + public void run() { + if (this.inventoryTaskType == InventoryTaskType.UNRANKED_SOLO) { + this.plugin.getManagerHandler().getInventoryManager().setUnrankedInventory(); + } + else if (this.inventoryTaskType == InventoryTaskType.UNRANKED_PARTY) { + this.plugin.getManagerHandler().getInventoryManager().setUnrankedPartyInventory(); + } + else if (this.inventoryTaskType == InventoryTaskType.RANKED_SOLO) { + this.plugin.getManagerHandler().getInventoryManager().setRankedInventory(); + } + else if (this.inventoryTaskType == InventoryTaskType.RANKED_PARTY) { + this.plugin.getManagerHandler().getInventoryManager().setRankedPartyInventory(); + } + else if (this.inventoryTaskType == InventoryTaskType.PREMIUM_SOLO) { + this.plugin.getManagerHandler().getInventoryManager().setPremiumInventory(); + } + else if (this.inventoryTaskType == InventoryTaskType.SPECTATOR) { + this.plugin.getManagerHandler().getInventoryManager().setSpectatorInventory(); + } + else if (this.inventoryTaskType == InventoryTaskType.TOURNAMENT) { + this.plugin.getManagerHandler().getInventoryManager().setJoinTournamentInventory(); + } + } + + public enum InventoryTaskType + { + UNRANKED_SOLO, + RANKED_SOLO, + RANKED_PARTY, + UNRANKED_PARTY, + PREMIUM_SOLO, + SPECTATOR, + TOURNAMENT; + } +} diff --git a/src/main/java/us/centile/practice/schedule/Schedule.java b/src/main/java/us/centile/practice/schedule/Schedule.java new file mode 100644 index 0000000..85ec5af --- /dev/null +++ b/src/main/java/us/centile/practice/schedule/Schedule.java @@ -0,0 +1,64 @@ +package us.centile.practice.schedule; + +import org.bukkit.*; +import us.centile.practice.*; +import org.bson.*; +import com.mongodb.client.model.*; +import us.centile.practice.player.*; +import com.mongodb.client.*; +import java.util.*; + +public class Schedule +{ + private long eventTime; + private long announceTime; + + public Schedule(final long eventTime) { + this.eventTime = eventTime; + this.announceTime = this.eventTime - 1800000L; + } + + public void runEvent() { + if (System.currentTimeMillis() > this.eventTime) { + try { + this.clearPremiumMatches(); + this.setNextEventTime(); + } + catch (Exception e) { + e.printStackTrace(); + } + } + if (System.currentTimeMillis() > this.announceTime) { + Bukkit.broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + "Premium Matches Tokens will clear in 30 minutes."); + this.setNextAnnounceTime(); + } + } + + public long getEventTime() { + return this.eventTime; + } + + private void setNextEventTime() { + this.eventTime += 604800000L; + } + + private void setNextAnnounceTime() { + this.announceTime += 604800000L; + } + + private void clearPremiumMatches() { + final FindIterable iterable = (FindIterable)nPractice.getInstance().getPracticeDatabase().getProfiles().find(); + for (final Document document : iterable) { + final UUID uuid = UUID.fromString(document.getString((Object)"uuid")); + final int rankTokens = document.getInteger((Object)"rankPremiumTokens"); + document.put("premiumTokens", (Object)rankTokens); + nPractice.getInstance().getPracticeDatabase().getProfiles().replaceOne(Filters.eq("uuid", (Object)uuid.toString()), (Object)document, new UpdateOptions().upsert(true)); + } + for (final PracticePlayer practicePlayer : PracticePlayer.getProfiles()) { + practicePlayer.load(); + } + Bukkit.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + Bukkit.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + "Premium Matches have been reset"); + Bukkit.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } +} diff --git a/src/main/java/us/centile/practice/schedule/ScheduleHandler.java b/src/main/java/us/centile/practice/schedule/ScheduleHandler.java new file mode 100644 index 0000000..d06478f --- /dev/null +++ b/src/main/java/us/centile/practice/schedule/ScheduleHandler.java @@ -0,0 +1,125 @@ +package us.centile.practice.schedule; + +import org.bukkit.*; +import us.noksdev.permissions.util.file.ConfigFile; + +import java.util.*; + +public class ScheduleHandler +{ + public static List schedules; + + public static void setSchedules(final ConfigFile config) { + ScheduleHandler.schedules.clear(); + final Calendar calendar = Calendar.getInstance(); + calendar.setTimeZone(TimeZone.getTimeZone(config.getString("schedule-timezone"))); + calendar.setFirstDayOfWeek(2); + calendar.set(11, 0); + calendar.clear(12); + calendar.clear(13); + calendar.clear(14); + calendar.set(7, calendar.getFirstDayOfWeek()); + final long calendarMillis = calendar.getTimeInMillis(); + if (config.getConfiguration().contains("schedule-monday")) { + readSchedule(config, "monday", 0, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for monday."); + } + if (config.getConfiguration().contains("schedule-tuesday")) { + readSchedule(config, "tuesday", 1, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for tuesday."); + } + if (config.getConfiguration().contains("schedule-wednesday")) { + readSchedule(config, "wednesday", 2, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for wednesday."); + } + if (config.getConfiguration().contains("schedule-thursday")) { + readSchedule(config, "thursday", 3, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for thursday."); + } + if (config.getConfiguration().contains("schedule-friday")) { + readSchedule(config, "friday", 4, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for friday."); + } + if (config.getConfiguration().contains("schedule-saturday")) { + readSchedule(config, "saturday", 5, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for saturday."); + } + if (config.getConfiguration().contains("schedule-sunday")) { + readSchedule(config, "sunday", 6, calendarMillis); + Bukkit.getLogger().info("[Practice] (Schedule): Loaded schedule for sunday."); + } + } + + public static void readSchedule(final ConfigFile config, final String day, final int dayInId, final long calendarMillis) { + try { + final String[] events = config.getString("schedule-" + day).split("#"); + for (int i = 0; i < events.length; ++i) { + final String[] event = events[i].split("/"); + final String time = event[0]; + int hours = 0; + int minute = 0; + if (time.contains(":")) { + final String[] build = time.split(":"); + hours = Integer.parseInt(build[0]); + minute = Integer.parseInt(build[1].replaceAll("[a-zA-Z]", "")); + } + else { + hours = Integer.parseInt(time.replaceAll("[a-zA-Z]", "")); + } + if (time.endsWith("PM")) { + hours += 12; + } + long eventTime = calendarMillis + dayInId * 24 * 60 * 60 * 1000 + hours * 60 * 60 * 1000 + minute * 60 * 1000; + if (eventTime < System.currentTimeMillis()) { + eventTime += 604800000L; + } + ScheduleHandler.schedules.add(new Schedule(eventTime)); + } + } + catch (Exception ex) { + ex.printStackTrace(); + } + } + + public static Schedule getNextEvent() { + Schedule ret = null; + for (final Schedule sched : ScheduleHandler.schedules) { + if (ret == null) { + ret = sched; + } + else { + if (sched.getEventTime() >= ret.getEventTime()) { + continue; + } + ret = sched; + } + } + return ret; + } + + public static Schedule getNextEvent(final String arenaName) { + Schedule schedule = null; + for (final Schedule sched : ScheduleHandler.schedules) { + if (schedule == null) { + schedule = sched; + } + else { + if (sched.getEventTime() >= schedule.getEventTime()) { + continue; + } + schedule = sched; + } + } + return schedule; + } + + public static void runSchedule() { + for (final Schedule schedule : ScheduleHandler.schedules) { + schedule.runEvent(); + } + } + + static { + ScheduleHandler.schedules = new ArrayList(); + } +} diff --git a/src/main/java/us/centile/practice/schedule/ScheduleTimer.java b/src/main/java/us/centile/practice/schedule/ScheduleTimer.java new file mode 100644 index 0000000..f65494a --- /dev/null +++ b/src/main/java/us/centile/practice/schedule/ScheduleTimer.java @@ -0,0 +1,19 @@ +package us.centile.practice.schedule; + +import org.bukkit.scheduler.*; +import us.centile.practice.*; +import org.bukkit.plugin.*; + +public class ScheduleTimer extends BukkitRunnable +{ + private nPractice plugin; + + public ScheduleTimer(final nPractice plugin) { + this.plugin = plugin; + plugin.getServer().getScheduler().runTaskTimerAsynchronously((Plugin)plugin, (BukkitRunnable)this, 20L, 20L); + } + + public void run() { + ScheduleHandler.runSchedule(); + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/BufferedObjective.java b/src/main/java/us/centile/practice/scoreboard/BufferedObjective.java new file mode 100644 index 0000000..84621b5 --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/BufferedObjective.java @@ -0,0 +1,129 @@ +package us.centile.practice.scoreboard; + +import gnu.trove.map.hash.*; +import org.apache.commons.lang.*; +import gnu.trove.procedure.*; +import org.bukkit.scoreboard.*; +import java.util.*; + +public class BufferedObjective +{ + private static final int MAX_SIDEBAR_ENTRIES = 16; + private static final int MAX_NAME_LENGTH = 16; + private static final int MAX_PREFIX_LENGTH = 16; + private static final int MAX_SUFFIX_LENGTH = 16; + private final Scoreboard scoreboard; + private Set previousLines; + private TIntObjectHashMap contents; + private boolean requiresUpdate; + private String title; + private Objective current; + private DisplaySlot displaySlot; + + public BufferedObjective(final Scoreboard scoreboard) { + this.previousLines = new HashSet(); + this.contents = (TIntObjectHashMap)new TIntObjectHashMap(); + this.requiresUpdate = false; + this.scoreboard = scoreboard; + this.title = RandomStringUtils.randomAlphabetic(4); + this.current = scoreboard.registerNewObjective("buffered", "dummy"); + } + + public void setTitle(final String title) { + if (this.title == null || !this.title.equals(title)) { + this.title = title; + this.requiresUpdate = true; + } + } + + public void setDisplaySlot(final DisplaySlot slot) { + this.displaySlot = slot; + this.current.setDisplaySlot(slot); + } + + public void setAllLines(final List lines) { + if (lines.size() != this.contents.size()) { + this.contents.clear(); + if (lines.isEmpty()) { + this.requiresUpdate = true; + return; + } + } + final int size = Math.min(16, lines.size()); + int count = 0; + for (final SidebarEntry sidebarEntry : lines) { + this.setLine(size - count++, sidebarEntry); + } + } + + public void setLine(final int lineNumber, final SidebarEntry sidebarEntry) { + final SidebarEntry value = this.contents.get(lineNumber); + if (value == null || !value.equals(sidebarEntry)) { + this.contents.put(lineNumber, sidebarEntry); + this.requiresUpdate = true; + } + } + + public void flip() { + if (!this.requiresUpdate) { + return; + } + final Set adding = new HashSet(); + this.contents.forEachEntry(new TIntObjectProcedure() { + public boolean execute(final int i, final SidebarEntry sidebarEntry) { + String name = sidebarEntry.name; + if (name.length() > 16) { + name = name.substring(0, 16); + } + Team team = BufferedObjective.this.scoreboard.getTeam(name); + if (team == null) { + team = BufferedObjective.this.scoreboard.registerNewTeam(name); + } + String prefix = sidebarEntry.prefix; + if (prefix != null) { + if (prefix.length() > 16) { + prefix = prefix.substring(0, 16); + } + team.setPrefix(prefix); + } + String suffix = sidebarEntry.suffix; + if (suffix != null) { + if (suffix.length() > 16) { + suffix = suffix.substring(0, 16); + } + team.setSuffix(suffix); + } + adding.add(name); + if (!team.hasEntry(name)) { + team.addEntry(name); + } + BufferedObjective.this.current.getScore(name).setScore(i); + return true; + } + }); + this.previousLines.removeAll(adding); + final Iterator iterator = this.previousLines.iterator(); + while (iterator.hasNext()) { + final String last = iterator.next(); + final Team team = this.scoreboard.getTeam(last); + if (team != null) { + team.removeEntry(last); + } + this.scoreboard.resetScores(last); + iterator.remove(); + } + this.previousLines = adding; + this.current.setDisplayName(this.title); + this.requiresUpdate = false; + } + + public void setVisible(final boolean value) { + if (this.displaySlot != null && !value) { + this.scoreboard.clearSlot(this.displaySlot); + this.displaySlot = null; + } + else if (this.displaySlot == null && value) { + this.current.setDisplaySlot(this.displaySlot = DisplaySlot.SIDEBAR); + } + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/PlayerBoard.java b/src/main/java/us/centile/practice/scoreboard/PlayerBoard.java new file mode 100644 index 0000000..dbe6b07 --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/PlayerBoard.java @@ -0,0 +1,150 @@ +package us.centile.practice.scoreboard; + +import org.bukkit.entity.*; +import us.centile.practice.*; +import org.bukkit.scheduler.*; +import org.bukkit.scoreboard.*; +import org.bukkit.plugin.*; +import us.centile.practice.util.*; +import java.util.*; +import org.bukkit.*; +import us.centile.practice.duel.*; + +public class PlayerBoard +{ + public final BufferedObjective bufferedObjective; + private final Team teammates; + private final Team opponents; + private final Team members; + private final Scoreboard scoreboard; + private final Player player; + private final nPractice plugin; + private boolean sidebarVisible; + private boolean removed; + private SidebarProvider defaultProvider; + private SidebarProvider temporaryProvider; + private BukkitRunnable runnable; + + public PlayerBoard(final nPractice plugin, final Player player) { + this.sidebarVisible = false; + this.removed = false; + this.plugin = plugin; + this.player = player; + this.scoreboard = plugin.getServer().getScoreboardManager().getNewScoreboard(); + this.bufferedObjective = new BufferedObjective(this.scoreboard); + (this.members = this.scoreboard.registerNewTeam("members")).setPrefix(ChatColor.GREEN.toString()); + (this.teammates = this.scoreboard.registerNewTeam("teammates")).setPrefix(ChatColor.GREEN.toString()); + (this.opponents = this.scoreboard.registerNewTeam("opponents")).setPrefix(ChatColor.RED.toString()); + player.setScoreboard(this.scoreboard); + } + + public void remove() { + this.removed = true; + if (this.scoreboard != null) { + synchronized (this.scoreboard) { + for (final Team team : this.scoreboard.getTeams()) { + team.unregister(); + } + for (final Objective objective : this.scoreboard.getObjectives()) { + objective.unregister(); + } + } + } + } + + public Player getPlayer() { + return this.player; + } + + public void setSidebarVisible(final boolean visible) { + this.sidebarVisible = visible; + this.bufferedObjective.setDisplaySlot(visible ? DisplaySlot.SIDEBAR : null); + } + + public void setDefaultSidebar(final SidebarProvider provider, final long updateInterval) { + if (provider != null && provider.equals(this.defaultProvider)) { + return; + } + this.defaultProvider = provider; + if (this.runnable != null) { + this.runnable.cancel(); + } + if (provider == null) { + this.scoreboard.clearSlot(DisplaySlot.SIDEBAR); + return; + } + (this.runnable = new BukkitRunnable() { + public void run() { + if (PlayerBoard.this.removed) { + this.cancel(); + return; + } + if (provider.equals(PlayerBoard.this.defaultProvider)) { + PlayerBoard.this.updateObjective(); + } + } + }).runTaskTimer((Plugin)this.plugin, updateInterval, updateInterval); + } + + private void updateObjective() { + final SidebarProvider provider = (this.temporaryProvider != null) ? this.temporaryProvider : this.defaultProvider; + if (provider == null) { + this.bufferedObjective.setVisible(false); + } + else { + final List lines = provider.getLines(this.player); + if (lines == null) { + this.bufferedObjective.setVisible(false); + return; + } + this.bufferedObjective.setVisible(true); + this.bufferedObjective.setTitle(provider.getTitle(this.player)); + this.bufferedObjective.setAllLines(lines); + this.bufferedObjective.flip(); + } + } + + public void addUpdates(final Player playerInDuel) { + new BukkitRunnable() { + public void run() { + final Duel currentDuel = PlayerBoard.this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(playerInDuel.getUniqueId()); + if (currentDuel == null) { + for (final Player online : PlayerUtility.getOnlinePlayers()) { + if (!PlayerBoard.this.members.hasPlayer((OfflinePlayer)online)) { + PlayerBoard.this.members.addPlayer((OfflinePlayer)online); + } + } + } + else if (currentDuel.getFfaPlayers() != null && currentDuel.getFfaPlayers().size() > 0) { + final List others = currentDuel.getFfaPlayers(); + for (final UUID uuid : others) { + final Player target = Bukkit.getPlayer(uuid); + if (target != null && !PlayerBoard.this.opponents.hasPlayer((OfflinePlayer)target)) { + PlayerBoard.this.opponents.addPlayer((OfflinePlayer)target); + } + } + } + else { + final List selfTeam = currentDuel.getDuelTeam(playerInDuel); + final List otherTeam = currentDuel.getOtherDuelTeam(playerInDuel); + if (selfTeam != null) { + for (final UUID uuid2 : selfTeam) { + final Player target2 = Bukkit.getPlayer(uuid2); + if (target2 != null && !PlayerBoard.this.teammates.hasPlayer((OfflinePlayer)target2)) { + PlayerBoard.this.teammates.addPlayer((OfflinePlayer)target2); + } + } + } + if (otherTeam != null) { + for (final UUID uuid2 : otherTeam) { + final Player target2 = Bukkit.getPlayer(uuid2); + if (target2 != null && !PlayerBoard.this.opponents.hasPlayer((OfflinePlayer)target2)) { + PlayerBoard.this.opponents.addPlayer((OfflinePlayer)target2); + } + } + } + } + } + }.runTaskLater((Plugin)this.plugin, 5L); + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/ScoreboardHandler.java b/src/main/java/us/centile/practice/scoreboard/ScoreboardHandler.java new file mode 100644 index 0000000..5b866ea --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/ScoreboardHandler.java @@ -0,0 +1,65 @@ +package us.centile.practice.scoreboard; + +import us.centile.practice.*; +import us.centile.practice.scoreboard.provider.*; +import org.bukkit.*; +import org.bukkit.plugin.*; +import us.centile.practice.util.*; +import org.bukkit.entity.*; +import java.util.*; +import org.bukkit.event.*; +import org.bukkit.event.player.*; + +public class ScoreboardHandler implements Listener +{ + private final Map playerBoards; + private final nPractice plugin; + private final SidebarProvider defaultProvider; + + public ScoreboardHandler(final nPractice plugin) { + this.playerBoards = new HashMap(); + this.plugin = plugin; + this.defaultProvider = new LobbyScoreboardProvider(this.plugin); + Bukkit.getPluginManager().registerEvents((Listener)this, (Plugin)plugin); + for (final Player player : PlayerUtility.getOnlinePlayers()) { + final PlayerBoard playerBoard; + this.setPlayerBoard(player.getUniqueId(), playerBoard = new PlayerBoard(plugin, player)); + playerBoard.addUpdates(player); + } + } + + @EventHandler(priority = EventPriority.LOWEST) + public void onPlayerJoin(final PlayerJoinEvent event) { + final Player player = event.getPlayer(); + final UUID uuid = player.getUniqueId(); + for (final PlayerBoard board : this.playerBoards.values()) { + board.addUpdates(player); + } + final PlayerBoard board2 = new PlayerBoard(this.plugin, player); + this.setPlayerBoard(uuid, board2); + board2.addUpdates(player); + } + + @EventHandler(ignoreCancelled = true, priority = EventPriority.LOWEST) + public void onPlayerQuit(final PlayerQuitEvent event) { + this.playerBoards.remove(event.getPlayer().getUniqueId()).remove(); + } + + public PlayerBoard getPlayerBoard(final UUID uuid) { + return this.playerBoards.get(uuid); + } + + public void setPlayerBoard(final UUID uuid, final PlayerBoard board) { + this.playerBoards.put(uuid, board); + board.setSidebarVisible(true); + board.setDefaultSidebar(this.defaultProvider, 2L); + } + + public void clearBoards() { + final Iterator iterator = this.playerBoards.values().iterator(); + while (iterator.hasNext()) { + iterator.next().remove(); + iterator.remove(); + } + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/SidebarEntry.java b/src/main/java/us/centile/practice/scoreboard/SidebarEntry.java new file mode 100644 index 0000000..6e53305 --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/SidebarEntry.java @@ -0,0 +1,78 @@ +package us.centile.practice.scoreboard; + +public class SidebarEntry +{ + public final String name; + public String prefix; + public String suffix; + + public SidebarEntry(final String name) { + this.name = name; + } + + public SidebarEntry(final Object name) { + this.name = String.valueOf(name); + } + + public SidebarEntry(final String prefix, final String name, final String suffix) { + this.name = name; + this.prefix = prefix; + this.suffix = suffix; + } + + public SidebarEntry(final Object prefix, final Object name, final Object suffix) { + this(name); + this.prefix = String.valueOf(prefix); + this.suffix = String.valueOf(suffix); + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (!(o instanceof SidebarEntry)) { + return false; + } + final SidebarEntry that = (SidebarEntry)o; + Label_0057: { + if (this.name != null) { + if (this.name.equals(that.name)) { + break Label_0057; + } + } + else if (that.name == null) { + break Label_0057; + } + return false; + } + Label_0093: { + if (this.prefix != null) { + if (this.prefix.equals(that.prefix)) { + break Label_0093; + } + } + else if (that.prefix == null) { + break Label_0093; + } + return false; + } + if (this.suffix != null) { + if (!this.suffix.equals(that.suffix)) { + return false; + } + } + else if (that.suffix != null) { + return false; + } + return true; + } + + @Override + public int hashCode() { + int result = (this.name != null) ? this.name.hashCode() : 0; + result = 31 * result + ((this.prefix != null) ? this.prefix.hashCode() : 0); + result = 31 * result + ((this.suffix != null) ? this.suffix.hashCode() : 0); + return result; + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/SidebarProvider.java b/src/main/java/us/centile/practice/scoreboard/SidebarProvider.java new file mode 100644 index 0000000..807f2f4 --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/SidebarProvider.java @@ -0,0 +1,20 @@ +package us.centile.practice.scoreboard; + +import org.bukkit.entity.*; +import java.util.*; +import org.bukkit.*; +import com.google.common.base.*; + +public abstract class SidebarProvider +{ + public static String SCOREBOARD_TITLE; + protected static final String STRAIGHT_LINE; + + public abstract String getTitle(final Player p0); + + public abstract List getLines(final Player p0); + + static { + STRAIGHT_LINE = ChatColor.STRIKETHROUGH.toString() + Strings.repeat("-", 256).substring(0, 10); + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/provider/DuelScoreboardProvider.java b/src/main/java/us/centile/practice/scoreboard/provider/DuelScoreboardProvider.java new file mode 100644 index 0000000..30b25cb --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/provider/DuelScoreboardProvider.java @@ -0,0 +1,81 @@ +package us.centile.practice.scoreboard.provider; + +import us.centile.practice.*; +import org.bukkit.entity.*; +import us.centile.practice.scoreboard.*; +import org.bukkit.*; +import us.centile.practice.listeners.*; +import java.text.*; +import com.google.common.collect.*; +import us.centile.practice.tournament.*; +import us.centile.practice.player.*; +import us.centile.practice.duel.*; +import java.util.*; +import org.apache.commons.lang3.time.*; + +public class DuelScoreboardProvider extends SidebarProvider +{ + private final nPractice plugin; + + public DuelScoreboardProvider(final nPractice plugin) { + this.plugin = plugin; + } + + @Override + public String getTitle(final Player paramPlayer) { + return DuelScoreboardProvider.SCOREBOARD_TITLE; + } + + @Override + public List getLines(final Player player) { + final List lines = new ArrayList(); + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer == null || !practicePlayer.getSettings().isScoreboard()) { + return null; + } + final Duel duel = this.plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(player.getUniqueId()); + lines.add(new SidebarEntry(ChatColor.GRAY, ChatColor.AQUA + ChatColor.GRAY.toString() + SidebarProvider.STRAIGHT_LINE, SidebarProvider.STRAIGHT_LINE)); + if (duel != null) { + if (duel.getFfaPlayers() == null || duel.getFfaPlayers().size() <= 0) { + final boolean isParty = duel.getOtherDuelTeam(player).size() >= 2; + final String opponent = (duel.getOtherDuelTeam(player).get(0) != null) ? Bukkit.getOfflinePlayer(duel.getOtherDuelTeam(player).get(0)).getName() : ("Undefined" + (isParty ? "'s Party" : "")); + if (opponent != null) { + lines.add(new SidebarEntry(ChatColor.RED.toString() + ChatColor.BOLD, "Opponent: ", ChatColor.WHITE + opponent)); + } + } + lines.add(new SidebarEntry(ChatColor.DARK_GREEN.toString() + ChatColor.BOLD, "Duration: ", ChatColor.WHITE + this.getRemaining((duel.getEndMatchTime() != 0L) ? duel.getFinalDuration() : duel.getStartDuration()))); + final long now = System.currentTimeMillis(); + final double diff = PlayerListener.getLastPearl().containsKey(player.getUniqueId()) ? (now - PlayerListener.getLastPearl().get(player.getUniqueId())) : ((double)now); + if (diff < 15000.0) { + lines.add(new SidebarEntry(ChatColor.GREEN.toString() + ChatColor.BOLD, "Enderpearl: ", ChatColor.WHITE + new DecimalFormat("#0.0").format(15.0 - diff / 1000.0) + "s")); + } + } + else { + lines.add(new SidebarEntry(nPractice.MAIN_COLOR, ChatColor.BOLD, "Loading...")); + } + for (final Tournament tournament : Tournament.getTournaments()) { + final Set counted = Sets.newHashSet(); + for (final TournamentMatch tournamentMatch : tournament.getCurrentMatches()) { + counted.addAll(tournamentMatch.getMatchPlayers()); + } + for (final TournamentTeam tournamentTeam : tournament.getCurrentQueue()) { + counted.addAll(tournamentTeam.getPlayers()); + } + for (final TournamentTeam tournamentTeam : tournament.getTeams()) { + counted.addAll(tournamentTeam.getPlayers()); + } + if (counted.contains(player.getUniqueId())) { + lines.add(new SidebarEntry(ChatColor.GRAY, ChatColor.GREEN + ChatColor.GRAY.toString() + SidebarProvider.STRAIGHT_LINE, SidebarProvider.STRAIGHT_LINE)); + lines.add(new SidebarEntry(nPractice.MAIN_COLOR + ChatColor.BOLD + "Tournament:")); + lines.add(new SidebarEntry(nPractice.SIDE_COLOR + "" + ((tournament.getTournamentStage() == null) ? "Uncommenced" : tournament.getTournamentStage().toReadable()))); + lines.add(new SidebarEntry(nPractice.EXTRA_COLOR + "[" + counted.size() + "/" + 32 + "]")); + } + } + lines.add(new SidebarEntry(ChatColor.GRAY, ChatColor.DARK_AQUA + ChatColor.GRAY.toString() + SidebarProvider.STRAIGHT_LINE, SidebarProvider.STRAIGHT_LINE)); + return lines; + } + + private String getRemaining(final long duration) { + return DurationFormatUtils.formatDuration(duration, "mm:ss"); + } +} diff --git a/src/main/java/us/centile/practice/scoreboard/provider/LobbyScoreboardProvider.java b/src/main/java/us/centile/practice/scoreboard/provider/LobbyScoreboardProvider.java new file mode 100644 index 0000000..925881a --- /dev/null +++ b/src/main/java/us/centile/practice/scoreboard/provider/LobbyScoreboardProvider.java @@ -0,0 +1,74 @@ +package us.centile.practice.scoreboard.provider; + +import us.centile.practice.*; +import org.bukkit.entity.*; +import us.centile.practice.scoreboard.*; +import org.bukkit.*; +import us.centile.practice.util.*; +import us.centile.practice.player.*; +import com.google.common.collect.*; +import us.centile.practice.tournament.*; +import java.util.*; +import us.centile.practice.duel.*; + +public class LobbyScoreboardProvider extends SidebarProvider +{ + private final nPractice plugin; + + public LobbyScoreboardProvider(final nPractice plugin) { + this.plugin = plugin; + } + + @Override + public String getTitle(final Player player) { + return LobbyScoreboardProvider.SCOREBOARD_TITLE; + } + + @Override + public List getLines(final Player player) { + final PracticePlayer practicePlayer = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player); + if (practicePlayer == null || !practicePlayer.getSettings().isScoreboard()) { + return null; + } + final List lines = new ArrayList(); + lines.add(new SidebarEntry(ChatColor.GRAY, ChatColor.AQUA + ChatColor.GRAY.toString() + SidebarProvider.STRAIGHT_LINE, SidebarProvider.STRAIGHT_LINE)); + lines.add(new SidebarEntry(nPractice.MAIN_COLOR, "Online: ", nPractice.EXTRA_COLOR + "" + PlayerUtility.getOnlinePlayers().size())); + lines.add(new SidebarEntry(nPractice.MAIN_COLOR, "In Fights: ", nPractice.EXTRA_COLOR + "" + this.getTotalInGame())); + lines.add(new SidebarEntry(nPractice.MAIN_COLOR, "In Queue: ", nPractice.EXTRA_COLOR + "" + this.plugin.getManagerHandler().getQueueManager().getTotalInQueues())); + lines.add(new SidebarEntry(nPractice.SIDE_COLOR + "Premium", " Matches: ", nPractice.EXTRA_COLOR + "" + PracticePlayer.getByUuid(player.getUniqueId()).getPremiumTokens())); + for (final Tournament tournament : Tournament.getTournaments()) { + final Set counted = Sets.newHashSet(); + for (final TournamentMatch tournamentMatch : tournament.getCurrentMatches()) { + counted.addAll(tournamentMatch.getMatchPlayers()); + } + for (final TournamentTeam tournamentTeam : tournament.getCurrentQueue()) { + counted.addAll(tournamentTeam.getPlayers()); + } + for (final TournamentTeam tournamentTeam : tournament.getTeams()) { + counted.addAll(tournamentTeam.getPlayers()); + } + lines.add(new SidebarEntry(ChatColor.GRAY, ChatColor.GREEN + ChatColor.GRAY.toString() + SidebarProvider.STRAIGHT_LINE, SidebarProvider.STRAIGHT_LINE)); + lines.add(new SidebarEntry(nPractice.MAIN_COLOR + ChatColor.BOLD + "Tournament:")); + lines.add(new SidebarEntry(nPractice.SIDE_COLOR + "" + ((tournament.getTournamentStage() == null) ? "Uncommenced" : tournament.getTournamentStage().toReadable()))); + lines.add(new SidebarEntry(nPractice.EXTRA_COLOR + "[" + counted.size() + "/" + 32 + "]")); + } + lines.add(new SidebarEntry(ChatColor.GRAY, ChatColor.DARK_AQUA + ChatColor.GRAY.toString() + SidebarProvider.STRAIGHT_LINE, SidebarProvider.STRAIGHT_LINE)); + return lines; + } + + private int getTotalInGame() { + int count = 0; + for (final Duel duel : this.plugin.getManagerHandler().getDuelManager().getUuidIdentifierToDuel().values()) { + if (duel.getFirstTeam() != null) { + count += duel.getFirstTeam().size(); + } + if (duel.getSecondTeam() != null) { + count += duel.getSecondTeam().size(); + } + if (duel.getFfaPlayers() != null) { + count += duel.getFfaPlayers().size(); + } + } + return count; + } +} diff --git a/src/main/java/us/centile/practice/settings/Settings.java b/src/main/java/us/centile/practice/settings/Settings.java new file mode 100644 index 0000000..97973ed --- /dev/null +++ b/src/main/java/us/centile/practice/settings/Settings.java @@ -0,0 +1,38 @@ +package us.centile.practice.settings; + +public class Settings +{ + private boolean scoreboard; + private boolean duelRequests; + private boolean publicChat; + + public Settings() { + this.scoreboard = true; + this.duelRequests = true; + this.publicChat = true; + } + + public boolean isScoreboard() { + return this.scoreboard; + } + + public boolean isDuelRequests() { + return this.duelRequests; + } + + public boolean isPublicChat() { + return this.publicChat; + } + + public void setScoreboard(final boolean scoreboard) { + this.scoreboard = scoreboard; + } + + public void setDuelRequests(final boolean duelRequests) { + this.duelRequests = duelRequests; + } + + public void setPublicChat(final boolean publicChat) { + this.publicChat = publicChat; + } +} diff --git a/src/main/java/us/centile/practice/settings/SettingsHandler.java b/src/main/java/us/centile/practice/settings/SettingsHandler.java new file mode 100644 index 0000000..af37b58 --- /dev/null +++ b/src/main/java/us/centile/practice/settings/SettingsHandler.java @@ -0,0 +1,114 @@ +package us.centile.practice.settings; + +import us.centile.practice.*; +import org.bukkit.plugin.*; +import org.bukkit.command.*; +import org.bukkit.entity.*; +import org.bukkit.event.inventory.*; +import org.bukkit.event.*; +import org.apache.commons.lang3.*; +import com.google.common.collect.*; +import org.bukkit.*; +import java.util.*; +import com.google.common.base.*; +import javax.annotation.*; +import org.bukkit.inventory.*; +import org.bukkit.inventory.meta.*; + +public class SettingsHandler implements CommandExecutor, Listener +{ + private final nPractice plugin; + + public SettingsHandler(final nPractice plugin) { + this.plugin = plugin; + plugin.getServer().getPluginManager().registerEvents((Listener)this, (Plugin)plugin); + plugin.getCommand("setting").setExecutor((CommandExecutor)this); + } + + public boolean onCommand(final CommandSender sender, final Command arg1, final String arg2, final String[] args) { + this.open((Player)sender); + return true; + } + + @EventHandler + public void onInventoryClick(final InventoryClickEvent event) { + if (event.getInventory().getTitle() != null && event.getInventory().getTitle().equals("Options")) { + event.setCancelled(true); + final Player player = (Player)event.getWhoClicked(); + final Settings settings = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player.getUniqueId()).getSettings(); + final int slot = event.getSlot(); + if (slot == 1) { + settings.setScoreboard(!settings.isScoreboard()); + player.sendMessage(ChatColor.YELLOW + "You are now " + this.able(settings.isScoreboard()) + ChatColor.YELLOW + " to see the scoreboard."); + } + else if (slot == 4) { + settings.setDuelRequests(!settings.isDuelRequests()); + player.sendMessage(ChatColor.YELLOW + "You are now " + this.able(settings.isDuelRequests()) + ChatColor.YELLOW + " to receive duel requests."); + } + else if (slot == 7) { + settings.setPublicChat(!settings.isPublicChat()); + player.sendMessage(ChatColor.YELLOW + "You are now " + this.able(settings.isPublicChat()) + ChatColor.YELLOW + " to see public chat messages."); + } + this.open((Player)event.getWhoClicked()); + } + } + + public String able(final boolean value) { + return value ? (ChatColor.GREEN + "able") : (ChatColor.RED + "unable"); + } + + public void open(final Player player) { + final Settings settings = this.plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(player.getUniqueId()).getSettings(); + final Inventory inventory = Bukkit.createInventory((InventoryHolder)null, 9, "Options"); + final String enabled = ChatColor.BLUE + StringEscapeUtils.unescapeHtml4("►") + " "; + List lore = Lists.newArrayList(); + lore.add(""); + lore.add(ChatColor.BLUE + "Do you want to see"); + lore.add(ChatColor.BLUE + "the scoreboard?"); + lore.add(""); + lore.add(" " + (settings.isScoreboard() ? enabled : " ") + ChatColor.YELLOW + "Show scoreboard"); + lore.add(" " + (settings.isScoreboard() ? " " : enabled) + ChatColor.YELLOW + "Hide scoreboard"); + String name = ChatColor.LIGHT_PURPLE + "Scoreboard"; + inventory.setItem(1, this.create(Material.PAINTING, name, lore)); + lore = Lists.newArrayList(); + lore.add(""); + lore.add(ChatColor.BLUE + "Do you want to receive"); + lore.add(ChatColor.BLUE + "duel requests?"); + lore.add(""); + lore.add(" " + (settings.isDuelRequests() ? enabled : " ") + ChatColor.YELLOW + "Show requests"); + lore.add(" " + (settings.isDuelRequests() ? " " : enabled) + ChatColor.YELLOW + "Hide requests"); + name = ChatColor.LIGHT_PURPLE + "Duel Requests"; + inventory.setItem(4, this.create(Material.SKULL_ITEM, (short)3, name, lore)); + lore = Lists.newArrayList(); + lore.add(""); + lore.add(ChatColor.BLUE + "Do you want to see"); + lore.add(ChatColor.BLUE + "public chat messages?"); + lore.add(""); + lore.add(" " + (settings.isPublicChat() ? enabled : " ") + ChatColor.YELLOW + "Show public chat"); + lore.add(" " + (settings.isPublicChat() ? " " : enabled) + ChatColor.YELLOW + "Hide public chat"); + name = ChatColor.LIGHT_PURPLE + "Public Chat"; + inventory.setItem(7, this.create(Material.SIGN, name, lore)); + player.openInventory(inventory); + } + + public static List translate(final List input) { + return (List)Lists.newArrayList((Iterable)Lists.transform((List)input, (Function)new Function() { + public String apply(@Nullable final String s) { + return ChatColor.translateAlternateColorCodes('&', s); + } + })); + } + + public ItemStack create(final Material material, final String name, final List lore) { + return this.create(material, (short)0, name, lore); + } + + public ItemStack create(final Material material, final short data, final String name, final List lore) { + final ItemStack itemstack = new ItemStack(material, 1, data); + final ItemMeta meta = itemstack.getItemMeta(); + meta.setDisplayName(ChatColor.translateAlternateColorCodes('&', name)); + meta.setLore((List)translate(lore)); + itemstack.setItemMeta(meta); + return itemstack; + } +} diff --git a/src/main/java/us/centile/practice/tournament/Tournament.java b/src/main/java/us/centile/practice/tournament/Tournament.java new file mode 100644 index 0000000..e65c5e0 --- /dev/null +++ b/src/main/java/us/centile/practice/tournament/Tournament.java @@ -0,0 +1,394 @@ +package us.centile.practice.tournament; + +import us.centile.practice.*; +import us.centile.practice.kit.*; +import us.centile.practice.tournament.tasks.*; +import org.bukkit.plugin.*; +import org.bukkit.scheduler.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.*; +import us.centile.practice.commands.*; +import org.bukkit.entity.*; +import java.util.*; + +public class Tournament +{ + private static List tournaments; + private nPractice plugin; + private int maximumPerTeam; + private int playersLimit; + private TournamentStage tournamentStage; + private TournamentTeam luckyTeam; + private List teams; + private List currentMatches; + private HashMap> matchesHistory; + private List currentQueue; + private Kit defaultKit; + private int taskId; + private boolean playerTournament; + private Long timeoutIdle; + private boolean started; + private boolean forceStarted; + + public Tournament(final int maximumPerTeam, final Kit defaultKit, final boolean playerTournament) { + this.plugin = nPractice.getInstance(); + this.maximumPerTeam = maximumPerTeam; + this.defaultKit = defaultKit; + this.teams = new ArrayList(); + this.currentMatches = new ArrayList(); + this.currentQueue = new ArrayList(); + this.matchesHistory = new HashMap>(); + this.forceStarted = false; + this.started = false; + this.playerTournament = playerTournament; + this.playersLimit = (this.playerTournament ? 16 : 32) * this.maximumPerTeam; + this.timeoutIdle = (this.playerTournament ? (System.currentTimeMillis() + 900000L) : 0L); + Tournament.tournaments.add(this); + this.taskId = this.getPlugin().getServer().getScheduler().runTaskTimerAsynchronously((Plugin)this.plugin, (BukkitRunnable)new TournamentTask(this), 200L, 200L).getTaskId(); + this.plugin.getServer().getScheduler().runTaskAsynchronously((Plugin)this.plugin, (Runnable)new UpdateInventoryTask(this.plugin, UpdateInventoryTask.InventoryTaskType.TOURNAMENT)); + } + + public void stopTournament() { + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ")"); + this.plugin.getServer().broadcastMessage(ChatColor.RED + "Ended by an administrator (Force-Stopped)"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + if (this.currentMatches.size() > 0) { + for (final TournamentMatch tournamentMatch : this.currentMatches) { + for (final UUID uuid : tournamentMatch.getMatchPlayers()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + player.sendMessage(ChatColor.RED.toString() + ChatColor.BOLD + "(-) You are still able to continue fighting."); + } + } + } + } + if (HostCommand.getRunningTournaments().size() >= 1) { + HostCommand.getRunningTournaments().clear(); + } + this.plugin.getServer().getScheduler().cancelTask(this.taskId); + Tournament.tournaments.remove(this); + } + + public void generateRoundMatches() { + if (this.timeoutIdle != 0L && this.timeoutIdle < System.currentTimeMillis()) { + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ")"); + this.plugin.getServer().broadcastMessage(ChatColor.RED + "Ended with not enough players (Timeout: 15 minutes)"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.stopTournament(); + return; + } + if (this.getTotalPlayersInTournament() < this.playersLimit && !this.forceStarted && !this.started) { + return; + } + if (this.currentMatches.size() > 0 && this.teams.size() > 1) { + return; + } + if (this.isMatchOnGoing()) { + return; + } + if (this.teams.size() <= 64 && this.teams.size() > 32 && this.tournamentStage != TournamentStage.FIRST_ROUND) { + this.setTournamentStage(TournamentStage.FIRST_ROUND); + if (!this.started) { + this.started = true; + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") 1ST ROUND"); + this.plugin.getServer().broadcastMessage(ChatColor.GRAY + "The First Round has just begun!"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + else if (this.teams.size() <= 32 && this.teams.size() > 16 && this.tournamentStage != TournamentStage.SECOND_ROUND) { + this.setTournamentStage(TournamentStage.SECOND_ROUND); + if (!this.started) { + this.started = true; + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") 2ND ROUND"); + this.plugin.getServer().broadcastMessage(ChatColor.GRAY + "The Second Round has just begun!"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + else if (this.teams.size() <= 16 && this.teams.size() > 8 && this.tournamentStage != TournamentStage.THIRD_ROUND) { + this.setTournamentStage(TournamentStage.THIRD_ROUND); + if (!this.started) { + this.started = true; + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") 3RD ROUND"); + this.plugin.getServer().broadcastMessage(ChatColor.GRAY + "The Third Round has just begun!"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + else if (this.teams.size() <= 8 && this.teams.size() > 4 && this.tournamentStage != TournamentStage.QUARTER_FINALS) { + this.setTournamentStage(TournamentStage.QUARTER_FINALS); + if (!this.started) { + this.started = true; + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") QUARTER FINALS"); + this.plugin.getServer().broadcastMessage(ChatColor.GRAY + "Quarter Finals have just begun!"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + else if (this.teams.size() <= 4 && this.teams.size() > 2 && this.tournamentStage != TournamentStage.SEMI_FINALS) { + this.setTournamentStage(TournamentStage.SEMI_FINALS); + if (!this.started) { + this.started = true; + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") SEMI-FINALS"); + this.plugin.getServer().broadcastMessage(ChatColor.GRAY + "Semi-Finals have just begun!"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + else if (this.teams.size() == 2 && this.tournamentStage != TournamentStage.FINALS) { + this.setTournamentStage(TournamentStage.FINALS); + if (!this.started) { + this.started = true; + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") FINALS"); + this.plugin.getServer().broadcastMessage(ChatColor.GRAY.toString() + ChatColor.BOLD + "The Grand Finals has just begun!"); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + } + else if (this.teams.size() == 1) { + final StringJoiner members = new StringJoiner(", "); + for (final UUID uuid : this.teams.get(0).getPlayers()) { + if (Bukkit.getOfflinePlayer(uuid) != null) { + members.add(Bukkit.getOfflinePlayer(uuid).getName()); + } + } + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().broadcastMessage(ChatColor.GREEN.toString() + ChatColor.BOLD + (this.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + this.maximumPerTeam + "v" + this.maximumPerTeam + ") WINNER"); + this.plugin.getServer().broadcastMessage(ChatColor.GREEN + "Winner" + ((this.teams.get(0).getPlayers().size() > 1) ? "s" : (": " + members))); + this.plugin.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + this.plugin.getServer().getScheduler().cancelTask(this.taskId); + Tournament.tournaments.remove(this); + return; + } + this.currentQueue.clear(); + this.currentQueue.addAll(this.teams); + if (this.currentQueue.size() % 2 != 0) { + this.luckyTeam = this.currentQueue.get(0); + this.currentQueue.remove(0); + this.luckyTeam.sendMessage(ChatColor.YELLOW + "You have been skipped to the next round."); + this.luckyTeam.sendMessage(ChatColor.YELLOW + "There was no matching team for you."); + } + this.currentMatches.clear(); + for (int j = 0; j < this.currentQueue.size(); j += 2) { + final TournamentMatch match = new TournamentMatch(); + match.setMatchState(TournamentMatch.MatchState.WAITING); + match.setFirstTeam(this.currentQueue.get(j)); + match.setSecondTeam(this.currentQueue.get(j + 1)); + match.start(this.plugin, this.defaultKit); + this.currentMatches.add(match); + } + this.matchesHistory.put(this.tournamentStage, this.currentMatches); + } + + public void sendMessage(final String message) { + for (final TournamentTeam team : this.teams) { + team.sendMessage(message); + } + } + + public boolean isInTournament(final Player player) { + for (final TournamentTeam tournamentTeam : this.teams) { + if (tournamentTeam.getPlayers().contains(player.getUniqueId())) { + return true; + } + } + return false; + } + + public TournamentMatch getTournamentMatch(final Player player) { + for (final TournamentMatch match : this.currentMatches) { + if (match.getMatchPlayers().contains(player.getUniqueId())) { + return match; + } + } + return null; + } + + private boolean isMatchOnGoing() { + for (final TournamentMatch match : this.currentMatches) { + if (match.getMatchState() == TournamentMatch.MatchState.FIGHTING) { + return true; + } + } + return false; + } + + public int getTotalPlayersInTournament() { + int total = 0; + for (final TournamentTeam tournamentTeam : this.teams) { + total += tournamentTeam.getPlayers().size(); + } + return total; + } + + public TournamentTeam getTournamentTeam(final Player player) { + for (final TournamentTeam tournamentTeam : this.teams) { + if (tournamentTeam.getPlayers().contains(player.getUniqueId())) { + return tournamentTeam; + } + } + return null; + } + + public static void forceEndPlayerTournaments() { + if (Tournament.tournaments.size() == 0) { + return; + } + final Iterator iterator = Tournament.tournaments.iterator(); + while (iterator.hasNext()) { + final Tournament tournament = iterator.next(); + if (tournament == null) { + continue; + } + if (!tournament.isPlayerTournament()) { + continue; + } + Bukkit.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + Bukkit.getServer().broadcastMessage(ChatColor.YELLOW.toString() + ChatColor.BOLD + (tournament.playerTournament ? "PLAYER " : "") + "TOURNAMENT (" + tournament.maximumPerTeam + "v" + tournament.maximumPerTeam + ")"); + Bukkit.getServer().broadcastMessage(ChatColor.RED + "Ended by an administator (Force-Stopped)"); + Bukkit.getServer().broadcastMessage(ChatColor.DARK_GRAY.toString() + ChatColor.STRIKETHROUGH + "----------------------------------------------------"); + if (tournament.getCurrentMatches().size() > 0) { + for (final TournamentMatch tournamentMatch : tournament.getCurrentMatches()) { + for (final UUID uuid : tournamentMatch.getMatchPlayers()) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + player.sendMessage(ChatColor.RED.toString() + ChatColor.BOLD + "(-) You are still able to continue fighting."); + } + } + } + } + if (HostCommand.getRunningTournaments().size() >= 1) { + HostCommand.getRunningTournaments().clear(); + } + Bukkit.getServer().getScheduler().cancelTask(tournament.taskId); + iterator.remove(); + } + } + + public static List getTournaments() { + return Tournament.tournaments; + } + + public nPractice getPlugin() { + return this.plugin; + } + + public int getMaximumPerTeam() { + return this.maximumPerTeam; + } + + public void setMaximumPerTeam(final int maximumPerTeam) { + this.maximumPerTeam = maximumPerTeam; + } + + public int getPlayersLimit() { + return this.playersLimit; + } + + public void setPlayersLimit(final int playersLimit) { + this.playersLimit = playersLimit; + } + + public TournamentStage getTournamentStage() { + return this.tournamentStage; + } + + public void setTournamentStage(final TournamentStage tournamentStage) { + this.tournamentStage = tournamentStage; + } + + public TournamentTeam getLuckyTeam() { + return this.luckyTeam; + } + + public void setLuckyTeam(final TournamentTeam luckyTeam) { + this.luckyTeam = luckyTeam; + } + + public List getTeams() { + return this.teams; + } + + public void setTeams(final List teams) { + this.teams = teams; + } + + public List getCurrentMatches() { + return this.currentMatches; + } + + public void setCurrentMatches(final List currentMatches) { + this.currentMatches = currentMatches; + } + + public HashMap> getMatchesHistory() { + return this.matchesHistory; + } + + public void setMatchesHistory(final HashMap> matchesHistory) { + this.matchesHistory = matchesHistory; + } + + public List getCurrentQueue() { + return this.currentQueue; + } + + public void setCurrentQueue(final List currentQueue) { + this.currentQueue = currentQueue; + } + + public Kit getDefaultKit() { + return this.defaultKit; + } + + public void setDefaultKit(final Kit defaultKit) { + this.defaultKit = defaultKit; + } + + public int getTaskId() { + return this.taskId; + } + + public void setTaskId(final int taskId) { + this.taskId = taskId; + } + + public boolean isPlayerTournament() { + return this.playerTournament; + } + + public void setPlayerTournament(final boolean playerTournament) { + this.playerTournament = playerTournament; + } + + public Long getTimeoutIdle() { + return this.timeoutIdle; + } + + public void setTimeoutIdle(final Long timeoutIdle) { + this.timeoutIdle = timeoutIdle; + } + + public boolean isStarted() { + return this.started; + } + + public void setStarted(final boolean started) { + this.started = started; + } + + public boolean isForceStarted() { + return this.forceStarted; + } + + public void setForceStarted(final boolean forceStarted) { + this.forceStarted = forceStarted; + } + + static { + Tournament.tournaments = new ArrayList(); + } +} diff --git a/src/main/java/us/centile/practice/tournament/TournamentListener.java b/src/main/java/us/centile/practice/tournament/TournamentListener.java new file mode 100644 index 0000000..fea3340 --- /dev/null +++ b/src/main/java/us/centile/practice/tournament/TournamentListener.java @@ -0,0 +1,34 @@ +package us.centile.practice.tournament; + +import org.bukkit.event.player.*; +import org.bukkit.*; +import us.centile.practice.*; +import org.bukkit.entity.*; +import java.util.*; +import org.bukkit.event.*; + +public class TournamentListener implements Listener +{ + @EventHandler + public void onPlayerQuitEvent(final PlayerQuitEvent event) { + final Player player = event.getPlayer(); + if (Tournament.getTournaments().size() == 0) { + return; + } + for (final Tournament tournament : Tournament.getTournaments()) { + if (tournament.isInTournament(player)) { + final TournamentTeam tournamentTeam = tournament.getTournamentTeam(player); + if (tournamentTeam == null) { + continue; + } + final String reason = (tournamentTeam.getPlayers().size() > 1) ? "(Tournament) Someone in your party left the server" : "(Tournament) You have left the server"; + tournamentTeam.sendMessage(ChatColor.RED + reason); + final TournamentMatch match = tournament.getTournamentMatch(player); + if (match == null) { + continue; + } + nPractice.getInstance().getManagerHandler().getDuelManager().removePlayerFromDuel(player); + } + } + } +} diff --git a/src/main/java/us/centile/practice/tournament/TournamentMatch.java b/src/main/java/us/centile/practice/tournament/TournamentMatch.java new file mode 100644 index 0000000..8e6d926 --- /dev/null +++ b/src/main/java/us/centile/practice/tournament/TournamentMatch.java @@ -0,0 +1,96 @@ +package us.centile.practice.tournament; + +import us.centile.practice.*; +import us.centile.practice.kit.*; +import java.util.*; +import org.bukkit.*; +import us.centile.practice.arena.*; +import org.bukkit.plugin.*; + +public class TournamentMatch +{ + private TournamentTeam firstTeam; + private TournamentTeam secondTeam; + private List matchPlayers; + private MatchState matchState; + private int winndingId; + + public void start(final nPractice plugin, final Kit defaultKit) { + (this.matchPlayers = new ArrayList()).addAll(this.firstTeam.getPlayers()); + this.matchPlayers.addAll(this.secondTeam.getPlayers()); + Bukkit.getScheduler().runTaskLater((Plugin)plugin, (Runnable)new Runnable() { + @Override + public void run() { + final Arena arena = plugin.getManagerHandler().getArenaManager().getRandomArena(); + plugin.getManagerHandler().getDuelManager().createDuel(arena, defaultKit, false, TournamentMatch.this.firstTeam.getPlayers().get(0), TournamentMatch.this.secondTeam.getPlayers().get(0), TournamentMatch.this.firstTeam.getPlayers(), TournamentMatch.this.secondTeam.getPlayers(), true, false); + } + }, 40L); + this.matchState = MatchState.FIGHTING; + this.winndingId = 0; + } + + public TournamentTeam getTournamentTeam(final TournamentTeam team) { + if (this.firstTeam == team) { + return this.firstTeam; + } + if (this.secondTeam == team) { + return this.secondTeam; + } + return null; + } + + public TournamentTeam getOtherTeam(final TournamentTeam tournamentTeam) { + return this.getOtherDuelTeam(this.getTournamentTeam(tournamentTeam)); + } + + public TournamentTeam getOtherDuelTeam(final TournamentTeam duelTeam) { + return (duelTeam == null) ? null : (duelTeam.equals(this.firstTeam) ? this.secondTeam : this.firstTeam); + } + + public TournamentTeam getFirstTeam() { + return this.firstTeam; + } + + public void setFirstTeam(final TournamentTeam firstTeam) { + this.firstTeam = firstTeam; + } + + public TournamentTeam getSecondTeam() { + return this.secondTeam; + } + + public void setSecondTeam(final TournamentTeam secondTeam) { + this.secondTeam = secondTeam; + } + + public List getMatchPlayers() { + return this.matchPlayers; + } + + public void setMatchPlayers(final List matchPlayers) { + this.matchPlayers = matchPlayers; + } + + public MatchState getMatchState() { + return this.matchState; + } + + public void setMatchState(final MatchState matchState) { + this.matchState = matchState; + } + + public int getWinndingId() { + return this.winndingId; + } + + public void setWinndingId(final int winndingId) { + this.winndingId = winndingId; + } + + public enum MatchState + { + WAITING, + FIGHTING, + ENDING; + } +} diff --git a/src/main/java/us/centile/practice/tournament/TournamentStage.java b/src/main/java/us/centile/practice/tournament/TournamentStage.java new file mode 100644 index 0000000..1478e54 --- /dev/null +++ b/src/main/java/us/centile/practice/tournament/TournamentStage.java @@ -0,0 +1,22 @@ +package us.centile.practice.tournament; + +import org.apache.commons.lang.*; +import com.google.common.base.*; + +public enum TournamentStage +{ + FIRST_ROUND, + SECOND_ROUND, + THIRD_ROUND, + QUARTER_FINALS, + SEMI_FINALS, + FINALS; + + public String toReadable() { + final String[] split = this.name().split("_"); + for (int i = 0; i < split.length; ++i) { + split[i] = WordUtils.capitalize(split[i].toLowerCase()); + } + return Joiner.on(" ").join((Object[])split); + } +} diff --git a/src/main/java/us/centile/practice/tournament/TournamentTeam.java b/src/main/java/us/centile/practice/tournament/TournamentTeam.java new file mode 100644 index 0000000..b96fdd4 --- /dev/null +++ b/src/main/java/us/centile/practice/tournament/TournamentTeam.java @@ -0,0 +1,31 @@ +package us.centile.practice.tournament; + +import org.bukkit.*; +import java.util.*; +import org.bukkit.entity.*; + +public class TournamentTeam +{ + private List players; + + public TournamentTeam() { + this.players = new ArrayList(); + } + + public void sendMessage(final String message) { + for (final UUID uuid : this.players) { + final Player player = Bukkit.getPlayer(uuid); + if (player != null) { + player.sendMessage(message); + } + } + } + + public List getPlayers() { + return this.players; + } + + public void setPlayers(final List players) { + this.players = players; + } +} diff --git a/src/main/java/us/centile/practice/tournament/tasks/TournamentTask.java b/src/main/java/us/centile/practice/tournament/tasks/TournamentTask.java new file mode 100644 index 0000000..d6866d4 --- /dev/null +++ b/src/main/java/us/centile/practice/tournament/tasks/TournamentTask.java @@ -0,0 +1,20 @@ +package us.centile.practice.tournament.tasks; + +import org.bukkit.scheduler.*; +import us.centile.practice.tournament.*; +import us.centile.practice.runnables.other.*; +import org.bukkit.plugin.*; + +public class TournamentTask extends BukkitRunnable +{ + private Tournament tournament; + + public TournamentTask(final Tournament tournament) { + this.tournament = tournament; + } + + public void run() { + this.tournament.generateRoundMatches(); + this.tournament.getPlugin().getServer().getScheduler().runTaskAsynchronously((Plugin)this.tournament.getPlugin(), (Runnable)new UpdateInventoryTask(this.tournament.getPlugin(), UpdateInventoryTask.InventoryTaskType.TOURNAMENT)); + } +} diff --git a/src/main/java/us/centile/practice/util/AbstractSerializer.java b/src/main/java/us/centile/practice/util/AbstractSerializer.java new file mode 100644 index 0000000..e3c6653 --- /dev/null +++ b/src/main/java/us/centile/practice/util/AbstractSerializer.java @@ -0,0 +1,8 @@ +package us.centile.practice.util; + +public abstract class AbstractSerializer +{ + public abstract String toString(final T p0); + + public abstract T fromString(final Object p0); +} diff --git a/src/main/java/us/centile/practice/util/Config.java b/src/main/java/us/centile/practice/util/Config.java new file mode 100644 index 0000000..8c297a6 --- /dev/null +++ b/src/main/java/us/centile/practice/util/Config.java @@ -0,0 +1,52 @@ +package us.centile.practice.util; + +import org.bukkit.plugin.java.*; +import java.io.*; +import org.bukkit.configuration.file.*; + +public class Config +{ + private FileConfiguration config; + private File file; + private String name; + + public Config(final JavaPlugin plugin, final String path, final String name) { + (this.file = new File(plugin.getDataFolder() + path)).mkdirs(); + this.file = new File(plugin.getDataFolder() + path, name + ".yml"); + try { + this.file.createNewFile(); + } + catch (IOException ex) {} + this.name = name; + this.config = (FileConfiguration)YamlConfiguration.loadConfiguration(this.file); + } + + public String getName() { + return this.name; + } + + public FileConfiguration getConfig() { + return this.config; + } + + public void setDefault(final String Path, final Object Set) { + if (!this.getConfig().contains(Path)) { + this.config.set(Path, Set); + this.save(); + } + } + + public void reload() { + try { + this.config.load(this.file); + } + catch (Exception ex) {} + } + + public void save() { + try { + this.config.save(this.file); + } + catch (IOException ex) {} + } +} diff --git a/src/main/java/us/centile/practice/util/DateUtil.java b/src/main/java/us/centile/practice/util/DateUtil.java new file mode 100644 index 0000000..ba31721 --- /dev/null +++ b/src/main/java/us/centile/practice/util/DateUtil.java @@ -0,0 +1,208 @@ +package us.centile.practice.util; + +import java.util.regex.*; +import java.util.*; +import java.math.*; +import java.text.*; +import java.io.*; + +public class DateUtil +{ + private static Pattern timePattern; + + public static String removeTimePattern(final String input) { + return DateUtil.timePattern.matcher(input).replaceFirst("").trim(); + } + + public static long parseDateDiff(final String time, final boolean future) throws Exception { + final Matcher m = DateUtil.timePattern.matcher(time); + int years = 0; + int months = 0; + int weeks = 0; + int days = 0; + int hours = 0; + int minutes = 0; + int seconds = 0; + boolean found = false; + while (m.find()) { + if (m.group() != null && !m.group().isEmpty()) { + for (int c = 0; c < m.groupCount(); ++c) { + if (m.group(c) != null && !m.group(c).isEmpty()) { + found = true; + break; + } + } + if (!found) { + continue; + } + if (m.group(1) != null && !m.group(1).isEmpty()) { + years = Integer.parseInt(m.group(1)); + } + if (m.group(2) != null && !m.group(2).isEmpty()) { + months = Integer.parseInt(m.group(2)); + } + if (m.group(3) != null && !m.group(3).isEmpty()) { + weeks = Integer.parseInt(m.group(3)); + } + if (m.group(4) != null && !m.group(4).isEmpty()) { + days = Integer.parseInt(m.group(4)); + } + if (m.group(5) != null && !m.group(5).isEmpty()) { + hours = Integer.parseInt(m.group(5)); + } + if (m.group(6) != null && !m.group(6).isEmpty()) { + minutes = Integer.parseInt(m.group(6)); + } + if (m.group(7) != null && !m.group(7).isEmpty()) { + seconds = Integer.parseInt(m.group(7)); + break; + } + break; + } + } + if (!found) { + throw new Exception("Illegal Date"); + } + final GregorianCalendar var13 = new GregorianCalendar(); + if (years > 0) { + var13.add(1, years * (future ? 1 : -1)); + } + if (months > 0) { + var13.add(2, months * (future ? 1 : -1)); + } + if (weeks > 0) { + var13.add(3, weeks * (future ? 1 : -1)); + } + if (days > 0) { + var13.add(5, days * (future ? 1 : -1)); + } + if (hours > 0) { + var13.add(11, hours * (future ? 1 : -1)); + } + if (minutes > 0) { + var13.add(12, minutes * (future ? 1 : -1)); + } + if (seconds > 0) { + var13.add(13, seconds * (future ? 1 : -1)); + } + final GregorianCalendar max = new GregorianCalendar(); + max.add(1, 10); + return var13.after(max) ? max.getTimeInMillis() : var13.getTimeInMillis(); + } + + static int dateDiff(final int type, final Calendar fromDate, final Calendar toDate, final boolean future) { + int diff = 0; + long savedDate = fromDate.getTimeInMillis(); + while ((future && !fromDate.after(toDate)) || (!future && !fromDate.before(toDate))) { + savedDate = fromDate.getTimeInMillis(); + fromDate.add(type, future ? 1 : -1); + ++diff; + } + --diff; + fromDate.setTimeInMillis(savedDate); + return diff; + } + + public static String formatDateDiff(final long date) { + final GregorianCalendar c = new GregorianCalendar(); + c.setTimeInMillis(date); + final GregorianCalendar now = new GregorianCalendar(); + return formatDateDiff(now, c); + } + + public static String formatDateDiff(final Calendar fromDate, final Calendar toDate) { + boolean future = false; + if (toDate.equals(fromDate)) { + return "now"; + } + if (toDate.after(fromDate)) { + future = true; + } + final StringBuilder sb = new StringBuilder(); + final int[] types = { 1, 2, 5, 11, 12, 13 }; + final String[] names = { "year", "years", "month", "months", "day", "days", "hour", "hours", "minute", "minutes", "second", "seconds" }; + for (int accuracy = 0, i = 0; i < types.length && accuracy <= 2; ++i) { + final int diff = dateDiff(types[i], fromDate, toDate, future); + if (diff > 0) { + ++accuracy; + sb.append(" ").append(diff).append(" ").append(names[i * 2 + ((diff > 1) ? 1 : 0)]); + } + } + return (sb.length() == 0) ? "now" : sb.toString().trim(); + } + + public static String formatSimplifiedDateDiff(final long date) { + final GregorianCalendar c = new GregorianCalendar(); + c.setTimeInMillis(date); + final GregorianCalendar now = new GregorianCalendar(); + return formatSimplifiedDateDiff(now, c); + } + + public static String formatSimplifiedDateDiff(final Calendar fromDate, final Calendar toDate) { + boolean future = false; + if (toDate.equals(fromDate)) { + return "now"; + } + if (toDate.after(fromDate)) { + future = true; + } + final StringBuilder sb = new StringBuilder(); + final int[] types = { 1, 2, 5, 11, 12, 13 }; + final String[] names = { "y", "y", "m", "m", "d", "d", "h", "h", "m", "m", "s", "s" }; + for (int accuracy = 0, i = 0; i < types.length && accuracy <= 2; ++i) { + final int diff = dateDiff(types[i], fromDate, toDate, future); + if (diff > 0) { + ++accuracy; + sb.append(" ").append(diff).append("").append(names[i * 2 + ((diff > 1) ? 1 : 0)]); + } + } + return (sb.length() == 0) ? "now" : sb.toString().trim(); + } + + public static String readableTime(final long time) { + final short SECOND = 1000; + final int MINUTE = 60000; + final int HOUR = 3600000; + final int DAY = 86400000; + long ms = time; + final StringBuilder text = new StringBuilder(""); + if (time > 86400000L) { + text.append(time / 86400000L).append(" days "); + ms = time % 86400000L; + } + if (ms > 3600000L) { + text.append(ms / 3600000L).append(" hours "); + ms %= 3600000L; + } + if (ms > 60000L) { + text.append(ms / 60000L).append(" minutes "); + ms %= 60000L; + } + if (ms > 1000L) { + text.append(ms / 1000L).append(" seconds "); + } + if (text.toString().trim().isEmpty()) { + return "now"; + } + return text.toString(); + } + + public static String readableTime(BigDecimal time) { + final String text = ""; + if (time.doubleValue() <= 60.0) { + time = time.add(BigDecimal.valueOf(0.1)); + return " " + time + "s"; + } + if (time.doubleValue() <= 3600.0) { + final int minutes = time.intValue() / 60; + final int seconds = time.intValue() % 60; + final DecimalFormat formatter = new DecimalFormat("00"); + return " " + formatter.format(minutes) + ":" + formatter.format(seconds) + "m"; + } + return null; + } + + static { + DateUtil.timePattern = Pattern.compile("(?:([0-9]+)\\s*y[a-z]*[,\\s]*)?(?:([0-9]+)\\s*mo[a-z]*[,\\s]*)?(?:([0-9]+)\\s*w[a-z]*[,\\s]*)?(?:([0-9]+)\\s*d[a-z]*[,\\s]*)?(?:([0-9]+)\\s*h[a-z]*[,\\s]*)?(?:([0-9]+)\\s*m[a-z]*[,\\s]*)?(?:([0-9]+)\\s*(?:s[a-z]*)?)?", 2); + } +} diff --git a/src/main/java/us/centile/practice/util/LocationSerializer.java b/src/main/java/us/centile/practice/util/LocationSerializer.java new file mode 100644 index 0000000..87fb72a --- /dev/null +++ b/src/main/java/us/centile/practice/util/LocationSerializer.java @@ -0,0 +1,15 @@ +package us.centile.practice.util; + +import org.bukkit.*; + +public class LocationSerializer +{ + public static String serializeLocation(final Location location) { + return location.getWorld().getName() + ":" + location.getX() + ":" + location.getY() + ":" + location.getZ() + ":" + location.getYaw() + ":" + location.getPitch(); + } + + public static Location deserializeLocation(final String serializedLocation) { + final String[] split = serializedLocation.split(":"); + return new Location(Bukkit.getServer().getWorld(split[0]), Double.parseDouble(split[1]), Double.parseDouble(split[2]), Double.parseDouble(split[3]), Float.parseFloat(split[4]), Float.parseFloat(split[5])); + } +} diff --git a/src/main/java/us/centile/practice/util/MapSorting.java b/src/main/java/us/centile/practice/util/MapSorting.java new file mode 100644 index 0000000..ce18924 --- /dev/null +++ b/src/main/java/us/centile/practice/util/MapSorting.java @@ -0,0 +1,48 @@ +package us.centile.practice.util; + +import com.google.common.base.*; +import java.util.*; +import com.google.common.collect.*; + +public class MapSorting +{ + private static final Function EXTRACT_KEY; + private static final Function EXTRACT_VALUE; + + public static > List> sortedValues(final Map map) { + return sortedValues(map, Ordering.natural()); + } + + public static List> sortedValues(final Map map, final Comparator valueComparator) { + return (List>)Ordering.from((Comparator)valueComparator).onResultOf(extractValue()).sortedCopy(map.entrySet()); + } + + public static Iterable keys(final List> entryList) { + return (Iterable)Iterables.transform(entryList, extractKey()); + } + + public static Iterable values(final List> entryList) { + return (Iterable)Iterables.transform(entryList, extractValue()); + } + + private static Function, T> extractKey() { + return (Function, T>)MapSorting.EXTRACT_KEY; + } + + private static Function, V> extractValue() { + return (Function, V>)MapSorting.EXTRACT_VALUE; + } + + static { + EXTRACT_KEY = new Function, Object>() { + public Object apply(final Map.Entry input) { + return (input == null) ? null : input.getKey(); + } + }; + EXTRACT_VALUE = new Function, Object>() { + public Object apply(final Map.Entry input) { + return (input == null) ? null : input.getValue(); + } + }; + } +} diff --git a/src/main/java/us/centile/practice/util/Messages.java b/src/main/java/us/centile/practice/util/Messages.java new file mode 100644 index 0000000..2e995c6 --- /dev/null +++ b/src/main/java/us/centile/practice/util/Messages.java @@ -0,0 +1,32 @@ +package us.centile.practice.util; + +import org.bukkit.*; + +public class Messages +{ + public static final String PLAYER_NOT_FOUND; + public static final String PLAYER_BUSY; + public static final String WAIT_SENDING_DUEL; + public static final String NO_REQUESTS_FOUND; + public static final String WAIT_EPEARL; + public static final String REQUESTED_PLAYER_NOT_IN_FIGHT; + public static final String NO_PERMISSION; + public static final String CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE; + public static final String CANNOT_FIND_SNAPSHOT; + public static final String CANNOT_DUEL_YOURSELF; + public static final String SPECIFY_KIT; + + static { + PLAYER_NOT_FOUND = ChatColor.RED + "Player not found"; + PLAYER_BUSY = ChatColor.RED + "This player is currently busy"; + WAIT_SENDING_DUEL = ChatColor.RED + "You already sent a duel request to this player, you must wait before sending one again."; + NO_REQUESTS_FOUND = ChatColor.RED + "You do not have any pending requests"; + WAIT_EPEARL = ChatColor.RED + "You must wait before throwing another ender pearl"; + REQUESTED_PLAYER_NOT_IN_FIGHT = ChatColor.RED + "The requested player is currently not in a fight"; + NO_PERMISSION = ChatColor.RED + "You do not have sufficient permissions to use this command"; + CANNOT_PERFORM_COMMAND_IN_CURRENT_STATE = ChatColor.RED + "Cannot execute this command in your current state"; + CANNOT_FIND_SNAPSHOT = ChatColor.RED + "Cannot find the requested inventory. Maybe it expired?"; + CANNOT_DUEL_YOURSELF = ChatColor.RED + "Cannot duel yourself!"; + SPECIFY_KIT = ChatColor.RED + "Please Specify Kit"; + } +} diff --git a/src/main/java/us/centile/practice/util/PlayerUtility.java b/src/main/java/us/centile/practice/util/PlayerUtility.java new file mode 100644 index 0000000..2e2c87f --- /dev/null +++ b/src/main/java/us/centile/practice/util/PlayerUtility.java @@ -0,0 +1,24 @@ +package us.centile.practice.util; + +import org.bukkit.entity.*; +import java.util.*; +import org.bukkit.*; + +public class PlayerUtility +{ + public static Set getConvertedUuidSet(final Set uuids) { + final Set toReturn = new HashSet(); + for (final UUID uuid : uuids) { + toReturn.add(uuid.toString()); + } + return toReturn; + } + + public static List getOnlinePlayers() { + final ArrayList ret = new ArrayList(); + for (final Player player : Bukkit.getServer().getOnlinePlayers()) { + ret.add(player); + } + return ret; + } +} diff --git a/src/main/java/us/centile/practice/util/Sinventory.java b/src/main/java/us/centile/practice/util/Sinventory.java new file mode 100644 index 0000000..1483763 --- /dev/null +++ b/src/main/java/us/centile/practice/util/Sinventory.java @@ -0,0 +1,129 @@ +package us.centile.practice.util; + +import org.bukkit.entity.*; +import org.bukkit.*; +import com.google.common.collect.*; +import org.bukkit.inventory.*; +import java.util.*; +import us.centile.practice.*; +import org.bukkit.event.inventory.*; +import us.centile.practice.duel.*; +import us.centile.practice.player.*; + +public class Sinventory +{ + private String title; + private List contents; + private ItemStack oldPage; + private ItemStack nextPage; + private int page; + private int totalPages; + + public Sinventory(final String title) { + this.page = 1; + this.totalPages = 1; + this.title = title; + this.contents = new ArrayList(); + this.nextPage = UtilItem.createItem(Material.ARROW, 1, (short)0, ChatColor.GREEN + "Next ->"); + this.oldPage = UtilItem.createItem(Material.ARROW, 1, (short)0, ChatColor.GREEN + "<- Back"); + } + + public Sinventory addItem(final ItemStack item) { + this.contents.add(item); + this.setTotalPages(); + return this; + } + + public void openInventory(final Player player) { + if (this.totalPages == 1) { + final Inventory inventory = Bukkit.createInventory(null, this.calcSize(this.contents.size()), this.title); + int slot = 0; + for (final ItemStack item : this.contents) { + inventory.setItem(slot++, item); + } + player.openInventory(inventory); + return; + } + int startPoint = (this.page - 1) * 45; + final List invContents = Lists.newArrayList(); + try { + ItemStack item2; + while ((item2 = this.contents.get(startPoint++)) != null) { + invContents.add(item2); + if (startPoint - (this.page - 1) * 45 == 45) { + break; + } + } + } + catch (IndexOutOfBoundsException ex) {} + final Inventory inventory2 = Bukkit.createInventory(null, 54, this.title); + int slot2 = 0; + for (final ItemStack invItem : invContents) { + inventory2.setItem(slot2++, invItem); + } + if (this.page > 1) { + inventory2.setItem(45, this.oldPage); + } + if (this.page < this.getPages(this.contents.size())) { + inventory2.setItem(53, this.nextPage); + } + player.openInventory(inventory2); + } + + public void executeClickEvent(final nPractice plugin, final Player player, final int slot, final InventoryClickEvent event) { + event.setCancelled(true); + if (slot == 45 && this.page > 1) { + --this.page; + this.openInventory(player); + } + if (slot == 53 && this.page < this.getPages(this.contents.size())) { + ++this.page; + this.openInventory(player); + } + if (event.getCurrentItem() != null && event.getCurrentItem().getType() == Material.PAPER && event.getCurrentItem().hasItemMeta() && event.getCurrentItem().getItemMeta().hasDisplayName() && event.getCurrentItem().getItemMeta().hasLore()) { + final String duelIdentifier = ChatColor.stripColor(event.getCurrentItem().getItemMeta().getLore().get(0).split(" ")[0]).replace("'s", ""); + if (Bukkit.getPlayer(duelIdentifier) == null) { + player.sendMessage(Messages.PLAYER_NOT_FOUND); + player.closeInventory(); + return; + } + final Player target = Bukkit.getPlayer(duelIdentifier); + final Duel duel = plugin.getManagerHandler().getDuelManager().getDuelFromPlayer(target.getUniqueId()); + if (duel == null) { + player.sendMessage(ChatColor.RED + "That duel match has ended."); + return; + } + final PracticePlayer practiceTarget = plugin.getManagerHandler().getPracticePlayerManager().getPracticePlayer(target); + if (practiceTarget.getCurrentState() != PlayerState.FIGHTING) { + player.sendMessage(Messages.REQUESTED_PLAYER_NOT_IN_FIGHT); + return; + } + plugin.getManagerHandler().getSpectatorManager().addSpectator(player, target); + player.sendMessage(ChatColor.YELLOW + "You are now spectating " + ChatColor.GREEN + target.getName()); + } + } + + public List getContents() { + return this.contents; + } + + public String getTitle() { + return this.title; + } + + private void setTotalPages() { + this.totalPages = ((this.contents.size() > 54) ? (this.contents.size() / 45) : 1); + } + + private int calcSize(final int size) { + return ((size - 1) / 9 + 1) * 9; + } + + private int getPages(final int size) { + if (size % 45 == 0) { + return size / 45; + } + final Double value = (size + 1.0) / 45.0; + return (int)Math.ceil(value); + } +} diff --git a/src/main/java/us/centile/practice/util/TtlArrayList.java b/src/main/java/us/centile/practice/util/TtlArrayList.java new file mode 100644 index 0000000..fcfd47e --- /dev/null +++ b/src/main/java/us/centile/practice/util/TtlArrayList.java @@ -0,0 +1,155 @@ +package us.centile.practice.util; + +import java.util.concurrent.*; +import java.util.*; + +public class TtlArrayList implements List +{ + private final List store; + private final HashMap timestamps; + private final long ttl; + + public TtlArrayList(final TimeUnit ttlUnit, final long ttlValue) { + this.store = new ArrayList(); + this.timestamps = new HashMap(); + this.ttl = ttlUnit.toNanos(ttlValue); + } + + private boolean expired(final E value) { + return System.nanoTime() - this.timestamps.get(value) > this.ttl; + } + + @Override + public E get(final int index) { + final E e = this.store.get(index); + if (e != null && this.store.contains(e) && this.timestamps.containsKey(e) && this.expired(e)) { + this.store.remove(e); + this.timestamps.remove(e); + return null; + } + return e; + } + + @Override + public int indexOf(final Object o) { + return this.store.indexOf(o); + } + + @Override + public int lastIndexOf(final Object o) { + return this.store.lastIndexOf(o); + } + + @Override + public E set(final int index, final E e) { + this.timestamps.put(e, System.nanoTime()); + return this.store.set(index, e); + } + + @Override + public boolean add(final E value) { + this.timestamps.put(value, System.nanoTime()); + return this.store.add(value); + } + + @Override + public void add(final int i, final E value) { + this.timestamps.put(value, System.nanoTime()); + this.store.add(i, value); + } + + @Override + public boolean addAll(final Collection c) { + return this.store.addAll(c); + } + + @Override + public boolean addAll(final int index, final Collection c) { + return this.store.addAll(index, c); + } + + @Override + public int size() { + return this.store.size(); + } + + @Override + public boolean isEmpty() { + return this.store.isEmpty(); + } + + @Override + public boolean contains(final Object value) { + if (value != null && this.store.contains(value) && this.timestamps.containsKey(value) && this.expired((E) value)) { + this.store.remove(value); + this.timestamps.remove(value); + return false; + } + return this.store.contains(value); + } + + @Override + public boolean remove(final Object value) { + this.timestamps.remove(value); + return this.store.remove(value); + } + + @Override + public E remove(final int i) { + return this.store.remove(i); + } + + @Override + public boolean removeAll(final Collection a) { + for (final Object object : a) { + this.timestamps.remove(object); + } + return this.store.removeAll(a); + } + + @Override + public void clear() { + this.timestamps.clear(); + this.store.clear(); + } + + @Override + public Object[] toArray() { + return this.store.toArray(); + } + + @Override + public Object[] toArray(final Object[] a) { + return this.store.toArray(a); + } + + @Override + public ListIterator listIterator() { + return this.store.listIterator(); + } + + @Override + public ListIterator listIterator(final int a) { + return this.store.listIterator(a); + } + + @Override + public Iterator iterator() { + return this.store.iterator(); + } + + @Override + public boolean retainAll(final Collection c) { + return this.store.retainAll(c); + } + + @Override + public List subList(final int fromIndex, final int toIndex) { + return this.store.subList(fromIndex, toIndex); + } + + @Override + public boolean containsAll(final Collection c) { + return this.store.containsAll(c); + } +} diff --git a/src/main/java/us/centile/practice/util/TtlHashMap.java b/src/main/java/us/centile/practice/util/TtlHashMap.java new file mode 100644 index 0000000..bd09969 --- /dev/null +++ b/src/main/java/us/centile/practice/util/TtlHashMap.java @@ -0,0 +1,107 @@ +package us.centile.practice.util; + +import java.util.concurrent.*; +import java.util.*; + +public class TtlHashMap implements Map +{ + private final HashMap store; + private final HashMap timestamps; + private final long ttl; + + public TtlHashMap(final TimeUnit ttlUnit, final long ttlValue) { + this.store = new HashMap(); + this.timestamps = new HashMap(); + this.ttl = ttlUnit.toNanos(ttlValue); + } + + @Override + public V get(final Object key) { + final V value = this.store.get(key); + if (value != null && this.expired(key, value)) { + this.store.remove(key); + this.timestamps.remove(key); + return null; + } + return value; + } + + private boolean expired(final Object key, final V value) { + return System.nanoTime() - this.timestamps.get(key) > this.ttl; + } + + @Override + public V put(final K key, final V value) { + this.timestamps.put(key, System.nanoTime()); + return this.store.put(key, value); + } + + @Override + public int size() { + return this.store.size(); + } + + @Override + public boolean isEmpty() { + return this.store.isEmpty(); + } + + @Override + public boolean containsKey(final Object key) { + final V value = this.store.get(key); + if (value != null && this.expired(key, value)) { + this.store.remove(key); + this.timestamps.remove(key); + return false; + } + return this.store.containsKey(key); + } + + @Override + public boolean containsValue(final Object value) { + return this.store.containsValue(value); + } + + @Override + public V remove(final Object key) { + this.timestamps.remove(key); + return this.store.remove(key); + } + + @Override + public void putAll(final Map m) { + for (final Entry e : m.entrySet()) { + this.put(e.getKey(), e.getValue()); + } + } + + @Override + public void clear() { + this.timestamps.clear(); + this.store.clear(); + } + + @Override + public Set keySet() { + this.clearExpired(); + return Collections.unmodifiableSet((Set)this.store.keySet()); + } + + @Override + public Collection values() { + this.clearExpired(); + return Collections.unmodifiableCollection((Collection)this.store.values()); + } + + @Override + public Set> entrySet() { + this.clearExpired(); + return Collections.unmodifiableSet((Set>)this.store.entrySet()); + } + + private void clearExpired() { + for (final K k : this.store.keySet()) { + this.get(k); + } + } +} diff --git a/src/main/java/us/centile/practice/util/UtilActionMessage.java b/src/main/java/us/centile/practice/util/UtilActionMessage.java new file mode 100644 index 0000000..feff7bf --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilActionMessage.java @@ -0,0 +1,116 @@ +package us.centile.practice.util; + +import org.bukkit.entity.*; +import org.bukkit.craftbukkit.v1_8_R3.entity.*; +import net.minecraft.server.v1_8_R3.*; +import java.util.*; +import org.bukkit.inventory.*; +import org.bukkit.craftbukkit.v1_8_R3.inventory.*; +import org.bukkit.inventory.ItemStack; + +public class UtilActionMessage +{ + private List Text; + + public UtilActionMessage() { + this.Text = new ArrayList(); + } + + public AMText addText(final String Message) { + final AMText Text = new AMText(Message); + this.Text.add(Text); + return Text; + } + + public String getFormattedMessage() { + String Chat = "[\"\","; + for (final AMText Text : this.Text) { + Chat = Chat + Text.getFormattedMessage() + ","; + } + Chat = Chat.substring(0, Chat.length() - 1); + Chat += "]"; + return Chat; + } + + public void sendToPlayer(final Player Player) { + final IChatBaseComponent base = IChatBaseComponent.ChatSerializer.a(this.getFormattedMessage()); + final PacketPlayOutChat packet = new PacketPlayOutChat(base, (byte)1); + ((CraftPlayer)Player).getHandle().playerConnection.sendPacket((Packet)packet); + } + + public enum ClickableType + { + RunCommand("run_command"), + SuggestCommand("suggest_command"), + OpenURL("open_url"); + + public String Action; + + private ClickableType(final String Action) { + this.Action = Action; + } + } + + public class AMText + { + private String Message; + private Map> Modifiers; + + public AMText(final String Text) { + this.Message = ""; + this.Modifiers = new HashMap>(); + this.Message = Text; + } + + public String getMessage() { + return this.Message; + } + + public String getFormattedMessage() { + String Chat = "{\"text\":\"" + this.Message + "\""; + for (final String Event : this.Modifiers.keySet()) { + final Map.Entry Modifier = this.Modifiers.get(Event); + Chat = Chat + ",\"" + Event + "\":{\"action\":\"" + Modifier.getKey() + "\",\"value\":" + Modifier.getValue() + "}"; + } + Chat += "}"; + return Chat; + } + + public AMText addHoverText(final String... Text) { + final String Event = "hoverEvent"; + final String Key = "show_text"; + String Value = ""; + if (Text.length == 1) { + Value = "{\"text\":\"" + Text[0] + "\"}"; + } + else { + Value = "{\"text\":\"\",\"extra\":["; + for (final String Message : Text) { + Value = Value + "{\"text\":\"" + Message + "\"},"; + } + Value = Value.substring(0, Value.length() - 1); + Value += "]}"; + } + final Map.Entry Values = new AbstractMap.SimpleEntry("show_text", Value); + this.Modifiers.put("hoverEvent", Values); + return this; + } + + public AMText addHoverItem(final ItemStack Item) { + final String Event = "hoverEvent"; + final String Key = "show_item"; + final String Value = CraftItemStack.asNMSCopy(Item).getTag().toString(); + final Map.Entry Values = new AbstractMap.SimpleEntry("show_item", Value); + this.Modifiers.put("hoverEvent", Values); + return this; + } + + public AMText setClickEvent(final ClickableType Type, final String Value) { + final String Event = "clickEvent"; + final String Key = Type.Action; + final Map.Entry Values = new AbstractMap.SimpleEntry(Key, "\"" + Value + "\""); + this.Modifiers.put("clickEvent", Values); + return this; + } + } +} diff --git a/src/main/java/us/centile/practice/util/UtilElo.java b/src/main/java/us/centile/practice/util/UtilElo.java new file mode 100644 index 0000000..e8735b8 --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilElo.java @@ -0,0 +1,35 @@ +package us.centile.practice.util; + +public class UtilElo +{ + private static double[] getEstimations(final double rankingA, final double rankingB) { + final double[] ret = new double[2]; + final double estA = 1.0 / (1.0 + Math.pow(10.0, (rankingB - rankingA) / 400.0)); + final double estB = 1.0 / (1.0 + Math.pow(10.0, (rankingA - rankingB) / 400.0)); + ret[0] = estA; + ret[1] = estB; + return ret; + } + + private static int getConstant(final int ranking) { + if (ranking < 1400) { + return 32; + } + if (ranking >= 1400 && ranking < 1800) { + return 24; + } + if (ranking >= 1800 && ranking < 2400) { + return 16; + } + return 0; + } + + public static int[] getNewRankings(final int rankingA, final int rankingB, final boolean victoryA) { + final int[] elo = new int[2]; + final double[] estimates = getEstimations(rankingA, rankingB); + final int newRankA = (int)(rankingA + getConstant(rankingA) * ((victoryA ? 1 : 0) - estimates[0])); + elo[0] = Math.round(newRankA); + elo[1] = Math.round(rankingB - (newRankA - rankingA)); + return elo; + } +} diff --git a/src/main/java/us/centile/practice/util/UtilItem.java b/src/main/java/us/centile/practice/util/UtilItem.java new file mode 100644 index 0000000..fef22b9 --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilItem.java @@ -0,0 +1,89 @@ +package us.centile.practice.util; + +import org.bukkit.*; +import org.bukkit.inventory.*; +import org.bukkit.enchantments.*; +import java.util.*; +import org.bukkit.inventory.meta.*; +import org.bukkit.potion.*; + +public class UtilItem +{ + public static ItemStack createItem(final Material m, final int amount) { + return new ItemStack(m, amount); + } + + public static ItemStack createItem(final Material m, final int amount, final short durability) { + return new ItemStack(m, amount, durability); + } + + public static ItemStack createItem(final Material m, final int amount, final short durability, final String name) { + ItemStack itemStack = new ItemStack(m, amount, durability); + if (name != null) { + itemStack = name(itemStack, name); + } + return itemStack; + } + + public static ItemStack createItem(final Material m, final int amount, final short durability, final String name, final Enchantment enchantment, final int level) { + ItemStack itemStack = new ItemStack(m, amount, durability); + if (name != null) { + itemStack = name(itemStack, name); + } + return enchantItem(itemStack, enchantment, level); + } + + public static ItemStack createItem(final Material m, final int amount, final short durability, final String name, final List lore) { + ItemStack itemStack = new ItemStack(m, amount, durability); + if (name != null) { + itemStack = name(itemStack, name); + } + if (lore != null) { + itemStack = lore(itemStack, lore); + } + return itemStack; + } + + public static ItemStack skull(final ItemStack itemStack, final String playerName) { + final SkullMeta meta = (SkullMeta)itemStack.getItemMeta(); + meta.setOwner(playerName); + itemStack.setItemMeta((ItemMeta)meta); + return itemStack; + } + + public static ItemStack name(final ItemStack itemStack, final String itemName) { + final ItemMeta itemMeta = itemStack.getItemMeta(); + itemMeta.setDisplayName(itemName); + itemStack.setItemMeta(itemMeta); + return itemStack; + } + + public static ItemStack lore(final ItemStack itemStack, final List lore) { + final ItemMeta itemMeta = itemStack.getItemMeta(); + itemMeta.setLore((List)lore); + itemStack.setItemMeta(itemMeta); + return itemStack; + } + + public static ItemStack enchantItem(final ItemStack itemStack, final Enchantment enchantment, final int level) { + itemStack.addUnsafeEnchantment(enchantment, level); + return itemStack; + } + + public static ItemStack effectItem(final ItemStack itemStack, final PotionEffectType potionEffectType, final int time, final int amplifier) { + final PotionMeta potionMeta = (PotionMeta)itemStack.getItemMeta(); + potionMeta.addCustomEffect(new PotionEffect(potionEffectType, time * 20, amplifier), true); + itemStack.setItemMeta((ItemMeta)potionMeta); + return itemStack; + } + + public static String getTitle(final ItemStack itemStack) { + if (itemStack.hasItemMeta()) { + final ItemMeta meta = itemStack.getItemMeta(); + if (meta.hasDisplayName()) { + return meta.getDisplayName(); + } + } + return ""; + } +} diff --git a/src/main/java/us/centile/practice/util/UtilMath.java b/src/main/java/us/centile/practice/util/UtilMath.java new file mode 100644 index 0000000..115da37 --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilMath.java @@ -0,0 +1,54 @@ +package us.centile.practice.util; + +import java.util.*; +import java.math.*; +import java.text.*; + +public class UtilMath +{ + private static Random random; + + public static Random getRandom() { + return UtilMath.random; + } + + public static double getFraction(final double value) { + return value % 1.0; + } + + public static double round(final double value, final int places) { + if (places < 0) { + throw new IllegalArgumentException(); + } + BigDecimal bd = new BigDecimal(value); + bd = bd.setScale(places, RoundingMode.HALF_UP); + return bd.doubleValue(); + } + + public static double trim(final int degree, final double d) { + String format = "#.#"; + for (int i = 1; i < degree; ++i) { + format += "#"; + } + final DecimalFormat twoDForm = new DecimalFormat(format); + return Double.valueOf(twoDForm.format(d)); + } + + public static String convertTicksToMinutes(final int ticks) { + final long minute = ticks / 1200; + final long second = ticks / 20 - minute * 60L; + String secondString = Math.round(second) + ""; + if (second < 10L) { + secondString = 0 + secondString; + } + String minuteString = Math.round(minute) + ""; + if (minute == 0L) { + minuteString = "0"; + } + return minuteString + ":" + secondString; + } + + static { + UtilMath.random = new Random(); + } +} diff --git a/src/main/java/us/centile/practice/util/UtilPlayer.java b/src/main/java/us/centile/practice/util/UtilPlayer.java new file mode 100644 index 0000000..8a185f0 --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilPlayer.java @@ -0,0 +1,54 @@ +package us.centile.practice.util; + +import org.bukkit.entity.*; +import org.bukkit.*; +import org.bukkit.inventory.*; +import java.util.*; +import org.bukkit.potion.*; +import com.google.common.base.*; + +public class UtilPlayer +{ + public static void clear(final Player player) { + for (final PotionEffect potion : player.getActivePotionEffects()) { + player.removePotionEffect(potion.getType()); + } + player.setGameMode(GameMode.SURVIVAL); + player.setAllowFlight(false); + player.setFlying(false); + player.setMaximumNoDamageTicks(20); + player.setFoodLevel(20); + player.setHealth(player.getMaxHealth()); + player.setFireTicks(0); + player.setFallDistance(0.0f); + player.getInventory().clear(); + player.getInventory().setArmorContents(null); + player.getInventory().setHeldItemSlot(4); + player.updateInventory(); + } + + public static PotionEffect getPotionEffect(final Player player, final PotionEffectType type) { + Preconditions.checkState(player.hasPotionEffect(type)); + for (final PotionEffect effect : player.getActivePotionEffects()) { + if (effect.getType().getId() == type.getId()) { + return effect; + } + } + throw new AssertionError(); + } + + public static void addConcideringLevel(final Player player, final PotionEffect effect) { + if (player.hasPotionEffect(effect.getType())) { + final PotionEffect before = getPotionEffect(player, effect.getType()); + if (before.getAmplifier() < effect.getAmplifier()) { + player.addPotionEffect(effect, true); + } + else if (before.getAmplifier() == effect.getAmplifier() && before.getDuration() < effect.getDuration()) { + player.addPotionEffect(effect, true); + } + } + else { + player.addPotionEffect(effect); + } + } +} diff --git a/src/main/java/us/centile/practice/util/UtilString.java b/src/main/java/us/centile/practice/util/UtilString.java new file mode 100644 index 0000000..bf40688 --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilString.java @@ -0,0 +1,46 @@ +package us.centile.practice.util; + +import us.centile.practice.*; +import java.util.*; + +public class UtilString +{ + public static String[] splitString(final String s) { + return s.split(nPractice.splitPattern.pattern()); + } + + public static String romanNumerals(int Int) { + final LinkedHashMap roman_numerals = new LinkedHashMap(); + roman_numerals.put("M", 1000); + roman_numerals.put("CM", 900); + roman_numerals.put("D", 500); + roman_numerals.put("CD", 400); + roman_numerals.put("C", 100); + roman_numerals.put("XC", 90); + roman_numerals.put("L", 50); + roman_numerals.put("XL", 40); + roman_numerals.put("X", 10); + roman_numerals.put("IX", 9); + roman_numerals.put("V", 5); + roman_numerals.put("IV", 4); + roman_numerals.put("I", 1); + String res = ""; + for (final Map.Entry entry : roman_numerals.entrySet()) { + final int matches = Int / entry.getValue(); + res += repeat(entry.getKey(), matches); + Int %= entry.getValue(); + } + return res; + } + + private static String repeat(final String s, final int n) { + if (s == null) { + return null; + } + final StringBuilder sb = new StringBuilder(); + for (int i = 0; i < n; ++i) { + sb.append(s); + } + return sb.toString(); + } +} diff --git a/src/main/java/us/centile/practice/util/UtilTime.java b/src/main/java/us/centile/practice/util/UtilTime.java new file mode 100644 index 0000000..bafbf4d --- /dev/null +++ b/src/main/java/us/centile/practice/util/UtilTime.java @@ -0,0 +1,192 @@ +package us.centile.practice.util; + +import java.text.*; +import java.util.*; + +public class UtilTime +{ + public static final String DATE_FORMAT_NOW = "yyyy-MM-dd HH:mm:ss"; + public static final String DATE_FORMAT_DAY = "yyyy-MM-dd"; + + public static String now() { + final Calendar cal = Calendar.getInstance(); + final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + return sdf.format(cal.getTime()); + } + + public static long nowlong() { + return System.currentTimeMillis(); + } + + public static String when(final long time) { + final SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy HH:mm:ss"); + return sdf.format(time); + } + + public static long a(final String a) { + if (a.endsWith("s")) { + return Long.valueOf(a.substring(0, a.length() - 1)) * 1000L; + } + if (a.endsWith("m")) { + return Long.valueOf(a.substring(0, a.length() - 1)) * 60000L; + } + if (a.endsWith("h")) { + return Long.valueOf(a.substring(0, a.length() - 1)) * 3600000L; + } + if (a.endsWith("d")) { + return Long.valueOf(a.substring(0, a.length() - 1)) * 86400000L; + } + if (a.endsWith("m")) { + return Long.valueOf(a.substring(0, a.length() - 1)) * 2592000000L; + } + if (a.endsWith("y")) { + return Long.valueOf(a.substring(0, a.length() - 1)) * 31104000000L; + } + return -1L; + } + + public static String date() { + final Calendar cal = Calendar.getInstance(); + final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); + return sdf.format(cal.getTime()); + } + + public static String getTime(final int time) { + final Date timeDiff = new Date(); + timeDiff.setTime(time * 1000); + final SimpleDateFormat timeFormat = new SimpleDateFormat("mm:ss"); + final String eventTimeDisplay = timeFormat.format(timeDiff); + return eventTimeDisplay; + } + + public static String since(final long epoch) { + return "Took " + convertString(System.currentTimeMillis() - epoch, 1, TimeUnit.FIT) + "."; + } + + public static double convert(final long time, final int trim, TimeUnit type) { + if (type == TimeUnit.FIT) { + if (time < 60000L) { + type = TimeUnit.SECONDS; + } + else if (time < 3600000L) { + type = TimeUnit.MINUTES; + } + else if (time < 86400000L) { + type = TimeUnit.HOURS; + } + else { + type = TimeUnit.DAYS; + } + } + if (type == TimeUnit.DAYS) { + return UtilMath.trim(trim, time / 8.64E7); + } + if (type == TimeUnit.HOURS) { + return UtilMath.trim(trim, time / 3600000.0); + } + if (type == TimeUnit.MINUTES) { + return UtilMath.trim(trim, time / 60000.0); + } + if (type == TimeUnit.SECONDS) { + return UtilMath.trim(trim, time / 1000.0); + } + return UtilMath.trim(trim, time); + } + + public static String convertTime(long time) { + if (time < 0L) { + return null; + } + final long week = 0L; + long day = 0L; + long hour = 0L; + long minute = 0L; + long second = 0L; + day = time / 86400L; + time -= day * 86400L; + hour = time / 3600L; + time -= hour * 3600L; + minute = time / 60L; + second = (time -= minute * 60L); + String build = ""; + if (day > 0L) { + build = build + day + " day" + ((day == 1L) ? " " : "s "); + } + if (hour > 0L) { + build = build + hour + " hour" + ((hour == 1L) ? " " : "s "); + } + if (minute > 0L) { + build = build + minute + " minute" + ((minute == 1L) ? " " : "s "); + } + if (second > 0L) { + build = build + second + " second" + ((second == 1L) ? " " : "s "); + } + if (build.length() == 0) { + build = "0 seconds"; + } + return build.trim(); + } + + public static String MakeStr(final long time) { + return convertString(time, 1, TimeUnit.FIT); + } + + public static String MakeStr(final long time, final int trim) { + return convertString(time, trim, TimeUnit.FIT); + } + + public static String convertString(final long time, final int trim, TimeUnit type) { + if (time == -1L) { + return "Permanent"; + } + if (type == TimeUnit.FIT) { + if (time < 60000L) { + type = TimeUnit.SECONDS; + } + else if (time < 3600000L) { + type = TimeUnit.MINUTES; + } + else if (time < 86400000L) { + type = TimeUnit.HOURS; + } + else { + type = TimeUnit.DAYS; + } + } + if (type == TimeUnit.DAYS) { + return UtilMath.trim(trim, time / 8.64E7) + " Days"; + } + if (type == TimeUnit.HOURS) { + return UtilMath.trim(trim, time / 3600000.0) + " Hours"; + } + if (type == TimeUnit.MINUTES) { + return UtilMath.trim(trim, time / 60000.0) + " Minutes"; + } + if (type == TimeUnit.SECONDS) { + return UtilMath.trim(trim, time / 1000.0) + " Seconds"; + } + return UtilMath.trim(trim, time) + " Milliseconds"; + } + + public static boolean elapsed(final long from, final long required) { + return System.currentTimeMillis() - from > required; + } + + public static long elapsed(final long starttime) { + return System.currentTimeMillis() - starttime; + } + + public static long left(final long start, final long required) { + return required + start - System.currentTimeMillis(); + } + + public enum TimeUnit + { + FIT, + DAYS, + HOURS, + MINUTES, + SECONDS, + MILLISECONDS; + } +} diff --git a/src/main/java/us/centile/practice/util/database/PracticeDatabase.java b/src/main/java/us/centile/practice/util/database/PracticeDatabase.java new file mode 100644 index 0000000..6e314a9 --- /dev/null +++ b/src/main/java/us/centile/practice/util/database/PracticeDatabase.java @@ -0,0 +1,43 @@ +package us.centile.practice.util.database; + +import com.mongodb.MongoClient; +import com.mongodb.client.*; +import us.centile.practice.*; +import com.mongodb.*; +import java.util.*; + +public class PracticeDatabase +{ + private final MongoClient client; + private final MongoDatabase database; + private final MongoCollection profiles; + private final MongoCollection kits; + + public PracticeDatabase(final nPractice main) { + if (main.getConfig().getBoolean("DATABASE.MONGO.AUTHENTICATION.ENABLED")) { + this.client = new MongoClient(new ServerAddress(main.getConfig().getString("DATABASE.MONGO.HOST"), main.getConfig().getInt("DATABASE.MONGO.PORT")), (List)Arrays.asList(MongoCredential.createCredential(main.getConfig().getString("DATABASE.MONGO.AUTHENTICATION.USER"), main.getConfig().getString("DATABASE.MONGO.AUTHENTICATION.DATABASE"), main.getConfig().getString("DATABASE.MONGO.AUTHENTICATION.PASSWORD").toCharArray()))); + } + else { + this.client = new MongoClient(new ServerAddress(main.getConfig().getString("DATABASE.MONGO.HOST"), main.getConfig().getInt("DATABASE.MONGO.PORT"))); + } + this.database = this.client.getDatabase("practice"); + this.profiles = this.database.getCollection("profiles"); + this.kits = this.database.getCollection("kits"); + } + + public MongoClient getClient() { + return this.client; + } + + public MongoDatabase getDatabase() { + return this.database; + } + + public MongoCollection getProfiles() { + return this.profiles; + } + + public MongoCollection getKits() { + return this.kits; + } +} diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..618af0e --- /dev/null +++ b/src/main/resources/config.yml @@ -0,0 +1,16 @@ +DATABASE: + MONGO: + HOST: "127.0.0.1" + PORT: 27017 + AUTHENTICATION: + ENABLED: FALSE + DATABASE: "practice" + USER: "user" + PASSWORD: "password" + +COLORS: + MAIN_COLOR: DARK_GREEN + SIDE_COLOR: GREEN + EXTRA_COLOR: GRAY +SCOREBOARD_TITLE: "&c&lVexus &7❘ &7Practice" +TAB_TITLE: " &6&lPractice" diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..bf43698 --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,82 @@ +name: "kPractice" +version: "0.1" +author: "Emilio" +main: "us.centile.practice.nPractice" +depend: [ProtocolLib] + +commands: + setting: + aliases: [settings, option , options] + premiumtop: + description: 'premiumtop command' + usage: '/premiumtop' + ping: + description: 'Ping command' + usage: '/ping' + matches: + description: 'Matches command' + usage: '/matches' + tokens: + description: 'Tokens command' + usage: '/tokens' + host: + description: 'Host Events command' + usage: '/host' + setspawn: + description: 'Set Spawn command' + usage: '/setspawn' + leave: + description: 'Leave command' + usage: '/leave' + join: + description: 'Join command' + usage: '/join' + tournament: + description: 'Tournament command' + aliases: [tourney, tour] + usage: '/tournament' + scoreboard: + description: 'Scoreboard command' + aliases: [sb, settings] + usage: '/scoreboard' + reset: + description: 'Reset command' + aliases: [resetelo, eloreset] + usage: '/reset' + credits: + description: 'Credits command' + aliases: [credit] + usage: '/credits' + arena: + description: 'Arena command' + usage: '/arena' + duel: + description: 'Send a duel' + usage: '/duel [player]' + accept: + description: 'Accept a player duel' + usage: '/accept [player]' + kit: + description: 'Kit command' + usage: '/kit' + spectate: + description: 'Spectate a player' + usage: '/spectate ' + aliases: [spec] + builder: + description: 'Puts you into builder mode' + usage: '/builder' + party: + description: 'Party command' + usage: '/party' + inventory: {} +permissions: + practice.commands.arena: + description: Gives access to the arena command + default: op + practice.commands.kit: + description: Gives access to the kit command + default: op + practice.commands.builder: + description: Gives access to the builder command + default: op \ No newline at end of file diff --git a/src/main/resources/schedule.yml b/src/main/resources/schedule.yml new file mode 100644 index 0000000..955e7f9 --- /dev/null +++ b/src/main/resources/schedule.yml @@ -0,0 +1,8 @@ +schedule-timezone: "America/New_York" +schedule-monday: "12:00AM" +schedule-tuesday: "12:00AM" +schedule-wednesday: "12:00AM" +schedule-thursday: "12:00AM" +schedule-friday: "12:00AM" +schedule-saturday: "12:00AM" +schedule-sunday: "12:00AM" diff --git a/target/classes/config.yml b/target/classes/config.yml new file mode 100644 index 0000000..618af0e --- /dev/null +++ b/target/classes/config.yml @@ -0,0 +1,16 @@ +DATABASE: + MONGO: + HOST: "127.0.0.1" + PORT: 27017 + AUTHENTICATION: + ENABLED: FALSE + DATABASE: "practice" + USER: "user" + PASSWORD: "password" + +COLORS: + MAIN_COLOR: DARK_GREEN + SIDE_COLOR: GREEN + EXTRA_COLOR: GRAY +SCOREBOARD_TITLE: "&c&lVexus &7❘ &7Practice" +TAB_TITLE: " &6&lPractice" diff --git a/target/classes/plugin.yml b/target/classes/plugin.yml new file mode 100644 index 0000000..bf43698 --- /dev/null +++ b/target/classes/plugin.yml @@ -0,0 +1,82 @@ +name: "kPractice" +version: "0.1" +author: "Emilio" +main: "us.centile.practice.nPractice" +depend: [ProtocolLib] + +commands: + setting: + aliases: [settings, option , options] + premiumtop: + description: 'premiumtop command' + usage: '/premiumtop' + ping: + description: 'Ping command' + usage: '/ping' + matches: + description: 'Matches command' + usage: '/matches' + tokens: + description: 'Tokens command' + usage: '/tokens' + host: + description: 'Host Events command' + usage: '/host' + setspawn: + description: 'Set Spawn command' + usage: '/setspawn' + leave: + description: 'Leave command' + usage: '/leave' + join: + description: 'Join command' + usage: '/join' + tournament: + description: 'Tournament command' + aliases: [tourney, tour] + usage: '/tournament' + scoreboard: + description: 'Scoreboard command' + aliases: [sb, settings] + usage: '/scoreboard' + reset: + description: 'Reset command' + aliases: [resetelo, eloreset] + usage: '/reset' + credits: + description: 'Credits command' + aliases: [credit] + usage: '/credits' + arena: + description: 'Arena command' + usage: '/arena' + duel: + description: 'Send a duel' + usage: '/duel [player]' + accept: + description: 'Accept a player duel' + usage: '/accept [player]' + kit: + description: 'Kit command' + usage: '/kit' + spectate: + description: 'Spectate a player' + usage: '/spectate ' + aliases: [spec] + builder: + description: 'Puts you into builder mode' + usage: '/builder' + party: + description: 'Party command' + usage: '/party' + inventory: {} +permissions: + practice.commands.arena: + description: Gives access to the arena command + default: op + practice.commands.kit: + description: Gives access to the kit command + default: op + practice.commands.builder: + description: Gives access to the builder command + default: op \ No newline at end of file diff --git a/target/classes/schedule.yml b/target/classes/schedule.yml new file mode 100644 index 0000000..955e7f9 --- /dev/null +++ b/target/classes/schedule.yml @@ -0,0 +1,8 @@ +schedule-timezone: "America/New_York" +schedule-monday: "12:00AM" +schedule-tuesday: "12:00AM" +schedule-wednesday: "12:00AM" +schedule-thursday: "12:00AM" +schedule-friday: "12:00AM" +schedule-saturday: "12:00AM" +schedule-sunday: "12:00AM" diff --git a/target/classes/us/centile/practice/arena/Arena.class b/target/classes/us/centile/practice/arena/Arena.class new file mode 100644 index 0000000..68c1ec3 Binary files /dev/null and b/target/classes/us/centile/practice/arena/Arena.class differ diff --git a/target/classes/us/centile/practice/arena/BlockChangeTracker.class b/target/classes/us/centile/practice/arena/BlockChangeTracker.class new file mode 100644 index 0000000..54b64d0 Binary files /dev/null and b/target/classes/us/centile/practice/arena/BlockChangeTracker.class differ diff --git a/target/classes/us/centile/practice/commands/AcceptCommand.class b/target/classes/us/centile/practice/commands/AcceptCommand.class new file mode 100644 index 0000000..95f116f Binary files /dev/null and b/target/classes/us/centile/practice/commands/AcceptCommand.class differ diff --git a/target/classes/us/centile/practice/commands/ArenaCommand.class b/target/classes/us/centile/practice/commands/ArenaCommand.class new file mode 100644 index 0000000..f1901c0 Binary files /dev/null and b/target/classes/us/centile/practice/commands/ArenaCommand.class differ diff --git a/target/classes/us/centile/practice/commands/BuilderCommand.class b/target/classes/us/centile/practice/commands/BuilderCommand.class new file mode 100644 index 0000000..25ab9bc Binary files /dev/null and b/target/classes/us/centile/practice/commands/BuilderCommand.class differ diff --git a/target/classes/us/centile/practice/commands/CreditsCommand$1.class b/target/classes/us/centile/practice/commands/CreditsCommand$1.class new file mode 100644 index 0000000..9bc8975 Binary files /dev/null and b/target/classes/us/centile/practice/commands/CreditsCommand$1.class differ diff --git a/target/classes/us/centile/practice/commands/CreditsCommand.class b/target/classes/us/centile/practice/commands/CreditsCommand.class new file mode 100644 index 0000000..b3012b2 Binary files /dev/null and b/target/classes/us/centile/practice/commands/CreditsCommand.class differ diff --git a/target/classes/us/centile/practice/commands/DuelCommand.class b/target/classes/us/centile/practice/commands/DuelCommand.class new file mode 100644 index 0000000..bbf061a Binary files /dev/null and b/target/classes/us/centile/practice/commands/DuelCommand.class differ diff --git a/target/classes/us/centile/practice/commands/HostCommand.class b/target/classes/us/centile/practice/commands/HostCommand.class new file mode 100644 index 0000000..1900915 Binary files /dev/null and b/target/classes/us/centile/practice/commands/HostCommand.class differ diff --git a/target/classes/us/centile/practice/commands/InventoryCommand.class b/target/classes/us/centile/practice/commands/InventoryCommand.class new file mode 100644 index 0000000..aaba36b Binary files /dev/null and b/target/classes/us/centile/practice/commands/InventoryCommand.class differ diff --git a/target/classes/us/centile/practice/commands/JoinCommand.class b/target/classes/us/centile/practice/commands/JoinCommand.class new file mode 100644 index 0000000..f7f44b5 Binary files /dev/null and b/target/classes/us/centile/practice/commands/JoinCommand.class differ diff --git a/target/classes/us/centile/practice/commands/KitCommand.class b/target/classes/us/centile/practice/commands/KitCommand.class new file mode 100644 index 0000000..9c1ff00 Binary files /dev/null and b/target/classes/us/centile/practice/commands/KitCommand.class differ diff --git a/target/classes/us/centile/practice/commands/LeaveCommand.class b/target/classes/us/centile/practice/commands/LeaveCommand.class new file mode 100644 index 0000000..3372f08 Binary files /dev/null and b/target/classes/us/centile/practice/commands/LeaveCommand.class differ diff --git a/target/classes/us/centile/practice/commands/MatchesCommand$1.class b/target/classes/us/centile/practice/commands/MatchesCommand$1.class new file mode 100644 index 0000000..7dbf90d Binary files /dev/null and b/target/classes/us/centile/practice/commands/MatchesCommand$1.class differ diff --git a/target/classes/us/centile/practice/commands/MatchesCommand.class b/target/classes/us/centile/practice/commands/MatchesCommand.class new file mode 100644 index 0000000..4d0f7e7 Binary files /dev/null and b/target/classes/us/centile/practice/commands/MatchesCommand.class differ diff --git a/target/classes/us/centile/practice/commands/PartyCommand.class b/target/classes/us/centile/practice/commands/PartyCommand.class new file mode 100644 index 0000000..ecf78ee Binary files /dev/null and b/target/classes/us/centile/practice/commands/PartyCommand.class differ diff --git a/target/classes/us/centile/practice/commands/PingCommand.class b/target/classes/us/centile/practice/commands/PingCommand.class new file mode 100644 index 0000000..bdcec1a Binary files /dev/null and b/target/classes/us/centile/practice/commands/PingCommand.class differ diff --git a/target/classes/us/centile/practice/commands/PremiumTokensCommand$1.class b/target/classes/us/centile/practice/commands/PremiumTokensCommand$1.class new file mode 100644 index 0000000..a116de3 Binary files /dev/null and b/target/classes/us/centile/practice/commands/PremiumTokensCommand$1.class differ diff --git a/target/classes/us/centile/practice/commands/PremiumTokensCommand.class b/target/classes/us/centile/practice/commands/PremiumTokensCommand.class new file mode 100644 index 0000000..5514d08 Binary files /dev/null and b/target/classes/us/centile/practice/commands/PremiumTokensCommand.class differ diff --git a/target/classes/us/centile/practice/commands/ResetEloCommand.class b/target/classes/us/centile/practice/commands/ResetEloCommand.class new file mode 100644 index 0000000..e9a3be4 Binary files /dev/null and b/target/classes/us/centile/practice/commands/ResetEloCommand.class differ diff --git a/target/classes/us/centile/practice/commands/ScoreboardCommand.class b/target/classes/us/centile/practice/commands/ScoreboardCommand.class new file mode 100644 index 0000000..175449c Binary files /dev/null and b/target/classes/us/centile/practice/commands/ScoreboardCommand.class differ diff --git a/target/classes/us/centile/practice/commands/SetSpawnCommand.class b/target/classes/us/centile/practice/commands/SetSpawnCommand.class new file mode 100644 index 0000000..fec335c Binary files /dev/null and b/target/classes/us/centile/practice/commands/SetSpawnCommand.class differ diff --git a/target/classes/us/centile/practice/commands/SortPremiumEloCommand$1.class b/target/classes/us/centile/practice/commands/SortPremiumEloCommand$1.class new file mode 100644 index 0000000..0dcd994 Binary files /dev/null and b/target/classes/us/centile/practice/commands/SortPremiumEloCommand$1.class differ diff --git a/target/classes/us/centile/practice/commands/SortPremiumEloCommand.class b/target/classes/us/centile/practice/commands/SortPremiumEloCommand.class new file mode 100644 index 0000000..a4a50b9 Binary files /dev/null and b/target/classes/us/centile/practice/commands/SortPremiumEloCommand.class differ diff --git a/target/classes/us/centile/practice/commands/SpectateCommand.class b/target/classes/us/centile/practice/commands/SpectateCommand.class new file mode 100644 index 0000000..65f0f39 Binary files /dev/null and b/target/classes/us/centile/practice/commands/SpectateCommand.class differ diff --git a/target/classes/us/centile/practice/commands/TournamentCommand.class b/target/classes/us/centile/practice/commands/TournamentCommand.class new file mode 100644 index 0000000..97b5e76 Binary files /dev/null and b/target/classes/us/centile/practice/commands/TournamentCommand.class differ diff --git a/target/classes/us/centile/practice/duel/Duel.class b/target/classes/us/centile/practice/duel/Duel.class new file mode 100644 index 0000000..a0b3858 Binary files /dev/null and b/target/classes/us/centile/practice/duel/Duel.class differ diff --git a/target/classes/us/centile/practice/duel/DuelRequest.class b/target/classes/us/centile/practice/duel/DuelRequest.class new file mode 100644 index 0000000..0c7d16e Binary files /dev/null and b/target/classes/us/centile/practice/duel/DuelRequest.class differ diff --git a/target/classes/us/centile/practice/duel/DuelState.class b/target/classes/us/centile/practice/duel/DuelState.class new file mode 100644 index 0000000..b83ab94 Binary files /dev/null and b/target/classes/us/centile/practice/duel/DuelState.class differ diff --git a/target/classes/us/centile/practice/events/DuelCreateEvent.class b/target/classes/us/centile/practice/events/DuelCreateEvent.class new file mode 100644 index 0000000..2a5dc89 Binary files /dev/null and b/target/classes/us/centile/practice/events/DuelCreateEvent.class differ diff --git a/target/classes/us/centile/practice/events/DuelEndEvent.class b/target/classes/us/centile/practice/events/DuelEndEvent.class new file mode 100644 index 0000000..3570f35 Binary files /dev/null and b/target/classes/us/centile/practice/events/DuelEndEvent.class differ diff --git a/target/classes/us/centile/practice/events/DuelEndingEvent.class b/target/classes/us/centile/practice/events/DuelEndingEvent.class new file mode 100644 index 0000000..1c86fea Binary files /dev/null and b/target/classes/us/centile/practice/events/DuelEndingEvent.class differ diff --git a/target/classes/us/centile/practice/events/DuelPreCreateEvent.class b/target/classes/us/centile/practice/events/DuelPreCreateEvent.class new file mode 100644 index 0000000..1e6427e Binary files /dev/null and b/target/classes/us/centile/practice/events/DuelPreCreateEvent.class differ diff --git a/target/classes/us/centile/practice/kit/Kit.class b/target/classes/us/centile/practice/kit/Kit.class new file mode 100644 index 0000000..f024271 Binary files /dev/null and b/target/classes/us/centile/practice/kit/Kit.class differ diff --git a/target/classes/us/centile/practice/listeners/BlockListener.class b/target/classes/us/centile/practice/listeners/BlockListener.class new file mode 100644 index 0000000..0eaba21 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/BlockListener.class differ diff --git a/target/classes/us/centile/practice/listeners/DuelListener$1.class b/target/classes/us/centile/practice/listeners/DuelListener$1.class new file mode 100644 index 0000000..a52cca9 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/DuelListener$1.class differ diff --git a/target/classes/us/centile/practice/listeners/DuelListener.class b/target/classes/us/centile/practice/listeners/DuelListener.class new file mode 100644 index 0000000..39905fc Binary files /dev/null and b/target/classes/us/centile/practice/listeners/DuelListener.class differ diff --git a/target/classes/us/centile/practice/listeners/EntityListener.class b/target/classes/us/centile/practice/listeners/EntityListener.class new file mode 100644 index 0000000..0e82563 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/EntityListener.class differ diff --git a/target/classes/us/centile/practice/listeners/HitDetectionListener.class b/target/classes/us/centile/practice/listeners/HitDetectionListener.class new file mode 100644 index 0000000..44e211c Binary files /dev/null and b/target/classes/us/centile/practice/listeners/HitDetectionListener.class differ diff --git a/target/classes/us/centile/practice/listeners/InventoryListener$1.class b/target/classes/us/centile/practice/listeners/InventoryListener$1.class new file mode 100644 index 0000000..0992f89 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/InventoryListener$1.class differ diff --git a/target/classes/us/centile/practice/listeners/InventoryListener.class b/target/classes/us/centile/practice/listeners/InventoryListener.class new file mode 100644 index 0000000..bad8191 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/InventoryListener.class differ diff --git a/target/classes/us/centile/practice/listeners/PlayerListener$1.class b/target/classes/us/centile/practice/listeners/PlayerListener$1.class new file mode 100644 index 0000000..a096d70 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/PlayerListener$1.class differ diff --git a/target/classes/us/centile/practice/listeners/PlayerListener$2.class b/target/classes/us/centile/practice/listeners/PlayerListener$2.class new file mode 100644 index 0000000..34e81a4 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/PlayerListener$2.class differ diff --git a/target/classes/us/centile/practice/listeners/PlayerListener$3.class b/target/classes/us/centile/practice/listeners/PlayerListener$3.class new file mode 100644 index 0000000..5281f5e Binary files /dev/null and b/target/classes/us/centile/practice/listeners/PlayerListener$3.class differ diff --git a/target/classes/us/centile/practice/listeners/PlayerListener$4.class b/target/classes/us/centile/practice/listeners/PlayerListener$4.class new file mode 100644 index 0000000..7fd48b4 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/PlayerListener$4.class differ diff --git a/target/classes/us/centile/practice/listeners/PlayerListener.class b/target/classes/us/centile/practice/listeners/PlayerListener.class new file mode 100644 index 0000000..e855a91 Binary files /dev/null and b/target/classes/us/centile/practice/listeners/PlayerListener.class differ diff --git a/target/classes/us/centile/practice/manager/Manager.class b/target/classes/us/centile/practice/manager/Manager.class new file mode 100644 index 0000000..4c2804c Binary files /dev/null and b/target/classes/us/centile/practice/manager/Manager.class differ diff --git a/target/classes/us/centile/practice/manager/ManagerHandler.class b/target/classes/us/centile/practice/manager/ManagerHandler.class new file mode 100644 index 0000000..adc0904 Binary files /dev/null and b/target/classes/us/centile/practice/manager/ManagerHandler.class differ diff --git a/target/classes/us/centile/practice/manager/managers/ArenaManager.class b/target/classes/us/centile/practice/manager/managers/ArenaManager.class new file mode 100644 index 0000000..b84b335 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/ArenaManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/DuelManager.class b/target/classes/us/centile/practice/manager/managers/DuelManager.class new file mode 100644 index 0000000..d025d77 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/DuelManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/EditorManager.class b/target/classes/us/centile/practice/manager/managers/EditorManager.class new file mode 100644 index 0000000..66bf3f5 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/EditorManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/InventoryManager.class b/target/classes/us/centile/practice/manager/managers/InventoryManager.class new file mode 100644 index 0000000..d0eba41 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/InventoryManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/InventorySnapshotManager.class b/target/classes/us/centile/practice/manager/managers/InventorySnapshotManager.class new file mode 100644 index 0000000..7c91864 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/InventorySnapshotManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/ItemManager.class b/target/classes/us/centile/practice/manager/managers/ItemManager.class new file mode 100644 index 0000000..823c942 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/ItemManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/KitManager.class b/target/classes/us/centile/practice/manager/managers/KitManager.class new file mode 100644 index 0000000..ad56edc Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/KitManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/PartyManager.class b/target/classes/us/centile/practice/manager/managers/PartyManager.class new file mode 100644 index 0000000..b63647e Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/PartyManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/PracticePlayerManager$1.class b/target/classes/us/centile/practice/manager/managers/PracticePlayerManager$1.class new file mode 100644 index 0000000..c0112fa Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/PracticePlayerManager$1.class differ diff --git a/target/classes/us/centile/practice/manager/managers/PracticePlayerManager.class b/target/classes/us/centile/practice/manager/managers/PracticePlayerManager.class new file mode 100644 index 0000000..a1bfe4d Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/PracticePlayerManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/QueueManager.class b/target/classes/us/centile/practice/manager/managers/QueueManager.class new file mode 100644 index 0000000..f703134 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/QueueManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/RequestManager.class b/target/classes/us/centile/practice/manager/managers/RequestManager.class new file mode 100644 index 0000000..6611021 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/RequestManager.class differ diff --git a/target/classes/us/centile/practice/manager/managers/SpectatorManager.class b/target/classes/us/centile/practice/manager/managers/SpectatorManager.class new file mode 100644 index 0000000..53846a7 Binary files /dev/null and b/target/classes/us/centile/practice/manager/managers/SpectatorManager.class differ diff --git a/target/classes/us/centile/practice/nPractice.class b/target/classes/us/centile/practice/nPractice.class new file mode 100644 index 0000000..8fa80d9 Binary files /dev/null and b/target/classes/us/centile/practice/nPractice.class differ diff --git a/target/classes/us/centile/practice/party/Party.class b/target/classes/us/centile/practice/party/Party.class new file mode 100644 index 0000000..dce6a1f Binary files /dev/null and b/target/classes/us/centile/practice/party/Party.class differ diff --git a/target/classes/us/centile/practice/party/PartyState.class b/target/classes/us/centile/practice/party/PartyState.class new file mode 100644 index 0000000..09eb20a Binary files /dev/null and b/target/classes/us/centile/practice/party/PartyState.class differ diff --git a/target/classes/us/centile/practice/player/Match.class b/target/classes/us/centile/practice/player/Match.class new file mode 100644 index 0000000..bdd5399 Binary files /dev/null and b/target/classes/us/centile/practice/player/Match.class differ diff --git a/target/classes/us/centile/practice/player/PlayerInventorySnapshot.class b/target/classes/us/centile/practice/player/PlayerInventorySnapshot.class new file mode 100644 index 0000000..11a5088 Binary files /dev/null and b/target/classes/us/centile/practice/player/PlayerInventorySnapshot.class differ diff --git a/target/classes/us/centile/practice/player/PlayerKit.class b/target/classes/us/centile/practice/player/PlayerKit.class new file mode 100644 index 0000000..6cce638 Binary files /dev/null and b/target/classes/us/centile/practice/player/PlayerKit.class differ diff --git a/target/classes/us/centile/practice/player/PlayerState.class b/target/classes/us/centile/practice/player/PlayerState.class new file mode 100644 index 0000000..00faa2f Binary files /dev/null and b/target/classes/us/centile/practice/player/PlayerState.class differ diff --git a/target/classes/us/centile/practice/player/PracticePlayer.class b/target/classes/us/centile/practice/player/PracticePlayer.class new file mode 100644 index 0000000..4d4093a Binary files /dev/null and b/target/classes/us/centile/practice/player/PracticePlayer.class differ diff --git a/target/classes/us/centile/practice/runnables/LoadPlayerTask.class b/target/classes/us/centile/practice/runnables/LoadPlayerTask.class new file mode 100644 index 0000000..d07bc99 Binary files /dev/null and b/target/classes/us/centile/practice/runnables/LoadPlayerTask.class differ diff --git a/target/classes/us/centile/practice/runnables/RemovePlayerTask.class b/target/classes/us/centile/practice/runnables/RemovePlayerTask.class new file mode 100644 index 0000000..7e77e46 Binary files /dev/null and b/target/classes/us/centile/practice/runnables/RemovePlayerTask.class differ diff --git a/target/classes/us/centile/practice/runnables/SavePlayerConfig.class b/target/classes/us/centile/practice/runnables/SavePlayerConfig.class new file mode 100644 index 0000000..c4c5148 Binary files /dev/null and b/target/classes/us/centile/practice/runnables/SavePlayerConfig.class differ diff --git a/target/classes/us/centile/practice/runnables/other/InsertMatchTask.class b/target/classes/us/centile/practice/runnables/other/InsertMatchTask.class new file mode 100644 index 0000000..bd7fc9a Binary files /dev/null and b/target/classes/us/centile/practice/runnables/other/InsertMatchTask.class differ diff --git a/target/classes/us/centile/practice/runnables/other/UpdateInventoryTask$InventoryTaskType.class b/target/classes/us/centile/practice/runnables/other/UpdateInventoryTask$InventoryTaskType.class new file mode 100644 index 0000000..56de5b3 Binary files /dev/null and b/target/classes/us/centile/practice/runnables/other/UpdateInventoryTask$InventoryTaskType.class differ diff --git a/target/classes/us/centile/practice/runnables/other/UpdateInventoryTask.class b/target/classes/us/centile/practice/runnables/other/UpdateInventoryTask.class new file mode 100644 index 0000000..4745e25 Binary files /dev/null and b/target/classes/us/centile/practice/runnables/other/UpdateInventoryTask.class differ diff --git a/target/classes/us/centile/practice/schedule/Schedule.class b/target/classes/us/centile/practice/schedule/Schedule.class new file mode 100644 index 0000000..cbb8657 Binary files /dev/null and b/target/classes/us/centile/practice/schedule/Schedule.class differ diff --git a/target/classes/us/centile/practice/schedule/ScheduleHandler.class b/target/classes/us/centile/practice/schedule/ScheduleHandler.class new file mode 100644 index 0000000..4c50779 Binary files /dev/null and b/target/classes/us/centile/practice/schedule/ScheduleHandler.class differ diff --git a/target/classes/us/centile/practice/schedule/ScheduleTimer.class b/target/classes/us/centile/practice/schedule/ScheduleTimer.class new file mode 100644 index 0000000..1e45e80 Binary files /dev/null and b/target/classes/us/centile/practice/schedule/ScheduleTimer.class differ diff --git a/target/classes/us/centile/practice/scoreboard/BufferedObjective$1.class b/target/classes/us/centile/practice/scoreboard/BufferedObjective$1.class new file mode 100644 index 0000000..60ec3f4 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/BufferedObjective$1.class differ diff --git a/target/classes/us/centile/practice/scoreboard/BufferedObjective.class b/target/classes/us/centile/practice/scoreboard/BufferedObjective.class new file mode 100644 index 0000000..ad74a65 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/BufferedObjective.class differ diff --git a/target/classes/us/centile/practice/scoreboard/PlayerBoard$1.class b/target/classes/us/centile/practice/scoreboard/PlayerBoard$1.class new file mode 100644 index 0000000..44f1249 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/PlayerBoard$1.class differ diff --git a/target/classes/us/centile/practice/scoreboard/PlayerBoard$2.class b/target/classes/us/centile/practice/scoreboard/PlayerBoard$2.class new file mode 100644 index 0000000..5047a85 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/PlayerBoard$2.class differ diff --git a/target/classes/us/centile/practice/scoreboard/PlayerBoard.class b/target/classes/us/centile/practice/scoreboard/PlayerBoard.class new file mode 100644 index 0000000..5863d59 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/PlayerBoard.class differ diff --git a/target/classes/us/centile/practice/scoreboard/ScoreboardHandler.class b/target/classes/us/centile/practice/scoreboard/ScoreboardHandler.class new file mode 100644 index 0000000..ccae86c Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/ScoreboardHandler.class differ diff --git a/target/classes/us/centile/practice/scoreboard/SidebarEntry.class b/target/classes/us/centile/practice/scoreboard/SidebarEntry.class new file mode 100644 index 0000000..002b109 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/SidebarEntry.class differ diff --git a/target/classes/us/centile/practice/scoreboard/SidebarProvider.class b/target/classes/us/centile/practice/scoreboard/SidebarProvider.class new file mode 100644 index 0000000..17fa886 Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/SidebarProvider.class differ diff --git a/target/classes/us/centile/practice/scoreboard/provider/DuelScoreboardProvider.class b/target/classes/us/centile/practice/scoreboard/provider/DuelScoreboardProvider.class new file mode 100644 index 0000000..b5306aa Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/provider/DuelScoreboardProvider.class differ diff --git a/target/classes/us/centile/practice/scoreboard/provider/LobbyScoreboardProvider.class b/target/classes/us/centile/practice/scoreboard/provider/LobbyScoreboardProvider.class new file mode 100644 index 0000000..b55c6ad Binary files /dev/null and b/target/classes/us/centile/practice/scoreboard/provider/LobbyScoreboardProvider.class differ diff --git a/target/classes/us/centile/practice/settings/Settings.class b/target/classes/us/centile/practice/settings/Settings.class new file mode 100644 index 0000000..7a98f7a Binary files /dev/null and b/target/classes/us/centile/practice/settings/Settings.class differ diff --git a/target/classes/us/centile/practice/settings/SettingsHandler$1.class b/target/classes/us/centile/practice/settings/SettingsHandler$1.class new file mode 100644 index 0000000..40064ab Binary files /dev/null and b/target/classes/us/centile/practice/settings/SettingsHandler$1.class differ diff --git a/target/classes/us/centile/practice/settings/SettingsHandler.class b/target/classes/us/centile/practice/settings/SettingsHandler.class new file mode 100644 index 0000000..95cffd1 Binary files /dev/null and b/target/classes/us/centile/practice/settings/SettingsHandler.class differ diff --git a/target/classes/us/centile/practice/tournament/Tournament.class b/target/classes/us/centile/practice/tournament/Tournament.class new file mode 100644 index 0000000..64e99e8 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/Tournament.class differ diff --git a/target/classes/us/centile/practice/tournament/TournamentListener.class b/target/classes/us/centile/practice/tournament/TournamentListener.class new file mode 100644 index 0000000..f9a6584 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/TournamentListener.class differ diff --git a/target/classes/us/centile/practice/tournament/TournamentMatch$1.class b/target/classes/us/centile/practice/tournament/TournamentMatch$1.class new file mode 100644 index 0000000..19c7173 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/TournamentMatch$1.class differ diff --git a/target/classes/us/centile/practice/tournament/TournamentMatch$MatchState.class b/target/classes/us/centile/practice/tournament/TournamentMatch$MatchState.class new file mode 100644 index 0000000..4687ab2 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/TournamentMatch$MatchState.class differ diff --git a/target/classes/us/centile/practice/tournament/TournamentMatch.class b/target/classes/us/centile/practice/tournament/TournamentMatch.class new file mode 100644 index 0000000..4d596c5 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/TournamentMatch.class differ diff --git a/target/classes/us/centile/practice/tournament/TournamentStage.class b/target/classes/us/centile/practice/tournament/TournamentStage.class new file mode 100644 index 0000000..c8dc563 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/TournamentStage.class differ diff --git a/target/classes/us/centile/practice/tournament/TournamentTeam.class b/target/classes/us/centile/practice/tournament/TournamentTeam.class new file mode 100644 index 0000000..9702588 Binary files /dev/null and b/target/classes/us/centile/practice/tournament/TournamentTeam.class differ diff --git a/target/classes/us/centile/practice/tournament/tasks/TournamentTask.class b/target/classes/us/centile/practice/tournament/tasks/TournamentTask.class new file mode 100644 index 0000000..9bbea0b Binary files /dev/null and b/target/classes/us/centile/practice/tournament/tasks/TournamentTask.class differ diff --git a/target/classes/us/centile/practice/util/AbstractSerializer.class b/target/classes/us/centile/practice/util/AbstractSerializer.class new file mode 100644 index 0000000..2e30d41 Binary files /dev/null and b/target/classes/us/centile/practice/util/AbstractSerializer.class differ diff --git a/target/classes/us/centile/practice/util/Config.class b/target/classes/us/centile/practice/util/Config.class new file mode 100644 index 0000000..6e93771 Binary files /dev/null and b/target/classes/us/centile/practice/util/Config.class differ diff --git a/target/classes/us/centile/practice/util/DateUtil.class b/target/classes/us/centile/practice/util/DateUtil.class new file mode 100644 index 0000000..908e6e1 Binary files /dev/null and b/target/classes/us/centile/practice/util/DateUtil.class differ diff --git a/target/classes/us/centile/practice/util/LocationSerializer.class b/target/classes/us/centile/practice/util/LocationSerializer.class new file mode 100644 index 0000000..2547fd3 Binary files /dev/null and b/target/classes/us/centile/practice/util/LocationSerializer.class differ diff --git a/target/classes/us/centile/practice/util/MapSorting$1.class b/target/classes/us/centile/practice/util/MapSorting$1.class new file mode 100644 index 0000000..3f01931 Binary files /dev/null and b/target/classes/us/centile/practice/util/MapSorting$1.class differ diff --git a/target/classes/us/centile/practice/util/MapSorting$2.class b/target/classes/us/centile/practice/util/MapSorting$2.class new file mode 100644 index 0000000..b75b184 Binary files /dev/null and b/target/classes/us/centile/practice/util/MapSorting$2.class differ diff --git a/target/classes/us/centile/practice/util/MapSorting.class b/target/classes/us/centile/practice/util/MapSorting.class new file mode 100644 index 0000000..f1e2368 Binary files /dev/null and b/target/classes/us/centile/practice/util/MapSorting.class differ diff --git a/target/classes/us/centile/practice/util/Messages.class b/target/classes/us/centile/practice/util/Messages.class new file mode 100644 index 0000000..afd3c94 Binary files /dev/null and b/target/classes/us/centile/practice/util/Messages.class differ diff --git a/target/classes/us/centile/practice/util/PlayerUtility.class b/target/classes/us/centile/practice/util/PlayerUtility.class new file mode 100644 index 0000000..63caa31 Binary files /dev/null and b/target/classes/us/centile/practice/util/PlayerUtility.class differ diff --git a/target/classes/us/centile/practice/util/Sinventory.class b/target/classes/us/centile/practice/util/Sinventory.class new file mode 100644 index 0000000..4faad58 Binary files /dev/null and b/target/classes/us/centile/practice/util/Sinventory.class differ diff --git a/target/classes/us/centile/practice/util/TtlArrayList.class b/target/classes/us/centile/practice/util/TtlArrayList.class new file mode 100644 index 0000000..c746555 Binary files /dev/null and b/target/classes/us/centile/practice/util/TtlArrayList.class differ diff --git a/target/classes/us/centile/practice/util/TtlHashMap.class b/target/classes/us/centile/practice/util/TtlHashMap.class new file mode 100644 index 0000000..a120f09 Binary files /dev/null and b/target/classes/us/centile/practice/util/TtlHashMap.class differ diff --git a/target/classes/us/centile/practice/util/UtilActionMessage$AMText.class b/target/classes/us/centile/practice/util/UtilActionMessage$AMText.class new file mode 100644 index 0000000..3f86680 Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilActionMessage$AMText.class differ diff --git a/target/classes/us/centile/practice/util/UtilActionMessage$ClickableType.class b/target/classes/us/centile/practice/util/UtilActionMessage$ClickableType.class new file mode 100644 index 0000000..b197321 Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilActionMessage$ClickableType.class differ diff --git a/target/classes/us/centile/practice/util/UtilActionMessage.class b/target/classes/us/centile/practice/util/UtilActionMessage.class new file mode 100644 index 0000000..b81c104 Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilActionMessage.class differ diff --git a/target/classes/us/centile/practice/util/UtilElo.class b/target/classes/us/centile/practice/util/UtilElo.class new file mode 100644 index 0000000..6a7a60e Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilElo.class differ diff --git a/target/classes/us/centile/practice/util/UtilItem.class b/target/classes/us/centile/practice/util/UtilItem.class new file mode 100644 index 0000000..3797ddb Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilItem.class differ diff --git a/target/classes/us/centile/practice/util/UtilMath.class b/target/classes/us/centile/practice/util/UtilMath.class new file mode 100644 index 0000000..2f9b3fb Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilMath.class differ diff --git a/target/classes/us/centile/practice/util/UtilPlayer.class b/target/classes/us/centile/practice/util/UtilPlayer.class new file mode 100644 index 0000000..ead7b48 Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilPlayer.class differ diff --git a/target/classes/us/centile/practice/util/UtilString.class b/target/classes/us/centile/practice/util/UtilString.class new file mode 100644 index 0000000..6f04d53 Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilString.class differ diff --git a/target/classes/us/centile/practice/util/UtilTime$TimeUnit.class b/target/classes/us/centile/practice/util/UtilTime$TimeUnit.class new file mode 100644 index 0000000..ebd9e2e Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilTime$TimeUnit.class differ diff --git a/target/classes/us/centile/practice/util/UtilTime.class b/target/classes/us/centile/practice/util/UtilTime.class new file mode 100644 index 0000000..e2c150a Binary files /dev/null and b/target/classes/us/centile/practice/util/UtilTime.class differ diff --git a/target/classes/us/centile/practice/util/database/PracticeDatabase.class b/target/classes/us/centile/practice/util/database/PracticeDatabase.class new file mode 100644 index 0000000..ce03545 Binary files /dev/null and b/target/classes/us/centile/practice/util/database/PracticeDatabase.class differ diff --git a/target/kPractice-1.0-SNAPSHOT.jar b/target/kPractice-1.0-SNAPSHOT.jar new file mode 100644 index 0000000..f6f030e Binary files /dev/null and b/target/kPractice-1.0-SNAPSHOT.jar differ diff --git a/target/maven-archiver/pom.properties b/target/maven-archiver/pom.properties new file mode 100644 index 0000000..f2b6ba6 --- /dev/null +++ b/target/maven-archiver/pom.properties @@ -0,0 +1,5 @@ +#Generated by Maven +#Sun Sep 09 15:33:38 EDT 2018 +version=1.0-SNAPSHOT +groupId=us.noksdev.practice +artifactId=kPractice diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst new file mode 100644 index 0000000..18c496f --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst @@ -0,0 +1,122 @@ +us\centile\practice\tournament\TournamentStage.class +us\centile\practice\util\MapSorting$1.class +us\centile\practice\commands\HostCommand.class +us\centile\practice\listeners\HitDetectionListener.class +us\centile\practice\util\UtilTime$TimeUnit.class +us\centile\practice\listeners\EntityListener.class +us\centile\practice\scoreboard\BufferedObjective$1.class +us\centile\practice\tournament\TournamentMatch.class +us\centile\practice\util\UtilElo.class +us\centile\practice\scoreboard\SidebarEntry.class +us\centile\practice\nPractice.class +us\centile\practice\manager\managers\InventorySnapshotManager.class +us\centile\practice\commands\KitCommand.class +us\centile\practice\util\UtilActionMessage$AMText.class +us\centile\practice\events\DuelPreCreateEvent.class +us\centile\practice\settings\SettingsHandler$1.class +us\centile\practice\schedule\Schedule.class +us\centile\practice\duel\DuelState.class +us\centile\practice\arena\Arena.class +us\centile\practice\util\Messages.class +us\centile\practice\tournament\TournamentTeam.class +us\centile\practice\util\DateUtil.class +us\centile\practice\listeners\DuelListener.class +us\centile\practice\commands\SpectateCommand.class +us\centile\practice\listeners\PlayerListener$2.class +us\centile\practice\tournament\Tournament.class +us\centile\practice\runnables\RemovePlayerTask.class +us\centile\practice\manager\managers\RequestManager.class +us\centile\practice\commands\JoinCommand.class +us\centile\practice\commands\PingCommand.class +us\centile\practice\duel\Duel.class +us\centile\practice\util\Sinventory.class +us\centile\practice\events\DuelCreateEvent.class +us\centile\practice\party\PartyState.class +us\centile\practice\scoreboard\SidebarProvider.class +us\centile\practice\settings\SettingsHandler.class +us\centile\practice\commands\PremiumTokensCommand.class +us\centile\practice\manager\managers\EditorManager.class +us\centile\practice\listeners\InventoryListener$1.class +us\centile\practice\listeners\PlayerListener$3.class +us\centile\practice\player\PlayerInventorySnapshot.class +us\centile\practice\commands\SortPremiumEloCommand$1.class +us\centile\practice\runnables\LoadPlayerTask.class +us\centile\practice\tournament\TournamentMatch$MatchState.class +us\centile\practice\player\PlayerKit.class +us\centile\practice\manager\managers\SpectatorManager.class +us\centile\practice\tournament\TournamentMatch$1.class +us\centile\practice\commands\ResetEloCommand.class +us\centile\practice\commands\DuelCommand.class +us\centile\practice\manager\managers\KitManager.class +us\centile\practice\runnables\other\UpdateInventoryTask.class +us\centile\practice\manager\managers\DuelManager.class +us\centile\practice\commands\MatchesCommand$1.class +us\centile\practice\util\PlayerUtility.class +us\centile\practice\player\Match.class +us\centile\practice\kit\Kit.class +us\centile\practice\duel\DuelRequest.class +us\centile\practice\commands\BuilderCommand.class +us\centile\practice\commands\CreditsCommand.class +us\centile\practice\util\UtilActionMessage.class +us\centile\practice\arena\BlockChangeTracker.class +us\centile\practice\manager\ManagerHandler.class +us\centile\practice\manager\managers\PracticePlayerManager$1.class +us\centile\practice\manager\managers\PracticePlayerManager.class +us\centile\practice\listeners\PlayerListener$4.class +us\centile\practice\util\UtilActionMessage$ClickableType.class +us\centile\practice\schedule\ScheduleHandler.class +us\centile\practice\scoreboard\PlayerBoard$2.class +us\centile\practice\manager\managers\ArenaManager.class +us\centile\practice\commands\TournamentCommand.class +us\centile\practice\listeners\DuelListener$1.class +us\centile\practice\commands\ScoreboardCommand.class +us\centile\practice\tournament\tasks\TournamentTask.class +us\centile\practice\schedule\ScheduleTimer.class +us\centile\practice\manager\managers\ItemManager.class +us\centile\practice\listeners\BlockListener.class +us\centile\practice\settings\Settings.class +us\centile\practice\events\DuelEndingEvent.class +us\centile\practice\util\database\PracticeDatabase.class +us\centile\practice\util\UtilTime.class +us\centile\practice\events\DuelEndEvent.class +us\centile\practice\manager\Manager.class +us\centile\practice\scoreboard\BufferedObjective.class +us\centile\practice\scoreboard\ScoreboardHandler.class +us\centile\practice\scoreboard\provider\LobbyScoreboardProvider.class +us\centile\practice\util\MapSorting$2.class +us\centile\practice\listeners\PlayerListener.class +us\centile\practice\util\UtilPlayer.class +us\centile\practice\commands\CreditsCommand$1.class +us\centile\practice\commands\PremiumTokensCommand$1.class +us\centile\practice\manager\managers\PartyManager.class +us\centile\practice\commands\AcceptCommand.class +us\centile\practice\util\UtilString.class +us\centile\practice\listeners\InventoryListener.class +us\centile\practice\util\TtlArrayList.class +us\centile\practice\runnables\SavePlayerConfig.class +us\centile\practice\player\PracticePlayer.class +us\centile\practice\runnables\other\UpdateInventoryTask$InventoryTaskType.class +us\centile\practice\player\PlayerState.class +us\centile\practice\runnables\other\InsertMatchTask.class +us\centile\practice\commands\SortPremiumEloCommand.class +us\centile\practice\commands\ArenaCommand.class +us\centile\practice\commands\InventoryCommand.class +us\centile\practice\commands\LeaveCommand.class +us\centile\practice\commands\MatchesCommand.class +us\centile\practice\util\Config.class +us\centile\practice\party\Party.class +us\centile\practice\util\LocationSerializer.class +us\centile\practice\tournament\TournamentListener.class +us\centile\practice\manager\managers\QueueManager.class +us\centile\practice\util\UtilMath.class +us\centile\practice\util\AbstractSerializer.class +us\centile\practice\util\TtlHashMap.class +us\centile\practice\commands\SetSpawnCommand.class +us\centile\practice\scoreboard\provider\DuelScoreboardProvider.class +us\centile\practice\manager\managers\InventoryManager.class +us\centile\practice\listeners\PlayerListener$1.class +us\centile\practice\commands\PartyCommand.class +us\centile\practice\util\MapSorting.class +us\centile\practice\util\UtilItem.class +us\centile\practice\scoreboard\PlayerBoard$1.class +us\centile\practice\scoreboard\PlayerBoard.class diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst new file mode 100644 index 0000000..8398a18 --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst @@ -0,0 +1,99 @@ +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\ArenaCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\player\PracticePlayer.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\database\PracticeDatabase.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilElo.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\DuelCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\listeners\InventoryListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\duel\DuelRequest.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\runnables\other\InsertMatchTask.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\tournament\TournamentMatch.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilActionMessage.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\tournament\Tournament.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\events\DuelEndingEvent.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\AcceptCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\arena\BlockChangeTracker.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\tournament\TournamentStage.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\KitCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\schedule\Schedule.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\SidebarEntry.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\PlayerUtility.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\SidebarProvider.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilMath.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\events\DuelEndEvent.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilItem.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\events\DuelCreateEvent.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\duel\Duel.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\provider\DuelScoreboardProvider.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\MapSorting.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\ManagerHandler.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\player\Match.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\player\PlayerInventorySnapshot.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\duel\DuelState.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilPlayer.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\InventoryCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\ArenaManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\BuilderCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\party\Party.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\KitManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\CreditsCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\nPractice.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\AbstractSerializer.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\Config.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\listeners\HitDetectionListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\settings\SettingsHandler.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\listeners\BlockListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\PlayerBoard.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\SetSpawnCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\PartyCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\settings\Settings.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\listeners\EntityListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\LocationSerializer.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\player\PlayerKit.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\listeners\PlayerListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\PracticePlayerManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\runnables\other\UpdateInventoryTask.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\ScoreboardCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\tournament\TournamentListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\QueueManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\TournamentCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\BufferedObjective.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\TtlHashMap.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\JoinCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\PremiumTokensCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\ItemManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\InventorySnapshotManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\provider\LobbyScoreboardProvider.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\Sinventory.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\schedule\ScheduleTimer.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\arena\Arena.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\events\DuelPreCreateEvent.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\scoreboard\ScoreboardHandler.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\DuelManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\player\PlayerState.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\Manager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\LeaveCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\schedule\ScheduleHandler.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\SpectateCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\runnables\RemovePlayerTask.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\party\PartyState.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\DateUtil.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilTime.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\PingCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\kit\Kit.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\RequestManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\runnables\SavePlayerConfig.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\tournament\TournamentTeam.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\SpectatorManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\PartyManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\runnables\LoadPlayerTask.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\InventoryManager.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\tournament\tasks\TournamentTask.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\SortPremiumEloCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\TtlArrayList.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\HostCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\MatchesCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\listeners\DuelListener.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\UtilString.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\commands\ResetEloCommand.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\util\Messages.java +C:\Users\William\Desktop\Vexus Dev Work\kPractice\src\main\java\us\centile\practice\manager\managers\EditorManager.java diff --git a/target/original-kPractice-1.0-SNAPSHOT.jar b/target/original-kPractice-1.0-SNAPSHOT.jar new file mode 100644 index 0000000..d935df2 Binary files /dev/null and b/target/original-kPractice-1.0-SNAPSHOT.jar differ