--- 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 commands.registerCommand(new AbstractCommand("hello", "my_plugin.commands.hello.description") { @Override protected CompletableFuture 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)` | Enregistrer un CompletableFuture pour le suivi | | `registerTask(ScheduledFuture)` | Enregistrer un ScheduledFuture pour le suivi | ### Exemple ```java // Opération async CompletableFuture 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) 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 itemMap = Item.getAssetMap(); Item sword = itemMap.getAsset("iron_sword"); // Obtenir les types de blocs DefaultAssetMap 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 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 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)); }); }); ```