Rename main package group

src/main/java/net/rawmod/mineclass/utils/ApplyClassStatusTask.java

@@ -0,0 +1,21 @@
+package net.rawmod.mineclass.utils;
+
+import net.rawmod.mineclass.classes.MineClassFactory;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+public class ApplyClassStatusTask extends BukkitRunnable {
+
+  private final Player player;
+
+  public ApplyClassStatusTask(Player player) {
+    this.player = player;
+  }
+
+  @Override
+  public void run() {
+    MineClassFactory.getInstance()
+        .getRightClass(player)
+        .ifPresent(mineClass -> mineClass.reapplyEffects(player));
+  }
+}

src/main/java/net/rawmod/mineclass/utils/ClassItemPossessed.java

@@ -0,0 +1,42 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class ClassItemPossessed {
+  /** Instance unique pré-initialisée */
+  private static ClassItemPossessed INSTANCE;
+
+  private final HashMap<String, List<ItemStack>> itemsPossessed;
+
+  /** Constructeur privé */
+  private ClassItemPossessed() {
+    itemsPossessed = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized ClassItemPossessed getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new ClassItemPossessed();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized void addItems(String playerName, List<ItemStack> itemStacks) {
+    List<ItemStack> itemStackList = itemsPossessed.getOrDefault(playerName, new ArrayList<>());
+    itemStackList.addAll(itemStacks);
+    itemsPossessed.put(playerName, itemStackList);
+  }
+
+  public synchronized void clearItems(String playerName) {
+    itemsPossessed.put(playerName, new ArrayList<>());
+  }
+
+  public synchronized List<ItemStack> getItems(String playerName) {
+    return itemsPossessed.getOrDefault(playerName, new ArrayList<>());
+  }
+}

src/main/java/net/rawmod/mineclass/utils/InvocationsFinder.java

@@ -0,0 +1,58 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class InvocationsFinder {
+
+  public static Optional<Entity> findWolf(Player player, int i) {
+    return player.getWorld().getEntities().stream()
+        .filter(
+            entity ->
+                entity.hasMetadata("beastMasterWolf")
+                    && entity.getMetadata("beastMasterWolf").stream()
+                        .anyMatch(
+                            metadataValue -> metadataValue.asString().equals(player.getName()))
+                    && entity.hasMetadata("beastMasterWolfType")
+                    && entity.getMetadata("beastMasterWolfType").stream()
+                        .anyMatch(metadataValue -> metadataValue.asInt() == i))
+        .findFirst();
+  }
+
+  public static List<Entity> findWolfs(Player player) {
+    return player.getWorld().getEntities().stream()
+        .filter(
+            entity ->
+                entity.hasMetadata("beastMasterWolf")
+                    && entity.getMetadata("beastMasterWolf").stream()
+                        .anyMatch(
+                            metadataValue -> metadataValue.asString().equals(player.getName())))
+        .collect(Collectors.toList());
+  }
+
+  public static List<Entity> findCats(Player player) {
+    return player.getWorld().getEntities().stream()
+        .filter(
+            entity ->
+                entity.hasMetadata("beastMasterCat")
+                    && entity.getMetadata("beastMasterCat").stream()
+                        .anyMatch(
+                            metadataValue -> metadataValue.asString().equals(player.getName())))
+        .collect(Collectors.toList());
+  }
+
+  public static List<Entity> findHorses(Player player) {
+    return player.getWorld().getEntities().stream()
+        .filter(
+            entity ->
+                entity.hasMetadata("beastMasterHorse")
+                    && entity.getMetadata("beastMasterHorse").stream()
+                        .anyMatch(
+                            metadataValue -> metadataValue.asString().equals(player.getName())))
+        .collect(Collectors.toList());
+  }
+}

src/main/java/net/rawmod/mineclass/utils/NumberOfInvocations.java

@@ -0,0 +1,47 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+
+public class NumberOfInvocations {
+  /** Instance unique pré-initialisée */
+  private static NumberOfInvocations INSTANCE;
+
+  private final HashMap<String, Integer> numberOfInvocations;
+
+  /** Constructeur privé */
+  private NumberOfInvocations() {
+    numberOfInvocations = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized NumberOfInvocations getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new NumberOfInvocations();
+    }
+
+    return INSTANCE;
+  }
+
+  public boolean increaseNumber(Player player) {
+    Integer integer = numberOfInvocations.getOrDefault(player.getName(), 0);
+    if (integer == 8) {
+      return true;
+    }
+    numberOfInvocations.put(player.getName(), integer + 1);
+    return false;
+  }
+
+  public void decreaseNumber(Player player) {
+    decreaseNumber(player.getName());
+  }
+
+  public void decreaseNumber(String playerName) {
+    Integer integer = numberOfInvocations.getOrDefault(playerName, 0);
+    if (integer == 0) {
+      return;
+    }
+    numberOfInvocations.put(playerName, integer - 1);
+  }
+}

src/main/java/net/rawmod/mineclass/utils/Pair.java

@@ -0,0 +1,27 @@
+package net.rawmod.mineclass.utils;
+
+public class Pair<F, S> {
+  private F first;
+  private S second;
+
+  public Pair(F first, S second) {
+    this.first = first;
+    this.second = second;
+  }
+
+  public F getFirst() {
+    return first;
+  }
+
+  public void setFirst(F first) {
+    this.first = first;
+  }
+
+  public S getSecond() {
+    return second;
+  }
+
+  public void setSecond(S second) {
+    this.second = second;
+  }
+}

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

@@ -0,0 +1,39 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+
+public class PlayerHitCounter {
+  /** Instance unique pré-initialisée */
+  private static PlayerHitCounter INSTANCE;
+
+  private final HashMap<String, Integer> byPlayerCounter;
+
+  /** Constructeur privé */
+  private PlayerHitCounter() {
+    byPlayerCounter = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized PlayerHitCounter getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new PlayerHitCounter();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized void increaseHitCount(Player player) {
+    Integer counter = byPlayerCounter.getOrDefault(player.getName(), 0);
+    byPlayerCounter.put(player.getName(), counter + 1);
+  }
+
+  public synchronized void resetHitCounter(Player player) {
+    byPlayerCounter.put(player.getName(), 0);
+  }
+
+  public synchronized Integer getHitCounter(Player player) {
+    return byPlayerCounter.getOrDefault(player.getName(), 0);
+  }
+}

src/main/java/net/rawmod/mineclass/utils/SmeltingEngine.java

@@ -0,0 +1,66 @@
+package net.rawmod.mineclass.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.ExperienceOrb;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.FurnaceRecipe;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.Recipe;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Optional;
+
+public class SmeltingEngine {
+  /** Instance unique pré-initialisée */
+  private static SmeltingEngine INSTANCE;
+
+  private final HashMap<String, HashMap<Material, Float>> expModifier;
+
+  /** Constructeur privé */
+  private SmeltingEngine() {
+    expModifier = new HashMap<>();
+  }
+
+  /** Point d'accès pour l'instance unique du singleton */
+  public static synchronized SmeltingEngine getInstance() {
+    if (INSTANCE == null) {
+      INSTANCE = new SmeltingEngine();
+    }
+
+    return INSTANCE;
+  }
+
+  public synchronized Optional<ItemStack> smelt(
+      Player player, Location location, ItemStack itemStack) {
+    Optional<ItemStack> result = Optional.empty();
+    Iterator<Recipe> iter = Bukkit.recipeIterator();
+    while (iter.hasNext()) {
+      Recipe recipe = iter.next();
+      if (!(recipe instanceof FurnaceRecipe)) continue;
+      if (((FurnaceRecipe) recipe).getInput().getType() != itemStack.getType()) continue;
+      result = Optional.of(recipe.getResult());
+      expModifier.computeIfAbsent(player.getName(), k -> new HashMap<>());
+      expModifier.get(player.getName()).putIfAbsent(result.get().getType(), 0.0f);
+      expModifier
+          .get(player.getName())
+          .put(
+              result.get().getType(),
+              expModifier.get(player.getName()).get(result.get().getType())
+                  + ((FurnaceRecipe) recipe).getExperience());
+      if (expModifier.get(player.getName()).get(result.get().getType()) >= 1) {
+        int exp = expModifier.get(player.getName()).get(result.get().getType()).intValue();
+        player.getWorld().spawn(location, ExperienceOrb.class).setExperience(exp);
+        expModifier
+            .get(player.getName())
+            .put(
+                result.get().getType(),
+                expModifier.get(player.getName()).get(result.get().getType()) - exp);
+      }
+      break;
+    }
+    return result;
+  }
+}