501 lines
25 KiB
Java
501 lines
25 KiB
Java
package rip.tilly.bedwars.managers;
|
|
|
|
import lombok.Getter;
|
|
import org.bukkit.Color;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.enchantments.Enchantment;
|
|
import org.bukkit.entity.Item;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.potion.PotionEffect;
|
|
import org.bukkit.potion.PotionEffectType;
|
|
import rip.tilly.bedwars.BedWars;
|
|
import rip.tilly.bedwars.game.*;
|
|
import rip.tilly.bedwars.game.arena.Arena;
|
|
import rip.tilly.bedwars.events.GameEndEvent;
|
|
import rip.tilly.bedwars.events.GameStartEvent;
|
|
import rip.tilly.bedwars.managers.hotbar.impl.HotbarItem;
|
|
import rip.tilly.bedwars.playerdata.currentgame.PlayerCurrentGameData;
|
|
import rip.tilly.bedwars.playerdata.PlayerData;
|
|
import rip.tilly.bedwars.playerdata.PlayerState;
|
|
import rip.tilly.bedwars.playerdata.currentgame.TeamUpgrades;
|
|
import rip.tilly.bedwars.utils.ItemBuilder;
|
|
import rip.tilly.bedwars.utils.ItemUtil;
|
|
import rip.tilly.bedwars.utils.PlayerUtil;
|
|
import rip.tilly.bedwars.utils.TtlHashMap;
|
|
|
|
import java.util.*;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
public class GameManager {
|
|
|
|
private final BedWars plugin = BedWars.getInstance();
|
|
|
|
private final Map<UUID, Set<GameRequest>> gameRequests = new TtlHashMap<>(TimeUnit.SECONDS, 30);
|
|
private final Map<UUID, UUID> spectators = new ConcurrentHashMap<>();
|
|
@Getter private final Map<UUID, Game> games = new ConcurrentHashMap<>();
|
|
|
|
public int getPlaying() {
|
|
int i = 0;
|
|
for (Game game : this.games.values()) {
|
|
for (GameTeam team : game.getTeams()) {
|
|
i += team.getPlayingPlayers().size();
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public int getPlayingByType(GameType gameType) {
|
|
int i = 0;
|
|
for (Game game : this.games.values()) {
|
|
if (game.getGameType() == gameType) {
|
|
for (GameTeam teams : game.getTeams()) {
|
|
i += teams.getPlayingPlayers().size();
|
|
}
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
public Game getGame(PlayerData playerData) {
|
|
return this.games.get(playerData.getCurrentGameId());
|
|
}
|
|
|
|
public Game getGame(UUID uuid) {
|
|
return this.getGame(this.plugin.getPlayerDataManager().getPlayerData(uuid));
|
|
}
|
|
|
|
public Game getGameFromUUID(UUID uuid) {
|
|
return this.games.get(uuid);
|
|
}
|
|
|
|
public void createGameRequest(Player requester, Player requested, Arena arena, boolean party) {
|
|
GameRequest request = new GameRequest(requester.getUniqueId(), requested.getUniqueId(), arena, party);
|
|
this.gameRequests.computeIfAbsent(requested.getUniqueId(), k -> new HashSet<>()).add(request);
|
|
}
|
|
|
|
public GameRequest getGameRequest(UUID requester, UUID requested) {
|
|
Set<GameRequest> requests = this.gameRequests.get(requested);
|
|
if (requests == null) {
|
|
return null;
|
|
}
|
|
|
|
return requests.stream().filter(req -> req.getRequester().equals(requester)).findAny().orElse(null);
|
|
}
|
|
|
|
public void removeGameRequests(UUID uuid) {
|
|
this.gameRequests.remove(uuid);
|
|
}
|
|
|
|
public void createGame(Game game) {
|
|
this.games.put(game.getGameId(), game);
|
|
this.plugin.getServer().getPluginManager().callEvent(new GameStartEvent(game));
|
|
}
|
|
|
|
public void removeGame(Game game) {
|
|
this.games.remove(game.getGameId());
|
|
}
|
|
|
|
public void addDroppedItem(Game game, Item item) {
|
|
game.addEntityToRemove(item);
|
|
game.addRunnable(this.plugin.getServer().getScheduler().runTaskLater(this.plugin, () -> {
|
|
game.removeEntityToRemove(item);
|
|
item.remove();
|
|
}, 100L).getTaskId());
|
|
}
|
|
|
|
public void addDroppedItems(Game game, Set<Item> items) {
|
|
for (Item item : items) {
|
|
game.addEntityToRemove(item);
|
|
}
|
|
game.addRunnable(this.plugin.getServer().getScheduler().runTaskLater(this.plugin, () -> {
|
|
for (Item item : items) {
|
|
game.removeEntityToRemove(item);
|
|
item.remove();
|
|
}
|
|
}, 100L).getTaskId());
|
|
}
|
|
|
|
public Game getSpectatingGame(UUID uuid) {
|
|
return this.games.get(this.spectators.get(uuid));
|
|
}
|
|
|
|
public void removePlayerFromGame(Player player, PlayerData playerData, boolean spectatorDeath) {
|
|
Game game = this.games.get(playerData.getCurrentGameId());
|
|
Player killer = playerData.getLastDamager();
|
|
|
|
if (player.isOnline() && killer != null) {
|
|
killer.hidePlayer(player);
|
|
}
|
|
|
|
GameTeam losingTeam = game.getTeams().get(playerData.getTeamId());
|
|
GameTeam winningTeam = game.getTeams().get(losingTeam.getId() == 0 ? 1 : 0);
|
|
|
|
if (killer != null) {
|
|
game.broadcast(losingTeam.getPlayerTeam().getChatColor() + player.getName() + " &ehas been killed by " + winningTeam.getPlayerTeam().getChatColor() + killer.getName() + "&e! &b&lFINAL KILL!");
|
|
PlayerData killerData = this.plugin.getPlayerDataManager().getPlayerData(killer.getUniqueId());
|
|
killerData.setKills(killerData.getKills() + 1);
|
|
} else {
|
|
game.broadcast(losingTeam.getPlayerTeam().getChatColor() + player.getName() + " &ehas died! &b&lFINAL KILL!");
|
|
}
|
|
|
|
playerData.setDeaths(playerData.getDeaths() + 1);
|
|
|
|
losingTeam.killPlayer(player.getUniqueId());
|
|
|
|
if (spectatorDeath) {
|
|
this.addSpectatorDeath(player, playerData, game);
|
|
}
|
|
|
|
int remaining = losingTeam.getPlayingPlayers().size();
|
|
if (remaining == 0) {
|
|
this.plugin.getServer().getPluginManager().callEvent(new GameEndEvent(game, winningTeam, losingTeam));
|
|
}
|
|
}
|
|
|
|
private void addSpectatorDeath(Player player, PlayerData playerData, Game game) {
|
|
this.spectators.put(player.getUniqueId(), game.getGameId());
|
|
playerData.setPlayerState(PlayerState.SPECTATING);
|
|
PlayerUtil.clearPlayer(player);
|
|
game.addSpectator(player.getUniqueId());
|
|
game.addRunnable(this.plugin.getServer().getScheduler().scheduleSyncDelayedTask(this.plugin, () -> {
|
|
game.getTeams().forEach(team -> team.playingPlayers().forEach(member -> member.hidePlayer(player)));
|
|
game.spectatorPlayers().forEach(spectator -> spectator.hidePlayer(player));
|
|
player.getActivePotionEffects().stream().map(PotionEffect::getType).forEach(player::removePotionEffect);
|
|
player.setWalkSpeed(0.2F);
|
|
player.setFlySpeed(0.4F);
|
|
player.setAllowFlight(true);
|
|
}, 20L));
|
|
|
|
player.setWalkSpeed(0.0F);
|
|
player.addPotionEffect(new PotionEffect(PotionEffectType.JUMP, 10000, -5));
|
|
|
|
this.plugin.getHotbarManager().getSpectatorItems().stream().filter(HotbarItem::isEnabled).forEach(item -> player.getInventory().setItem(item.getSlot(), item.getItemStack()));
|
|
player.updateInventory();
|
|
}
|
|
|
|
public void addSpectator(Player player, PlayerData playerData, Player target, Game targetGame) {
|
|
this.spectators.put(player.getUniqueId(), targetGame.getGameId());
|
|
|
|
if (targetGame.getGameState() != GameState.ENDING) {
|
|
targetGame.broadcast("&d" + player.getName() + " &eis now spectating!");
|
|
}
|
|
|
|
targetGame.addSpectator(player.getUniqueId());
|
|
playerData.setPlayerState(PlayerState.SPECTATING);
|
|
|
|
player.teleport(target);
|
|
player.setAllowFlight(true);
|
|
player.setFlying(true);
|
|
|
|
player.getInventory().clear();
|
|
this.plugin.getHotbarManager().getSpectatorItems().stream().filter(HotbarItem::isEnabled).forEach(item -> player.getInventory().setItem(item.getSlot(), item.getItemStack()));
|
|
player.updateInventory();
|
|
|
|
this.plugin.getServer().getOnlinePlayers().forEach(online -> {
|
|
online.hidePlayer(player);
|
|
player.hidePlayer(online);
|
|
});
|
|
|
|
targetGame.getTeams().forEach(team -> team.playingPlayers().forEach(player::showPlayer));
|
|
}
|
|
|
|
public void removeSpectator(Player player) {
|
|
Game game = this.games.get(this.spectators.get(player.getUniqueId()));
|
|
game.removeSpectator(player.getUniqueId());
|
|
|
|
if (game.getGameState() != GameState.ENDING) {
|
|
game.broadcast("&d" + player.getName() + " &eis no longer spectating!");
|
|
}
|
|
|
|
this.spectators.remove(player.getUniqueId());
|
|
this.plugin.getPlayerDataManager().resetPlayer(player, true);
|
|
}
|
|
|
|
public List<ItemStack> getGameItems(PlayerCurrentGameData currentGameData, TeamUpgrades teamUpgrades) {
|
|
List<ItemStack> allItems = new ArrayList<>();
|
|
|
|
ItemStack sword = new ItemBuilder(Material.WOOD_SWORD).addUnbreakable().build();
|
|
if (teamUpgrades.isSharpenedSwords()) {
|
|
sword = new ItemBuilder(Material.WOOD_SWORD).enchantment(Enchantment.DAMAGE_ALL, 1).addUnbreakable().build();
|
|
}
|
|
allItems.add(sword);
|
|
|
|
if (currentGameData.isShears()) {
|
|
ItemStack shears = new ItemBuilder(Material.SHEARS).addUnbreakable().build();
|
|
allItems.add(shears);
|
|
}
|
|
|
|
ItemStack axe = null;
|
|
if (currentGameData.getAxeLevel() > 0) {
|
|
switch (currentGameData.getAxeLevel()) {
|
|
case 1:
|
|
axe = new ItemBuilder(Material.WOOD_AXE).enchantment(Enchantment.DIG_SPEED, 1).addUnbreakable().build();
|
|
break;
|
|
case 2:
|
|
axe = new ItemBuilder(Material.STONE_AXE).enchantment(Enchantment.DIG_SPEED, 1).addUnbreakable().build();
|
|
break;
|
|
case 3:
|
|
axe = new ItemBuilder(Material.IRON_AXE).enchantment(Enchantment.DIG_SPEED, 2).addUnbreakable().build();
|
|
break;
|
|
case 4:
|
|
axe = new ItemBuilder(Material.DIAMOND_AXE).enchantment(Enchantment.DIG_SPEED, 3).addUnbreakable().build();
|
|
break;
|
|
default:
|
|
axe = null;
|
|
break;
|
|
}
|
|
}
|
|
if (axe != null) {
|
|
allItems.add(axe);
|
|
}
|
|
|
|
ItemStack pickaxe = null;
|
|
if (currentGameData.getPickaxeLevel() > 0) {
|
|
switch (currentGameData.getPickaxeLevel()) {
|
|
case 1:
|
|
pickaxe = new ItemBuilder(Material.WOOD_PICKAXE).enchantment(Enchantment.DIG_SPEED, 1).addUnbreakable().build();
|
|
break;
|
|
case 2:
|
|
pickaxe = new ItemBuilder(Material.IRON_PICKAXE).enchantment(Enchantment.DIG_SPEED, 2).addUnbreakable().build();
|
|
break;
|
|
case 3:
|
|
pickaxe = new ItemBuilder(Material.GOLD_PICKAXE).enchantment(Enchantment.DIG_SPEED, 3).enchantment(Enchantment.DAMAGE_ALL, 2).addUnbreakable().build();
|
|
break;
|
|
case 4:
|
|
pickaxe = new ItemBuilder(Material.DIAMOND_PICKAXE).enchantment(Enchantment.DIG_SPEED, 3).addUnbreakable().build();
|
|
break;
|
|
default:
|
|
pickaxe = null;
|
|
break;
|
|
}
|
|
}
|
|
if (pickaxe != null) {
|
|
allItems.add(pickaxe);
|
|
}
|
|
|
|
return allItems;
|
|
}
|
|
|
|
public ItemStack[] getGameArmor(PlayerData playerData, TeamUpgrades teamUpgrades) {
|
|
Color color = playerData.getPlayerTeam().getColor();
|
|
PlayerCurrentGameData currentGameData = playerData.getCurrentGameData();
|
|
|
|
ItemStack leatherBoots = new ItemBuilder(Material.LEATHER_BOOTS).color(color).addUnbreakable().build();
|
|
ItemStack leatherLeggings = new ItemBuilder(Material.LEATHER_LEGGINGS).color(color).addUnbreakable().build();
|
|
ItemStack leatherChestplate = new ItemBuilder(Material.LEATHER_CHESTPLATE).color(color).addUnbreakable().build();
|
|
ItemStack leatherHelmet = new ItemBuilder(Material.LEATHER_HELMET).color(color).addUnbreakable().build();
|
|
ItemStack chainBoots = new ItemBuilder(Material.CHAINMAIL_BOOTS).addUnbreakable().build();
|
|
ItemStack chainLeggings = new ItemBuilder(Material.CHAINMAIL_LEGGINGS).addUnbreakable().build();
|
|
ItemStack ironBoots = new ItemBuilder(Material.IRON_BOOTS).addUnbreakable().build();
|
|
ItemStack ironLeggings = new ItemBuilder(Material.IRON_LEGGINGS).addUnbreakable().build();
|
|
ItemStack diamondBoots = new ItemBuilder(Material.DIAMOND_BOOTS).addUnbreakable().build();
|
|
ItemStack diamondLeggings = new ItemBuilder(Material.DIAMOND_LEGGINGS).addUnbreakable().build();
|
|
|
|
switch (teamUpgrades.getArmorLevel()) {
|
|
case 0:
|
|
switch (currentGameData.getArmorType()) {
|
|
case LEATHER:
|
|
return new ItemStack[]{
|
|
leatherBoots,
|
|
leatherLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
case CHAIN:
|
|
return new ItemStack[]{
|
|
chainBoots,
|
|
chainLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
case IRON:
|
|
return new ItemStack[]{
|
|
ironBoots,
|
|
ironLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
case DIAMOND:
|
|
return new ItemStack[]{
|
|
diamondBoots,
|
|
diamondLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
}
|
|
break;
|
|
case 1:
|
|
switch (currentGameData.getArmorType()) {
|
|
case LEATHER:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(leatherBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
};
|
|
case CHAIN:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(chainBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(chainLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
};
|
|
case IRON:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(ironBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(ironLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
};
|
|
case DIAMOND:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(diamondBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(diamondLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 1, true),
|
|
};
|
|
}
|
|
break;
|
|
case 2:
|
|
switch (currentGameData.getArmorType()) {
|
|
case LEATHER:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(leatherBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
};
|
|
case CHAIN:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(chainBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(chainLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
};
|
|
case IRON:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(ironBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(ironLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
};
|
|
case DIAMOND:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(diamondBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(diamondLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 2, true),
|
|
};
|
|
}
|
|
break;
|
|
case 3:
|
|
switch (currentGameData.getArmorType()) {
|
|
case LEATHER:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(leatherBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
};
|
|
case CHAIN:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(chainBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(chainLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
};
|
|
case IRON:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(ironBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(ironLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
};
|
|
case DIAMOND:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(diamondBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(diamondLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 3, true),
|
|
};
|
|
}
|
|
break;
|
|
case 4:
|
|
switch (currentGameData.getArmorType()) {
|
|
case LEATHER:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(leatherBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
};
|
|
case CHAIN:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(chainBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(chainLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
};
|
|
case IRON:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(ironBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(ironLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
};
|
|
case DIAMOND:
|
|
return new ItemStack[]{
|
|
ItemUtil.reEnchantItem(diamondBoots, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(diamondLeggings, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherChestplate, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
ItemUtil.reEnchantItem(leatherHelmet, Enchantment.PROTECTION_ENVIRONMENTAL, 4, true),
|
|
};
|
|
}
|
|
break;
|
|
default:
|
|
switch (currentGameData.getArmorType()) {
|
|
case LEATHER:
|
|
return new ItemStack[]{
|
|
leatherBoots,
|
|
leatherLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
case CHAIN:
|
|
return new ItemStack[]{
|
|
chainBoots,
|
|
chainLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
case IRON:
|
|
return new ItemStack[]{
|
|
ironBoots,
|
|
ironLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
case DIAMOND:
|
|
return new ItemStack[]{
|
|
diamondBoots,
|
|
diamondLeggings,
|
|
leatherChestplate,
|
|
leatherHelmet
|
|
};
|
|
}
|
|
break;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void clearBlocks(Game game) {
|
|
game.getPlacedBlocksLocations().forEach(location -> {
|
|
location.getBlock().setType(Material.AIR);
|
|
game.removePlacedBlock(location.getBlock());
|
|
});
|
|
}
|
|
}
|