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

title, type, weight

title	type	weight
Créer des Commandes	docs	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

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 :

// 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 :

@Override
public void start() {
    getCommandRegistry().registerCommand(new HelloCommand());
}

Ajouter des Alias

Les commandes peuvent avoir plusieurs noms :

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 :

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 :

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 :

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 :

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 :

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 :

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 :

public GiveCommand() {
    super("give", "Donner des items");
    requirePermission("myplugin.admin.give");
}