Initial commit
This commit is contained in:
@@ -0,0 +1,49 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
|
||||
<parent>
|
||||
<artifactId>ProjectCranked</artifactId>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<version>1.0</version>
|
||||
</parent>
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
|
||||
<artifactId>Duels</artifactId>
|
||||
|
||||
<properties>
|
||||
<maven.compiler.source>8</maven.compiler.source>
|
||||
<maven.compiler.target>8</maven.compiler.target>
|
||||
</properties>
|
||||
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<artifactId>Utils</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<artifactId>Teams</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<artifactId>Collect</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<artifactId>Pets</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<artifactId>Enchants</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>net.crankedpvp</groupId>
|
||||
<artifactId>StorageUtilsShaded</artifactId>
|
||||
<version>1.0</version>
|
||||
<scope>system</scope>
|
||||
<systemPath>${project.basedir}/../StorageUtils/target/StorageUtils-1.0-shaded.jar</systemPath>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
</project>
|
||||
@@ -0,0 +1,144 @@
|
||||
package net.crankedpvp.duels;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
import net.crankedpvp.crankedutils.utils.InventoryUtils;
|
||||
import net.crankedpvp.crankedutils.utils.MiscUtils;
|
||||
import net.crankedpvp.crankedutils.utils.SoundUtils;
|
||||
import net.crankedpvp.duels.struct.*;
|
||||
import net.crankedpvp.teams.TeamsAPI;
|
||||
import net.crankedpvp.teams.struct.Team;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class DuelsAPI {
|
||||
|
||||
private static DuelManager duelManager = DuelsPlugin.getInstance().getDuelManager();
|
||||
|
||||
private static DuelTeam createDuelTeamFromPlayer(Player sender) {
|
||||
Team team = TeamsAPI.hasTeam(sender) ? TeamsAPI.getTeamFromPlayer(sender) : TeamsAPI.createTeam(sender);
|
||||
List<DuelPlayer> duelPlayerList = new ArrayList<>();
|
||||
if(team.getMembers() != null && team.getMembers().size() > 0)
|
||||
team.getMembers().stream()
|
||||
.map(DuelsAPI::createDuelPlayer)
|
||||
.forEach(duelPlayerList::add);
|
||||
|
||||
Player player = team.getLeader().getPlayer();
|
||||
return new DuelTeam(createDuelPlayer(player), duelPlayerList);
|
||||
}
|
||||
|
||||
private static DuelPlayer createDuelPlayer(Player player) {
|
||||
return new DuelPlayer(player.getUniqueId(),
|
||||
Arrays.stream(player.getInventory().getContents())
|
||||
.filter(Objects::nonNull)
|
||||
.map(ItemStack::clone)
|
||||
.toArray(ItemStack[]::new),
|
||||
MiscUtils.defaultIfNull(player.getInventory().getHelmet(), new ItemStack(Material.AIR)).clone(),
|
||||
MiscUtils.defaultIfNull(player.getInventory().getChestplate(), new ItemStack(Material.AIR)).clone(),
|
||||
MiscUtils.defaultIfNull(player.getInventory().getLeggings(), new ItemStack(Material.AIR)).clone(),
|
||||
MiscUtils.defaultIfNull(player.getInventory().getBoots(), new ItemStack(Material.AIR)).clone());
|
||||
}
|
||||
|
||||
public static DuelTeam getDuelTeamByPlayer(Player player) {
|
||||
for(DuelMatch duelMatch : duelManager.getDuelMatches()) {
|
||||
if(duelMatch.getTeamTwo().getDuelPlayersAsPlayers().contains(player)) return duelMatch.getTeamTwo();
|
||||
if(duelMatch.getTeamOne().getDuelPlayersAsPlayers().contains(player)) return duelMatch.getTeamOne();
|
||||
}
|
||||
return createDuelTeamFromPlayer(player);
|
||||
}
|
||||
|
||||
public static DuelPlayer getDuelPlayerByPlayer(Player player) {
|
||||
for(DuelMatch duelMatch : duelManager.getDuelMatches()) {
|
||||
for(DuelPlayer duelPlayer : duelMatch.getTeamTwo().getDuelPlayersAsDuelPlayers()) {
|
||||
if(duelPlayer.getPlayerUUID().equals(player.getUniqueId())) return duelPlayer;
|
||||
}
|
||||
for(DuelPlayer duelPlayer : duelMatch.getTeamOne().getDuelPlayersAsDuelPlayers()) {
|
||||
if(duelPlayer.getPlayerUUID().equals(player.getUniqueId())) return duelPlayer;
|
||||
}
|
||||
}
|
||||
System.out.println("not a player?");
|
||||
return null;
|
||||
}
|
||||
|
||||
public static DuelMatch getDuelMatchByPlayer(Player player) {
|
||||
return duelManager.getDuelMatchFromTeam(getDuelTeamByPlayer(player));
|
||||
}
|
||||
|
||||
public static EnumMap<DuelSetting, Boolean> getDefaultSettings() {
|
||||
EnumMap<DuelSetting, Boolean> settings = Maps.newEnumMap(DuelSetting.class);
|
||||
for(DuelSetting value : DuelSetting.values()) {
|
||||
settings.put(value, value.isDefaultSetting());
|
||||
}
|
||||
return settings;
|
||||
}
|
||||
|
||||
public static boolean isPlayerInDuel(Player player) {
|
||||
for(DuelMatch duelMatch : duelManager.getDuelMatches()) {
|
||||
if(duelMatch.getTeamTwo().getDuelPlayersAsPlayers().contains(player)) return true;
|
||||
if(duelMatch.getTeamOne().getDuelPlayersAsPlayers().contains(player)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static void setPlayerDeadInDuel(Player player) {
|
||||
for(DuelMatch duelMatch : duelManager.getDuelMatches()) {
|
||||
if(duelMatch.getTeamTwo().getDuelPlayersAsPlayers().contains(player)) {
|
||||
for(DuelPlayer duelPlayersAsDuelPlayer : duelMatch.getTeamTwo().getDuelPlayersAsDuelPlayers()) {
|
||||
if(!duelPlayersAsDuelPlayer.isDead() && duelPlayersAsDuelPlayer.getPlayerUUID() == player.getUniqueId()) {
|
||||
duelPlayersAsDuelPlayer.setDead(true);}}}
|
||||
if(duelMatch.getTeamOne().getDuelPlayersAsPlayers().contains(player)) {
|
||||
for(DuelPlayer duelPlayersAsDuelPlayer : duelMatch.getTeamOne().getDuelPlayersAsDuelPlayers()) {
|
||||
if(!duelPlayersAsDuelPlayer.isDead() && duelPlayersAsDuelPlayer.getPlayerUUID() == player.getUniqueId()) {
|
||||
duelPlayersAsDuelPlayer.setDead(true);}}}
|
||||
}
|
||||
}
|
||||
|
||||
public static void setPlayerDeadAndCheckForWin(Player player) {
|
||||
InventoryUtils.clearInventory(player);
|
||||
player.teleport(Bukkit.getWorld("world").getSpawnLocation());
|
||||
SoundUtils.tryPlayErrorSound(player);
|
||||
setPlayerDeadInDuel(player);
|
||||
}
|
||||
|
||||
public static List<ItemStack> getItemsFromTeam(DuelTeam duelTeam) {
|
||||
List<ItemStack> itemStacks = new ArrayList<>();
|
||||
duelTeam.getDuelPlayersAsDuelPlayers().forEach(duelPlayer -> {
|
||||
itemStacks.addAll(Arrays.asList(duelPlayer.getInitialInventory()));
|
||||
itemStacks.add(duelPlayer.getHelmet());
|
||||
itemStacks.add(duelPlayer.getChestplate());
|
||||
itemStacks.add(duelPlayer.getLeggings());
|
||||
itemStacks.add(duelPlayer.getBoots());
|
||||
});
|
||||
return itemStacks.stream().filter(Objects::nonNull).filter(itemStack -> itemStack.getType() != Material.AIR).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public static List<ItemStack> getItemsFromPlayer(DuelPlayer duelPlayer) {
|
||||
List<ItemStack> itemStacks = new ArrayList<>(Arrays.asList(duelPlayer.getInitialInventory()));
|
||||
itemStacks.add(duelPlayer.getHelmet());
|
||||
itemStacks.add(duelPlayer.getChestplate());
|
||||
itemStacks.add(duelPlayer.getLeggings());
|
||||
itemStacks.add(duelPlayer.getBoots());
|
||||
return itemStacks.stream().filter(Objects::nonNull).filter(itemStack -> itemStack.getType() != Material.AIR).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public static DuelArena findOpenArena() {
|
||||
List<DuelArena> duelArenas = new ArrayList<>(DuelsPlugin.getInstance().getArenaRegister().getCacheValues());
|
||||
Collections.shuffle(duelArenas);
|
||||
for(DuelArena duelArena : duelArenas) {
|
||||
if(!duelArena.isActive()) return duelArena;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static boolean isParticipant(Player player) {
|
||||
if(player == null || !player.isOnline()) return false;
|
||||
for(DuelMatch duelMatch : DuelsPlugin.getInstance().getDuelManager().getDuelMatches()) {
|
||||
if(duelMatch.getAllPlayers().contains(player)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package net.crankedpvp.duels;
|
||||
|
||||
import lombok.Getter;
|
||||
import me.mattstudios.mf.base.CommandManager;
|
||||
import net.crankedpvp.collect.CollectPlugin;
|
||||
import net.crankedpvp.collect.struct.CollectCategory;
|
||||
import net.crankedpvp.collect.struct.CollectType;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.InventoryUtils;
|
||||
import net.crankedpvp.duels.commands.DuelCommand;
|
||||
import net.crankedpvp.duels.listeners.DamageListener;
|
||||
import net.crankedpvp.duels.listeners.PlayerDeathListener;
|
||||
import net.crankedpvp.duels.listeners.PlayerDisconnectListener;
|
||||
import net.crankedpvp.duels.listeners.PlayerListener;
|
||||
import net.crankedpvp.duels.struct.*;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.event.player.PlayerTeleportEvent;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.plugin.PluginManager;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
|
||||
public class DuelsPlugin extends JavaPlugin {
|
||||
|
||||
@Getter
|
||||
private static DuelsPlugin instance;
|
||||
|
||||
@Getter
|
||||
private DuelManager duelManager;
|
||||
|
||||
@Getter
|
||||
private ArenaRegister arenaRegister;
|
||||
|
||||
@Getter
|
||||
private DuelPlayerHandler duelPlayerHandler;
|
||||
|
||||
@Override
|
||||
public void onEnable() {
|
||||
instance = this;
|
||||
this.duelManager = new DuelManager(this);
|
||||
this.arenaRegister = new ArenaRegister(this);
|
||||
this.arenaRegister.loadAll();
|
||||
|
||||
this.duelPlayerHandler = new DuelPlayerHandler(this);
|
||||
CommandManager commandManager = new CommandManager(this);
|
||||
commandManager.register(new DuelCommand(this));
|
||||
|
||||
registerListeners();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onDisable() {
|
||||
this.arenaRegister.saveAll();
|
||||
this.getLogger().info("Removing players from active duel matches...");
|
||||
for(DuelMatch duelMatch : this.duelManager.getDuelMatches()) {
|
||||
if(duelMatch.getDuelStatus() != DuelStatus.ACTIVE) continue;
|
||||
this.getLogger().info("Arena: " + duelMatch.getDuelArena().getArenaName() + " Removing " + duelMatch.getAllPlayers().size() + " players");
|
||||
for(DuelPlayer duelPlayer : duelMatch.getAllDuelPlayers()) {
|
||||
if(!duelPlayer.isDead()) {
|
||||
InventoryUtils.clearInventory(duelPlayer.getPlayer());
|
||||
}
|
||||
duelPlayer.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
|
||||
duelPlayer.getPlayer().sendMessage(CC.translate("&cYour duel match has been forcefully "));
|
||||
List<ItemStack> items = DuelsAPI.getItemsFromPlayer(Objects.requireNonNull(duelPlayer));
|
||||
if(items.size() == 0) return;
|
||||
CollectPlugin.getInstance().getCollectManager().getOrCreate(duelPlayer.getPlayerUUID().toString()).add(new CollectCategory(CollectType.DUEL, items.toArray(new ItemStack[items.size() - 1]), CC.RedB + "Your duel items", System.currentTimeMillis()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void registerListeners() {
|
||||
PluginManager pluginManager = this.getServer().getPluginManager();
|
||||
pluginManager.registerEvents(new PlayerDeathListener(this), this);
|
||||
pluginManager.registerEvents(new PlayerDisconnectListener(this), this);
|
||||
pluginManager.registerEvents(new DamageListener(this), this);
|
||||
pluginManager.registerEvents(new PlayerListener(), this);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
package net.crankedpvp.duels.commands;
|
||||
|
||||
import me.mattstudios.mf.annotations.*;
|
||||
import me.mattstudios.mf.base.CommandBase;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.SoundUtils;
|
||||
import net.crankedpvp.crankedutils.utils.WorldGuardUtils;
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import net.crankedpvp.duels.inventory.DuelAcceptUI;
|
||||
import net.crankedpvp.duels.inventory.DuelSettingsUI;
|
||||
import net.crankedpvp.duels.struct.*;
|
||||
import org.bukkit.Sound;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
@Command("duel")
|
||||
public class DuelCommand extends CommandBase {
|
||||
|
||||
private final DuelsPlugin plugin;
|
||||
public DuelCommand(DuelsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
@Default
|
||||
public void defaultCommand(final CommandSender commandSender, @Optional @Completion("#players") final Player toDuel) {
|
||||
if(!(commandSender instanceof Player)) {
|
||||
commandSender.sendMessage(CC.translate("&cOnly players can execute this command"));
|
||||
return;
|
||||
}
|
||||
|
||||
Player sender = ((Player) commandSender);
|
||||
|
||||
if(toDuel == null) {
|
||||
sender.sendMessage(CC.translate("&cPlayer Duels"));
|
||||
sender.sendMessage(CC.translate("&f/duel <player>"));
|
||||
return;
|
||||
}
|
||||
|
||||
if(!toDuel.isOnline()) {
|
||||
sender.sendMessage(CC.translate("&cThat player is not online"));
|
||||
SoundUtils.tryPlayErrorSound(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
if(this.plugin.getDuelManager().getDuelMatches().contains(DuelsAPI.getDuelMatchByPlayer(sender))) {
|
||||
DuelMatch duelMatch = DuelsAPI.getDuelMatchByPlayer(sender);
|
||||
if(duelMatch.getSendingTeam().getDuelPlayersAsPlayers().contains(sender)) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYou have already sent another team a duel request"));
|
||||
SoundUtils.tryPlayErrorSound(sender);
|
||||
return;
|
||||
}
|
||||
DuelsPlugin.getInstance().getDuelManager().getDuelMatches().remove(duelMatch);
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYour incoming duel request has been cancelled"));
|
||||
}
|
||||
|
||||
if(WorldGuardUtils.canPvPInRegion(sender)) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYou cannot send a duel request unless you are in a safezone"));
|
||||
SoundUtils.tryPlayErrorSound(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
DuelTeam senderDuelTeam = DuelsAPI.getDuelTeamByPlayer(sender);
|
||||
DuelTeam receiverDuelTeam = DuelsAPI.getDuelTeamByPlayer(toDuel);
|
||||
if(senderDuelTeam.getAmountOfPlayers() != receiverDuelTeam.getAmountOfPlayers()) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYour team &7(" + senderDuelTeam.getAmountOfPlayers() + " players) &cdoes not have equal players to this team"));
|
||||
return;
|
||||
}
|
||||
|
||||
DuelSettingsUI duelSettingsUI = new DuelSettingsUI(senderDuelTeam, receiverDuelTeam, DuelsAPI.getDefaultSettings());
|
||||
duelSettingsUI.getSettingsUI().open(sender);
|
||||
}
|
||||
|
||||
|
||||
@SubCommand("setspawn")
|
||||
@Permission("cranked.admin")
|
||||
public void setSpawnCommand(final Player player, String duelArenaName, String team) {
|
||||
if(this.plugin.getArenaRegister().containsKey(duelArenaName)) {
|
||||
DuelArena duelArena = this.plugin.getArenaRegister().getFromCache(duelArenaName);
|
||||
if(team.equals("true")) duelArena.setSpawnPointOne(player.getLocation());
|
||||
if(team.equals("false")) duelArena.setSpawnPointTwo(player.getLocation());
|
||||
return;
|
||||
}
|
||||
this.plugin.getArenaRegister().addToCache(new DuelArena(duelArenaName, player.getLocation(), player.getLocation()));
|
||||
|
||||
player.sendMessage("setup");
|
||||
player.playSound(player.getLocation(), Sound.SUCCESSFUL_HIT, 2.0F, 2.0F);
|
||||
|
||||
}
|
||||
|
||||
@SubCommand("cancel")
|
||||
public void cancelCommand(final CommandSender commandSender) {
|
||||
if(!(commandSender instanceof Player)) {
|
||||
commandSender.sendMessage(CC.translate("&cOnly players can execute this command"));
|
||||
return;
|
||||
}
|
||||
|
||||
Player sender = ((Player) commandSender);
|
||||
DuelTeam duelReceiver = DuelsAPI.getDuelTeamByPlayer(sender);
|
||||
if(!sender.getName().equals(duelReceiver.getDuelTeamLeader().getName())) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cOnly the team leader can cancel duel requests"));
|
||||
return;
|
||||
}
|
||||
|
||||
DuelMatch duelMatch = this.plugin.getDuelManager().getDuelMatchFromTeam(duelReceiver);
|
||||
this.plugin.getDuelManager().getDuelMatches().remove(duelMatch);
|
||||
for(Player allPlayer : duelMatch.getAllPlayers()) {
|
||||
allPlayer.sendMessage(CC.translate(DuelManager.prefix + "&cThis duel has been aborted by " + sender.getName()));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@SubCommand("accept")
|
||||
public void acceptCommand(final CommandSender commandSender, @Completion("#players") final Player player) {
|
||||
if(!(commandSender instanceof Player)) {
|
||||
commandSender.sendMessage(CC.translate("&cOnly players can execute this command"));
|
||||
return;
|
||||
}
|
||||
|
||||
Player sender = ((Player) commandSender);
|
||||
DuelTeam duelReceiver = DuelsAPI.getDuelTeamByPlayer(sender);
|
||||
if(!sender.getName().equals(duelReceiver.getDuelTeamLeader().getName())) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cOnly the team leader can accept duel requests"));
|
||||
return;
|
||||
}
|
||||
|
||||
if(!this.plugin.getDuelManager().hasBeenDueled(duelReceiver)) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYour team has not been sent a duel request"));
|
||||
return;
|
||||
}
|
||||
DuelTeam duelSender = DuelsAPI.getDuelTeamByPlayer(player);
|
||||
|
||||
if(duelReceiver.getAmountOfPlayers() != duelSender.getAmountOfPlayers()) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYour team &7(" + duelReceiver.getAmountOfPlayers() + " players) &cdoes not have equal amount of players to this team"));
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
DuelMatch duelMatch = this.plugin.getDuelManager().getDuelMatchFromTeam(duelReceiver);
|
||||
if(WorldGuardUtils.canPvPInRegion(sender)) {
|
||||
sender.sendMessage(CC.translate(DuelManager.prefix + "&cYou cannot accept a duel request unless you are in a safezone"));
|
||||
SoundUtils.tryPlayErrorSound(sender);
|
||||
return;
|
||||
}
|
||||
|
||||
for(Player duelMatchPlayer : duelMatch.getAllPlayers()) {
|
||||
if(WorldGuardUtils.canPvPInRegion(duelMatchPlayer)) {
|
||||
duelMatch.sendToAllPlayers(CC.translate(DuelManager.prefix + "&cThe duel cannot be accepted as &4" + duelMatchPlayer.getName() + " &cis not in a safezone"));
|
||||
SoundUtils.tryPlayErrorSound(sender);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if(duelMatch.getDuelStatus() == DuelStatus.ACTIVE) {
|
||||
sender.sendMessage(DuelManager.prefix + "&cThis duel has already begun");
|
||||
sender.playSound(sender.getLocation(), Sound.ANVIL_BREAK, 2.0f, 2.0f);
|
||||
return;
|
||||
}
|
||||
//sender.sendMessage("YOUR TEAM (" + duelMatch.getTeamTwo().getAmountOfPlayers() + ") vs " + duelMatch.getTeamOne().getDuelTeamLeader().getName() + "'s Team (" + duelMatch.getTeamOne().getAmountOfPlayers() + ")");
|
||||
DuelAcceptUI duelAcceptUI = new DuelAcceptUI(duelMatch);
|
||||
duelAcceptUI.getAcceptUI().open(duelReceiver.getDuelTeamLeader());
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
package net.crankedpvp.duels.inventory;
|
||||
|
||||
import dev.triumphteam.gui.components.GuiType;
|
||||
import dev.triumphteam.gui.guis.Gui;
|
||||
import dev.triumphteam.gui.guis.GuiItem;
|
||||
import lombok.Getter;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.MiscUtils;
|
||||
import net.crankedpvp.crankedutils.utils.SoundUtils;
|
||||
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import net.crankedpvp.duels.struct.DuelManager;
|
||||
import net.crankedpvp.duels.struct.DuelMatch;
|
||||
import net.crankedpvp.duels.struct.DuelPlayer;
|
||||
import net.crankedpvp.duels.struct.DuelSetting;
|
||||
import org.bukkit.DyeColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class DuelAcceptUI {
|
||||
|
||||
private boolean forceClose = false;
|
||||
private final EnumMap<DuelSetting, Boolean> currentSettings;
|
||||
|
||||
@Getter
|
||||
private final Gui acceptUI;
|
||||
|
||||
public DuelAcceptUI(DuelMatch duelMatch) {
|
||||
this.currentSettings = duelMatch.getSettings();
|
||||
this.acceptUI = new Gui(GuiType.HOPPER, "Duel Accept");
|
||||
this.acceptUI.setDefaultClickAction(event -> event.setCancelled(true));
|
||||
this.acceptUI.setCloseGuiAction(inventoryCloseEvent -> {
|
||||
if(forceClose) return;
|
||||
DuelManager duelManager = DuelsPlugin.getInstance().getDuelManager();
|
||||
duelMatch.getTeamOne().getDuelPlayersAsPlayers().forEach(player -> {
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&c" + duelMatch.getTeamTwo().getDuelTeamLeader().getName() + "'s team has declined the duel"));
|
||||
SoundUtils.tryPlayErrorSound(player);
|
||||
});
|
||||
duelMatch.getTeamTwo().getDuelPlayersAsPlayers().forEach(player -> {
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cYour team has declined the duel against " + duelMatch.getTeamOne().getDuelTeamLeader().getName() + "'s team"));
|
||||
SoundUtils.tryPlayErrorSound(player);
|
||||
});
|
||||
duelManager.getDuelMatches().remove(duelMatch);
|
||||
});
|
||||
|
||||
updateConfirmButton(duelMatch);
|
||||
|
||||
}
|
||||
|
||||
private void updateConfirmButton(DuelMatch duelMatch) {
|
||||
this.acceptUI.updateItem(2, new GuiItem(createConfirmButton(), event -> {
|
||||
this.forceClose = true;
|
||||
event.getWhoClicked().closeInventory();
|
||||
SoundUtils.tryPlaySuccessSound(event.getWhoClicked());
|
||||
event.getWhoClicked().sendMessage(CC.translate(DuelManager.prefix + "&aAccepted duel against " + duelMatch.getTeamOne().getDuelTeamLeader().getName() + "'s team"));
|
||||
duelMatch.getTeamOne().getDuelTeamLeader().sendMessage(CC.translate(DuelManager.prefix + "&aThe player &6" + duelMatch.getReceivingTeam().getDuelTeamLeader().getName() + " &ahas accepted your teams duel request"));
|
||||
|
||||
DuelConfirmUI duelConfirmUI = new DuelConfirmUI(duelMatch);
|
||||
Gui gui = duelConfirmUI.getDuelConfirmUI();
|
||||
duelMatch.getAllPlayers().forEach(gui::open);
|
||||
/*
|
||||
for(Player teamOnePlayer : duelMatch.getTeamOne().getDuelPlayersAsPlayers()) {
|
||||
resetInventory(teamOnePlayer);
|
||||
teamOnePlayer.teleport(duelMatch.getDuelArena().getSpawnPointOne(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
|
||||
InventorySettings.applyInventorySettings(teamOnePlayer, this.currentSettings);
|
||||
}
|
||||
|
||||
for(Player teamTwoPlayer : duelMatch.getTeamTwo().getDuelPlayersAsPlayers()) {
|
||||
resetInventory(teamTwoPlayer);
|
||||
teamTwoPlayer.teleport(duelMatch.getDuelArena().getSpawnPointTwo(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
|
||||
InventorySettings.applyInventorySettings(teamTwoPlayer, this.currentSettings);
|
||||
}
|
||||
|
||||
*/
|
||||
}));
|
||||
}
|
||||
|
||||
|
||||
private void resetInventory(Player player) {
|
||||
DuelPlayer duelPlayer = DuelsAPI.getDuelPlayerByPlayer(player);
|
||||
assert duelPlayer != null;
|
||||
ItemStack[] itemStacks = Arrays.stream(player.getInventory().getContents())
|
||||
.filter(Objects::nonNull)
|
||||
.map(ItemStack::clone)
|
||||
.toArray(ItemStack[]::new);
|
||||
duelPlayer.setInitialInventory(itemStacks);
|
||||
duelPlayer.setHelmet(MiscUtils.defaultIfNull(player.getInventory().getHelmet(), new ItemStack(Material.AIR)).clone());
|
||||
duelPlayer.setChestplate(MiscUtils.defaultIfNull(player.getInventory().getChestplate(), new ItemStack(Material.AIR)).clone());
|
||||
duelPlayer.setLeggings(MiscUtils.defaultIfNull(player.getInventory().getLeggings(), new ItemStack(Material.AIR)).clone());
|
||||
duelPlayer.setBoots(MiscUtils.defaultIfNull(player.getInventory().getBoots(), new ItemStack(Material.AIR)).clone());
|
||||
}
|
||||
|
||||
/*
|
||||
private void equipPlayer(Player player) {
|
||||
player.getInventory().clear();
|
||||
player.getInventory().setHelmet(new ItemBuilder(Material.DIAMOND_HELMET, "&b&lDuel Armor").addEnchantment(Enchantment.PROTECTION_ENVIRONMENTAL, 4).addEnchantment(Enchantment.DURABILITY, 3).colorize().build());
|
||||
player.getInventory().setChestplate(new ItemBuilder(Material.DIAMOND_CHESTPLATE, "&b&lDuel Armor").addEnchantment(Enchantment.PROTECTION_ENVIRONMENTAL, 4).addEnchantment(Enchantment.DURABILITY, 3).colorize().build());
|
||||
player.getInventory().setLeggings(new ItemBuilder(Material.DIAMOND_LEGGINGS, "&b&lDuel Armor").addEnchantment(Enchantment.PROTECTION_ENVIRONMENTAL, 4).addEnchantment(Enchantment.DURABILITY, 3).colorize().build());
|
||||
player.getInventory().setBoots(new ItemBuilder(Material.DIAMOND_BOOTS, "&b&lDuel Armor").addEnchantment(Enchantment.PROTECTION_ENVIRONMENTAL, 4).addEnchantment(Enchantment.DURABILITY, 3).colorize().build());
|
||||
player.getInventory().setHeldItemSlot(0);
|
||||
player.getInventory().setItemInHand(new ItemBuilder(Material.DIAMOND_SWORD, "&b&lDuel Weapon").addEnchantment(Enchantment.DAMAGE_ALL, 5).colorize().build());
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
private ItemStack createConfirmButton() {
|
||||
ItemBuilder itemBuilder = new ItemBuilder(Material.STAINED_GLASS_PANE, 1, DyeColor.LIME.getWoolData());
|
||||
itemBuilder.setName("&a&lAccept Duel");
|
||||
List<String> lore = new ArrayList<>();
|
||||
this.currentSettings.forEach((key, value) -> lore.add("&4&l* &c" + key.getSettingName() + ": " + getEnabled(value)));
|
||||
itemBuilder.setLore(lore);
|
||||
return itemBuilder.colorize().build();
|
||||
}
|
||||
|
||||
private String getEnabled(boolean enabled) {
|
||||
return enabled ? "&a&lENABLED" : "&c&lDISABLED";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
package net.crankedpvp.duels.inventory;
|
||||
|
||||
import de.tr7zw.nbtapi.NBTItem;
|
||||
import dev.triumphteam.gui.guis.Gui;
|
||||
import dev.triumphteam.gui.guis.GuiItem;
|
||||
import lombok.Getter;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
|
||||
import net.crankedpvp.crankedutils.utils.MiscUtils;
|
||||
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import net.crankedpvp.duels.struct.DuelManager;
|
||||
import net.crankedpvp.duels.struct.DuelMatch;
|
||||
import net.crankedpvp.duels.struct.DuelPlayer;
|
||||
import net.crankedpvp.duels.struct.DuelStatus;
|
||||
import net.crankedpvp.duels.utils.InventorySettings;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.Sound;
|
||||
import org.bukkit.entity.HumanEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.inventory.InventoryClickEvent;
|
||||
import org.bukkit.event.player.PlayerTeleportEvent;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
public class DuelConfirmUI {
|
||||
private boolean forceClose = false;
|
||||
private List<String> settingsLore;
|
||||
private List<Player> clickCooldown;
|
||||
private DuelMatch duelMatch;
|
||||
private int maxPlayers;
|
||||
private int acceptedPlayers = 0;
|
||||
|
||||
private boolean closed = false;
|
||||
|
||||
private int countdownTaskID;
|
||||
|
||||
@Getter
|
||||
private final Gui duelConfirmUI;
|
||||
|
||||
public DuelConfirmUI(DuelMatch duelMatch) {
|
||||
this.registerValues(duelMatch);
|
||||
this.duelConfirmUI = new Gui(6, "Duel Accept");
|
||||
this.duelConfirmUI.setDefaultClickAction(event -> event.setCancelled(true));
|
||||
this.duelConfirmUI.setCloseGuiAction(inventoryCloseEvent -> {
|
||||
if(!this.forceClose) {
|
||||
this.closed = true;
|
||||
duelMatch.setDuelStatus(DuelStatus.CANCELLED);
|
||||
Player closingPlayer = (Player)inventoryCloseEvent.getPlayer();
|
||||
List<Player> players = duelMatch.getAllPlayers();
|
||||
players.remove(closingPlayer);
|
||||
this.stopCountdown();
|
||||
closingPlayer.sendMessage(CC.translate(DuelManager.prefix + "&cYou have aborted your duel"));
|
||||
DuelsPlugin.getInstance().getDuelManager().getDuelMatches().remove(duelMatch);
|
||||
players.forEach(player -> {
|
||||
player.closeInventory();
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cThis duel has been aborted by " + closingPlayer.getName()));
|
||||
});
|
||||
}
|
||||
if(duelMatch.getDuelStatus() == DuelStatus.CANCELLED) return;
|
||||
if(this.closed) return;
|
||||
this.closed = true;
|
||||
List<Player> players = duelMatch.getAllPlayers();
|
||||
duelMatch.setDuelStatus(DuelStatus.ACTIVE);
|
||||
players.forEach(player -> {
|
||||
EssentialsUtils.clearTeleportRequests(player);
|
||||
player.closeInventory();
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&aThe duel has started"));
|
||||
});
|
||||
this.startDuel();
|
||||
});
|
||||
|
||||
splitGui(0);
|
||||
addPlayersConfirmButtonsToUI();
|
||||
}
|
||||
|
||||
private void startDuel() {
|
||||
for(Player teamOnePlayer : duelMatch.getTeamOne().getDuelPlayersAsPlayers()) {
|
||||
resetInventory(teamOnePlayer);
|
||||
teamOnePlayer.teleport(duelMatch.getDuelArena().getSpawnPointOne(), PlayerTeleportEvent.TeleportCause.PLUGIN);
|
||||
InventorySettings.applyInventorySettings(teamOnePlayer, this.duelMatch.getSettings());
|
||||
}
|
||||
|
||||
for(Player teamTwoPlayer : duelMatch.getTeamTwo().getDuelPlayersAsPlayers()) {
|
||||
resetInventory(teamTwoPlayer);
|
||||
teamTwoPlayer.teleport(duelMatch.getDuelArena().getSpawnPointTwo(), PlayerTeleportEvent.TeleportCause.PLUGIN);
|
||||
InventorySettings.applyInventorySettings(teamTwoPlayer, this.duelMatch.getSettings());
|
||||
}
|
||||
}
|
||||
|
||||
private void registerValues(DuelMatch duelMatch) {
|
||||
duelMatch.setDuelStatus(DuelStatus.CONFIRMING);
|
||||
this.duelMatch = duelMatch;
|
||||
this.maxPlayers = duelMatch.getAllPlayers().size();
|
||||
this.clickCooldown = new ArrayList<>();
|
||||
List<String> settingsLore = new ArrayList<>();
|
||||
duelMatch.getSettings().forEach((key, value) -> settingsLore.add("&4&l* &c" + key.getSettingName() + ": " + getEnabled(value)));
|
||||
this.settingsLore = settingsLore;
|
||||
}
|
||||
|
||||
private void addPlayersConfirmButtonsToUI() {
|
||||
List<Player> teamOne = duelMatch.getTeamOne().getDuelPlayersAsPlayers();
|
||||
List<Player> teamTwo = duelMatch.getTeamTwo().getDuelPlayersAsPlayers();
|
||||
int[] teamOneSlots = new int[] {0, 1, 2, 3, 9, 10, 11, 12, 18, 19, 20, 21};
|
||||
int[] teamTwoSlots = new int[] {8, 7, 6, 5, 17, 16, 15, 14, 26, 25, 24, 23};
|
||||
for(int i = 0; i < teamOne.size(); i++) {
|
||||
this.duelConfirmUI.updateItem(teamOneSlots[i], new GuiItem(setupPlayersAcceptButton(teamOne.get(i), false), this::runAcceptCheck));
|
||||
}
|
||||
for(int i = 0; i < teamTwo.size(); i++) {
|
||||
this.duelConfirmUI.updateItem(teamTwoSlots[i], new GuiItem(setupPlayersAcceptButton(teamTwo.get(i), false), this::runAcceptCheck));
|
||||
}
|
||||
}
|
||||
|
||||
private void runAcceptCheck(InventoryClickEvent event) {
|
||||
if(this.clickCooldown.contains((Player) event.getWhoClicked())) return;
|
||||
this.clickCooldown.add((Player) event.getWhoClicked());
|
||||
Bukkit.getScheduler().runTaskLater(DuelsPlugin.getInstance(), () -> this.clickCooldown.remove((Player) event.getWhoClicked()), 10L);
|
||||
NBTItem nbtItem = new NBTItem(event.getCurrentItem());
|
||||
UUID playerUUID = UUID.fromString(nbtItem.getString("playerUUID"));
|
||||
if(!event.getWhoClicked().getUniqueId().equals(playerUUID)) return;
|
||||
this.duelConfirmUI.updateItem(event.getSlot(), new GuiItem(setupPlayersAcceptButton(Bukkit.getPlayer(playerUUID), !nbtItem.getBoolean("accepted")), this::runAcceptCheck));
|
||||
this.updateGuiForAllPlayers();
|
||||
}
|
||||
|
||||
private void updateGuiForAllPlayers() {
|
||||
duelMatch.getAllPlayers().forEach(Player::updateInventory);
|
||||
}
|
||||
|
||||
private ItemStack setupPlayersAcceptButton(Player player, boolean accepted) {
|
||||
ItemBuilder itemBuilder = new ItemBuilder(Material.STAINED_GLASS_PANE, "&a&lAccept? &7(" + player.getName() + ")", "&fClick to accept the duel");
|
||||
if(accepted) {
|
||||
this.acceptedPlayers++;
|
||||
itemBuilder.setDurability((short) 5);
|
||||
itemBuilder.setGlowing();
|
||||
if(this.acceptedPlayers == this.maxPlayers) this.startCountdown();
|
||||
|
||||
} else {
|
||||
itemBuilder.setDurability((short) 14);
|
||||
if(this.acceptedPlayers != 0) {
|
||||
this.acceptedPlayers--;
|
||||
this.stopCountdown();
|
||||
}
|
||||
|
||||
}
|
||||
NBTItem nbtItem = new NBTItem(itemBuilder.colorize().build());
|
||||
nbtItem.setString("playerUUID", player.getUniqueId().toString());
|
||||
nbtItem.setBoolean("accepted", accepted);
|
||||
return nbtItem.getItem();
|
||||
}
|
||||
|
||||
private void stopCountdown() {
|
||||
DuelsPlugin.getInstance().getServer().getScheduler().cancelTask(this.countdownTaskID);
|
||||
this.splitGui(0);
|
||||
}
|
||||
|
||||
private void startCountdown() {
|
||||
AtomicInteger countdown = new AtomicInteger(5);
|
||||
this.countdownTaskID = DuelsPlugin.getInstance().getServer().getScheduler().scheduleAsyncRepeatingTask(DuelsPlugin.getInstance(), () -> {
|
||||
this.splitGui(countdown.get());
|
||||
if(countdown.get() == 0) {
|
||||
this.stopCountdown();
|
||||
this.forceClose = true;
|
||||
this.duelMatch.getAllPlayers().forEach(HumanEntity::closeInventory);
|
||||
return;
|
||||
}
|
||||
|
||||
countdown.getAndDecrement();
|
||||
this.getAllPlayers().forEach(player -> player.playSound(player.getLocation(), Sound.SUCCESSFUL_HIT, 2.0f, 2.0f));
|
||||
}, 0L, 20);
|
||||
}
|
||||
|
||||
private List<Player> getAllPlayers() {
|
||||
return this.duelMatch.getAllPlayers();
|
||||
}
|
||||
|
||||
private void splitGui(int num) {
|
||||
for(int i = 1; i < 7; i++) {
|
||||
this.duelConfirmUI.updateItem(i, 5, new GuiItem(this.getSplitterItem(num)));
|
||||
}
|
||||
}
|
||||
|
||||
private ItemStack getSplitterItem(int num) {
|
||||
ItemBuilder itemBuilder = new ItemBuilder(Material.STAINED_GLASS_PANE, (num == 0 ? 1 : num));
|
||||
itemBuilder.setLore(this.settingsLore);
|
||||
switch(num) {
|
||||
case 0:
|
||||
if(this.maxPlayers == this.acceptedPlayers) {
|
||||
itemBuilder.setName("&a&lStarting Duel..");
|
||||
} else {
|
||||
itemBuilder.setName("&fWaiting for players to accept...");
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
case 3:
|
||||
itemBuilder.setDurability((short) 1);
|
||||
itemBuilder.setName("&6&l" + num + "..");
|
||||
break;
|
||||
case 2:
|
||||
case 1:
|
||||
itemBuilder.setDurability((short) 14);
|
||||
itemBuilder.setName("&c&l" + num + "..");
|
||||
break;
|
||||
default:
|
||||
itemBuilder.setDurability((short) 4);
|
||||
itemBuilder.setName("&e&l" + num + "..");
|
||||
}
|
||||
return itemBuilder.colorize().build();
|
||||
}
|
||||
|
||||
private String getEnabled(boolean enabled) {
|
||||
return enabled ? "&a&lENABLED" : "&c&lDISABLED";
|
||||
}
|
||||
|
||||
private void resetInventory(Player player) {
|
||||
DuelPlayer duelPlayer = DuelsAPI.getDuelPlayerByPlayer(player);
|
||||
assert duelPlayer != null;
|
||||
ItemStack[] itemStacks = Arrays.stream(player.getInventory().getContents())
|
||||
.filter(Objects::nonNull)
|
||||
.map(ItemStack::clone)
|
||||
.toArray(ItemStack[]::new);
|
||||
duelPlayer.setInitialInventory(itemStacks);
|
||||
duelPlayer.setHelmet(MiscUtils.defaultIfNull(player.getInventory().getHelmet(), new ItemStack(Material.AIR)).clone());
|
||||
duelPlayer.setChestplate(MiscUtils.defaultIfNull(player.getInventory().getChestplate(), new ItemStack(Material.AIR)).clone());
|
||||
duelPlayer.setLeggings(MiscUtils.defaultIfNull(player.getInventory().getLeggings(), new ItemStack(Material.AIR)).clone());
|
||||
duelPlayer.setBoots(MiscUtils.defaultIfNull(player.getInventory().getBoots(), new ItemStack(Material.AIR)).clone());
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package net.crankedpvp.duels.inventory;
|
||||
|
||||
import dev.triumphteam.gui.guis.Gui;
|
||||
import dev.triumphteam.gui.guis.GuiItem;
|
||||
import lombok.Getter;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.Clickable;
|
||||
import net.crankedpvp.crankedutils.utils.GuiUtil;
|
||||
import net.crankedpvp.crankedutils.utils.SoundUtils;
|
||||
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import net.crankedpvp.duels.struct.*;
|
||||
import org.bukkit.DyeColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.EnumMap;
|
||||
import java.util.List;
|
||||
|
||||
public class DuelSettingsUI {
|
||||
|
||||
private boolean forceClose = false;
|
||||
|
||||
private EnumMap<DuelSetting, Boolean> currentSettings;
|
||||
|
||||
@Getter
|
||||
private final Gui settingsUI;
|
||||
|
||||
public DuelSettingsUI(DuelTeam teamOne, DuelTeam teamTwo, EnumMap<DuelSetting, Boolean> currentSettings) {
|
||||
this.currentSettings = currentSettings;
|
||||
this.settingsUI = new Gui(3, "Duel Settings");
|
||||
this.settingsUI.setDefaultClickAction(event -> event.setCancelled(true));
|
||||
|
||||
/*
|
||||
this.settingsUI.setCloseGuiAction(inventoryCloseEvent -> {
|
||||
if(forceClose) return;
|
||||
});
|
||||
|
||||
*/
|
||||
|
||||
updateConfirmButton(teamOne, teamTwo);
|
||||
|
||||
for(DuelSetting duelSetting : DuelSetting.values()) {
|
||||
this.settingsUI.addItem(new GuiItem(buildSetting(duelSetting), event -> {
|
||||
this.currentSettings.put(duelSetting, !currentSettings.get(duelSetting));
|
||||
this.settingsUI.updateItem(event.getSlot(), buildSetting(duelSetting));
|
||||
updateConfirmButton(teamOne, teamTwo);
|
||||
SoundUtils.tryPlaySuccessSound(event.getWhoClicked());
|
||||
}));
|
||||
}
|
||||
this.settingsUI.getFiller().fill(new GuiItem(GuiUtil.createFillerItem()));
|
||||
}
|
||||
|
||||
private void updateConfirmButton(DuelTeam senderTeam, DuelTeam receiverTeam) {
|
||||
this.settingsUI.updateItem(3, 5, new GuiItem(createConfirmButton(), event -> {
|
||||
forceClose = true;
|
||||
event.getWhoClicked().closeInventory();
|
||||
SoundUtils.tryPlaySuccessSound(event.getWhoClicked());
|
||||
DuelArena duelArena = DuelsAPI.findOpenArena();
|
||||
if(duelArena == null) {
|
||||
senderTeam.getDuelTeamLeader().sendMessage(DuelManager.prefix + "&eYou cannot duel as there are no open arenas");
|
||||
return;
|
||||
}
|
||||
DuelMatch duelMatch = new DuelMatch(senderTeam, receiverTeam, this.currentSettings, duelArena, DuelStatus.INACTIVE);
|
||||
duelMatch.setDuelStatus(DuelStatus.SELECTING);
|
||||
DuelsPlugin.getInstance().getDuelManager().getDuelMatches().add(duelMatch);
|
||||
Clickable clickable = new Clickable(CC.translate(DuelManager.prefix + "&eThe player &7" + senderTeam.getDuelTeamLeader().getName() + " &ehas sent your team a duel request"),
|
||||
"&7Click &fhere &7to accept the duel",
|
||||
"/duel accept " + senderTeam.getDuelTeamLeader().getName());
|
||||
clickable.sendToPlayer(receiverTeam.getDuelTeamLeader());
|
||||
senderTeam.getDuelTeamLeader().sendMessage(CC.translate(DuelManager.prefix + "&eDuel request sent to " + receiverTeam.getDuelTeamLeader().getName() + "'s team"));
|
||||
senderTeam.getDuelTeamLeader().sendMessage(CC.translate(DuelManager.prefix + "&eThis duel request will expire in &730 seconds"));
|
||||
|
||||
DuelsPlugin.getInstance().getServer().getScheduler().runTaskLater(DuelsPlugin.getInstance(), () -> {
|
||||
if(duelMatch.getDuelStatus() == DuelStatus.INACTIVE) {
|
||||
DuelsPlugin.getInstance().getDuelManager().getDuelMatches().remove(duelMatch);
|
||||
duelMatch.getTeamOne().getDuelTeamLeader().sendMessage(CC.translate(DuelManager.prefix + "&cYour duel request to " + duelMatch.getTeamTwo().getDuelTeamLeader().getName() + " has expired"));
|
||||
duelMatch.getTeamTwo().getDuelTeamLeader().sendMessage(CC.translate(DuelManager.prefix + "&cThe incoming duel request from " + duelMatch.getTeamOne().getDuelTeamLeader().getName() + " has expired"));
|
||||
SoundUtils.tryPlayErrorSound(duelMatch.getTeamTwo().getDuelTeamLeader());
|
||||
SoundUtils.tryPlayErrorSound(duelMatch.getTeamOne().getDuelTeamLeader());
|
||||
}
|
||||
}, 20L * 30);
|
||||
}));
|
||||
}
|
||||
|
||||
private ItemStack createConfirmButton() {
|
||||
ItemBuilder itemBuilder = new ItemBuilder(Material.STAINED_GLASS_PANE, 1, DyeColor.LIME.getWoolData());
|
||||
itemBuilder.setName("&a&lConfirm Selection");
|
||||
List<String> lore = new ArrayList<>();
|
||||
this.currentSettings.forEach((key, value) -> lore.add("&4&l* &c" + key.getSettingName() + ": " + getEnabled(value)));
|
||||
itemBuilder.setLore(lore);
|
||||
return itemBuilder.colorize().build();
|
||||
}
|
||||
|
||||
private String getEnabled(boolean enabled) {
|
||||
return enabled ? "&a&lENABLED" : "&c&lDISABLED";
|
||||
}
|
||||
|
||||
private ItemStack buildSetting(DuelSetting duelSetting) {
|
||||
List<String> lore = new ArrayList<>();
|
||||
boolean enabled = this.currentSettings.get(duelSetting);
|
||||
for(String line : duelSetting.getDisplayLore()) {
|
||||
if(line.contains("{enabled}")) line = line.replace("{enabled}", getEnabled(enabled));
|
||||
lore.add(line);
|
||||
}
|
||||
ItemBuilder itemBuilder = new ItemBuilder(duelSetting.getDisplayMaterial(), duelSetting.getDisplayName(), lore);
|
||||
if(enabled) itemBuilder.setGlowing();
|
||||
return itemBuilder.colorize().build();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package net.crankedpvp.duels.listeners;
|
||||
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import net.crankedpvp.duels.struct.DuelPlayer;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.EventPriority;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.event.entity.EntityDamageByEntityEvent;
|
||||
|
||||
public class DamageListener implements Listener {
|
||||
|
||||
private DuelsPlugin plugin;
|
||||
public DamageListener(DuelsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGHEST)
|
||||
public void entityDamage(EntityDamageByEntityEvent event) {
|
||||
if(event.getEntity() == null) return;
|
||||
if(event.getDamager() == null) return;
|
||||
if(!(event.getEntity() instanceof Player)) return;
|
||||
if(!(event.getDamager() instanceof Player)) return;
|
||||
|
||||
Player entity = (Player) event.getEntity();
|
||||
Player damager = (Player) event.getDamager();
|
||||
|
||||
if(!DuelsAPI.isPlayerInDuel(entity)) return;
|
||||
if(!DuelsAPI.isPlayerInDuel(damager)) return;
|
||||
|
||||
DuelPlayer duelPlayerEntity = DuelsAPI.getDuelPlayerByPlayer(entity);
|
||||
DuelPlayer duelPlayerDamager = DuelsAPI.getDuelPlayerByPlayer(damager);
|
||||
|
||||
assert duelPlayerEntity != null;
|
||||
duelPlayerEntity.setDamageReceived(duelPlayerEntity.getDamageReceived() + event.getFinalDamage());
|
||||
duelPlayerEntity.setHitsReceived(duelPlayerEntity.getHitsReceived() + 1);
|
||||
|
||||
assert duelPlayerDamager != null;
|
||||
duelPlayerDamager.setDamageSent(duelPlayerDamager.getDamageSent() + event.getFinalDamage());
|
||||
duelPlayerDamager.setHitsSent(duelPlayerDamager.getHitsSent() + 1);
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.LOWEST)
|
||||
public void noTeamDamage(EntityDamageByEntityEvent event) {
|
||||
if(event.getEntity() == null) return;
|
||||
if(event.getDamager() == null) return;
|
||||
if(!(event.getEntity() instanceof Player)) return;
|
||||
if(!(event.getDamager() instanceof Player)) return;
|
||||
Player entity = (Player) event.getEntity();
|
||||
Player damager = (Player) event.getDamager();
|
||||
if(!DuelsAPI.isPlayerInDuel(entity)) return;
|
||||
if(!DuelsAPI.isPlayerInDuel(damager)) return;
|
||||
if(DuelsAPI.getDuelTeamByPlayer(entity) == DuelsAPI.getDuelTeamByPlayer(damager)) {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package net.crankedpvp.duels.listeners;
|
||||
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.EventPriority;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.event.entity.PlayerDeathEvent;
|
||||
|
||||
public class PlayerDeathListener implements Listener {
|
||||
|
||||
private final DuelsPlugin plugin;
|
||||
public PlayerDeathListener(DuelsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.LOWEST)
|
||||
public void deathEvent(PlayerDeathEvent event) {
|
||||
if(event.getEntity() == null) return;
|
||||
final Player player = event.getEntity();
|
||||
if(!DuelsAPI.isPlayerInDuel(player)) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(player).getDuelStatus().isActive()) return;
|
||||
event.getDrops().clear();
|
||||
this.plugin.getDuelPlayerHandler().handle(player);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package net.crankedpvp.duels.listeners;
|
||||
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.event.player.PlayerKickEvent;
|
||||
import org.bukkit.event.player.PlayerQuitEvent;
|
||||
|
||||
public class PlayerDisconnectListener implements Listener {
|
||||
|
||||
private DuelsPlugin plugin;
|
||||
public PlayerDisconnectListener(DuelsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void disconnectPlayer(PlayerQuitEvent event) {
|
||||
if(event.getPlayer() == null) return;
|
||||
Player player = event.getPlayer();
|
||||
if(!DuelsAPI.isPlayerInDuel(player)) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(player).getDuelStatus().isActive()) return;
|
||||
this.plugin.getDuelPlayerHandler().handle(player);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void kickPlayer(PlayerKickEvent event) {
|
||||
if(event.getPlayer() == null) return;
|
||||
Player player = event.getPlayer();
|
||||
if(!DuelsAPI.isPlayerInDuel(player)) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(player).getDuelStatus().isActive()) return;
|
||||
this.plugin.getDuelPlayerHandler().handle(player);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
package net.crankedpvp.duels.listeners;
|
||||
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.struct.DuelManager;
|
||||
import net.crankedpvp.duels.struct.DuelStatus;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Sound;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.EventPriority;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.event.block.BlockBreakEvent;
|
||||
import org.bukkit.event.block.BlockPlaceEvent;
|
||||
import org.bukkit.event.inventory.InventoryOpenEvent;
|
||||
import org.bukkit.event.player.*;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Locale;
|
||||
|
||||
public class PlayerListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onJoin(PlayerJoinEvent event) {
|
||||
if(event.getPlayer() == null) return;
|
||||
if(!event.getPlayer().getWorld().getName().contains("tournament")) return;
|
||||
event.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
|
||||
event.getPlayer().getInventory().setArmorContents(new ItemStack[4]);
|
||||
event.getPlayer().getInventory().clear();
|
||||
}
|
||||
|
||||
|
||||
@EventHandler
|
||||
public void onPickUpWhileInGame(PlayerPickupItemEvent event) {
|
||||
if (!DuelsAPI.isPlayerInDuel(event.getPlayer())) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(event.getPlayer()).getDuelStatus().isActive()) return;
|
||||
event.setCancelled(true);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onBlockPlaceWhileInGame(BlockPlaceEvent event) {
|
||||
if (!DuelsAPI.isParticipant(event.getPlayer())) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(event.getPlayer()).getDuelStatus().isActive()) return;
|
||||
event.setCancelled(true);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onBlockBreakWhileInGame(BlockBreakEvent event) {
|
||||
if (!DuelsAPI.isParticipant(event.getPlayer())) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(event.getPlayer()).getDuelStatus().isActive()) return;
|
||||
event.setCancelled(true);
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onDropWhileInGame(PlayerDropItemEvent event) {
|
||||
if (!DuelsAPI.isParticipant(event.getPlayer())) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer(event.getPlayer()).getDuelStatus().isActive()) return;
|
||||
event.setCancelled(true);
|
||||
}
|
||||
|
||||
|
||||
@EventHandler(priority = EventPriority.LOWEST)
|
||||
public void onCommandWhileInGame(PlayerCommandPreprocessEvent event) {
|
||||
if (!DuelsAPI.isParticipant(event.getPlayer())) return;
|
||||
if(DuelsAPI.getDuelMatchByPlayer(event.getPlayer()).getDuelStatus() != DuelStatus.ACTIVE) return;
|
||||
String command = event.getMessage().replace("/", "").toLowerCase(Locale.ROOT);
|
||||
|
||||
if (Arrays.stream(this.excludedBlockedCommands).noneMatch(command::startsWith)) {
|
||||
event.setCancelled(true);
|
||||
Player player = event.getPlayer();
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cYou cannot run /" + event.getMessage() + " while in a duel"));
|
||||
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 2.0f);
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onOpenInventory(InventoryOpenEvent event) {
|
||||
if(event.getPlayer() == null) return;
|
||||
if(event.getInventory() == null) return;
|
||||
if(event.getInventory() == event.getPlayer().getInventory()) return;
|
||||
if(!(event.getPlayer() instanceof Player)) return;
|
||||
if(!DuelsAPI.isParticipant((Player) event.getPlayer())) return;
|
||||
if(!DuelsAPI.getDuelMatchByPlayer((Player) event.getPlayer()).getDuelStatus().isActive()) return;
|
||||
event.setCancelled(true);
|
||||
event.getPlayer().sendMessage(CC.translate("&cYou cannot open external inventories while in a duel match"));
|
||||
}
|
||||
|
||||
private final String[] excludedBlockedCommands = {"f c", "bless", "feed", "msg", "r "};
|
||||
|
||||
@EventHandler
|
||||
public void teleport(PlayerTeleportEvent event) {
|
||||
if(DuelsAPI.isParticipant(event.getPlayer())) {
|
||||
if(!(event.getCause() == PlayerTeleportEvent.TeleportCause.ENDER_PEARL || event.getCause() == PlayerTeleportEvent.TeleportCause.PLUGIN)) {
|
||||
event.setCancelled(true);
|
||||
event.getPlayer().sendMessage(CC.translate(DuelManager.prefix + "&cYou cannot teleport during a duel match"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import net.crankedpvp.storageutils.StorageUtils;
|
||||
import net.crankedpvp.storageutils.struct.NewSaveLoadManager;
|
||||
import org.bukkit.plugin.java.JavaPlugin;
|
||||
|
||||
public class ArenaRegister extends NewSaveLoadManager<String, DuelArena> {
|
||||
public ArenaRegister(JavaPlugin plugin) {
|
||||
super(plugin, StorageUtils.getInstance().getGson(), "arenas", DuelArena.class);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String serialize(String string) {
|
||||
return string;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String deserialize(String string) {
|
||||
return string;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import net.crankedpvp.storageutils.struct.NewKeyToSave;
|
||||
import org.bukkit.Location;
|
||||
|
||||
@Getter @AllArgsConstructor @Setter
|
||||
public class DuelArena implements NewKeyToSave<String> {
|
||||
|
||||
private String arenaName;
|
||||
private Location spawnPointOne;
|
||||
private Location spawnPointTwo;
|
||||
private boolean active;
|
||||
|
||||
public DuelArena(String arenaName, Location spawnPointOne, Location spawnPointTwo) {
|
||||
this.arenaName = arenaName;
|
||||
this.spawnPointOne = spawnPointOne;
|
||||
this.spawnPointTwo = spawnPointTwo;
|
||||
this.active = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getKey() {
|
||||
return this.arenaName;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setKey(String name) {
|
||||
this.arenaName = name;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import lombok.Getter;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class DuelManager {
|
||||
|
||||
private final DuelsPlugin plugin;
|
||||
public DuelManager(DuelsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
this.duelMatches = new ArrayList<>();
|
||||
}
|
||||
|
||||
public static String prefix = "&e&lDuels &8➥ ";
|
||||
|
||||
@Getter
|
||||
private final List<DuelMatch> duelMatches;
|
||||
|
||||
public List<DuelMatch> getActiveDuelMatches() {
|
||||
return duelMatches.stream().filter(duelMatch -> duelMatch.getDuelStatus().isActive()).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public List<DuelMatch> getRequestedDuelMatches() {
|
||||
return duelMatches.stream().filter(duelMatch -> !duelMatch.getDuelStatus().isActive()).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public DuelMatch getDuelMatchFromTeam(DuelTeam duelTeam) {
|
||||
for(DuelMatch duelMatch : this.duelMatches) {
|
||||
if(duelMatch.getTeamTwo().getDuelTeamLeader() == duelTeam.getDuelTeamLeader()) return duelMatch;
|
||||
if(duelMatch.getTeamOne().getDuelTeamLeader() == duelTeam.getDuelTeamLeader()) return duelMatch;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean hasBeenDueled(DuelTeam duelTeam) {
|
||||
for(DuelMatch duelMatch : this.duelMatches) {
|
||||
if(duelMatch.getTeamTwo().getDuelTeamLeader() == duelTeam.getDuelTeamLeader()) return true;
|
||||
if(duelMatch.getTeamOne().getDuelTeamLeader() == duelTeam.getDuelTeamLeader()) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.EnumMap;
|
||||
import java.util.List;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
@Getter @AllArgsConstructor
|
||||
public class DuelMatch {
|
||||
|
||||
private DuelTeam teamOne;
|
||||
private DuelTeam teamTwo;
|
||||
private EnumMap<DuelSetting, Boolean> settings;
|
||||
private DuelArena duelArena;
|
||||
|
||||
@Setter
|
||||
private DuelStatus duelStatus;
|
||||
|
||||
public DuelTeam getSendingTeam() {
|
||||
return this.teamOne;
|
||||
}
|
||||
|
||||
public DuelTeam getReceivingTeam() {
|
||||
return this.teamTwo;
|
||||
}
|
||||
|
||||
public List<DuelPlayer> getAllDuelPlayers() {
|
||||
List<DuelPlayer> players = new ArrayList<>();
|
||||
players.addAll(this.teamOne.getDuelPlayersAsDuelPlayers());
|
||||
players.addAll(this.teamTwo.getDuelPlayersAsDuelPlayers());
|
||||
return players;
|
||||
}
|
||||
|
||||
public List<Player> getAllPlayers() {
|
||||
List<Player> players = new ArrayList<>();
|
||||
players.addAll(this.teamOne.getDuelPlayersAsPlayers());
|
||||
players.addAll(this.teamTwo.getDuelPlayersAsPlayers());
|
||||
return players;
|
||||
}
|
||||
|
||||
public void sendToAllPlayers(String message) {
|
||||
this.getAllPlayers().forEach(player -> player.sendMessage(CC.translate(message)));
|
||||
}
|
||||
|
||||
public boolean checkConditionOnMembers(Predicate<Player> condition) {
|
||||
for(Player player : this.getAllPlayers()) {
|
||||
if(!condition.test(player)) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.UUID;
|
||||
|
||||
@Getter @Setter
|
||||
public class DuelPlayer {
|
||||
|
||||
private UUID playerUUID;
|
||||
private boolean dead;
|
||||
|
||||
private ItemStack[] initialInventory;
|
||||
private ItemStack helmet;
|
||||
private ItemStack chestplate;
|
||||
private ItemStack leggings;
|
||||
private ItemStack boots;
|
||||
|
||||
private double damageReceived;
|
||||
private double damageSent;
|
||||
private int hitsReceived;
|
||||
private int hitsSent;
|
||||
|
||||
public DuelPlayer(UUID uuid, ItemStack[] initialInventory, ItemStack helmet, ItemStack chestplate, ItemStack leggings, ItemStack boots) {
|
||||
this.playerUUID = uuid;
|
||||
this.initialInventory = initialInventory;
|
||||
this.helmet = helmet;
|
||||
this.chestplate = chestplate;
|
||||
this.leggings = leggings;
|
||||
this.boots = boots;
|
||||
this.dead = false;
|
||||
|
||||
this.damageReceived = 0;
|
||||
this.damageSent = 0;
|
||||
this.hitsReceived = 0;
|
||||
this.hitsSent = 0;
|
||||
}
|
||||
|
||||
public double getAverageDamage() {
|
||||
return damageSent / hitsSent;
|
||||
}
|
||||
|
||||
public Player getPlayer() {
|
||||
return Bukkit.getPlayer(this.playerUUID);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import net.crankedpvp.collect.CollectPlugin;
|
||||
import net.crankedpvp.collect.struct.CollectCategory;
|
||||
import net.crankedpvp.collect.struct.CollectType;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.InventoryUtils;
|
||||
import net.crankedpvp.crankedutils.utils.SoundUtils;
|
||||
import net.crankedpvp.duels.DuelsAPI;
|
||||
import net.crankedpvp.duels.DuelsPlugin;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.HumanEntity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.text.DecimalFormat;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class DuelPlayerHandler {
|
||||
|
||||
private final DecimalFormat decimalFormat = new DecimalFormat("##.00");
|
||||
|
||||
private final DuelsPlugin plugin;
|
||||
public DuelPlayerHandler(DuelsPlugin plugin) {
|
||||
this.plugin = plugin;
|
||||
}
|
||||
|
||||
public void handle(Player player) {
|
||||
final DuelMatch duelMatch = DuelsAPI.getDuelMatchByPlayer(player);
|
||||
DuelsAPI.setPlayerDeadInDuel(player);
|
||||
|
||||
List<Player> winners = new ArrayList<>();
|
||||
List<Player> losers = new ArrayList<>();
|
||||
|
||||
if(duelMatch.getTeamOne().getRemainingPlayersAmount() <= 0 || duelMatch.getTeamTwo().getRemainingPlayersAmount() <= 0) {
|
||||
DuelTeam winningTeam = null;
|
||||
DuelTeam losingTeam = null;
|
||||
if(duelMatch.getTeamOne().getRemainingPlayersAmount() <= 0) {
|
||||
losers.addAll(duelMatch.getTeamOne().getDuelPlayersAsPlayers());
|
||||
winners.addAll(duelMatch.getTeamTwo().getDuelPlayersAsPlayers());
|
||||
winningTeam = duelMatch.getTeamTwo();
|
||||
losingTeam = duelMatch.getTeamOne();
|
||||
} else if(duelMatch.getTeamTwo().getRemainingPlayersAmount() <= 0) {
|
||||
winners.addAll(duelMatch.getTeamOne().getDuelPlayersAsPlayers());
|
||||
losers.addAll(duelMatch.getTeamTwo().getDuelPlayersAsPlayers());
|
||||
winningTeam = duelMatch.getTeamOne();
|
||||
losingTeam = duelMatch.getTeamTwo();
|
||||
}
|
||||
assert winningTeam != null;
|
||||
sendDuelEndMessage(winningTeam, losingTeam);
|
||||
winners.forEach(winningPlayer -> {
|
||||
this.finalise(winningPlayer);
|
||||
if(duelMatch.getSettings().get(DuelSetting.RISK_INVENTORY)) {
|
||||
winningPlayer.sendMessage(CC.translate(DuelManager.prefix + "&aYour team leader has received ALL duel rewards &7(/collect)"));
|
||||
} else {
|
||||
winningPlayer.sendMessage(CC.translate(DuelManager.prefix + "&aYour duel items have been stored in your /collect"));
|
||||
}
|
||||
giveOwnItemsBack(winningPlayer);
|
||||
});
|
||||
|
||||
if(duelMatch.getSettings().get(DuelSetting.RISK_INVENTORY)) {
|
||||
giveItemsToWinner(winningTeam.getDuelTeamLeader(), losingTeam);
|
||||
} else {
|
||||
losers.forEach(loser -> {
|
||||
this.giveOwnItemsBack(loser);
|
||||
loser.sendMessage(CC.translate(DuelManager.prefix + "&aYour duel items have been stored in your /collect"));
|
||||
});
|
||||
}
|
||||
duelMatch.setDuelStatus(DuelStatus.INACTIVE);
|
||||
this.plugin.getDuelManager().getDuelMatches().remove(duelMatch);
|
||||
}
|
||||
|
||||
this.finalise(player);
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cYou have been eliminated from the duel"));
|
||||
}
|
||||
|
||||
private void sendDuelEndMessage(DuelTeam winners, DuelTeam losers) {
|
||||
List<Player> players = new ArrayList<>();
|
||||
players.addAll(winners.getDuelPlayersAsPlayers());
|
||||
players.addAll(losers.getDuelPlayersAsPlayers());
|
||||
|
||||
Bukkit.broadcastMessage(CC.translate(DuelManager.prefix + "&4" + winners.getDuelTeamLeader().getName() + "'s &cTeam has beaten &4" + losers.getDuelTeamLeader().getName() + "'s &cteam in a duel"));
|
||||
|
||||
players.forEach(player -> {
|
||||
double overAllDmgWinners = 0;
|
||||
double overAllDmgLosers = 0;
|
||||
int overAllHitsWinners = 0;
|
||||
int overAllHitsLosers = 0;
|
||||
player.sendMessage(CC.translate("&4&lWinning Team &8➥ &c" + winners.getDuelPlayersAsPlayers().stream().map(HumanEntity::getName).collect(Collectors.joining(", "))));
|
||||
for(DuelPlayer duelPlayer : winners.getDuelPlayersAsDuelPlayers()) {
|
||||
overAllDmgWinners += duelPlayer.getDamageSent();
|
||||
overAllHitsWinners += duelPlayer.getHitsSent();
|
||||
}
|
||||
player.sendMessage(CC.translate("&cOutgoing Hits: &f" + this.decimalFormat.format(overAllHitsWinners)));
|
||||
player.sendMessage(CC.translate("&cOutgoing Damage: &f" + this.decimalFormat.format(overAllDmgWinners)));
|
||||
player.sendMessage("");
|
||||
player.sendMessage(CC.translate("&4&lLosing Team &8➥ &c" + losers.getDuelPlayersAsPlayers().stream().map(HumanEntity::getName).collect(Collectors.joining(", "))));
|
||||
for(DuelPlayer duelPlayer : losers.getDuelPlayersAsDuelPlayers()) {
|
||||
overAllDmgLosers += duelPlayer.getDamageSent();
|
||||
overAllHitsLosers += duelPlayer.getHitsSent();
|
||||
}
|
||||
player.sendMessage(CC.translate("&cOutgoing Hits: &f" + this.decimalFormat.format(overAllHitsLosers)));
|
||||
player.sendMessage(CC.translate("&cOutgoing Damage: &f" + this.decimalFormat.format(overAllDmgLosers)));
|
||||
});
|
||||
}
|
||||
|
||||
private void finalise(Player player) {
|
||||
player.teleport(Bukkit.getWorld("world").getSpawnLocation());
|
||||
InventoryUtils.clearInventory(player);
|
||||
SoundUtils.tryPlayErrorSound(player);
|
||||
}
|
||||
|
||||
private void giveItemsToWinner(Player player, DuelTeam losingTeam) {
|
||||
List<ItemStack> items = DuelsAPI.getItemsFromTeam(losingTeam);
|
||||
if(items.size() == 0) return;
|
||||
CollectPlugin.getInstance().getCollectManager().getOrCreate(player.getUniqueId().toString()).add(new CollectCategory(CollectType.DUEL, items.toArray(new ItemStack[items.size() - 1]), CC.RedB + losingTeam.getDuelTeamLeader().getName() + "'s Duel Teams Items", System.currentTimeMillis()));
|
||||
}
|
||||
|
||||
private void giveOwnItemsBack(Player player) {
|
||||
List<ItemStack> items = DuelsAPI.getItemsFromPlayer(Objects.requireNonNull(DuelsAPI.getDuelPlayerByPlayer(player)));
|
||||
if(items.size() == 0) return;
|
||||
CollectPlugin.getInstance().getCollectManager().getOrCreate(player.getUniqueId().toString()).add(new CollectCategory(CollectType.DUEL, items.toArray(new ItemStack[items.size() - 1]), CC.RedB + "Your duel items", System.currentTimeMillis()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import lombok.Getter;
|
||||
import org.bukkit.Material;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
@Getter @AllArgsConstructor
|
||||
public enum DuelSetting {
|
||||
|
||||
RISK_INVENTORY("Risk Inventory", Material.PAPER, "&b&lRisk Inventory", Arrays.asList("&7Should your inventory be at", "&7risk in this duel?", "", "{enabled}"), false),
|
||||
ENDER_PEARLS("Ender Pearls", Material.ENDER_PEARL, "&5&lEnder Pearls", Arrays.asList("&7Should ender pearls be", "&7allowed in this duel?", "", "{enabled}"), true),
|
||||
GOLDEN_APPLES("Golden Apples", Material.GOLDEN_APPLE, "&e&lGolden Apples", Arrays.asList("&7Should golden apples be", "&7allowed in this duel?", "", "{enabled}"), true),
|
||||
DEATH_CERTIFICATES("Death Certificates", Material.PAPER, "&c&lDeath Certificates", Arrays.asList("&7Should the winner receive", "&7a death certificate from the", "&7loser in this duel?", "", "{enabled}"), true),
|
||||
POTIONS("Potions", Material.POTION, "&a&lPotions", Arrays.asList("&7Should potions be allowed", "&7in this duel?", "", "{enabled}"), true),
|
||||
FIX("Fix", Material.GOLD_HELMET, "&d&lFix", Arrays.asList("&7Should players be allowed to", "&7/fix their armor during the duel?", "", "{enabled}"), true),
|
||||
PETS("Pets", Material.SKULL_ITEM, "&e&lPets", Arrays.asList("&7Should players be allowed to", "&7bring inventory pets to the duel", "", "{enabled}"), true),
|
||||
FLY("Fly", Material.FEATHER, "&b&lFly", Arrays.asList("&7Should players be allowed to", "&7fly during the duel", "", "{enabled}"), false),
|
||||
FOOD_LOSS("Food Loss", Material.COOKED_BEEF, "&e&lFood Loss", Arrays.asList("&7Should players lose hunger", "&7during the duel?", "", "{enabled}"), false),
|
||||
HEALING("Healing", Material.GHAST_TEAR, "&c&lHealing", Arrays.asList("&7Should players be able to", "&7heal during the duel?", "", "{enabled}"), true),
|
||||
SOUL_GEMS("Soul Gems", Material.EMERALD, "&c&lSoul Gems", Arrays.asList("&7Should players be able to use", "&7soul gems during the duel?", "", "{enabled}"), true),
|
||||
BOWS("Bows", Material.BOW, "&6&lBows", Arrays.asList("&7Should players be able to use", "&7bows during the duel?", "", "{enabled}"), true),
|
||||
ARMOR("Armor", Material.DIAMOND_CHESTPLATE, "&b&lArmor", Arrays.asList("&7Should players be able to use", "&7armor during the duel?", "", "{enabled}"), true),
|
||||
WEAPONS("Weapons", Material.DIAMOND_SWORD, "&b&lWeapons", Arrays.asList("&7Should players be able to use", "&7weapons during the duel?", "", "{enabled}"), true),
|
||||
;
|
||||
|
||||
private final String settingName;
|
||||
private final Material displayMaterial;
|
||||
private final String displayName;
|
||||
private final List<String> displayLore;
|
||||
private final boolean defaultSetting;
|
||||
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
public enum DuelStatus {
|
||||
ACTIVE, SELECTING, CONFIRMING, INACTIVE, CANCELLED;
|
||||
|
||||
public boolean isActive() {
|
||||
return this == ACTIVE;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package net.crankedpvp.duels.struct;
|
||||
|
||||
import lombok.AllArgsConstructor;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
@AllArgsConstructor
|
||||
public class DuelTeam {
|
||||
|
||||
private DuelPlayer duelLeader;
|
||||
private List<DuelPlayer> duelTeamMembers;
|
||||
|
||||
public List<DuelPlayer> getDuelPlayersAsDuelPlayers() {
|
||||
List<DuelPlayer> players = this.duelTeamMembers.size() > 0 ? new ArrayList<>(this.duelTeamMembers) : new ArrayList<>();
|
||||
players.add(duelLeader);
|
||||
return players;
|
||||
}
|
||||
|
||||
public int getAmountOfPlayers() {
|
||||
return this.getDuelPlayersAsDuelPlayers().size();
|
||||
}
|
||||
|
||||
public Player getDuelTeamLeader() {
|
||||
return Bukkit.getPlayer(this.duelLeader.getPlayerUUID());
|
||||
}
|
||||
|
||||
public List<Player> getDuelPlayersAsPlayers() {
|
||||
return getDuelPlayersAsDuelPlayers().stream().map(duelPlayer -> Bukkit.getPlayer(duelPlayer.getPlayerUUID())).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public List<UUID> getDuelPlayersAsPlayerUUIDs() {
|
||||
return getDuelPlayersAsDuelPlayers().stream().map(DuelPlayer::getPlayerUUID).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
public int getRemainingPlayersAmount() {
|
||||
return (int) getDuelPlayersAsDuelPlayers().stream().filter(duelPlayer -> !duelPlayer.isDead()).count();
|
||||
}
|
||||
|
||||
public DuelPlayer getDuelPlayerFromPlayer(Player player) {
|
||||
for(DuelPlayer duelPlayer : getDuelPlayersAsDuelPlayers()) {
|
||||
if(duelPlayer.getPlayerUUID().equals(player.getUniqueId())) return duelPlayer;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public boolean checkConditionOnMembers(Predicate<Player> condition) {
|
||||
for(Player player : this.getDuelPlayersAsPlayers()) {
|
||||
if(!condition.test(player)) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package net.crankedpvp.duels.utils;
|
||||
|
||||
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
|
||||
import net.crankedpvp.crankedpets.CrankedPetsAPI;
|
||||
import net.crankedpvp.crankedutils.utils.CC;
|
||||
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
|
||||
import net.crankedpvp.duels.struct.DuelManager;
|
||||
import net.crankedpvp.duels.struct.DuelSetting;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
import java.util.EnumMap;
|
||||
|
||||
public class InventorySettings {
|
||||
|
||||
public static void applyInventorySettings(Player player, EnumMap<DuelSetting, Boolean> currentSettings) {
|
||||
if(!currentSettings.get(DuelSetting.POTIONS))
|
||||
checkPotions(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.ENDER_PEARLS))
|
||||
checkEnderPearls(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.GOLDEN_APPLES))
|
||||
checkGoldenApples(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.BOWS))
|
||||
checkBows(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.PETS))
|
||||
checkPets(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.SOUL_GEMS))
|
||||
checkSoulGems(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.ARMOR))
|
||||
checkArmor(player);
|
||||
|
||||
if(!currentSettings.get(DuelSetting.WEAPONS))
|
||||
checkWeapons(player);
|
||||
}
|
||||
|
||||
private static void checkPotions(Player player) {
|
||||
if(!player.getInventory().contains(Material.POTION)) return;
|
||||
player.getInventory().remove(Material.POTION);
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cPotion(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkEnderPearls(Player player) {
|
||||
if(!player.getInventory().contains(Material.ENDER_PEARL)) return;
|
||||
player.getInventory().remove(Material.ENDER_PEARL);
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cEnder Pearl(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkGoldenApples(Player player) {
|
||||
if(!player.getInventory().contains(Material.GOLDEN_APPLE)) return;
|
||||
player.getInventory().remove(Material.GOLDEN_APPLE);
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cGolden Apple(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkPets(Player player) {
|
||||
if(!player.getInventory().contains(Material.SKULL_ITEM)) return;
|
||||
for(int i = 0; i < player.getInventory().getContents().length; i++) {
|
||||
ItemStack itemStack = player.getInventory().getItem(i);
|
||||
if(itemStack.getType() == Material.SKULL_ITEM) {
|
||||
if(CrankedPetsAPI.isPet(itemStack)) player.getInventory().remove(itemStack);
|
||||
}
|
||||
}
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cPet(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkArmor(Player player) {
|
||||
boolean msg = false;
|
||||
for(int i = 0; i < player.getInventory().getContents().length; i++) {
|
||||
ItemStack itemStack = player.getInventory().getItem(i);
|
||||
if(ItemUtils.isArmor(itemStack)) {
|
||||
msg = true;
|
||||
player.getInventory().remove(itemStack);
|
||||
}
|
||||
}
|
||||
if(msg) player.sendMessage(CC.translate(DuelManager.prefix + "&cArmor has been removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkWeapons(Player player) {
|
||||
boolean msg = false;
|
||||
for(int i = 0; i < player.getInventory().getContents().length; i++) {
|
||||
ItemStack itemStack = player.getInventory().getItem(i);
|
||||
if(ItemUtils.isWeapon(itemStack)) {
|
||||
msg = true;
|
||||
player.getInventory().remove(itemStack);
|
||||
}
|
||||
}
|
||||
if(msg) player.sendMessage(CC.translate(DuelManager.prefix + "&cWeapon(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkSoulGems(Player player) {
|
||||
if(!player.getInventory().contains(Material.EMERALD)) return;
|
||||
for(int i = 0; i < player.getInventory().getContents().length; i++) {
|
||||
ItemStack itemStack = player.getInventory().getItem(i);
|
||||
if(itemStack.getType() == Material.EMERALD) {
|
||||
if(CrankedEnchantsAPI.isSoulGem(itemStack)) player.getInventory().remove(itemStack);
|
||||
}
|
||||
}
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cSoul Gem(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
|
||||
private static void checkBows(Player player) {
|
||||
if(!player.getInventory().contains(Material.BOW)) return;
|
||||
player.getInventory().remove(Material.BOW);
|
||||
player.sendMessage(CC.translate(DuelManager.prefix + "&cBow(s) were removed from your inventory due to duel settings"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
name: CrankedDuels
|
||||
main: net.crankedpvp.duels.DuelsPlugin
|
||||
version: ${git.total.commit.count}.0
|
||||
description: "§fCommit ID: §a${git.commit.id.abbrev}"
|
||||
website: https://crankedpvp.net/
|
||||
depend:
|
||||
- CrankedUtils
|
||||
- CrankedCollect
|
||||
- StorageUtil
|
||||
- CrankedPets
|
||||
- CrankedEnchants
|
||||
|
||||
Reference in New Issue
Block a user