380 lines
12 KiB
Markdown
380 lines
12 KiB
Markdown
---
|
|
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));
|
|
});
|
|
});
|
|
```
|