Documentation/content/world/chunks.fr.md

---
title: Chunks
type: docs
weight: 2
---

Les chunks sont l'unité fondamentale de stockage et de chargement du monde dans Hytale.

## Bases des Chunks

Un chunk représente une section de taille fixe du monde contenant des blocs :

```java
import com.hypixel.hytale.server.core.universe.Universe;
import com.hypixel.hytale.server.core.universe.world.World;
import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;

World world = Universe.get().getWorld("default");

// Les chunks sont chargés automatiquement quand nécessaire
// Accédez aux blocs via l'API World
BlockType blockType = world.getBlockType(x, y, z);
```

## Coordonnées des Chunks

Les chunks utilisent un système de coordonnées séparé des coordonnées de blocs :

```java
// Convertir les coordonnées de bloc en coordonnées de chunk
int chunkX = blockX >> 4;  // Diviser par 16
int chunkZ = blockZ >> 4;

// Convertir les coordonnées de chunk en coordonnées de bloc (coin)
int blockX = chunkX << 4;  // Multiplier par 16
int blockZ = chunkZ << 4;
```

## ChunkStore

Le ChunkStore gère la persistance des chunks :

```java
// ChunkStore gère la sauvegarde et le chargement des chunks
// Ceci est généralement géré en interne par le serveur
```

## Chargement des Chunks

Les chunks sont chargés dynamiquement en fonction des positions des joueurs :

```java
import com.hypixel.hytale.server.core.event.events.player.PlayerConnectEvent;
import com.hypixel.hytale.server.core.universe.PlayerRef;
import com.hypixel.hytale.math.vector.Vector3d;
import com.hypixel.hytale.math.vector.Transform;
import java.util.logging.Level;

getEventRegistry().register(PlayerConnectEvent.class, event -> {
    PlayerRef playerRef = event.getPlayerRef();

    // Obtenir la position depuis PlayerRef.getTransform()
    // Note : Player.getPosition() n'existe PAS !
    Transform transform = playerRef.getTransform();
    if (transform != null) {
        Vector3d pos = transform.getPosition();
        // Vector3d utilise getX(), getZ() - PAS x(), z()
        int chunkX = (int) pos.getX() >> 4;
        int chunkZ = (int) pos.getZ() >> 4;

        getLogger().at(Level.INFO).log("Joueur au chunk : " + chunkX + ", " + chunkZ);
    }
});
```

## Travailler avec les Chunks

### Itérer les Blocs d'un Chunk

```java
// Itérer tous les blocs dans une zone de chunk
int chunkX = 0;
int chunkZ = 0;
int startX = chunkX << 4;
int startZ = chunkZ << 4;

for (int x = startX; x < startX + 16; x++) {
    for (int z = startZ; z < startZ + 16; z++) {
        for (int y = 0; y < 256; y++) {
            BlockType blockType = world.getBlockType(x, y, z);
            // Traiter le bloc...
        }
    }
}
```

### Opérations par Chunk

```java
// Effectuer des opérations par chunk pour l'efficacité
public void processChunk(World world, int chunkX, int chunkZ) {
    int baseX = chunkX << 4;
    int baseZ = chunkZ << 4;

    for (int x = 0; x < 16; x++) {
        for (int z = 0; z < 16; z++) {
            // Traiter relatif à l'origine du chunk
            int worldX = baseX + x;
            int worldZ = baseZ + z;
            // ...
        }
    }
}
```

## Considérations de Performance

{{< callout type="warning" >}}
Évitez de charger ou traiter beaucoup de chunks simultanément car cela peut impacter les performances du serveur. Utilisez des opérations asynchrones pour le traitement lourd de chunks.
{{< /callout >}}

```java
import com.hypixel.hytale.server.core.Message;
import com.hypixel.hytale.math.vector.Vector3i;
import java.util.Map;
import java.util.HashMap;
import java.util.concurrent.CompletableFuture;

// Traiter les chunks de manière asynchrone
World world = player.getWorld();
PlayerRef playerRef = player.getPlayerRef();

CompletableFuture.runAsync(() -> {
    // Traitement lourd de chunks ici
    Map<Vector3i, String> results = new HashMap<>();
    // ... traiter

    // Retourner au thread du monde pour appliquer les résultats
    world.execute(() -> {
        for (var entry : results.entrySet()) {
            Vector3i pos = entry.getKey();
            // Vector3i utilise getX(), getY(), getZ() - PAS x(), y(), z()
            world.setBlock(pos.getX(), pos.getY(), pos.getZ(), entry.getValue());
        }
        playerRef.sendMessage(Message.raw("Traitement des chunks terminé !"));
    });
});
```

## Gestion des Chunks

{{< callout type="info" >}}
**Note :** Hytale gère le chargement et déchargement des chunks en interne. Il n'y a pas d'événements de chargement/déchargement de chunks exposés aux plugins. Les chunks sont automatiquement gérés en fonction des positions des joueurs et de la distance de vue.
{{< /callout >}}

```java
import com.hypixel.hytale.math.vector.Vector2i;

// Calculer les coordonnées de chunk depuis une position de joueur
public Vector2i getChunkCoords(PlayerRef playerRef) {
    Transform transform = playerRef.getTransform();
    if (transform == null) {
        return new Vector2i(0, 0);
    }

    Vector3d pos = transform.getPosition();
    // Vector3d utilise getX(), getZ() - PAS x(), z()
    int chunkX = (int) pos.getX() >> 4;
    int chunkZ = (int) pos.getZ() >> 4;
    return new Vector2i(chunkX, chunkZ);
}
```