Documentation/content/world/worldgen/cave-generation.fr.md

title, type, weight

title	type	weight
Génération de Grottes	docs	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 :

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 :

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

Grottes Caverne

Grands espaces souterrains ouverts :

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

Grottes Ravine

Formations de fissures verticales :

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 :

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

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 :

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 :

# 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

# 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 :

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

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 >}}