---
title: Événements Monde
type: docs
weight: 5
---

Événements liés à la gestion des mondes, chunks et changements environnementaux.

## Événements du Cycle de Vie des Mondes

### AddWorldEvent

{{< badge "Annulable" >}}

Déclenché quand un monde est en train d'être ajouté au serveur.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde ajouté |
| universe | `Universe` | L'univers parent |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getUniverse()` - Retourne l'univers parent
- `isCancelled()` - Vérifie si annulé
- `setCancelled(boolean)` - Annule l'ajout du monde
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(AddWorldEvent.class, event -> {
    World world = event.getWorld();
    Universe universe = event.getUniverse();

    getLogger().at(Level.INFO).log("Monde ajouté : " + world.getName() + " à " + universe.getName());

    // Empêcher certains types de mondes de se charger
    if (world.getName().contains("test") && !isDevMode()) {
        event.setCancelled(true);
    }
});
```
{{< /tab >}}
{{< /tabs >}}

---

### RemoveWorldEvent

{{< badge "Annulable" >}}

Déclenché quand un monde est en train d'être retiré du serveur.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde retiré |
| reason | `RemovalReason` | Raison du retrait |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getReason()` - Retourne la raison du retrait
- `isCancelled()` - Vérifie si annulé
- `setCancelled(boolean)` - Annule le retrait du monde
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(RemoveWorldEvent.class, event -> {
    World world = event.getWorld();

    // Empêcher le retrait du monde principal
    if (world.getName().equals("main")) {
        event.setCancelled(true);
        getLogger().warning("Impossible de retirer le monde principal !");
        return;
    }

    // Sauvegarder les données avant que le monde soit retiré
    saveWorldData(world);
    notifyPlayersInWorld(world, "Le monde est en cours de déchargement !");
});
```
{{< /tab >}}
{{< /tabs >}}

---

### StartWorldEvent

Déclenché quand un monde démarre (termine son initialisation).

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde qui a démarré |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(StartWorldEvent.class, event -> {
    World world = event.getWorld();

    getLogger().at(Level.INFO).log("Monde démarré : " + world.getName());

    // Initialiser les fonctionnalités spécifiques au monde
    initializeWorldBorders(world);
    spawnWorldBoss(world);
    startWeatherCycle(world);
});
```
{{< /tab >}}
{{< /tabs >}}

---

### AllWorldsLoadedEvent

Déclenché quand tous les mondes ont fini de charger au démarrage du serveur.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| worlds | `List<World>` | Tous les mondes chargés |
{{< /tab >}}
{{< tab >}}
- `getWorlds()` - Retourne la liste de tous les mondes chargés
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(AllWorldsLoadedEvent.class, event -> {
    List<World> worlds = event.getWorlds();

    getLogger().at(Level.INFO).log("Tous les " + worlds.size() + " mondes chargés !");

    // Initialiser les fonctionnalités inter-mondes
    initializePortalNetwork(worlds);
    syncWorldTimes(worlds);
});
```
{{< /tab >}}
{{< /tabs >}}

---

## Événements de Chunk

### ChunkPreLoadProcessEvent

Déclenché avant qu'un chunk commence à charger.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde |
| chunkX | `int` | Coordonnée X du chunk |
| chunkZ | `int` | Coordonnée Z du chunk |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getChunkX()` - Retourne la coordonnée X du chunk
- `getChunkZ()` - Retourne la coordonnée Z du chunk
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(ChunkPreLoadProcessEvent.class, event -> {
    int x = event.getChunkX();
    int z = event.getChunkZ();

    // Pré-charger les données des chunks adjacents pour un chargement fluide
    prepareAdjacentChunkData(event.getWorld(), x, z);
});
```
{{< /tab >}}
{{< /tabs >}}

---

### ChunkLoadEvent

Déclenché quand un chunk finit de charger.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde |
| chunk | `Chunk` | Le chunk chargé |
| isNewChunk | `boolean` | Si c'est un chunk nouvellement généré |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getChunk()` - Retourne le chunk
- `isNewChunk()` - Retourne vrai si nouvellement généré
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(ChunkLoadEvent.class, event -> {
    Chunk chunk = event.getChunk();
    World world = event.getWorld();

    if (event.isNewChunk()) {
        // Ajouter des structures personnalisées aux nouveaux chunks
        generateCustomStructures(chunk);
        populateCustomOres(chunk);
    }

    // Restaurer les entités depuis le stockage
    loadChunkEntities(world, chunk);
});
```
{{< /tab >}}
{{< /tabs >}}

---

### ChunkUnloadEvent

Déclenché quand un chunk est sur le point d'être déchargé.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde |
| chunk | `Chunk` | Le chunk déchargé |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getChunk()` - Retourne le chunk
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(ChunkUnloadEvent.class, event -> {
    Chunk chunk = event.getChunk();
    World world = event.getWorld();

    // Sauvegarder les données personnalisées du chunk
    saveChunkEntities(world, chunk);
    saveChunkMetadata(chunk);

    // Nettoyer les ressources spécifiques au chunk
    cleanupChunkParticles(chunk);
});
```
{{< /tab >}}
{{< /tabs >}}

---

### ChunkSaveEvent

Déclenché quand un chunk est en cours de sauvegarde.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde |
| chunk | `Chunk` | Le chunk sauvegardé |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getChunk()` - Retourne le chunk
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(ChunkSaveEvent.class, event -> {
    Chunk chunk = event.getChunk();

    // Sauvegarder des données personnalisées supplémentaires avec le chunk
    saveCustomChunkData(chunk);

    getLogger().debug("Chunk sauvegardé : " + chunk.getX() + ", " + chunk.getZ());
});
```
{{< /tab >}}
{{< /tabs >}}

---

## Événements Environnementaux

### MoonPhaseChangeEvent

Déclenché quand la phase lunaire change.

**Package :** `com.hypixel.hytale.server.core.event.events.world`

{{< tabs items="Champs,Méthodes,Exemple" >}}
{{< tab >}}
| Champ | Type | Description |
|-------|------|-------------|
| world | `World` | Le monde |
| previousPhase | `MoonPhase` | Phase lunaire précédente |
| newPhase | `MoonPhase` | Nouvelle phase lunaire |
{{< /tab >}}
{{< tab >}}
- `getWorld()` - Retourne le monde
- `getPreviousPhase()` - Retourne la phase précédente
- `getNewPhase()` - Retourne la nouvelle phase
{{< /tab >}}
{{< tab >}}
```java
getEventRegistry().register(MoonPhaseChangeEvent.class, event -> {
    World world = event.getWorld();
    MoonPhase phase = event.getNewPhase();

    getLogger().at(Level.INFO).log("Phase lunaire changée en : " + phase);

    // Événements spéciaux pleine lune
    if (phase == MoonPhase.FULL) {
        increaseHostileMobSpawns(world);
        enableWerewolfTransformations(world);
    }

    // Événements de ténèbres nouvelle lune
    if (phase == MoonPhase.NEW) {
        spawnDarkCreatures(world);
    }
});
```
{{< /tab >}}
{{< /tabs >}}

---

## Exemples Pratiques

### Plugin Gestionnaire de Mondes

```java
public class WorldManagerPlugin extends JavaPlugin {

    private final Map<String, WorldConfig> worldConfigs = new HashMap<>();

    @Override
    public void start() {
        // Suivre les ajouts de mondes
        getEventRegistry().register(AddWorldEvent.class, event -> {
            World world = event.getWorld();
            WorldConfig config = loadWorldConfig(world.getName());
            worldConfigs.put(world.getName(), config);

            // Appliquer les paramètres spécifiques au monde
            applyWorldConfig(world, config);
        });

        // Gérer le retrait de monde
        getEventRegistry().register(RemoveWorldEvent.class, event -> {
            World world = event.getWorld();
            WorldConfig config = worldConfigs.remove(world.getName());

            if (config != null) {
                saveWorldConfig(world.getName(), config);
            }
        });

        // Initialiser quand tous les mondes sont prêts
        getEventRegistry().register(AllWorldsLoadedEvent.class, event -> {
            getLogger().at(Level.INFO).log("Initialisation du gestionnaire de mondes avec " +
                event.getWorlds().size() + " mondes");
            initializeCrossWorldFeatures();
        });
    }
}
```

### Système de Protection de Chunks

```java
public class ChunkProtectionPlugin extends JavaPlugin {

    private final Set<ChunkCoord> protectedChunks = new HashSet<>();

    @Override
    public void start() {
        // Charger les chunks protégés quand le chunk charge
        getEventRegistry().register(ChunkLoadEvent.class, event -> {
            Chunk chunk = event.getChunk();
            ChunkCoord coord = new ChunkCoord(
                event.getWorld().getName(),
                chunk.getX(),
                chunk.getZ()
            );

            if (isChunkProtected(coord)) {
                protectedChunks.add(coord);
                // Appliquer la protection au niveau du chunk
                markChunkAsProtected(chunk);
            }
        });

        // Sauvegarder le statut de protection au déchargement
        getEventRegistry().register(ChunkUnloadEvent.class, event -> {
            Chunk chunk = event.getChunk();
            ChunkCoord coord = new ChunkCoord(
                event.getWorld().getName(),
                chunk.getX(),
                chunk.getZ()
            );

            if (protectedChunks.contains(coord)) {
                saveProtectionStatus(coord);
            }
        });
    }

    public void protectChunk(World world, int chunkX, int chunkZ) {
        ChunkCoord coord = new ChunkCoord(world.getName(), chunkX, chunkZ);
        protectedChunks.add(coord);
        saveProtectionStatus(coord);
    }
}
```

### Événements de Monde Dynamiques

```java
public class DynamicWorldPlugin extends JavaPlugin {

    @Override
    public void start() {
        // Effets de phase lunaire
        getEventRegistry().register(MoonPhaseChangeEvent.class, event -> {
            World world = event.getWorld();
            MoonPhase phase = event.getNewPhase();

            switch (phase) {
                case FULL:
                    broadcastToWorld(world, "La pleine lune se lève...");
                    applyMoonEffect(world, "mob_spawn_increase", 2.0);
                    break;
                case NEW:
                    broadcastToWorld(world, "Les ténèbres tombent...");
                    applyMoonEffect(world, "visibility_decrease", 0.5);
                    break;
                default:
                    clearMoonEffects(world);
            }
        });

        // Génération de chunk personnalisée
        getEventRegistry().register(ChunkLoadEvent.class, event -> {
            if (event.isNewChunk()) {
                Chunk chunk = event.getChunk();

                // Ajouter des emplacements mystères
                if (random.nextFloat() < 0.01) {  // 1% de chance
                    generateMysteryStructure(chunk);
                }

                // Ajouter des nœuds de ressources
                populateResourceNodes(chunk, event.getWorld());
            }
        });
    }
}
```

## Bonnes Pratiques

{{< callout type="info" >}}
**Directives pour les Événements de Monde :**
- Utiliser `AllWorldsLoadedEvent` pour l'initialisation inter-mondes
- Sauvegarder les données importantes dans `ChunkUnloadEvent` et `RemoveWorldEvent`
- Utiliser `isNewChunk()` pour éviter de régénérer du contenu dans les chunks existants
- Être prudent en annulant `AddWorldEvent` et `RemoveWorldEvent`
- Considérer l'utilisation mémoire lors du stockage de données par chunk
{{< /callout >}}

{{< callout type="warning" >}}
**Note de Performance :** Les événements de chunk peuvent se déclencher fréquemment pendant le mouvement des joueurs. Gardez les handlers légers et évitez les opérations bloquantes.
{{< /callout >}}
