Refactor code and remove naga class

2020-10-24 14:30:39 +02:00
parent 4db1014b2d
commit 8db992a3be
15 changed files with 297 additions and 506 deletions
--- a/src/main/java/net/babamod/mineclass/Mineclass.java
+++ b/src/main/java/net/babamod/mineclass/Mineclass.java
@@ -1,13 +1,15 @@
 package net.babamod.mineclass;

+import net.babamod.mineclass.classes.MineClassFactory;
 import net.babamod.mineclass.commands.CommandClass;
-import net.babamod.mineclass.utils.AppliedStatus;
 import net.babamod.mineclass.listeners.MineClassListeners;
+import net.babamod.mineclass.utils.AppliedStatus;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.event.Listener;
 import org.bukkit.plugin.java.JavaPlugin;

-import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;

 public final class Mineclass extends JavaPlugin implements Listener {

@@ -17,9 +19,12 @@ public final class Mineclass extends JavaPlugin implements Listener {
    new MineClassListeners(this);
    PluginCommand pluginCommand = this.getCommand("class");
    if (pluginCommand != null) {
+      List<String> arguments = new ArrayList<>(MineClassFactory.getInstance().getAvailableClassCodes());
+      arguments.add("clear");
+      arguments.add("whoami");
      pluginCommand.setTabCompleter(
          (sender, command, alias, args) ->
-              Arrays.asList("dwarf", "elf", "fire_dwarf", "naga", "clear", "whoami"));
+              arguments);
      pluginCommand.setExecutor(new CommandClass());
    }
  }
--- a/src/main/java/net/babamod/mineclass/classes/ClassWrapper.java
+++ b/src/main/java/net/babamod/mineclass/classes/ClassWrapper.java
@@ -1,147 +0,0 @@
-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;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.potion.PotionEffect;
-
-import java.util.ArrayList;
-import java.util.Collections;
-
-public class ClassWrapper {
-
-  public static boolean reapplyRightClassEffects(Player player, boolean sendReminder) {
-    if (AppliedStatus.getInstance().isDwarf(player.getName()) || DwarfClass.is(player)) {
-      AppliedStatus.getInstance().setDwarf(player.getName(), true);
-      DwarfClass.reapplyEffects(player);
-      if (sendReminder) {
-        player.sendMessage("Reminder : You are a dwarf.");
-      }
-      return true;
-    }
-    if (AppliedStatus.getInstance().isElf(player.getName()) || ElfClass.is(player)) {
-      AppliedStatus.getInstance().setElf(player.getName(), true);
-      ElfClass.reapplyEffects(player);
-      if (sendReminder) {
-        player.sendMessage("Reminder : You are an elf.");
-      }
-      return true;
-    }
-    if (AppliedStatus.getInstance().isFireDwarf(player.getName()) || FireDwarfClass.is(player)) {
-      AppliedStatus.getInstance().setFireDwarf(player.getName(), true);
-      FireDwarfClass.reapplyEffects(player);
-      if (sendReminder) {
-        player.sendMessage("Reminder : You are a fire dwarf.");
-      }
-      return true;
-    }
-    if (AppliedStatus.getInstance().isNaga(player.getName()) || NagaClass.is(player)) {
-      AppliedStatus.getInstance().setNaga(player.getName(), true);
-      NagaClass.reapplyEffects(player);
-      if (sendReminder) {
-        player.sendMessage("Reminder : You are a naga.");
-      }
-      return true;
-    }
-    return false;
-  }
-
-  public static void clearAllClassEffects(Player player) {
-    for (PotionEffect activePotionEffect : player.getActivePotionEffects()) {
-      if (activePotionEffect.getDuration() > 32766) {
-        player.removePotionEffect(activePotionEffect.getType());
-      }
-    }
-  }
-
-  public static boolean isItemForbidden(Player player, Material type) {
-    if (AppliedStatus.getInstance().isDwarf(player.getName())) {
-      return DwarfClass.isItemForbidden(type);
-    }
-    if (AppliedStatus.getInstance().isElf(player.getName())) {
-      return ElfClass.isItemForbidden(type);
-    }
-    if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
-      return FireDwarfClass.isItemForbidden(type);
-    }
-    if (AppliedStatus.getInstance().isNaga(player.getName())) {
-      return NagaClass.isItemForbidden(type);
-    }
-    return false;
-  }
-
-  public static boolean isItemEnchantable(Player player, Material type) {
-    if (AppliedStatus.getInstance().isDwarf(player.getName())) {
-      return DwarfClass.isItemEnchantable(type);
-    }
-    if (AppliedStatus.getInstance().isElf(player.getName())) {
-      return ElfClass.isItemEnchantable(type);
-    }
-    if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
-      return FireDwarfClass.isItemEnchantable(type);
-    }
-    if (AppliedStatus.getInstance().isNaga(player.getName())) {
-      return NagaClass.isItemEnchantable(type);
-    }
-    return false;
-  }
-
-  public static void enchantItem(Player player, ItemStack itemStack) {
-    if (AppliedStatus.getInstance().isDwarf(player.getName())) {
-      if (DwarfClass.isItemEnchantable(itemStack.getType())) {
-        setUnbreakableAndSoulbound(itemStack);
-        DwarfClass.enchantItem(itemStack);
-      }
-    }
-    if (AppliedStatus.getInstance().isElf(player.getName())) {
-      if (ElfClass.isItemEnchantable(itemStack.getType())) {
-        setUnbreakableAndSoulbound(itemStack);
-        ElfClass.enchantItem(itemStack);
-      }
-    }
-    if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
-      if (FireDwarfClass.isItemEnchantable(itemStack.getType())) {
-        setUnbreakableAndSoulbound(itemStack);
-        FireDwarfClass.enchantItem(itemStack);
-      }
-    }
-    if (AppliedStatus.getInstance().isNaga(player.getName())) {
-      if (NagaClass.isItemEnchantable(itemStack.getType())) {
-        setUnbreakableAndSoulbound(itemStack);
-        NagaClass.enchantItem(itemStack);
-      }
-    }
-  }
-
-  public static void removeAllEnchantments(ItemStack itemStack) {
-    itemStack.getEnchantments().keySet().forEach(itemStack::removeEnchantment);
-    removeUnbreakableAndSoulbound(itemStack);
-  }
-
-  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 static void removeUnbreakableAndSoulbound(ItemStack itemStack) {
-    if (itemStack.getItemMeta() != null) {
-      ItemMeta itemMeta = itemStack.getItemMeta();
-      itemMeta.setUnbreakable(false);
-      itemMeta.setLore(new ArrayList<>());
-      itemStack.setItemMeta(itemMeta);
-    }
-  }
-
-  public static boolean isSoulBound(ItemStack itemStack) {
-    if (itemStack.getItemMeta() != null && itemStack.getItemMeta().getLore() != null) {
-      return itemStack.getItemMeta().getLore().contains("Soulbound");
-    }
-    return false;
-  }
-}
--- a/src/main/java/net/babamod/mineclass/classes/DwarfClass.java
+++ b/src/main/java/net/babamod/mineclass/classes/DwarfClass.java
@@ -3,18 +3,15 @@ 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.PotionEffect;
 import org.bukkit.potion.PotionEffectType;

 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

-public class DwarfClass {
+public class DwarfClass extends MineClassImpl {

-  private static final Set<Material> forbiddenItems =
+  private final Set<Material> forbiddenItems =
      new HashSet<Material>() {
        {
          add(Material.DIAMOND_AXE);
@@ -30,7 +27,7 @@ public class DwarfClass {
        }
      };

-  private static final Map<PotionEffectType, Integer> potionEffects =
+  private final Map<PotionEffectType, Integer> potionEffects =
      Stream.of(
              new Object[][] {
                {PotionEffectType.HEALTH_BOOST, 2},
@@ -41,7 +38,7 @@ public class DwarfClass {
              })
          .collect(Collectors.toMap(data -> (PotionEffectType) data[0], data -> (Integer) data[1]));

-  private static final Map<Material, List<Pair<Enchantment, Integer>>> classEnchantments =
+  private final Map<Material, List<Pair<Enchantment, Integer>>> classEnchantments =
      Stream.of(
              new AbstractMap.SimpleEntry<>(
                  Material.NETHERITE_PICKAXE,
@@ -75,37 +72,23 @@ public class DwarfClass {
                      new Pair<>(Enchantment.LOOT_BONUS_BLOCKS, 2))))
          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

-  public static boolean is(Player player) {
-    return player.getActivePotionEffects().stream()
-        .map(PotionEffect::getType)
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
+  @Override
+  public Set<Material> getForbiddenItems() {
+    return forbiddenItems;
  }

-  public static void reapplyEffects(Player player) {
-    potionEffects.forEach(
-        (key, value) -> {
-          if (player.hasPotionEffect(key)) {
-            player.removePotionEffect(key);
-          }
-          player.addPotionEffect(new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
-        });
+  @Override
+  public Map<PotionEffectType, Integer> getPotionEffects() {
+    return potionEffects;
  }

-  public static boolean isItemForbidden(Material type) {
-    return forbiddenItems.contains(type);
+  @Override
+  public Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments() {
+    return classEnchantments;
  }

-  public static boolean isItemEnchantable(Material type) {
-    return classEnchantments.containsKey(type);
-  }
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
+  @Override
+  public String getCode() {
+    return "dwarf";
  }
 }
--- a/src/main/java/net/babamod/mineclass/classes/ElfClass.java
+++ b/src/main/java/net/babamod/mineclass/classes/ElfClass.java
@@ -3,16 +3,13 @@ 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.PotionEffect;
 import org.bukkit.potion.PotionEffectType;

 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

-public class ElfClass {
+public class ElfClass extends MineClassImpl {

  private static final Set<Material> forbiddenItems =
      new HashSet<Material>() {
@@ -53,37 +50,23 @@ public class ElfClass {
                      new Pair<>(Enchantment.ARROW_DAMAGE, 8))))
          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

-  public static boolean is(Player player) {
-    return player.getActivePotionEffects().stream()
-        .map(PotionEffect::getType)
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
+  @Override
+  public Set<Material> getForbiddenItems() {
+    return forbiddenItems;
  }

-  public static void reapplyEffects(Player player) {
-    potionEffects.forEach(
-        (key, value) -> {
-          if (player.hasPotionEffect(key)) {
-            player.removePotionEffect(key);
-          }
-          player.addPotionEffect(new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
-        });
+  @Override
+  public Map<PotionEffectType, Integer> getPotionEffects() {
+    return potionEffects;
  }

-  public static boolean isItemForbidden(Material type) {
-    return forbiddenItems.contains(type);
+  @Override
+  public Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments() {
+    return classEnchantments;
  }

-  public static boolean isItemEnchantable(Material type) {
-    return classEnchantments.containsKey(type);
-  }
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
+  @Override
+  public String getCode() {
+    return "elf";
  }
 }
--- a/src/main/java/net/babamod/mineclass/classes/FireDwarfClass.java
+++ b/src/main/java/net/babamod/mineclass/classes/FireDwarfClass.java
@@ -3,16 +3,13 @@ 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.PotionEffect;
 import org.bukkit.potion.PotionEffectType;

 import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;

-public class FireDwarfClass {
+public class FireDwarfClass extends MineClassImpl {

  private static final Set<Material> forbiddenItems =
      new HashSet<Material>() {
@@ -93,37 +90,23 @@ public class FireDwarfClass {
              )
          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

-  public static boolean is(Player player) {
-    return player.getActivePotionEffects().stream()
-        .map(PotionEffect::getType)
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
+  @Override
+  public Set<Material> getForbiddenItems() {
+    return forbiddenItems;
  }

-  public static void reapplyEffects(Player player) {
-    potionEffects.forEach(
-        (key, value) -> {
-          if (player.hasPotionEffect(key)) {
-            player.removePotionEffect(key);
-          }
-          player.addPotionEffect(new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
-        });
+  @Override
+  public Map<PotionEffectType, Integer> getPotionEffects() {
+    return potionEffects;
  }

-  public static boolean isItemForbidden(Material type) {
-    return forbiddenItems.contains(type);
+  @Override
+  public Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments() {
+    return classEnchantments;
  }

-  public static boolean isItemEnchantable(Material type) {
-    return classEnchantments.containsKey(type);
-  }
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
+  @Override
+  public String getCode() {
+    return "fire_dwarf";
  }
 }
--- a/src/main/java/net/babamod/mineclass/classes/MineClass.java
+++ b/src/main/java/net/babamod/mineclass/classes/MineClass.java
@@ -0,0 +1,33 @@
+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.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();
+
+  boolean is(Player player);
+
+  void reapplyEffects(Player player);
+
+  boolean isItemForbidden(Material type);
+
+  boolean isItemEnchantable(Material type);
+
+  void enchantItem(ItemStack itemStack);
+
+  String getCode();
+}
--- a/src/main/java/net/babamod/mineclass/classes/MineClassFactory.java
+++ b/src/main/java/net/babamod/mineclass/classes/MineClassFactory.java
@@ -0,0 +1,76 @@
+package net.babamod.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());
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized MineClassFactory getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new MineClassFactory();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized Collection<MineClass> getAvailableClasses() {
+    return availableClasses.values();
+  }
+
+  public synchronized Set<String> getAvailableClassCodes() {
+    return availableClasses.keySet();
+  }
+
+  public synchronized Optional<MineClass> getRightClass(Player player) {
+    for (Map.Entry<String, MineClass> stringMineClassEntry : availableClasses.entrySet()) {
+      if (stringMineClassEntry.getValue().is(player)) {
+        return Optional.of(stringMineClassEntry.getValue());
+      }
+    }
+    return Optional.empty();
+  }
+
+  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 void reapplyEffectsByCode(String code, Player player) {
+    availableClasses.get(code).reapplyEffects(player);
+  }
+
+  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);
+    }
+  }
+}
--- a/src/main/java/net/babamod/mineclass/classes/MineClassImpl.java
+++ b/src/main/java/net/babamod/mineclass/classes/MineClassImpl.java
@@ -0,0 +1,54 @@
+package net.babamod.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;
+import java.util.stream.Collectors;
+
+public abstract class MineClassImpl implements MineClass {
+
+  @Override
+  public boolean is(Player player) {
+    return player.getActivePotionEffects().stream()
+        .map(PotionEffect::getType)
+        .collect(Collectors.toList())
+        .containsAll(getPotionEffects().keySet());
+  }
+
+  @Override
+  public void reapplyEffects(Player player) {
+    getPotionEffects()
+        .forEach(
+            (key, value) -> {
+              if (player.hasPotionEffect(key)) {
+                player.removePotionEffect(key);
+              }
+              player.addPotionEffect(
+                  new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
+            });
+  }
+
+  @Override
+  public boolean isItemForbidden(Material type) {
+    return getForbiddenItems().contains(type);
+  }
+
+  @Override
+  public boolean isItemEnchantable(Material type) {
+    return getClassEnchantments().containsKey(type);
+  }
+
+  @Override
+  public void enchantItem(ItemStack itemStack) {
+    getClassEnchantments()
+        .getOrDefault(itemStack.getType(), new ArrayList<>())
+        .forEach(
+            enchantmentIntegerPair ->
+                itemStack.addUnsafeEnchantment(
+                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
+    MineClassFactory.setUnbreakableAndSoulbound(itemStack);
+  }
+}
--- a/src/main/java/net/babamod/mineclass/classes/NagaClass.java
+++ b/src/main/java/net/babamod/mineclass/classes/NagaClass.java
@@ -1,109 +0,0 @@
-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.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-
-import java.util.*;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class NagaClass {
-
-  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_AXE);
-          add(Material.GOLDEN_AXE);
-          add(Material.IRON_AXE);
-          add(Material.NETHERITE_AXE);
-          add(Material.CROSSBOW);
-          add(Material.BOW);
-          add(Material.FLINT_AND_STEEL);
-        }
-      };
-
-  private static final Map<PotionEffectType, Integer> potionEffects =
-      Stream.of(
-              new Object[][] {
-                {PotionEffectType.DOLPHINS_GRACE, 1},
-                {PotionEffectType.CONDUIT_POWER, 1},
-                {PotionEffectType.WATER_BREATHING, 1},
-                {PotionEffectType.SLOW, 2},
-                {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.TRIDENT,
-                  Arrays.asList(
-                      new Pair<>(Enchantment.LOYALTY, 3),
-                      new Pair<>(Enchantment.IMPALING, 5),
-                      new Pair<>(Enchantment.CHANNELING, 1))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.NETHERITE_HOE,
-                  Collections.singletonList(new Pair<>(Enchantment.DAMAGE_ALL, 5))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.DIAMOND_HOE,
-                  Collections.singletonList(new Pair<>(Enchantment.DAMAGE_ALL, 5))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.IRON_HOE,
-                  Collections.singletonList(new Pair<>(Enchantment.DAMAGE_ALL, 5))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.WOODEN_HOE,
-                  Collections.singletonList(new Pair<>(Enchantment.DAMAGE_ALL, 5))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.GOLDEN_HOE,
-                  Collections.singletonList(new Pair<>(Enchantment.DAMAGE_ALL, 5))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.STONE_HOE,
-                  Collections.singletonList(new Pair<>(Enchantment.DAMAGE_ALL, 5))),
-              new AbstractMap.SimpleEntry<>(
-                  Material.FISHING_ROD,
-                  Arrays.asList(new Pair<>(Enchantment.LUCK, 3), new Pair<>(Enchantment.LURE, 3))))
-          .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
-
-  public static boolean is(Player player) {
-    return player.getActivePotionEffects().stream()
-        .map(PotionEffect::getType)
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
-  }
-
-  public static void reapplyEffects(Player player) {
-    potionEffects.forEach(
-        (key, value) -> {
-          if (player.hasPotionEffect(key)) {
-            player.removePotionEffect(key);
-          }
-          player.addPotionEffect(new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
-        });
-  }
-
-  public static boolean isItemForbidden(Material type) {
-    return forbiddenItems.contains(type);
-  }
-
-  public static boolean isItemEnchantable(Material type) {
-    return classEnchantments.containsKey(type);
-  }
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
-  }
-}
--- a/src/main/java/net/babamod/mineclass/commands/CommandClass.java
+++ b/src/main/java/net/babamod/mineclass/commands/CommandClass.java
@@ -1,6 +1,6 @@
 package net.babamod.mineclass.commands;

-import net.babamod.mineclass.classes.*;
+import net.babamod.mineclass.classes.MineClassFactory;
 import net.babamod.mineclass.utils.AppliedStatus;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
@@ -11,67 +11,30 @@ 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.");
+      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 (args[0].equals("dwarf")) {
-        AppliedStatus.getInstance().setElf(player.getName(), false);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setNaga(player.getName(), false);
-        AppliedStatus.getInstance().setDwarf(player.getName(), true);
-        ClassWrapper.clearAllClassEffects(player);
-        DwarfClass.reapplyEffects(player);
-        return true;
-      }
-      if (args[0].equals("elf")) {
-        AppliedStatus.getInstance().setDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setNaga(player.getName(), false);
-        AppliedStatus.getInstance().setElf(player.getName(), true);
-        ClassWrapper.clearAllClassEffects(player);
-        ElfClass.reapplyEffects(player);
-        return true;
-      }
-      if (args[0].equals("fire_dwarf")) {
-        AppliedStatus.getInstance().setDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setElf(player.getName(), false);
-        AppliedStatus.getInstance().setNaga(player.getName(), false);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), true);
-        ClassWrapper.clearAllClassEffects(player);
-        FireDwarfClass.reapplyEffects(player);
-        return true;
-      }
-      if (args[0].equals("naga")) {
-        AppliedStatus.getInstance().setDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setElf(player.getName(), false);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setNaga(player.getName(), true);
-        ClassWrapper.clearAllClassEffects(player);
-        NagaClass.reapplyEffects(player);
+      if (MineClassFactory.getInstance().getAvailableClassCodes().contains(args[0])) {
+        AppliedStatus.getInstance().setStatus(player.getName(), args[0]);
+        MineClassFactory.clearAllClassEffects(player);
+        MineClassFactory.getInstance().reapplyEffectsByCode(args[0], player);
        return true;
      }
      if (args[0].equals("clear")) {
-        AppliedStatus.getInstance().setDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setElf(player.getName(), false);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setNaga(player.getName(), false);
-        ClassWrapper.clearAllClassEffects(player);
+        AppliedStatus.getInstance().setStatus(player.getName(), null);
+        MineClassFactory.clearAllClassEffects(player);
        return true;
      }
      if (args[0].equals("whoami")) {
-        if (AppliedStatus.getInstance().isDwarf(player.getName())) {
-          player.sendMessage("You are a dwarf.");
-        }
-        if (AppliedStatus.getInstance().isElf(player.getName())) {
-          player.sendMessage("You are an elf.");
-        }
-        if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
-          player.sendMessage("You are a fire dwarf.");
-        }
-        if (AppliedStatus.getInstance().isNaga(player.getName())) {
-          player.sendMessage("You are a naga.");
+        String classCode = AppliedStatus.getInstance().getStatus(player.getName());
+        if (!classCode.equals("none")) {
+          player.sendMessage(
+              String.format(
+                  "You are a %s.", classCode));
+        } else {
+          player.sendMessage("You are a simple steve.");
        }
        return true;
      }
--- a/src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java
+++ b/src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java
@@ -1,7 +1,8 @@
 package net.babamod.mineclass.listeners;

 import net.babamod.mineclass.Mineclass;
-import net.babamod.mineclass.classes.ClassWrapper;
+import net.babamod.mineclass.classes.MineClass;
+import net.babamod.mineclass.classes.MineClassFactory;
 import net.babamod.mineclass.utils.AppliedStatus;
 import net.babamod.mineclass.utils.ApplyClassStatusTask;
 import net.babamod.mineclass.utils.ClassItemPossessed;
@@ -16,13 +17,13 @@ import org.bukkit.event.block.BlockDropItemEvent;
 import org.bukkit.event.entity.*;
 import org.bukkit.event.inventory.InventoryAction;
 import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerItemConsumeEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.inventory.ItemStack;

 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;

 public class MineClassListeners implements Listener {
@@ -37,7 +38,12 @@ public class MineClassListeners implements Listener {
  @EventHandler
  public void on(PlayerJoinEvent event) {
    Player player = event.getPlayer();
-    if (!ClassWrapper.reapplyRightClassEffects(player, true)) {
+    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.");
    }
@@ -47,7 +53,7 @@ public class MineClassListeners implements Listener {
  public void on(PlayerItemConsumeEvent event) {
    if (event.getItem().getType().equals(Material.MILK_BUCKET)) {
      if (AppliedStatus.getInstance().hasAClass(event.getPlayer().getName())) {
-        new ApplyClassStatusTask(this.plugin, event.getPlayer()).runTaskLater(this.plugin, 10);
+        new ApplyClassStatusTask(event.getPlayer()).runTaskLater(this.plugin, 10);
      }
    }
  }
@@ -56,11 +62,14 @@ public class MineClassListeners implements Listener {
  public void on(EntityPickupItemEvent event) {
    if (event.getEntity() instanceof Player) {
      Player player = (Player) event.getEntity();
-      if (ClassWrapper.isItemForbidden(player, event.getItem().getItemStack().getType())) {
+      Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+      if (mineClass.isPresent()) {
+        if (mineClass.get().isItemForbidden(event.getItem().getItemStack().getType())) {
          event.setCancelled(true);
        }
-      if (ClassWrapper.isItemEnchantable(player, event.getItem().getItemStack().getType())) {
-        ClassWrapper.enchantItem(player, event.getItem().getItemStack());
+        if (mineClass.get().isItemEnchantable(event.getItem().getItemStack().getType())) {
+          mineClass.get().enchantItem(event.getItem().getItemStack());
+        }
      }
    }
  }
@@ -68,14 +77,16 @@ public class MineClassListeners implements Listener {
  @EventHandler
  public void on(PlayerDeathEvent event) {
    List<ItemStack> itemStackList =
-        event.getDrops().stream().filter(ClassWrapper::isSoulBound).collect(Collectors.toList());
+        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(this.plugin, event.getPlayer()).runTaskLater(this.plugin, 10);
+    new ApplyClassStatusTask(event.getPlayer()).runTaskLater(this.plugin, 10);
    ClassItemPossessed.getInstance()
        .getItems(event.getPlayer().getName())
        .forEach(itemStack -> event.getPlayer().getInventory().addItem(itemStack));
@@ -108,25 +119,27 @@ public class MineClassListeners implements Listener {

  private boolean isForbiddenItem(InventoryClickEvent event) {
    Player player = (Player) event.getWhoClicked();
-    if (AppliedStatus.getInstance().hasAClass(player.getName())) {
+    Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+    if (mineClass.isPresent() && AppliedStatus.getInstance().hasAClass(player.getName())) {
      if (event.getCurrentItem() != null
-          && ClassWrapper.isItemForbidden(player, event.getCurrentItem().getType())) {
+          && mineClass.get().isItemForbidden(event.getCurrentItem().getType())) {
        return true;
      }
      return event.getCursor() != null
-          && ClassWrapper.isItemForbidden(player, event.getCursor().getType());
+          && mineClass.get().isItemForbidden(event.getCursor().getType());
    }
    return false;
  }

  private void enchantItem(InventoryClickEvent event) {
    Player player = (Player) event.getWhoClicked();
-    if (AppliedStatus.getInstance().hasAClass(player.getName())) {
-      if (event.getCurrentItem() != null && !ClassWrapper.isSoulBound(event.getCurrentItem())) {
-        ClassWrapper.enchantItem(player, event.getCurrentItem());
+    Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
+    if (mineClass.isPresent() && AppliedStatus.getInstance().hasAClass(player.getName())) {
+      if (event.getCurrentItem() != null && !MineClassFactory.isSoulBound(event.getCurrentItem())) {
+        mineClass.get().enchantItem(event.getCurrentItem());
      }
-      if (event.getCursor() != null && !ClassWrapper.isSoulBound(event.getCursor())) {
-        ClassWrapper.enchantItem(player, event.getCursor());
+      if (event.getCursor() != null && !MineClassFactory.isSoulBound(event.getCursor())) {
+        mineClass.get().enchantItem(event.getCursor());
      }
    }
  }
@@ -134,18 +147,13 @@ public class MineClassListeners implements Listener {
  @EventHandler
  public void on(BlockDropItemEvent event) {
    Player player = event.getPlayer();
-    if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
+    if (AppliedStatus.getInstance().getStatus(player.getName()).equals("fire_dwarf")) {
      event
          .getItems()
          .forEach(
-              item -> {
-                ItemStack smelted =
-                    SmeltingEngine.getInstance()
-                        .smelt(player, event.getBlock().getLocation(), item.getItemStack());
-                if (smelted != null) {
-                  item.setItemStack(smelted);
-                }
-              });
+              item -> SmeltingEngine.getInstance()
+                  .smelt(player, event.getBlock().getLocation(), item.getItemStack())
+                  .ifPresent(item::setItemStack));
    }
  }

@@ -160,7 +168,7 @@ public class MineClassListeners implements Listener {
          ((AbstractArrow) event.getProjectile())
              .setPickupStatus(AbstractArrow.PickupStatus.DISALLOWED);
        }
-        if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
+        if (AppliedStatus.getInstance().getStatus(player.getName()).equals("fire_dwarf")) {
          event.getProjectile().setFireTicks(10000);
        }
      }
@@ -172,7 +180,7 @@ public class MineClassListeners implements Listener {
    if (event.getEntity() instanceof Player) {
      Player player = (Player) event.getEntity();
      if (event.getCause().equals(EntityDamageEvent.DamageCause.FALL)
-          && AppliedStatus.getInstance().isElf(player.getName())) {
+          && AppliedStatus.getInstance().getStatus(player.getName()).equals("elf")) {
        event.setCancelled(true);
      }
    }
@@ -182,7 +190,7 @@ public class MineClassListeners implements Listener {
  public void on(FoodLevelChangeEvent event) {
    if (event.getEntity() instanceof Player) {
      Player player = (Player) event.getEntity();
-      if (AppliedStatus.getInstance().isElf(player.getName())) {
+      if (AppliedStatus.getInstance().getStatus(player.getName()).equals("elf")) {
        event.setCancelled(true);
      }
    }
--- a/src/main/java/net/babamod/mineclass/utils/AppliedStatus.java
+++ b/src/main/java/net/babamod/mineclass/utils/AppliedStatus.java
@@ -8,17 +8,11 @@ public class AppliedStatus implements Serializable {
  /** Instance unique pré-initialisée */
  private static AppliedStatus INSTANCE;

-  private final HashMap<String, Boolean> dwarf;
-  private final HashMap<String, Boolean> elf;
-  private final HashMap<String, Boolean> fireDwarf;
-  private final HashMap<String, Boolean> naga;
+  private final HashMap<String, String> appliedStatus;

  /** Constructeur privé */
  private AppliedStatus() {
-    dwarf = new HashMap<>();
-    elf = new HashMap<>();
-    fireDwarf = new HashMap<>();
-    naga = new HashMap<>();
+    appliedStatus = new HashMap<>();
  }

  /** Point d'accès pour l'instance unique du singleton */
@@ -30,72 +24,37 @@ public class AppliedStatus implements Serializable {
    return INSTANCE;
  }

-  public synchronized void setDwarf(String playerName, boolean dwarf) {
-    this.dwarf.put(playerName, dwarf);
+  public synchronized void setStatus(String playerName, String status) {
+    appliedStatus.put(playerName, status);
  }

-  public synchronized void setElf(String playerName, boolean elf) {
-    this.elf.put(playerName, elf);
-  }
-
-  public synchronized void setFireDwarf(String playerName, boolean fireDwarf) {
-    this.fireDwarf.put(playerName, fireDwarf);
-  }
-
-  public synchronized void setNaga(String playerName, boolean naga) {
-    this.naga.put(playerName, naga);
-  }
-
-  public synchronized boolean isDwarf(String playerName) {
-    return dwarf.getOrDefault(playerName, false);
-  }
-
-  public synchronized boolean isElf(String playerName) {
-    return elf.getOrDefault(playerName, false);
-  }
-
-  public synchronized boolean isFireDwarf(String playerName) {
-    return fireDwarf.getOrDefault(playerName, false);
-  }
-
-  public synchronized boolean isNaga(String playerName) {
-    return naga.getOrDefault(playerName, false);
+  public synchronized String getStatus(String playerName) {
+    return appliedStatus.getOrDefault(playerName, "none");
  }

  public synchronized boolean hasAClass(String playerName) {
-    return dwarf.getOrDefault(playerName, false)
-        || elf.getOrDefault(playerName, false)
-        || fireDwarf.getOrDefault(playerName, false)
-        || naga.getOrDefault(playerName, false);
+    return appliedStatus.getOrDefault(playerName, null) != null;
  }

  @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(dwarf, that.dwarf)
-        && Objects.equals(elf, that.elf)
-        && Objects.equals(fireDwarf, that.fireDwarf)
-        && Objects.equals(naga, that.naga);
+
+    return Objects.equals(appliedStatus, that.appliedStatus);
  }

  @Override
  public int hashCode() {
-    return Objects.hash(dwarf, elf, fireDwarf, naga);
+    return appliedStatus.hashCode();
  }

  @Override
  public String toString() {
-    return "AppliedStatus{"
-        + "dwarf="
-        + dwarf
-        + ", elf="
-        + elf
-        + ", fireDwarf="
-        + fireDwarf
-        + ", naga="
-        + naga
-        + '}';
+    return "AppliedStatus{" +
+            "appliedStatus=" + appliedStatus +
+            '}';
  }
 }
--- a/src/main/java/net/babamod/mineclass/utils/ApplyClassStatusTask.java
+++ b/src/main/java/net/babamod/mineclass/utils/ApplyClassStatusTask.java
@@ -1,22 +1,21 @@
 package net.babamod.mineclass.utils;

-import net.babamod.mineclass.classes.ClassWrapper;
+import net.babamod.mineclass.classes.MineClassFactory;
 import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.scheduler.BukkitRunnable;

 public class ApplyClassStatusTask extends BukkitRunnable {

-  private final JavaPlugin plugin;
  private final Player player;

-  public ApplyClassStatusTask(JavaPlugin plugin, Player player) {
-    this.plugin = plugin;
+  public ApplyClassStatusTask(Player player) {
    this.player = player;
  }

  @Override
  public void run() {
-    ClassWrapper.reapplyRightClassEffects(player, false);
+    MineClassFactory.getInstance()
+        .getRightClass(player)
+        .ifPresent(mineClass -> mineClass.reapplyEffects(player));
  }
 }
--- a/src/main/java/net/babamod/mineclass/utils/ClassItemPossessed.java
+++ b/src/main/java/net/babamod/mineclass/utils/ClassItemPossessed.java
@@ -37,6 +37,6 @@ public class ClassItemPossessed {
  }

  public synchronized List<ItemStack> getItems(String playerName) {
-    return itemsPossessed.get(playerName);
+    return itemsPossessed.getOrDefault(playerName, new ArrayList<>());
  }
 }
--- a/src/main/java/net/babamod/mineclass/utils/SmeltingEngine.java
+++ b/src/main/java/net/babamod/mineclass/utils/SmeltingEngine.java
@@ -11,6 +11,7 @@ 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 */
@@ -32,28 +33,28 @@ public class SmeltingEngine {
    return INSTANCE;
  }

-  public synchronized ItemStack smelt(Player player, Location location, ItemStack itemStack) {
-    ItemStack result = null;
+  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 = recipe.getResult();
+      result = Optional.of(recipe.getResult());
      expModifier.computeIfAbsent(player.getName(), k -> new HashMap<>());
-      expModifier.get(player.getName()).putIfAbsent(result.getType(), 0.0f);
+      expModifier.get(player.getName()).putIfAbsent(result.get().getType(), 0.0f);
      expModifier
          .get(player.getName())
          .put(
-              result.getType(),
-              expModifier.get(player.getName()).get(result.getType())
+              result.get().getType(),
+              expModifier.get(player.getName()).get(result.get().getType())
                  + ((FurnaceRecipe) recipe).getExperience());
-      if (expModifier.get(player.getName()).get(result.getType()) >= 1) {
-        int exp = expModifier.get(player.getName()).get(result.getType()).intValue();
+      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.getType(), expModifier.get(player.getName()).get(result.getType()) - exp);
+            .put(result.get().getType(), expModifier.get(player.getName()).get(result.get().getType()) - exp);
      }
      break;
    }