Rename main package group

2021-12-10 21:27:54 +01:00
parent a6ddc8fd49
commit bebf17ba67
20 changed files with 37 additions and 37 deletions
--- a/src/main/java/net/rawmod/mineclass/Mineclass.java
+++ b/src/main/java/net/rawmod/mineclass/Mineclass.java
@@ -0,0 +1,39 @@
+package net.rawmod.mineclass;
+
+import net.rawmod.mineclass.classes.MineClassFactory;
+import net.rawmod.mineclass.commands.CommandClass;
+import net.rawmod.mineclass.listeners.MineClassListeners;
+import org.bukkit.Bukkit;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class Mineclass extends JavaPlugin {
+
+  @Override
+  public void onEnable() {
+    new MineClassListeners(this);
+    PluginCommand pluginCommand = this.getCommand("class");
+    if (pluginCommand != null) {
+      List<String> arguments =
+          new ArrayList<>(MineClassFactory.getInstance().getAvailableClassCodes());
+      arguments.add("steve");
+      arguments.add("whoami");
+      pluginCommand.setTabCompleter((sender, command, alias, args) -> arguments);
+      pluginCommand.setExecutor(new CommandClass());
+    }
+    Bukkit.getOnlinePlayers()
+        .forEach(
+            player ->
+                MineClassFactory.getInstance()
+                    .getRightClass(player)
+                    .ifPresent(aClass -> aClass.reapplyEffects(player)));
+  }
+
+  @Override
+  public void onDisable() {
+    // Plugin shutdown logic
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/classes/BeastMasterClass.java
+++ b/src/main/java/net/rawmod/mineclass/classes/BeastMasterClass.java
@@ -0,0 +1,85 @@
+package net.rawmod.mineclass.classes;
+
+import net.rawmod.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);
+    }
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/classes/DwarfClass.java
+++ b/src/main/java/net/rawmod/mineclass/classes/DwarfClass.java
@@ -0,0 +1,98 @@
+package net.rawmod.mineclass.classes;
+
+import net.rawmod.mineclass.utils.Pair;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class DwarfClass extends MineClassImpl {
+
+  private final Set<Material> forbiddenItems =
+      new HashSet<Material>() {
+        {
+          add(Material.DIAMOND_AXE);
+          add(Material.GOLDEN_AXE);
+          add(Material.IRON_AXE);
+          add(Material.NETHERITE_AXE);
+          add(Material.DIAMOND_HOE);
+          add(Material.GOLDEN_HOE);
+          add(Material.IRON_HOE);
+          add(Material.NETHERITE_HOE);
+          add(Material.BOW);
+          add(Material.TRIDENT);
+        }
+      };
+
+  private final Map<PotionEffectType, Integer> potionEffects =
+      Stream.of(
+              new Object[][] {
+                {PotionEffectType.HEALTH_BOOST, 2},
+                {PotionEffectType.DAMAGE_RESISTANCE, 1},
+                {PotionEffectType.HERO_OF_THE_VILLAGE, 1},
+                {PotionEffectType.FAST_DIGGING, 1},
+                {PotionEffectType.NIGHT_VISION, 1},
+              })
+          .collect(Collectors.toMap(data -> (PotionEffectType) data[0], data -> (Integer) data[1]));
+
+  private final Map<Material, List<Pair<Enchantment, Integer>>> classEnchantments =
+      Stream.of(
+              new AbstractMap.SimpleEntry<>(
+                  Material.NETHERITE_PICKAXE,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.DIG_SPEED, 8),
+                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.DIAMOND_PICKAXE,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.DIG_SPEED, 8),
+                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.IRON_PICKAXE,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.DIG_SPEED, 8),
+                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.GOLDEN_PICKAXE,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.DIG_SPEED, 8),
+                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.STONE_PICKAXE,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.DIG_SPEED, 8),
+                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.WOODEN_PICKAXE,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.DIG_SPEED, 8),
+                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))))
+          .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 "dwarf";
+  }
+
+  @Override
+  public void giveItems(Player player) {}
+}
--- a/src/main/java/net/rawmod/mineclass/classes/ElfClass.java
+++ b/src/main/java/net/rawmod/mineclass/classes/ElfClass.java
@@ -0,0 +1,77 @@
+package net.rawmod.mineclass.classes;
+
+import net.rawmod.mineclass.utils.Pair;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class ElfClass extends MineClassImpl {
+
+  private static final Set<Material> forbiddenItems =
+      new HashSet<Material>() {
+        {
+          add(Material.DIAMOND_SWORD);
+          add(Material.GOLDEN_SWORD);
+          add(Material.IRON_SWORD);
+          add(Material.NETHERITE_SWORD);
+          add(Material.DIAMOND_PICKAXE);
+          add(Material.GOLDEN_PICKAXE);
+          add(Material.IRON_PICKAXE);
+          add(Material.NETHERITE_PICKAXE);
+          add(Material.DIAMOND_SHOVEL);
+          add(Material.GOLDEN_SHOVEL);
+          add(Material.IRON_SHOVEL);
+          add(Material.NETHERITE_SHOVEL);
+          add(Material.CROSSBOW);
+          add(Material.TRIDENT);
+          add(Material.ENDER_PEARL);
+        }
+      };
+
+  private static final Map<PotionEffectType, Integer> potionEffects =
+      Stream.of(
+              new Object[][] {
+                {PotionEffectType.SPEED, 2},
+                {PotionEffectType.JUMP, 3},
+                {PotionEffectType.LUCK, 1},
+                {PotionEffectType.NIGHT_VISION, 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.BOW,
+                  Arrays.asList(
+                      new Pair<>(Enchantment.ARROW_INFINITE, 1),
+                      new Pair<>(Enchantment.ARROW_DAMAGE, 8))))
+          .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 "elf";
+  }
+
+  @Override
+  public void giveItems(Player player) {}
+}
--- a/src/main/java/net/rawmod/mineclass/classes/EnderElfClass.java
+++ b/src/main/java/net/rawmod/mineclass/classes/EnderElfClass.java
@@ -0,0 +1,99 @@
+package net.rawmod.mineclass.classes;
+
+import net.rawmod.mineclass.utils.Pair;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class EnderElfClass extends MineClassImpl {
+
+  private static final Set<Material> forbiddenItems =
+      new HashSet<Material>() {
+        {
+          add(Material.DIAMOND_SWORD);
+          add(Material.GOLDEN_SWORD);
+          add(Material.IRON_SWORD);
+          add(Material.NETHERITE_SWORD);
+          add(Material.DIAMOND_PICKAXE);
+          add(Material.GOLDEN_PICKAXE);
+          add(Material.IRON_PICKAXE);
+          add(Material.NETHERITE_PICKAXE);
+          add(Material.DIAMOND_SHOVEL);
+          add(Material.GOLDEN_SHOVEL);
+          add(Material.IRON_SHOVEL);
+          add(Material.NETHERITE_SHOVEL);
+          add(Material.DIAMOND_HOE);
+          add(Material.GOLDEN_HOE);
+          add(Material.IRON_HOE);
+          add(Material.NETHERITE_HOE);
+          add(Material.DIAMOND_AXE);
+          add(Material.GOLDEN_AXE);
+          add(Material.IRON_AXE);
+          add(Material.NETHERITE_AXE);
+          add(Material.CROSSBOW);
+          add(Material.BOW);
+          add(Material.TRIDENT);
+        }
+      };
+
+  private static final Map<PotionEffectType, Integer> potionEffects =
+      Stream.of(
+              new Object[][] {
+                {PotionEffectType.NIGHT_VISION, 1},
+                {PotionEffectType.ABSORPTION, 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.ENDER_PEARL, 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 "ender_elf";
+  }
+
+  @Override
+  public void reapplyEffects(Player player) {
+    super.reapplyEffects(player);
+    if (player.getWorld().getEnvironment().equals(World.Environment.THE_END)) {
+      PotionEffect saturation =
+          new PotionEffect(PotionEffectType.SATURATION, Integer.MAX_VALUE, 9, false, false);
+      player.addPotionEffect(saturation);
+    }
+  }
+
+  @Override
+  public void giveItems(Player player) {
+    if (!player.getInventory().contains(Material.ENDER_PEARL)) {
+      ItemStack itemStack = new ItemStack(Material.ENDER_PEARL, 2);
+      enchantItem(itemStack);
+      player.getInventory().addItem(itemStack);
+    }
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/classes/FireDwarfClass.java
+++ b/src/main/java/net/rawmod/mineclass/classes/FireDwarfClass.java
@@ -0,0 +1,113 @@
+package net.rawmod.mineclass.classes;
+
+import net.rawmod.mineclass.utils.Pair;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class FireDwarfClass extends MineClassImpl {
+
+  private static final Set<Material> forbiddenItems =
+      new HashSet<Material>() {
+        {
+          add(Material.DIAMOND_SWORD);
+          add(Material.GOLDEN_SWORD);
+          add(Material.IRON_SWORD);
+          add(Material.NETHERITE_SWORD);
+          add(Material.DIAMOND_HOE);
+          add(Material.GOLDEN_HOE);
+          add(Material.IRON_HOE);
+          add(Material.NETHERITE_HOE);
+          add(Material.DIAMOND_SHOVEL);
+          add(Material.GOLDEN_SHOVEL);
+          add(Material.IRON_SHOVEL);
+          add(Material.NETHERITE_SHOVEL);
+          add(Material.BOW);
+          add(Material.TRIDENT);
+        }
+      };
+
+  private static final Map<PotionEffectType, Integer> potionEffects =
+      Stream.of(
+              new Object[][] {
+                {PotionEffectType.FIRE_RESISTANCE, 1},
+                {PotionEffectType.FAST_DIGGING, 1},
+                {PotionEffectType.JUMP, 2},
+                {PotionEffectType.NIGHT_VISION, 1},
+                {PotionEffectType.HEALTH_BOOST, 2},
+              })
+          .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.NETHERITE_AXE,
+                  Collections.singletonList(new Pair<>(Enchantment.FIRE_ASPECT, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.DIAMOND_AXE,
+                  Collections.singletonList(new Pair<>(Enchantment.FIRE_ASPECT, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.IRON_AXE,
+                  Collections.singletonList(new Pair<>(Enchantment.FIRE_ASPECT, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.GOLDEN_AXE,
+                  Collections.singletonList(new Pair<>(Enchantment.FIRE_ASPECT, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.STONE_AXE,
+                  Collections.singletonList(new Pair<>(Enchantment.FIRE_ASPECT, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.WOODEN_AXE,
+                  Collections.singletonList(new Pair<>(Enchantment.FIRE_ASPECT, 2))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.NETHERITE_PICKAXE,
+                  Collections.singletonList(new Pair<>(Enchantment.DIG_SPEED, 5))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.DIAMOND_PICKAXE,
+                  Collections.singletonList(new Pair<>(Enchantment.DIG_SPEED, 5))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.IRON_PICKAXE,
+                  Collections.singletonList(new Pair<>(Enchantment.DIG_SPEED, 5))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.GOLDEN_PICKAXE,
+                  Collections.singletonList(new Pair<>(Enchantment.DIG_SPEED, 5))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.STONE_PICKAXE,
+                  Collections.singletonList(new Pair<>(Enchantment.DIG_SPEED, 5))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.WOODEN_PICKAXE,
+                  Collections.singletonList(new Pair<>(Enchantment.DIG_SPEED, 5))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.CROSSBOW,
+                  Collections.singletonList(new Pair<>(Enchantment.ARROW_INFINITE, 1))),
+              new AbstractMap.SimpleEntry<>(
+                  Material.FLINT_AND_STEEL, 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 "fire_dwarf";
+  }
+
+  @Override
+  public void giveItems(Player player) {}
+}
--- a/src/main/java/net/rawmod/mineclass/classes/MineClass.java
+++ b/src/main/java/net/rawmod/mineclass/classes/MineClass.java
@@ -0,0 +1,33 @@
+package net.rawmod.mineclass.classes;
+
+import net.rawmod.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.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface MineClass {
+
+  Set<Material> getForbiddenItems();
+
+  Map<PotionEffectType, Integer> getPotionEffects();
+
+  Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments();
+
+  void reapplyEffects(Player player);
+
+  boolean isItemForbidden(Material type);
+
+  void enchantItem(ItemStack itemStack);
+
+  void giveItems(Player player);
+
+  String getCode();
+
+  void dropForbiddenItems(Player player);
+}
--- a/src/main/java/net/rawmod/mineclass/classes/MineClassFactory.java
+++ b/src/main/java/net/rawmod/mineclass/classes/MineClassFactory.java
@@ -0,0 +1,96 @@
+package net.rawmod.mineclass.classes;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.potion.PotionEffect;
+
+import java.util.*;
+
+public class MineClassFactory {
+  /** Instance unique pré-initialisée */
+  private static MineClassFactory INSTANCE;
+
+  private final Map<String, MineClass> availableClasses;
+
+  /** Constructeur privé */
+  private MineClassFactory() {
+    availableClasses = new HashMap<>();
+    availableClasses.put("dwarf", new DwarfClass());
+    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 */
+  public static synchronized MineClassFactory getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new MineClassFactory();
+    }
+
+    return INSTANCE;
+  }
+
+  public static boolean isSoulBound(ItemStack itemStack) {
+    if (itemStack.getItemMeta() != null && itemStack.getItemMeta().getLore() != null) {
+      return itemStack.getItemMeta().getLore().contains("Soulbound");
+    }
+    return false;
+  }
+
+  public static void clearAllClassEffects(Player player) {
+    for (PotionEffect activePotionEffect : player.getActivePotionEffects()) {
+      if (activePotionEffect.getDuration() > 32766) {
+        player.removePotionEffect(activePotionEffect.getType());
+      }
+    }
+  }
+
+  public static void setUnbreakableAndSoulbound(ItemStack itemStack) {
+    if (itemStack.getItemMeta() != null) {
+      ItemMeta itemMeta = itemStack.getItemMeta();
+      itemMeta.setUnbreakable(true);
+      itemMeta.setLore(Collections.singletonList("Soulbound"));
+      itemStack.setItemMeta(itemMeta);
+    }
+  }
+
+  public synchronized Set<String> getAvailableClassCodes() {
+    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 (getClassCode(player) != null
+          && getClassCode(player).equals(stringMineClassEntry.getKey())) {
+        return Optional.of(stringMineClassEntry.getValue());
+      }
+    }
+    return Optional.empty();
+  }
+
+  public void reapplyEffectsByCode(String code, Player player) {
+    availableClasses.get(code).reapplyEffects(player);
+  }
+
+  public void giveItemsForClassByCode(String code, Player player) {
+    availableClasses.get(code).giveItems(player);
+  }
+
+  public void dropForbiddenItemsForClassByCode(String code, Player player) {
+    availableClasses.get(code).dropForbiddenItems(player);
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/classes/MineClassImpl.java
+++ b/src/main/java/net/rawmod/mineclass/classes/MineClassImpl.java
@@ -0,0 +1,54 @@
+package net.rawmod.mineclass.classes;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+
+import java.util.ArrayList;
+
+public abstract class MineClassImpl implements MineClass {
+
+  @Override
+  public void reapplyEffects(Player player) {
+    MineClassFactory.clearAllClassEffects(player);
+    getPotionEffects()
+        .forEach(
+            (key, value) -> {
+              if (player.hasPotionEffect(key)) {
+                player.removePotionEffect(key);
+              }
+              player.addPotionEffect(
+                  new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
+            });
+    MineClassFactory.getInstance().setClassCode(player, getCode());
+  }
+
+  @Override
+  public boolean isItemForbidden(Material type) {
+    return getForbiddenItems().contains(type);
+  }
+
+  @Override
+  public void enchantItem(ItemStack itemStack) {
+    if (getClassEnchantments().containsKey(itemStack.getType())) {
+      getClassEnchantments()
+          .getOrDefault(itemStack.getType(), new ArrayList<>())
+          .forEach(
+              enchantmentIntegerPair ->
+                  itemStack.addUnsafeEnchantment(
+                      enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
+      MineClassFactory.setUnbreakableAndSoulbound(itemStack);
+    }
+  }
+
+  @Override
+  public void dropForbiddenItems(Player player) {
+    for (ItemStack content : player.getInventory().getContents()) {
+      if (content != null && getForbiddenItems().contains(content.getType())) {
+        player.getInventory().remove(content);
+        player.getWorld().dropItemNaturally(player.getLocation(), content);
+      }
+    }
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/commands/CommandClass.java
+++ b/src/main/java/net/rawmod/mineclass/commands/CommandClass.java
@@ -0,0 +1,67 @@
+package net.rawmod.mineclass.commands;
+
+import net.rawmod.mineclass.classes.MineClassFactory;
+import net.rawmod.mineclass.utils.InvocationsFinder;
+import net.rawmod.mineclass.utils.NumberOfInvocations;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public class CommandClass implements CommandExecutor {
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (args.length == 0) {
+      sender.sendMessage(
+          "You need to use this command with one of the suggested arguments (press space then tab to see suggested arguments).");
+      return false;
+    }
+    if (sender instanceof Player) {
+      Player player = (Player) sender;
+      if (MineClassFactory.getInstance().getAvailableClassCodes().contains(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]);
+        if (!player.hasPotionEffect(PotionEffectType.SATURATION)) {
+          player.addPotionEffect(new PotionEffect(PotionEffectType.SATURATION, 200, 9));
+        }
+        return true;
+      }
+      if (args[0].equals("steve")) {
+        MineClassFactory.getInstance().setClassCode(player, "steve");
+        MineClassFactory.clearAllClassEffects(player);
+        return true;
+      }
+      if (args[0].equals("whoami")) {
+        String classCode = MineClassFactory.getInstance().getClassCode(player);
+        if (classCode != null) {
+          player.sendMessage(String.format("You are a %s.", classCode));
+        } else {
+          player.sendMessage("You are a steve.");
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/listeners/MineClassListeners.java
+++ b/src/main/java/net/rawmod/mineclass/listeners/MineClassListeners.java
@@ -0,0 +1,457 @@
+package net.rawmod.mineclass.listeners;
+
+import net.rawmod.mineclass.Mineclass;
+import net.rawmod.mineclass.classes.MineClass;
+import net.rawmod.mineclass.classes.MineClassFactory;
+import net.rawmod.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.*;
+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.*;
+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;
+
+public class MineClassListeners implements Listener {
+
+  private final Mineclass plugin;
+
+  public MineClassListeners(Mineclass plugin) {
+    this.plugin = plugin;
+    this.plugin.getServer().getPluginManager().registerEvents(this, plugin);
+  }
+
+  @EventHandler
+  public void on(PlayerJoinEvent event) {
+    Player player = event.getPlayer();
+    Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+    if (mineClass.isPresent()) {
+      mineClass.get().reapplyEffects(player);
+      player.sendMessage(String.format("Reminder : You are a %s.", mineClass.get().getCode()));
+    } else {
+      player.sendMessage(
+          "Hello ! The amazing MineClass mod is available on this server ! You can pick a class with the /class command.");
+    }
+  }
+
+  @EventHandler
+  public void on(PlayerItemConsumeEvent event) {
+    if (event.getItem().getType().equals(Material.MILK_BUCKET)) {
+      new ApplyClassStatusTask(event.getPlayer()).runTaskLater(this.plugin, 10);
+    }
+  }
+
+  @EventHandler
+  public void on(EntityPickupItemEvent event) {
+    if (event.getEntity() instanceof Player) {
+      Player player = (Player) event.getEntity();
+      Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+      if (mineClass.isPresent()) {
+        if (mineClass.get().isItemForbidden(event.getItem().getItemStack().getType())) {
+          event.setCancelled(true);
+        }
+        mineClass.get().enchantItem(event.getItem().getItemStack());
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(PlayerDeathEvent event) {
+    List<ItemStack> itemStackList =
+        event.getDrops().stream()
+            .filter(MineClassFactory::isSoulBound)
+            .collect(Collectors.toList());
+    event.getDrops().removeAll(itemStackList);
+    ClassItemPossessed.getInstance().addItems(event.getEntity().getName(), itemStackList);
+  }
+
+  @EventHandler
+  public void on(PlayerRespawnEvent event) {
+    new ApplyClassStatusTask(event.getPlayer()).runTaskLater(this.plugin, 10);
+    ClassItemPossessed.getInstance()
+        .getItems(event.getPlayer().getName())
+        .forEach(itemStack -> event.getPlayer().getInventory().addItem(itemStack));
+    ClassItemPossessed.getInstance().clearItems(event.getPlayer().getName());
+  }
+
+  @EventHandler
+  public void on(InventoryClickEvent event) {
+    if (event.getWhoClicked() instanceof Player) {
+      if (isForbiddenItem(event)) {
+        event.setCancelled(true);
+        return;
+      }
+      enchantItem(event);
+    }
+  }
+
+  private boolean isForbiddenItem(InventoryClickEvent event) {
+    Player player = (Player) event.getWhoClicked();
+    Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+    if (mineClass.isPresent()) {
+      if (event.getCurrentItem() != null
+          && mineClass.get().isItemForbidden(event.getCurrentItem().getType())) {
+        return true;
+      }
+      return event.getCursor() != null
+          && mineClass.get().isItemForbidden(event.getCursor().getType());
+    }
+    return false;
+  }
+
+  private void enchantItem(InventoryClickEvent event) {
+    Player player = (Player) event.getWhoClicked();
+    Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+    if (mineClass.isPresent()) {
+      if (event.getCurrentItem() != null && !MineClassFactory.isSoulBound(event.getCurrentItem())) {
+        mineClass.get().enchantItem(event.getCurrentItem());
+      }
+      if (event.getCursor() != null && !MineClassFactory.isSoulBound(event.getCursor())) {
+        mineClass.get().enchantItem(event.getCursor());
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(BlockDropItemEvent event) {
+    Player player = event.getPlayer();
+    if (MineClassFactory.getInstance().getClassCode(player).equals("fire_dwarf")) {
+      event
+          .getItems()
+          .forEach(
+              item ->
+                  SmeltingEngine.getInstance()
+                      .smelt(player, event.getBlock().getLocation(), item.getItemStack())
+                      .ifPresent(item::setItemStack));
+    }
+  }
+
+  @EventHandler
+  public void on(EntityShootBowEvent event) {
+    if (event.getBow() != null && event.getBow().getType().equals(Material.CROSSBOW)) {
+      if (event.getEntity() instanceof Player) {
+        Player player = (Player) event.getEntity();
+        if (event.getProjectile() instanceof AbstractArrow
+            && event.getBow().getEnchantments().containsKey(Enchantment.ARROW_INFINITE)) {
+          player.getInventory().addItem(new ItemStack(Material.ARROW));
+          ((AbstractArrow) event.getProjectile())
+              .setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
+        }
+        if (MineClassFactory.getInstance().getClassCode(player).equals("fire_dwarf")) {
+          event.getProjectile().setFireTicks(10000);
+        }
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(EntityDamageEvent event) {
+    if (event.getEntity() instanceof Player) {
+      Player player = (Player) event.getEntity();
+      if (event.getCause().equals(EntityDamageEvent.DamageCause.FALL)
+          && (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);
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(FoodLevelChangeEvent event) {
+    if (event.getEntity() instanceof Player) {
+      Player player = (Player) event.getEntity();
+      if (MineClassFactory.getInstance().getClassCode(player).equals("elf")) {
+        int difference = player.getFoodLevel() - event.getFoodLevel();
+        if (difference > 0) {
+          event.setCancelled(true);
+        }
+      }
+      if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf")) {
+        int difference = player.getFoodLevel() - event.getFoodLevel();
+        if (difference > 0) {
+          event.setFoodLevel(player.getFoodLevel() - (difference * 2));
+        }
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(EntityDamageByEntityEvent event) {
+    if (event.getDamager() instanceof Player) {
+      Player player = (Player) event.getDamager();
+      if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf")
+          && player.getInventory().getItemInMainHand().getType().equals(Material.ENDER_PEARL)) {
+        PlayerHitCounter.getInstance().increaseHitCount(player);
+        if (player.getAttackCooldown() == 1) {
+          // Vampirisme
+          if (player.getHealth() <= 19) {
+            player.setHealth(player.getHealth() + 1);
+          }
+        }
+        if (PlayerHitCounter.getInstance().getHitCounter(player) == 15) {
+          // Absorption
+          PlayerHitCounter.getInstance().resetHitCounter(player);
+          PotionEffect absorption =
+              new PotionEffect(PotionEffectType.ABSORPTION, Integer.MAX_VALUE, 0, false, false);
+          player.removePotionEffect(PotionEffectType.ABSORPTION);
+          player.addPotionEffect(absorption);
+        }
+        // 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);
+                }
+              });
+    }
+  }
+
+  @EventHandler
+  public void on(CreatureSpawnEvent event) {
+    if (event.getSpawnReason().equals(CreatureSpawnEvent.SpawnReason.ENDER_PEARL)) {
+      event.setCancelled(true);
+    }
+  }
+
+  @EventHandler
+  public void on(ProjectileHitEvent event) {
+    if (event.getEntity().getShooter() instanceof Player) {
+      Player player = (Player) event.getEntity().getShooter();
+      if (player.getGameMode().equals(GameMode.CREATIVE)) {
+        return;
+      }
+      if (MineClassFactory.getInstance().getClassCode(player).equals("ender_elf")
+          && event.getEntity() instanceof EnderPearl) {
+        ItemStack itemStack = new ItemStack(Material.ENDER_PEARL, 1);
+        MineClassFactory.setUnbreakableAndSoulbound(itemStack);
+        player.getInventory().addItem(itemStack);
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(PlayerChangedWorldEvent event) {
+    Player player = event.getPlayer();
+    MineClassFactory.getInstance()
+        .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));
+    }
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/ApplyClassStatusTask.java
+++ b/src/main/java/net/rawmod/mineclass/utils/ApplyClassStatusTask.java
@@ -0,0 +1,21 @@
+package net.rawmod.mineclass.utils;
+
+import net.rawmod.mineclass.classes.MineClassFactory;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+public class ApplyClassStatusTask extends BukkitRunnable {
+
+  private final Player player;
+
+  public ApplyClassStatusTask(Player player) {
+    this.player = player;
+  }
+
+  @Override
+  public void run() {
+    MineClassFactory.getInstance()
+        .getRightClass(player)
+        .ifPresent(mineClass -> mineClass.reapplyEffects(player));
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/ClassItemPossessed.java
+++ b/src/main/java/net/rawmod/mineclass/utils/ClassItemPossessed.java
@@ -0,0 +1,42 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ClassItemPossessed {
+  /** Instance unique pré-initialisée */
+  private static ClassItemPossessed INSTANCE;
+
+  private final HashMap<String, List<ItemStack>> itemsPossessed;
+
+  /** Constructeur privé */
+  private ClassItemPossessed() {
+    itemsPossessed = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized ClassItemPossessed getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new ClassItemPossessed();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized void addItems(String playerName, List<ItemStack> itemStacks) {
+    List<ItemStack> itemStackList = itemsPossessed.getOrDefault(playerName, new ArrayList<>());
+    itemStackList.addAll(itemStacks);
+    itemsPossessed.put(playerName, itemStackList);
+  }
+
+  public synchronized void clearItems(String playerName) {
+    itemsPossessed.put(playerName, new ArrayList<>());
+  }
+
+  public synchronized List<ItemStack> getItems(String playerName) {
+    return itemsPossessed.getOrDefault(playerName, new ArrayList<>());
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/InvocationsFinder.java
+++ b/src/main/java/net/rawmod/mineclass/utils/InvocationsFinder.java
@@ -0,0 +1,58 @@
+package net.rawmod.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());
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/NumberOfInvocations.java
+++ b/src/main/java/net/rawmod/mineclass/utils/NumberOfInvocations.java
@@ -0,0 +1,47 @@
+package net.rawmod.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);
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/Pair.java
+++ b/src/main/java/net/rawmod/mineclass/utils/Pair.java
@@ -0,0 +1,27 @@
+package net.rawmod.mineclass.utils;
+
+public class Pair<F, S> {
+  private F first;
+  private S second;
+
+  public Pair(F first, S second) {
+    this.first = first;
+    this.second = second;
+  }
+
+  public F getFirst() {
+    return first;
+  }
+
+  public void setFirst(F first) {
+    this.first = first;
+  }
+
+  public S getSecond() {
+    return second;
+  }
+
+  public void setSecond(S second) {
+    this.second = second;
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/PlayerHitCounter.java
+++ b/src/main/java/net/rawmod/mineclass/utils/PlayerHitCounter.java
@@ -0,0 +1,39 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+
+public class PlayerHitCounter {
+  /** Instance unique pré-initialisée */
+  private static PlayerHitCounter INSTANCE;
+
+  private final HashMap<String, Integer> byPlayerCounter;
+
+  /** Constructeur privé */
+  private PlayerHitCounter() {
+    byPlayerCounter = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized PlayerHitCounter getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new PlayerHitCounter();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized void increaseHitCount(Player player) {
+    Integer counter = byPlayerCounter.getOrDefault(player.getName(), 0);
+    byPlayerCounter.put(player.getName(), counter + 1);
+  }
+
+  public synchronized void resetHitCounter(Player player) {
+    byPlayerCounter.put(player.getName(), 0);
+  }
+
+  public synchronized Integer getHitCounter(Player player) {
+    return byPlayerCounter.getOrDefault(player.getName(), 0);
+  }
+}
--- a/src/main/java/net/rawmod/mineclass/utils/SmeltingEngine.java
+++ b/src/main/java/net/rawmod/mineclass/utils/SmeltingEngine.java
@@ -0,0 +1,66 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.ExperienceOrb;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.FurnaceRecipe;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.Recipe;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Optional;
+
+public class SmeltingEngine {
+  /** Instance unique pré-initialisée */
+  private static SmeltingEngine INSTANCE;
+
+  private final HashMap<String, HashMap<Material, Float>> expModifier;
+
+  /** Constructeur privé */
+  private SmeltingEngine() {
+    expModifier = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized SmeltingEngine getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new SmeltingEngine();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized Optional<ItemStack> smelt(
+      Player player, Location location, ItemStack itemStack) {
+    Optional<ItemStack> result = Optional.empty();
+    Iterator<Recipe> iter = Bukkit.recipeIterator();
+    while (iter.hasNext()) {
+      Recipe recipe = iter.next();
+      if (!(recipe instanceof FurnaceRecipe)) continue;
+      if (((FurnaceRecipe) recipe).getInput().getType() != itemStack.getType()) continue;
+      result = Optional.of(recipe.getResult());
+      expModifier.computeIfAbsent(player.getName(), k -> new HashMap<>());
+      expModifier.get(player.getName()).putIfAbsent(result.get().getType(), 0.0f);
+      expModifier
+          .get(player.getName())
+          .put(
+              result.get().getType(),
+              expModifier.get(player.getName()).get(result.get().getType())
+                  + ((FurnaceRecipe) recipe).getExperience());
+      if (expModifier.get(player.getName()).get(result.get().getType()) >= 1) {
+        int exp = expModifier.get(player.getName()).get(result.get().getType()).intValue();
+        player.getWorld().spawn(location, ExperienceOrb.class).setExperience(exp);
+        expModifier
+            .get(player.getName())
+            .put(
+                result.get().getType(),
+                expModifier.get(player.getName()).get(result.get().getType()) - exp);
+      }
+      break;
+    }
+    return result;
+  }
+}