Documentation/content/world/worldgen/climate-biomes.fr.md

---
title: Climat & Biomes
type: docs
weight: 3
---

Le système de climat et de biomes détermine la distribution des biomes à travers le monde basée sur la température, l'humidité et d'autres facteurs.

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

## Système de Climat

Le `ClimateGenerator` crée des cartes de climat :

```java
public class ClimateGenerator {
    // Obtenir la température à une position
    public float getTemperature(int x, int z);

    // Obtenir l'humidité à une position
    public float getHumidity(int x, int z);

    // Obtenir le facteur d'altitude
    public float getAltitude(int x, int y, int z);

    // Obtenir les données climatiques
    public ClimateData getClimate(int x, int z);
}
```

## ClimateData

```java
public class ClimateData {
    private float temperature;  // -1.0 (froid) à 1.0 (chaud)
    private float humidity;     // 0.0 (sec) à 1.0 (humide)
    private float altitude;     // Hauteur normalisée
    private float continentality; // Distance de l'océan

    public Biome getBiome();
}
```

## Sélection de Biome

Les biomes sont sélectionnés selon les paramètres climatiques :

```java
public class BiomeSelector {
    private Map<BiomeCondition, Biome> biomeMap;

    public Biome selectBiome(ClimateData climate) {
        for (Map.Entry<BiomeCondition, Biome> entry : biomeMap.entrySet()) {
            if (entry.getKey().matches(climate)) {
                return entry.getValue();
            }
        }
        return defaultBiome;
    }
}

public class BiomeCondition {
    private Range temperatureRange;
    private Range humidityRange;
    private Range altitudeRange;

    public boolean matches(ClimateData climate) {
        return temperatureRange.contains(climate.temperature)
            && humidityRange.contains(climate.humidity)
            && altitudeRange.contains(climate.altitude);
    }
}
```

## Définition de Biome

```yaml
# biomes/forest.yaml
Type: Biome
Id: forest
DisplayName: "Forêt"
Climate:
  Temperature: [0.3, 0.7]
  Humidity: [0.4, 0.8]
Terrain:
  SurfaceBlock: grass
  SubsurfaceBlock: dirt
  StoneBlock: stone
Features:
  - Type: Tree
    Density: 0.3
    Variants: [oak, birch]
  - Type: Grass
    Density: 0.8
  - Type: Flower
    Density: 0.1
Mobs:
  - Type: deer
    SpawnWeight: 10
  - Type: rabbit
    SpawnWeight: 20
AmbientSounds:
  - birds
  - wind_leaves
```

## Zones de Température

```java
public enum TemperatureZone {
    FROZEN(-1.0f, -0.5f),    // Glace, neige
    COLD(-0.5f, 0.0f),       // Taïga, toundra
    TEMPERATE(0.0f, 0.5f),   // Forêt, plaines
    WARM(0.5f, 0.8f),        // Savane, jungle
    HOT(0.8f, 1.0f);         // Désert, volcanique

    private float min;
    private float max;
}
```

## Zones d'Humidité

```java
public enum HumidityZone {
    ARID(0.0f, 0.2f),        // Désert
    DRY(0.2f, 0.4f),         // Savane, steppe
    MODERATE(0.4f, 0.6f),    // Plaines, forêt
    HUMID(0.6f, 0.8f),       // Jungle, marais
    WET(0.8f, 1.0f);         // Forêt tropicale, marécage
}
```

## Mélange de Biomes

Transitions douces entre biomes :

```java
public class BiomeBlender {
    private int blendRadius;

    public BiomeBlendData blend(int x, int z) {
        Map<Biome, Float> weights = new HashMap<>();

        // Échantillonner les biomes environnants
        for (int dx = -blendRadius; dx <= blendRadius; dx++) {
            for (int dz = -blendRadius; dz <= blendRadius; dz++) {
                Biome biome = getBiome(x + dx, z + dz);
                float distance = (float) Math.sqrt(dx * dx + dz * dz);
                float weight = 1.0f / (1.0f + distance);
                weights.merge(biome, weight, Float::sum);
            }
        }

        return new BiomeBlendData(weights);
    }
}
```

## Bruit Climatique

```java
public class ClimateNoiseGenerator {
    private SimplexNoise temperatureNoise;
    private SimplexNoise humidityNoise;

    public ClimateNoiseGenerator(long seed) {
        temperatureNoise = new SimplexNoise(seed);
        humidityNoise = new SimplexNoise(seed + 1);
    }

    public float getTemperature(int x, int z) {
        // Variation de température à grande échelle
        float base = temperatureNoise.noise2D(x * 0.001f, z * 0.001f);
        // Variation à petite échelle
        float detail = temperatureNoise.noise2D(x * 0.01f, z * 0.01f) * 0.2f;
        return base + detail;
    }

    public float getHumidity(int x, int z) {
        return humidityNoise.noise2D(x * 0.002f, z * 0.002f);
    }
}
```

## Effets d'Altitude

```java
public class AltitudeClimateModifier {
    // La température diminue avec l'altitude
    public float modifyTemperature(float baseTemp, int altitude) {
        float altitudeFactor = altitude / 256.0f;
        return baseTemp - (altitudeFactor * 0.5f);
    }

    // L'humidité varie avec l'altitude
    public float modifyHumidity(float baseHumidity, int altitude) {
        if (altitude < 64) {
            return baseHumidity * 1.2f; // Plus humide en basse altitude
        } else if (altitude > 128) {
            return baseHumidity * 0.6f; // Plus sec en haute altitude
        }
        return baseHumidity;
    }
}
```

## Configuration

```yaml
# worldgen/climate_config.yaml
Climate:
  NoiseScale: 0.001
  TemperatureRange: [-1.0, 1.0]
  HumidityRange: [0.0, 1.0]
  BlendRadius: 8
  AltitudeEffect: true
Biomes:
  - Id: forest
    Temperature: [0.3, 0.7]
    Humidity: [0.4, 0.8]
  - Id: desert
    Temperature: [0.7, 1.0]
    Humidity: [0.0, 0.3]
  - Id: tundra
    Temperature: [-1.0, -0.3]
    Humidity: [0.2, 0.6]
```

## Bonnes Pratiques

{{< callout type="info" >}}
**Directives Climatiques :**
- Utilisez un bruit lisse pour des transitions climatiques naturelles
- Considérez l'altitude lors de la détermination des biomes
- Mélangez les biomes pour des transitions fluides
- Testez la distribution des biomes sur de grandes zones
{{< /callout >}}