Add Beast Master and make an overall improvement for all the mod

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<String> 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());

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<Material> forbiddenItems =
+      new HashSet<Material>() {
+        {
+          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<PotionEffectType, Integer> 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<Material, List<Pair<Enchantment, Integer>>> classEnchantments =
+      Stream.of(
+              new AbstractMap.SimpleEntry<>(
+                  Material.BONE, new ArrayList<Pair<Enchantment, Integer>>()),
+              new AbstractMap.SimpleEntry<>(
+                  Material.SALMON, new ArrayList<Pair<Enchantment, Integer>>()),
+              new AbstractMap.SimpleEntry<>(
+                  Material.SADDLE, new ArrayList<Pair<Enchantment, Integer>>()))
+          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+  @Override
+  public Set<Material> getForbiddenItems() {
+    return forbiddenItems;
+  }
+
+  @Override
+  public Map<PotionEffectType, Integer> getPotionEffects() {
+    return potionEffects;
+  }
+
+  @Override
+  public Map<Material, List<Pair<Enchantment, Integer>>> 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);
+    }
+  }
+}

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<Pair<Enchantment, Integer>>())
-              // See to make infinity working on crossbow
-              // Inventory auto smelt
               )
           .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 

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<MineClass> getRightClass(Player player) {
     for (Map.Entry<String, MineClass> stringMineClassEntry : availableClasses.entrySet()) {
-      if (AppliedStatus.getInstance().getStatus(player) != null
+      if (getClassCode(player) != null
-              && AppliedStatus.getInstance().getStatus(player).equals(stringMineClassEntry.getKey())
+              && getClassCode(player).equals(stringMineClassEntry.getKey())
           || stringMineClassEntry.getValue().is(player)) {
         return Optional.of(stringMineClassEntry.getValue());
       }

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

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")) {
+      if (args[0].equals("steve")) {
-        AppliedStatus.getInstance().setStatus(player, null);
+        MineClassFactory.getInstance().setClassCode(player, "steve");
         MineClassFactory.clearAllClassEffects(player);
         return true;
       }
       if (args[0].equals("whoami")) {
-        String classCode = AppliedStatus.getInstance().getStatus(player);
+        String classCode =
-        if (classCode != null && !classCode.equals("none")) {
+            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;
   }
+
+
 }

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.*;
-import org.bukkit.entity.EnderPearl;
+import org.bukkit.event.Event;
-import org.bukkit.entity.Player;
 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.*;
-import org.bukkit.event.player.PlayerItemConsumeEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerRespawnEvent;
 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
+    if (MineClassFactory.getInstance().getClassCode(player).equals("fire_dwarf")) {
-        && AppliedStatus.getInstance().getStatus(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
+        if (MineClassFactory.getInstance().getClassCode(player).equals("fire_dwarf")) {
-            && AppliedStatus.getInstance().getStatus(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
+          && (MineClassFactory.getInstance().getClassCode(player).equals("elf")
-          && (AppliedStatus.getInstance().getStatus(player).equals("elf")
+              || MineClassFactory.getInstance().getClassCode(player).equals("ender_elf"))) {
-              || AppliedStatus.getInstance().getStatus(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
+      if (MineClassFactory.getInstance().getClassCode(player).equals("elf")) {
-          && AppliedStatus.getInstance().getStatus(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
+      if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf")
-          && AppliedStatus.getInstance().getStatus(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
+      if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf")
-          && AppliedStatus.getInstance().getStatus(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<Entity> 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<Entity> 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));
+    }
+  }
 }

src/main/java/net/babamod/mineclass/utils/AppliedStatus.java

@@ -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<String, String> 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 + '}';
-  }
-}

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<Entity> 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<Entity> 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<Entity> 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<Entity> 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());
+  }
+}

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<String, Integer> 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);
+  }
+
+}