Refactor code and remove naga class

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

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;
-  }
-}

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) {
+  @Override
-    return player.getActivePotionEffects().stream()
+  public Set<Material> getForbiddenItems() {
-        .map(PotionEffect::getType)
+    return forbiddenItems;
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
   }
 
-  public static void reapplyEffects(Player player) {
+  @Override
-    potionEffects.forEach(
+  public Map<PotionEffectType, Integer> getPotionEffects() {
-        (key, value) -> {
+    return potionEffects;
-          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) {
+  @Override
-    return forbiddenItems.contains(type);
+  public Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments() {
+    return classEnchantments;
   }
 
-  public static boolean isItemEnchantable(Material type) {
+  @Override
-    return classEnchantments.containsKey(type);
+  public String getCode() {
-  }
+    return "dwarf";
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
   }
 }

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) {
+  @Override
-    return player.getActivePotionEffects().stream()
+  public Set<Material> getForbiddenItems() {
-        .map(PotionEffect::getType)
+    return forbiddenItems;
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
   }
 
-  public static void reapplyEffects(Player player) {
+  @Override
-    potionEffects.forEach(
+  public Map<PotionEffectType, Integer> getPotionEffects() {
-        (key, value) -> {
+    return potionEffects;
-          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) {
+  @Override
-    return forbiddenItems.contains(type);
+  public Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments() {
+    return classEnchantments;
   }
 
-  public static boolean isItemEnchantable(Material type) {
+  @Override
-    return classEnchantments.containsKey(type);
+  public String getCode() {
-  }
+    return "elf";
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
   }
 }

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) {
+  @Override
-    return player.getActivePotionEffects().stream()
+  public Set<Material> getForbiddenItems() {
-        .map(PotionEffect::getType)
+    return forbiddenItems;
-        .collect(Collectors.toList())
-        .containsAll(potionEffects.keySet());
   }
 
-  public static void reapplyEffects(Player player) {
+  @Override
-    potionEffects.forEach(
+  public Map<PotionEffectType, Integer> getPotionEffects() {
-        (key, value) -> {
+    return potionEffects;
-          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) {
+  @Override
-    return forbiddenItems.contains(type);
+  public Map<Material, List<Pair<Enchantment, Integer>>> getClassEnchantments() {
+    return classEnchantments;
   }
 
-  public static boolean isItemEnchantable(Material type) {
+  @Override
-    return classEnchantments.containsKey(type);
+  public String getCode() {
-  }
+    return "fire_dwarf";
-
-  public static void enchantItem(ItemStack itemStack) {
-    classEnchantments
-        .getOrDefault(itemStack.getType(), new ArrayList<>())
-        .forEach(
-            enchantmentIntegerPair ->
-                itemStack.addUnsafeEnchantment(
-                    enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
   }
 }

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

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

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

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

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")) {
+      if (MineClassFactory.getInstance().getAvailableClassCodes().contains(args[0])) {
-        AppliedStatus.getInstance().setElf(player.getName(), false);
+        AppliedStatus.getInstance().setStatus(player.getName(), args[0]);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), false);
+        MineClassFactory.clearAllClassEffects(player);
-        AppliedStatus.getInstance().setNaga(player.getName(), false);
+        MineClassFactory.getInstance().reapplyEffectsByCode(args[0], player);
-        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);
         return true;
       }
       if (args[0].equals("clear")) {
-        AppliedStatus.getInstance().setDwarf(player.getName(), false);
+        AppliedStatus.getInstance().setStatus(player.getName(), null);
-        AppliedStatus.getInstance().setElf(player.getName(), false);
+        MineClassFactory.clearAllClassEffects(player);
-        AppliedStatus.getInstance().setFireDwarf(player.getName(), false);
-        AppliedStatus.getInstance().setNaga(player.getName(), false);
-        ClassWrapper.clearAllClassEffects(player);
         return true;
       }
       if (args[0].equals("whoami")) {
-        if (AppliedStatus.getInstance().isDwarf(player.getName())) {
+        String classCode = AppliedStatus.getInstance().getStatus(player.getName());
-          player.sendMessage("You are a dwarf.");
+        if (!classCode.equals("none")) {
-        }
+          player.sendMessage(
-        if (AppliedStatus.getInstance().isElf(player.getName())) {
+              String.format(
-          player.sendMessage("You are an elf.");
+                  "You are a %s.", classCode));
-        }
+        } else {
-        if (AppliedStatus.getInstance().isFireDwarf(player.getName())) {
+          player.sendMessage("You are a simple steve.");
-          player.sendMessage("You are a fire dwarf.");
-        }
-        if (AppliedStatus.getInstance().isNaga(player.getName())) {
-          player.sendMessage("You are a naga.");
         }
         return true;
       }

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);
-        event.setCancelled(true);
+      if (mineClass.isPresent()) {
-      }
+        if (mineClass.get().isItemForbidden(event.getItem().getItemStack().getType())) {
-      if (ClassWrapper.isItemEnchantable(player, event.getItem().getItemStack().getType())) {
+          event.setCancelled(true);
-        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())) {
+    Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
-      if (event.getCurrentItem() != null && !ClassWrapper.isSoulBound(event.getCurrentItem())) {
+    if (mineClass.isPresent() && AppliedStatus.getInstance().hasAClass(player.getName())) {
-        ClassWrapper.enchantItem(player, event.getCurrentItem());
+      if (event.getCurrentItem() != null && !MineClassFactory.isSoulBound(event.getCurrentItem())) {
+        mineClass.get().enchantItem(event.getCurrentItem());
       }
-      if (event.getCursor() != null && !ClassWrapper.isSoulBound(event.getCursor())) {
+      if (event.getCursor() != null && !MineClassFactory.isSoulBound(event.getCursor())) {
-        ClassWrapper.enchantItem(player, 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 -> {
+              item -> SmeltingEngine.getInstance()
-                ItemStack smelted =
+                  .smelt(player, event.getBlock().getLocation(), item.getItemStack())
-                    SmeltingEngine.getInstance()
+                  .ifPresent(item::setItemStack));
-                        .smelt(player, event.getBlock().getLocation(), item.getItemStack());
-                if (smelted != null) {
-                  item.setItemStack(smelted);
-                }
-              });
     }
   }
 
@@ -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);
       }
     }

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, String> appliedStatus;
-  private final HashMap<String, Boolean> elf;
-  private final HashMap<String, Boolean> fireDwarf;
-  private final HashMap<String, Boolean> naga;
 
   /** Constructeur privé */
   private AppliedStatus() {
-    dwarf = new HashMap<>();
+    appliedStatus = new HashMap<>();
-    elf = new HashMap<>();
-    fireDwarf = new HashMap<>();
-    naga = 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) {
+  public synchronized void setStatus(String playerName, String status) {
-    this.dwarf.put(playerName, dwarf);
+    appliedStatus.put(playerName, status);
   }
 
-  public synchronized void setElf(String playerName, boolean elf) {
+  public synchronized String getStatus(String playerName) {
-    this.elf.put(playerName, elf);
+    return appliedStatus.getOrDefault(playerName, "none");
-  }
-
-  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 boolean hasAClass(String playerName) {
-    return dwarf.getOrDefault(playerName, false)
+    return appliedStatus.getOrDefault(playerName, null) != null;
-        || elf.getOrDefault(playerName, false)
-        || fireDwarf.getOrDefault(playerName, false)
-        || naga.getOrDefault(playerName, false);
   }
 
   @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)
+    return Objects.equals(appliedStatus, that.appliedStatus);
-        && Objects.equals(fireDwarf, that.fireDwarf)
-        && Objects.equals(naga, that.naga);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(dwarf, elf, fireDwarf, naga);
+    return appliedStatus.hashCode();
   }
 
   @Override
   public String toString() {
-    return "AppliedStatus{"
+    return "AppliedStatus{" +
-        + "dwarf="
+            "appliedStatus=" + appliedStatus +
-        + dwarf
+            '}';
-        + ", elf="
-        + elf
-        + ", fireDwarf="
-        + fireDwarf
-        + ", naga="
-        + naga
-        + '}';
   }
 }

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) {
+  public ApplyClassStatusTask(Player player) {
-    this.plugin = plugin;
     this.player = player;
   }
 
   @Override
   public void run() {
-    ClassWrapper.reapplyRightClassEffects(player, false);
+    MineClassFactory.getInstance()
+        .getRightClass(player)
+        .ifPresent(mineClass -> mineClass.reapplyEffects(player));
   }
 }

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

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) {
+  public synchronized Optional<ItemStack> smelt(Player player, Location location, ItemStack itemStack) {
-    ItemStack result = null;
+    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(),
+              result.get().getType(),
-              expModifier.get(player.getName()).get(result.getType())
+              expModifier.get(player.getName()).get(result.get().getType())
                   + ((FurnaceRecipe) recipe).getExperience());
-      if (expModifier.get(player.getName()).get(result.getType()) >= 1) {
+      if (expModifier.get(player.getName()).get(result.get().getType()) >= 1) {
-        int exp = expModifier.get(player.getName()).get(result.getType()).intValue();
+        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;
     }