From f28a9d0503864a90aaa1f274bb499580438fb3bd Mon Sep 17 00:00:00 2001 From: Barazok Date: Sun, 25 Oct 2020 19:08:43 +0100 Subject: [PATCH] Add Beast Master and make an overall improvement for all the mod --- .../java/net/babamod/mineclass/Mineclass.java | 4 +- .../mineclass/classes/BeastMasterClass.java | 85 ++++++ .../mineclass/classes/FireDwarfClass.java | 2 - .../mineclass/classes/MineClassFactory.java | 20 +- .../mineclass/classes/MineClassImpl.java | 3 +- .../mineclass/commands/CommandClass.java | 35 ++- .../listeners/MineClassListeners.java | 247 ++++++++++++++++-- .../mineclass/utils/AppliedStatus.java | 56 ---- .../mineclass/utils/InvocationsFinder.java | 58 ++++ .../mineclass/utils/NumberOfInvocations.java | 48 ++++ 10 files changed, 461 insertions(+), 97 deletions(-) create mode 100644 src/main/java/net/babamod/mineclass/classes/BeastMasterClass.java delete mode 100644 src/main/java/net/babamod/mineclass/utils/AppliedStatus.java create mode 100644 src/main/java/net/babamod/mineclass/utils/InvocationsFinder.java create mode 100644 src/main/java/net/babamod/mineclass/utils/NumberOfInvocations.java diff --git a/src/main/java/net/babamod/mineclass/Mineclass.java b/src/main/java/net/babamod/mineclass/Mineclass.java index daa4f19..4526950 100644 --- a/src/main/java/net/babamod/mineclass/Mineclass.java +++ b/src/main/java/net/babamod/mineclass/Mineclass.java @@ -3,7 +3,6 @@ package net.babamod.mineclass; import net.babamod.mineclass.classes.MineClassFactory; import net.babamod.mineclass.commands.CommandClass; import net.babamod.mineclass.listeners.MineClassListeners; -import net.babamod.mineclass.utils.AppliedStatus; import org.bukkit.Bukkit; import org.bukkit.command.PluginCommand; import org.bukkit.event.Listener; @@ -16,13 +15,12 @@ public final class Mineclass extends JavaPlugin implements Listener { @Override public void onEnable() { - AppliedStatus.getInstance(); new MineClassListeners(this); PluginCommand pluginCommand = this.getCommand("class"); if (pluginCommand != null) { List arguments = new ArrayList<>(MineClassFactory.getInstance().getAvailableClassCodes()); - arguments.add("clear"); + arguments.add("steve"); arguments.add("whoami"); pluginCommand.setTabCompleter((sender, command, alias, args) -> arguments); pluginCommand.setExecutor(new CommandClass()); diff --git a/src/main/java/net/babamod/mineclass/classes/BeastMasterClass.java b/src/main/java/net/babamod/mineclass/classes/BeastMasterClass.java new file mode 100644 index 0000000..d80cc78 --- /dev/null +++ b/src/main/java/net/babamod/mineclass/classes/BeastMasterClass.java @@ -0,0 +1,85 @@ +package net.babamod.mineclass.classes; + +import net.babamod.mineclass.utils.Pair; +import org.bukkit.Material; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; +import org.bukkit.potion.PotionEffectType; + +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +public class BeastMasterClass extends MineClassImpl { + + private static final Set forbiddenItems = + new HashSet() { + { + add(Material.DIAMOND_PICKAXE); + add(Material.GOLDEN_PICKAXE); + add(Material.IRON_PICKAXE); + add(Material.NETHERITE_PICKAXE); + add(Material.CROSSBOW); + add(Material.TRIDENT); + } + }; + + private static final Map potionEffects = + Stream.of( + new Object[][] { + {PotionEffectType.NIGHT_VISION, 1}, + {PotionEffectType.SLOW, 1}, + {PotionEffectType.WEAKNESS, 1}, + }) + .collect(Collectors.toMap(data -> (PotionEffectType) data[0], data -> (Integer) data[1])); + + private static final Map>> classEnchantments = + Stream.of( + new AbstractMap.SimpleEntry<>( + Material.BONE, new ArrayList>()), + new AbstractMap.SimpleEntry<>( + Material.SALMON, new ArrayList>()), + new AbstractMap.SimpleEntry<>( + Material.SADDLE, new ArrayList>())) + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + + @Override + public Set getForbiddenItems() { + return forbiddenItems; + } + + @Override + public Map getPotionEffects() { + return potionEffects; + } + + @Override + public Map>> getClassEnchantments() { + return classEnchantments; + } + + @Override + public String getCode() { + return "beast_master"; + } + + @Override + public void giveItems(Player player) { + if (!player.getInventory().contains(Material.BONE)) { + ItemStack itemStack = new ItemStack(Material.BONE, 1); + enchantItem(itemStack); + player.getInventory().addItem(itemStack); + } + if (!player.getInventory().contains(Material.SALMON)) { + ItemStack itemStack = new ItemStack(Material.SALMON, 1); + enchantItem(itemStack); + player.getInventory().addItem(itemStack); + } + if (!player.getInventory().contains(Material.SADDLE)) { + ItemStack itemStack = new ItemStack(Material.SADDLE, 1); + enchantItem(itemStack); + player.getInventory().addItem(itemStack); + } + } +} diff --git a/src/main/java/net/babamod/mineclass/classes/FireDwarfClass.java b/src/main/java/net/babamod/mineclass/classes/FireDwarfClass.java index 044fa1a..4d61110 100644 --- a/src/main/java/net/babamod/mineclass/classes/FireDwarfClass.java +++ b/src/main/java/net/babamod/mineclass/classes/FireDwarfClass.java @@ -86,8 +86,6 @@ public class FireDwarfClass extends MineClassImpl { Collections.singletonList(new Pair<>(Enchantment.ARROW_INFINITE, 1))), new AbstractMap.SimpleEntry<>( Material.FLINT_AND_STEEL, new ArrayList>()) - // See to make infinity working on crossbow - // Inventory auto smelt ) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); diff --git a/src/main/java/net/babamod/mineclass/classes/MineClassFactory.java b/src/main/java/net/babamod/mineclass/classes/MineClassFactory.java index ae27af4..11db105 100644 --- a/src/main/java/net/babamod/mineclass/classes/MineClassFactory.java +++ b/src/main/java/net/babamod/mineclass/classes/MineClassFactory.java @@ -1,6 +1,5 @@ package net.babamod.mineclass.classes; -import net.babamod.mineclass.utils.AppliedStatus; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; @@ -21,6 +20,7 @@ public class MineClassFactory { availableClasses.put("elf", new ElfClass()); availableClasses.put("fire_dwarf", new FireDwarfClass()); availableClasses.put("ender_elf", new EnderElfClass()); + availableClasses.put("beast_master", new BeastMasterClass()); } /** Point d'accès pour l'instance unique du singleton */ @@ -60,10 +60,24 @@ public class MineClassFactory { return availableClasses.keySet(); } + public synchronized String getClassCode(Player player) { + return player.getScoreboardTags().stream() + .filter(availableClasses::containsKey) + .findFirst() + .orElse("steve"); + } + + public synchronized void setClassCode(Player player, String code) { + player + .getScoreboardTags() + .removeAll(availableClasses.keySet()); + player.addScoreboardTag(code); + } + public synchronized Optional getRightClass(Player player) { for (Map.Entry stringMineClassEntry : availableClasses.entrySet()) { - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals(stringMineClassEntry.getKey()) + if (getClassCode(player) != null + && getClassCode(player).equals(stringMineClassEntry.getKey()) || stringMineClassEntry.getValue().is(player)) { return Optional.of(stringMineClassEntry.getValue()); } diff --git a/src/main/java/net/babamod/mineclass/classes/MineClassImpl.java b/src/main/java/net/babamod/mineclass/classes/MineClassImpl.java index f0efa51..13cf9a3 100644 --- a/src/main/java/net/babamod/mineclass/classes/MineClassImpl.java +++ b/src/main/java/net/babamod/mineclass/classes/MineClassImpl.java @@ -1,6 +1,5 @@ package net.babamod.mineclass.classes; -import net.babamod.mineclass.utils.AppliedStatus; import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; @@ -31,7 +30,7 @@ public abstract class MineClassImpl implements MineClass { player.addPotionEffect( new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false)); }); - AppliedStatus.getInstance().setStatus(player, getCode()); + MineClassFactory.getInstance().setClassCode(player, getCode()); } @Override diff --git a/src/main/java/net/babamod/mineclass/commands/CommandClass.java b/src/main/java/net/babamod/mineclass/commands/CommandClass.java index 1c7a99e..68a4c09 100644 --- a/src/main/java/net/babamod/mineclass/commands/CommandClass.java +++ b/src/main/java/net/babamod/mineclass/commands/CommandClass.java @@ -1,11 +1,15 @@ package net.babamod.mineclass.commands; import net.babamod.mineclass.classes.MineClassFactory; -import net.babamod.mineclass.utils.AppliedStatus; +import net.babamod.mineclass.utils.InvocationsFinder; +import net.babamod.mineclass.utils.NumberOfInvocations; +import org.bukkit.attribute.Attribute; import org.bukkit.command.Command; import org.bukkit.command.CommandExecutor; import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; +import org.bukkit.entity.*; +import org.bukkit.potion.PotionEffect; +import org.bukkit.potion.PotionEffectType; public class CommandClass implements CommandExecutor { @Override @@ -18,28 +22,43 @@ public class CommandClass implements CommandExecutor { if (sender instanceof Player) { Player player = (Player) sender; if (MineClassFactory.getInstance().getAvailableClassCodes().contains(args[0])) { - AppliedStatus.getInstance().setStatus(player, args[0]); + if (MineClassFactory.getInstance().getClassCode(player).equals("beast_master")) { + InvocationsFinder.findWolfs(player).forEach(entity -> { + entity.remove(); + NumberOfInvocations.getInstance().decreaseNumber(player); + }); + InvocationsFinder.findCats(player).forEach(entity -> { + entity.remove(); + NumberOfInvocations.getInstance().decreaseNumber(player); + }); + InvocationsFinder.findHorses(player).forEach(Entity::remove); + } MineClassFactory.clearAllClassEffects(player); MineClassFactory.getInstance().reapplyEffectsByCode(args[0], player); MineClassFactory.getInstance().giveItemsForClassByCode(args[0], player); MineClassFactory.getInstance().dropForbiddenItemsForClassByCode(args[0], player); + MineClassFactory.getInstance().setClassCode(player, args[0]); + player.addPotionEffect(new PotionEffect(PotionEffectType.SATURATION,200, 9)); return true; } - if (args[0].equals("clear")) { - AppliedStatus.getInstance().setStatus(player, null); + if (args[0].equals("steve")) { + MineClassFactory.getInstance().setClassCode(player, "steve"); MineClassFactory.clearAllClassEffects(player); return true; } if (args[0].equals("whoami")) { - String classCode = AppliedStatus.getInstance().getStatus(player); - if (classCode != null && !classCode.equals("none")) { + String classCode = + MineClassFactory.getInstance().getClassCode(player); + if (classCode != null) { player.sendMessage(String.format("You are a %s.", classCode)); } else { - player.sendMessage("You are a simple steve."); + player.sendMessage("You are a steve."); } return true; } } return false; } + + } diff --git a/src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java b/src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java index 0525b9a..fdf3fa3 100644 --- a/src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java +++ b/src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java @@ -4,26 +4,28 @@ import net.babamod.mineclass.Mineclass; import net.babamod.mineclass.classes.MineClass; import net.babamod.mineclass.classes.MineClassFactory; import net.babamod.mineclass.utils.*; +import org.bukkit.DyeColor; import org.bukkit.GameMode; import org.bukkit.Material; +import org.bukkit.block.BlockFace; import org.bukkit.enchantments.Enchantment; -import org.bukkit.entity.AbstractArrow; -import org.bukkit.entity.EnderPearl; -import org.bukkit.entity.Player; +import org.bukkit.entity.*; +import org.bukkit.event.Event; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; import org.bukkit.event.block.BlockDropItemEvent; import org.bukkit.event.entity.*; import org.bukkit.event.inventory.InventoryClickEvent; -import org.bukkit.event.player.PlayerChangedWorldEvent; -import org.bukkit.event.player.PlayerItemConsumeEvent; -import org.bukkit.event.player.PlayerJoinEvent; -import org.bukkit.event.player.PlayerRespawnEvent; +import org.bukkit.event.player.*; import org.bukkit.inventory.ItemStack; +import org.bukkit.metadata.FixedMetadataValue; +import org.bukkit.metadata.MetadataValue; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.stream.Collectors; @@ -130,8 +132,7 @@ public class MineClassListeners implements Listener { @EventHandler public void on(BlockDropItemEvent event) { Player player = event.getPlayer(); - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals("fire_dwarf")) { + if (MineClassFactory.getInstance().getClassCode(player).equals("fire_dwarf")) { event .getItems() .forEach( @@ -153,8 +154,7 @@ public class MineClassListeners implements Listener { ((AbstractArrow) event.getProjectile()) .setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED); } - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals("fire_dwarf")) { + if (MineClassFactory.getInstance().getClassCode(player).equals("fire_dwarf")) { event.getProjectile().setFireTicks(10000); } } @@ -166,9 +166,13 @@ public class MineClassListeners implements Listener { if (event.getEntity() instanceof Player) { Player player = (Player) event.getEntity(); if (event.getCause().equals(EntityDamageEvent.DamageCause.FALL) - && AppliedStatus.getInstance().getStatus(player) != null - && (AppliedStatus.getInstance().getStatus(player).equals("elf") - || AppliedStatus.getInstance().getStatus(player).equals("ender_elf"))) { + && (MineClassFactory.getInstance().getClassCode(player).equals("elf") + || MineClassFactory.getInstance().getClassCode(player).equals("ender_elf"))) { + event.setCancelled(true); + } + } else { + if (event.getEntity().hasMetadata("beastMasterHorse") + && event.getCause().equals(EntityDamageEvent.DamageCause.FALL)) { event.setCancelled(true); } } @@ -178,12 +182,13 @@ public class MineClassListeners implements Listener { public void on(FoodLevelChangeEvent event) { if (event.getEntity() instanceof Player) { Player player = (Player) event.getEntity(); - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals("elf")) { - event.setCancelled(true); + if (MineClassFactory.getInstance().getClassCode(player).equals("elf")) { + int difference = player.getFoodLevel() - event.getFoodLevel(); + if (difference > 0) { + event.setCancelled(true); + } } - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals("ender_elf")) { + if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf")) { int difference = player.getFoodLevel() - event.getFoodLevel(); if (difference > 0) { event.setFoodLevel(player.getFoodLevel() - (difference * 2)); @@ -196,8 +201,7 @@ public class MineClassListeners implements Listener { public void on(EntityDamageByEntityEvent event) { if (event.getDamager() instanceof Player) { Player player = (Player) event.getDamager(); - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals("ender_elf") + if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf") && player.getInventory().getItemInMainHand().getType().equals(Material.ENDER_PEARL)) { PlayerHitCounter.getInstance().increaseHitCount(player); if (player.getAttackCooldown() == 1) { @@ -217,6 +221,16 @@ public class MineClassListeners implements Listener { // Damage event.setDamage(event.getDamage() * (player.getAttackCooldown() * 10)); } + } else if (event.getDamager().hasMetadata("beastMasterWolfType")) { + event.getDamager().getMetadata("beastMasterWolfType").stream() + .map(MetadataValue::asInt) + .findFirst() + .ifPresent( + integer -> { + if (integer == 2) { + event.getEntity().setFireTicks(200); + } + }); } } @@ -234,8 +248,7 @@ public class MineClassListeners implements Listener { if (player.getGameMode().equals(GameMode.CREATIVE)) { return; } - if (AppliedStatus.getInstance().getStatus(player) != null - && AppliedStatus.getInstance().getStatus(player).equals("ender_elf") + if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf") && event.getEntity() instanceof EnderPearl) { ItemStack itemStack = new ItemStack(Material.ENDER_PEARL, 1); MineClassFactory.setUnbreakableAndSoulbound(itemStack); @@ -251,4 +264,192 @@ public class MineClassListeners implements Listener { .getRightClass(player) .ifPresent(mineClass -> mineClass.reapplyEffects(player)); } + + @EventHandler + public void on(PlayerInteractEvent event) { + Player player = event.getPlayer(); + if (player.isSneaking() + && event.getAction().equals(Action.RIGHT_CLICK_BLOCK) + && event.useInteractedBlock().equals(Event.Result.ALLOW) + && MineClassFactory.getInstance().getClassCode(player).equals("beast_master") + && event.getClickedBlock() != null + && event.getItem() != null) { + event.setCancelled(true); + ItemStack itemStack = event.getItem(); + switch (itemStack.getType()) { + case SADDLE: + invokeHorse(event, player); + break; + case BONE: + try { + invokeWolf(event, player, itemStack); + } catch (IllegalStateException e) { + player.sendMessage(e.getMessage()); + } + break; + case SALMON: + invokeCat(event, player, itemStack); + break; + default: + break; + } + } + if (player.isSneaking() + && (event.getAction().equals(Action.RIGHT_CLICK_BLOCK) || event.getAction().equals(Action.RIGHT_CLICK_AIR)) + && MineClassFactory.getInstance().getClassCode(player).equals("ender_elf") + && event.getItem() != null && event.getItem().getType().equals(Material.ENDER_PEARL)) { + player.openInventory(player.getEnderChest()); + event.setCancelled(true); + } + } + + private void invokeCat(PlayerInteractEvent event, Player player, ItemStack itemStack) { + Objects.requireNonNull(event.getClickedBlock()); + if (NumberOfInvocations.getInstance().increaseNumber(player)) { + player.sendMessage("Invocation limit reached."); + return; + } + Cat cat = + player + .getWorld() + .spawn(event.getClickedBlock().getRelative(BlockFace.UP).getLocation(), Cat.class); + cat.setTamed(true); + cat.setOwner(player); + cat.setMetadata("beastMasterCat", new FixedMetadataValue(this.plugin, player.getName())); + cat.setCustomName(String.format("%s's Beast Master Cat", player.getName())); + cat.setCustomNameVisible(true); + cat.setCollarColor(DyeColor.BLACK); + if (!player.getGameMode().equals(GameMode.CREATIVE)) { + itemStack.setAmount(itemStack.getAmount() - 1); + } + } + + private void invokeWolf(PlayerInteractEvent event, Player player, ItemStack itemStack) { + Objects.requireNonNull(event.getClickedBlock()); + ItemStack offhandItem = player.getInventory().getItemInOffHand(); + switch (offhandItem.getType()) { + case BEEF: + if (offhandItem.getAmount() >= 8) { + Optional wolfOptional = InvocationsFinder.findWolf(player, 0); + if (wolfOptional.isPresent()) { + wolfOptional.get().remove(); + NumberOfInvocations.getInstance().decreaseNumber(player); + Wolf wolf = spawnBasicWolf(event, player); + updateToBMWolf(player, wolf); + if (!player.getGameMode().equals(GameMode.CREATIVE)) { + offhandItem.setAmount(offhandItem.getAmount() - 8); + } + } else { + spawnBasicWolf(event, player); + } + } + break; + case BLAZE_ROD: + if (offhandItem.getAmount() >= 8) { + Optional wolfOptional = InvocationsFinder.findWolf(player, 1); + if (wolfOptional.isPresent()) { + wolfOptional.get().remove(); + NumberOfInvocations.getInstance().decreaseNumber(player); + Wolf wolf = spawnBasicWolf(event, player); + updateToHellhound(player, wolf); + if (!player.getGameMode().equals(GameMode.CREATIVE)) { + offhandItem.setAmount(offhandItem.getAmount() - 8); + } + } else { + spawnBasicWolf(event, player); + } + } + break; + default: + spawnBasicWolf(event, player); + break; + } + + if (!player.getGameMode().equals(GameMode.CREATIVE)) { + itemStack.setAmount(itemStack.getAmount() - 1); + } + } + + private void updateToBMWolf(Player player, Wolf wolf) { + wolf.setMetadata("beastMasterWolfType", new FixedMetadataValue(this.plugin, 1)); + wolf.setCustomName(String.format("%s's Beast Master Wolf", player.getName())); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, Integer.MAX_VALUE, 3)); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.INCREASE_DAMAGE, Integer.MAX_VALUE, 1)); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 2)); + } + + private void updateToHellhound(Player player, Wolf wolf) { + wolf.setMetadata("beastMasterWolfType", new FixedMetadataValue(this.plugin, 2)); + wolf.setCustomName(String.format("%s's Beast Master Hellhound", player.getName())); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, Integer.MAX_VALUE, 4)); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.INCREASE_DAMAGE, Integer.MAX_VALUE, 2)); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 4)); + wolf.addPotionEffect(new PotionEffect(PotionEffectType.FIRE_RESISTANCE, Integer.MAX_VALUE, 0)); + } + + private Wolf spawnBasicWolf(PlayerInteractEvent event, Player player) { + Objects.requireNonNull(event.getClickedBlock()); + if (NumberOfInvocations.getInstance().increaseNumber(player)) { + throw new IllegalStateException("Invocation limit reached."); + } + Wolf wolf = + player + .getWorld() + .spawn(event.getClickedBlock().getRelative(BlockFace.UP).getLocation(), Wolf.class); + wolf.setTamed(true); + wolf.setOwner(player); + wolf.setMetadata("beastMasterWolf", new FixedMetadataValue(this.plugin, player.getName())); + wolf.setMetadata("beastMasterWolfType", new FixedMetadataValue(this.plugin, 0)); + wolf.setCustomName(String.format("%s's Wolf", player.getName())); + wolf.setCustomNameVisible(true); + wolf.setCollarColor(DyeColor.BLACK); + return wolf; + } + + private void invokeHorse(PlayerInteractEvent event, Player player) { + Objects.requireNonNull(event.getClickedBlock()); + player.getWorld().getEntities().stream() + .filter( + entity -> + entity.getCustomName() != null + && entity.hasMetadata("beastMasterHorse") + && entity.getMetadata("beastMasterHorse").stream() + .anyMatch( + metadataValue -> metadataValue.asString().equals(player.getName()))) + .findFirst() + .ifPresent(Entity::remove); + Horse horse = + player + .getWorld() + .spawn(event.getClickedBlock().getRelative(BlockFace.UP).getLocation(), Horse.class); + horse.setTamed(true); + horse.setOwner(player); + horse.setMetadata("beastMasterHorse", new FixedMetadataValue(this.plugin, player.getName())); + horse.setCustomName(String.format("%s's Beast Master Horse", player.getName())); + horse.setCustomNameVisible(true); + horse.setColor(Horse.Color.DARK_BROWN); + horse.setJumpStrength(1.1); + horse.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 3)); + horse.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, Integer.MAX_VALUE, 3)); + horse.getInventory().setSaddle(new ItemStack(Material.SADDLE, 1)); + } + + @EventHandler + public void on(EntityDeathEvent event) { + if (event.getEntity().hasMetadata("beastMasterHorse")) { + event.getDrops().clear(); + } + if (event.getEntity().hasMetadata("beastMasterWolf")) { + event.getEntity().getMetadata("beastMasterWolf").stream() + .map(MetadataValue::asString) + .findFirst() + .ifPresent(s -> NumberOfInvocations.getInstance().decreaseNumber(s)); + } + if (event.getEntity().hasMetadata("beastMasterCat")) { + event.getEntity().getMetadata("beastMasterCat").stream() + .map(MetadataValue::asString) + .findFirst() + .ifPresent(s -> NumberOfInvocations.getInstance().decreaseNumber(s)); + } + } } diff --git a/src/main/java/net/babamod/mineclass/utils/AppliedStatus.java b/src/main/java/net/babamod/mineclass/utils/AppliedStatus.java deleted file mode 100644 index adadcc7..0000000 --- a/src/main/java/net/babamod/mineclass/utils/AppliedStatus.java +++ /dev/null @@ -1,56 +0,0 @@ -package net.babamod.mineclass.utils; - -import org.bukkit.entity.Player; - -import java.io.Serializable; -import java.util.HashMap; -import java.util.Objects; - -public class AppliedStatus implements Serializable { - /** Instance unique pré-initialisée */ - private static AppliedStatus INSTANCE; - - private final HashMap appliedStatus; - - /** Constructeur privé */ - private AppliedStatus() { - appliedStatus = new HashMap<>(); - } - - /** Point d'accès pour l'instance unique du singleton */ - public static synchronized AppliedStatus getInstance() { - if (INSTANCE == null) { - INSTANCE = new AppliedStatus(); - } - - return INSTANCE; - } - - public synchronized void setStatus(Player player, String status) { - appliedStatus.put(player.getName(), status); - } - - public synchronized String getStatus(Player player) { - return appliedStatus.getOrDefault(player.getName(), "none"); - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - AppliedStatus that = (AppliedStatus) o; - - return Objects.equals(appliedStatus, that.appliedStatus); - } - - @Override - public int hashCode() { - return appliedStatus.hashCode(); - } - - @Override - public String toString() { - return "AppliedStatus{" + "appliedStatus=" + appliedStatus + '}'; - } -} diff --git a/src/main/java/net/babamod/mineclass/utils/InvocationsFinder.java b/src/main/java/net/babamod/mineclass/utils/InvocationsFinder.java new file mode 100644 index 0000000..e5321c4 --- /dev/null +++ b/src/main/java/net/babamod/mineclass/utils/InvocationsFinder.java @@ -0,0 +1,58 @@ +package net.babamod.mineclass.utils; + +import org.bukkit.entity.Entity; +import org.bukkit.entity.Player; + +import java.util.List; +import java.util.Optional; +import java.util.stream.Collectors; + +public class InvocationsFinder { + + public static Optional findWolf(Player player, int i) { + return player.getWorld().getEntities().stream() + .filter( + entity -> + entity.hasMetadata("beastMasterWolf") + && entity.getMetadata("beastMasterWolf").stream() + .anyMatch( + metadataValue -> metadataValue.asString().equals(player.getName())) + && entity.hasMetadata("beastMasterWolfType") + && entity.getMetadata("beastMasterWolfType").stream() + .anyMatch(metadataValue -> metadataValue.asInt() == i)) + .findFirst(); + } + + public static List findWolfs(Player player) { + return player.getWorld().getEntities().stream() + .filter( + entity -> + entity.hasMetadata("beastMasterWolf") + && entity.getMetadata("beastMasterWolf").stream() + .anyMatch( + metadataValue -> metadataValue.asString().equals(player.getName()))) + .collect(Collectors.toList()); + } + + public static List findCats(Player player) { + return player.getWorld().getEntities().stream() + .filter( + entity -> + entity.hasMetadata("beastMasterCat") + && entity.getMetadata("beastMasterCat").stream() + .anyMatch( + metadataValue -> metadataValue.asString().equals(player.getName()))) + .collect(Collectors.toList()); + } + + public static List findHorses(Player player) { + return player.getWorld().getEntities().stream() + .filter( + entity -> + entity.hasMetadata("beastMasterHorse") + && entity.getMetadata("beastMasterHorse").stream() + .anyMatch( + metadataValue -> metadataValue.asString().equals(player.getName()))) + .collect(Collectors.toList()); + } +} diff --git a/src/main/java/net/babamod/mineclass/utils/NumberOfInvocations.java b/src/main/java/net/babamod/mineclass/utils/NumberOfInvocations.java new file mode 100644 index 0000000..9510de9 --- /dev/null +++ b/src/main/java/net/babamod/mineclass/utils/NumberOfInvocations.java @@ -0,0 +1,48 @@ +package net.babamod.mineclass.utils; + +import org.bukkit.entity.Player; + +import java.util.HashMap; + +public class NumberOfInvocations { + /** Instance unique pré-initialisée */ + private static NumberOfInvocations INSTANCE; + + private final HashMap numberOfInvocations; + + /** Constructeur privé */ + private NumberOfInvocations() { + numberOfInvocations = new HashMap<>(); + } + + /** Point d'accès pour l'instance unique du singleton */ + public static synchronized NumberOfInvocations getInstance() { + if (INSTANCE == null) { + INSTANCE = new NumberOfInvocations(); + } + + return INSTANCE; + } + + public boolean increaseNumber(Player player) { + Integer integer = numberOfInvocations.getOrDefault(player.getName(), 0); + if (integer == 8) { + return true; + } + numberOfInvocations.put(player.getName(), integer + 1); + return false; + } + + public void decreaseNumber(Player player) { + decreaseNumber(player.getName()); + } + + public void decreaseNumber(String playerName) { + Integer integer = numberOfInvocations.getOrDefault(playerName, 0); + if (integer == 0) { + return; + } + numberOfInvocations.put(playerName, integer - 1); + } + +}