Init

content/core-concepts/commands/creating-commands.fr.md

@@ -0,0 +1,264 @@
+---
+title: Créer des Commandes
+type: docs
+weight: 1
+---
+
+Les commandes dans Hytale sont créées en étendant la classe `AbstractCommand`. Cette page couvre les bases de la création et de l'enregistrement des commandes.
+
+## Structure de Base d'une Commande
+
+```java
+import com.hypixel.hytale.server.core.command.system.AbstractCommand;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.Message;
+import java.util.concurrent.CompletableFuture;
+
+public class HelloCommand extends AbstractCommand {
+
+    public HelloCommand() {
+        super("hello", "Envoie un message de salutation");
+    }
+
+    @Override
+    protected CompletableFuture<Void> execute(CommandContext context) {
+        context.sendMessage(Message.raw("Bonjour, le monde !"));
+        return null;
+    }
+}
+```
+
+## Constructeurs
+
+`AbstractCommand` fournit plusieurs constructeurs :
+
+```java
+// Nom et description
+protected AbstractCommand(String name, String description)
+
+// Nom, description, et flag de confirmation requise
+protected AbstractCommand(String name, String description, boolean requiresConfirmation)
+
+// Description seule (pour les commandes variantes)
+protected AbstractCommand(String description)
+```
+
+## Enregistrer des Commandes
+
+Enregistrez les commandes dans la méthode `start()` de votre plugin :
+
+```java
+@Override
+public void start() {
+    getCommandRegistry().registerCommand(new HelloCommand());
+}
+```
+
+## Ajouter des Alias
+
+Les commandes peuvent avoir plusieurs noms :
+
+```java
+public class TeleportCommand extends AbstractCommand {
+
+    public TeleportCommand() {
+        super("teleport", "Téléporter vers un emplacement");
+        addAliases("tp", "warp");
+    }
+
+    // ...
+}
+```
+
+Les joueurs peuvent maintenant utiliser `/teleport`, `/tp`, ou `/warp`.
+
+## Commande avec Arguments
+
+Ajoutez des arguments requis avec `withRequiredArg` :
+
+```java
+import com.hypixel.hytale.server.core.command.system.AbstractCommand;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.arguments.system.RequiredArg;
+import com.hypixel.hytale.server.core.command.system.arguments.types.ArgTypes;
+// Pour les opérations ECS: import com.hypixel.hytale.component.Ref;
+// Pour les opérations ECS: import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+import com.hypixel.hytale.server.core.Message;
+import java.util.concurrent.CompletableFuture;
+
+public class GiveCommand extends AbstractCommand {
+
+    private final RequiredArg<PlayerRef> targetArg;
+    private final RequiredArg<Item> itemArg;
+
+    public GiveCommand() {
+        super("give", "Donner un item à un joueur");
+
+        targetArg = withRequiredArg("player", "Joueur cible", ArgTypes.PLAYER_REF);
+        itemArg = withRequiredArg("item", "Item à donner", ArgTypes.ITEM_ASSET);
+    }
+
+    @Override
+    protected CompletableFuture<Void> execute(CommandContext context) {
+        PlayerRef targetRef = context.get(targetArg);
+        Item item = context.get(itemArg);
+
+        // PlayerRef fournit un accès direct aux infos du joueur
+        String username = targetRef.getUsername();
+
+        // Pour les opérations ECS, utiliser getReference() pour accéder à l'EntityStore
+        // Ref<EntityStore> entityRef = targetRef.getReference();
+
+        // Donner l'item au joueur...
+        context.sendMessage(Message.raw("Item donné à " + username));
+
+        return null;
+    }
+}
+```
+
+## Arguments Optionnels
+
+Ajoutez des arguments optionnels qui n'ont pas besoin d'être spécifiés :
+
+```java
+private final OptionalArg<Integer> countArg;
+
+public GiveCommand() {
+    super("give", "Donner des items à un joueur");
+
+    targetArg = withRequiredArg("player", "Joueur cible", ArgTypes.PLAYER_REF);
+    itemArg = withRequiredArg("item", "Item à donner", ArgTypes.ITEM_ASSET);
+    countArg = withOptionalArg("count", "Nombre d'items", ArgTypes.INTEGER);
+}
+
+@Override
+protected CompletableFuture<Void> execute(CommandContext context) {
+    PlayerRef targetRef = context.get(targetArg);
+    Item item = context.get(itemArg);
+    Integer count = context.get(countArg);  // Peut être null
+
+    int amount = count != null ? count : 1;
+    // Donner les items au joueur...
+
+    return null;
+}
+```
+
+Utilisation : `/give player123 iron_sword` ou `/give player123 iron_sword --count 5`
+
+## Arguments par Défaut
+
+Arguments avec valeurs par défaut :
+
+```java
+private final DefaultArg<Integer> countArg;
+
+public GiveCommand() {
+    super("give", "Donner des items à un joueur");
+
+    countArg = withDefaultArg("count", "Nombre d'items",
+        ArgTypes.INTEGER, 1, "par défaut 1");
+}
+
+@Override
+protected CompletableFuture<Void> execute(CommandContext context) {
+    int count = context.get(countArg); // Jamais null, utilise la valeur par défaut
+    // ...
+}
+```
+
+## Arguments Flag
+
+Flags booléens qui peuvent être activés :
+
+```java
+private final FlagArg silentFlag;
+
+public BroadcastCommand() {
+    super("broadcast", "Envoyer un message à tous les joueurs");
+
+    silentFlag = withFlagArg("silent", "Ne pas afficher le nom de l'expéditeur");
+}
+
+@Override
+protected CompletableFuture<Void> execute(CommandContext context) {
+    boolean silent = context.provided(silentFlag);
+    // ...
+}
+```
+
+Utilisation : `/broadcast Bonjour à tous ! --silent`
+
+## Arguments Liste
+
+Pour les arguments qui acceptent plusieurs valeurs :
+
+```java
+private final RequiredArg<List<String>> playersArg;
+
+public KickAllCommand() {
+    super("kickall", "Expulser plusieurs joueurs");
+
+    playersArg = withListRequiredArg("players", "Joueurs à expulser", ArgTypes.STRING);
+}
+
+@Override
+protected CompletableFuture<Void> execute(CommandContext context) {
+    List<String> players = context.get(playersArg);
+    for (String player : players) {
+        // Expulser chaque joueur
+    }
+    return null;
+}
+```
+
+Utilisation : `/kickall player1 player2 player3`
+
+Méthodes d'arguments liste disponibles :
+- `withListRequiredArg(name, description, argType)` - Liste requise
+- `withListOptionalArg(name, description, argType)` - Liste optionnelle
+- `withListDefaultArg(name, description, argType, defaultValue, defaultDesc)` - Liste avec défaut
+
+## Exiger une Confirmation
+
+Pour les commandes dangereuses, exigez une confirmation explicite :
+
+```java
+public class ResetCommand extends AbstractCommand {
+
+    public ResetCommand() {
+        super("reset", "Réinitialiser toutes les données joueur", true); // requiresConfirmation = true
+    }
+
+    @Override
+    protected CompletableFuture<Void> execute(CommandContext context) {
+        // Ceci ne s'exécute que si --confirm a été fourni
+        resetAllData();
+        return null;
+    }
+}
+```
+
+Utilisation : `/reset --confirm`
+
+## Permissions
+
+Les commandes génèrent automatiquement des permissions basées sur le nom de votre plugin :
+
+```
+{group}.{plugin}.command.{commandname}
+```
+
+Par exemple : `com.example.myplugin.command.give`
+
+Vous pouvez aussi définir une permission personnalisée :
+
+```java
+public GiveCommand() {
+    super("give", "Donner des items");
+    requirePermission("myplugin.admin.give");
+}
+```