Init

content/world/worldgen/generation-patterns.fr.md

@@ -0,0 +1,328 @@
+---
+title: Patterns de Génération
+type: docs
+weight: 11
+---
+
+Les patterns de génération fournissent des algorithmes réutilisables pour créer des caractéristiques de terrain, des structures et des décorations.
+
+**Packages:**
+- `com.hypixel.hytale.builtin.hytalegenerator.patterns`
+- `com.hypixel.hytale.builtin.hytalegenerator.fields`
+
+## Système de Patterns
+
+Les patterns encapsulent la logique de génération :
+
+```java
+public interface GenerationPattern {
+    // Appliquer le pattern au conteneur
+    void apply(GenerationContainer container, PatternContext context);
+}
+
+public class PatternContext {
+    private Vector3i origin;
+    private int size;
+    private Random random;
+    private Map<String, Object> parameters;
+}
+```
+
+## Patterns Intégrés
+
+### SpherePattern
+
+Crée des formations sphériques :
+
+```yaml
+Type: SpherePattern
+Radius: 5
+Block: stone
+Hollow: false
+```
+
+```java
+public class SpherePattern implements GenerationPattern {
+    private float radius;
+    private BlockType block;
+    private boolean hollow;
+
+    public void apply(GenerationContainer container, PatternContext ctx) {
+        int r = (int) radius;
+        for (int dx = -r; dx <= r; dx++) {
+            for (int dy = -r; dy <= r; dy++) {
+                for (int dz = -r; dz <= r; dz++) {
+                    float dist = (float) Math.sqrt(dx*dx + dy*dy + dz*dz);
+                    if (dist <= radius && (!hollow || dist > radius - 1)) {
+                        container.setBlock(
+                            ctx.origin.x + dx,
+                            ctx.origin.y + dy,
+                            ctx.origin.z + dz,
+                            block
+                        );
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+### CylinderPattern
+
+Crée des formations cylindriques :
+
+```yaml
+Type: CylinderPattern
+Radius: 4
+Height: 10
+Block: stone
+Hollow: true
+```
+
+### ArchPattern
+
+Crée des formations d'arches :
+
+```yaml
+Type: ArchPattern
+Width: 8
+Height: 6
+Thickness: 2
+Block: stone
+```
+
+### SpirePattern
+
+Crée des formes de flèche/stalagmite :
+
+```yaml
+Type: SpirePattern
+BaseRadius: 3
+Height: 15
+TaperRate: 0.2
+Block: stone
+```
+
+## Génération par Champs
+
+Les champs génèrent des valeurs à travers l'espace 2D ou 3D :
+
+### NoiseField
+
+```java
+public class NoiseField implements Field2D {
+    private SimplexNoise noise;
+    private float scale;
+    private int octaves;
+
+    public float getValue(int x, int z) {
+        return noise.noise2D(x * scale, z * scale);
+    }
+}
+```
+
+### GradientField
+
+```java
+public class GradientField implements Field2D {
+    private Vector2f direction;
+    private float scale;
+
+    public float getValue(int x, int z) {
+        return (x * direction.x + z * direction.y) * scale;
+    }
+}
+```
+
+### VoronoiField
+
+```java
+public class VoronoiField implements Field2D {
+    private List<Vector2i> points;
+
+    public float getValue(int x, int z) {
+        float minDist = Float.MAX_VALUE;
+        for (Vector2i point : points) {
+            float dist = (float) Math.sqrt(
+                (x - point.x) * (x - point.x) +
+                (z - point.y) * (z - point.y)
+            );
+            minDist = Math.min(minDist, dist);
+        }
+        return minDist;
+    }
+}
+```
+
+## Patterns Composites
+
+### RepeatPattern
+
+Répète un pattern dans une grille :
+
+```yaml
+Type: RepeatPattern
+Pattern: pillar_pattern
+SpacingX: 10
+SpacingZ: 10
+Count: 16
+```
+
+### ScatterPattern
+
+Place des patterns à des positions aléatoires :
+
+```yaml
+Type: ScatterPattern
+Pattern: boulder_pattern
+Density: 0.05
+MinSpacing: 5
+```
+
+### ConditionalPattern
+
+Applique un pattern selon des conditions :
+
+```yaml
+Type: ConditionalPattern
+Pattern: snow_cap
+Condition:
+  Type: HeightAbove
+  Height: 100
+```
+
+## Patterns de Terrain
+
+### RiverPattern
+
+Creuse des canaux de rivière :
+
+```java
+public class RiverPattern implements GenerationPattern {
+    private List<Vector2f> path;
+    private float width;
+    private float depth;
+
+    public void apply(GenerationContainer container, PatternContext ctx) {
+        for (Vector2f point : path) {
+            carveRiverSection(container, point, width, depth);
+        }
+    }
+}
+```
+
+### CliffPattern
+
+Crée des formations de falaises :
+
+```yaml
+Type: CliffPattern
+Height: 20
+Steepness: 0.9
+NoiseScale: 0.1
+```
+
+### TerracePattern
+
+Crée un terrain en terrasses :
+
+```yaml
+Type: TerracePattern
+TerraceHeight: 5
+TerraceCount: 4
+Smoothing: 0.3
+```
+
+## Patterns de Décoration
+
+### ClusterPattern
+
+Crée des groupes de blocs :
+
+```yaml
+Type: ClusterPattern
+Block: flower_red
+Size: 3-7
+Density: 0.8
+```
+
+### VeinPattern
+
+Crée des veines de minerai :
+
+```yaml
+Type: VeinPattern
+Block: iron_ore
+Length: 10-20
+Branching: 0.3
+```
+
+### LayerPattern
+
+Crée des couches horizontales :
+
+```yaml
+Type: LayerPattern
+Layers:
+  - Block: grass_block
+    Thickness: 1
+  - Block: dirt
+    Thickness: 3
+  - Block: stone
+    Thickness: -1  # Remplir le reste
+```
+
+## Configuration
+
+```yaml
+# patterns/config.yaml
+Patterns:
+  boulder:
+    Type: SpherePattern
+    Radius: 2-4
+    Block: stone
+  tree_trunk:
+    Type: CylinderPattern
+    Radius: 1
+    Height: 5-10
+    Block: oak_log
+  crystal_cluster:
+    Type: ClusterPattern
+    Block: crystal
+    Size: 3-8
+```
+
+## Pattern Personnalisé
+
+```java
+public class MyPattern implements GenerationPattern {
+    @Override
+    public void apply(GenerationContainer container, PatternContext ctx) {
+        // Logique de génération personnalisée
+        int size = ctx.parameters.getInt("size", 5);
+
+        for (int i = 0; i < size; i++) {
+            int x = ctx.origin.x + ctx.random.nextInt(size);
+            int z = ctx.origin.z + ctx.random.nextInt(size);
+            int y = container.getHeight(x, z);
+
+            container.setBlock(x, y + 1, z, BlockTypes.STONE);
+        }
+    }
+}
+
+// Enregistrer
+patternRegistry.register("my_pattern", new MyPattern());
+```
+
+## Bonnes Pratiques
+
+{{< callout type="info" >}}
+**Directives des Patterns :**
+- Utilisez les patterns pour une logique de génération réutilisable
+- Combinez les patterns avec les champs pour la variété
+- Testez les patterns à différentes échelles
+- Considérez les performances avec les patterns complexes
+- Documentez clairement les paramètres des patterns
+{{< /callout >}}