First commit

.dockerignore

@@ -0,0 +1,9 @@
+**/__pycache__
+**/*.pyc
+**/*.pyo
+**/.env
+**/node_modules
+frontend/.svelte-kit
+frontend/build
+.git
+*.md

.env.example

@@ -0,0 +1,4 @@
+MISTRAL_API_KEY=your_mistral_api_key_here
+ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
+ELEVENLABS_VOICE_ID=21m00Tcm4TlvDq8ikWAM
+SECRET_KEY=change-me-in-production

.gitattributes

@@ -0,0 +1,2 @@
+*.PNG filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -0,0 +1,30 @@
+# ── Stage 1 : Build SvelteKit ────────────────────────────────────────────────
+FROM node:20-slim AS frontend-builder
+
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm ci --prefer-offline
+
+COPY frontend/ ./
+RUN npm run build          # → frontend/build/
+
+# ── Stage 2 : Runtime Python ─────────────────────────────────────────────────
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Deps Python
+COPY backend/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Code backend
+COPY backend/ ./backend/
+
+# Build frontend statique (servi par FastAPI)
+COPY --from=frontend-builder /app/frontend/build ./frontend/build
+
+# HF Spaces exige le port 7860
+EXPOSE 7860
+
+WORKDIR /app/backend
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,214 @@
+---
+title: VoiceStrike
+emoji: ⚡
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# VoiceStrike — RTS commandé à la voix
+
+> Hackathon Mistral × ElevenLabs — Hébergé sur Hugging Face Spaces
+
+Un jeu de stratégie en temps réel 1v1 entièrement contrôlé à la voix. Inspiré de la race Terran de StarCraft, simplifié pour être jouable sur mobile avec seulement un micro.
+
+---
+
+## Concept
+
+Le joueur parle pour donner des ordres : *"Construis des barracks, entraîne 4 marines, attaque la base ennemie"*. L'IA (Mistral) interprète les commandes en langage naturel et les traduit en actions de jeu. ElevenLabs restitue les retours audio du jeu (*"Construction terminée", "Sous attaque !"*).
+
+Le toucher / la souris servent uniquement à naviguer sur la carte, inspecter les unités ou les techs — jamais pour jouer.
+
+---
+
+## Stack
+
+| Couche | Technologie |
+|---|---|
+| Frontend | SvelteKit + socket.io-client |
+| Backend | FastAPI + python-socketio (asyncio) |
+| Interprétation commandes | Mistral API (mistral-large) |
+| Voix → Texte | ElevenLabs Speech-to-Text |
+| Texte → Voix | ElevenLabs TTS |
+| Hosting | Hugging Face Spaces (Docker) |
+
+---
+
+## Architecture du projet
+
+```
+hackaton/
+├── Dockerfile                  # HF Spaces — expose port 7860
+├── docker-compose.yml          # Dev local
+├── .env.example
+│
+├── backend/
+│   ├── main.py                 # Point d'entrée : FastAPI + Socket.IO montés ensemble
+│   ├── requirements.txt
+│   │
+│   ├── lobby/
+│   │   └── manager.py          # Création / jointure de rooms, matchmaking
+│   │
+│   ├── game/
+│   │   ├── engine.py           # Boucle de jeu (tick ~250ms), résolution des actions
+│   │   ├── state.py            # GameState : ressources, unités, bâtiments par joueur
+│   │   ├── units.py            # Définitions Marine / Medic / Goliath / Tank / Wraith / SCV
+│   │   ├── buildings.py        # Command Center / Barracks / Factory / Starport / Depot…
+│   │   ├── tech_tree.py        # Prérequis de construction et de production
+│   │   └── map.py              # Grille, pathfinding simple (A*)
+│   │
+│   └── voice/
+│       ├── stt.py              # ElevenLabs STT : audio bytes → transcription texte
+│       ├── tts.py              # ElevenLabs TTS : texte → audio bytes streamé au client
+│       └── command_parser.py   # Mistral : texte + état du jeu → commandes structurées
+│
+└── frontend/
+    ├── package.json
+    └── src/
+        ├── routes/
+        │   ├── +page.svelte        # Lobby : créer / rejoindre une partie
+        │   └── game/
+        │       └── +page.svelte    # Vue jeu principale
+        │
+        └── lib/
+            ├── socket.ts           # Singleton socket.io-client
+            ├── voice.ts            # Capture micro → envoi backend → lecture réponse audio
+            ├── stores/
+            │   └── gameState.ts    # Store Svelte réactif (état jeu reçu du serveur)
+            └── components/
+                ├── Map.svelte          # Carte SVG scrollable / zoomable
+                ├── UnitPanel.svelte    # Détail unité au tap
+                ├── TechTree.svelte     # Arbre tech en lecture seule
+                ├── ResourceBar.svelte  # Minéraux / Gaz / Supply
+                └── VoiceButton.svelte  # Bouton push-to-talk (PTT)
+```
+
+---
+
+## Flux d'une commande vocale
+
+```
+[Joueur maintient PTT]
+        │
+        ▼
+  MediaRecorder (browser)
+        │  audio blob
+        ▼
+  Socket.IO  ──voice_input──►  backend
+                                  │
+                                  ▼
+                          ElevenLabs STT
+                          "entraîne 3 marines"
+                                  │
+                                  ▼
+                      Mistral API  (prompt système = état du jeu)
+                      → { action: "train", unit: "marine", count: 3 }
+                                  │
+                                  ▼
+                          engine.apply_command()
+                                  │
+                          ┌───────┴───────┐
+                          ▼               ▼
+                    game_state       ElevenLabs TTS
+                    broadcast        "Entraînement de 3 marines lancé"
+                          │               │
+                          ▼               ▼
+                  ◄──game_update──  ◄──voice_feedback──
+```
+
+---
+
+## Jeu — Race Terran simplifiée
+
+### Ressources
+| Ressource | Source | Usage |
+|---|---|---|
+| Minéraux | Patchs collectés par SCV | Tout |
+| Gaz Vespène | Geysers collectés par SCV | Unités avancées, upgrades |
+| Supply | Supply Depots + Command Center | Limite de population |
+
+### Bâtiments
+| Bâtiment | Prérequis | Rôle |
+|---|---|---|
+| Command Center | — | Départ, produit SCV |
+| Supply Depot | — | +8 supply |
+| Barracks | — | Marine, Medic |
+| Engineering Bay | Barracks | Upgrades infanterie |
+| Factory | Barracks | Goliath, Tank |
+| Armory | Factory | Upgrades véhicules |
+| Starport | Factory | Wraith |
+
+### Unités
+| Unité | Coût | Prérequis | Rôle |
+|---|---|---|---|
+| SCV | 50m | CC | Collecte, construction |
+| Marine | 50m | Barracks | Infanterie de base, anti-air |
+| Medic | 50m / 25g | Barracks + Academy* | Soigne l'infanterie |
+| Goliath | 100m / 50g | Factory | Anti-air + sol |
+| Siege Tank | 150m / 100g | Factory + Machine Shop* | DPS sol, mode siège |
+| Wraith | 150m / 100g | Starport | Air, camouflage |
+
+*simplifié : add-ons remplacés par simple prérequis de bâtiment*
+
+### Exemples de commandes vocales
+- *"Construis un supply depot près du command center"*
+- *"Entraîne quatre marines"*
+- *"Envoie tous les marines attaquer en haut à gauche"*
+- *"Passe le tank en mode siège"*
+- *"Fais patrouiller les wraiths autour de ma base"*
+- *"Combien de gaz j'ai ?"*
+- *"Scout avec un SCV vers le centre"*
+
+---
+
+## Démarrage local
+
+```bash
+# Variables d'environnement
+cp .env.example .env
+# Remplir MISTRAL_API_KEY, ELEVENLABS_API_KEY
+
+# Backend
+cd backend
+pip install -r requirements.txt
+uvicorn main:app --reload --port 8000
+
+# Frontend
+cd frontend
+npm install
+npm run dev
+```
+
+---
+
+## Déploiement Hugging Face Spaces
+
+Le `Dockerfile` à la racine expose le port **7860** (requis par HF Spaces).  
+Il sert à la fois le backend FastAPI/Socket.IO et le build statique SvelteKit (`adapter-static`).
+
+```bash
+# Push suffit à déclencher le build sur HF Spaces
+git push
+```
+
+---
+
+## Variables d'environnement
+
+| Variable | Description |
+|---|---|
+| `MISTRAL_API_KEY` | Clé API Mistral |
+| `ELEVENLABS_API_KEY` | Clé API ElevenLabs |
+| `SECRET_KEY` | Clé pour signer les sessions lobby |
+
+---
+
+## Notes de conception
+
+- **python-socketio** avec transport asyncio est choisi pour la gestion des rooms et la diffusion d'état — il gère nativement les rooms, les namespaces et la reconnexion, évitant d'implémenter tout ça à la main avec des WebSockets bruts.
+- La boucle de jeu tourne côté serveur (tick toutes les 250ms). Les clients reçoivent un snapshot d'état complet à chaque tick — pas de réconciliation client-side pour rester simple.
+- Mistral reçoit en contexte système un résumé de l'état courant du joueur (ressources, bâtiments actifs, supply) pour que l'interprétation soit cohérente avec la situation réelle.
+- Le PTT (push-to-talk) évite les faux positifs sur mobile et réduit la latence en limitant la taille des chunks audio envoyés.

backend/config.py

@@ -0,0 +1,18 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+MISTRAL_API_KEY: str = os.getenv("MISTRAL_API_KEY", "")
+ELEVENLABS_API_KEY: str = os.getenv("ELEVENLABS_API_KEY", "")
+SECRET_KEY: str = os.getenv("SECRET_KEY", "dev-secret-key-change-me")
+
+# ElevenLabs voice ID for game feedback (default: Rachel)
+ELEVENLABS_VOICE_ID: str = os.getenv("ELEVENLABS_VOICE_ID", "21m00Tcm4TlvDq8ikWAM")
+
+# Game constants
+TICK_INTERVAL: float = 0.25        # seconds per game tick
+TICKS_PER_SECOND: int = 4
+MINERAL_PER_HARVEST: int = 8       # minerals per SCV per harvest cycle
+GAS_PER_HARVEST: int = 8           # gas per SCV per harvest cycle
+HARVEST_INTERVAL_TICKS: int = 4    # harvest every N ticks (~1s)

backend/game/buildings.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import uuid
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class BuildingType(str, Enum):
+    COMMAND_CENTER = "command_center"
+    SUPPLY_DEPOT = "supply_depot"
+    BARRACKS = "barracks"
+    ENGINEERING_BAY = "engineering_bay"
+    REFINERY = "refinery"
+    FACTORY = "factory"
+    ARMORY = "armory"
+    STARPORT = "starport"
+
+
+class BuildingStatus(str, Enum):
+    CONSTRUCTING = "constructing"
+    ACTIVE = "active"
+    PRODUCING = "producing"
+    DESTROYED = "destroyed"
+
+
+class BuildingDef(BaseModel):
+    max_hp: int
+    mineral_cost: int
+    gas_cost: int
+    build_time_ticks: int
+    width: int = 2
+    height: int = 2
+    supply_provided: int = 0
+
+
+BUILDING_DEFS: dict[BuildingType, BuildingDef] = {
+    BuildingType.COMMAND_CENTER: BuildingDef(
+        max_hp=1500, mineral_cost=400, gas_cost=0, build_time_ticks=120,
+        width=4, height=3, supply_provided=10,
+    ),
+    BuildingType.SUPPLY_DEPOT: BuildingDef(
+        max_hp=500, mineral_cost=100, gas_cost=0, build_time_ticks=30,
+        width=3, height=2, supply_provided=8,
+    ),
+    BuildingType.BARRACKS: BuildingDef(
+        max_hp=1000, mineral_cost=150, gas_cost=0, build_time_ticks=80,
+        width=4, height=3,
+    ),
+    BuildingType.ENGINEERING_BAY: BuildingDef(
+        max_hp=850, mineral_cost=125, gas_cost=0, build_time_ticks=60,
+        width=3, height=2,
+    ),
+    BuildingType.REFINERY: BuildingDef(
+        max_hp=500, mineral_cost=100, gas_cost=0, build_time_ticks=40,
+        width=2, height=2,
+    ),
+    BuildingType.FACTORY: BuildingDef(
+        max_hp=1250, mineral_cost=200, gas_cost=100, build_time_ticks=80,
+        width=4, height=3,
+    ),
+    BuildingType.ARMORY: BuildingDef(
+        max_hp=800, mineral_cost=100, gas_cost=50, build_time_ticks=60,
+        width=3, height=2,
+    ),
+    BuildingType.STARPORT: BuildingDef(
+        max_hp=1300, mineral_cost=150, gas_cost=100, build_time_ticks=70,
+        width=4, height=2,
+    ),
+}
+
+
+class ProductionItem(BaseModel):
+    unit_type: str
+    ticks_remaining: int
+
+
+class Building(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4())[:8])
+    building_type: BuildingType
+    owner: str
+    x: int
+    y: int
+    hp: float
+    max_hp: int
+    status: BuildingStatus = BuildingStatus.CONSTRUCTING
+    construction_ticks_remaining: int = 0
+    production_queue: list[ProductionItem] = Field(default_factory=list)
+    rally_x: Optional[float] = None
+    rally_y: Optional[float] = None
+
+    @classmethod
+    def create(cls, bt: BuildingType, owner: str, x: int, y: int) -> "Building":
+        defn = BUILDING_DEFS[bt]
+        return cls(
+            building_type=bt,
+            owner=owner,
+            x=x,
+            y=y,
+            hp=float(defn.max_hp),
+            max_hp=defn.max_hp,
+            construction_ticks_remaining=defn.build_time_ticks,
+        )
+
+    def spawn_point(self) -> tuple[float, float]:
+        """Position where units appear when produced."""
+        defn = BUILDING_DEFS[self.building_type]
+        return (float(self.x) + defn.width / 2, float(self.y) + defn.height + 1)

backend/game/commands.py

@@ -0,0 +1,78 @@
+"""
+Command models: output of the Mistral voice command parser.
+
+ActionType values and GameAction fields mirror the JSON schema
+given to Mistral in voice/command_parser.py.
+"""
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class ActionType(str, Enum):
+    BUILD = "build"
+    TRAIN = "train"
+    MOVE = "move"
+    ATTACK = "attack"
+    SIEGE = "siege"
+    UNSIEGE = "unsiege"
+    CLOAK = "cloak"
+    DECLOAK = "decloak"
+    GATHER = "gather"
+    STOP = "stop"
+    PATROL = "patrol"
+    QUERY = "query"
+
+
+# Unit selectors understood by the engine
+# "all"           → every unit the player owns
+# "all_military"  → all non-SCV units
+# "all_marines"   → all marines  (same pattern for other types)
+# "all_scv"       → all SCVs
+# "idle_scv"      → idle SCVs only
+# "most_damaged"  → the most injured unit
+UNIT_SELECTORS = [
+    "all", "all_military", "all_marines", "all_medics",
+    "all_goliaths", "all_tanks", "all_wraiths",
+    "all_scv", "idle_scv", "most_damaged",
+]
+
+# Zone names resolved by the engine to (x, y) coordinates
+TARGET_ZONES = [
+    "my_base", "enemy_base", "center",
+    "top_left", "top_right", "bottom_left", "bottom_right",
+    "front_line",
+]
+
+
+class GameAction(BaseModel):
+    type: ActionType
+    # build
+    building_type: Optional[str] = None
+    # train
+    unit_type: Optional[str] = None
+    count: int = 1
+    # move / attack / patrol / stop
+    unit_selector: Optional[str] = None
+    target_zone: Optional[str] = None
+    # gather
+    resource_type: Optional[str] = None  # "minerals" or "gas"
+
+
+class ParsedCommand(BaseModel):
+    """Full Mistral response: one or more actions + French feedback text."""
+    actions: list[GameAction]
+    feedback: str
+
+
+class ActionResult(BaseModel):
+    action_type: str
+    success: bool
+    message: str
+
+
+class CommandResult(BaseModel):
+    results: list[ActionResult]
+    feedback_override: Optional[str] = None  # replaces Mistral feedback on hard error

backend/game/engine.py

@@ -0,0 +1,743 @@
+"""
+GameEngine — server-side game loop running at 4 ticks/second.
+
+One engine instance per active room. Responsibilities:
+  - Tick loop (asyncio task)
+  - Apply parsed voice commands
+  - Mining, construction, production, movement, combat
+  - Win-condition check
+  - State broadcast via Socket.IO
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import math
+from typing import TYPE_CHECKING, Optional
+
+from config import TICK_INTERVAL, HARVEST_INTERVAL_TICKS, MINERAL_PER_HARVEST, GAS_PER_HARVEST
+
+from .buildings import Building, BuildingDef, BuildingStatus, BuildingType, BUILDING_DEFS
+from .commands import ActionResult, ActionType, CommandResult, GameAction, ParsedCommand
+from .map import MAP_HEIGHT, MAP_WIDTH, ResourceType
+from .state import GamePhase, GameState, PlayerState
+from .tech_tree import can_build, can_train, get_producer, missing_for_build, missing_for_train
+from .units import Unit, UnitDef, UnitStatus, UnitType, UNIT_DEFS
+
+if TYPE_CHECKING:
+    import socketio
+
+log = logging.getLogger(__name__)
+
+# Auto-attack trigger range (fraction of weapon range)
+AUTO_ATTACK_RANGE_FACTOR = 0.6
+
+
+class GameEngine:
+    def __init__(self, state: GameState, sio: "socketio.AsyncServer") -> None:
+        self.state = state
+        self.sio = sio
+        self._task: Optional[asyncio.Task] = None  # type: ignore[type-arg]
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    def start(self) -> None:
+        self._task = asyncio.create_task(self._loop())
+
+    async def stop(self) -> None:
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+
+    # ------------------------------------------------------------------
+    # Public command entry point
+    # ------------------------------------------------------------------
+
+    def apply_command(self, player_id: str, parsed: ParsedCommand) -> CommandResult:
+        player = self.state.players.get(player_id)
+        if not player or self.state.phase != GamePhase.PLAYING:
+            return CommandResult(results=[], feedback_override="La partie n'est pas en cours.")
+
+        results: list[ActionResult] = []
+        for action in parsed.actions:
+            result = self._dispatch(player, action)
+            results.append(result)
+
+        player.recalculate_supply()
+        return CommandResult(results=results)
+
+    # ------------------------------------------------------------------
+    # Tick loop
+    # ------------------------------------------------------------------
+
+    async def _loop(self) -> None:
+        while self.state.phase == GamePhase.PLAYING:
+            await asyncio.sleep(TICK_INTERVAL)
+            self._tick()
+            await self._broadcast()
+
+    def _tick(self) -> None:
+        self.state.tick += 1
+
+        for player in self.state.players.values():
+            self._tick_construction(player)
+            self._tick_production(player)
+            if self.state.tick % HARVEST_INTERVAL_TICKS == 0:
+                self._tick_mining(player)
+
+        self._tick_movement_and_combat()
+        self._tick_healing()
+        self._remove_dead()
+
+        for player in self.state.players.values():
+            player.recalculate_supply()
+
+        winner = self._check_win()
+        if winner:
+            self.state.phase = GamePhase.GAME_OVER
+            self.state.winner = winner
+
+    # ------------------------------------------------------------------
+    # Sub-tick processors
+    # ------------------------------------------------------------------
+
+    def _tick_construction(self, player: PlayerState) -> None:
+        """Advance SCV-built buildings under construction."""
+        for building in player.buildings.values():
+            if building.status != BuildingStatus.CONSTRUCTING:
+                continue
+            building.construction_ticks_remaining -= 1
+            if building.construction_ticks_remaining <= 0:
+                building.status = BuildingStatus.ACTIVE
+                building.construction_ticks_remaining = 0
+                # Mark the assigned SCV as idle
+                for unit in player.units.values():
+                    if unit.building_target_id == building.id:
+                        unit.status = UnitStatus.IDLE
+                        unit.building_target_id = None
+                        unit.target_x = unit.target_y = None
+
+    def _tick_production(self, player: PlayerState) -> None:
+        """Tick building production queues and spawn units."""
+        for building in player.buildings.values():
+            if not building.production_queue:
+                building.status = BuildingStatus.ACTIVE
+                continue
+            item = building.production_queue[0]
+            item.ticks_remaining -= 1
+            building.status = BuildingStatus.PRODUCING
+            if item.ticks_remaining <= 0:
+                building.production_queue.pop(0)
+                building.status = (
+                    BuildingStatus.PRODUCING if building.production_queue
+                    else BuildingStatus.ACTIVE
+                )
+                self._spawn_unit(player, building, UnitType(item.unit_type))
+
+    def _spawn_unit(self, player: PlayerState, building: Building, ut: UnitType) -> None:
+        sx, sy = building.spawn_point()
+        # Rally point overrides default spawn position
+        tx = building.rally_x if building.rally_x is not None else sx
+        ty = building.rally_y if building.rally_y is not None else sy
+        unit = Unit.create(ut, player.player_id, sx, sy)
+        if tx != sx or ty != sy:
+            unit.status = UnitStatus.MOVING
+            unit.target_x = tx
+            unit.target_y = ty
+        player.units[unit.id] = unit
+
+    def _tick_mining(self, player: PlayerState) -> None:
+        """SCVs collect resources every HARVEST_INTERVAL_TICKS ticks."""
+        for unit in player.units.values():
+            if unit.status == UnitStatus.MINING_MINERALS:
+                resource = self.state.game_map.get_resource(unit.assigned_resource_id or "")
+                if resource and not resource.is_depleted:
+                    gathered = min(MINERAL_PER_HARVEST, resource.amount)
+                    player.minerals += gathered
+                    resource.amount -= gathered
+                else:
+                    # Patch depleted: find another
+                    unit.assigned_resource_id = None
+                    unit.status = UnitStatus.IDLE
+
+            elif unit.status == UnitStatus.MINING_GAS:
+                resource = self.state.game_map.get_resource(unit.assigned_resource_id or "")
+                if resource and resource.has_refinery:
+                    player.gas += GAS_PER_HARVEST
+                else:
+                    unit.assigned_resource_id = None
+                    unit.status = UnitStatus.IDLE
+
+    def _tick_movement_and_combat(self) -> None:
+        """Move units toward targets and resolve attacks."""
+        # Build flat lookup of all units across both players
+        all_units: dict[str, tuple[Unit, str]] = {}  # id -> (unit, owner_id)
+        for pid, player in self.state.players.items():
+            for uid, unit in player.units.items():
+                all_units[uid] = (unit, pid)
+
+        for pid, player in self.state.players.items():
+            enemy = self.state.enemy_of(pid)
+            if not enemy:
+                continue
+
+            for unit in player.units.values():
+                defn = UNIT_DEFS[unit.unit_type]
+
+                # Siege tanks in siege mode cannot move
+                if unit.is_sieged:
+                    self._combat_attack(unit, defn, all_units, player, enemy, sieged=True)
+                    continue
+
+                # Units on a mining or building task skip combat movement
+                if unit.status in (UnitStatus.MINING_MINERALS, UnitStatus.MINING_GAS,
+                                   UnitStatus.BUILDING):
+                    continue
+
+                # Movement
+                if unit.status in (UnitStatus.MOVING, UnitStatus.ATTACKING, UnitStatus.PATROLLING):
+                    target_x = unit.target_x
+                    target_y = unit.target_y
+                    if target_x is not None and target_y is not None:
+                        self._move_toward(unit, defn, target_x, target_y)
+
+                # Auto-attack: idle units defend themselves
+                auto_range = defn.attack_range * AUTO_ATTACK_RANGE_FACTOR
+                if unit.status == UnitStatus.IDLE:
+                    nearest_enemy = self._nearest_enemy_in_range(unit, enemy, auto_range)
+                    if nearest_enemy:
+                        unit.attack_target_id = nearest_enemy.id
+
+                # Combat
+                if unit.attack_target_id:
+                    self._combat_attack(unit, defn, all_units, player, enemy, sieged=False)
+
+    def _move_toward(self, unit: Unit, defn: UnitDef, tx: float, ty: float) -> None:
+        dx = tx - unit.x
+        dy = ty - unit.y
+        dist = math.sqrt(dx * dx + dy * dy)
+        step = defn.move_speed * TICK_INTERVAL
+        if dist <= step:
+            unit.x = tx
+            unit.y = ty
+            if unit.status == UnitStatus.MOVING:
+                unit.status = UnitStatus.IDLE
+                unit.target_x = unit.target_y = None
+            elif unit.status == UnitStatus.PATROLLING:
+                # Swap waypoints
+                unit.target_x, unit.patrol_x = unit.patrol_x, unit.target_x
+                unit.target_y, unit.patrol_y = unit.patrol_y, unit.target_y
+        else:
+            unit.x += (dx / dist) * step
+            unit.y += (dy / dist) * step
+
+    def _combat_attack(
+        self,
+        unit: Unit,
+        defn: UnitDef,
+        all_units: dict[str, tuple[Unit, str]],
+        player: PlayerState,
+        enemy: PlayerState,
+        sieged: bool,
+    ) -> None:
+        if unit.attack_cooldown > 0:
+            unit.attack_cooldown -= 1
+            return
+
+        if not unit.attack_target_id or unit.attack_target_id not in all_units:
+            # Acquire nearest enemy
+            rng = defn.siege_range if sieged else defn.attack_range
+            target = self._nearest_enemy_in_range(unit, enemy, rng)
+            if not target:
+                unit.attack_target_id = None
+                return
+            unit.attack_target_id = target.id
+
+        target_unit, _ = all_units.get(unit.attack_target_id, (None, None))
+        if target_unit is None or target_unit.hp <= 0:
+            unit.attack_target_id = None
+            return
+
+        # Check range
+        dist = unit.dist_to(target_unit.x, target_unit.y)
+        attack_range = defn.siege_range if sieged else defn.attack_range
+        if dist > attack_range + 0.5:
+            # Move into range (unless sieged)
+            if not sieged:
+                unit.target_x = target_unit.x
+                unit.target_y = target_unit.y
+                unit.status = UnitStatus.ATTACKING
+            return
+
+        # Determine damage
+        if sieged:
+            dmg = defn.siege_damage
+            splash = defn.siege_splash_radius
+            cooldown = defn.siege_cooldown_ticks
+            # Splash: damage all enemies in splash radius
+            for eu in enemy.units.values():
+                if eu.dist_to(target_unit.x, target_unit.y) <= splash:
+                    self._apply_damage(eu, dmg)
+        else:
+            target_flying = UNIT_DEFS[target_unit.unit_type].is_flying
+            dmg = defn.air_damage if target_flying else defn.ground_damage
+            cooldown = defn.attack_cooldown_ticks
+            if dmg > 0:
+                self._apply_damage(target_unit, dmg)
+
+        unit.attack_cooldown = cooldown
+        unit.status = UnitStatus.ATTACKING
+
+    def _apply_damage(self, target: Unit, raw_dmg: int) -> None:
+        defn = UNIT_DEFS[target.unit_type]
+        effective = max(0, raw_dmg - defn.armor)
+        target.hp = max(0.0, target.hp - effective)
+
+    def _tick_healing(self) -> None:
+        """Medics heal the most-injured adjacent infantry unit."""
+        for player in self.state.players.values():
+            for medic in player.units_of(UnitType.MEDIC):
+                defn = UNIT_DEFS[UnitType.MEDIC]
+                healable = [
+                    u for u in player.units.values()
+                    if u.unit_type in (UnitType.MARINE, UnitType.MEDIC)
+                    and u.hp < u.max_hp
+                    and medic.dist_to(u.x, u.y) <= defn.attack_range
+                    and u.id != medic.id
+                ]
+                if healable:
+                    target = min(healable, key=lambda u: u.hp / u.max_hp)
+                    target.hp = min(float(target.max_hp), target.hp + defn.heal_per_tick)
+                    medic.status = UnitStatus.HEALING
+
+    def _remove_dead(self) -> None:
+        """Remove units with hp <= 0 and mark buildings as destroyed."""
+        for player in self.state.players.values():
+            dead = [uid for uid, u in player.units.items() if u.hp <= 0]
+            for uid in dead:
+                # Unassign from resource patches
+                unit = player.units[uid]
+                if unit.assigned_resource_id:
+                    res = self.state.game_map.get_resource(unit.assigned_resource_id)
+                    if res and uid in res.assigned_scv_ids:
+                        res.assigned_scv_ids.remove(uid)
+                del player.units[uid]
+
+            for building in player.buildings.values():
+                if building.hp <= 0 and building.status != BuildingStatus.DESTROYED:
+                    building.status = BuildingStatus.DESTROYED
+                    building.production_queue.clear()
+
+    def _check_win(self) -> Optional[str]:
+        for player_id, player in self.state.players.items():
+            cc = player.command_center()
+            if cc is None:
+                enemy = self.state.enemy_of(player_id)
+                return enemy.player_id if enemy else None
+        return None
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _nearest_enemy_in_range(
+        self, unit: Unit, enemy: PlayerState, max_range: float
+    ) -> Optional[Unit]:
+        candidates = [
+            u for u in enemy.units.values()
+            if unit.dist_to(u.x, u.y) <= max_range
+        ]
+        # Also consider enemy buildings as targets
+        enemy_structs = [
+            b for b in enemy.buildings.values()
+            if b.status != BuildingStatus.DESTROYED
+            and unit.dist_to(b.x, b.y) <= max_range
+        ]
+        if not candidates and not enemy_structs:
+            return None
+        if not candidates:
+            return None
+        return min(candidates, key=lambda u: unit.dist_to(u.x, u.y))
+
+    def _resolve_zone(self, player_id: str, zone: str) -> tuple[float, float]:
+        player = self.state.players[player_id]
+        enemy = self.state.enemy_of(player_id)
+        cc = player.command_center()
+        base_x = float(cc.x) + 2 if cc else float(MAP_WIDTH) / 2
+        base_y = float(cc.y) + 2 if cc else float(MAP_HEIGHT) / 2
+
+        if zone == "my_base":
+            return (base_x, base_y)
+        if zone == "enemy_base" and enemy:
+            ecc = enemy.command_center()
+            return (float(ecc.x) + 2, float(ecc.y) + 2) if ecc else (MAP_WIDTH - 5, MAP_HEIGHT - 5)
+        if zone == "center":
+            return (MAP_WIDTH / 2, MAP_HEIGHT / 2)
+        if zone == "top_left":
+            return (4.0, 4.0)
+        if zone == "top_right":
+            return (MAP_WIDTH - 4.0, 4.0)
+        if zone == "bottom_left":
+            return (4.0, MAP_HEIGHT - 4.0)
+        if zone == "bottom_right":
+            return (MAP_WIDTH - 4.0, MAP_HEIGHT - 4.0)
+        if zone == "front_line":
+            military = [
+                u for u in player.units.values()
+                if u.unit_type != UnitType.SCV
+            ]
+            if military:
+                avg_x = sum(u.x for u in military) / len(military)
+                avg_y = sum(u.y for u in military) / len(military)
+                return (avg_x, avg_y)
+        # Fallback: enemy base
+        if enemy:
+            ecc = enemy.command_center()
+            if ecc:
+                return (float(ecc.x) + 2, float(ecc.y) + 2)
+        return (MAP_WIDTH / 2, MAP_HEIGHT / 2)
+
+    def _resolve_selector(self, player: PlayerState, selector: str) -> list[Unit]:
+        s = selector.lower()
+        if s == "all":
+            return list(player.units.values())
+        if s == "all_military":
+            return [u for u in player.units.values() if u.unit_type != UnitType.SCV]
+        if s == "all_marines":
+            return player.units_of(UnitType.MARINE)
+        if s == "all_medics":
+            return player.units_of(UnitType.MEDIC)
+        if s == "all_goliaths":
+            return player.units_of(UnitType.GOLIATH)
+        if s == "all_tanks":
+            return player.units_of(UnitType.TANK)
+        if s == "all_wraiths":
+            return player.units_of(UnitType.WRAITH)
+        if s == "all_scv":
+            return player.units_of(UnitType.SCV)
+        if s == "idle_scv":
+            return [u for u in player.units_of(UnitType.SCV) if u.status == UnitStatus.IDLE]
+        if s == "most_damaged":
+            units = list(player.units.values())
+            return [min(units, key=lambda u: u.hp / u.max_hp)] if units else []
+        return []
+
+    def _find_build_position(
+        self, player: PlayerState, bt: BuildingType
+    ) -> Optional[tuple[int, int]]:
+        cc = player.command_center()
+        if not cc:
+            return None
+        origin_x, origin_y = cc.x, cc.y
+        defn = BUILDING_DEFS[bt]
+
+        for radius in range(3, 18):
+            for dx in range(-radius, radius + 1):
+                for dy in range(-radius, radius + 1):
+                    x, y = origin_x + dx, origin_y + dy
+                    if self._can_place(x, y, defn):
+                        return (x, y)
+        return None
+
+    def _can_place(self, x: int, y: int, defn: BuildingDef) -> bool:
+        if x < 0 or y < 0 or x + defn.width > MAP_WIDTH or y + defn.height > MAP_HEIGHT:
+            return False
+        # Check overlap with all buildings
+        for player in self.state.players.values():
+            for b in player.buildings.values():
+                if b.status == BuildingStatus.DESTROYED:
+                    continue
+                bd = BUILDING_DEFS[b.building_type]
+                if x < b.x + bd.width and x + defn.width > b.x \
+                        and y < b.y + bd.height and y + defn.height > b.y:
+                    return False
+        # Check overlap with resources
+        for res in self.state.game_map.resources:
+            if x <= res.x < x + defn.width and y <= res.y < y + defn.height:
+                return False
+        return True
+
+    # ------------------------------------------------------------------
+    # Command dispatchers
+    # ------------------------------------------------------------------
+
+    def _dispatch(self, player: PlayerState, action: GameAction) -> ActionResult:
+        try:
+            t = action.type
+            if t == ActionType.BUILD:
+                return self._cmd_build(player, action)
+            if t == ActionType.TRAIN:
+                return self._cmd_train(player, action)
+            if t == ActionType.MOVE:
+                return self._cmd_move(player, action)
+            if t == ActionType.ATTACK:
+                return self._cmd_attack(player, action)
+            if t == ActionType.SIEGE:
+                return self._cmd_siege(player, action, siege=True)
+            if t == ActionType.UNSIEGE:
+                return self._cmd_siege(player, action, siege=False)
+            if t == ActionType.CLOAK:
+                return self._cmd_cloak(player, action, cloak=True)
+            if t == ActionType.DECLOAK:
+                return self._cmd_cloak(player, action, cloak=False)
+            if t == ActionType.GATHER:
+                return self._cmd_gather(player, action)
+            if t == ActionType.STOP:
+                return self._cmd_stop(player, action)
+            if t == ActionType.PATROL:
+                return self._cmd_patrol(player, action)
+            if t == ActionType.QUERY:
+                return self._cmd_query(player, action)
+            return ActionResult(action_type=t, success=False, message="Action inconnue.")
+        except Exception as exc:
+            log.exception("Error applying action %s", action.type)
+            return ActionResult(action_type=str(action.type), success=False, message=str(exc))
+
+    def _cmd_build(self, player: PlayerState, action: GameAction) -> ActionResult:
+        raw = action.building_type
+        if not raw:
+            return ActionResult(action_type="build", success=False, message="Type de bâtiment manquant.")
+        try:
+            bt = BuildingType(raw)
+        except ValueError:
+            return ActionResult(action_type="build", success=False, message=f"Bâtiment inconnu: {raw}.")
+
+        defn = BUILDING_DEFS[bt]
+        if player.minerals < defn.mineral_cost or player.gas < defn.gas_cost:
+            return ActionResult(action_type="build", success=False,
+                                message=f"Ressources insuffisantes ({defn.mineral_cost}m/{defn.gas_cost}g requis).")
+
+        if not can_build(bt, player):
+            missing = missing_for_build(bt, player)
+            names = ", ".join(m.value for m in missing)
+            return ActionResult(action_type="build", success=False,
+                                message=f"Prérequis manquants: {names}.")
+
+        # For a refinery, place on nearest geyser without refinery
+        if bt == BuildingType.REFINERY:
+            cc = player.command_center()
+            cx, cy = (float(cc.x), float(cc.y)) if cc else (0.0, 0.0)
+            geyser = self.state.game_map.nearest_geyser_without_refinery(cx, cy)
+            if not geyser:
+                return ActionResult(action_type="build", success=False,
+                                    message="Aucun geyser disponible pour la raffinerie.")
+            pos: tuple[int, int] = (geyser.x, geyser.y)
+            geyser.has_refinery = True
+        else:
+            pos_opt = self._find_build_position(player, bt)
+            if not pos_opt:
+                return ActionResult(action_type="build", success=False, message="Impossible de trouver un emplacement.")
+            pos = pos_opt
+
+        # Find idle SCV
+        idle_scv = next(
+            (u for u in player.units_of(UnitType.SCV) if u.status == UnitStatus.IDLE), None
+        )
+        if not idle_scv:
+            return ActionResult(action_type="build", success=False, message="Aucun SCV disponible.")
+
+        player.minerals -= defn.mineral_cost
+        player.gas -= defn.gas_cost
+
+        building = Building.create(bt, player.player_id, pos[0], pos[1])
+        player.buildings[building.id] = building
+
+        idle_scv.status = UnitStatus.BUILDING
+        idle_scv.building_target_id = building.id
+        idle_scv.target_x = float(pos[0])
+        idle_scv.target_y = float(pos[1])
+
+        return ActionResult(action_type="build", success=True,
+                            message=f"Construction de {bt.value} commencée.")
+
+    def _cmd_train(self, player: PlayerState, action: GameAction) -> ActionResult:
+        raw = action.unit_type
+        if not raw:
+            return ActionResult(action_type="train", success=False, message="Type d'unité manquant.")
+        try:
+            ut = UnitType(raw)
+        except ValueError:
+            return ActionResult(action_type="train", success=False, message=f"Unité inconnue: {raw}.")
+
+        if not can_train(ut, player):
+            missing = missing_for_train(ut, player)
+            names = ", ".join(m.value for m in missing)
+            return ActionResult(action_type="train", success=False,
+                                message=f"Prérequis manquants: {names}.")
+
+        defn = UNIT_DEFS[ut]
+        producer_type = get_producer(ut)
+        producers = player.active_buildings_of(producer_type)
+        if not producers:
+            return ActionResult(action_type="train", success=False,
+                                message=f"Aucun {producer_type.value} actif.")
+
+        count = max(1, min(action.count, 20))
+        trained = 0
+        idx = 0
+
+        while trained < count:
+            if player.minerals < defn.mineral_cost or player.gas < defn.gas_cost:
+                break
+            if player.supply_used + defn.supply_cost > player.supply_max:
+                break
+
+            building = producers[idx % len(producers)]
+            from .buildings import ProductionItem  # local import to avoid cycle
+            building.production_queue.append(
+                ProductionItem(unit_type=ut.value, ticks_remaining=defn.build_time_ticks)
+            )
+            player.minerals -= defn.mineral_cost
+            player.gas -= defn.gas_cost
+            player.supply_used += defn.supply_cost
+            trained += 1
+            idx += 1
+
+        if trained == 0:
+            return ActionResult(action_type="train", success=False,
+                                message="Ressources ou supply insuffisants.")
+        return ActionResult(action_type="train", success=True,
+                            message=f"{trained} {ut.value}(s) en production.")
+
+    def _cmd_move(self, player: PlayerState, action: GameAction) -> ActionResult:
+        units = self._resolve_selector(player, action.unit_selector or "all_military")
+        if not units:
+            return ActionResult(action_type="move", success=False, message="Aucune unité sélectionnée.")
+        tx, ty = self._resolve_zone(player.player_id, action.target_zone or "center")
+        for unit in units:
+            if unit.is_sieged:
+                continue
+            unit.status = UnitStatus.MOVING
+            unit.target_x = tx
+            unit.target_y = ty
+            unit.attack_target_id = None
+        return ActionResult(action_type="move", success=True,
+                            message=f"{len(units)} unité(s) en mouvement vers {action.target_zone}.")
+
+    def _cmd_attack(self, player: PlayerState, action: GameAction) -> ActionResult:
+        units = self._resolve_selector(player, action.unit_selector or "all_military")
+        if not units:
+            return ActionResult(action_type="attack", success=False, message="Aucune unité sélectionnée.")
+        tx, ty = self._resolve_zone(player.player_id, action.target_zone or "enemy_base")
+        for unit in units:
+            if unit.is_sieged:
+                continue
+            unit.status = UnitStatus.ATTACKING
+            unit.target_x = tx
+            unit.target_y = ty
+            unit.attack_target_id = None
+        return ActionResult(action_type="attack", success=True,
+                            message=f"{len(units)} unité(s) envoyées à l'attaque vers {action.target_zone}.")
+
+    def _cmd_siege(self, player: PlayerState, action: GameAction, siege: bool) -> ActionResult:
+        tanks = self._resolve_selector(player, action.unit_selector or "all_tanks")
+        tanks = [u for u in tanks if u.unit_type == UnitType.TANK]
+        if not tanks:
+            return ActionResult(action_type="siege", success=False, message="Aucun tank disponible.")
+        for tank in tanks:
+            tank.is_sieged = siege
+            tank.status = UnitStatus.SIEGED if siege else UnitStatus.IDLE
+            if siege:
+                tank.target_x = tank.target_y = None
+        mode = "siège" if siege else "mobile"
+        return ActionResult(action_type="siege", success=True,
+                            message=f"{len(tanks)} tank(s) en mode {mode}.")
+
+    def _cmd_cloak(self, player: PlayerState, action: GameAction, cloak: bool) -> ActionResult:
+        wraiths = self._resolve_selector(player, action.unit_selector or "all_wraiths")
+        wraiths = [u for u in wraiths if u.unit_type == UnitType.WRAITH]
+        if not wraiths:
+            return ActionResult(action_type="cloak", success=False, message="Aucun wraith disponible.")
+        for wraith in wraiths:
+            wraith.is_cloaked = cloak
+        state = "activé" if cloak else "désactivé"
+        return ActionResult(action_type="cloak", success=True,
+                            message=f"Camouflage {state} sur {len(wraiths)} wraith(s).")
+
+    def _cmd_gather(self, player: PlayerState, action: GameAction) -> ActionResult:
+        resource_type = (action.resource_type or "minerals").lower()
+        cc = player.command_center()
+        cx, cy = (float(cc.x), float(cc.y)) if cc else (0.0, 0.0)
+
+        scvs = self._resolve_selector(player, action.unit_selector or "idle_scv")
+        scvs = [u for u in scvs if u.unit_type == UnitType.SCV]
+        if not scvs:
+            return ActionResult(action_type="gather", success=False, message="Aucun SCV disponible.")
+
+        assigned = 0
+        if resource_type == "gas":
+            for scv in scvs:
+                geyser = self.state.game_map.nearest_available_geyser(cx, cy)
+                if not geyser:
+                    break
+                if scv.assigned_resource_id and scv.assigned_resource_id in \
+                        [r.id for r in self.state.game_map.resources]:
+                    old = self.state.game_map.get_resource(scv.assigned_resource_id)
+                    if old and scv.id in old.assigned_scv_ids:
+                        old.assigned_scv_ids.remove(scv.id)
+                scv.status = UnitStatus.MINING_GAS
+                scv.assigned_resource_id = geyser.id
+                geyser.assigned_scv_ids.append(scv.id)
+                assigned += 1
+        else:
+            for scv in scvs:
+                patch = self.state.game_map.nearest_mineral(cx, cy)
+                if not patch:
+                    break
+                if scv.assigned_resource_id:
+                    old = self.state.game_map.get_resource(scv.assigned_resource_id)
+                    if old and scv.id in old.assigned_scv_ids:
+                        old.assigned_scv_ids.remove(scv.id)
+                scv.status = UnitStatus.MINING_MINERALS
+                scv.assigned_resource_id = patch.id
+                patch.assigned_scv_ids.append(scv.id)
+                assigned += 1
+
+        if assigned == 0:
+            return ActionResult(action_type="gather", success=False,
+                                message="Aucune ressource disponible ou aucun SCV libre.")
+        return ActionResult(action_type="gather", success=True,
+                            message=f"{assigned} SCV(s) envoyés collecter {resource_type}.")
+
+    def _cmd_stop(self, player: PlayerState, action: GameAction) -> ActionResult:
+        units = self._resolve_selector(player, action.unit_selector or "all_military")
+        for unit in units:
+            unit.status = UnitStatus.IDLE
+            unit.target_x = unit.target_y = None
+            unit.attack_target_id = None
+        return ActionResult(action_type="stop", success=True,
+                            message=f"{len(units)} unité(s) stoppées.")
+
+    def _cmd_patrol(self, player: PlayerState, action: GameAction) -> ActionResult:
+        units = self._resolve_selector(player, action.unit_selector or "all_military")
+        if not units:
+            return ActionResult(action_type="patrol", success=False, message="Aucune unité sélectionnée.")
+        tx, ty = self._resolve_zone(player.player_id, action.target_zone or "center")
+        for unit in units:
+            if unit.is_sieged:
+                continue
+            # Return waypoint = current position
+            unit.patrol_x = unit.x
+            unit.patrol_y = unit.y
+            unit.target_x = tx
+            unit.target_y = ty
+            unit.status = UnitStatus.PATROLLING
+        return ActionResult(action_type="patrol", success=True,
+                            message=f"{len(units)} unité(s) en patrouille vers {action.target_zone}.")
+
+    def _cmd_query(self, player: PlayerState, action: GameAction) -> ActionResult:
+        return ActionResult(action_type="query", success=True, message=player.summary())
+
+    # ------------------------------------------------------------------
+    # Broadcast
+    # ------------------------------------------------------------------
+
+    async def _broadcast(self) -> None:
+        payload = self.state.model_dump(mode="json")
+        await self.sio.emit("game_update", payload, room=self.state.room_id)

backend/game/map.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import uuid
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+MAP_WIDTH = 40
+MAP_HEIGHT = 40
+
+# Starting positions (top-left corner of Command Center footprint)
+PLAYER1_START: tuple[int, int] = (4, 5)
+PLAYER2_START: tuple[int, int] = (32, 32)
+
+# Absolute resource positions
+_P1_MINERALS: list[tuple[int, int]] = [
+    (2, 2), (3, 2), (4, 2), (5, 2), (6, 2),
+    (2, 3), (6, 3), (3, 9),
+]
+_P1_GEYSERS: list[tuple[int, int]] = [(2, 9), (7, 9)]
+
+_P2_MINERALS: list[tuple[int, int]] = [
+    (33, 37), (34, 37), (35, 37), (36, 37), (37, 37),
+    (33, 36), (37, 36), (34, 30),
+]
+_P2_GEYSERS: list[tuple[int, int]] = [(32, 30), (37, 30)]
+
+# Named map zones resolved to (x, y) center coordinates
+# Zone values depend on player — resolved at engine level using player start positions
+ZONE_NAMES = [
+    "my_base", "enemy_base", "center",
+    "top_left", "top_right", "bottom_left", "bottom_right",
+    "front_line",
+]
+
+
+class ResourceType(str, Enum):
+    MINERAL = "mineral"
+    GEYSER = "geyser"
+
+
+class Resource(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4())[:8])
+    resource_type: ResourceType
+    x: int
+    y: int
+    amount: int = 1500         # minerals per patch (geysers are unlimited)
+    max_scv: int = 3
+    assigned_scv_ids: list[str] = Field(default_factory=list)
+    has_refinery: bool = False  # geysers only
+
+    @property
+    def is_depleted(self) -> bool:
+        return self.resource_type == ResourceType.MINERAL and self.amount <= 0
+
+    @property
+    def has_capacity(self) -> bool:
+        return len(self.assigned_scv_ids) < self.max_scv
+
+
+class GameMap(BaseModel):
+    width: int = MAP_WIDTH
+    height: int = MAP_HEIGHT
+    resources: list[Resource] = Field(default_factory=list)
+
+    @classmethod
+    def create_default(cls) -> "GameMap":
+        resources: list[Resource] = []
+        for x, y in _P1_MINERALS:
+            resources.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
+        for x, y in _P1_GEYSERS:
+            resources.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
+        for x, y in _P2_MINERALS:
+            resources.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
+        for x, y in _P2_GEYSERS:
+            resources.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
+        return cls(resources=resources)
+
+    def get_resource(self, resource_id: str) -> Resource | None:
+        return next((r for r in self.resources if r.id == resource_id), None)
+
+    def nearest_mineral(self, x: float, y: float) -> Resource | None:
+        candidates = [
+            r for r in self.resources
+            if r.resource_type == ResourceType.MINERAL
+            and not r.is_depleted
+            and r.has_capacity
+        ]
+        return min(candidates, key=lambda r: (r.x - x) ** 2 + (r.y - y) ** 2, default=None)
+
+    def nearest_available_geyser(self, x: float, y: float) -> Resource | None:
+        """Geyser with a refinery that still has SCV capacity."""
+        candidates = [
+            r for r in self.resources
+            if r.resource_type == ResourceType.GEYSER
+            and r.has_refinery
+            and r.has_capacity
+        ]
+        return min(candidates, key=lambda r: (r.x - x) ** 2 + (r.y - y) ** 2, default=None)
+
+    def nearest_geyser_without_refinery(self, x: float, y: float) -> Resource | None:
+        candidates = [
+            r for r in self.resources
+            if r.resource_type == ResourceType.GEYSER and not r.has_refinery
+        ]
+        return min(candidates, key=lambda r: (r.x - x) ** 2 + (r.y - y) ** 2, default=None)

backend/game/state.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from .buildings import Building, BuildingStatus, BuildingType, BUILDING_DEFS
+from .map import GameMap, PLAYER1_START, PLAYER2_START
+from .units import Unit, UnitType, UNIT_DEFS, UnitStatus
+
+
+class GamePhase(str, Enum):
+    LOBBY = "lobby"
+    PLAYING = "playing"
+    GAME_OVER = "game_over"
+
+
+class PlayerState(BaseModel):
+    player_id: str
+    player_name: str
+    minerals: int = 50
+    gas: int = 0
+    supply_used: int = 0
+    supply_max: int = 10
+    units: dict[str, Unit] = Field(default_factory=dict)
+    buildings: dict[str, Building] = Field(default_factory=dict)
+    is_defeated: bool = False
+
+    def recalculate_supply(self) -> None:
+        self.supply_max = sum(
+            BUILDING_DEFS[b.building_type].supply_provided
+            for b in self.buildings.values()
+            if b.status not in (BuildingStatus.CONSTRUCTING, BuildingStatus.DESTROYED)
+        )
+        self.supply_used = sum(
+            UNIT_DEFS[u.unit_type].supply_cost
+            for u in self.units.values()
+        )
+
+    def has_active(self, bt: BuildingType) -> bool:
+        return any(
+            b.building_type == bt
+            and b.status not in (BuildingStatus.CONSTRUCTING, BuildingStatus.DESTROYED)
+            for b in self.buildings.values()
+        )
+
+    def active_buildings_of(self, bt: BuildingType) -> list[Building]:
+        return [
+            b for b in self.buildings.values()
+            if b.building_type == bt
+            and b.status not in (BuildingStatus.CONSTRUCTING, BuildingStatus.DESTROYED)
+        ]
+
+    def units_of(self, ut: UnitType) -> list[Unit]:
+        return [u for u in self.units.values() if u.unit_type == ut]
+
+    def command_center(self) -> Optional[Building]:
+        return next(
+            (b for b in self.buildings.values()
+             if b.building_type == BuildingType.COMMAND_CENTER
+             and b.status != BuildingStatus.DESTROYED),
+            None,
+        )
+
+    def summary(self) -> str:
+        active = [
+            b.building_type.value for b in self.buildings.values()
+            if b.status not in (BuildingStatus.CONSTRUCTING, BuildingStatus.DESTROYED)
+        ]
+        constructing = [
+            f"{b.building_type.value}({b.construction_ticks_remaining}t)"
+            for b in self.buildings.values()
+            if b.status == BuildingStatus.CONSTRUCTING
+        ]
+        counts: dict[str, int] = {}
+        for u in self.units.values():
+            counts[u.unit_type.value] = counts.get(u.unit_type.value, 0) + 1
+
+        lines = [
+            f"Minéraux: {self.minerals}, Gaz: {self.gas}, Supply: {self.supply_used}/{self.supply_max}",
+            f"Bâtiments actifs: {', '.join(active) or 'aucun'}",
+        ]
+        if constructing:
+            lines.append(f"En construction: {', '.join(constructing)}")
+        if counts:
+            lines.append(f"Unités: {', '.join(f'{v} {k}' for k, v in counts.items())}")
+        return "\n".join(lines)
+
+
+class GameState(BaseModel):
+    room_id: str
+    tick: int = 0
+    phase: GamePhase = GamePhase.LOBBY
+    players: dict[str, PlayerState] = Field(default_factory=dict)
+    game_map: GameMap = Field(default_factory=GameMap.create_default)
+    winner: Optional[str] = None
+
+    @classmethod
+    def create_new(
+        cls,
+        room_id: str,
+        player1_id: str,
+        player1_name: str,
+        player2_id: str,
+        player2_name: str,
+    ) -> "GameState":
+        state = cls(room_id=room_id, phase=GamePhase.PLAYING)
+
+        p1 = PlayerState(player_id=player1_id, player_name=player1_name)
+        p2 = PlayerState(player_id=player2_id, player_name=player2_name)
+
+        # Starting Command Centers (already built)
+        cc1 = Building.create(BuildingType.COMMAND_CENTER, player1_id, *PLAYER1_START)
+        cc1.status = BuildingStatus.ACTIVE
+        cc1.construction_ticks_remaining = 0
+        p1.buildings[cc1.id] = cc1
+
+        cc2 = Building.create(BuildingType.COMMAND_CENTER, player2_id, *PLAYER2_START)
+        cc2.status = BuildingStatus.ACTIVE
+        cc2.construction_ticks_remaining = 0
+        p2.buildings[cc2.id] = cc2
+
+        # 5 starting SCVs per player, positioned south of CC
+        for i in range(5):
+            scv1 = Unit.create(UnitType.SCV, player1_id,
+                               PLAYER1_START[0] + 1 + i * 0.8,
+                               PLAYER1_START[1] + 4)
+            p1.units[scv1.id] = scv1
+
+            scv2 = Unit.create(UnitType.SCV, player2_id,
+                               PLAYER2_START[0] + 1 + i * 0.8,
+                               PLAYER2_START[1] - 1)
+            p2.units[scv2.id] = scv2
+
+        p1.recalculate_supply()
+        p2.recalculate_supply()
+
+        state.players[player1_id] = p1
+        state.players[player2_id] = p2
+
+        return state
+
+    def enemy_of(self, player_id: str) -> Optional[PlayerState]:
+        return next((p for pid, p in self.players.items() if pid != player_id), None)

backend/game/tech_tree.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .buildings import BuildingType, BuildingStatus
+from .units import UnitType
+
+if TYPE_CHECKING:
+    from .state import PlayerState
+
+
+# unit_type -> required active buildings
+UNIT_REQUIREMENTS: dict[UnitType, list[BuildingType]] = {
+    UnitType.SCV:     [BuildingType.COMMAND_CENTER],
+    UnitType.MARINE:  [BuildingType.BARRACKS],
+    UnitType.MEDIC:   [BuildingType.BARRACKS, BuildingType.ENGINEERING_BAY],
+    UnitType.GOLIATH: [BuildingType.FACTORY],
+    UnitType.TANK:    [BuildingType.FACTORY, BuildingType.ARMORY],
+    UnitType.WRAITH:  [BuildingType.STARPORT],
+}
+
+# building_type -> required active buildings (to be able to construct it)
+BUILDING_REQUIREMENTS: dict[BuildingType, list[BuildingType]] = {
+    BuildingType.COMMAND_CENTER:   [],
+    BuildingType.SUPPLY_DEPOT:     [],
+    BuildingType.REFINERY:         [],
+    BuildingType.BARRACKS:         [],
+    BuildingType.ENGINEERING_BAY:  [BuildingType.BARRACKS],
+    BuildingType.FACTORY:          [BuildingType.BARRACKS],
+    BuildingType.ARMORY:           [BuildingType.FACTORY],
+    BuildingType.STARPORT:         [BuildingType.FACTORY],
+}
+
+# unit_type -> building that produces it
+PRODUCTION_SOURCES: dict[UnitType, BuildingType] = {
+    UnitType.SCV:     BuildingType.COMMAND_CENTER,
+    UnitType.MARINE:  BuildingType.BARRACKS,
+    UnitType.MEDIC:   BuildingType.BARRACKS,
+    UnitType.GOLIATH: BuildingType.FACTORY,
+    UnitType.TANK:    BuildingType.FACTORY,
+    UnitType.WRAITH:  BuildingType.STARPORT,
+}
+
+
+def _active(player: "PlayerState", bt: BuildingType) -> bool:
+    return any(
+        b.building_type == bt
+        and b.status not in (BuildingStatus.CONSTRUCTING, BuildingStatus.DESTROYED)
+        for b in player.buildings.values()
+    )
+
+
+def can_build(bt: BuildingType, player: "PlayerState") -> bool:
+    return all(_active(player, req) for req in BUILDING_REQUIREMENTS[bt])
+
+
+def can_train(ut: UnitType, player: "PlayerState") -> bool:
+    return all(_active(player, req) for req in UNIT_REQUIREMENTS[ut])
+
+
+def missing_for_build(bt: BuildingType, player: "PlayerState") -> list[BuildingType]:
+    return [req for req in BUILDING_REQUIREMENTS[bt] if not _active(player, req)]
+
+
+def missing_for_train(ut: UnitType, player: "PlayerState") -> list[BuildingType]:
+    return [req for req in UNIT_REQUIREMENTS[ut] if not _active(player, req)]
+
+
+def get_producer(ut: UnitType) -> BuildingType:
+    return PRODUCTION_SOURCES[ut]

backend/game/units.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import uuid
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class UnitType(str, Enum):
+    SCV = "scv"
+    MARINE = "marine"
+    MEDIC = "medic"
+    GOLIATH = "goliath"
+    TANK = "tank"
+    WRAITH = "wraith"
+
+
+class UnitStatus(str, Enum):
+    IDLE = "idle"
+    MOVING = "moving"
+    ATTACKING = "attacking"
+    MINING_MINERALS = "mining_minerals"
+    MINING_GAS = "mining_gas"
+    BUILDING = "building"
+    HEALING = "healing"
+    SIEGED = "sieged"
+    PATROLLING = "patrolling"
+
+
+class UnitDef(BaseModel):
+    max_hp: int
+    armor: int
+    ground_damage: int
+    air_damage: int
+    attack_range: float
+    move_speed: float          # tiles/second
+    mineral_cost: int
+    gas_cost: int
+    supply_cost: int
+    build_time_ticks: int      # ticks to produce (at 4 ticks/s)
+    is_flying: bool = False
+    can_cloak: bool = False
+    can_siege: bool = False
+    heal_per_tick: float = 0.0 # medic healing
+    attack_cooldown_ticks: int = 4
+    # Siege-mode stats (tanks only)
+    siege_damage: int = 0
+    siege_range: float = 0.0
+    siege_splash_radius: float = 0.0
+    siege_cooldown_ticks: int = 0
+
+
+UNIT_DEFS: dict[UnitType, UnitDef] = {
+    UnitType.SCV: UnitDef(
+        max_hp=60, armor=0, ground_damage=5, air_damage=0,
+        attack_range=1, move_speed=1.5, mineral_cost=50, gas_cost=0,
+        supply_cost=1, build_time_ticks=20, attack_cooldown_ticks=6,
+    ),
+    UnitType.MARINE: UnitDef(
+        max_hp=40, armor=0, ground_damage=6, air_damage=6,
+        attack_range=4, move_speed=1.5, mineral_cost=50, gas_cost=0,
+        supply_cost=1, build_time_ticks=24, attack_cooldown_ticks=4,
+    ),
+    UnitType.MEDIC: UnitDef(
+        max_hp=60, armor=1, ground_damage=0, air_damage=0,
+        attack_range=2, move_speed=1.5, mineral_cost=50, gas_cost=25,
+        supply_cost=1, build_time_ticks=24, heal_per_tick=1.5,
+        attack_cooldown_ticks=999,  # medics don't attack
+    ),
+    UnitType.GOLIATH: UnitDef(
+        max_hp=125, armor=1, ground_damage=12, air_damage=20,
+        attack_range=5, move_speed=1.0, mineral_cost=100, gas_cost=50,
+        supply_cost=2, build_time_ticks=40, attack_cooldown_ticks=4,
+    ),
+    UnitType.TANK: UnitDef(
+        max_hp=150, armor=1, ground_damage=15, air_damage=0,
+        attack_range=7, move_speed=0.75, mineral_cost=150, gas_cost=100,
+        supply_cost=2, build_time_ticks=50, can_siege=True,
+        attack_cooldown_ticks=5,
+        siege_damage=35, siege_range=12.0, siege_splash_radius=2.0,
+        siege_cooldown_ticks=8,
+    ),
+    UnitType.WRAITH: UnitDef(
+        max_hp=120, armor=0, ground_damage=8, air_damage=20,
+        attack_range=5, move_speed=2.5, mineral_cost=150, gas_cost=100,
+        supply_cost=2, build_time_ticks=60, is_flying=True, can_cloak=True,
+        attack_cooldown_ticks=4,
+    ),
+}
+
+
+class Unit(BaseModel):
+    id: str = Field(default_factory=lambda: str(uuid.uuid4())[:8])
+    unit_type: UnitType
+    owner: str
+    x: float
+    y: float
+    hp: float
+    max_hp: int
+    status: UnitStatus = UnitStatus.IDLE
+    # Movement
+    target_x: Optional[float] = None
+    target_y: Optional[float] = None
+    # Patrol waypoints (current + return)
+    patrol_x: Optional[float] = None
+    patrol_y: Optional[float] = None
+    # Combat
+    attack_target_id: Optional[str] = None
+    attack_cooldown: int = 0
+    # Modes
+    is_sieged: bool = False
+    is_cloaked: bool = False
+    # SCV tasks
+    assigned_resource_id: Optional[str] = None
+    building_target_id: Optional[str] = None
+
+    @classmethod
+    def create(cls, unit_type: UnitType, owner: str, x: float, y: float) -> "Unit":
+        defn = UNIT_DEFS[unit_type]
+        return cls(
+            unit_type=unit_type,
+            owner=owner,
+            x=x,
+            y=y,
+            hp=float(defn.max_hp),
+            max_hp=defn.max_hp,
+        )
+
+    def dist_to(self, x: float, y: float) -> float:
+        return ((self.x - x) ** 2 + (self.y - y) ** 2) ** 0.5

backend/lobby/manager.py

@@ -0,0 +1,198 @@
+"""
+LobbyManager — room lifecycle and matchmaking.
+
+Rooms go through:  waiting → ready → playing → finished
+
+Socket.IO events consumed (called from main.py):
+    create_room   → { name: str }
+    join_room     → { room_id: str, name: str }
+    quick_match   → { name: str }
+    player_ready  → {}
+    leave_room    → {}
+
+Events emitted back:
+    room_created  → { room_id, room }
+    room_joined   → { room_id, room }
+    room_update   → { room }
+    match_found   → { room_id, room }
+    error         → { message }
+"""
+
+from __future__ import annotations
+
+import logging
+import random
+import string
+from typing import Optional
+
+log = logging.getLogger(__name__)
+
+
+def _gen_room_id(length: int = 6) -> str:
+    return "".join(random.choices(string.ascii_uppercase + string.digits, k=length))
+
+
+class RoomPlayer:
+    __slots__ = ("sid", "name", "ready")
+
+    def __init__(self, sid: str, name: str) -> None:
+        self.sid = sid
+        self.name = name
+        self.ready = False
+
+    def to_dict(self) -> dict:
+        return {"sid": self.sid, "name": self.name, "ready": self.ready}
+
+
+class Room:
+    def __init__(self, room_id: str) -> None:
+        self.room_id = room_id
+        self.players: list[RoomPlayer] = []
+        self.status: str = "waiting"  # waiting | ready | playing | finished
+        self.engine = None  # set by main.py when game starts
+
+    @property
+    def is_full(self) -> bool:
+        return len(self.players) >= 2
+
+    @property
+    def all_ready(self) -> bool:
+        return self.is_full and all(p.ready for p in self.players)
+
+    def get_player(self, sid: str) -> Optional[RoomPlayer]:
+        return next((p for p in self.players if p.sid == sid), None)
+
+    def to_dict(self) -> dict:
+        return {
+            "room_id": self.room_id,
+            "status": self.status,
+            "players": [p.to_dict() for p in self.players],
+        }
+
+
+class LobbyManager:
+    def __init__(self) -> None:
+        self._rooms: dict[str, Room] = {}
+        self._sid_to_room: dict[str, str] = {}   # sid → room_id
+        self._queue: list[tuple[str, str]] = []  # (sid, name) pairs waiting for match
+
+    # ------------------------------------------------------------------
+    # Room management
+    # ------------------------------------------------------------------
+
+    def create_room(self, sid: str, name: str) -> Room:
+        self._leave_current(sid)
+        room_id = _gen_room_id()
+        while room_id in self._rooms:
+            room_id = _gen_room_id()
+        room = Room(room_id)
+        room.players.append(RoomPlayer(sid, name))
+        self._rooms[room_id] = room
+        self._sid_to_room[sid] = room_id
+        log.info("Room %s created by %s (%s)", room_id, name, sid)
+        return room
+
+    def join_room(self, sid: str, room_id: str, name: str) -> tuple[Optional[Room], Optional[str]]:
+        room = self._rooms.get(room_id)
+        if not room:
+            return None, "Room introuvable."
+        if room.is_full:
+            return None, "Room pleine."
+        if room.status not in ("waiting",):
+            return None, "La partie est déjà commencée."
+
+        self._leave_current(sid)
+        room.players.append(RoomPlayer(sid, name))
+        self._sid_to_room[sid] = room_id
+        log.info("%s (%s) joined room %s", name, sid, room_id)
+        return room, None
+
+    def quick_match(self, sid: str, name: str) -> tuple[Optional[Room], bool]:
+        """
+        Add player to matchmaking queue.
+        Returns (room, is_new_game):
+          - (None, False)  → queued, waiting for opponent
+          - (room, True)   → match found, room ready to start
+        """
+        self._leave_current(sid)
+
+        # Check if there's someone waiting
+        if self._queue:
+            opp_sid, opp_name = self._queue.pop(0)
+            room = self.create_room(opp_sid, opp_name)
+            room.players.append(RoomPlayer(sid, name))
+            self._sid_to_room[sid] = room.room_id
+            log.info("Match found: %s vs %s in room %s", opp_name, name, room.room_id)
+            return room, True
+        else:
+            self._queue.append((sid, name))
+            self._sid_to_room[sid] = "__queue__"
+            log.info("%s (%s) added to matchmaking queue", name, sid)
+            return None, False
+
+    def set_ready(self, sid: str) -> tuple[Optional[Room], bool]:
+        """Mark player as ready. Returns (room, all_ready)."""
+        room = self._get_room(sid)
+        if not room:
+            return None, False
+        player = room.get_player(sid)
+        if player:
+            player.ready = True
+        all_ready = room.all_ready
+        if all_ready:
+            room.status = "playing"
+        return room, all_ready
+
+    def set_playing(self, room_id: str) -> None:
+        room = self._rooms.get(room_id)
+        if room:
+            room.status = "playing"
+
+    def finish_room(self, room_id: str) -> None:
+        room = self._rooms.get(room_id)
+        if room:
+            room.status = "finished"
+
+    def disconnect(self, sid: str) -> Optional[Room]:
+        """Handle disconnection. Returns affected room (if any)."""
+        room = self._get_room(sid)
+        if room:
+            player = room.get_player(sid)
+            if player:
+                room.players.remove(player)
+            if not room.players:
+                del self._rooms[room.room_id]
+                room = None
+            elif room.status == "playing":
+                room.status = "finished"
+        # Remove from queue if waiting
+        self._queue = [(s, n) for s, n in self._queue if s != sid]
+        self._sid_to_room.pop(sid, None)
+        return room
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def get_room(self, room_id: str) -> Optional[Room]:
+        return self._rooms.get(room_id)
+
+    def get_room_for_sid(self, sid: str) -> Optional[Room]:
+        return self._get_room(sid)
+
+    def _get_room(self, sid: str) -> Optional[Room]:
+        room_id = self._sid_to_room.get(sid)
+        if not room_id or room_id == "__queue__":
+            return None
+        return self._rooms.get(room_id)
+
+    def _leave_current(self, sid: str) -> None:
+        current_room_id = self._sid_to_room.get(sid)
+        if current_room_id and current_room_id != "__queue__":
+            current_room = self._rooms.get(current_room_id)
+            if current_room:
+                player = current_room.get_player(sid)
+                if player:
+                    current_room.players.remove(player)
+        self._queue = [(s, n) for s, n in self._queue if s != sid]
+        self._sid_to_room.pop(sid, None)

backend/main.py

@@ -0,0 +1,341 @@
+"""
+Entry point — FastAPI + Socket.IO ASGI app.
+
+Run with:
+    uvicorn main:app --reload --port 8000
+
+Socket.IO events
+────────────────
+Client → Server
+  create_room   { name }
+  join_room     { room_id, name }
+  quick_match   { name }
+  player_ready  {}
+  voice_input   { audio_b64, mime_type? }
+  disconnect    (automatic)
+
+Server → Client
+  room_created  { room_id, room }
+  room_joined   { room_id, room }
+  room_update   { room }          — broadcast to room on any lobby change
+  match_found   { room_id, room } — to both players in quick match
+  game_start    { game_state }    — when both ready
+  game_update   { game_state }    — every tick (~250ms)
+  voice_result  { transcription, feedback_text, feedback_audio_b64, results }
+  game_over     { winner_id, winner_name }
+  error         { message }
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+import socketio
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from game.engine import GameEngine
+from game.state import GameState
+from lobby.manager import LobbyManager
+from voice import command_parser, stt, tts
+
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Socket.IO + FastAPI setup
+# ---------------------------------------------------------------------------
+
+sio = socketio.AsyncServer(
+    async_mode="asgi",
+    cors_allowed_origins="*",
+    ping_timeout=60,
+    ping_interval=25,
+    logger=False,
+    engineio_logger=False,
+)
+
+fastapi_app = FastAPI(title="VoiceStrike API")
+fastapi_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Serve SvelteKit static build if present (production / HF Spaces)
+_FRONTEND_BUILD = Path(__file__).parent.parent / "frontend" / "build"
+if _FRONTEND_BUILD.exists():
+    fastapi_app.mount(
+        "/",
+        StaticFiles(directory=str(_FRONTEND_BUILD), html=True),
+        name="frontend",
+    )
+
+# ASGI app: Socket.IO wraps FastAPI
+app = socketio.ASGIApp(sio, fastapi_app)
+
+# ---------------------------------------------------------------------------
+# Global state
+# ---------------------------------------------------------------------------
+
+lobby = LobbyManager()
+engines: dict[str, GameEngine] = {}   # room_id → GameEngine
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _player_name_in_room(sid: str, room_id: str) -> str:
+    room = lobby.get_room(room_id)
+    if not room:
+        return sid
+    player = room.get_player(sid)
+    return player.name if player else sid
+
+
+async def _emit_error(sid: str, message: str) -> None:
+    await sio.emit("error", {"message": message}, to=sid)
+
+
+async def _start_game(room_id: str) -> None:
+    """Create game state + engine, emit game_start to both players."""
+    room = lobby.get_room(room_id)
+    if not room or len(room.players) != 2:
+        return
+
+    p1, p2 = room.players[0], room.players[1]
+    game_state = GameState.create_new(
+        room_id=room_id,
+        player1_id=p1.sid,
+        player1_name=p1.name,
+        player2_id=p2.sid,
+        player2_name=p2.name,
+    )
+    engine = GameEngine(game_state, sio)
+    engines[room_id] = engine
+    room.engine = engine
+
+    payload = game_state.model_dump(mode="json")
+    # Send each player their own perspective (same state for now — no fog of war)
+    await sio.emit("game_start", {"game_state": payload, "your_id": p1.sid}, to=p1.sid)
+    await sio.emit("game_start", {"game_state": payload, "your_id": p2.sid}, to=p2.sid)
+
+    engine.start()
+    log.info("Game started in room %s: %s vs %s", room_id, p1.name, p2.name)
+
+
+# ---------------------------------------------------------------------------
+# Connection lifecycle
+# ---------------------------------------------------------------------------
+
+
+@sio.event
+async def connect(sid: str, environ: dict, auth: Optional[dict] = None) -> None:
+    log.info("Client connected: %s", sid)
+
+
+@sio.event
+async def disconnect(sid: str) -> None:
+    log.info("Client disconnected: %s", sid)
+    room = lobby.disconnect(sid)
+    if room:
+        if room.status == "finished" and room.room_id in engines:
+            await engines[room.room_id].stop()
+            del engines[room.room_id]
+        # Notify remaining players
+        for player in room.players:
+            await sio.emit(
+                "room_update",
+                {"room": room.to_dict(), "message": "Un joueur a quitté la partie."},
+                to=player.sid,
+            )
+            if room.status == "finished":
+                await sio.emit(
+                    "game_over",
+                    {"winner_id": player.sid, "winner_name": player.name,
+                     "reason": "opponent_disconnected"},
+                    to=player.sid,
+                )
+
+
+# ---------------------------------------------------------------------------
+# Lobby events
+# ---------------------------------------------------------------------------
+
+
+@sio.event
+async def create_room(sid: str, data: dict) -> None:
+    name = str(data.get("name", "Player")).strip() or "Player"
+    room = lobby.create_room(sid, name)
+    await sio.enter_room(sid, room.room_id)
+    await sio.emit("room_created", {"room_id": room.room_id, "room": room.to_dict()}, to=sid)
+    log.info("Room %s created by %s", room.room_id, name)
+
+
+@sio.event
+async def join_room(sid: str, data: dict) -> None:
+    room_id = str(data.get("room_id", "")).upper().strip()
+    name = str(data.get("name", "Player")).strip() or "Player"
+
+    room, err = lobby.join_room(sid, room_id, name)
+    if err:
+        await _emit_error(sid, err)
+        return
+
+    await sio.enter_room(sid, room_id)
+    await sio.emit("room_joined", {"room_id": room_id, "room": room.to_dict()}, to=sid)
+    # Notify host
+    await sio.emit("room_update", {"room": room.to_dict()}, room=room_id)
+
+
+@sio.event
+async def quick_match(sid: str, data: dict) -> None:
+    name = str(data.get("name", "Player")).strip() or "Player"
+    room, is_new = lobby.quick_match(sid, name)
+
+    if not is_new:
+        await sio.emit("match_queued", {"message": "En attente d'un adversaire…"}, to=sid)
+        return
+
+    # Match found — notify both players
+    await sio.enter_room(room.players[0].sid, room.room_id)
+    await sio.enter_room(room.players[1].sid, room.room_id)
+    for player in room.players:
+        await sio.emit(
+            "match_found",
+            {"room_id": room.room_id, "room": room.to_dict()},
+            to=player.sid,
+        )
+
+    # Auto-ready both players in quick match and start the game
+    for player in room.players:
+        player.ready = True
+    room.status = "playing"
+    await _start_game(room.room_id)
+
+
+@sio.event
+async def player_ready(sid: str, data: dict) -> None:
+    room, all_ready = lobby.set_ready(sid)
+    if not room:
+        await _emit_error(sid, "Tu n'es dans aucune room.")
+        return
+
+    await sio.emit("room_update", {"room": room.to_dict()}, room=room.room_id)
+
+    if all_ready:
+        await _start_game(room.room_id)
+
+
+# ---------------------------------------------------------------------------
+# Voice pipeline
+# ---------------------------------------------------------------------------
+
+
+@sio.event
+async def voice_input(sid: str, data: dict) -> None:
+    """
+    Receives base64-encoded audio from the client.
+    Pipeline: STT → Mistral → game commands → TTS → response
+    """
+    room = lobby.get_room_for_sid(sid)
+    if not room:
+        await _emit_error(sid, "Tu n'es dans aucune room.")
+        return
+
+    engine = engines.get(room.room_id)
+    if not engine:
+        await _emit_error(sid, "La partie n'a pas encore commencé.")
+        return
+
+    player = engine.state.players.get(sid)
+    if not player:
+        await _emit_error(sid, "Joueur introuvable dans la partie.")
+        return
+
+    audio_b64: str = data.get("audio_b64", "")
+    mime_type: str = data.get("mime_type", "audio/webm")
+
+    if not audio_b64:
+        await _emit_error(sid, "Aucune donnée audio reçue.")
+        return
+
+    try:
+        audio_bytes = base64.b64decode(audio_b64)
+    except Exception:
+        await _emit_error(sid, "Données audio invalides (base64 incorrect).")
+        return
+
+    # 1. Speech-to-text
+    try:
+        transcription = await stt.transcribe(audio_bytes, mime_type)
+    except Exception as exc:
+        log.exception("STT failed")
+        await _emit_error(sid, f"Erreur de reconnaissance vocale: {exc}")
+        return
+
+    if not transcription:
+        await sio.emit("voice_result", {
+            "transcription": "",
+            "feedback_text": "Je n'ai rien entendu. Appuie et parle!",
+            "feedback_audio_b64": "",
+            "results": [],
+        }, to=sid)
+        return
+
+    # 2. Parse command with Mistral
+    try:
+        parsed = await command_parser.parse(transcription, player)
+    except Exception as exc:
+        log.exception("Command parsing failed")
+        await _emit_error(sid, f"Erreur d'interprétation: {exc}")
+        return
+
+    # 3. Apply commands to game engine
+    cmd_result = engine.apply_command(sid, parsed)
+
+    feedback_text = (
+        cmd_result.feedback_override
+        if cmd_result.feedback_override
+        else parsed.feedback
+    )
+
+    # Append query result to feedback if present
+    for r in cmd_result.results:
+        if r.action_type == "query" and r.success:
+            feedback_text += "\n" + r.message
+
+    # 4. Text-to-speech
+    try:
+        audio_out = await tts.synthesize(feedback_text)
+        feedback_audio_b64 = base64.b64encode(audio_out).decode()
+    except Exception as exc:
+        log.warning("TTS failed (non-fatal): %s", exc)
+        feedback_audio_b64 = ""
+
+    # 5. Send result back to client
+    await sio.emit("voice_result", {
+        "transcription": transcription,
+        "feedback_text": feedback_text,
+        "feedback_audio_b64": feedback_audio_b64,
+        "results": [r.model_dump() for r in cmd_result.results],
+    }, to=sid)
+
+    # Check win condition after command
+    if engine.state.winner:
+        winner_state = engine.state.players.get(engine.state.winner)
+        winner_name = winner_state.player_name if winner_state else engine.state.winner
+        await sio.emit("game_over", {
+            "winner_id": engine.state.winner,
+            "winner_name": winner_name,
+        }, room=room.room_id)
+        await engines[room.room_id].stop()
+        del engines[room.room_id]
+        lobby.finish_room(room.room_id)

backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+python-socketio>=5.11.0
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+mistralai>=1.0.0
+elevenlabs>=1.0.0
+httpx>=0.27.0

backend/voice/command_parser.py

@@ -0,0 +1,117 @@
+"""
+Voice command parser — Mistral LLM interprets transcribed text
+and returns structured GameActions.
+
+The player's current game state is injected as context so Mistral
+can understand references like "envoie tous mes marines" or
+"construis quelque chose pour produire des tanks".
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+
+from mistralai import Mistral
+
+from config import MISTRAL_API_KEY
+from game.commands import ActionType, GameAction, ParsedCommand
+from game.state import PlayerState
+
+log = logging.getLogger(__name__)
+
+_SYSTEM_PROMPT = """\
+Tu es l'interprète de commandes vocales d'un jeu de stratégie en temps réel (style StarCraft, race Terran).
+Ton rôle est de convertir les instructions vocales d'un joueur en actions JSON structurées.
+
+=== UNITÉS DISPONIBLES ===
+scv, marine, medic, goliath, tank, wraith
+
+=== BÂTIMENTS DISPONIBLES ===
+supply_depot, barracks, engineering_bay, refinery, factory, armory, starport
+
+=== TYPES D'ACTIONS ===
+- build        : construire un bâtiment  → champs: building_type
+- train        : entraîner des unités    → champs: unit_type, count (défaut 1)
+- move         : déplacer des unités     → champs: unit_selector, target_zone
+- attack       : attaquer une zone       → champs: unit_selector, target_zone
+- siege        : tank en mode siège      → champs: unit_selector (optionnel)
+- unsiege      : retirer le mode siège   → champs: unit_selector (optionnel)
+- cloak        : activer camouflage      → champs: unit_selector (optionnel)
+- decloak      : désactiver camouflage   → champs: unit_selector (optionnel)
+- gather       : collecter ressources    → champs: unit_selector, resource_type ("minerals"|"gas")
+- stop         : arrêter des unités      → champs: unit_selector
+- patrol       : patrouiller            → champs: unit_selector, target_zone
+- query        : information sur l'état  → aucun champ requis
+
+=== SÉLECTEURS D'UNITÉS ===
+all, all_military, all_marines, all_medics, all_goliaths, all_tanks, all_wraiths, all_scv, idle_scv, most_damaged
+
+=== ZONES CIBLES ===
+my_base, enemy_base, center, top_left, top_right, bottom_left, bottom_right, front_line
+
+=== ÉTAT ACTUEL DU JOUEUR ===
+{player_state}
+
+=== CONSIGNES ===
+- Réponds UNIQUEMENT avec un JSON valide, aucun texte avant ou après.
+- Une commande peut générer PLUSIEURS actions (ex: "entraîne 4 marines et attaque la base").
+- Le champ "feedback" est un message en français à lire au joueur pour confirmer l'action.
+- Si la commande est incompréhensible, génère une action de type "query" avec un feedback explicatif.
+- Si le joueur demande son état / ses ressources, utilise l'action "query".
+
+=== FORMAT DE RÉPONSE ===
+{
+  "actions": [
+    {
+      "type": "<action_type>",
+      "building_type": "<valeur ou omis>",
+      "unit_type": "<valeur ou omis>",
+      "count": <entier, défaut 1>,
+      "unit_selector": "<valeur ou omis>",
+      "target_zone": "<valeur ou omis>",
+      "resource_type": "<valeur ou omis>"
+    }
+  ],
+  "feedback": "<message en français>"
+}
+"""
+
+
+async def parse(transcription: str, player: PlayerState) -> ParsedCommand:
+    """
+    Send transcription + player state to Mistral and return parsed command.
+    Falls back to a query action if parsing fails.
+    """
+    if not MISTRAL_API_KEY:
+        raise RuntimeError("MISTRAL_API_KEY not set")
+
+    client = Mistral(api_key=MISTRAL_API_KEY)
+    system = _SYSTEM_PROMPT.replace("{player_state}", player.summary())
+
+    response = await client.chat.complete_async(
+        model="mistral-large-latest",
+        messages=[
+            {"role": "system", "content": system},
+            {"role": "user", "content": transcription},
+        ],
+        response_format={"type": "json_object"},
+        temperature=0.1,
+    )
+
+    raw = response.choices[0].message.content or "{}"
+    log.info("Mistral raw response: %s", raw[:300])
+
+    try:
+        data = json.loads(raw)
+        actions = [GameAction(**a) for a in data.get("actions", [])]
+        feedback = data.get("feedback", "Commande reçue.")
+        if not actions:
+            raise ValueError("Empty actions list")
+        return ParsedCommand(actions=actions, feedback=feedback)
+    except Exception as exc:
+        log.warning("Failed to parse Mistral response: %s — %s", exc, raw[:200])
+        return ParsedCommand(
+            actions=[GameAction(type=ActionType.QUERY)],
+            feedback="Je n'ai pas compris cette commande. Voici ton état actuel.",
+        )

backend/voice/stt.py

@@ -0,0 +1,41 @@
+"""
+Speech-to-Text via ElevenLabs STT API.
+
+Input : raw audio bytes (WebM/Opus from MediaRecorder, or WAV)
+Output: transcribed text string
+"""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from config import ELEVENLABS_API_KEY
+
+log = logging.getLogger(__name__)
+
+_STT_URL = "https://api.elevenlabs.io/v1/speech-to-text"
+
+
+async def transcribe(audio_bytes: bytes, mime_type: str = "audio/webm") -> str:
+    """
+    Send audio bytes to ElevenLabs STT and return transcribed text.
+    Raises on HTTP errors.
+    """
+    if not ELEVENLABS_API_KEY:
+        raise RuntimeError("ELEVENLABS_API_KEY not set")
+
+    headers = {"xi-api-key": ELEVENLABS_API_KEY}
+
+    # ElevenLabs STT expects multipart/form-data with field "audio"
+    files = {"audio": ("audio.webm", audio_bytes, mime_type)}
+    data = {"model_id": "scribe_v1"}
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(_STT_URL, headers=headers, files=files, data=data)
+        resp.raise_for_status()
+        body = resp.json()
+        text: str = body.get("text", "").strip()
+        log.info("STT result: %r", text)
+        return text

backend/voice/tts.py

@@ -0,0 +1,49 @@
+"""
+Text-to-Speech via ElevenLabs TTS API.
+
+Input : text string
+Output: MP3 bytes (streamed and collected)
+"""
+
+from __future__ import annotations
+
+import logging
+
+import httpx
+
+from config import ELEVENLABS_API_KEY, ELEVENLABS_VOICE_ID
+
+log = logging.getLogger(__name__)
+
+_TTS_URL = "https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+
+
+async def synthesize(text: str) -> bytes:
+    """
+    Convert text to speech using ElevenLabs TTS.
+    Returns MP3 bytes.
+    """
+    if not ELEVENLABS_API_KEY:
+        raise RuntimeError("ELEVENLABS_API_KEY not set")
+
+    url = _TTS_URL.format(voice_id=ELEVENLABS_VOICE_ID)
+    headers = {
+        "xi-api-key": ELEVENLABS_API_KEY,
+        "Content-Type": "application/json",
+        "Accept": "audio/mpeg",
+    }
+    payload = {
+        "text": text,
+        "model_id": "eleven_multilingual_v2",
+        "voice_settings": {
+            "stability": 0.5,
+            "similarity_boost": 0.75,
+        },
+    }
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(url, headers=headers, json=payload)
+        resp.raise_for_status()
+        audio = resp.content
+        log.info("TTS generated %d bytes for: %r", len(audio), text[:60])
+        return audio

frontend/.svelte-kit/ambient.d.ts

@@ -0,0 +1,406 @@
+
+// this file is generated — do not edit it
+
+
+/// <reference types="@sveltejs/kit" />
+
+/**
+ * This module provides access to environment variables that are injected _statically_ into your bundle at build time and are limited to _private_ access.
+ * 
+ * |         | Runtime                                                                    | Build time                                                               |
+ * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+ * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) |
+ * | Public  | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public)   | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public)   |
+ * 
+ * Static environment variables are [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env` at build time and then statically injected into your bundle at build time, enabling optimisations like dead code elimination.
+ * 
+ * **_Private_ access:**
+ * 
+ * - This module cannot be imported into client-side code
+ * - This module only includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://svelte.dev/docs/kit/configuration#env) (if configured)
+ * 
+ * For example, given the following build time environment:
+ * 
+ * ```env
+ * ENVIRONMENT=production
+ * PUBLIC_BASE_URL=http://site.com
+ * ```
+ * 
+ * With the default `publicPrefix` and `privatePrefix`:
+ * 
+ * ```ts
+ * import { ENVIRONMENT, PUBLIC_BASE_URL } from '$env/static/private';
+ * 
+ * console.log(ENVIRONMENT); // => "production"
+ * console.log(PUBLIC_BASE_URL); // => throws error during build
+ * ```
+ * 
+ * The above values will be the same _even if_ different values for `ENVIRONMENT` or `PUBLIC_BASE_URL` are set at runtime, as they are statically replaced in your code with their build time values.
+ */
+declare module '$env/static/private' {
+	export const GJS_DEBUG_TOPICS: string;
+	export const LESSOPEN: string;
+	export const VSCODE_CWD: string;
+	export const CURSOR_EXTENSION_HOST_ROLE: string;
+	export const VSCODE_ESM_ENTRYPOINT: string;
+	export const CONDA_PROMPT_MODIFIER: string;
+	export const USER: string;
+	export const VSCODE_NLS_CONFIG: string;
+	export const npm_config_user_agent: string;
+	export const CI: string;
+	export const VSCODE_HANDLES_UNCAUGHT_ERRORS: string;
+	export const XDG_SESSION_TYPE: string;
+	export const npm_node_execpath: string;
+	export const SHLVL: string;
+	export const LD_LIBRARY_PATH: string;
+	export const npm_config_noproxy: string;
+	export const HOME: string;
+	export const CHROME_DESKTOP: string;
+	export const APPDIR: string;
+	export const CONDA_SHLVL: string;
+	export const OLDPWD: string;
+	export const DESKTOP_SESSION: string;
+	export const npm_package_json: string;
+	export const PERLLIB: string;
+	export const VSCODE_IPC_HOOK: string;
+	export const GIO_LAUNCHED_DESKTOP_FILE: string;
+	export const GNOME_SHELL_SESSION_MODE: string;
+	export const GTK_MODULES: string;
+	export const MANAGERPID: string;
+	export const npm_config_userconfig: string;
+	export const npm_config_local_prefix: string;
+	export const SYSTEMD_EXEC_PID: string;
+	export const IM_CONFIG_CHECK_ENV: string;
+	export const NO_COLOR: string;
+	export const DBUS_SESSION_BUS_ADDRESS: string;
+	export const _CE_M: string;
+	export const GIO_LAUNCHED_DESKTOP_FILE_PID: string;
+	export const COLOR: string;
+	export const VSCODE_CRASH_REPORTER_PROCESS_TYPE: string;
+	export const DEBUGINFOD_URLS: string;
+	export const IM_CONFIG_PHASE: string;
+	export const WAYLAND_DISPLAY: string;
+	export const LOGNAME: string;
+	export const FORCE_COLOR: string;
+	export const OWD: string;
+	export const JOURNAL_STREAM: string;
+	export const _: string;
+	export const npm_config_prefix: string;
+	export const npm_config_npm_version: string;
+	export const MEMORY_PRESSURE_WATCH: string;
+	export const XDG_SESSION_CLASS: string;
+	export const USERNAME: string;
+	export const TERM: string;
+	export const npm_config_cache: string;
+	export const GNOME_DESKTOP_SESSION_ID: string;
+	export const _CE_CONDA: string;
+	export const FC_FONTATIONS: string;
+	export const npm_config_node_gyp: string;
+	export const PATH: string;
+	export const INVOCATION_ID: string;
+	export const APPIMAGE: string;
+	export const NODE: string;
+	export const npm_package_name: string;
+	export const XDG_MENU_PREFIX: string;
+	export const VSCODE_PROCESS_TITLE: string;
+	export const GNOME_SETUP_DISPLAY: string;
+	export const XDG_RUNTIME_DIR: string;
+	export const GDK_BACKEND: string;
+	export const CURSOR_AGENT: string;
+	export const DISPLAY: string;
+	export const LANG: string;
+	export const XDG_CURRENT_DESKTOP: string;
+	export const XMODIFIERS: string;
+	export const XDG_SESSION_DESKTOP: string;
+	export const XAUTHORITY: string;
+	export const LS_COLORS: string;
+	export const CURSOR_TRACE_ID: string;
+	export const npm_lifecycle_script: string;
+	export const SSH_AUTH_SOCK: string;
+	export const GSETTINGS_SCHEMA_DIR: string;
+	export const CONDA_PYTHON_EXE: string;
+	export const SHELL: string;
+	export const ARGV0: string;
+	export const npm_package_version: string;
+	export const npm_lifecycle_event: string;
+	export const QT_ACCESSIBILITY: string;
+	export const GDMSESSION: string;
+	export const LESSCLOSE: string;
+	export const CONDA_DEFAULT_ENV: string;
+	export const GPG_AGENT_INFO: string;
+	export const GJS_DEBUG_OUTPUT: string;
+	export const QT_IM_MODULE: string;
+	export const npm_config_globalconfig: string;
+	export const npm_config_init_module: string;
+	export const PWD: string;
+	export const npm_execpath: string;
+	export const XDG_CONFIG_DIRS: string;
+	export const CONDA_EXE: string;
+	export const VSCODE_CODE_CACHE_PATH: string;
+	export const XDG_DATA_DIRS: string;
+	export const npm_config_global_prefix: string;
+	export const npm_command: string;
+	export const CONDA_PREFIX: string;
+	export const QT_PLUGIN_PATH: string;
+	export const _ZO_DOCTOR: string;
+	export const QT_IM_MODULES: string;
+	export const MEMORY_PRESSURE_WRITE: string;
+	export const VSCODE_PID: string;
+	export const INIT_CWD: string;
+	export const EDITOR: string;
+	export const NODE_ENV: string;
+}
+
+/**
+ * This module provides access to environment variables that are injected _statically_ into your bundle at build time and are _publicly_ accessible.
+ * 
+ * |         | Runtime                                                                    | Build time                                                               |
+ * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+ * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) |
+ * | Public  | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public)   | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public)   |
+ * 
+ * Static environment variables are [loaded by Vite](https://vitejs.dev/guide/env-and-mode.html#env-files) from `.env` files and `process.env` at build time and then statically injected into your bundle at build time, enabling optimisations like dead code elimination.
+ * 
+ * **_Public_ access:**
+ * 
+ * - This module _can_ be imported into client-side code
+ * - **Only** variables that begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) (which defaults to `PUBLIC_`) are included
+ * 
+ * For example, given the following build time environment:
+ * 
+ * ```env
+ * ENVIRONMENT=production
+ * PUBLIC_BASE_URL=http://site.com
+ * ```
+ * 
+ * With the default `publicPrefix` and `privatePrefix`:
+ * 
+ * ```ts
+ * import { ENVIRONMENT, PUBLIC_BASE_URL } from '$env/static/public';
+ * 
+ * console.log(ENVIRONMENT); // => throws error during build
+ * console.log(PUBLIC_BASE_URL); // => "http://site.com"
+ * ```
+ * 
+ * The above values will be the same _even if_ different values for `ENVIRONMENT` or `PUBLIC_BASE_URL` are set at runtime, as they are statically replaced in your code with their build time values.
+ */
+declare module '$env/static/public' {
+	
+}
+
+/**
+ * This module provides access to environment variables set _dynamically_ at runtime and that are limited to _private_ access.
+ * 
+ * |         | Runtime                                                                    | Build time                                                               |
+ * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+ * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) |
+ * | Public  | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public)   | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public)   |
+ * 
+ * Dynamic environment variables are defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/main/packages/adapter-node) (or running [`vite preview`](https://svelte.dev/docs/kit/cli)), this is equivalent to `process.env`.
+ * 
+ * **_Private_ access:**
+ * 
+ * - This module cannot be imported into client-side code
+ * - This module includes variables that _do not_ begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) _and do_ start with [`config.kit.env.privatePrefix`](https://svelte.dev/docs/kit/configuration#env) (if configured)
+ * 
+ * > [!NOTE] In `dev`, `$env/dynamic` includes environment variables from `.env`. In `prod`, this behavior will depend on your adapter.
+ * 
+ * > [!NOTE] To get correct types, environment variables referenced in your code should be declared (for example in an `.env` file), even if they don't have a value until the app is deployed:
+ * >
+ * > ```env
+ * > MY_FEATURE_FLAG=
+ * > ```
+ * >
+ * > You can override `.env` values from the command line like so:
+ * >
+ * > ```sh
+ * > MY_FEATURE_FLAG="enabled" npm run dev
+ * > ```
+ * 
+ * For example, given the following runtime environment:
+ * 
+ * ```env
+ * ENVIRONMENT=production
+ * PUBLIC_BASE_URL=http://site.com
+ * ```
+ * 
+ * With the default `publicPrefix` and `privatePrefix`:
+ * 
+ * ```ts
+ * import { env } from '$env/dynamic/private';
+ * 
+ * console.log(env.ENVIRONMENT); // => "production"
+ * console.log(env.PUBLIC_BASE_URL); // => undefined
+ * ```
+ */
+declare module '$env/dynamic/private' {
+	export const env: {
+		GJS_DEBUG_TOPICS: string;
+		LESSOPEN: string;
+		VSCODE_CWD: string;
+		CURSOR_EXTENSION_HOST_ROLE: string;
+		VSCODE_ESM_ENTRYPOINT: string;
+		CONDA_PROMPT_MODIFIER: string;
+		USER: string;
+		VSCODE_NLS_CONFIG: string;
+		npm_config_user_agent: string;
+		CI: string;
+		VSCODE_HANDLES_UNCAUGHT_ERRORS: string;
+		XDG_SESSION_TYPE: string;
+		npm_node_execpath: string;
+		SHLVL: string;
+		LD_LIBRARY_PATH: string;
+		npm_config_noproxy: string;
+		HOME: string;
+		CHROME_DESKTOP: string;
+		APPDIR: string;
+		CONDA_SHLVL: string;
+		OLDPWD: string;
+		DESKTOP_SESSION: string;
+		npm_package_json: string;
+		PERLLIB: string;
+		VSCODE_IPC_HOOK: string;
+		GIO_LAUNCHED_DESKTOP_FILE: string;
+		GNOME_SHELL_SESSION_MODE: string;
+		GTK_MODULES: string;
+		MANAGERPID: string;
+		npm_config_userconfig: string;
+		npm_config_local_prefix: string;
+		SYSTEMD_EXEC_PID: string;
+		IM_CONFIG_CHECK_ENV: string;
+		NO_COLOR: string;
+		DBUS_SESSION_BUS_ADDRESS: string;
+		_CE_M: string;
+		GIO_LAUNCHED_DESKTOP_FILE_PID: string;
+		COLOR: string;
+		VSCODE_CRASH_REPORTER_PROCESS_TYPE: string;
+		DEBUGINFOD_URLS: string;
+		IM_CONFIG_PHASE: string;
+		WAYLAND_DISPLAY: string;
+		LOGNAME: string;
+		FORCE_COLOR: string;
+		OWD: string;
+		JOURNAL_STREAM: string;
+		_: string;
+		npm_config_prefix: string;
+		npm_config_npm_version: string;
+		MEMORY_PRESSURE_WATCH: string;
+		XDG_SESSION_CLASS: string;
+		USERNAME: string;
+		TERM: string;
+		npm_config_cache: string;
+		GNOME_DESKTOP_SESSION_ID: string;
+		_CE_CONDA: string;
+		FC_FONTATIONS: string;
+		npm_config_node_gyp: string;
+		PATH: string;
+		INVOCATION_ID: string;
+		APPIMAGE: string;
+		NODE: string;
+		npm_package_name: string;
+		XDG_MENU_PREFIX: string;
+		VSCODE_PROCESS_TITLE: string;
+		GNOME_SETUP_DISPLAY: string;
+		XDG_RUNTIME_DIR: string;
+		GDK_BACKEND: string;
+		CURSOR_AGENT: string;
+		DISPLAY: string;
+		LANG: string;
+		XDG_CURRENT_DESKTOP: string;
+		XMODIFIERS: string;
+		XDG_SESSION_DESKTOP: string;
+		XAUTHORITY: string;
+		LS_COLORS: string;
+		CURSOR_TRACE_ID: string;
+		npm_lifecycle_script: string;
+		SSH_AUTH_SOCK: string;
+		GSETTINGS_SCHEMA_DIR: string;
+		CONDA_PYTHON_EXE: string;
+		SHELL: string;
+		ARGV0: string;
+		npm_package_version: string;
+		npm_lifecycle_event: string;
+		QT_ACCESSIBILITY: string;
+		GDMSESSION: string;
+		LESSCLOSE: string;
+		CONDA_DEFAULT_ENV: string;
+		GPG_AGENT_INFO: string;
+		GJS_DEBUG_OUTPUT: string;
+		QT_IM_MODULE: string;
+		npm_config_globalconfig: string;
+		npm_config_init_module: string;
+		PWD: string;
+		npm_execpath: string;
+		XDG_CONFIG_DIRS: string;
+		CONDA_EXE: string;
+		VSCODE_CODE_CACHE_PATH: string;
+		XDG_DATA_DIRS: string;
+		npm_config_global_prefix: string;
+		npm_command: string;
+		CONDA_PREFIX: string;
+		QT_PLUGIN_PATH: string;
+		_ZO_DOCTOR: string;
+		QT_IM_MODULES: string;
+		MEMORY_PRESSURE_WRITE: string;
+		VSCODE_PID: string;
+		INIT_CWD: string;
+		EDITOR: string;
+		NODE_ENV: string;
+		[key: `PUBLIC_${string}`]: undefined;
+		[key: `${string}`]: string | undefined;
+	}
+}
+
+/**
+ * This module provides access to environment variables set _dynamically_ at runtime and that are _publicly_ accessible.
+ * 
+ * |         | Runtime                                                                    | Build time                                                               |
+ * | ------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+ * | Private | [`$env/dynamic/private`](https://svelte.dev/docs/kit/$env-dynamic-private) | [`$env/static/private`](https://svelte.dev/docs/kit/$env-static-private) |
+ * | Public  | [`$env/dynamic/public`](https://svelte.dev/docs/kit/$env-dynamic-public)   | [`$env/static/public`](https://svelte.dev/docs/kit/$env-static-public)   |
+ * 
+ * Dynamic environment variables are defined by the platform you're running on. For example if you're using [`adapter-node`](https://github.com/sveltejs/kit/tree/main/packages/adapter-node) (or running [`vite preview`](https://svelte.dev/docs/kit/cli)), this is equivalent to `process.env`.
+ * 
+ * **_Public_ access:**
+ * 
+ * - This module _can_ be imported into client-side code
+ * - **Only** variables that begin with [`config.kit.env.publicPrefix`](https://svelte.dev/docs/kit/configuration#env) (which defaults to `PUBLIC_`) are included
+ * 
+ * > [!NOTE] In `dev`, `$env/dynamic` includes environment variables from `.env`. In `prod`, this behavior will depend on your adapter.
+ * 
+ * > [!NOTE] To get correct types, environment variables referenced in your code should be declared (for example in an `.env` file), even if they don't have a value until the app is deployed:
+ * >
+ * > ```env
+ * > MY_FEATURE_FLAG=
+ * > ```
+ * >
+ * > You can override `.env` values from the command line like so:
+ * >
+ * > ```sh
+ * > MY_FEATURE_FLAG="enabled" npm run dev
+ * > ```
+ * 
+ * For example, given the following runtime environment:
+ * 
+ * ```env
+ * ENVIRONMENT=production
+ * PUBLIC_BASE_URL=http://example.com
+ * ```
+ * 
+ * With the default `publicPrefix` and `privatePrefix`:
+ * 
+ * ```ts
+ * import { env } from '$env/dynamic/public';
+ * console.log(env.ENVIRONMENT); // => undefined, not public
+ * console.log(env.PUBLIC_BASE_URL); // => "http://example.com"
+ * ```
+ * 
+ * ```
+ * 
+ * ```
+ */
+declare module '$env/dynamic/public' {
+	export const env: {
+		[key: `PUBLIC_${string}`]: string | undefined;
+	}
+}

frontend/.svelte-kit/generated/client-optimized/app.js

@@ -0,0 +1,31 @@
+export { matchers } from './matchers.js';
+
+export const nodes = [
+	() => import('./nodes/0'),
+	() => import('./nodes/1'),
+	() => import('./nodes/2'),
+	() => import('./nodes/3')
+];
+
+export const server_loads = [];
+
+export const dictionary = {
+		"/": [2],
+		"/game": [3]
+	};
+
+export const hooks = {
+	handleError: (({ error }) => { console.error(error) }),
+	
+	reroute: (() => {}),
+	transport: {}
+};
+
+export const decoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.decode]));
+export const encoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.encode]));
+
+export const hash = false;
+
+export const decode = (type, value) => decoders[type](value);
+
+export { default as root } from '../root.svelte';

frontend/.svelte-kit/generated/client-optimized/matchers.js

@@ -0,0 +1 @@
+export const matchers = {};

frontend/.svelte-kit/generated/client-optimized/nodes/0.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../src/routes/+layout.svelte";

frontend/.svelte-kit/generated/client-optimized/nodes/1.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../node_modules/@sveltejs/kit/src/runtime/components/svelte-4/error.svelte";

frontend/.svelte-kit/generated/client-optimized/nodes/2.js

@@ -0,0 +1,3 @@
+import * as universal from "../../../../src/routes/+page.js";
+export { universal };
+export { default as component } from "../../../../src/routes/+page.svelte";

frontend/.svelte-kit/generated/client-optimized/nodes/3.js

@@ -0,0 +1,3 @@
+import * as universal from "../../../../src/routes/game/+page.js";
+export { universal };
+export { default as component } from "../../../../src/routes/game/+page.svelte";

frontend/.svelte-kit/generated/client/app.js

@@ -0,0 +1,31 @@
+export { matchers } from './matchers.js';
+
+export const nodes = [
+	() => import('./nodes/0'),
+	() => import('./nodes/1'),
+	() => import('./nodes/2'),
+	() => import('./nodes/3')
+];
+
+export const server_loads = [];
+
+export const dictionary = {
+		"/": [2],
+		"/game": [3]
+	};
+
+export const hooks = {
+	handleError: (({ error }) => { console.error(error) }),
+	
+	reroute: (() => {}),
+	transport: {}
+};
+
+export const decoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.decode]));
+export const encoders = Object.fromEntries(Object.entries(hooks.transport).map(([k, v]) => [k, v.encode]));
+
+export const hash = false;
+
+export const decode = (type, value) => decoders[type](value);
+
+export { default as root } from '../root.svelte';

frontend/.svelte-kit/generated/client/matchers.js

@@ -0,0 +1 @@
+export const matchers = {};

frontend/.svelte-kit/generated/client/nodes/0.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../src/routes/+layout.svelte";

frontend/.svelte-kit/generated/client/nodes/1.js

@@ -0,0 +1 @@
+export { default as component } from "../../../../node_modules/@sveltejs/kit/src/runtime/components/svelte-4/error.svelte";