Documentation/content/world/worldgen/hytale-generator.fr.md

---
title: Hytale Generator
type: docs
weight: 7
---

Le Hytale Generator est le générateur de monde procédural par défaut qui crée le terrain, les structures et les caractéristiques de Hytale.

**Package:** `com.hypixel.hytale.builtin.hytalegenerator`

## Vue d'Ensemble

Le Hytale Generator combine plusieurs systèmes :

```
Hytale Generator
├── Fonctions de Densité (forme du terrain)
├── Material Providers (sélection de blocs)
├── Placement de Props (végétation/objets)
├── Génération de Grottes
├── Placement de Structures
└── Caractéristiques spécifiques aux biomes
```

## Structure du Générateur

```java
public class HytaleGenerator implements WorldGenerator {
    private DensityFunctionRegistry densityFunctions;
    private MaterialProviderRegistry materialProviders;
    private PropPlacementRegistry propPlacement;
    private CaveGenerator caveGenerator;
    private StructureGenerator structureGenerator;

    @Override
    public void generate(GenerationContainer container, int chunkX, int chunkZ) {
        // 1. Générer le terrain de base
        generateTerrain(container, chunkX, chunkZ);

        // 2. Creuser les grottes
        caveGenerator.generate(container, chunkX, chunkZ);

        // 3. Placer les structures
        structureGenerator.generate(container, chunkX, chunkZ);

        // 4. Placer les props
        propPlacement.generate(container, chunkX, chunkZ);

        // 5. Finaliser
        finalize(container);
    }
}
```

## Configuration d'Assets

Les assets du générateur définissent les paramètres de génération :

```yaml
# hytalegenerator/world_generator.yaml
Type: HytaleGenerator
Id: default_generator
Seed: 0  # 0 = aléatoire
TerrainDensity:
  Function: terrain_combined
  Scale: 1.0
Materials:
  Provider: biome_materials
Caves:
  Enabled: true
  Frequency: 0.5
Structures:
  Enabled: true
  Spacing: 32
Props:
  Density: 1.0
```

## Composants du Framework

Le framework du générateur fournit des utilitaires de base :

```java
// Contexte de génération
public class GenerationContext {
    private long seed;
    private int chunkX, chunkZ;
    private Biome biome;
    private Random random;

    public float noise2D(float x, float z, float scale);
    public float noise3D(float x, float y, float z, float scale);
}

// Phase de génération
public enum GenerationPhase {
    TERRAIN,
    CARVING,
    STRUCTURES,
    DECORATION,
    FINALIZATION
}
```

## Structures de Données

Structures de données spécialisées pour la génération :

```java
// Stockage de carte de hauteur
public class HeightMap2D {
    private float[] data;
    private int width, height;

    public float get(int x, int z);
    public void set(int x, int z, float value);
}

// Stockage de densité 3D
public class DensityField3D {
    private float[] data;
    private int sizeX, sizeY, sizeZ;

    public float get(int x, int y, int z);
    public float sample(float x, float y, float z);  // Interpolé
}
```

## Intégration Nouveau Système

Le générateur intègre les systèmes plus récents :

```java
public class NewSystemIntegration {
    // Enregistrer une fonction de densité personnalisée
    public void registerDensityFunction(String id, DensityFunction function);

    // Enregistrer un material provider personnalisé
    public void registerMaterialProvider(String id, MaterialProvider provider);

    // Enregistrer un placeur de props personnalisé
    public void registerPropPlacer(String id, PropPlacer placer);
}
```

## Sous-packages

| Package | Fichiers | Description |
|---------|----------|-------------|
| `assets/` | 232 | Définitions d'assets pour la génération |
| `density/` | 76 | Implémentations de fonctions de densité |
| `newsystem/` | 29 | Nouveau système de génération |
| `materialproviders/` | 29 | Sélection de matériaux |
| `framework/` | 29 | Framework de base |
| `props/` | 24 | Placement de props |
| `datastructures/` | 16 | Structures de données |
| `positionproviders/` | 14 | Calcul de positions |
| `patterns/` | 13 | Patterns de génération |
| `fields/` | 8 | Génération par champs |

## Générateur Personnalisé

Créer un générateur personnalisé :

```java
public class MyGenerator extends HytaleGenerator {
    @Override
    protected void generateTerrain(GenerationContainer container, int chunkX, int chunkZ) {
        // Génération de terrain personnalisée
        for (int x = 0; x < 16; x++) {
            for (int z = 0; z < 16; z++) {
                int worldX = chunkX * 16 + x;
                int worldZ = chunkZ * 16 + z;

                float density = getCustomDensity(worldX, worldZ);
                int height = (int) (density * 64) + 64;

                fillColumn(container, x, z, height);
            }
        }
    }
}
```

## Configuration

```yaml
# hytalegenerator/config.yaml
HytaleGenerator:
  WorldType: normal
  SeaLevel: 64
  TerrainAmplitude: 1.0
  CaveFrequency: 0.5
  StructureSpacing: 32
  BiomeScale: 256
  Features:
    Caves: true
    Structures: true
    Props: true
    Ores: true
```

## Bonnes Pratiques

{{< callout type="info" >}}
**Directives du Générateur :**
- Étendez HytaleGenerator pour des mondes personnalisés
- Utilisez le système d'assets pour la configuration
- Enregistrez les composants personnalisés dans la phase setup
- Testez la génération avec différentes seeds
- Profilez les performances des fonctions personnalisées
{{< /callout >}}