Implémentation des Icones dans la plupart des messages

src/main/java/fr/openmc/api/menulib/Menu.java

@@ -1,6 +1,6 @@
 package fr.openmc.api.menulib;
 
-import fr.openmc.api.entity.player.OMCPlayer;
+import fr.openmc.api.omcplayer.OMCPlayer;
 import fr.openmc.api.menulib.events.OpenMenuEvent;
 import fr.openmc.api.menulib.utils.InventorySize;
 import fr.openmc.api.menulib.utils.ItemMenuBuilder;

src/main/java/fr/openmc/api/omcplayer/OMCOfflinePlayer.java

@@ -0,0 +1,37 @@
+package fr.openmc.api.omcplayer;
+
+import fr.openmc.api.omcplayer.sub.OMCPlayerHome;
+import fr.openmc.core.utils.cache.CacheOfflinePlayer;
+import net.kyori.adventure.text.Component;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+@SuppressWarnings({"unused", "removal", "deprecation"})
+public interface OMCOfflinePlayer extends OfflinePlayer {
+    static OMCOfflinePlayer of(UUID playerUUID) {
+        OfflinePlayer offlinePlayer = CacheOfflinePlayer.getOfflinePlayer(playerUUID);
+        return new OMCOfflinePlayerImpl(offlinePlayer);
+    }
+
+    static OMCOfflinePlayer of(String playerName) {
+        OfflinePlayer offlinePlayer = CacheOfflinePlayer.getOfflinePlayer(playerName);
+        return new OMCOfflinePlayerImpl(offlinePlayer);
+    }
+
+    static OMCOfflinePlayer of(@NotNull OfflinePlayer player) {
+        if (player instanceof Player online)
+            return OMCPlayer.of(online);
+        if (player instanceof OMCOfflinePlayer omcPlayer)
+            return omcPlayer;
+        return new OMCOfflinePlayerImpl(player);
+    }
+
+    @NotNull OfflinePlayer getOfflinePlayer();
+
+    Component getNameWithHead();
+
+    OMCPlayerHome home();
+}

src/main/java/fr/openmc/api/omcplayer/OMCOfflinePlayerImpl.java

@@ -0,0 +1,49 @@
+package fr.openmc.api.omcplayer;
+
+import fr.openmc.api.omcplayer.sub.OMCPlayerHome;
+import fr.openmc.core.utils.cache.CachePlayerName;
+import lombok.experimental.Delegate;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.object.ObjectContents;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings({"unused", "removal", "deprecation"})
+public class OMCOfflinePlayerImpl implements OMCOfflinePlayer {
+
+    @Delegate(types = OfflinePlayer.class)
+    private final OfflinePlayer player;
+    private final OMCPlayerHome home;
+
+    OMCOfflinePlayerImpl(OfflinePlayer player) {
+        this.player = player;
+        this.home = new OMCPlayerHome(player);
+    }
+
+    @Override
+    public Component getNameWithHead() {
+        if (player == null)
+            return CachePlayerName.name(null);
+
+        String playerName = player.getName();
+
+        if (playerName == null)
+            playerName = CachePlayerName.getName(player.getUniqueId());
+
+        return Component.textOfChildren(
+                Component.object(ObjectContents.playerHead(player.getUniqueId())).color(NamedTextColor.WHITE),
+                Component.space()
+        ).append(Component.text(playerName));
+    }
+
+    @Override
+    public @NotNull OfflinePlayer getOfflinePlayer() {
+        return player;
+    }
+
+    @Override
+    public OMCPlayerHome home() {
+        return home;
+    }
+}

src/main/java/fr/openmc/api/entity/player/OMCPlayer.java → src/main/java/fr/openmc/api/omcplayer/OMCPlayer.java

@@ -1,12 +1,16 @@
-package fr.openmc.api.entity.player;
-
-import fr.openmc.api.entity.player.sub.OMCPlayerCity;
-import fr.openmc.api.entity.player.sub.OMCPlayerEconomy;
-import fr.openmc.api.entity.player.sub.OMCPlayerMessage;
-import fr.openmc.api.entity.player.sub.OMCPlayerSettings;
+package fr.openmc.api.omcplayer;
+
+import fr.openmc.api.omcplayer.sub.OMCPlayerCity;
+import fr.openmc.api.omcplayer.sub.OMCPlayerEconomy;
+import fr.openmc.api.omcplayer.sub.OMCPlayerMessage;
+import fr.openmc.api.omcplayer.sub.OMCPlayerSettings;
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.UUID;
+
 /**
  * Wrapper autour d'un {@link Player} pour les methodes propres a OpenMC
  * (economie, ville, menus...).
@@ -31,7 +35,13 @@ static OMCPlayer of(@Nullable Player player) {
         return OMCPlayerImpl.of(player);
     }
 
+    static OMCPlayer of(UUID playerUUID) {
+        return OMCPlayerImpl.of(playerUUID);
+    }
+
     @Nullable Player getPlayer();
+    @Nullable CraftPlayer getCraftPlayer();
+    ServerPlayer getServerPlayer();
 
     OMCPlayerMessage message();
 

src/main/java/fr/openmc/api/omcplayer/OMCPlayerImpl.java

@@ -0,0 +1,120 @@
+package fr.openmc.api.omcplayer;
+
+import fr.openmc.api.omcplayer.sub.OMCPlayerCity;
+import fr.openmc.api.omcplayer.sub.OMCPlayerEconomy;
+import fr.openmc.api.omcplayer.sub.OMCPlayerMessage;
+import fr.openmc.api.omcplayer.sub.OMCPlayerSettings;
+import lombok.experimental.Delegate;
+import net.minecraft.server.level.ServerPlayer;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+@SuppressWarnings({"unused", "removal", "deprecation"})
+public class OMCPlayerImpl extends OMCOfflinePlayerImpl implements OMCPlayer {
+    private static final Map<UUID, OMCPlayer> CACHE = new ConcurrentHashMap<>();
+
+    @Delegate(types = Player.class)
+    private final Player player;
+    private final OMCPlayerMessage message;
+    private final OMCPlayerCity city;
+    private final OMCPlayerEconomy economy;
+    private final OMCPlayerSettings settings;
+
+    private OMCPlayerImpl(Player player) {
+        super(player);
+        this.player = player;
+        this.message = new OMCPlayerMessage(player);
+        this.city = new OMCPlayerCity(player);
+        this.economy = new OMCPlayerEconomy(player);
+        this.settings = new OMCPlayerSettings(player);
+    }
+
+    static OMCPlayer of(Player player) {
+        if (player == null) throw new IllegalArgumentException("player ne peut pas être null");
+
+
+        return CACHE.compute(player.getUniqueId(), (id, cachedPlayer) -> {
+            if (cachedPlayer == null) return new OMCPlayerImpl(player);
+
+            Player cachedBukkitPlayer = cachedPlayer.getPlayer();
+
+            if (cachedBukkitPlayer == null
+                    || !cachedBukkitPlayer.isOnline()
+                    || !cachedBukkitPlayer.equals(player))
+                return new OMCPlayerImpl(player);
+
+            return cachedPlayer;
+        });
+    }
+
+    static OMCPlayer of(UUID playerUUID) {
+        Player playerBukkit = Bukkit.getPlayer(playerUUID);
+
+        if (playerBukkit == null) throw new IllegalArgumentException("player ne peut pas être null");
+
+        return of(playerBukkit);
+    }
+
+    @Override
+    public @Nullable Player getPlayer() {
+        return player;
+    }
+
+    @Override
+    public @Nullable CraftPlayer getCraftPlayer() {
+        return (CraftPlayer) player;
+    }
+
+    @Override
+    public ServerPlayer getServerPlayer() {
+        if (getCraftPlayer() == null)
+            throw new IllegalStateException("getCraftPlayer() ne devrait pas être null");
+        return getCraftPlayer().getHandle();
+    }
+
+    public static OMCPlayer getCache(UUID uuid) {
+        return CACHE.get(uuid);
+    }
+
+    public static void removeCache(UUID uuid) {
+        CACHE.remove(uuid);
+    }
+
+    @Override
+    public OMCPlayerMessage message() {
+        return message;
+    }
+
+    @Override
+    public OMCPlayerEconomy economy() {
+        return economy;
+    }
+
+    @Override
+    public OMCPlayerCity city() {
+        return city;
+    }
+
+    @Override
+    public OMCPlayerSettings settings() {
+        return settings;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof Player p)) return false;
+        return player.getUniqueId().equals(p.getUniqueId());
+    }
+
+    @Override
+    public int hashCode() {
+        return player.getUniqueId().hashCode();
+    }
+}