---
title: Tous les Registres
type: docs
weight: 2
---

Référence complète de tous les registres disponibles dans l'API Plugin Hytale.

## Aperçu des Registres

Les registres sont accessibles via les méthodes de `PluginBase` :

```java
public class MyPlugin extends PluginBase {
    @Override
    public void start() {
        EventRegistry events = getEventRegistry();
        CommandRegistry commands = getCommandRegistry();
        TaskRegistry tasks = getTaskRegistry();
        AssetRegistry assets = getAssetRegistry();
        BlockStateRegistry blocks = getBlockStateRegistry();
        CodecRegistry codecs = getCodecRegistry();
        EntityRegistry entities = getEntityRegistry();
    }
}
```

## EventRegistry

Gère les écouteurs d'événements et la diffusion.

### Méthodes

| Méthode | Description |
|---------|-------------|
| `register(Class, Consumer)` | Enregistrer un handler d'événement |
| `register(EventPriority, Class, Consumer)` | Enregistrer avec priorité |
| `registerGlobal(Class, Consumer)` | Enregistrer un handler global |
| `registerAsync(Class, Function)` | Enregistrer un handler async |
| `unregister(listener)` | Supprimer un écouteur |

### Exemple

```java
import com.hypixel.hytale.event.EventRegistry;
import com.hypixel.hytale.event.EventPriority;
import com.hypixel.hytale.server.core.event.events.player.PlayerConnectEvent;
import com.hypixel.hytale.server.core.event.events.player.PlayerDisconnectEvent;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.server.core.Message;
import java.util.logging.Level;

EventRegistry events = getEventRegistry();

// Utilisez getPlayerRef() - getPlayer() est déprécié
events.register(PlayerConnectEvent.class, event -> {
    PlayerRef playerRef = event.getPlayerRef();
    playerRef.sendMessage(Message.raw("Bienvenue !"));
});

events.register(EventPriority.FIRST, PlayerDisconnectEvent.class, event -> {
    PlayerRef playerRef = event.getPlayerRef();
    getLogger().at(Level.INFO).log(playerRef.getUsername() + " est parti");
});
```

## CommandRegistry

Gère l'enregistrement et l'exécution des commandes.

### Méthodes

| Méthode | Description |
|---------|-------------|
| `registerCommand(AbstractCommand)` | Enregistrer une commande |

### Exemple

```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.CommandRegistry;
import com.hypixel.hytale.server.core.Message;
import java.util.concurrent.CompletableFuture;

CommandRegistry commands = getCommandRegistry();

// Enregistrer une commande - AbstractCommand.execute() retourne CompletableFuture<Void>
commands.registerCommand(new AbstractCommand("hello", "my_plugin.commands.hello.description") {
    @Override
    protected CompletableFuture<Void> execute(CommandContext ctx) {
        ctx.sender().sendMessage(Message.raw("Bonjour, Monde !"));
        return null; // Retourner null pour une complétion synchrone
    }
});
```

{{< callout type="info" >}}
**Note :** Créez une classe de commande dédiée en étendant `AbstractCommand` pour les commandes complexes. Voir [Créer des Commandes](/fr/commands/creating-commands/) pour les détails.
{{< /callout >}}

## TaskRegistry

Suit les tâches asynchrones pour le nettoyage lors de l'arrêt du plugin.

{{< callout type="warning" >}}
**Important :** TaskRegistry n'a PAS de méthodes `runAsync()`, `runSync()`, `runLater()`, ou `runRepeating()`. Utilisez les APIs de concurrence standard de Java à la place.
{{< /callout >}}

### Méthodes

| Méthode | Description |
|---------|-------------|
| `registerTask(CompletableFuture<Void>)` | Enregistrer un CompletableFuture pour le suivi |
| `registerTask(ScheduledFuture<Void>)` | Enregistrer un ScheduledFuture pour le suivi |

### Exemple

```java
// Opération async
CompletableFuture<Void> task = CompletableFuture.runAsync(() -> {
    // Travail en arrière-plan
    Data result = heavyComputation();

    world.execute(() -> {
        playerRef.sendMessage(Message.raw("Terminé : " + result));
    });
});
getTaskRegistry().registerTask(task);

// Opération différée (3 secondes)
CompletableFuture.delayedExecutor(3, TimeUnit.SECONDS)
    .execute(() -> {
        world.execute(() -> {
            getLogger().at(Level.INFO).log("3 secondes passées !");
        });
    });

// Opération répétitive
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
ScheduledFuture<?> repeating = scheduler.scheduleAtFixedRate(() -> {
    broadcastTime();
}, 0, 5, TimeUnit.MINUTES);
getTaskRegistry().registerTask((ScheduledFuture<Void>) repeating);
```

## AssetRegistry

Enregistre les stores d'assets personnalisés avec le jeu.

**Package :** `com.hypixel.hytale.server.core.plugin.registry`

{{< callout type="warning" >}}
**Important :** `AssetRegistry` ne fournit PAS de méthodes `getItem()`, `getBlockType()`, etc. Pour accéder aux assets, utilisez directement les méthodes statiques de la classe d'asset.
{{< /callout >}}

### Méthodes

| Méthode | Description |
|---------|-------------|
| `register(AssetStore)` | Enregistrer un AssetStore personnalisé |

### Accéder aux Assets

Les assets sont accessibles via les méthodes statiques de leur classe, pas via AssetRegistry :

```java
import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
import com.hypixel.hytale.server.core.asset.type.item.config.Item;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;

// Obtenir les objets par ID string directement (DefaultAssetMap)
DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
Item sword = itemMap.getAsset("iron_sword");

// Obtenir les types de blocs
DefaultAssetMap<String, BlockType> blockMap = BlockType.getAssetMap();
BlockType stone = blockMap.getAsset("stone");
```

{{< callout type="info" >}}
**Note :** La plupart des assets comme `Item` et `BlockType` utilisent `DefaultAssetMap` où vous pouvez accéder directement par clé string. Certains assets comme `Interaction` utilisent `IndexedLookupTableAssetMap` qui nécessite d'obtenir l'index d'abord.
{{< /callout >}}

### Enregistrement d'Asset Store Personnalisé

```java
AssetRegistry assets = getAssetRegistry();

// Enregistrer un asset store personnalisé
assets.register(MyCustomAsset.getAssetStore());
```

## BlockStateRegistry

Gère les états de blocs et leurs propriétés.

### Méthodes

| Méthode | Description |
|---------|-------------|
| `getBlockState(BlockType)` | Obtenir l'état par défaut |
| `getBlockState(BlockType, Properties)` | Obtenir l'état avec propriétés |

### Exemple

```java
BlockStateRegistry blocks = getBlockStateRegistry();

BlockState stone = blocks.getBlockState(stoneType);
world.setBlockState(x, y, z, stone);
```

## Enregistrement de Codecs

**Package :** `com.hypixel.hytale.server.core.plugin.registry`

{{< callout type="warning" >}}
**Important :** Il n'y a pas de classe `CodecRegistry` simple. Utilisez plutôt les méthodes typées `getCodecRegistry()` avec des paramètres de codec map.
{{< /callout >}}

### Méthodes

| Méthode | Description |
|---------|-------------|
| `getCodecRegistry(StringCodecMapCodec)` | Obtenir CodecMapRegistry pour codecs à clés string |
| `getCodecRegistry(AssetCodecMapCodec)` | Obtenir CodecMapRegistry.Assets pour codecs d'assets |
| `getCodecRegistry(MapKeyMapCodec)` | Obtenir MapKeyMapRegistry pour codecs à clés map |

### Exemple

```java
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.server.core.plugin.registry.CodecMapRegistry;
import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;

// Enregistrer un type d'interaction personnalisé utilisant le CODEC d'Interaction
CodecMapRegistry.Assets<Interaction, ?> registry =
    getCodecRegistry(Interaction.CODEC);

registry.register("MyCustomInteraction", MyCustomInteraction.class, MyCustomInteraction.CODEC);
```

Pour la sérialisation simple de données, utilisez `BuilderCodec` directement :

```java
import com.hypixel.hytale.codec.builder.BuilderCodec;
import com.hypixel.hytale.codec.KeyedCodec;
import com.hypixel.hytale.codec.Codec;

// Définir un codec pour votre classe de données
public static final BuilderCodec<PlayerData> CODEC = BuilderCodec.builder(PlayerData.class, PlayerData::new)
    .append(new KeyedCodec<>("name", Codec.STRING),
            (obj, val) -> obj.name = val,
            obj -> obj.name)
    .add()
    .build();
```

## EntityRegistry

Enregistre les types d'entités personnalisés avec le jeu.

**Package :** `com.hypixel.hytale.server.core.modules.entity`

{{< callout type="warning" >}}
**Important :** `EntityRegistry` sert à enregistrer des types d'entités personnalisés, PAS à faire apparaître des entités. Pour faire apparaître des entités, utilisez `World.spawnEntity()`.
{{< /callout >}}

### Méthodes

| Méthode | Description |
|---------|-------------|
| `registerEntity(String, Class, Function, Codec)` | Enregistrer un type d'entité personnalisé |

### Enregistrer des Entités Personnalisées

```java
import com.hypixel.hytale.server.core.entity.Entity;
import com.hypixel.hytale.codec.DirectDecodeCodec;

EntityRegistry entities = getEntityRegistry();

// Enregistrer un type d'entité personnalisé
entities.registerEntity(
    "my_custom_entity",
    MyCustomEntity.class,
    world -> new MyCustomEntity(world),
    MyCustomEntity.CODEC
);
```

### Faire Apparaître des Entités

Pour faire apparaître des entités à l'exécution, utilisez `World` :

```java
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.entity.Entity;

World world = player.getWorld();

// Faire apparaître une entité
Entity entity = world.spawnEntity(entityClass, position);
```

## Patterns d'Accès aux Registres

### Initialisation Différée

```java
public class MyPlugin extends PluginBase {
    private EventRegistry events;
    private CommandRegistry commands;

    @Override
    public void start() {
        this.events = getEventRegistry();
        this.commands = getCommandRegistry();

        registerEvents();
        registerCommands();
    }

    private void registerEvents() {
        events.register(PlayerConnectEvent.class, this::onJoin);
    }

    private void registerCommands() {
        commands.registerCommand(new MyCommand());
    }
}
```

### Méthodes Helper

```java
public class MyPlugin extends JavaPlugin {
    public void runOnWorldThread(World world, Runnable task) {
        world.execute(task);
    }

    public void runAsync(Runnable task) {
        CompletableFuture.runAsync(task);
    }

    public Item getItem(String id) {
        return Item.getAssetMap().getAsset(id);
    }
}
```

## Sécurité des Threads

{{< callout type="warning" >}}
**Sécurité des Threads des Registres :**
- La plupart des registres sont conçus pour l'accès sur le thread du monde
- Chaque World s'exécute sur son propre thread dédié
- Utilisez `world.execute()` lors de l'accès depuis du code async
- TaskRegistry est thread-safe pour l'enregistrement des tâches
{{< /callout >}}

```java
// Pattern async sûr
World world = player.getWorld();
PlayerRef playerRef = player.getPlayerRef();

CompletableFuture.runAsync(() -> {
    // Travail en arrière-plan
    Data result = compute();

    // Retourner au thread du monde pour les changements d'état du jeu
    world.execute(() -> {
        // Accéder aux autres registres ici en sécurité
        EventRegistry events = getEventRegistry();
        playerRef.sendMessage(Message.raw("Résultat : " + result));
    });
});
```
