Init

content/world/chunks.fr.md

@@ -0,0 +1,172 @@
+---
+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);
+}
+```