Ajout du wrapper OMCPlayer

src/main/java/fr/openmc/api/entity/player/OMCOfflinePlayer.java

@@ -0,0 +1,22 @@
+package fr.openmc.api.entity.player;
+
+import fr.openmc.api.entity.player.sub.OMCPlayerHome;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings({"unused", "removal", "deprecation"})
+public interface OMCOfflinePlayer extends 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();
+
+    OMCPlayerHome home();
+}

src/main/java/fr/openmc/api/entity/player/OMCOfflinePlayerImpl.java

@@ -0,0 +1,29 @@
+package fr.openmc.api.entity.player;
+
+import fr.openmc.api.entity.player.sub.OMCPlayerHome;
+import lombok.experimental.Delegate;
+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 @NotNull OfflinePlayer getOfflinePlayer() {
+        return player;
+    }
+
+    @Override
+    public OMCPlayerHome home() {
+        return home;
+    }
+}

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

@@ -0,0 +1,44 @@
+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;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Wrapper autour d'un {@link Player} pour les methodes propres a OpenMC
+ * (economie, ville, menus...).
+ * <p>
+ * Exemples :
+ * <pre>{@code
+ * // Dans une commande Lamp, en sender ou en argument :
+ * @Command("balance")
+ * public void balance(OMCPlayer player) {
+ *      player.message().sendInfo(Component.text("Vous avez " + player.getFormattedBalance()));
+ * }
+ *
+ * // Dans un event :
+ * OMCPlayer player = OMCPlayer.of(event.getPlayer());
+ * if (player.hasCity()) { ... }
+ * }</pre>
+ */
+@SuppressWarnings({"unused", "removal", "deprecation"})
+public interface OMCPlayer extends OMCOfflinePlayer, Player {
+
+    static OMCPlayer of(@Nullable Player player) {
+        return OMCPlayerImpl.of(player);
+    }
+
+    @Nullable Player getPlayer();
+
+    OMCPlayerMessage message();
+
+    OMCPlayerEconomy economy();
+
+    OMCPlayerCity city();
+
+    OMCPlayerSettings settings();
+
+}

src/main/java/fr/openmc/api/entity/player/OMCPlayerImpl.java

@@ -0,0 +1,54 @@
+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;
+import lombok.experimental.Delegate;
+import org.bukkit.entity.Player;
+
+@SuppressWarnings({"unused", "removal", "deprecation"})
+public class OMCPlayerImpl extends OMCOfflinePlayerImpl implements OMCPlayer {
+
+    @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 instanceof OMCPlayer omcPlayer)
+            return omcPlayer;
+        return new OMCPlayerImpl(player);
+    }
+
+    @Override
+    public OMCPlayerMessage message() {
+        return message;
+    }
+
+    @Override
+    public OMCPlayerEconomy economy() {
+        return economy;
+    }
+
+    @Override
+    public OMCPlayerCity city() {
+        return city;
+    }
+
+    @Override
+    public OMCPlayerSettings settings() {
+        return settings;
+    }
+}

src/main/java/fr/openmc/api/entity/player/OMCPlayerParameterType.java

@@ -0,0 +1,24 @@
+package fr.openmc.api.entity.player;
+
+import org.jetbrains.annotations.NotNull;
+import revxrsal.commands.autocomplete.SuggestionProvider;
+import revxrsal.commands.bukkit.actor.BukkitCommandActor;
+import revxrsal.commands.bukkit.parameters.PlayerParameterType;
+import revxrsal.commands.node.ExecutionContext;
+import revxrsal.commands.parameter.ParameterType;
+import revxrsal.commands.stream.MutableStringStream;
+
+public class OMCPlayerParameterType implements ParameterType<BukkitCommandActor, OMCPlayer> {
+
+    private final PlayerParameterType delegate = new PlayerParameterType(false);
+
+    @Override
+    public OMCPlayer parse(@NotNull MutableStringStream input, @NotNull ExecutionContext<BukkitCommandActor> context) {
+        return OMCPlayer.of(delegate.parse(input, context));
+    }
+
+    @Override
+    public @NotNull SuggestionProvider<BukkitCommandActor> defaultSuggestions() {
+        return delegate.defaultSuggestions();
+    }
+}

src/main/java/fr/openmc/api/entity/player/OMCPlayerSenderResolver.java

@@ -0,0 +1,20 @@
+package fr.openmc.api.entity.player;
+
+import org.jetbrains.annotations.NotNull;
+import revxrsal.commands.bukkit.actor.BukkitCommandActor;
+import revxrsal.commands.command.CommandParameter;
+import revxrsal.commands.command.ExecutableCommand;
+import revxrsal.commands.process.SenderResolver;
+
+public class OMCPlayerSenderResolver implements SenderResolver<BukkitCommandActor> {
+
+    @Override
+    public boolean isSenderType(@NotNull CommandParameter parameter) {
+        return parameter.type() == OMCPlayer.class;
+    }
+
+    @Override
+    public @NotNull Object getSender(@NotNull Class<?> customSenderType, @NotNull BukkitCommandActor actor, @NotNull ExecutableCommand<BukkitCommandActor> command) {
+        return OMCPlayer.of(actor.requirePlayer());
+    }
+}

src/main/java/fr/openmc/api/entity/player/sub/OMCPlayerCity.java

@@ -0,0 +1,21 @@
+package fr.openmc.api.entity.player.sub;
+
+import fr.openmc.core.features.city.City;
+import fr.openmc.core.features.city.CityManager;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+public class OMCPlayerCity extends OMCPlayerFeat {
+    public OMCPlayerCity(Player player) {
+        super(player);
+    }
+
+    @Nullable
+    public City getCity() {
+        return CityManager.getCity(getUniqueId());
+    }
+
+    public boolean hasCity() {
+        return getCity() != null;
+    }
+}

src/main/java/fr/openmc/api/entity/player/sub/OMCPlayerEconomy.java

@@ -0,0 +1,55 @@
+package fr.openmc.api.entity.player.sub;
+
+import fr.openmc.core.features.economy.EconomyManager;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+public class OMCPlayerEconomy extends OMCPlayerFeat {
+    public OMCPlayerEconomy(Player player) {
+        super(player);
+    }
+
+    /**
+     * Recupere la balance du joueur
+     *
+     * @return la balance du joueur
+     */
+    public double getBalance() {
+        return EconomyManager.getBalance(getUniqueId());
+    }
+
+    /**
+     * Recupere la balance du joueur formatee avec le symbole de la monnaie
+     *
+     * @return la balance du joueur formatee
+     */
+    public String getFormattedBalance() {
+        return EconomyManager.getFormattedBalance(getUniqueId());
+    }
+
+    public void addBalance(double amount) {
+        EconomyManager.addBalance(getUniqueId(), amount);
+    }
+
+    public void addBalance(double amount, @Nullable String reason) {
+        EconomyManager.addBalance(getUniqueId(), amount, reason);
+    }
+
+    public boolean withdrawBalance(double amount) {
+        return EconomyManager.withdrawBalance(getUniqueId(), amount);
+    }
+
+    public boolean withdrawBalance(double amount, @Nullable String reason) {
+        return EconomyManager.withdrawBalance(getUniqueId(), amount, reason);
+    }
+
+    public void setBalance(double amount) {
+        EconomyManager.setBalance(getUniqueId(), amount);
+    }
+
+    public boolean pay(UUID targetUUID, double amount, @Nullable String reason) {
+        return EconomyManager.transferBalance(getUniqueId(), targetUUID, amount, reason);
+    }
+}

src/main/java/fr/openmc/api/entity/player/sub/OMCPlayerFeat.java

@@ -0,0 +1,27 @@
+package fr.openmc.api.entity.player.sub;
+
+import lombok.Getter;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+public class OMCPlayerFeat {
+
+    @Getter
+    private final OfflinePlayer offlinePlayer;
+
+    public OMCPlayerFeat(OfflinePlayer player) {
+        this.offlinePlayer = player;
+    }
+
+    public UUID getUniqueId() {
+        return offlinePlayer.getUniqueId();
+    }
+
+    @Nullable
+    public Player getPlayer() {
+        return offlinePlayer instanceof Player online ? online : offlinePlayer.getPlayer();
+    }
+}

src/main/java/fr/openmc/api/entity/player/sub/OMCPlayerHome.java

@@ -0,0 +1,74 @@
+package fr.openmc.api.entity.player.sub;
+
+import fr.openmc.core.features.homes.HomeLimits;
+import fr.openmc.core.features.homes.HomesManager;
+import fr.openmc.core.features.homes.models.Home;
+import fr.openmc.core.features.homes.models.HomeLimit;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+
+import java.util.List;
+
+public class OMCPlayerHome extends OMCPlayerFeat {
+    public OMCPlayerHome(OfflinePlayer player) {
+        super(player);
+    }
+
+    public List<Home> getHomes() {
+        return HomesManager.homes
+                .stream()
+                .filter(home -> home.getOwner().equals(getUniqueId()))
+                .toList();
+    }
+
+    public List<String> getHomesNames() {
+        return getHomes()
+                .stream()
+                .map(Home::getName)
+                .toList();
+    }
+
+    public boolean setHome(Home home) {
+        return HomesManager.homes.add(home);
+    }
+
+    public boolean removeHome(Home home) {
+        return HomesManager.homes.remove(home);
+    }
+
+    public void renameHome(Home home, String newName) {
+        home.setName(newName);
+    }
+
+    public void relocateHome(Home home, Location newLoc) {
+        HomesManager.homes.remove(home);
+    }
+
+    public HomeLimits getHomeLimit() {
+        HomeLimit homeLimit = HomesManager.homeLimits.stream()
+                .filter(hl -> hl.getPlayerUUID().equals(getUniqueId()))
+                .findFirst()
+                .orElse(null);
+
+        if (homeLimit == null) {
+            homeLimit = new HomeLimit(getUniqueId(), HomeLimits.LIMIT_0);
+            HomesManager.homeLimits.add(homeLimit);
+        }
+
+        return homeLimit.getHomeLimit();
+    }
+
+    public void updateHomeLimit() {
+        HomeLimit homeLimit = HomesManager.homeLimits.stream()
+                .filter(hl -> hl.getPlayerUUID().equals(getUniqueId()))
+                .findFirst()
+                .orElse(null);
+        if (homeLimit == null) {
+            HomesManager.homeLimits.add(new HomeLimit(getUniqueId(), HomeLimits.LIMIT_0));
+        } else {
+            int currentLimitIndex = homeLimit.getHomeLimit().ordinal();
+            HomeLimits newLimit = HomeLimits.values()[currentLimitIndex + 1];
+            homeLimit.setLimit(newLimit.getLimit());
+        }
+    }
+}