Refactor code and implement ender elf

src/main/java/net/babamod/mineclass/Mineclass.java

@@ -4,6 +4,7 @@ import net.babamod.mineclass.classes.MineClassFactory;
 import net.babamod.mineclass.commands.CommandClass;
 import net.babamod.mineclass.listeners.MineClassListeners;
 import net.babamod.mineclass.utils.AppliedStatus;
+import org.bukkit.Bukkit;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.event.Listener;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -19,14 +20,20 @@ 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());
+      List<String> arguments =
+          new ArrayList<>(MineClassFactory.getInstance().getAvailableClassCodes());
       arguments.add("clear");
       arguments.add("whoami");
-      pluginCommand.setTabCompleter(
+      pluginCommand.setTabCompleter((sender, command, alias, args) -> arguments);
-          (sender, command, alias, args) ->
-              arguments);
       pluginCommand.setExecutor(new CommandClass());
     }
+    System.out.println(Bukkit.getOnlinePlayers());
+    Bukkit.getOnlinePlayers()
+        .forEach(
+            player ->
+                MineClassFactory.getInstance()
+                    .getRightClass(player)
+                    .ifPresent(aClass -> aClass.reapplyEffects(player)));
   }
 
   @Override

src/main/java/net/babamod/mineclass/classes/ElfClass.java

@@ -28,6 +28,7 @@ public class ElfClass extends MineClassImpl {
           add(Material.NETHERITE_SHOVEL);
           add(Material.CROSSBOW);
           add(Material.TRIDENT);
+          add(Material.ENDER_PEARL);
         }
       };
 

src/main/java/net/babamod/mineclass/classes/EnderElfClass.java

@@ -0,0 +1,77 @@
+package net.babamod.mineclass.classes;
+
+import net.babamod.mineclass.utils.Pair;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+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.HUNGER, 10},
+                {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";
+  }
+}

src/main/java/net/babamod/mineclass/classes/MineClass.java

@@ -25,8 +25,6 @@ public interface MineClass {
 
   boolean isItemForbidden(Material type);
 
-  boolean isItemEnchantable(Material type);
-
   void enchantItem(ItemStack itemStack);
 
   String getCode();

src/main/java/net/babamod/mineclass/classes/MineClassFactory.java

@@ -18,6 +18,7 @@ public class MineClassFactory {
     availableClasses.put("dwarf", new DwarfClass());
     availableClasses.put("elf", new ElfClass());
     availableClasses.put("fire_dwarf", new FireDwarfClass());
+    availableClasses.put("ender_elf", new EnderElfClass());
   }
 
   /** Point d'accès pour l'instance unique du singleton */
@@ -29,10 +30,6 @@ public class MineClassFactory {
     return INSTANCE;
   }
 
-  public synchronized Collection<MineClass> getAvailableClasses() {
-    return availableClasses.values();
-  }
-
   public synchronized Set<String> getAvailableClassCodes() {
     return availableClasses.keySet();
   }

src/main/java/net/babamod/mineclass/classes/MineClassImpl.java

@@ -1,5 +1,6 @@
 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;
@@ -29,6 +30,7 @@ public abstract class MineClassImpl implements MineClass {
               player.addPotionEffect(
                   new PotionEffect(key, Integer.MAX_VALUE, value - 1, false, false));
             });
+    AppliedStatus.getInstance().setStatus(player.getName(), getCode());
   }
 
   @Override
@@ -36,13 +38,9 @@ public abstract class MineClassImpl implements MineClass {
     return getForbiddenItems().contains(type);
   }
 
-  @Override
-  public boolean isItemEnchantable(Material type) {
-    return getClassEnchantments().containsKey(type);
-  }
-
   @Override
   public void enchantItem(ItemStack itemStack) {
+    if (getClassEnchantments().containsKey(itemStack.getType())) {
       getClassEnchantments()
           .getOrDefault(itemStack.getType(), new ArrayList<>())
           .forEach(
@@ -51,4 +49,5 @@ public abstract class MineClassImpl implements MineClass {
                       enchantmentIntegerPair.getFirst(), enchantmentIntegerPair.getSecond()));
       MineClassFactory.setUnbreakableAndSoulbound(itemStack);
     }
+  }
 }

src/main/java/net/babamod/mineclass/listeners/MineClassListeners.java

@@ -3,24 +3,28 @@ package net.babamod.mineclass.listeners;
 import net.babamod.mineclass.Mineclass;
 import net.babamod.mineclass.classes.MineClass;
 import net.babamod.mineclass.classes.MineClassFactory;
-import net.babamod.mineclass.utils.AppliedStatus;
+import net.babamod.mineclass.utils.*;
-import net.babamod.mineclass.utils.ApplyClassStatusTask;
+import org.bukkit.Bukkit;
-import net.babamod.mineclass.utils.ClassItemPossessed;
-import net.babamod.mineclass.utils.SmeltingEngine;
 import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.AbstractArrow;
+import org.bukkit.entity.EnderPearl;
 import org.bukkit.entity.Player;
+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.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 org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
 
 import java.util.List;
 import java.util.Optional;
@@ -41,8 +45,7 @@ public class MineClassListeners implements Listener {
     Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
     if (mineClass.isPresent()) {
       mineClass.get().reapplyEffects(player);
-      player.sendMessage(
+      player.sendMessage(String.format("Reminder : You are a %s.", mineClass.get().getCode()));
-          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.");
@@ -52,11 +55,9 @@ public class MineClassListeners implements Listener {
   @EventHandler
   public void on(PlayerItemConsumeEvent event) {
     if (event.getItem().getType().equals(Material.MILK_BUCKET)) {
-      if (AppliedStatus.getInstance().hasAClass(event.getPlayer().getName())) {
       new ApplyClassStatusTask(event.getPlayer()).runTaskLater(this.plugin, 10);
     }
   }
-  }
 
   @EventHandler
   public void on(EntityPickupItemEvent event) {
@@ -67,12 +68,10 @@ public class MineClassListeners implements Listener {
         if (mineClass.get().isItemForbidden(event.getItem().getItemStack().getType())) {
           event.setCancelled(true);
         }
-        if (mineClass.get().isItemEnchantable(event.getItem().getItemStack().getType())) {
         mineClass.get().enchantItem(event.getItem().getItemStack());
       }
     }
   }
-  }
 
   @EventHandler
   public void on(PlayerDeathEvent event) {
@@ -120,7 +119,7 @@ public class MineClassListeners implements Listener {
   private boolean isForbiddenItem(InventoryClickEvent event) {
     Player player = (Player) event.getWhoClicked();
     Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
-    if (mineClass.isPresent() && AppliedStatus.getInstance().hasAClass(player.getName())) {
+    if (mineClass.isPresent()) {
       if (event.getCurrentItem() != null
           && mineClass.get().isItemForbidden(event.getCurrentItem().getType())) {
         return true;
@@ -134,7 +133,7 @@ public class MineClassListeners implements Listener {
   private void enchantItem(InventoryClickEvent event) {
     Player player = (Player) event.getWhoClicked();
     Optional<MineClass> mineClass = MineClassFactory.getInstance().getRightClass(player);
-    if (mineClass.isPresent() && AppliedStatus.getInstance().hasAClass(player.getName())) {
+    if (mineClass.isPresent()) {
       if (event.getCurrentItem() != null && !MineClassFactory.isSoulBound(event.getCurrentItem())) {
         mineClass.get().enchantItem(event.getCurrentItem());
       }
@@ -151,7 +150,8 @@ public class MineClassListeners implements Listener {
       event
           .getItems()
           .forEach(
-              item -> SmeltingEngine.getInstance()
+              item ->
+                  SmeltingEngine.getInstance()
                       .smelt(player, event.getBlock().getLocation(), item.getItemStack())
                       .ifPresent(item::setItemStack));
     }
@@ -180,7 +180,8 @@ public class MineClassListeners implements Listener {
     if (event.getEntity() instanceof Player) {
       Player player = (Player) event.getEntity();
       if (event.getCause().equals(EntityDamageEvent.DamageCause.FALL)
-          && AppliedStatus.getInstance().getStatus(player.getName()).equals("elf")) {
+          && (AppliedStatus.getInstance().getStatus(player.getName()).equals("elf")
+              || AppliedStatus.getInstance().getStatus(player.getName()).equals("ender_elf"))) {
         event.setCancelled(true);
       }
     }
@@ -195,4 +196,55 @@ public class MineClassListeners implements Listener {
       }
     }
   }
+
+  @EventHandler
+  public void on(EntityDamageByEntityEvent event) {
+    if (event.getDamager() instanceof Player) {
+      Player player = (Player) event.getDamager();
+      if (AppliedStatus.getInstance().getStatus(player.getName()).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);
+          player.removePotionEffect(PotionEffectType.ABSORPTION);
+          player.addPotionEffect(absorption);
+        }
+        // Damage
+        event.setDamage(event.getDamage() * (player.getAttackCooldown() * 10));
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(PlayerInteractEvent event) {
+    Player player = event.getPlayer();
+    if (AppliedStatus.getInstance().getStatus(player.getName()).equals("ender_elf")
+        && event.getItem() != null
+        && event.getItem().getType().equals(Material.ENDER_PEARL)) {
+      if (event.getAction().equals(Action.RIGHT_CLICK_AIR)
+          || event.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
+        if (!PlayerLaunchedEnderPearl.getInstance().getCooldown(player)) {
+          PlayerLaunchedEnderPearl.getInstance().setCooldown(player, this.plugin);
+          player.launchProjectile(EnderPearl.class);
+        }
+        event.setCancelled(true);
+      }
+    }
+  }
+
+  @EventHandler
+  public void on(CreatureSpawnEvent event) {
+    if (event.getSpawnReason().equals(CreatureSpawnEvent.SpawnReason.ENDER_PEARL)) {
+      event.setCancelled(true);
+    }
+  }
 }

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

@@ -32,10 +32,6 @@ public class AppliedStatus implements Serializable {
     return appliedStatus.getOrDefault(playerName, "none");
   }
 
-  public synchronized boolean hasAClass(String playerName) {
-    return appliedStatus.getOrDefault(playerName, null) != null;
-  }
-
   @Override
   public boolean equals(Object o) {
     if (this == o) return true;

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

@@ -0,0 +1,18 @@
+package net.babamod.mineclass.utils;
+
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+public class EndCooldownTask extends BukkitRunnable {
+
+  private final Player player;
+
+  public EndCooldownTask(Player player) {
+    this.player = player;
+  }
+
+  @Override
+  public void run() {
+    PlayerLaunchedEnderPearl.getInstance().resetCooldown(player);
+  }
+}

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

@@ -0,0 +1,39 @@
+package net.babamod.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);
+  }
+}

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

@@ -0,0 +1,40 @@
+package net.babamod.mineclass.utils;
+
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import java.util.HashMap;
+
+public class PlayerLaunchedEnderPearl {
+  /** Instance unique pré-initialisée */
+  private static PlayerLaunchedEnderPearl INSTANCE;
+
+  private final HashMap<String, Boolean> playerLaunchedEnderPearl;
+
+  /** Constructeur privé */
+  private PlayerLaunchedEnderPearl() {
+    playerLaunchedEnderPearl = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized PlayerLaunchedEnderPearl getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new PlayerLaunchedEnderPearl();
+    }
+
+    return INSTANCE;
+  }
+
+  public void setCooldown(Player player, Plugin plugin) {
+    playerLaunchedEnderPearl.put(player.getName(), true);
+    new EndCooldownTask(player).runTaskLater(plugin, 20);
+  }
+
+  public void resetCooldown(Player player) {
+    playerLaunchedEnderPearl.put(player.getName(), false);
+  }
+
+  public boolean getCooldown(Player player) {
+    return playerLaunchedEnderPearl.getOrDefault(player.getName(), false);
+  }
+}