---
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");
}
```