Modules du jeu
==============

Le code source est organisé en six modules dans ``scripts/``.

Module Monde (``world/``)
--------------------------

Responsable de la génération et de la gestion du monde voxel sous-marin.

**BlockDatabase.gd**
   Registre central de tous les types de blocs (id, nom, texture, propriétés physiques).
   API publique : ``get_block(id: int) -> BlockData``, ``get_id_by_name(name: String) -> int``.

**Chunk.gd**
   Représente un chunk 16×16×16 blocs. Gère son maillage 3D et son état de chargement.
   API publique : ``set_block(x, y, z, id)``, ``get_block(x, y, z) -> int``, ``rebuild_mesh()``.

**ChunkManager.gd**
   Orchestre le chargement/déchargement des chunks autour du joueur (rayon configurable).
   API publique : ``get_chunk(cx, cy, cz) -> Chunk``, ``request_chunk(pos: Vector3i)``.

**WorldGenerator.gd**
   Génère le contenu des chunks de façon procédurale (bruit de Perlin, biomes, structures).
   API publique : ``generate_chunk(cx, cy, cz) -> Array`` (tableau de 4096 block ids).

Module Dauphin (``dolphin/``)
------------------------------

Contrôle du personnage joueur et interface utilisateur associée.

**DolphinController.gd**
   Gère les entrées clavier/souris, applique la physique de nage, envoie les actions au serveur.
   API publique : ``apply_input(input: Dictionary)``, ``take_damage(amount: int)``.

**HUD.gd**
   Affiche les jauges (oxygène, vie, faim), la hotbar et les notifications.
   API publique : ``update_oxygen(value: float)``, ``update_health(value: float)``,
   ``update_hunger(value: float)``.

**EcholocationPulse.gd**
   Crée et anime l'impulsion sphérique d'écholocation. Détecte les mobs et blocs dans le rayon.
   API publique : ``emit_pulse(origin: Vector3, radius: float)``.

Module Ambiance (``ambience/``)
--------------------------------

Environnement visuel et sonore sous-marin.

**UnderwaterEnvironment.gd**
   Configure le fog volumétrique, la lumière directionnelle atténuée et les effets de post-process
   selon la profondeur du joueur. API publique : ``set_depth(depth: float)``.

**AudioManager.gd**
   Singleton audio. Gère les pistes de musique et les effets sonores avec transitions douces.
   API publique : ``play_sfx(name: String)``, ``play_music(name: String)``, ``stop_music()``.

**PlanktonParticles.gd**
   Système de particules generant le plancton lumineux ambiant.
   API publique : ``set_density(density: float)``.

**MainMenu.gd**
   Logique du menu principal (navigation, transitions de scène).

Module Inventaire (``inventory/``)
-----------------------------------

Gestion des ressources, recettes et interface d'inventaire.

**Inventory.gd**
   Stockage des items du joueur (tableau de slots). Synchronisé avec le serveur en multijoueur.
   API publique : ``add_item(id: int, qty: int) -> bool``, ``remove_item(id: int, qty: int) -> bool``,
   ``has_item(id: int, qty: int) -> bool``.

**ItemDatabase.gd**
   Registre de tous les items (id, nom, icône, stack max).
   API publique : ``get_item(id: int) -> ItemData``.

**CraftingRecipes.gd**
   Définit les 5 recettes de craft et expose la logique de fabrication.
   API publique : ``get_available_recipes(inventory: Inventory) -> Array``,
   ``craft(recipe_id: int, inventory: Inventory) -> bool``.

**InventoryUI.gd**
   Interface graphique de l'inventaire et du panneau de crafting.
   API publique : ``open()``, ``close()``, ``refresh()``.

Module Mobs (``mobs/``)
------------------------

Intelligence artificielle des créatures marines.

**FishSchool.gd**
   Comportement de banc de poissons (alignment, cohesion, separation — boids simplifié).
   Fuit le joueur à proximité. API publique : ``set_school_size(n: int)``.

**Jellyfish.gd**
   Déplacement oscillant aléatoire. Inflige des dégâts de contact au joueur.
   API publique : ``get_damage() -> int``.

**Shark.gd**
   IA hostile : détection du joueur, poursuite, attaque, réaction à l'écholocation (fuite).
   API publique : ``stun(duration: float)``.

**MobSpawner.gd**
   Gère l'apparition des mobs selon le biome et la profondeur, avec limite de population.
   API publique : ``spawn_in_chunk(chunk_pos: Vector3i)``.

Module Réseau (``net/``)
-------------------------

Infrastructure multijoueur ENet.

**NetworkManager.gd**
   Singleton réseau. Initialise ENet, gère les connexions/déconnexions joueurs, expose les RPCs.
   API publique : ``host_game(port: int)``, ``join_game(ip: String, port: int)``,
   ``disconnect()``.

**PlayerSyncComponent.gd**
   Attaché à chaque ``Dolphin``. Synchronise position, rotation et état sur le réseau.
   API publique : ``sync_state(state: Dictionary)``.

**WorldSyncComponent.gd**
   Synchronise les modifications de blocs entre serveur et clients.
   API publique : ``broadcast_block_change(pos: Vector3i, block_id: int)``.

**ChatManager.gd**
   Gère l'envoi et la réception des messages de chat en multijoueur.
   API publique : ``send_message(text: String)``, ``on_message_received(sender: String, text: String)``.