---
title: Génération de Grottes
type: docs
weight: 2
---

Le système de génération de grottes crée des réseaux de grottes souterraines, des cavernes et des caractéristiques souterraines.

**Package:** `com.hypixel.hytale.server.worldgen.cave`

## Cave Generator

Le `CaveGenerator` creuse les espaces souterrains :

```java
public class CaveGenerator {
    // Générer des grottes pour un chunk
    public void generateCaves(GenerationContainer container, int chunkX, int chunkZ);

    // Vérifier si une position est dans une grotte
    public boolean isInCave(int x, int y, int z);

    // Obtenir la densité de grotte à une position
    public float getCaveDensity(int x, int y, int z);
}
```

## Types de Grottes

### Grottes Tunnel

Tunnels sinueux à travers le terrain :

```yaml
CaveType: Tunnel
Width: 3.0
Height: 4.0
Length: 50-200
Frequency: 0.02
MinY: 10
MaxY: 60
```

### Grottes Caverne

Grands espaces souterrains ouverts :

```yaml
CaveType: Cavern
MinRadius: 10
MaxRadius: 30
MinHeight: 8
MaxHeight: 20
Frequency: 0.005
MinY: 5
MaxY: 40
```

### Grottes Ravine

Formations de fissures verticales :

```yaml
CaveType: Ravine
Width: 5-15
Depth: 30-60
Length: 100-300
Frequency: 0.001
```

## Génération Basée sur le Bruit

Les grottes utilisent du bruit 3D pour des formes naturelles :

```java
public class CaveNoiseGenerator {
    private SimplexNoise primaryNoise;
    private SimplexNoise secondaryNoise;
    private float threshold;

    public boolean shouldCarve(int x, int y, int z) {
        float noise1 = primaryNoise.noise3D(x * 0.05f, y * 0.1f, z * 0.05f);
        float noise2 = secondaryNoise.noise3D(x * 0.02f, y * 0.05f, z * 0.02f);

        float combined = (noise1 + noise2) / 2.0f;
        return combined > threshold;
    }
}
```

## Creusement de Grottes

```java
public class CaveCarver {
    // Creuser une sphère à une position
    public void carveSphere(GenerationContainer container, Vector3d center, float radius);

    // Creuser un tunnel entre deux points
    public void carveTunnel(
        GenerationContainer container,
        Vector3d start,
        Vector3d end,
        float radius
    );

    // Creuser avec du bruit
    public void carveWithNoise(
        GenerationContainer container,
        Vector3d position,
        NoiseGenerator noise,
        float threshold
    );
}
```

## Décoration de Grottes

Après le creusement, les grottes sont décorées :

```java
public class CaveDecorator {
    // Ajouter stalactites/stalagmites
    public void addStalactites(GenerationContainer container, int x, int y, int z);

    // Ajouter des formations de cristaux
    public void addCrystals(GenerationContainer container, int x, int y, int z);

    // Ajouter des bassins d'eau/lave
    public void addPool(GenerationContainer container, int x, int y, int z, FluidType type);

    // Ajouter de la végétation de grotte
    public void addMushrooms(GenerationContainer container, int x, int y, int z);
}
```

## Biomes de Grottes

Différents biomes de grottes avec des caractéristiques uniques :

```yaml
# cave_biomes/crystal_cave.yaml
Type: CaveBiome
Id: crystal_cave
Features:
  - Type: CrystalCluster
    Frequency: 0.1
    MinSize: 2
    MaxSize: 8
  - Type: GlowingMushroom
    Frequency: 0.05
AmbientLight: 0.2
Blocks:
  Floor: crystal_stone
  Ceiling: crystal_stone
  Walls: smooth_stone
```

## Configuration des Grottes

```yaml
# worldgen/cave_config.yaml
CaveGeneration:
  Enabled: true
  Types:
    - Type: Tunnel
      Weight: 0.6
      MinY: 10
      MaxY: 60
    - Type: Cavern
      Weight: 0.3
      MinY: 5
      MaxY: 40
    - Type: Ravine
      Weight: 0.1
      MinY: 0
      MaxY: 64
  Decoration:
    Stalactites: true
    Pools: true
    Vegetation: true
  NoiseSettings:
    Octaves: 4
    Persistence: 0.5
    Scale: 0.05
```

## Systèmes de Grottes

Réseaux de grottes connectées :

```java
public class CaveSystem {
    private List<CaveNode> nodes;
    private List<CaveConnection> connections;

    // Générer un système connecté
    public void generate(GenerationContainer container) {
        // Créer les nœuds
        for (int i = 0; i < nodeCount; i++) {
            nodes.add(createCaveNode());
        }

        // Connecter les nœuds
        for (CaveNode node : nodes) {
            CaveNode nearest = findNearest(node);
            connections.add(new CaveConnection(node, nearest));
        }

        // Creuser les cavernes
        for (CaveNode node : nodes) {
            carver.carveCavern(container, node.position, node.radius);
        }

        // Creuser les tunnels
        for (CaveConnection conn : connections) {
            carver.carveTunnel(container, conn.start, conn.end, conn.radius);
        }
    }
}
```

## Intégration avec le Terrain

```java
public class TerrainCaveIntegration {
    // Empêcher les grottes de percer la surface
    public boolean shouldCarve(int x, int y, int z, int surfaceY) {
        // Ne pas creuser à moins de 5 blocs de la surface
        if (y > surfaceY - 5) {
            return false;
        }

        // Ne pas creuser sous le niveau de bedrock
        if (y < 5) {
            return false;
        }

        return caveNoise.shouldCarve(x, y, z);
    }
}
```

## Bonnes Pratiques

{{< callout type="info" >}}
**Directives des Grottes :**
- Équilibrez la fréquence des grottes avec la densité du monde
- Utilisez le bruit pour des formes naturelles
- Connectez les systèmes de grottes pour l'exploration
- Ajoutez de la décoration pour l'intérêt visuel
- Considérez les performances avec les grandes cavernes
{{< /callout >}}
