feat: add new units/buildings/map assets, admin routes, and frontend build

- Add new sprites (goliath, medic, tank, wraith, armory, barracks, etc.)
- Add MAP_half/quarter LOD variants via generate_map_lod script
- Add compiled_map.json and game_positions.json static assets
- Add cover.jpg and HF Spaces logos (LFS-tracked)
- Add admin compiled-map route and layout
- Add map_compiler.py and safe_name.py modules
- Track *.jpg/*.jpeg in Git LFS; remove frontend/build from .gitignore
- Update game engine, pathfinding, tech tree, bot, buildings, commands, units
- Refresh SvelteKit build and type definitions

Made-with: Cursor

.env.example

@@ -1,2 +1,7 @@
 MISTRAL_API_KEY=your_mistral_api_key_here
 SECRET_KEY=change-me-in-production
+
+# Optionnel : génération sprites via Vertex AI Imagen (ex. project GCP temporaire)
+# Si défini, le script generate_sprites utilise Imagen au lieu de Mistral. À retirer en prod.
+# GCP_PROJECT_ID=mtgbinder
+# GCP_LOCATION=us-central1

.gitattributes

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

.gitignore

@@ -6,5 +6,4 @@ __pycache__/
 **/*.pyc
 **/__pycache__/
 frontend/.svelte-kit/generated/
-frontend/.svelte-kit/output/
-frontend/build/
+frontend/.svelte-kit/output/

TODO.md

@@ -1,4 +1,7 @@
-AJouter detection safename
-Ajouter observing des matches existants si trop de matches en cours.
-Refaire la landing page pour etre plus précis engageant design plus cool etc... expliquer dans la peau d'un général
-Ajouter PVs unités
++ Refaire la landing page pour etre plus précis engageant design plus cool etc... expliquer dans la peau d'un général
++ AJouter detection safename
++ Ajouter observing des matches existants si trop de matches en cours.
+Ajouter PVs unités
+utiliser poisiotns de départ et placement des minéraux
+pathfinding
+shoot animation

backend/config.py

@@ -17,6 +17,11 @@ VOXTRAL_REALTIME_MODEL: str = "voxtral-mini-transcribe-realtime-2602"  # streami
 # Mistral LLM model for command parsing
 MISTRAL_CHAT_MODEL: str = "mistral-large-latest"
 
+# GCP Vertex AI Imagen (optionnel, pour génération sprites si Mistral restreint)
+# Ex: project mtgbinder — à retirer en prod
+GCP_PROJECT_ID: str = os.getenv("GCP_PROJECT_ID", "")
+GCP_LOCATION: str = os.getenv("GCP_LOCATION", "us-central1")
+
 # Game constants
 TICK_INTERVAL: float = 0.25        # seconds per game tick
 TICKS_PER_SECOND: int = 4

backend/game/bot.py

@@ -31,7 +31,7 @@ BOT_TICK_INTERVAL = 8
 
 
 def _cmd(*actions: GameAction) -> ParsedCommand:
-    return ParsedCommand(actions=list(actions), feedback="")
+    return ParsedCommand(actions=list(actions), feedback_template="")
 
 
 class BotPlayer:

backend/game/buildings.py

@@ -33,6 +33,17 @@ class BuildingDef(BaseModel):
     width: int = 2
     height: int = 2
     supply_provided: int = 0
+    # Collision box is shrunk by this amount on each side vs. the visual box,
+    # so units can squeeze between buildings that have a small visual gap.
+    collision_shrink: float = 0.4
+
+    def col_hw(self) -> float:
+        """Half collision width."""
+        return max(0.5, self.width / 2 - self.collision_shrink)
+
+    def col_hh(self) -> float:
+        """Half collision height."""
+        return max(0.5, self.height / 2 - self.collision_shrink)
 
 
 BUILDING_DEFS: dict[BuildingType, BuildingDef] = {
@@ -54,7 +65,7 @@ BUILDING_DEFS: dict[BuildingType, BuildingDef] = {
     ),
     BuildingType.REFINERY: BuildingDef(
         max_hp=500, mineral_cost=100, gas_cost=0, build_time_ticks=40,
-        width=2, height=2,
+        width=2, height=2, collision_shrink=0.2,
     ),
     BuildingType.FACTORY: BuildingDef(
         max_hp=1250, mineral_cost=200, gas_cost=100, build_time_ticks=80,
@@ -81,8 +92,8 @@ class Building(BaseModel):
     id: str = Field(default_factory=lambda: str(uuid.uuid4())[:8])
     building_type: BuildingType
     owner: str
-    x: int
-    y: int
+    x: float  # center x
+    y: float  # center y
     hp: float
     max_hp: int
     status: BuildingStatus = BuildingStatus.CONSTRUCTING
@@ -93,20 +104,20 @@ class Building(BaseModel):
     rally_y: Optional[float] = None
 
     @classmethod
-    def create(cls, bt: BuildingType, owner: str, x: int, y: int) -> "Building":
+    def create(cls, bt: BuildingType, owner: str, x: float, y: float) -> "Building":
         defn = BUILDING_DEFS[bt]
         return cls(
             building_type=bt,
             owner=owner,
             x=x,
             y=y,
-            hp=float(defn.max_hp),
+            hp=float(defn.max_hp) * 0.15,
             max_hp=defn.max_hp,
             construction_ticks_remaining=defn.build_time_ticks,
-        construction_max_ticks=defn.build_time_ticks,
+            construction_max_ticks=defn.build_time_ticks,
         )
 
     def spawn_point(self) -> tuple[float, float]:
-        """Position where units appear when produced."""
+        """Position where units appear when produced (below bottom edge, horizontally centered)."""
         defn = BUILDING_DEFS[self.building_type]
-        return (float(self.x) + defn.width / 2, float(self.y) + defn.height + 1)
+        return (self.x, self.y + defn.height / 2 + 1.0)

backend/game/commands.py

@@ -6,9 +6,9 @@ given to Mistral in voice/command_parser.py.
 """
 
 from enum import Enum
-from typing import Optional
+from typing import Any, Optional
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class ActionType(str, Enum):
@@ -68,19 +68,20 @@ class GameAction(BaseModel):
 
 
 class ParsedCommand(BaseModel):
-    """Full Mistral response: one or more actions + French feedback text."""
+    """Full Mistral response: one or more actions + feedback template to fill with game data."""
     actions: list[GameAction]
-    feedback: str
+    feedback_template: str  # sentence in command language with placeholders {n}, {zone}, {building}, etc.
+    language: str = "fr"  # ISO code of the user's command language (fr, en, ...)
 
 
 class ActionResult(BaseModel):
     action_type: str
     success: bool
-    message: str
+    data: dict[str, Any] = Field(default_factory=dict)  # template variables: n, zone, building, count, summary, ...
     sound_events: list[dict] = []  # e.g. [{"kind": "move_ack", "unit_type": "marine"}]
     unit_ids: list[str] = []  # for query_units: list of unit IDs matching the filter
 
 
 class CommandResult(BaseModel):
     results: list[ActionResult]
-    feedback_override: Optional[str] = None  # replaces Mistral feedback on hard error
+    feedback_override: Optional[str] = None  # error key for API to generate message (e.g. "game_not_in_progress")

backend/game/engine.py

@@ -22,7 +22,7 @@ from .bot import BOT_TICK_INTERVAL, BotPlayer
 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 .pathfinding import find_path, is_walkable, snap_to_walkable
+from .pathfinding import find_path, is_walkable, nearest_walkable_navpoint, snap_to_walkable
 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
@@ -47,6 +47,7 @@ class GameEngine:
         self._task: Optional[asyncio.Task] = None  # type: ignore[type-arg]
         self.bot: Optional[BotPlayer] = None
         self._sound_events: list[dict] = []  # fire/death per tick, sent in game_update
+        self._cmd_lang: str = "fr"
 
     # ------------------------------------------------------------------
     # Lifecycle
@@ -68,9 +69,10 @@ class GameEngine:
     # ------------------------------------------------------------------
 
     def apply_command(self, player_id: str, parsed: ParsedCommand) -> CommandResult:
+        self._cmd_lang = getattr(parsed, "language", "fr") or "fr"
         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.")
+            return CommandResult(results=[], feedback_override="game_not_in_progress")
 
         results: list[ActionResult] = []
         last_query_unit_ids: Optional[list[str]] = None
@@ -137,20 +139,44 @@ class GameEngine:
         for building in player.buildings.values():
             if building.status != BuildingStatus.CONSTRUCTING:
                 continue
+            # Only progress if the assigned SCV has arrived (status == BUILDING)
+            scv = next(
+                (u for u in player.units.values()
+                 if u.building_target_id == building.id and u.status == UnitStatus.BUILDING),
+                None,
+            )
+            if not scv:
+                continue
             building.construction_ticks_remaining -= 1
+            # HP grows linearly from 15% to 100% over build time
+            hp_gain = building.max_hp * 0.85 / max(1, building.construction_max_ticks)
+            building.hp = min(building.hp + hp_gain, float(building.max_hp))
             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
+                building.hp = float(building.max_hp)
+                scv.building_target_id = None
+                scv.target_x = scv.target_y = None
+                # Auto-return SCV to nearest mineral patch
+                cc = player.command_center()
+                cx = float(cc.x) + 2.0 if cc else scv.x
+                cy = float(cc.y) + 1.5 if cc else scv.y
+                patch = self.state.game_map.nearest_mineral(cx, cy)
+                if patch:
+                    scv.status = UnitStatus.MINING_MINERALS
+                    scv.assigned_resource_id = patch.id
+                    scv.harvest_carry = False
+                    scv.harvest_amount = 0
+                    patch.assigned_scv_ids.append(scv.id)
+                    self._set_unit_destination(scv, float(patch.x), float(patch.y), is_flying=False)
+                else:
+                    scv.status = UnitStatus.IDLE
 
     def _tick_production(self, player: PlayerState) -> None:
         """Tick building production queues and spawn units."""
         for building in player.buildings.values():
+            if building.status == BuildingStatus.CONSTRUCTING:
+                continue
             if not building.production_queue:
                 building.status = BuildingStatus.ACTIVE
                 continue
@@ -166,13 +192,19 @@ class GameEngine:
                 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()
+        raw_sx, raw_sy = building.spawn_point()
+        is_flying = UNIT_DEFS[ut].is_flying
+        if is_flying:
+            sx, sy = raw_sx, raw_sy
+        else:
+            blocked = self._building_blocked_rects()
+            sx, sy = nearest_walkable_navpoint(raw_sx, raw_sy, blocked_rects=blocked)
         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
-            self._set_unit_destination(unit, tx, ty, is_flying=UNIT_DEFS[ut].is_flying)
+            self._set_unit_destination(unit, tx, ty, is_flying=is_flying)
         player.units[unit.id] = unit
 
     def _tick_mining(self, player: PlayerState) -> None:
@@ -193,36 +225,47 @@ class GameEngine:
                     unit.harvest_carry = False
             return
 
-        cc_x = float(cc.x) + 2.0
-        cc_y = float(cc.y) + 1.5
-        arrive_dist = 1.5
+        mineral_arrive = 1.2   # SCV stops right next to the patch
+        cc_edge_arrive = 1.0   # SCV triggers deposit when within 1 tile of any CC edge
 
         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 not resource or resource.is_depleted:
+                    # Remove from old patch assignment
+                    if resource and unit.id in resource.assigned_scv_ids:
+                        resource.assigned_scv_ids.remove(unit.id)
                     unit.assigned_resource_id = None
-                    unit.status = UnitStatus.IDLE
-                    unit.target_x = unit.target_y = None
-                    unit.path_waypoints = []
-                    unit.harvest_carry = False
+                    # Auto-reassign to next available mineral instead of going idle
+                    next_patch = self.state.game_map.nearest_mineral(cc.x, cc.y)
+                    if next_patch:
+                        unit.assigned_resource_id = next_patch.id
+                        next_patch.assigned_scv_ids.append(unit.id)
+                        self._set_unit_destination(unit, float(next_patch.x), float(next_patch.y), is_flying=False)
+                    else:
+                        unit.status = UnitStatus.IDLE
+                        unit.target_x = unit.target_y = None
+                        unit.path_waypoints = []
+                        unit.harvest_carry = False
                     continue
 
                 rx, ry = float(resource.x), float(resource.y)
 
                 if not unit.harvest_carry:
-                    if unit.target_x != rx or unit.target_y != ry:
+                    if unit.target_x is None:
                         self._set_unit_destination(unit, rx, ry, is_flying=False)
-                    if unit.dist_to(rx, ry) <= arrive_dist:
+                    if unit.dist_to(rx, ry) <= mineral_arrive:
                         gathered = min(MINERAL_PER_HARVEST, resource.amount)
                         resource.amount -= gathered
                         unit.harvest_carry = True
                         unit.harvest_amount = gathered
-                        self._set_unit_destination(unit, cc_x, cc_y, is_flying=False)
+                        tx, ty = self._nearest_building_entry(unit, cc)
+                        self._set_unit_destination(unit, tx, ty, is_flying=False)
                 else:
-                    if unit.target_x != cc_x or unit.target_y != cc_y:
-                        self._set_unit_destination(unit, cc_x, cc_y, is_flying=False)
-                    if unit.dist_to(cc_x, cc_y) <= arrive_dist:
+                    if unit.target_x is None:
+                        tx, ty = self._nearest_building_entry(unit, cc)
+                        self._set_unit_destination(unit, tx, ty, is_flying=False)
+                    if self._dist_unit_to_building(unit, cc) <= cc_edge_arrive:
                         player.minerals += unit.harvest_amount
                         unit.harvest_carry = False
                         unit.harvest_amount = 0
@@ -241,16 +284,18 @@ class GameEngine:
                 rx, ry = float(resource.x), float(resource.y)
 
                 if not unit.harvest_carry:
-                    if unit.target_x != rx or unit.target_y != ry:
+                    if unit.target_x is None:
                         self._set_unit_destination(unit, rx, ry, is_flying=False)
-                    if unit.dist_to(rx, ry) <= arrive_dist:
+                    if unit.dist_to(rx, ry) <= mineral_arrive:
                         unit.harvest_carry = True
                         unit.harvest_amount = GAS_PER_HARVEST
-                        self._set_unit_destination(unit, cc_x, cc_y, is_flying=False)
+                        tx, ty = self._nearest_building_entry(unit, cc)
+                        self._set_unit_destination(unit, tx, ty, is_flying=False)
                 else:
-                    if unit.target_x != cc_x or unit.target_y != cc_y:
-                        self._set_unit_destination(unit, cc_x, cc_y, is_flying=False)
-                    if unit.dist_to(cc_x, cc_y) <= arrive_dist:
+                    if unit.target_x is None:
+                        tx, ty = self._nearest_building_entry(unit, cc)
+                        self._set_unit_destination(unit, tx, ty, is_flying=False)
+                    if self._dist_unit_to_building(unit, cc) <= cc_edge_arrive:
                         player.gas += unit.harvest_amount
                         unit.harvest_carry = False
                         unit.harvest_amount = 0
@@ -280,6 +325,10 @@ class GameEngine:
                 # Building SCVs stay put; mining SCVs move but skip combat
                 if unit.status == UnitStatus.BUILDING:
                     continue
+                if unit.status == UnitStatus.MOVING_TO_BUILD:
+                    if unit.target_x is not None and unit.target_y is not None:
+                        self._move_toward(unit, defn, unit.target_x, unit.target_y)
+                    continue
                 if unit.status in (UnitStatus.MINING_MINERALS, UnitStatus.MINING_GAS):
                     if unit.target_x is not None and unit.target_y is not None:
                         self._move_toward(unit, defn, unit.target_x, unit.target_y)
@@ -325,6 +374,22 @@ class GameEngine:
                 if unit.attack_target_id or unit.attack_target_building_id:
                     self._combat_attack(unit, defn, all_units, player, enemy, sieged=False)
 
+    def _building_blocked_rects(self) -> list[tuple[float, float, float, float]]:
+        """Collision footprints (x, y, w, h) used for pathfinding and unit collision.
+
+        Uses the shrunk collision box so units can pass between buildings
+        that have a small visual gap.
+        """
+        rects: list[tuple[float, float, float, float]] = []
+        for player in self.state.players.values():
+            for b in player.buildings.values():
+                if b.status == BuildingStatus.DESTROYED:
+                    continue
+                defn = BUILDING_DEFS[b.building_type]
+                chw, chh = defn.col_hw(), defn.col_hh()
+                rects.append((b.x - chw, b.y - chh, chw * 2, chh * 2))
+        return rects
+
     def _set_unit_destination(
         self, unit: Unit, tx: float, ty: float, *, is_flying: bool
     ) -> None:
@@ -334,40 +399,157 @@ class GameEngine:
         unit.path_waypoints = []
         if is_flying:
             return
-        path = find_path(unit.x, unit.y, tx, ty)
+        blocked = self._building_blocked_rects()
+        sx, sy = unit.x, unit.y
+        path = find_path(sx, sy, tx, ty, blocked_rects=blocked)
         if path is None:
-            snapped = snap_to_walkable(tx, ty)
-            unit.target_x, unit.target_y = snapped[0], snapped[1]
-            return
+            # Start is inside a building footprint — snap start outside first
+            snapped_start = snap_to_walkable(sx, sy, blocked_rects=blocked)
+            if snapped_start != (sx, sy):
+                path = find_path(snapped_start[0], snapped_start[1], tx, ty, blocked_rects=blocked)
+            if path is None:
+                snapped_dst = snap_to_walkable(tx, ty, blocked_rects=blocked)
+                unit.target_x, unit.target_y = snapped_dst[0], snapped_dst[1]
+                return
         if not path:
             return
         unit.target_x, unit.target_y = path[0][0], path[0][1]
         unit.path_waypoints = [[p[0], p[1]] for p in path[1:]]
 
+    def _would_overlap(
+        self, unit: Unit, new_x: float, new_y: float, *, exclude_unit_id: Optional[str] = None
+    ) -> bool:
+        """True if (new_x, new_y) would overlap another unit or a building.
+
+        Mining SCVs use soft collision (they can pass through each other, like in SC).
+        For other units, if two already overlap we allow moves that increase separation.
+        """
+        _mining = (UnitStatus.MINING_MINERALS, UnitStatus.MINING_GAS)
+        unit_is_miner = unit.status in _mining
+        for player in self.state.players.values():
+            for u in player.units.values():
+                if u.id == unit.id or (exclude_unit_id and u.id == exclude_unit_id):
+                    continue
+                # Miners pass through other miners (soft collision, matching SC behaviour)
+                if unit_is_miner and u.status in _mining:
+                    continue
+                min_dist = 2 * UNIT_RADIUS
+                new_dist = math.hypot(new_x - u.x, new_y - u.y)
+                if new_dist >= min_dist:
+                    continue
+                # Already overlapping: allow the move only if it increases separation
+                cur_dist = math.hypot(unit.x - u.x, unit.y - u.y)
+                if cur_dist < min_dist and new_dist >= cur_dist:
+                    continue  # moving away from an already-overlapping unit — allow
+                return True
+        for rx, ry, w, h in self._building_blocked_rects():
+            px = max(rx, min(rx + w, new_x))
+            py = max(ry, min(ry + h, new_y))
+            if math.hypot(new_x - px, new_y - py) < UNIT_RADIUS:
+                return True
+        return 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)
+        """Move unit up to one full step toward target, consuming intermediate waypoints smoothly."""
         step = defn.move_speed * TICK_INTERVAL
-        if dist <= step:
-            unit.x = tx
-            unit.y = ty
-            if unit.path_waypoints:
-                next_wp = unit.path_waypoints.pop(0)
-                unit.target_x, unit.target_y = next_wp[0], next_wp[1]
-                return
-            if unit.status == UnitStatus.MOVING:
-                unit.status = UnitStatus.IDLE
-                unit.target_x = unit.target_y = None
-            elif unit.status == UnitStatus.ATTACKING:
-                unit.status = UnitStatus.IDLE
-                unit.target_x = unit.target_y = None
-            elif unit.status == UnitStatus.PATROLLING:
-                unit.target_x, unit.patrol_x = unit.patrol_x, unit.target_x
-                unit.target_y, unit.patrol_y = unit.patrol_y, unit.target_y
+        remaining = step
+        cur_tx, cur_ty = tx, ty
+        moved = False
+        arrived = False
+
+        while remaining > 1e-6:
+            dx = cur_tx - unit.x
+            dy = cur_ty - unit.y
+            dist = math.sqrt(dx * dx + dy * dy)
+
+            if dist < 1e-6:
+                # Already on this waypoint — advance immediately
+                if unit.path_waypoints:
+                    nw = unit.path_waypoints.pop(0)
+                    cur_tx = nw[0]; cur_ty = nw[1]
+                    unit.target_x = cur_tx; unit.target_y = cur_ty
+                else:
+                    arrived = True
+                break
+
+            if dist <= remaining:
+                # Can reach this waypoint within remaining budget — snap and continue
+                unit.x = cur_tx
+                unit.y = cur_ty
+                remaining -= dist
+                moved = True
+                if unit.path_waypoints:
+                    nw = unit.path_waypoints.pop(0)
+                    cur_tx = nw[0]; cur_ty = nw[1]
+                    unit.target_x = cur_tx; unit.target_y = cur_ty
+                else:
+                    arrived = True
+                    break
+            else:
+                # Partial move — try full remaining, then half, then slide
+                nx = dx / dist
+                ny = dy / dist
+                new_x = unit.x + nx * remaining
+                new_y = unit.y + ny * remaining
+
+                if not self._would_overlap(unit, new_x, new_y):
+                    unit.x = new_x
+                    unit.y = new_y
+                    moved = True
+                else:
+                    hx = unit.x + nx * remaining * 0.5
+                    hy = unit.y + ny * remaining * 0.5
+                    if not self._would_overlap(unit, hx, hy):
+                        unit.x = hx
+                        unit.y = hy
+                        moved = True
+                    elif abs(nx) >= abs(ny):
+                        if abs(nx) > 0.05 and not self._would_overlap(unit, unit.x + nx * remaining, unit.y):
+                            unit.x += nx * remaining
+                            moved = True
+                        elif abs(ny) > 0.05 and not self._would_overlap(unit, unit.x, unit.y + ny * remaining):
+                            unit.y += ny * remaining
+                            moved = True
+                    else:
+                        if abs(ny) > 0.05 and not self._would_overlap(unit, unit.x, unit.y + ny * remaining):
+                            unit.y += ny * remaining
+                            moved = True
+                        elif abs(nx) > 0.05 and not self._would_overlap(unit, unit.x + nx * remaining, unit.y):
+                            unit.x += nx * remaining
+                            moved = True
+                break
+
+        unit.target_x = cur_tx
+        unit.target_y = cur_ty
+
+        if moved or arrived:
+            unit.stuck_ticks = 0
         else:
-            unit.x += (dx / dist) * step
-            unit.y += (dy / dist) * step
+            unit.stuck_ticks += 1
+            if unit.stuck_ticks >= 4:
+                unit.stuck_ticks = 0
+                if unit.path_waypoints:
+                    nw = unit.path_waypoints.pop(0)
+                    unit.target_x, unit.target_y = nw[0], nw[1]
+                else:
+                    arrived = True
+            else:
+                return
+
+        if not arrived:
+            return
+        if unit.status == UnitStatus.MOVING:
+            unit.status = UnitStatus.IDLE
+            unit.target_x = unit.target_y = None
+        elif unit.status == UnitStatus.ATTACKING:
+            unit.status = UnitStatus.IDLE
+            unit.target_x = unit.target_y = None
+        elif unit.status == UnitStatus.MOVING_TO_BUILD:
+            unit.status = UnitStatus.BUILDING
+            unit.target_x = unit.target_y = None
+        elif unit.status == UnitStatus.PATROLLING:
+            unit.target_x, unit.patrol_x = unit.patrol_x, unit.target_x
+            unit.target_y, unit.patrol_y = unit.patrol_y, unit.target_y
 
     def _combat_attack(
         self,
@@ -517,18 +699,38 @@ class GameEngine:
     # ------------------------------------------------------------------
 
     def _building_center(self, b: Building) -> tuple[float, float]:
-        defn = BUILDING_DEFS[b.building_type]
-        return (float(b.x) + defn.width / 2, float(b.y) + defn.height / 2)
+        return (b.x, b.y)
 
     def _dist_unit_to_building(self, unit: Unit, building: Building) -> float:
-        """Distance from unit center to nearest point on building footprint (carré le plus proche)."""
+        """Distance from unit center to nearest point on the building collision box."""
         defn = BUILDING_DEFS[building.building_type]
-        x0, x1 = float(building.x), float(building.x) + defn.width
-        y0, y1 = float(building.y), float(building.y) + defn.height
+        chw, chh = defn.col_hw(), defn.col_hh()
+        x0, x1 = building.x - chw, building.x + chw
+        y0, y1 = building.y - chh, building.y + chh
         px = max(x0, min(x1, unit.x))
         py = max(y0, min(y1, unit.y))
         return math.sqrt((unit.x - px) ** 2 + (unit.y - py) ** 2)
 
+    def _nearest_building_entry(self, unit: Unit, building: Building) -> tuple[float, float]:
+        """Return a point just outside the nearest visual edge of a building, on the unit's side.
+
+        SCVs use this to approach from whichever direction they're coming from,
+        so they can deposit/interact from any side instead of always queuing at one point.
+        Uses the visual box (not the collision box) so the SCV visually touches the building.
+        """
+        defn = BUILDING_DEFS[building.building_type]
+        hw = defn.width / 2
+        hh = defn.height / 2
+        px = max(building.x - hw, min(building.x + hw, unit.x))
+        py = max(building.y - hh, min(building.y + hh, unit.y))
+        dx = unit.x - px
+        dy = unit.y - py
+        d = math.hypot(dx, dy)
+        margin = UNIT_RADIUS + 0.3
+        if d > 0:
+            return (px + dx / d * margin, py + dy / d * margin)
+        return (building.x, building.y + hh + margin)
+
     def _nearest_enemy_in_range(
         self,
         unit: Unit,
@@ -557,17 +759,18 @@ class GameEngine:
         return best[1] if best else None
 
     def _resolve_zone(self, player_id: str, zone: str) -> tuple[float, float]:
+        import re as _re
         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
+        base_x = cc.x if cc else float(MAP_WIDTH) / 2
+        base_y = cc.y 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)
+            return (ecc.x, ecc.y) if ecc else (MAP_WIDTH - 5, MAP_HEIGHT - 5)
         if zone == "center":
             return (MAP_WIDTH / 2, MAP_HEIGHT / 2)
         if zone == "top_left":
@@ -587,6 +790,29 @@ class GameEngine:
                 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)
+
+        m = _re.match(r'^mineral_(\d+)$', zone)
+        if m:
+            idx = int(m.group(1)) - 1
+            minerals = [
+                r for r in self.state.game_map.resources
+                if r.resource_type == ResourceType.MINERAL and not r.is_depleted
+            ]
+            minerals.sort(key=lambda r: (r.x - base_x) ** 2 + (r.y - base_y) ** 2)
+            if 0 <= idx < len(minerals):
+                return (float(minerals[idx].x), float(minerals[idx].y))
+
+        m = _re.match(r'^geyser_(\d+)$', zone)
+        if m:
+            idx = int(m.group(1)) - 1
+            geysers = [
+                r for r in self.state.game_map.resources
+                if r.resource_type == ResourceType.GEYSER
+            ]
+            geysers.sort(key=lambda r: (r.x - base_x) ** 2 + (r.y - base_y) ** 2)
+            if 0 <= idx < len(geysers):
+                return (float(geysers[idx].x), float(geysers[idx].y))
+
         # Fallback: enemy base
         if enemy:
             ecc = enemy.command_center()
@@ -635,38 +861,71 @@ class GameEngine:
                 pass
         return [u.id for u in units]
 
+    # Vision radii (in cells) — must match frontend constants
+    _UNIT_VISION: dict[UnitType, float] = {
+        UnitType.SCV: 6, UnitType.MARINE: 6, UnitType.MEDIC: 6,
+        UnitType.GOLIATH: 8, UnitType.TANK: 8, UnitType.WRAITH: 9,
+    }
+    _BUILDING_VISION: dict[BuildingType, float] = {
+        BuildingType.COMMAND_CENTER: 10, BuildingType.SUPPLY_DEPOT: 7,
+        BuildingType.BARRACKS: 7, BuildingType.ENGINEERING_BAY: 7,
+        BuildingType.REFINERY: 7, BuildingType.FACTORY: 7,
+        BuildingType.ARMORY: 7, BuildingType.STARPORT: 7,
+    }
+    _SCV_BUILD_RANGE: float = 6.0
+
+    def _is_visible(self, player: PlayerState, x: float, y: float) -> bool:
+        """Return True if tile (x, y) is within vision of any own unit or building."""
+        for u in player.units.values():
+            r = self._UNIT_VISION.get(u.unit_type, 6.0)
+            if (u.x - x) ** 2 + (u.y - y) ** 2 <= r * r:
+                return True
+        for b in player.buildings.values():
+            if b.status == BuildingStatus.DESTROYED:
+                continue
+            r = self._BUILDING_VISION.get(b.building_type, 7.0)
+            if (b.x - x) ** 2 + (b.y - y) ** 2 <= r * r:
+                return True
+        return False
+
     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
+        self, player: PlayerState, bt: BuildingType, near_scv: Unit
+    ) -> Optional[tuple[float, float]]:
+        """Return CENTER coordinates for a new building, or None if no valid spot found."""
         defn = BUILDING_DEFS[bt]
+        cx, cy = near_scv.x, near_scv.y
 
-        for radius in range(3, 18):
+        for radius in range(1, int(self._SCV_BUILD_RANGE) + 2):
             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)
+                    tl_x, tl_y = int(cx) + dx, int(cy) + dy
+                    tile_cx = tl_x + defn.width / 2.0
+                    tile_cy = tl_y + defn.height / 2.0
+                    if (tile_cx - cx) ** 2 + (tile_cy - cy) ** 2 > self._SCV_BUILD_RANGE ** 2:
+                        continue
+                    if not self._can_place(tl_x, tl_y, defn):
+                        continue
+                    if not self._is_visible(player, tile_cx, tile_cy):
+                        continue
+                    return (tile_cx, tile_cy)
         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:
+    def _can_place(self, tl_x: int, tl_y: int, defn: BuildingDef) -> bool:
+        """Check if a building with given top-left corner can be placed (no overlap, in bounds)."""
+        if tl_x < 0 or tl_y < 0 or tl_x + defn.width > MAP_WIDTH or tl_y + defn.height > MAP_HEIGHT:
             return False
-        # Check overlap with all buildings
+        # Check overlap with existing buildings (stored as center coords)
         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:
+                if tl_x < b.x + bd.width / 2 and tl_x + defn.width > b.x - bd.width / 2 \
+                        and tl_y < b.y + bd.height / 2 and tl_y + defn.height > b.y - bd.height / 2:
                     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:
+            if tl_x <= res.x < tl_x + defn.width and tl_y <= res.y < tl_y + defn.height:
                 return False
         return True
 
@@ -705,30 +964,37 @@ class GameEngine:
                 return self._cmd_query_units(player, action)
             if t == ActionType.ASSIGN_TO_GROUP:
                 return self._cmd_assign_to_group(player, action)
-            return ActionResult(action_type=t, success=False, message="Action inconnue.")
+            return ActionResult(
+                action_type=t, success=False, data={"error": "unknown_action"}
+            )
         except Exception as exc:
             log.exception("Error applying action %s", action.type)
-            return ActionResult(action_type=str(action.type), success=False, message=str(exc))
+            return ActionResult(
+                action_type=str(action.type), success=False, data={"error": "exception", "detail": 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.")
+            return ActionResult(action_type="build", success=False, data={"error": "build_missing_type"})
         try:
             bt = BuildingType(raw)
         except ValueError:
-            return ActionResult(action_type="build", success=False, message=f"Bâtiment inconnu: {raw}.")
+            return ActionResult(action_type="build", success=False, data={"error": "build_unknown", "raw": raw})
 
         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}.")
+            return ActionResult(
+                action_type="build", success=False, data={"error": "build_missing_prereq", "names": names}
+            )
 
         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).")
+            return ActionResult(
+                action_type="build", success=False,
+                data={"error": "build_insufficient_resources", "mineral": defn.mineral_cost, "gas": defn.gas_cost},
+            )
 
         # Clamp count to what resources and SCVs allow
         count = max(1, min(action.count, 5))
@@ -745,27 +1011,31 @@ class GameEngine:
         )
         count = min(count, len(available_scvs))
         if count == 0:
-            return ActionResult(action_type="build", success=False, message="Aucun SCV disponible.")
+            return ActionResult(action_type="build", success=False, data={"error": "build_no_scv"})
 
         cc = player.command_center()
         cx, cy = (float(cc.x), float(cc.y)) if cc else (0.0, 0.0)
 
         built = 0
         for i in range(count):
-            # Find position for this building
+            scv = available_scvs[i]
+
+            # Find center position for this building
             if bt == BuildingType.REFINERY:
                 geyser = self.state.game_map.nearest_geyser_without_refinery(cx, cy)
                 if not geyser:
                     break
-                pos: tuple[int, int] = (geyser.x, geyser.y)
+                # Refinery (2×2) centered on geyser tile (+1 from integer geyser coord)
+                pos_cx: float = geyser.x + 1.0
+                pos_cy: float = geyser.y + 1.0
+                if not self._is_visible(player, pos_cx, pos_cy):
+                    break
                 geyser.has_refinery = True
             else:
-                pos_opt = self._find_build_position(player, bt)
+                pos_opt = self._find_build_position(player, bt, scv)
                 if not pos_opt:
                     break
-                pos = pos_opt
-
-            scv = available_scvs[i]
+                pos_cx, pos_cy = pos_opt
             # Unassign from resource if mining
             if scv.assigned_resource_id:
                 res = self.state.game_map.get_resource(scv.assigned_resource_id)
@@ -778,62 +1048,80 @@ class GameEngine:
             player.minerals -= defn.mineral_cost
             player.gas -= defn.gas_cost
 
-            building = Building.create(bt, player.player_id, pos[0], pos[1])
+            building = Building.create(bt, player.player_id, pos_cx, pos_cy)
             player.buildings[building.id] = building
 
-            scv.status = UnitStatus.BUILDING
+            scv.status = UnitStatus.MOVING_TO_BUILD
             scv.building_target_id = building.id
-            scv.target_x = float(pos[0])
-            scv.target_y = float(pos[1])
+            # Navigate to the nearest point just outside the building edge
+            bw = float(defn.width)
+            bh = float(defn.height)
+            edge_x = max(pos_cx - bw / 2, min(pos_cx + bw / 2, scv.x))
+            edge_y = max(pos_cy - bh / 2, min(pos_cy + bh / 2, scv.y))
+            dx = scv.x - edge_x
+            dy = scv.y - edge_y
+            edge_dist = math.hypot(dx, dy)
+            approach_margin = UNIT_RADIUS + 0.6
+            if edge_dist > 0:
+                dest_x = edge_x + dx / edge_dist * approach_margin
+                dest_y = edge_y + dy / edge_dist * approach_margin
+            else:
+                dest_x = pos_cx + bw / 2 + approach_margin
+                dest_y = pos_cy
+            self._set_unit_destination(scv, dest_x, dest_y, is_flying=False)
             built += 1
 
         if built == 0:
-            return ActionResult(action_type="build", success=False,
-                                message="Impossible de trouver un emplacement.")
-        return ActionResult(action_type="build", success=True,
-                            message=f"{built} {bt.value}(s) en construction.")
+            return ActionResult(action_type="build", success=False, data={"error": "build_no_placement"})
+        return ActionResult(
+            action_type="build", success=True,
+            data={"built": built, "building": bt.value},
+        )
 
     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.")
+            return ActionResult(action_type="train", success=False, data={"error": "train_missing_type"})
         try:
             ut = UnitType(raw)
         except ValueError:
-            return ActionResult(action_type="train", success=False, message=f"Unité inconnue: {raw}.")
+            return ActionResult(action_type="train", success=False, data={"error": "train_unknown", "raw": 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}.")
+            return ActionResult(
+                action_type="train", success=False, data={"error": "train_missing_prereq", "names": 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.")
+            return ActionResult(
+                action_type="train", success=False,
+                data={"error": "train_no_producer", "producer": producer_type.value},
+            )
 
         count = max(1, min(action.count, 20))
         num_producers = len(producers)
 
-        # Resources are checked for the full requested count
         total_minerals = defn.mineral_cost * count
         total_gas = defn.gas_cost * count
         if player.minerals < total_minerals or player.gas < total_gas:
-            return ActionResult(action_type="train", success=False,
-                                message="Ressources insuffisantes.")
+            return ActionResult(
+                action_type="train", success=False, data={"error": "train_insufficient_resources"}
+            )
 
-        # Supply check: account for actual units + already-queued units + new batch
         queued_supply = sum(
             UNIT_DEFS[UnitType(item.unit_type)].supply_cost
             for b in player.buildings.values()
             for item in b.production_queue
         )
         if player.supply_used + queued_supply + defn.supply_cost * count > player.supply_max:
-            return ActionResult(action_type="train", success=False,
-                                message="Supply insuffisant.")
+            return ActionResult(
+                action_type="train", success=False, data={"error": "train_insufficient_supply"}
+            )
 
         from .buildings import ProductionItem  # local import to avoid cycle
         for i in range(count):
@@ -849,13 +1137,15 @@ class GameEngine:
         player.minerals -= total_minerals
         player.gas -= total_gas
 
-        return ActionResult(action_type="train", success=True,
-                            message=f"{count} {ut.value}(s) en production.")
+        return ActionResult(
+            action_type="train", success=True,
+            data={"count": count, "unit": ut.value},
+        )
 
     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.")
+            return ActionResult(action_type="move", success=False, data={"error": "no_units_selected"})
         tx, ty = self._resolve_zone(player.player_id, action.target_zone or "center")
         for unit in units:
             if unit.is_sieged:
@@ -865,14 +1155,16 @@ class GameEngine:
             unit.attack_target_building_id = None
             self._set_unit_destination(unit, tx, ty, is_flying=UNIT_DEFS[unit.unit_type].is_flying)
         move_ack = [{"kind": "move_ack", "unit_type": units[0].unit_type.value}]
-        return ActionResult(action_type="move", success=True,
-                            message=f"{len(units)} unité(s) en mouvement vers {action.target_zone}.",
-                            sound_events=move_ack)
+        zone = action.target_zone or "center"
+        return ActionResult(
+            action_type="move", success=True,
+            data={"n": len(units), "zone": zone}, sound_events=move_ack,
+        )
 
     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.")
+            return ActionResult(action_type="attack", success=False, data={"error": "no_units_selected"})
         tx, ty = self._resolve_zone(player.player_id, action.target_zone or "enemy_base")
         for unit in units:
             if unit.is_sieged:
@@ -882,34 +1174,40 @@ class GameEngine:
             unit.attack_target_building_id = None
             self._set_unit_destination(unit, tx, ty, is_flying=UNIT_DEFS[unit.unit_type].is_flying)
         move_ack = [{"kind": "move_ack", "unit_type": units[0].unit_type.value}]
-        return ActionResult(action_type="attack", success=True,
-                            message=f"{len(units)} unité(s) envoyées à l'attaque vers {action.target_zone}.",
-                            sound_events=move_ack)
+        zone = action.target_zone or "enemy_base"
+        return ActionResult(
+            action_type="attack", success=True,
+            data={"n": len(units), "zone": zone}, sound_events=move_ack,
+        )
 
     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.")
+            return ActionResult(action_type="siege", success=False, data={"error": "siege_no_tanks"})
         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}.")
+        mode = "siege" if siege else "mobile"
+        return ActionResult(
+            action_type="siege", success=True,
+            data={"n": len(tanks), "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.")
+            return ActionResult(action_type="cloak", success=False, data={"error": "cloak_no_wraiths"})
         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).")
+        state = "on" if cloak else "off"
+        return ActionResult(
+            action_type="cloak", success=True,
+            data={"n": len(wraiths), "state": state},
+        )
 
     def _cmd_gather(self, player: PlayerState, action: GameAction) -> ActionResult:
         resource_type = (action.resource_type or "minerals").lower()
@@ -919,7 +1217,7 @@ class GameEngine:
         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.")
+            return ActionResult(action_type="gather", success=False, data={"error": "gather_no_scv"})
 
         assigned = 0
         if resource_type == "gas":
@@ -940,8 +1238,23 @@ class GameEngine:
                 geyser.assigned_scv_ids.append(scv.id)
                 assigned += 1
         else:
+            # Distribute SCVs across patches evenly: pick the patch with fewest assigned SCVs
+            # (avoids funnelling all 5 SCVs to the same nearest patch)
+            mineral_patches = [
+                r for r in self.state.game_map.resources
+                if r.resource_type.value == "mineral" and not r.is_depleted and r.has_capacity
+            ]
+            if not mineral_patches:
+                return ActionResult(action_type="gather", success=False, data={"error": "gather_no_resource"})
+
             for scv in scvs:
-                patch = self.state.game_map.nearest_mineral(cx, cy)
+                if not mineral_patches:
+                    break
+                # Choose patch with fewest assigned SCVs (tie-break: nearest to CC)
+                patch = min(
+                    mineral_patches,
+                    key=lambda r: (len(r.assigned_scv_ids), (r.x - cx) ** 2 + (r.y - cy) ** 2)
+                )
                 if not patch:
                     break
                 if scv.assigned_resource_id:
@@ -955,12 +1268,17 @@ class GameEngine:
                 self._set_unit_destination(scv, float(patch.x), float(patch.y), is_flying=False)
                 patch.assigned_scv_ids.append(scv.id)
                 assigned += 1
+                # Remove full patches from candidates
+                mineral_patches = [r for r in mineral_patches if r.has_capacity]
 
         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}.")
+            return ActionResult(
+                action_type="gather", success=False, data={"error": "gather_no_resource"}
+            )
+        return ActionResult(
+            action_type="gather", success=True,
+            data={"n": assigned, "resource": resource_type},
+        )
 
     def _cmd_stop(self, player: PlayerState, action: GameAction) -> ActionResult:
         units = self._resolve_selector(player, action.unit_selector or "all_military")
@@ -970,13 +1288,12 @@ class GameEngine:
             unit.path_waypoints = []
             unit.attack_target_id = None
             unit.attack_target_building_id = None
-        return ActionResult(action_type="stop", success=True,
-                            message=f"{len(units)} unité(s) stoppées.")
+        return ActionResult(action_type="stop", success=True, data={"n": len(units)})
 
     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.")
+            return ActionResult(action_type="patrol", success=False, data={"error": "no_units_selected"})
         tx, ty = self._resolve_zone(player.player_id, action.target_zone or "center")
         for unit in units:
             if unit.is_sieged:
@@ -986,12 +1303,17 @@ class GameEngine:
             unit.status = UnitStatus.PATROLLING
             self._set_unit_destination(unit, tx, ty, is_flying=UNIT_DEFS[unit.unit_type].is_flying)
         move_ack = [{"kind": "move_ack", "unit_type": units[0].unit_type.value}]
-        return ActionResult(action_type="patrol", success=True,
-                            message=f"{len(units)} unité(s) en patrouille vers {action.target_zone}.",
-                            sound_events=move_ack)
+        zone = action.target_zone or "center"
+        return ActionResult(
+            action_type="patrol", success=True,
+            data={"n": len(units), "zone": zone}, sound_events=move_ack,
+        )
 
     def _cmd_query(self, player: PlayerState, action: GameAction) -> ActionResult:
-        return ActionResult(action_type="query", success=True, message=player.summary())
+        return ActionResult(
+            action_type="query", success=True,
+            data={"summary": player.summary(self._cmd_lang)},
+        )
 
     def _cmd_query_units(self, player: PlayerState, action: GameAction) -> ActionResult:
         """Query units by zone and/or type; return their IDs in result.unit_ids."""
@@ -1001,7 +1323,7 @@ class GameEngine:
         return ActionResult(
             action_type="query_units",
             success=True,
-            message=f"{len(ids)} unité(s) trouvée(s).",
+            data={"n": len(ids)},
             unit_ids=ids,
         )
 
@@ -1012,7 +1334,7 @@ class GameEngine:
             return ActionResult(
                 action_type="assign_to_group",
                 success=False,
-                message="Groupe invalide (utilise 1, 2 ou 3).",
+                data={"error": "group_invalid"},
             )
         ids = list(action.unit_ids) if action.unit_ids else []
         valid_ids = [uid for uid in ids if uid in player.units]
@@ -1020,7 +1342,7 @@ class GameEngine:
         return ActionResult(
             action_type="assign_to_group",
             success=True,
-            message=f"Groupe {gi} : {len(valid_ids)} unité(s) assignée(s).",
+            data={"gi": gi, "n": len(valid_ids)},
         )
 
     # ------------------------------------------------------------------

backend/game/map.py

@@ -7,25 +7,25 @@ from enum import Enum
 
 from pydantic import BaseModel, Field
 
-MAP_WIDTH = 40
-MAP_HEIGHT = 40
+MAP_WIDTH = 80
+MAP_HEIGHT = 80
 
 # Starting positions (top-left corner of Command Center footprint) — fallback if no game_positions.json
-PLAYER1_START: tuple[int, int] = (4, 5)
-PLAYER2_START: tuple[int, int] = (32, 32)
+PLAYER1_START: tuple[int, int] = (8, 10)
+PLAYER2_START: tuple[int, int] = (64, 64)
 
 # Absolute resource positions (fallback)
 _P1_MINERALS: list[tuple[int, int]] = [
-    (2, 2), (3, 2), (4, 2), (5, 2), (6, 2),
-    (2, 3), (6, 3), (3, 9),
+    (4, 4), (6, 4), (8, 4), (10, 4), (12, 4),
+    (4, 6), (12, 6), (6, 18),
 ]
-_P1_GEYSERS: list[tuple[int, int]] = [(2, 9), (7, 9)]
+_P1_GEYSERS: list[tuple[int, int]] = [(4, 18), (14, 18)]
 
 _P2_MINERALS: list[tuple[int, int]] = [
-    (33, 37), (34, 37), (35, 37), (36, 37), (37, 37),
-    (33, 36), (37, 36), (34, 30),
+    (66, 74), (68, 74), (70, 74), (72, 74), (74, 74),
+    (66, 72), (74, 72), (68, 60),
 ]
-_P2_GEYSERS: list[tuple[int, int]] = [(32, 30), (37, 30)]
+_P2_GEYSERS: list[tuple[int, int]] = [(64, 60), (74, 60)]
 
 
 def _game_positions_path() -> Path | None:
@@ -33,32 +33,266 @@ def _game_positions_path() -> Path | None:
     return p if p.exists() else None
 
 
-def get_start_positions() -> tuple[tuple[int, int], tuple[int, int]]:
-    """Return (player1_start, player2_start) in game grid. With 3 positions in file, 2 are chosen at random."""
+def _to_game_coords(x: float, y: float) -> tuple[int, int]:
+    gx = max(0, min(MAP_WIDTH - 1, int(round(x * MAP_WIDTH / 100.0))))
+    gy = max(0, min(MAP_HEIGHT - 1, int(round(y * MAP_HEIGHT / 100.0))))
+    return (gx, gy)
+
+
+def _resources_from_start_entry(entry: dict) -> list["Resource"]:
+    """Build list of Resource from a starting_position entry that has nested minerals/geysers."""
+    resources: list[Resource] = []
+    for m in entry.get("minerals") or []:
+        x, y = int(m.get("x", 0)), int(m.get("y", 0))
+        if 0 <= x < MAP_WIDTH and 0 <= y < MAP_HEIGHT:
+            resources.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
+    for g in entry.get("geysers") or []:
+        x, y = int(g.get("x", 0)), int(g.get("y", 0))
+        if 0 <= x < MAP_WIDTH and 0 <= y < MAP_HEIGHT:
+            resources.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
+    return resources
+
+
+# 8 minerals in a ring at ~6 tiles from center, 2 geysers at ~8 tiles.
+# All distances are deterministic so every base gets the same layout.
+_RESOURCE_OFFSETS_MINERAL = [
+    (6, 0), (5, 3), (0, 6), (-5, 3), (-6, 0), (-5, -3), (0, -6), (5, -3),
+]
+_RESOURCE_OFFSETS_GEYSER = [(7, 4), (-7, 4)]
+
+
+def _generate_resources_at(gx: int, gy: int) -> list["Resource"]:
+    """Generate 8 mineral patches and 2 geysers at fixed distances around a game coordinate.
+
+    Every base always gets the same symmetric layout so distances are consistent.
+    """
+    resources: list[Resource] = []
+    seen: set[tuple[int, int]] = set()
+    for dx, dy in _RESOURCE_OFFSETS_MINERAL:
+        x = max(0, min(MAP_WIDTH - 1, gx + dx))
+        y = max(0, min(MAP_HEIGHT - 1, gy + dy))
+        if (x, y) not in seen:
+            seen.add((x, y))
+            resources.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
+    for dx, dy in _RESOURCE_OFFSETS_GEYSER:
+        x = max(0, min(MAP_WIDTH - 1, gx + dx))
+        y = max(0, min(MAP_HEIGHT - 1, gy + dy))
+        if (x, y) not in seen:
+            seen.add((x, y))
+            resources.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
+    return resources
+
+
+def get_start_positions() -> tuple[tuple[float, float], tuple[float, float]]:
+    """Return (player1_start, player2_start) in game coords. With 3 positions in file, 2 are chosen at random."""
+    start1, _, start2, _ = get_start_data()
+    return start1, start2
+
+
+def get_all_map_resources() -> list["Resource"]:
+    """Return resources for ALL starting positions AND expansion positions.
+
+    Resources are ALWAYS generated via _generate_resources_at() using fixed offsets so that
+    every base — regardless of origin — has minerals and geysers at a consistent distance
+    from its Command Center.  Embedded minerals in game_positions.json are intentionally
+    ignored in favour of this deterministic layout.
+    """
+    path = _game_positions_path()
+    if path:
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+            all_entries = (
+                list(data.get("starting_positions") or [])
+                + list(data.get("expansion_positions") or [])
+            )
+            if all_entries:
+                resources: list[Resource] = []
+                for entry in all_entries:
+                    gx, gy = _to_game_coords(float(entry.get("x", 0)), float(entry.get("y", 0)))
+                    resources.extend(_generate_resources_at(gx, gy))
+                return resources
+        except (OSError, json.JSONDecodeError, KeyError):
+            pass
+    # Fallback: derive starts + expansions from nav_points
+    compiled_path = Path(__file__).resolve().parent.parent / "static" / "compiled_map.json"
+    if compiled_path.exists():
+        try:
+            with open(compiled_path, encoding="utf-8") as f:
+                nav_data = json.load(f)
+            pts = nav_data.get("nav_points") or []
+            if len(pts) >= 4:
+                coords = [(float(p[0]), float(p[1])) for p in pts]
+                starts, expansions, _ = _fallback_all_resources(coords)
+                resources = []
+                for pos in starts + expansions:
+                    gx, gy = int(round(pos[0])), int(round(pos[1]))
+                    resources.extend(_generate_resources_at(gx, gy))
+                return resources
+        except (OSError, json.JSONDecodeError, KeyError, ValueError):
+            pass
+    _, r1, _, r2 = _fallback_from_nav()
+    return r1 + r2
+
+
+def get_start_data() -> tuple[
+    tuple[float, float], list[Resource], tuple[float, float], list[Resource]
+]:
+    """Return (start1, resources1, start2, resources2) for the 2 chosen bases. With 3 positions, 2 are chosen at random; resources are only those for the chosen bases."""
     import random
     path = _game_positions_path()
     if not path:
-        return PLAYER1_START, PLAYER2_START
+        return _fallback_from_nav()
     try:
         with open(path, encoding="utf-8") as f:
             data = json.load(f)
         starts = data.get("starting_positions") or []
         if len(starts) >= 3:
-            def to_game(p: dict) -> tuple[int, int]:
-                x = p.get("x", 0) * MAP_WIDTH / 100.0
-                y = p.get("y", 0) * MAP_HEIGHT / 100.0
-                return (max(0, min(MAP_WIDTH - 1, int(round(x)))), max(0, min(MAP_HEIGHT - 1, int(round(y)))))
             chosen = random.sample(starts, 2)
-            return to_game(chosen[0]), to_game(chosen[1])
+            s1, s2 = chosen[0], chosen[1]
+            start1 = _to_game_coords(s1.get("x", 0), s1.get("y", 0))
+            start2 = _to_game_coords(s2.get("x", 0), s2.get("y", 0))
+            res1 = _resources_from_start_entry(s1) if "minerals" in s1 else []
+            res2 = _resources_from_start_entry(s2) if "minerals" in s2 else []
+            return (start1, res1, start2, res2)
         if len(starts) >= 2:
-            def to_game(p: dict) -> tuple[int, int]:
-                x = p.get("x", 0) * MAP_WIDTH / 100.0
-                y = p.get("y", 0) * MAP_HEIGHT / 100.0
-                return (max(0, min(MAP_WIDTH - 1, int(round(x)))), max(0, min(MAP_HEIGHT - 1, int(round(y)))))
-            return to_game(starts[0]), to_game(starts[1])
+            s1, s2 = starts[0], starts[1]
+            start1 = _to_game_coords(s1.get("x", 0), s1.get("y", 0))
+            start2 = _to_game_coords(s2.get("x", 0), s2.get("y", 0))
+            res1 = _resources_from_start_entry(s1) if "minerals" in s1 else []
+            res2 = _resources_from_start_entry(s2) if "minerals" in s2 else []
+            return (start1, res1, start2, res2)
     except (OSError, json.JSONDecodeError, KeyError):
         pass
-    return PLAYER1_START, PLAYER2_START
+    return _fallback_from_nav()
+
+
+def _pick_nav_corners(coords: list[tuple[float, float]]) -> tuple[tuple[float, float], tuple[float, float]]:
+    """Pick the 2 most separated nav_points (opposing corners)."""
+    pa1 = min(coords, key=lambda p: p[0] + p[1])
+    pa2 = max(coords, key=lambda p: p[0] + p[1])
+    pb1 = min(coords, key=lambda p: p[0] - p[1])
+    pb2 = max(coords, key=lambda p: p[0] - p[1])
+    d_a = (pa2[0] - pa1[0]) ** 2 + (pa2[1] - pa1[1]) ** 2
+    d_b = (pb2[0] - pb1[0]) ** 2 + (pb2[1] - pb1[1]) ** 2
+    return (pa1, pa2) if d_a >= d_b else (pb1, pb2)
+
+
+def _pick_expansion_nav_positions(
+    coords: list[tuple[float, float]],
+    start_positions: list[tuple[float, float]],
+    count: int = 3,
+    min_dist_from_start: float = 12.0,
+) -> list[tuple[float, float]]:
+    """Pick expansion positions: closest nav_point to each pair midpoint, at least min_dist from any start."""
+    def dist2(a: tuple[float, float], b: tuple[float, float]) -> float:
+        return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
+
+    candidates: list[tuple[float, float]] = []
+    n = len(start_positions)
+    for i in range(n):
+        for j in range(i + 1, n):
+            mx = (start_positions[i][0] + start_positions[j][0]) / 2
+            my = (start_positions[i][1] + start_positions[j][1]) / 2
+            # Find closest nav_point to midpoint that is far enough from all starts
+            nearby = [
+                p for p in coords
+                if all(dist2(p, s) >= min_dist_from_start ** 2 for s in start_positions)
+            ]
+            if nearby:
+                best = min(nearby, key=lambda p: dist2(p, (mx, my)))
+                # Avoid duplicates
+                if all(dist2(best, c) > 4.0 for c in candidates):
+                    candidates.append(best)
+
+    return candidates[:count]
+
+
+def _fallback_all_resources(
+    coords: list[tuple[float, float]],
+) -> tuple[list[tuple[float, float]], list[tuple[float, float]], list[list[Resource]]]:
+    """Pick start and expansion positions from nav_points and generate resources at each.
+
+    Returns (start_positions, expansion_positions, all_resource_lists).
+    Resources are generated via _generate_resources_at for consistent fixed-distance placement.
+    """
+    s1_f, s2_f = _pick_nav_corners(coords)
+    def min_dist2(p: tuple[float, float]) -> float:
+        return min((p[0]-s1_f[0])**2+(p[1]-s1_f[1])**2, (p[0]-s2_f[0])**2+(p[1]-s2_f[1])**2)
+    s3_f = max(coords, key=min_dist2)
+
+    starts = [s1_f, s2_f, s3_f]
+    expansions = _pick_expansion_nav_positions(coords, starts, count=3)
+
+    all_resources: list[list[Resource]] = []
+    for pos in starts + expansions:
+        gx, gy = int(round(pos[0])), int(round(pos[1]))
+        all_resources.append(_generate_resources_at(gx, gy))
+
+    return starts, expansions, all_resources
+
+
+def _fallback_from_nav() -> tuple[
+    tuple[int, int], list[Resource], tuple[int, int], list[Resource]
+]:
+    """Pick 2 well-separated start positions from compiled nav_points and generate minerals near each."""
+    compiled_path = Path(__file__).resolve().parent.parent / "static" / "compiled_map.json"
+    if compiled_path.exists():
+        try:
+            with open(compiled_path, encoding="utf-8") as f:
+                data = json.load(f)
+            pts = data.get("nav_points") or []
+            if len(pts) >= 4:
+                coords = [(float(p[0]), float(p[1])) for p in pts]
+                s1_f, s2_f = _pick_nav_corners(coords)
+                res1 = _nav_minerals_around(s1_f, coords)
+                res2 = _nav_minerals_around(s2_f, coords)
+                return (s1_f, res1, s2_f, res2)
+        except (OSError, json.JSONDecodeError, KeyError, ValueError):
+            pass
+    # Last resort: use original hardcoded values (may be outside walkable area on this map)
+    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))
+    r2: list[Resource] = []
+    for x, y in _P2_MINERALS:
+        r2.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
+    for x, y in _P2_GEYSERS:
+        r2.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
+    return (
+        (float(PLAYER1_START[0]), float(PLAYER1_START[1])),
+        resources,
+        (float(PLAYER2_START[0]), float(PLAYER2_START[1])),
+        r2,
+    )
+
+
+def _nav_minerals_around(
+    center: tuple[float, float],
+    all_nav: list[tuple[float, float]],
+    mineral_count: int = 7,
+    geyser_count: int = 1,
+    mineral_radius: float = 6.0,
+    geyser_radius: float = 8.0,
+) -> list[Resource]:
+    """Generate minerals and geysers at nav_points near a start position."""
+    cx, cy = center
+    nearby = sorted(
+        [p for p in all_nav if p != center and (p[0]-cx)**2 + (p[1]-cy)**2 <= mineral_radius**2],
+        key=lambda p: (p[0]-cx)**2 + (p[1]-cy)**2,
+    )
+    resources: list[Resource] = []
+    for p in nearby[:mineral_count]:
+        resources.append(Resource(resource_type=ResourceType.MINERAL, x=int(round(p[0])), y=int(round(p[1]))))
+    geyser_nearby = sorted(
+        [p for p in all_nav if p != center and (p[0]-cx)**2 + (p[1]-cy)**2 <= geyser_radius**2],
+        key=lambda p: -((p[0]-cx)**2 + (p[1]-cy)**2),
+    )
+    for p in geyser_nearby[:geyser_count]:
+        resources.append(Resource(resource_type=ResourceType.GEYSER, x=int(round(p[0])), y=int(round(p[1]))))
+    return resources
 
 # Named map zones resolved to (x, y) center coordinates
 # Zone values depend on player — resolved at engine level using player start positions
@@ -99,35 +333,32 @@ class GameMap(BaseModel):
     resources: list[Resource] = Field(default_factory=list)
 
     @classmethod
-    def create_default(cls) -> "GameMap":
+    def create_default(cls, resources: list[Resource] | None = None) -> "GameMap":
+        """Create map with given resources, or load from file (legacy flat minerals/geysers), or use hardcoded fallback."""
+        if resources is not None:
+            return cls(resources=resources)
         path = _game_positions_path()
         if path:
             try:
                 with open(path, encoding="utf-8") as f:
                     data = json.load(f)
-                resources = []
+                # Legacy format: top-level minerals/geysers
+                flat_resources = []
                 for m in data.get("minerals") or []:
                     x, y = int(m.get("x", 0)), int(m.get("y", 0))
                     if 0 <= x < MAP_WIDTH and 0 <= y < MAP_HEIGHT:
-                        resources.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
+                        flat_resources.append(Resource(resource_type=ResourceType.MINERAL, x=x, y=y))
                 for g in data.get("geysers") or []:
                     x, y = int(g.get("x", 0)), int(g.get("y", 0))
                     if 0 <= x < MAP_WIDTH and 0 <= y < MAP_HEIGHT:
-                        resources.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
-                if resources:
-                    return cls(resources=resources)
+                        flat_resources.append(Resource(resource_type=ResourceType.GEYSER, x=x, y=y))
+                if flat_resources:
+                    return cls(resources=flat_resources)
             except (OSError, json.JSONDecodeError, KeyError):
                 pass
-        resources = []
-        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)
+        # Use nav-based fallback which derives positions from the actual compiled map
+        _, r1, _, r2 = _fallback_from_nav()
+        return cls(resources=r1 + r2)
 
     def get_resource(self, resource_id: str) -> Resource | None:
         return next((r for r in self.resources if r.id == resource_id), None)

backend/game/map_compiler.py

@@ -0,0 +1,157 @@
+"""
+Compile walkable polygons into a single figure: one exterior boundary + holes (internal non-walkable zones).
+Produces compiled_map.json used by pathfinding for walkable test and optional nav points.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+def _signed_area(polygon: list[tuple[float, float]]) -> float:
+    """Signed area (positive = CCW)."""
+    n = len(polygon)
+    if n < 3:
+        return 0.0
+    area = 0.0
+    for i in range(n):
+        j = (i + 1) % n
+        area += polygon[i][0] * polygon[j][1]
+        area -= polygon[j][0] * polygon[i][1]
+    return area / 2.0
+
+
+def _centroid(polygon: list[tuple[float, float]]) -> tuple[float, float]:
+    n = len(polygon)
+    if n == 0:
+        return (0.0, 0.0)
+    cx = sum(p[0] for p in polygon) / n
+    cy = sum(p[1] for p in polygon) / n
+    return (cx, cy)
+
+
+def _point_in_polygon(x: float, y: float, polygon: list[tuple[float, float]]) -> bool:
+    n = len(polygon)
+    inside = False
+    j = n - 1
+    for i in range(n):
+        xi, yi = polygon[i]
+        xj, yj = polygon[j]
+        if ((yi > y) != (yj > y)) and (x < (xj - xi) * (y - yi) / (yj - yi) + xi):
+            inside = not inside
+        j = i
+    return inside
+
+
+def compile_walkable(
+    polygons: list[list[tuple[float, float]]],
+) -> tuple[list[tuple[float, float]], list[list[tuple[float, float]]]]:
+    """
+    From a list of polygons (each list of (x,y) in 0-100 space),
+    return (exterior, holes).
+    Exterior = polygon with largest absolute area.
+    Holes = polygons whose centroid is inside the exterior.
+    """
+    if not polygons:
+        return ([], [])
+
+    # Filter to valid polygons
+    valid = [p for p in polygons if len(p) >= 3]
+    if not valid:
+        return ([], [])
+
+    # Exterior = largest area
+    by_area = [(abs(_signed_area(p)), p) for p in valid]
+    by_area.sort(key=lambda x: -x[0])
+    exterior = by_area[0][1]
+    others = [p for _, p in by_area[1:]]
+
+    holes: list[list[tuple[float, float]]] = []
+    for poly in others:
+        cx, cy = _centroid(poly)
+        if _point_in_polygon(cx, cy, exterior):
+            holes.append(poly)
+
+    return (exterior, holes)
+
+
+def build_nav_points(
+    polygons: list[list[tuple[float, float]]],
+    scale_x: float,
+    scale_y: float,
+    step: float = 2.0,
+) -> list[list[float]]:
+    """
+    Generate navigation points (in game coordinates) for ALL walkable polygons.
+    Used for pathfinding graph: units can path between these points.
+    """
+    if not polygons:
+        return []
+
+    all_xs = [p[0] for poly in polygons for p in poly]
+    all_ys = [p[1] for poly in polygons for p in poly]
+    min_x, max_x = min(all_xs), max(all_xs)
+    min_y, max_y = min(all_ys), max(all_ys)
+
+    def is_walkable_100(x: float, y: float) -> bool:
+        return any(_point_in_polygon(x, y, poly) for poly in polygons)
+
+    points: list[list[float]] = []
+    x = min_x
+    while x <= max_x:
+        y = min_y
+        while y <= max_y:
+            if is_walkable_100(x, y):
+                points.append([x * scale_x / 100.0, y * scale_y / 100.0])
+            y += step
+        x += step
+    return points
+
+
+def run_compiler(
+    walkable_path: Path,
+    output_path: Path,
+    map_width: float = 80.0,
+    map_height: float = 80.0,
+    nav_step: float = 2.0,
+) -> None:
+    """Load walkable.json, compile to exterior + holes, write compiled_map.json."""
+    scale_x = map_width / 100.0
+    scale_y = map_height / 100.0
+
+    if not walkable_path.exists():
+        raise FileNotFoundError(f"Walkable file not found: {walkable_path}")
+
+    with open(walkable_path, encoding="utf-8") as f:
+        data = json.load(f)
+
+    raw = data.get("polygons", [])
+    if not raw and data.get("polygon"):
+        raw = [data["polygon"]]
+
+    polygons: list[list[tuple[float, float]]] = []
+    for poly in raw:
+        if len(poly) < 3:
+            continue
+        polygons.append([(float(p[0]), float(p[1])) for p in poly])
+
+    exterior, holes = compile_walkable(polygons)
+
+    nav_points_game = build_nav_points(polygons, map_width, map_height, step=nav_step)
+
+    out = {
+        "exterior": [[round(x, 4), round(y, 4)] for x, y in exterior],
+        "holes": [[[round(x, 4), round(y, 4)] for x, y in h] for h in holes],
+        "nav_points": [[round(x, 4), round(y, 4)] for x, y in nav_points_game],
+    }
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(out, f, indent=2)
+
+
+if __name__ == "__main__":
+    static_dir = Path(__file__).resolve().parent.parent / "static"
+    run_compiler(
+        static_dir / "walkable.json",
+        static_dir / "compiled_map.json",
+    )

backend/game/pathfinding.py

@@ -1,28 +1,150 @@
 """
-Pathfinding constrained to walkable polygons (walkable.json).
-Coordinates: walkable.json uses 0-100 space; game uses 0-MAP_WIDTH, 0-MAP_HEIGHT.
+Pathfinding constrained to walkable area: one exterior polygon + holes (compiled_map.json),
+or fallback to walkable.json polygons. Supports dynamic obstacles (building footprints).
+Coordinates: sources use 0-100; game uses 0-MAP_WIDTH, 0-MAP_HEIGHT.
 """
 
 from __future__ import annotations
 
 import heapq
 import json
+import math
 from pathlib import Path
 from typing import Optional
 
 from .map import MAP_HEIGHT, MAP_WIDTH
 
-# Walkable data is in 0-100; game is 0-40
-WALKABLE_SCALE = 0.01  # 100 -> 1.0, then we scale by MAP_WIDTH/MAP_HEIGHT
-# So game_x = raw_x * (MAP_WIDTH / 100) = raw_x * 0.4
 SCALE_X = MAP_WIDTH / 100.0
 SCALE_Y = MAP_HEIGHT / 100.0
 
 _GRID_STEP = 0.5
 _GRID_W = int(MAP_WIDTH / _GRID_STEP) + 1
 _GRID_H = int(MAP_HEIGHT / _GRID_STEP) + 1
+
+# Compiled map: (exterior_scaled, holes_scaled) in game coords, or None
+_compiled_cache: Optional[tuple[list[tuple[float, float]], list[list[tuple[float, float]]]]] = None
+# Legacy: list of polygons in game coords (when no compiled map)
 _polygons_cache: Optional[list[list[tuple[float, float]]]] = None
 
+# Nav graph: (points_list, adjacency_dict). points_list[i] = (x, y) in game coords; adjacency[i] = [(j, cost), ...]
+_nav_graph_cache: Optional[tuple[list[tuple[float, float]], dict[int, list[tuple[int, float]]]]] = None
+# step=2.0 → cardinal dist=2.0, diagonal dist≈2.83; use 2.9 to include diagonals
+_NAV_CONNECT_RADIUS = 2.9
+# Clearance margin around buildings when filtering nav points (should match UNIT_RADIUS in engine)
+_NAV_BUILDING_MARGIN = 0.6
+
+
+def _load_compiled() -> Optional[tuple[list[tuple[float, float]], list[list[tuple[float, float]]]]]:
+    global _compiled_cache
+    if _compiled_cache is not None:
+        return _compiled_cache
+    path = Path(__file__).resolve().parent.parent / "static" / "compiled_map.json"
+    if not path.exists():
+        return None
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return None
+    exterior_raw = data.get("exterior", [])
+    holes_raw = data.get("holes", [])
+    if len(exterior_raw) < 3:
+        return None
+    exterior = [(float(p[0]) * SCALE_X, float(p[1]) * SCALE_Y) for p in exterior_raw]
+    holes = [
+        [(float(p[0]) * SCALE_X, float(p[1]) * SCALE_Y) for p in h]
+        for h in holes_raw if len(h) >= 3
+    ]
+    _compiled_cache = (exterior, holes)
+    return _compiled_cache
+
+
+def _load_nav_graph() -> Optional[tuple[list[tuple[float, float]], dict[int, list[tuple[int, float]]]]]:
+    """Load nav_points from compiled_map.json (game coords) and build adjacency graph. Returns (points, adj) or None."""
+    global _nav_graph_cache
+    if _nav_graph_cache is not None:
+        return _nav_graph_cache
+    path = Path(__file__).resolve().parent.parent / "static" / "compiled_map.json"
+    if not path.exists():
+        return None
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return None
+    raw = data.get("nav_points", [])
+    if len(raw) < 2:
+        return None
+    points: list[tuple[float, float]] = [(float(p[0]), float(p[1])) for p in raw]
+    adj: dict[int, list[tuple[int, float]]] = {i: [] for i in range(len(points))}
+    for i in range(len(points)):
+        xi, yi = points[i]
+        for j in range(i + 1, len(points)):
+            xj, yj = points[j]
+            d = ((xj - xi) ** 2 + (yj - yi) ** 2) ** 0.5
+            if d <= _NAV_CONNECT_RADIUS and d > 0:
+                adj[i].append((j, d))
+                adj[j].append((i, d))
+    _nav_graph_cache = (points, adj)
+    return _nav_graph_cache
+
+
+def _nav_point_blocked(
+    x: float,
+    y: float,
+    blocked_rects: list[tuple[float, float, float, float]],
+) -> bool:
+    """True if nav point (x, y) is inside or too close to any building rect."""
+    for rx, ry, w, h in blocked_rects:
+        cx = max(rx, min(rx + w, x))
+        cy = max(ry, min(ry + h, y))
+        if math.hypot(x - cx, y - cy) < _NAV_BUILDING_MARGIN:
+            return True
+    return False
+
+
+def _nav_valid_set(
+    points: list[tuple[float, float]],
+    blocked_rects: Optional[list[tuple[float, float, float, float]]],
+) -> Optional[set[int]]:
+    """Return set of nav point indices not blocked by buildings, or None if no filtering needed."""
+    if not blocked_rects:
+        return None  # all valid
+    return {
+        i for i, (px, py) in enumerate(points)
+        if not _nav_point_blocked(px, py, blocked_rects)
+    }
+
+
+def _nearest_nav_index(
+    x: float,
+    y: float,
+    points: list[tuple[float, float]],
+    valid: Optional[set[int]] = None,
+) -> int:
+    """Return index of nav point closest to (x, y), restricted to valid set if given."""
+    best_i = -1
+    best_d = float("inf")
+    for i in range(len(points)):
+        if valid is not None and i not in valid:
+            continue
+        px, py = points[i]
+        d = (px - x) ** 2 + (py - y) ** 2
+        if d < best_d:
+            best_d = d
+            best_i = i
+    if best_i == -1:
+        # fallback: ignore valid constraint
+        best_i = 0
+        best_d = (points[0][0] - x) ** 2 + (points[0][1] - y) ** 2
+        for i in range(1, len(points)):
+            px, py = points[i]
+            d = (px - x) ** 2 + (py - y) ** 2
+            if d < best_d:
+                best_d = d
+                best_i = i
+    return best_i
+
 
 def _load_polygons() -> list[list[tuple[float, float]]]:
     global _polygons_cache
@@ -63,8 +185,12 @@ def _point_in_polygon(x: float, y: float, polygon: list[tuple[float, float]]) ->
     return inside
 
 
-def is_walkable(x: float, y: float) -> bool:
-    """True if (x, y) is inside any walkable polygon. Uses game coordinates 0..MAP_WIDTH, 0..MAP_HEIGHT."""
+def _point_in_rect(x: float, y: float, rx: float, ry: float, w: float, h: float) -> bool:
+    return rx <= x < rx + w and ry <= y < ry + h
+
+
+def _static_walkable(x: float, y: float) -> bool:
+    """True if (x,y) is in any walkable polygon (all polygons from walkable.json)."""
     if x < 0 or x > MAP_WIDTH or y < 0 or y > MAP_HEIGHT:
         return False
     polygons = _load_polygons()
@@ -76,6 +202,25 @@ def is_walkable(x: float, y: float) -> bool:
     return False
 
 
+def is_walkable(
+    x: float,
+    y: float,
+    *,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> bool:
+    """
+    True if (x, y) is walkable (inside exterior, not in holes, not in any blocked rect).
+    blocked_rects: optional list of (x, y, width, height) in game coordinates (e.g. building footprints).
+    """
+    if not _static_walkable(x, y):
+        return False
+    if blocked_rects:
+        for rx, ry, w, h in blocked_rects:
+            if _point_in_rect(x, y, rx, ry, w, h):
+                return False
+    return True
+
+
 def _cell_center(ci: int, cj: int) -> tuple[float, float]:
     return (ci * _GRID_STEP, cj * _GRID_STEP)
 
@@ -88,35 +233,126 @@ def _to_cell(x: float, y: float) -> tuple[int, int]:
     return (ci, cj)
 
 
-def _cell_walkable(ci: int, cj: int) -> bool:
+def _cell_walkable(
+    ci: int,
+    cj: int,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> bool:
     cx, cy = _cell_center(ci, cj)
-    return is_walkable(cx, cy)
+    return is_walkable(cx, cy, blocked_rects=blocked_rects)
 
 
-def _neighbors(ci: int, cj: int) -> list[tuple[int, int, float]]:
+def _neighbors(
+    ci: int,
+    cj: int,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> list[tuple[int, int, float]]:
     out: list[tuple[int, int, float]] = []
     for di in (-1, 0, 1):
         for dj in (-1, 0, 1):
             if di == 0 and dj == 0:
                 continue
             ni, nj = ci + di, cj + dj
-            if 0 <= ni < _GRID_W and 0 <= nj < _GRID_H and _cell_walkable(ni, nj):
+            if 0 <= ni < _GRID_W and 0 <= nj < _GRID_H and _cell_walkable(ni, nj, blocked_rects):
                 cost = 1.414 if di != 0 and dj != 0 else 1.0
                 out.append((ni, nj, cost))
     return out
 
 
+def _find_path_navgraph(
+    sx: float, sy: float, tx: float, ty: float,
+    points: list[tuple[float, float]],
+    adj: dict[int, list[tuple[int, float]]],
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> Optional[list[tuple[float, float]]]:
+    """A* on nav graph, skipping points inside buildings. Returns waypoints or None."""
+    if not points or not adj:
+        return None
+
+    valid = _nav_valid_set(points, blocked_rects)
+    start_i = _nearest_nav_index(sx, sy, points, valid)
+    end_i = _nearest_nav_index(tx, ty, points, valid)
+    if start_i == end_i:
+        return [(tx, ty)]
+
+    def heuristic(i: int) -> float:
+        px, py = points[i]
+        return ((tx - px) ** 2 + (ty - py) ** 2) ** 0.5
+
+    counter = 0
+    best_g: dict[int, float] = {start_i: 0.0}
+    came_from: dict[int, Optional[int]] = {start_i: None}
+    open_set: list[tuple[float, int, int]] = []
+    heapq.heappush(open_set, (heuristic(start_i), counter, start_i))
+    counter += 1
+
+    while open_set:
+        f, _, node_i = heapq.heappop(open_set)
+        g = best_g.get(node_i, float("inf"))
+        if f > g + heuristic(node_i) + 1e-9:
+            continue  # stale entry
+        if node_i == end_i:
+            # Reconstruct
+            path_indices: list[int] = []
+            cur: Optional[int] = node_i
+            while cur is not None:
+                path_indices.append(cur)
+                cur = came_from[cur]
+            path_indices.reverse()
+            result = [points[i] for i in path_indices]
+            if result:
+                result[-1] = (tx, ty)
+            else:
+                result = [(tx, ty)]
+            return result
+        for j, cost in adj.get(node_i, []):
+            if valid is not None and j not in valid:
+                continue
+            new_g = g + cost
+            if new_g < best_g.get(j, float("inf")):
+                best_g[j] = new_g
+                came_from[j] = node_i
+                heapq.heappush(open_set, (new_g + heuristic(j), counter, j))
+                counter += 1
+    return None
+
+
 def find_path(
-    sx: float, sy: float, tx: float, ty: float
+    sx: float,
+    sy: float,
+    tx: float,
+    ty: float,
+    *,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
 ) -> Optional[list[tuple[float, float]]]:
     """
     A* path from (sx,sy) to (tx,ty) in game coordinates.
+    Uses nav-point graph when available and no dynamic obstacles; else grid A*.
+    blocked_rects: optional list of (x, y, width, height) to avoid (e.g. buildings).
     Returns list of waypoints (including end), or None if no path.
-    Returns [] if start/end not walkable or start==end.
     """
+    nav = _load_nav_graph()
+    if nav is not None:
+        points, adj = nav
+        path = _find_path_navgraph(sx, sy, tx, ty, points, adj, blocked_rects=blocked_rects)
+        if path is not None:
+            return path
+
+    return _find_path_grid(sx, sy, tx, ty, blocked_rects=blocked_rects)
+
+
+def _find_path_grid(
+    sx: float,
+    sy: float,
+    tx: float,
+    ty: float,
+    *,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> Optional[list[tuple[float, float]]]:
+    """Grid A* path (used when nav graph unavailable or blocked_rects present)."""
     si, sj = _to_cell(sx, sy)
     ti, tj = _to_cell(tx, ty)
-    if not _cell_walkable(si, sj) or not _cell_walkable(ti, tj):
+    if not _cell_walkable(si, sj, blocked_rects) or not _cell_walkable(ti, tj, blocked_rects):
         return None
     if si == ti and sj == tj:
         return [(tx, ty)]
@@ -124,59 +360,85 @@ def find_path(
     def heuristic(i: int, j: int) -> float:
         return ((ti - i) ** 2 + (tj - j) ** 2) ** 0.5
 
-    # (f, counter, (ci, cj), path)
     counter = 0
-    open_set: list[tuple[float, int, int, int, list[tuple[int, int]]]] = []
-    heapq.heappush(
-        open_set,
-        (heuristic(si, sj), counter, si, sj, [(si, sj)])
-    )
+    # Heap entries: (f, counter, ci, cj, g, parent_cell_or_None)
+    open_set: list[tuple[float, int, int, int, float, Optional[tuple[int, int]]]] = []
+    heapq.heappush(open_set, (heuristic(si, sj), counter, si, sj, 0.0, None))
     counter += 1
-    closed: set[tuple[int, int]] = set()
+    # best g seen per cell; also acts as closed set when set to a finite value
+    best_g: dict[tuple[int, int], float] = {(si, sj): 0.0}
+    came_from: dict[tuple[int, int], Optional[tuple[int, int]]] = {(si, sj): None}
 
     while open_set:
-        _, _, ci, cj, path = heapq.heappop(open_set)
-        if (ci, cj) in closed:
-            continue
-        closed.add((ci, cj))
+        f, _, ci, cj, g, _ = heapq.heappop(open_set)
+        if g > best_g.get((ci, cj), float("inf")):
+            continue  # stale entry
         if ci == ti and cj == tj:
-            # path = [start_cell, ..., end_cell]; waypoints from first step to end
-            waypoints = [_cell_center(i, j) for i, j in path[1:]]
+            # Reconstruct path
+            cells: list[tuple[int, int]] = []
+            cur: Optional[tuple[int, int]] = (ci, cj)
+            while cur is not None:
+                cells.append(cur)
+                cur = came_from[cur]
+            cells.reverse()
+            waypoints = [_cell_center(i, j) for i, j in cells[1:]]
             if waypoints:
                 waypoints[-1] = (tx, ty)
             else:
                 waypoints = [(tx, ty)]
             return waypoints
-        for ni, nj, cost in _neighbors(ci, cj):
-            if (ni, nj) in closed:
-                continue
-            new_path = path + [(ni, nj)]
-            g = sum(
-                (new_path[k+1][0] - new_path[k][0]) ** 2 + (new_path[k+1][1] - new_path[k][1]) ** 2
-                for k in range(len(new_path) - 1)
-            ) ** 0.5
-            f = g + heuristic(ni, nj)
-            heapq.heappush(open_set, (f, counter, ni, nj, new_path))
-            counter += 1
+        for ni, nj, cost in _neighbors(ci, cj, blocked_rects):
+            new_g = g + cost
+            if new_g < best_g.get((ni, nj), float("inf")):
+                best_g[(ni, nj)] = new_g
+                came_from[(ni, nj)] = (ci, cj)
+                f_new = new_g + heuristic(ni, nj)
+                heapq.heappush(open_set, (f_new, counter, ni, nj, new_g, (ci, cj)))
+                counter += 1
     return None
 
 
-def snap_to_walkable(x: float, y: float) -> tuple[float, float]:
-    """Return nearest walkable point to (x,y). If (x,y) is walkable, return it."""
-    if is_walkable(x, y):
+def nearest_walkable_navpoint(
+    x: float,
+    y: float,
+    *,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> tuple[float, float]:
+    """Return the nearest nav point that is walkable (not inside any building).
+    Falls back to snap_to_walkable if no nav graph available."""
+    nav = _load_nav_graph()
+    if nav is not None:
+        points, _ = nav
+        valid = _nav_valid_set(points, blocked_rects)
+        best_i = _nearest_nav_index(x, y, points, valid)
+        if best_i >= 0:
+            return points[best_i]
+    return snap_to_walkable(x, y, blocked_rects=blocked_rects)
+
+
+def snap_to_walkable(
+    x: float,
+    y: float,
+    *,
+    blocked_rects: Optional[list[tuple[float, float, float, float]]] = None,
+) -> tuple[float, float]:
+    """Return nearest walkable point to (x,y)."""
+    if is_walkable(x, y, blocked_rects=blocked_rects):
         return (x, y)
     best = (x, y)
     best_d = 1e9
-    for radius in [0.5, 1.0, 1.5, 2.0]:
-        for dx in [-radius, 0, radius]:
-            for dy in [-radius, 0, radius]:
-                if dx == 0 and dy == 0 and radius != 0:
+    for radius in [0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 5.0]:
+        for dx in [-radius, -radius * 0.5, 0, radius * 0.5, radius]:
+            for dy in [-radius, -radius * 0.5, 0, radius * 0.5, radius]:
+                if dx == 0 and dy == 0:
                     continue
                 nx = max(0, min(MAP_WIDTH, x + dx))
                 ny = max(0, min(MAP_HEIGHT, y + dy))
-                if is_walkable(nx, ny):
+                if is_walkable(nx, ny, blocked_rects=blocked_rects):
                     d = (nx - x) ** 2 + (ny - y) ** 2
                     if d < best_d:
                         best_d = d
                         best = (nx, ny)
+        if best_d < 1e9:
+            break
     return best

backend/game/state.py

@@ -6,7 +6,8 @@ from typing import Optional
 from pydantic import BaseModel, Field
 
 from .buildings import Building, BuildingStatus, BuildingType, BUILDING_DEFS
-from .map import GameMap, get_start_positions
+from .map import GameMap, get_start_data, get_all_map_resources
+from .pathfinding import snap_to_walkable
 from .units import Unit, UnitType, UNIT_DEFS, UnitStatus
 
 
@@ -68,7 +69,7 @@ class PlayerState(BaseModel):
             None,
         )
 
-    def summary(self) -> str:
+    def summary(self, lang: str = "fr") -> str:
         active = [
             b.building_type.value for b in self.buildings.values()
             if b.status not in (BuildingStatus.CONSTRUCTING, BuildingStatus.DESTROYED)
@@ -82,14 +83,21 @@ class PlayerState(BaseModel):
         for u in self.units.values():
             counts[u.unit_type.value] = counts.get(u.unit_type.value, 0) + 1
 
+        if (lang or "fr").lower() == "en":
+            minerals_l, gas_l, supply_l = "Minerals", "Gas", "Supply"
+            buildings_l, constructing_l, units_l, none_l = "Active buildings", "Under construction", "Units", "none"
+        else:
+            minerals_l, gas_l, supply_l = "Minéraux", "Gaz", "Supply"
+            buildings_l, constructing_l, units_l, none_l = "Bâtiments actifs", "En construction", "Unités", "aucun"
+
         lines = [
-            f"Minéraux: {self.minerals}, Gaz: {self.gas}, Supply: {self.supply_used}/{self.supply_max}",
-            f"Bâtiments actifs: {', '.join(active) or 'aucun'}",
+            f"{minerals_l}: {self.minerals}, {gas_l}: {self.gas}, {supply_l}: {self.supply_used}/{self.supply_max}",
+            f"{buildings_l}: {', '.join(active) or none_l}",
         ]
         if constructing:
-            lines.append(f"En construction: {', '.join(constructing)}")
+            lines.append(f"{constructing_l}: {', '.join(constructing)}")
         if counts:
-            lines.append(f"Unités: {', '.join(f'{v} {k}' for k, v in counts.items())}")
+            lines.append(f"{units_l}: {', '.join(f'{v} {k}' for k, v in counts.items())}")
         return "\n".join(lines)
 
 
@@ -115,29 +123,38 @@ class GameState(BaseModel):
         p1 = PlayerState(player_id=player1_id, player_name=player1_name)
         p2 = PlayerState(player_id=player2_id, player_name=player2_name)
 
-        start1, start2 = get_start_positions()
+        start1, _, start2, _ = get_start_data()
+        state.game_map = GameMap.create_default(resources=get_all_map_resources())
 
-        # Starting Command Centers (already built)
-        cc1 = Building.create(BuildingType.COMMAND_CENTER, player1_id, *start1)
+        # Starting Command Centers (already built); x,y is center of building footprint
+        cc1 = Building.create(BuildingType.COMMAND_CENTER, player1_id, float(start1[0]), float(start1[1]))
         cc1.status = BuildingStatus.ACTIVE
         cc1.construction_ticks_remaining = 0
+        cc1.hp = float(cc1.max_hp)
         p1.buildings[cc1.id] = cc1
 
-        cc2 = Building.create(BuildingType.COMMAND_CENTER, player2_id, *start2)
+        cc2 = Building.create(BuildingType.COMMAND_CENTER, player2_id, float(start2[0]), float(start2[1]))
         cc2.status = BuildingStatus.ACTIVE
         cc2.construction_ticks_remaining = 0
+        cc2.hp = float(cc2.max_hp)
         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,
-                               start1[0] + 1 + i * 0.8,
-                               start1[1] + 4)
+        # 5 starting SCVs per player, spread in x around CC; snap each to nearest walkable point
+        _MAP_W = 80.0
+        _MAP_H = 80.0
+        # Spacing must be > 2*UNIT_RADIUS (1.0) to avoid collision-blocking at spawn
+        _scv_offsets = [(-2.4, 3), (-1.2, 3), (0.0, 3), (1.2, 3), (2.4, 3)]
+        for i, (ox, oy) in enumerate(_scv_offsets):
+            raw1x = max(0.5, min(_MAP_W - 0.5, start1[0] + ox))
+            raw1y = max(0.5, min(_MAP_H - 0.5, start1[1] + oy))
+            sx1, sy1 = snap_to_walkable(raw1x, raw1y)
+            scv1 = Unit.create(UnitType.SCV, player1_id, sx1, sy1)
             p1.units[scv1.id] = scv1
 
-            scv2 = Unit.create(UnitType.SCV, player2_id,
-                               start2[0] + 1 + i * 0.8,
-                               start2[1] - 1)
+            raw2x = max(0.5, min(_MAP_W - 0.5, start2[0] + ox))
+            raw2y = max(0.5, min(_MAP_H - 0.5, start2[1] - oy))
+            sx2, sy2 = snap_to_walkable(raw2x, raw2y)
+            scv2 = Unit.create(UnitType.SCV, player2_id, sx2, sy2)
             p2.units[scv2.id] = scv2
 
         p1.recalculate_supply()

backend/game/tech_tree.py

@@ -24,7 +24,7 @@ BUILDING_REQUIREMENTS: dict[BuildingType, list[BuildingType]] = {
     BuildingType.COMMAND_CENTER:   [],
     BuildingType.SUPPLY_DEPOT:     [],
     BuildingType.REFINERY:         [],
-    BuildingType.BARRACKS:         [],
+    BuildingType.BARRACKS:         [BuildingType.SUPPLY_DEPOT],
     BuildingType.ENGINEERING_BAY:  [BuildingType.BARRACKS],
     BuildingType.FACTORY:          [BuildingType.BARRACKS],
     BuildingType.ARMORY:           [BuildingType.FACTORY],

backend/game/units.py

@@ -22,6 +22,7 @@ class UnitStatus(str, Enum):
     ATTACKING = "attacking"
     MINING_MINERALS = "mining_minerals"
     MINING_GAS = "mining_gas"
+    MOVING_TO_BUILD = "moving_to_build"
     BUILDING = "building"
     HEALING = "healing"
     SIEGED = "sieged"
@@ -74,17 +75,15 @@ UNIT_DEFS: dict[UnitType, UnitDef] = {
         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,
+        max_hp=150, armor=1, ground_damage=35, 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,
+        supply_cost=3, build_time_ticks=50,
         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,
+        supply_cost=2, build_time_ticks=60, is_flying=True,
         attack_cooldown_ticks=4,
     ),
 }
@@ -118,6 +117,7 @@ class Unit(BaseModel):
     building_target_id: Optional[str] = None
     harvest_carry: bool = False   # True while carrying resources back to CC
     harvest_amount: int = 0       # amount being carried (deposited on CC arrival)
+    stuck_ticks: int = 0          # consecutive ticks the unit couldn't move
 
     @classmethod
     def create(cls, unit_type: UnitType, owner: str, x: float, y: float) -> "Unit":

backend/lobby/manager.py

@@ -199,6 +199,17 @@ class LobbyManager:
     def get_room(self, room_id: str) -> Optional[Room]:
         return self._rooms.get(room_id)
 
+    def get_playing_count(self) -> int:
+        """Return number of rooms currently in 'playing' status."""
+        return sum(1 for r in self._rooms.values() if r.status == "playing")
+
+    def get_a_playing_room_id(self) -> Optional[str]:
+        """Return one room_id in 'playing' status for observe, or None."""
+        for room_id, room in self._rooms.items():
+            if room.status == "playing":
+                return room_id
+        return None
+
     def get_room_for_sid(self, sid: str) -> Optional[Room]:
         return self._get_room(sid)
 

backend/lobby/safe_name.py

@@ -0,0 +1,75 @@
+"""
+Validation du pseudo joueur via Mistral : détection d'insultes / noms inappropriés.
+Si le nom est jugé insultant, il est remplacé par un nom aléatoire inoffensif.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import random
+
+from config import MISTRAL_API_KEY, MISTRAL_CHAT_MODEL
+
+log = logging.getLogger(__name__)
+
+_FALLBACK_NAMES = [
+    "Player",
+    "Guest",
+    "Strategist",
+    "Commander",
+    "Pilot",
+    "Scout",
+    "Rookie",
+]
+
+_PROMPT = """Tu dois juger si un pseudo de joueur pour un jeu en ligne est insultant, vulgaire, discriminatoire ou inapproprié pour un public familial.
+
+Réponds UNIQUEMENT avec un JSON valide, sans texte avant ni après, avec exactement ces deux champs :
+- "is_insulting": true si le pseudo est inapproprié (insulte, gros mot, contenu choquant), false sinon.
+- "replacement": si is_insulting est true, un pseudo de remplacement court, sympa et inoffensif (ex: "Chevalier", "Pilote"); sinon la chaîne vide "".
+
+Pseudo à évaluer : "{name}"
+"""
+
+
+async def sanitize_player_name(name: str) -> str:
+    """
+    Vérifie le nom via Mistral. Si insultant, retourne un remplacement ; sinon retourne le nom tel quel.
+    En cas d'absence de clé API ou d'erreur, retourne le nom original.
+    """
+    name = (name or "").strip() or "Player"
+    if not MISTRAL_API_KEY:
+        return name
+
+    try:
+        from mistralai import Mistral
+
+        client = Mistral(api_key=MISTRAL_API_KEY)
+        response = await client.chat.complete_async(
+            model=MISTRAL_CHAT_MODEL,
+            messages=[{"role": "user", "content": _PROMPT.format(name=name)}],
+            response_format={"type": "json_object"},
+        )
+        content = response.choices[0].message.content
+        if isinstance(content, str):
+            raw = content.strip()
+        elif content:
+            first = content[0]
+            raw = (getattr(first, "text", None) or str(first)).strip()
+        else:
+            raw = ""
+        # Extraire un éventuel bloc JSON
+        if "```" in raw:
+            raw = raw.split("```")[1]
+            if raw.startswith("json"):
+                raw = raw[4:]
+        data = json.loads(raw)
+        if data.get("is_insulting") and data.get("replacement"):
+            replacement = str(data["replacement"]).strip() or random.choice(_FALLBACK_NAMES)
+            log.info("Safe name: %r replaced by %r", name, replacement)
+            return replacement[:50]
+        return name[:50]
+    except Exception as e:
+        log.warning("Safe name check failed for %r: %s", name, e)
+        return name[:50]

backend/main.py

@@ -11,6 +11,8 @@ Client → Server
   join_room     { room_id, name }
   quick_match   { name }
   player_ready  {}
+  get_playing_count  {}   — server responds with playing_count
+  observe       {}       — server responds with observe_room or error
   voice_input   { audio_b64, mime_type? }
   text_input    { text }
   disconnect    (automatic)
@@ -25,6 +27,8 @@ Server → Client
   voice_result  { transcription, feedback_text, feedback_audio_b64, results }
   game_over     { winner_id, winner_name }
   error         { message }
+  playing_count { count }     — in response to get_playing_count
+  observe_room  { room_id }   — in response to observe (spectator)
 """
 
 from __future__ import annotations
@@ -33,13 +37,14 @@ import asyncio
 import base64
 import logging
 import os
+import re
 import subprocess
 import sys
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 import socketio
-from fastapi import Body, FastAPI, HTTPException
+from fastapi import APIRouter, Body, FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
@@ -48,6 +53,7 @@ from game.bot import BOT_PLAYER_ID, BotPlayer
 from game.engine import GameEngine
 from game.state import GameState
 from lobby.manager import LobbyManager
+from lobby.safe_name import sanitize_player_name
 from voice import command_parser, stt
 
 BOT_OFFER_DELAY = 10  # seconds before offering bot opponent
@@ -55,6 +61,35 @@ BOT_OFFER_DELAY = 10  # seconds before offering bot opponent
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger(__name__)
 
+
+def _fill_template(template: str, data: dict[str, Any]) -> str:
+    """Fill placeholders {key} in template with data; missing keys become empty string."""
+    placeholders = re.findall(r"\{(\w+)\}", template)
+    safe = {k: str(data.get(k, "")) for k in placeholders}
+    try:
+        return template.format(**safe)
+    except KeyError:
+        return template
+
+
+def _compute_feedback_level(cmd_result) -> str:
+    """Derive ok/warning/error from command results."""
+    if cmd_result.feedback_override:
+        return "error"
+    results = cmd_result.results
+    if not results:
+        return "error"
+    successes = sum(1 for r in results if r.success)
+    if successes == 0:
+        return "error"
+    if successes < len(results):
+        return "warning"
+    # All succeeded — check if any result carries an error key
+    for r in results:
+        if r.data and "error" in r.data:
+            return "warning"
+    return "ok"
+
 # ---------------------------------------------------------------------------
 # Socket.IO + FastAPI setup
 # ---------------------------------------------------------------------------
@@ -76,6 +111,32 @@ fastapi_app.add_middleware(
     allow_headers=["*"],
 )
 
+# Paths for static assets (must serve before any catch-all mount)
+_STATIC_DIR = Path(__file__).parent / "static"
+_SPRITES_DIR = Path(__file__).parent / "static" / "sprites"
+
+_static_router = APIRouter()
+
+@_static_router.get("/static/MAP.png", response_class=FileResponse)
+def _serve_map_png():
+    p = _STATIC_DIR / "MAP.png"
+    if not p.is_file():
+        raise HTTPException(404, "MAP.png not found")
+    return FileResponse(p, media_type="image/png")
+
+@_static_router.get("/sprites/{kind}/{filename:path}", response_class=FileResponse)
+def _serve_sprite(kind: str, filename: str):
+    p = _SPRITES_DIR / kind / filename
+    if not p.is_file():
+        raise HTTPException(404, "Sprite not found")
+    return FileResponse(
+        p,
+        media_type="image/png",
+        headers={"Cache-Control": "no-store"},
+    )
+
+fastapi_app.include_router(_static_router)
+
 # Unit sound effects (generated by scripts/generate_unit_sounds.py)
 _SOUNDS_DIR = Path(__file__).parent / "static" / "sounds"
 _UNITS_SOUNDS_DIR = _SOUNDS_DIR / "units"
@@ -84,23 +145,32 @@ _UNITS_SOUNDS_DIR.mkdir(parents=True, exist_ok=True)
 fastapi_app.mount("/sounds", StaticFiles(directory=str(_SOUNDS_DIR)), name="sounds")
 
 # Sprites (unit/building icons generated via Mistral image API)
-_SPRITES_DIR = Path(__file__).parent / "static" / "sprites"
 _SPRITES_DIR.mkdir(parents=True, exist_ok=True)
 if _SPRITES_DIR.exists():
     fastapi_app.mount("/sprites", StaticFiles(directory=str(_SPRITES_DIR)), name="sprites")
 
-# Map image, map.json, walkable polygon
-_STATIC_DIR = Path(__file__).parent / "static"
+# Map image, map.json, walkable polygon (fallback for other static files)
 if _STATIC_DIR.exists():
     fastapi_app.mount("/static", StaticFiles(directory=str(_STATIC_DIR)), name="static")
 
 _MAP_JSON = _STATIC_DIR / "map.json"
 _WALKABLE_JSON = _STATIC_DIR / "walkable.json"
+_COMPILED_MAP_JSON = _STATIC_DIR / "compiled_map.json"
 _GAME_POSITIONS_JSON = _STATIC_DIR / "game_positions.json"
 
 # Game grid size (must match game/map.py)
-_MAP_GRID_W = 40
-_MAP_GRID_H = 40
+_MAP_GRID_W = 80
+_MAP_GRID_H = 80
+
+# Compile walkable → exterior + holes once at server startup
+if _WALKABLE_JSON.exists():
+    try:
+        from game.map import MAP_WIDTH as _MAP_W, MAP_HEIGHT as _MAP_H
+        from game.map_compiler import run_compiler
+        run_compiler(_WALKABLE_JSON, _COMPILED_MAP_JSON, map_width=_MAP_W, map_height=_MAP_H)
+        log.info("Map compiled: %s", _COMPILED_MAP_JSON)
+    except Exception as e:
+        log.warning("Map compiler skipped: %s", e)
 
 
 def _load_game_positions() -> dict:
@@ -238,12 +308,12 @@ def _generate_geysers_around(cx: int, cy: int, count: int = 1, radius: float = 4
 
 @fastapi_app.put("/api/map/positions")
 async def save_map_positions(body: dict = Body(...)):
-    """Enregistre positions de départ (exactement 3, 2 seront tirées au sort par partie) et expansions, génère minerais (et geysers) autour de chacune."""
+    """Enregistre positions de départ (2 ou 3, si 3 alors 2 seront tirées au sort par partie) et expansions."""
     import json
     starts = body.get("starting_positions")
     expansions = body.get("expansion_positions")
-    if not isinstance(starts, list) or len(starts) != 3:
-        raise HTTPException(400, "starting_positions requis (exactement 3 positions {x, y} en 0-100)")
+    if not isinstance(starts, list) or len(starts) < 2:
+        raise HTTPException(400, "starting_positions requis (au moins 2 positions {x, y} en 0-100)")
     if not isinstance(expansions, list):
         expansions = []
     for i, p in enumerate(starts):
@@ -259,27 +329,37 @@ async def save_map_positions(body: dict = Body(...)):
         if not (0 <= x <= 100 and 0 <= y <= 100):
             raise HTTPException(400, f"expansion_positions[{i}] hors [0,100]")
 
-    # Keep positions in 0-100 for admin display
-    starting_positions = [{"x": float(p["x"]), "y": float(p["y"])} for p in starts]
-    expansion_positions = [{"x": float(p["x"]), "y": float(p["y"])} for p in expansions]
-
-    minerals = []
-    geysers = []
-    for p in starting_positions + expansion_positions:
-        gx, gy = _admin_to_game_x(p["x"]), _admin_to_game_y(p["y"])
-        minerals.extend(_generate_minerals_around(gx, gy, count=7))
-        geysers.extend(_generate_geysers_around(gx, gy, count=1))
+    # Keep positions in 0-100 for admin display; embed minerals/geysers per start so we load only the 2 chosen bases' resources
+    starting_positions = []
+    total_minerals = 0
+    total_geysers = 0
+    for p in starts:
+        x, y = float(p["x"]), float(p["y"])
+        gx, gy = _admin_to_game_x(x), _admin_to_game_y(y)
+        minerals = _generate_minerals_around(gx, gy, count=7)
+        geysers = _generate_geysers_around(gx, gy, count=1)
+        total_minerals += len(minerals)
+        total_geysers += len(geysers)
+        starting_positions.append({"x": x, "y": y, "minerals": minerals, "geysers": geysers})
+
+    expansion_positions = []
+    for p in expansions:
+        x, y = float(p["x"]), float(p["y"])
+        gx, gy = _admin_to_game_x(x), _admin_to_game_y(y)
+        minerals = _generate_minerals_around(gx, gy, count=7)
+        geysers = _generate_geysers_around(gx, gy, count=1)
+        total_minerals += len(minerals)
+        total_geysers += len(geysers)
+        expansion_positions.append({"x": x, "y": y, "minerals": minerals, "geysers": geysers})
 
     payload = {
         "starting_positions": starting_positions,
         "expansion_positions": expansion_positions,
-        "minerals": minerals,
-        "geysers": geysers,
     }
     _STATIC_DIR.mkdir(parents=True, exist_ok=True)
     with open(_GAME_POSITIONS_JSON, "w", encoding="utf-8") as f:
         json.dump(payload, f, indent=2)
-    return {"status": "ok", "minerals_count": len(minerals), "geysers_count": len(geysers)}
+    return {"status": "ok", "minerals_count": total_minerals, "geysers_count": total_geysers}
 
 
 @fastapi_app.get("/api/sounds/units")
@@ -340,7 +420,7 @@ async def generate_sprites():
 
     def run():
         return subprocess.run(
-            [sys.executable, "-m", "scripts.generate_sprites"],
+            [sys.executable, "-m", "scripts.generate_sprites", "--skip-existing"],
             cwd=str(Path(__file__).parent),
             capture_output=True,
             text=True,
@@ -398,6 +478,49 @@ async def generate_one_building_sprite(building_id: str):
     return {"status": "ok", "id": building_id}
 
 
+@fastapi_app.get("/api/sprites/resources")
+async def list_resource_sprites():
+    """Liste les sprites de ressources présents."""
+    return {"sprites": _list_sprites(_SPRITES_DIR / "resources")}
+
+
+@fastapi_app.post("/api/sprites/generate/resources/{resource_id}")
+async def generate_one_resource_sprite(resource_id: str):
+    """Régénère une seule icône de ressource (mineral, geyser)."""
+    resource_id = resource_id.strip().lower()
+    valid = ["mineral", "geyser"]
+    if resource_id not in valid:
+        raise HTTPException(400, f"Resource invalide. Valides: {valid}")
+    loop = asyncio.get_event_loop()
+    result = await loop.run_in_executor(None, lambda: _run_sprite_script(["--resource", resource_id]))
+    if result.returncode != 0:
+        raise HTTPException(500, result.stderr or result.stdout or "Échec génération")
+    return {"status": "ok", "id": resource_id}
+
+
+_ICONS_DIR = _SPRITES_DIR / "icons"
+
+
+@fastapi_app.get("/api/icons")
+async def list_icons():
+    """Liste les icônes UI présentes."""
+    return {"icons": _list_sprites(_ICONS_DIR)}
+
+
+@fastapi_app.post("/api/icons/generate/{icon_id}")
+async def generate_one_icon(icon_id: str):
+    """Génère une icône UI symbolique (mineral, gas, supply)."""
+    icon_id = icon_id.strip().lower()
+    valid = ["mineral", "gas", "supply"]
+    if icon_id not in valid:
+        raise HTTPException(400, f"Icône invalide. Valides: {valid}")
+    loop = asyncio.get_event_loop()
+    result = await loop.run_in_executor(None, lambda: _run_sprite_script(["--icon", icon_id]))
+    if result.returncode != 0:
+        raise HTTPException(500, result.stderr or result.stdout or "Échec génération")
+    return {"status": "ok", "id": icon_id}
+
+
 # Serve SvelteKit static build if present (production / HF Spaces)
 _FRONTEND_BUILD = Path(__file__).parent.parent / "frontend" / "build"
 if _FRONTEND_BUILD.exists():
@@ -435,6 +558,28 @@ async def _emit_error(sid: str, message: str) -> None:
     await sio.emit("error", {"message": message}, to=sid)
 
 
+def _build_resource_zones(engine: Any, player_id: str) -> list[str]:
+    """Return sorted resource zone names (mineral_1…N, geyser_1…M) by proximity to player base."""
+    from game.map import ResourceType as _RT
+    player = engine.state.players.get(player_id)
+    cc = player.command_center() if player else None
+    base_x = float(cc.x) + 2 if cc else 40.0
+    base_y = float(cc.y) + 2 if cc else 40.0
+    resources = engine.state.game_map.resources
+
+    minerals = sorted(
+        [r for r in resources if r.resource_type == _RT.MINERAL and not r.is_depleted],
+        key=lambda r: (r.x - base_x) ** 2 + (r.y - base_y) ** 2,
+    )
+    geysers = sorted(
+        [r for r in resources if r.resource_type == _RT.GEYSER],
+        key=lambda r: (r.x - base_x) ** 2 + (r.y - base_y) ** 2,
+    )
+    zones = [f"mineral_{i + 1}" for i in range(len(minerals))]
+    zones += [f"geyser_{i + 1}" for i in range(len(geysers))]
+    return zones
+
+
 async def _start_game(room_id: str) -> None:
     """Create game state + engine, emit game_start to human players."""
     room = lobby.get_room(room_id)
@@ -540,9 +685,30 @@ async def disconnect(sid: str) -> None:
 # ---------------------------------------------------------------------------
 
 
+@sio.event
+async def get_playing_count(sid: str, data: dict) -> None:
+    count = lobby.get_playing_count()
+    await sio.emit("playing_count", {"count": count}, to=sid)
+
+
+@sio.event
+async def observe(sid: str, data: dict) -> None:
+    room_id = lobby.get_a_playing_room_id()
+    if not room_id:
+        await _emit_error(sid, "Aucune partie en cours à observer.")
+        return
+    await sio.enter_room(sid, room_id)
+    engine = engines.get(room_id)
+    payload = {"room_id": room_id}
+    if engine:
+        payload["game_state"] = engine.state.model_dump(mode="json")
+    await sio.emit("observe_room", payload, to=sid)
+
+
 @sio.event
 async def create_room(sid: str, data: dict) -> None:
     name = str(data.get("name", "Player")).strip() or "Player"
+    name = await sanitize_player_name(name)
     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)
@@ -556,6 +722,7 @@ async def create_room(sid: str, data: dict) -> None:
 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"
+    name = await sanitize_player_name(name)
 
     room, err = lobby.join_room(sid, room_id, name)
     if err:
@@ -576,6 +743,7 @@ async def join_room(sid: str, data: dict) -> None:
 @sio.event
 async def quick_match(sid: str, data: dict) -> None:
     name = str(data.get("name", "Player")).strip() or "Player"
+    name = await sanitize_player_name(name)
     room, is_new = lobby.quick_match(sid, name)
 
     if not is_new:
@@ -706,14 +874,15 @@ async def voice_input(sid: str, data: dict) -> None:
         await sio.emit("voice_result", {
             "transcription": "",
             "feedback_text": "Je n'ai rien entendu. Appuie et parle!",
-            "feedback_audio_b64": "",
+            "feedback_level": "warning",
             "results": [],
         }, to=sid)
         return
 
     # 2. Parse command with Mistral
+    resource_zones = _build_resource_zones(engine, sid)
     try:
-        parsed = await command_parser.parse(transcription, player)
+        parsed = await command_parser.parse(transcription, player, resource_zones=resource_zones)
     except Exception as exc:
         log.exception("Command parsing failed")
         await _emit_error(sid, f"Erreur d'interprétation: {exc}")
@@ -722,21 +891,20 @@ async def voice_input(sid: str, data: dict) -> None:
     # 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
-    )
-
-    # Replace/append actual engine results so failures are always heard
-    failures = [r.message for r in cmd_result.results if not r.success and r.message]
-    if failures:
-        feedback_text = " ".join(failures)
-
-    # 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
+    if cmd_result.feedback_override:
+        feedback_text = await command_parser.generate_feedback(
+            cmd_result.feedback_override, parsed.language
+        )
+    else:
+        merged: dict[str, Any] = {}
+        for r in cmd_result.results:
+            merged.update(r.data or {})
+        if "error" in merged:
+            feedback_text = await command_parser.generate_feedback(
+                merged["error"], parsed.language
+            )
+        else:
+            feedback_text = _fill_template(parsed.feedback_template, merged)
 
     sound_events = []
     for r in cmd_result.results:
@@ -744,6 +912,7 @@ async def voice_input(sid: str, data: dict) -> None:
     await sio.emit("voice_result", {
         "transcription": transcription,
         "feedback_text": feedback_text,
+        "feedback_level": _compute_feedback_level(cmd_result),
         "results": [r.model_dump() for r in cmd_result.results],
         "sound_events": sound_events,
     }, to=sid)
@@ -779,8 +948,9 @@ async def _process_text_command(sid: str, transcription: str) -> None:
         return
 
     # Parse command with Mistral
+    resource_zones = _build_resource_zones(engine, sid)
     try:
-        parsed = await command_parser.parse(transcription, player)
+        parsed = await command_parser.parse(transcription, player, resource_zones=resource_zones)
     except Exception as exc:
         log.exception("Command parsing failed")
         await _emit_error(sid, f"Erreur d'interprétation: {exc}")
@@ -789,19 +959,20 @@ async def _process_text_command(sid: str, transcription: str) -> None:
     # 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
-    )
-
-    failures = [r.message for r in cmd_result.results if not r.success and r.message]
-    if failures:
-        feedback_text = " ".join(failures)
-
-    for r in cmd_result.results:
-        if r.action_type == "query" and r.success:
-            feedback_text += "\n" + r.message
+    if cmd_result.feedback_override:
+        feedback_text = await command_parser.generate_feedback(
+            cmd_result.feedback_override, parsed.language
+        )
+    else:
+        merged = {}
+        for r in cmd_result.results:
+            merged.update(r.data or {})
+        if "error" in merged:
+            feedback_text = await command_parser.generate_feedback(
+                merged["error"], parsed.language
+            )
+        else:
+            feedback_text = _fill_template(parsed.feedback_template, merged)
 
     sound_events = []
     for r in cmd_result.results:
@@ -809,6 +980,7 @@ async def _process_text_command(sid: str, transcription: str) -> None:
     await sio.emit("voice_result", {
         "transcription": transcription,
         "feedback_text": feedback_text,
+        "feedback_level": _compute_feedback_level(cmd_result),
         "results": [r.model_dump() for r in cmd_result.results],
         "sound_events": sound_events,
     }, to=sid)

backend/requirements.txt

@@ -5,3 +5,5 @@ python-dotenv>=1.0.0
 pydantic>=2.0.0
 mistralai>=1.0.0
 httpx>=0.27.0
+google-genai>=1.0.0
+Pillow>=10.0.0

backend/scripts/generate_map_lod.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Génère des versions basse résolution de MAP.png pour le chargement progressif.
+
+  MAP_quarter.png  →  1/4 de la taille originale  (chargement rapide ~1-2 Mo)
+  MAP_half.png     →  1/2 de la taille originale  (qualité intermédiaire ~7 Mo)
+
+Usage :
+  cd backend && python -m scripts.generate_map_lod
+  cd backend && python -m scripts.generate_map_lod --input static/MAP.png
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from PIL import Image
+
+_backend = Path(__file__).resolve().parent.parent
+if str(_backend) not in sys.path:
+    sys.path.insert(0, str(_backend))
+
+
+def generate_lods(input_path: Path) -> None:
+    src = Image.open(input_path).convert("RGB")
+    w, h = src.size
+    size_mb = input_path.stat().st_size / 1024 / 1024
+    print(f"Source : {w}×{h}  ({size_mb:.1f} Mo)  →  {input_path}")
+
+    lods = [
+        ("MAP_half.png",    (w // 2, h // 2)),
+        ("MAP_quarter.png", (w // 4, h // 4)),
+    ]
+
+    for filename, size in lods:
+        out_path = input_path.parent / filename
+        resized = src.resize(size, Image.LANCZOS)
+        resized.save(out_path, format="PNG", optimize=True)
+        out_mb = out_path.stat().st_size / 1024 / 1024
+        print(f"  {filename:25s}  {size[0]}×{size[1]}  ({out_mb:.1f} Mo)  →  {out_path}")
+
+
+def main() -> None:
+    default = _backend / "static" / "MAP.png"
+    parser = argparse.ArgumentParser(description="Génère MAP_half.png et MAP_quarter.png")
+    parser.add_argument("--input", type=Path, default=default)
+    args = parser.parse_args()
+    if not args.input.is_file():
+        raise SystemExit(f"Fichier introuvable : {args.input}")
+    generate_lods(args.input)
+
+
+if __name__ == "__main__":
+    main()

backend/scripts/generate_sprites.py

@@ -1,14 +1,16 @@
 #!/usr/bin/env python3
 """
-Génère les sprites PNG (vues de dessus, transparent, style SF Starcraft/Warhammer)
-via l'API Mistral (agent avec outil image_generation).
-Chaque unité et bâtiment a un prompt détaillé pour un rendu homogène.
+Génère les sprites PNG (vues de dessus, style SF Starcraft/Warhammer).
+
+Backend au choix (priorité GCP si configuré) :
+- GCP Vertex AI Imagen : définir GCP_PROJECT_ID (et optionnellement GCP_LOCATION) dans .env
+- Mistral : définir MISTRAL_API_KEY dans .env
 
 Usage : cd backend && python -m scripts.generate_sprites
-Nécessite MISTRAL_API_KEY dans .env
 """
 from __future__ import annotations
 
+import os
 import sys
 from pathlib import Path
 
@@ -21,12 +23,10 @@ import random
 import time
 from typing import Any
 
-from mistralai import Mistral
-from mistralai.models import ToolFileChunk
-
-from config import MISTRAL_API_KEY
+from config import GCP_PROJECT_ID, GCP_LOCATION, MISTRAL_API_KEY
 from game.units import UnitType
 from game.buildings import BuildingType, BUILDING_DEFS
+from game.map import ResourceType
 
 logging.basicConfig(level=logging.INFO)
 log = logging.getLogger(__name__)
@@ -34,6 +34,18 @@ log = logging.getLogger(__name__)
 SPRITES_DIR = _backend / "static" / "sprites"
 UNITS_DIR = SPRITES_DIR / "units"
 BUILDINGS_DIR = SPRITES_DIR / "buildings"
+RESOURCES_DIR = SPRITES_DIR / "resources"
+ICONS_DIR = SPRITES_DIR / "icons"
+
+# Taille cible et fond transparent obligatoires
+TARGET_SIZE = 128
+
+# Chroma vert : fond #00ff00 demandé à l'API, détourage sur cette couleur uniquement
+CHROMA_GREEN_RGB = (0, 255, 0)  # #00ff00 pour le prompt
+CHROMA_GREEN_TOLERANCE = 55  # pour vert vif proche de #00ff00
+# Vert "dominant" (G > R et G > B) pour attraper les verts plus foncés renvoyés par Imagen
+CHROMA_GREEN_MIN_G = 60  # G >= ce seuil et G dominant → considéré fond vert
+CHROMA_GREEN_PROMPT = " The background must be solid green #00ff00 only, like a green screen. Subject in gray/blue/metallic, no white or other background."
 
 # Backoff pour rate limit (429)
 BACKOFF_BASE_SEC = 30
@@ -49,25 +61,41 @@ CRITICAL - SMALL SIZE (to avoid rate limits):
 - Generate SMALL, LOW-RESOLUTION images only. For units: exactly 128x128 pixels. For buildings: longest side 128 pixels. Do NOT generate large or high-resolution images (no 512, 1024, etc.). Small output is required.
 - MANDATORY transparent background: only the subject has visible pixels; everything else fully transparent (PNG with alpha). No ground, no floor, no solid color.
 
-CRITICAL - VIEW ANGLE:
-- Strict top-down view (bird's eye, camera directly above). Only the top surface/footprint visible. No side view, no 3/4, no isometric.
+CRITICAL - VIEW ANGLE (NO EXCEPTIONS):
+- Strict top-down view ONLY (bird's eye, camera at exactly 90 degrees directly above the subject). This applies to EVERY sprite without exception, including soldiers, mechs, vehicles, and buildings.
+- You must ONLY see the top surface/footprint of the subject. No side view, no 3/4 view, no isometric, no perspective angle.
+- For units with weapons (marine, goliath, tank, etc.): the weapon barrel must point straight forward, visible from above as a shape pointing toward the top of the image.
+- Reject any tendency to show a front/side/3D perspective — the camera is directly overhead, period.
 
 Other: subject fills frame, minimal margins. Dark metallic, blue/gray palette, industrial sci-fi. No text or labels. One image per request, no commentary."""
 
 # Vue strictement de dessus + fond transparent + remplir le cadre
 _TOP = "Strict top-down view only (bird's eye, camera directly above, 90°). Only the top surface/footprint visible, no side or perspective. "
-_FILL = "MANDATORY transparent background only (no ground, no floor, no solid color). Subject must fill the frame tightly, edge to edge. "
+_FILL = "MANDATORY green #00ff00 background only (no ground, no floor, no details). Subject must fill the frame tightly, edge to edge. "
 # Petite image demandée à l'API pour éviter le rate limit (pas de post-traitement)
 _SMALL = "Generate a SMALL low-resolution image only: 128x128 pixels for square sprites, or longest side 128 for rectangles. Tiny size. Do NOT output large or high-resolution (no 512, 1024, etc.). "
 
 # Prompts par unité : petite 128x128, fond transparent
 UNIT_PROMPTS: dict[str, str] = {
-    UnitType.SCV.value: _TOP + _FILL + _SMALL + "Single SCV worker from above: mech footprint, two arms, cockpit. Industrial gray and blue.",
-    UnitType.MARINE.value: _TOP + _FILL + _SMALL + "Single Terran Marine from above: oval footprint, weapon. Dark blue armor.",
-    UnitType.MEDIC.value: _TOP + _FILL + _SMALL + "Single Medic from above: compact footprint, cross/medical symbol. Sci-fi armor.",
-    UnitType.GOLIATH.value: _TOP + _FILL + _SMALL + "Goliath walker from above: two gun pods, central body. Dark metal and blue.",
-    UnitType.TANK.value: _TOP + _FILL + _SMALL + "Siege Tank from above: elongated hull, round turret, treads. Military gray and blue.",
-    UnitType.WRAITH.value: _TOP + _FILL + _SMALL + "Wraith starfighter from above: delta wing, cockpit. Dark with blue.",
+    UnitType.SCV.value: _TOP + _FILL + _SMALL + "Single SCV worker robot seen strictly from directly above at 90 degrees, bird's eye view only. Top surface visible: mechanical body footprint, two mechanical arms extended sideways, cockpit hatch on top. Industrial gray and blue. Camera is directly overhead, no side or perspective angle.",
+    UnitType.MARINE.value: _TOP + _FILL + _SMALL + "Single Terran Marine soldier seen strictly from directly above at 90 degrees, bird's eye view only. Top of armored helmet visible at center, heavy shoulder pads on both sides, rifle/assault gun barrel pointing straight forward (upward in the image). Dark blue armor. No side view, no isometric, camera directly overhead.",
+    UnitType.MEDIC.value: _TOP + _FILL + _SMALL + "Single Terran Medic soldier seen strictly from directly above at 90 degrees, bird's eye view only. Top of helmet visible at center, white/light armor with red cross medical symbol on back, medkit or injector pointing forward. Sci-fi armor. Camera directly overhead, no side or perspective.",
+    UnitType.GOLIATH.value: _TOP + _FILL + _SMALL + "Goliath combat walker mech seen strictly from directly above at 90 degrees, bird's eye view only. Top surface: wide armored torso, two autocannon gun pods mounted on shoulders pointing straight forward (upward in image), legs spread below. Dark metal and blue. Camera directly overhead at 90 degrees, no side view.",
+    UnitType.TANK.value: _TOP + _FILL + _SMALL + "Siege Tank seen strictly from directly above at 90 degrees, bird's eye view only. Top surface: elongated armored hull, round turret on top with long cannon barrel pointing straight forward (upward in image), tank treads visible on both sides. Military gray and blue. Camera directly overhead.",
+    UnitType.WRAITH.value: _TOP + _FILL + _SMALL + "Wraith starfighter aircraft seen strictly from directly above at 90 degrees, bird's eye view only. Top surface: delta wing shape, cockpit bubble at center-front, weapon pods on wing edges pointing forward. Dark metallic with blue highlights. Camera directly overhead.",
+}
+
+# Icônes UI : style flat symbolique, fond vert chroma pour détourage
+ICON_PROMPTS: dict[str, str] = {
+    "mineral": _FILL + _SMALL + "Flat symbolic icon of a blue mineral crystal, bold angular shape, solid blue-cyan color, thick black outline, 2D game UI icon style. No background, no text, no shading.",
+    "gas": _FILL + _SMALL + "Flat symbolic icon of a purple vespene gas canister or flask, bold shape, solid purple-violet color, thick black outline, 2D game UI icon style. No green. No background, no text, no shading.",
+    "supply": _FILL + _SMALL + "Flat symbolic icon of a chevron/arrow pointing up or a small house shape, bold, solid yellow-orange color, thick black outline, 2D game UI icon style. No background, no text, no shading.",
+}
+
+# Prompts par ressource : icône top-down 64x64
+RESOURCE_PROMPTS: dict[str, str] = {
+    ResourceType.MINERAL.value: _TOP + _FILL + _SMALL + "Mineral crystal cluster from above: angular blue-teal crystalline shards, glowing. Sci-fi RTS style. No text.",
+    ResourceType.GEYSER.value: _TOP + _FILL + _SMALL + "Vespene gas geyser from above: purple/violet glowing vent/crater with purple gas fumes rising. Purple and magenta colors only, NO green. Sci-fi RTS style. No text.",
 }
 
 # Prompts par bâtiment : petite image (longest side 128), fond transparent
@@ -86,8 +114,110 @@ def _building_prompt(building_type: BuildingType) -> str:
     return base + " Transparent background only. Dark metal and blue."
 
 
+def _is_chroma_green(r: int, g: int, b: int) -> bool:
+    """True si le pixel est fond vert à détourer : proche de #00ff00 ou vert dominant (G > R, G > B)."""
+    # Vert vif type #00ff00
+    r0, g0, b0 = CHROMA_GREEN_RGB
+    if (
+        abs(r - r0) <= CHROMA_GREEN_TOLERANCE
+        and abs(g - g0) <= CHROMA_GREEN_TOLERANCE
+        and abs(b - b0) <= CHROMA_GREEN_TOLERANCE
+    ):
+        return True
+    # Vert plus foncé (Imagen renvoie souvent ~50,127,70) : G dominant et G assez élevé
+    if g >= CHROMA_GREEN_MIN_G and g >= r and g >= b:
+        # exclure les gris (r≈g≈b) et garder un vrai vert (g nettement > r ou b)
+        if r > 100 and b > 100 and abs(r - g) < 30 and abs(b - g) < 30:
+            return False  # gris, pas vert
+        return True
+    return False
+
+
+def _resize_and_make_transparent(data: bytes, out_path: Path, size: int = TARGET_SIZE) -> None:
+    """Redimensionne à size px (côté max). Rend transparent : fond vert chroma ET blanc/clair. Sauvegarde en PNG."""
+    from PIL import Image
+    import io
+    img = Image.open(io.BytesIO(data)).convert("RGBA")
+    w, h = img.size
+    if w > size or h > size:
+        scale = size / max(w, h)
+        nw, nh = max(1, int(w * scale)), max(1, int(h * scale))
+        img = img.resize((nw, nh), Image.Resampling.LANCZOS)
+    pixels = img.load()
+    for y in range(img.height):
+        for x in range(img.width):
+            r, g, b, a = pixels[x, y]
+            if _is_chroma_green(r, g, b):
+                pixels[x, y] = (r, g, b, 0)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    img.save(out_path, "PNG")
+
+
+# ---------------------------------------------------------------------------
+# GCP Vertex AI Imagen (optionnel)
+# ---------------------------------------------------------------------------
+
+def _generate_one_vertex(prompt: str, out_path: Path, progress: str = "") -> bool:
+    """Génère une image via Vertex AI Imagen et la sauvegarde."""
+    from google import genai
+    from google.genai.types import GenerateImagesConfig
+
+    name = out_path.stem
+    for attempt in range(BACKOFF_MAX_RETRIES):
+        try:
+            if attempt == 0:
+                log.info("[%s] Appel Vertex Imagen pour %s...", progress or name, name)
+            else:
+                log.info("[%s] Retry %s/%s — Imagen pour %s...", progress or name, attempt + 1, BACKOFF_MAX_RETRIES, name)
+            # GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_LOCATION, GOOGLE_GENAI_USE_VERTEXAI set in main()
+            client = genai.Client(vertexai=True)
+            vertex_prompt = prompt + CHROMA_GREEN_PROMPT
+            response = client.models.generate_images(
+                model="imagen-3.0-fast-generate-001",
+                prompt=vertex_prompt,
+                config=GenerateImagesConfig(
+                    numberOfImages=1,
+                    aspectRatio="1:1",
+                ),
+            )
+            if not response.generated_images or not response.generated_images[0].image:
+                log.warning("[%s] Réponse Imagen vide pour %s", progress or name, name)
+                return False
+            img = response.generated_images[0].image
+            raw_bytes: bytes
+            if hasattr(img, "image_bytes") and img.image_bytes is not None:
+                raw_bytes = img.image_bytes
+            elif hasattr(img, "save") and callable(img.save):
+                import io
+                buf = io.BytesIO()
+                img.save(buf)
+                raw_bytes = buf.getvalue()
+            else:
+                log.error("[%s] Format image Imagen inattendu pour %s", progress or name, name)
+                return False
+            _resize_and_make_transparent(raw_bytes, out_path)
+            size_kb = out_path.stat().st_size / 1024
+            log.info("[%s] OK %s — sauvegardé 128px transparent (%s Ko) → %s", progress or name, name, round(size_kb, 1), out_path)
+            return True
+        except Exception as e:
+            err_msg = str(e)
+            if ("429" in err_msg or "rate limit" in err_msg.lower() or "resource exhausted" in err_msg.lower()) and attempt < BACKOFF_MAX_RETRIES - 1:
+                delay = min(BACKOFF_BASE_SEC * (2 ** attempt), BACKOFF_MAX_SEC)
+                jitter = random.uniform(0, delay * 0.2)
+                time.sleep(delay + jitter)
+            else:
+                log.error("[%s] Échec Imagen pour %s: %s", progress or name, name, err_msg)
+                return False
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Mistral (fallback si GCP non configuré)
+# ---------------------------------------------------------------------------
+
 def _find_file_id_in_response(response: Any) -> str | None:
     """Extrait le file_id du premier ToolFileChunk dans response.outputs."""
+    from mistralai.models import ToolFileChunk
     for entry in getattr(response, "outputs", []) or []:
         content = getattr(entry, "content", None)
         if content is None:
@@ -172,98 +302,186 @@ def _generate_one(client: Mistral, agent_id: str, prompt: str, out_path: Path, p
     if data is None:
         return False
 
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    out_path.write_bytes(data)
-    size_kb = len(data) / 1024
-    log.info("[%s] OK %s — sauvegardé (%s Ko) → %s", progress or name, name, round(size_kb, 1), out_path)
+    _resize_and_make_transparent(data, out_path)
+    size_kb = out_path.stat().st_size / 1024
+    log.info("[%s] OK %s — sauvegardé 128px transparent (%s Ko) → %s", progress or name, name, round(size_kb, 1), out_path)
     return True
 
 
 def main() -> None:
     import argparse
-    parser = argparse.ArgumentParser(description="Generate unit/building sprites via Mistral")
+    parser = argparse.ArgumentParser(description="Generate unit/building sprites (Vertex Imagen or Mistral)")
     parser.add_argument("--unit", type=str, metavar="ID", help="Generate only this unit (e.g. marine, scv)")
     parser.add_argument("--building", type=str, metavar="ID", help="Generate only this building (e.g. barracks)")
+    parser.add_argument("--resource", type=str, metavar="ID", help="Generate only this resource (e.g. mineral, geyser)")
+    parser.add_argument("--icon", type=str, metavar="ID", help="Generate only this UI icon (e.g. mineral, gas, supply)")
+    parser.add_argument("--skip-existing", action="store_true", help="Skip sprites that already exist (do not regenerate)")
     args = parser.parse_args()
 
     only_unit = args.unit.strip().lower() if args.unit else None
+    skip_existing = args.skip_existing
     only_building = args.building.strip().lower().replace(" ", "_") if args.building else None
+    only_resource = args.resource.strip().lower() if args.resource else None
+    only_icon = args.icon.strip().lower() if args.icon else None
+
+    use_vertex = bool(GCP_PROJECT_ID)
+    if use_vertex:
+        os.environ["GOOGLE_CLOUD_PROJECT"] = GCP_PROJECT_ID
+        os.environ["GOOGLE_CLOUD_LOCATION"] = GCP_LOCATION
+        os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "true"
+        log.info("Backend: Vertex AI Imagen (project=%s, location=%s)", GCP_PROJECT_ID, GCP_LOCATION)
+
+        def do_generate(prompt: str, out: Path, progress: str) -> bool:
+            return _generate_one_vertex(prompt, out, progress)
+    else:
+        if not MISTRAL_API_KEY:
+            log.error("Aucun backend image configuré. Définir GCP_PROJECT_ID (ex: mtgbinder) ou MISTRAL_API_KEY dans .env")
+            sys.exit(1)
+        from mistralai import Mistral
+        client = Mistral(api_key=MISTRAL_API_KEY)
+        log.info("Creating Mistral image generation agent...")
+        try:
+            agent = client.beta.agents.create(
+                model="mistral-medium-2505",
+                name="Sprite Generator",
+                description="Generates top-down game sprites for units and buildings.",
+                instructions=AGENT_INSTRUCTIONS,
+                tools=[{"type": "image_generation"}],
+                completion_args={"temperature": 0.3, "top_p": 0.95},
+            )
+            agent_id = agent.id
+            log.info("Agent id: %s", agent_id)
+        except Exception as e:
+            log.exception("Failed to create agent: %s", e)
+            sys.exit(1)
 
-    if not MISTRAL_API_KEY:
-        log.error("MISTRAL_API_KEY not set. Add it to .env")
-        sys.exit(1)
+        def do_generate(prompt: str, out: Path, progress: str) -> bool:
+            return _generate_one(client, agent_id, prompt, out, progress=progress)
 
-    client = Mistral(api_key=MISTRAL_API_KEY)
-
-    log.info("Creating image generation agent...")
-    try:
-        agent = client.beta.agents.create(
-            model="mistral-medium-2505",
-            name="Sprite Generator",
-            description="Generates top-down game sprites for units and buildings.",
-            instructions=AGENT_INSTRUCTIONS,
-            tools=[{"type": "image_generation"}],
-            completion_args={"temperature": 0.3, "top_p": 0.95},
-        )
-        agent_id = agent.id
-        log.info("Agent id: %s", agent_id)
-    except Exception as e:
-        log.exception("Failed to create agent: %s", e)
-        sys.exit(1)
+    only_resource_flag = only_resource is not None
+    only_unit_flag = only_unit is not None
+    only_building_flag = only_building is not None
+    only_icon_flag = only_icon is not None
 
     UNITS_DIR.mkdir(parents=True, exist_ok=True)
     BUILDINGS_DIR.mkdir(parents=True, exist_ok=True)
+    RESOURCES_DIR.mkdir(parents=True, exist_ok=True)
+    ICONS_DIR.mkdir(parents=True, exist_ok=True)
 
-    # Si --unit X : uniquement cette unité (pas de bâtiments). Si --building Y : uniquement ce bâtiment (pas d'unités).
     units_to_run: list = []
-    if not only_building:
-        units_to_run = [ut for ut in UnitType if not only_unit or ut.value == only_unit]
-        if only_unit and not units_to_run:
+    if not only_building_flag and not only_resource_flag and not only_icon_flag:
+        units_to_run = [ut for ut in UnitType if not only_unit_flag or ut.value == only_unit]
+        if only_unit_flag and not units_to_run:
             log.error("Unknown unit: %s. Valid: %s", only_unit, [u.value for u in UnitType])
             sys.exit(1)
 
     buildings_to_run: list = []
-    if not only_unit:
-        buildings_to_run = [bt for bt in BuildingType if not only_building or bt.value == only_building]
-        if only_building and not buildings_to_run:
+    if not only_unit_flag and not only_resource_flag and not only_icon_flag:
+        buildings_to_run = [bt for bt in BuildingType if not only_building_flag or bt.value == only_building]
+        if only_building_flag and not buildings_to_run:
             log.error("Unknown building: %s. Valid: %s", only_building, [b.value for b in BuildingType])
             sys.exit(1)
 
-    total = len(units_to_run) + len(buildings_to_run)
+    resources_to_run: list = []
+    if not only_unit_flag and not only_building_flag and not only_icon_flag:
+        valid_resources = list(RESOURCE_PROMPTS.keys())
+        resources_to_run = [r for r in valid_resources if not only_resource_flag or r == only_resource]
+        if only_resource_flag and not resources_to_run:
+            log.error("Unknown resource: %s. Valid: %s", only_resource, valid_resources)
+            sys.exit(1)
+
+    icons_to_run: list = []
+    if not only_unit_flag and not only_building_flag and not only_resource_flag:
+        valid_icons = list(ICON_PROMPTS.keys())
+        icons_to_run = [ic for ic in valid_icons if not only_icon_flag or ic == only_icon]
+        if only_icon_flag and not icons_to_run:
+            log.error("Unknown icon: %s. Valid: %s", only_icon, valid_icons)
+            sys.exit(1)
+
+    total = len(units_to_run) + len(buildings_to_run) + len(resources_to_run) + len(icons_to_run)
     log.info("========== GÉNÉRATION SPRITES ==========")
     log.info("Unités à générer: %s (%s)", [u.value for u in units_to_run], len(units_to_run))
     log.info("Bâtiments à générer: %s (%s)", [b.value for b in buildings_to_run], len(buildings_to_run))
+    log.info("Ressources à générer: %s (%s)", resources_to_run, len(resources_to_run))
+    log.info("Icônes UI à générer: %s (%s)", icons_to_run, len(icons_to_run))
     log.info("Total: %s sprites. Délai entre chaque: %s s.", total, DELAY_BETWEEN_SPRITES_SEC)
     log.info("=========================================")
 
     ok, fail = 0, 0
     t0 = time.monotonic()
+    generated_count = 0
 
     for i, ut in enumerate(units_to_run):
-        if i > 0:
-            log.info("--- Pause %s s (rate limit) avant prochaine unité ---", DELAY_BETWEEN_SPRITES_SEC)
-            time.sleep(DELAY_BETWEEN_SPRITES_SEC)
         out = UNITS_DIR / f"{ut.value}.png"
+        if skip_existing and out.exists():
+            log.info("[unit %s/%s] Déjà présent, ignoré: %s", i + 1, len(units_to_run), out.name)
+            ok += 1
+            continue
+        if generated_count > 0:
+            log.info("--- Pause %s s (rate limit) ---", DELAY_BETWEEN_SPRITES_SEC)
+            time.sleep(DELAY_BETWEEN_SPRITES_SEC)
         prompt = UNIT_PROMPTS.get(ut.value, _TOP + _FILL + _SMALL + f"{ut.value} unit from above, sci-fi RTS. Transparent background only.")
         progress = "unit %s/%s" % (i + 1, len(units_to_run))
-        if _generate_one(client, agent_id, prompt, out, progress=progress):
+        if do_generate(prompt, out, progress):
             ok += 1
         else:
             fail += 1
             log.warning("Échec pour unité %s", ut.value)
+        generated_count += 1
 
     for i, bt in enumerate(buildings_to_run):
-        if i > 0 or units_to_run:
-            log.info("--- Pause %s s (rate limit) avant prochain bâtiment ---", DELAY_BETWEEN_SPRITES_SEC)
-            time.sleep(DELAY_BETWEEN_SPRITES_SEC)
         out = BUILDINGS_DIR / f"{bt.value}.png"
+        if skip_existing and out.exists():
+            log.info("[building %s/%s] Déjà présent, ignoré: %s", i + 1, len(buildings_to_run), out.name)
+            ok += 1
+            continue
+        if generated_count > 0:
+            log.info("--- Pause %s s (rate limit) ---", DELAY_BETWEEN_SPRITES_SEC)
+            time.sleep(DELAY_BETWEEN_SPRITES_SEC)
         prompt = _building_prompt(bt)
         progress = "building %s/%s" % (i + 1, len(buildings_to_run))
-        if _generate_one(client, agent_id, prompt, out, progress=progress):
+        if do_generate(prompt, out, progress):
             ok += 1
         else:
             fail += 1
             log.warning("Échec pour bâtiment %s", bt.value)
+        generated_count += 1
+
+    for i, rid in enumerate(resources_to_run):
+        out = RESOURCES_DIR / f"{rid}.png"
+        if skip_existing and out.exists():
+            log.info("[resource %s/%s] Déjà présent, ignoré: %s", i + 1, len(resources_to_run), out.name)
+            ok += 1
+            continue
+        if generated_count > 0:
+            log.info("--- Pause %s s (rate limit) ---", DELAY_BETWEEN_SPRITES_SEC)
+            time.sleep(DELAY_BETWEEN_SPRITES_SEC)
+        prompt = RESOURCE_PROMPTS[rid]
+        progress = "resource %s/%s" % (i + 1, len(resources_to_run))
+        if do_generate(prompt, out, progress):
+            ok += 1
+        else:
+            fail += 1
+            log.warning("Échec pour ressource %s", rid)
+        generated_count += 1
+
+    for i, ic in enumerate(icons_to_run):
+        out = ICONS_DIR / f"{ic}.png"
+        if skip_existing and out.exists():
+            log.info("[icon %s/%s] Déjà présent, ignoré: %s", i + 1, len(icons_to_run), out.name)
+            ok += 1
+            continue
+        if generated_count > 0:
+            log.info("--- Pause %s s (rate limit) ---", DELAY_BETWEEN_SPRITES_SEC)
+            time.sleep(DELAY_BETWEEN_SPRITES_SEC)
+        prompt = ICON_PROMPTS[ic]
+        progress = "icon %s/%s" % (i + 1, len(icons_to_run))
+        if do_generate(prompt, out, progress):
+            ok += 1
+        else:
+            fail += 1
+            log.warning("Échec pour icône %s", ic)
+        generated_count += 1
 
     elapsed = time.monotonic() - t0
     log.info("========== FIN ==========")

backend/scripts/upscale_cover.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Upscale l'image cover (lobby) via Vertex AI Imagen 4.0 upscale.
+
+Prérequis : GCP_PROJECT_ID et GCP_LOCATION dans .env, et `gcloud auth application-default login`
+(ou GOOGLE_APPLICATION_CREDENTIALS).
+
+Usage :
+  cd backend && python -m scripts.upscale_cover
+  cd backend && python -m scripts.upscale_cover --factor x2 --input ../frontend/src/cover.jpg --output ../frontend/src/cover.jpg
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import subprocess
+import sys
+from pathlib import Path
+
+_backend = Path(__file__).resolve().parent.parent
+if str(_backend) not in sys.path:
+    sys.path.insert(0, str(_backend))
+
+from config import GCP_PROJECT_ID, GCP_LOCATION
+
+
+def get_access_token() -> str:
+    """Token via gcloud (ADC)."""
+    out = subprocess.run(
+        ["gcloud", "auth", "print-access-token"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if out.returncode != 0:
+        raise RuntimeError(
+            "Échec gcloud auth. Lancez: gcloud auth application-default login"
+        )
+    return out.stdout.strip()
+
+
+def upscale_image(
+    image_path: Path,
+    out_path: Path,
+    factor: str = "x4",
+    region: str | None = None,
+    project_id: str | None = None,
+) -> None:
+    region = region or GCP_LOCATION
+    project_id = project_id or GCP_PROJECT_ID
+    if not project_id:
+        raise SystemExit("Définir GCP_PROJECT_ID dans .env")
+
+    data = image_path.read_bytes()
+    if len(data) > 10 * 1024 * 1024:
+        raise SystemExit("Image trop lourde (max 10 Mo)")
+
+    b64 = base64.standard_b64encode(data).decode("ascii")
+    token = get_access_token()
+    url = (
+        f"https://{region}-aiplatform.googleapis.com/v1/projects/{project_id}"
+        f"/locations/{region}/publishers/google/models/imagen-4.0-upscale-preview:predict"
+    )
+    import httpx
+
+    payload = {
+        "instances": [
+            {"prompt": "Upscale the image", "image": {"bytesBase64Encoded": b64}}
+        ],
+        "parameters": {
+            "mode": "upscale",
+            "upscaleConfig": {"upscaleFactor": factor},
+            "outputOptions": {"mimeType": "image/png"},
+        },
+    }
+    resp = httpx.post(
+        url,
+        json=payload,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        },
+        timeout=120.0,
+    )
+    resp.raise_for_status()
+    body = resp.json()
+    preds = body.get("predictions") or []
+    if not preds or "bytesBase64Encoded" not in preds[0]:
+        raise SystemExit("Réponse Vertex sans image: " + str(body)[:500])
+    out_b64 = preds[0]["bytesBase64Encoded"]
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_bytes(base64.standard_b64decode(out_b64))
+    print(f"Upscale {factor} OK → {out_path} ({out_path.stat().st_size / 1024:.1f} Ko)")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Upscale cover image via Vertex AI Imagen")
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=_backend.parent / "frontend" / "src" / "cover.jpg",
+        help="Image source",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help="Image de sortie (défaut: --input)",
+    )
+    parser.add_argument(
+        "--factor",
+        choices=("x2", "x3", "x4"),
+        default="x4",
+        help="Facteur d'upscale (défaut: x4)",
+    )
+    args = parser.parse_args()
+    out = args.output or args.input
+    if not args.input.is_file():
+        raise SystemExit(f"Fichier introuvable: {args.input}")
+    upscale_image(args.input, out, factor=args.factor)
+
+
+if __name__ == "__main__":
+    main()

backend/scripts/upscale_map.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""
+Upscale MAP.png en 4 passes (4 quadrants) via Vertex AI Imagen upscale.
+
+La map étant trop lourde pour l'API en un seul appel (> 10 Mo), on :
+  1. Découpe en 4 quadrants de 2048×2048
+  2. Upscale chaque quadrant ×2  →  4096×4096 chacun
+  3. Recolle en une image finale 8192×8192
+
+Usage :
+  cd backend && python -m scripts.upscale_map
+  cd backend && python -m scripts.upscale_map --factor x2 --input static/MAP.png --output static/MAP.png
+"""
+from __future__ import annotations
+
+import argparse
+import io
+import sys
+from pathlib import Path
+
+from PIL import Image
+
+_backend = Path(__file__).resolve().parent.parent
+if str(_backend) not in sys.path:
+    sys.path.insert(0, str(_backend))
+
+from scripts.upscale_cover import upscale_image
+
+
+def upscale_map(
+    input_path: Path,
+    output_path: Path,
+    factor: str = "x2",
+) -> None:
+    src = Image.open(input_path).convert("RGB")
+    w, h = src.size
+    print(f"Image source : {w}×{h}  ({input_path.stat().st_size / 1024 / 1024:.1f} Mo)")
+
+    half_w, half_h = w // 2, h // 2
+    quadrants = [
+        (0,      0,      half_w, half_h),   # top-left
+        (half_w, 0,      w,      half_h),   # top-right
+        (0,      half_h, half_w, h     ),   # bottom-left
+        (half_w, half_h, w,      h     ),   # bottom-right
+    ]
+    labels = ["top-left", "top-right", "bottom-left", "bottom-right"]
+
+    upscaled_quadrants: list[Image.Image] = []
+
+    for i, (box, label) in enumerate(zip(quadrants, labels)):
+        print(f"\n[{i+1}/4] Quadrant {label} {box}")
+
+        quad_img = src.crop(box)
+        tmp_in = Path(f"/tmp/map_quad_{i}.png")
+        tmp_out = Path(f"/tmp/map_quad_{i}_up.png")
+
+        buf = io.BytesIO()
+        quad_img.save(buf, format="PNG", optimize=False)
+        size_mb = len(buf.getvalue()) / 1024 / 1024
+        print(f"       Taille quadrant : {size_mb:.1f} Mo", end="")
+        if size_mb > 10:
+            print("  ⚠ > 10 Mo, passage en JPEG lossy pour respecter la limite API")
+            buf = io.BytesIO()
+            quad_img.save(buf, format="JPEG", quality=92)
+            tmp_in = Path(f"/tmp/map_quad_{i}.jpg")
+        else:
+            print()
+
+        tmp_in.write_bytes(buf.getvalue())
+
+        upscale_image(tmp_in, tmp_out, factor=factor)
+        upscaled_quadrants.append(Image.open(tmp_out).convert("RGB"))
+
+    uw, uh = upscaled_quadrants[0].size
+    print(f"\nRecomposition : quadrants upscalés {uw}×{uh} → image finale {uw*2}×{uh*2}")
+    final = Image.new("RGB", (uw * 2, uh * 2))
+    final.paste(upscaled_quadrants[0], (0,   0))
+    final.paste(upscaled_quadrants[1], (uw,  0))
+    final.paste(upscaled_quadrants[2], (0,   uh))
+    final.paste(upscaled_quadrants[3], (uw,  uh))
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    final.save(output_path, format="PNG", optimize=False)
+    print(f"\nSauvegardé : {output_path} ({output_path.stat().st_size / 1024 / 1024:.1f} Mo)")
+
+
+def main() -> None:
+    default_map = _backend / "static" / "MAP.png"
+    parser = argparse.ArgumentParser(description="Upscale MAP.png en 4 quadrants via Vertex AI")
+    parser.add_argument("--input",  type=Path, default=default_map)
+    parser.add_argument("--output", type=Path, default=None)
+    parser.add_argument("--factor", choices=("x2", "x4"), default="x2")
+    args = parser.parse_args()
+
+    out = args.output or args.input
+    if not args.input.is_file():
+        raise SystemExit(f"Fichier introuvable : {args.input}")
+
+    upscale_map(args.input, out, factor=args.factor)
+
+
+if __name__ == "__main__":
+    main()

backend/static/compiled_map.json

@@ -0,0 +1,4211 @@
+{
+  "exterior": [
+    [
+      43.7365,
+      65.5492
+    ],
+    [
+      47.7007,
+      67.2865
+    ],
+    [
+      41.6913,
+      75.7753
+    ],
+    [
+      45.6539,
+      77.8206
+    ],
+    [
+      41.18,
+      80.8884
+    ],
+    [
+      46.4852,
+      85.1941
+    ],
+    [
+      41.9342,
+      88.3091
+    ],
+    [
+      51.1504,
+      95.2049
+    ],
+    [
+      58.3087,
+      94.2606
+    ],
+    [
+      62.1435,
+      99.1675
+    ],
+    [
+      46.8043,
+      98.9119
+    ],
+    [
+      41.18,
+      95.4606
+    ],
+    [
+      36.5783,
+      98.1449
+    ],
+    [
+      29.5478,
+      93.2875
+    ],
+    [
+      25.0739,
+      94.6936
+    ],
+    [
+      18.4269,
+      93.0319
+    ],
+    [
+      14.72,
+      90.4753
+    ],
+    [
+      11.2687,
+      87.9188
+    ],
+    [
+      7.6895,
+      80.7606
+    ],
+    [
+      5.6443,
+      77.8206
+    ],
+    [
+      10.1182,
+      76.5423
+    ],
+    [
+      11.1408,
+      72.5797
+    ],
+    [
+      16.1261,
+      72.1962
+    ],
+    [
+      16.1261,
+      74.6249
+    ],
+    [
+      23.2843,
+      72.9632
+    ],
+    [
+      29.6756,
+      69.8953
+    ],
+    [
+      33.8939,
+      73.091
+    ],
+    [
+      37.6009,
+      73.9858
+    ],
+    [
+      43.0878,
+      65.1726
+    ]
+  ],
+  "holes": [],
+  "nav_points": [
+    [
+      2.7408,
+      47.5359
+    ],
+    [
+      4.3408,
+      45.9359
+    ],
+    [
+      4.3408,
+      47.5359
+    ],
+    [
+      5.9408,
+      44.3359
+    ],
+    [
+      5.9408,
+      45.9359
+    ],
+    [
+      5.9408,
+      47.5359
+    ],
+    [
+      5.9408,
+      49.1359
+    ],
+    [
+      5.9408,
+      61.9359
+    ],
+    [
+      5.9408,
+      63.5359
+    ],
+    [
+      7.5408,
+      20.3359
+    ],
+    [
+      7.5408,
+      44.3359
+    ],
+    [
+      7.5408,
+      45.9359
+    ],
+    [
+      7.5408,
+      47.5359
+    ],
+    [
+      7.5408,
+      61.9359
+    ],
+    [
+      7.5408,
+      63.5359
+    ],
+    [
+      7.5408,
+      65.1359
+    ],
+    [
+      7.5408,
+      66.7359
+    ],
+    [
+      9.1408,
+      17.1359
+    ],
+    [
+      9.1408,
+      18.7359
+    ],
+    [
+      9.1408,
+      20.3359
+    ],
+    [
+      9.1408,
+      21.9359
+    ],
+    [
+      9.1408,
+      44.3359
+    ],
+    [
+      9.1408,
+      45.9359
+    ],
+    [
+      9.1408,
+      47.5359
+    ],
+    [
+      9.1408,
+      58.7359
+    ],
+    [
+      9.1408,
+      60.3359
+    ],
+    [
+      9.1408,
+      61.9359
+    ],
+    [
+      9.1408,
+      63.5359
+    ],
+    [
+      9.1408,
+      65.1359
+    ],
+    [
+      9.1408,
+      66.7359
+    ],
+    [
+      9.1408,
+      68.3359
+    ],
+    [
+      9.1408,
+      69.9359
+    ],
+    [
+      10.7408,
+      17.1359
+    ],
+    [
+      10.7408,
+      18.7359
+    ],
+    [
+      10.7408,
+      20.3359
+    ],
+    [
+      10.7408,
+      21.9359
+    ],
+    [
+      10.7408,
+      23.5359
+    ],
+    [
+      10.7408,
+      28.3359
+    ],
+    [
+      10.7408,
+      44.3359
+    ],
+    [
+      10.7408,
+      45.9359
+    ],
+    [
+      10.7408,
+      47.5359
+    ],
+    [
+      10.7408,
+      58.7359
+    ],
+    [
+      10.7408,
+      60.3359
+    ],
+    [
+      10.7408,
+      61.9359
+    ],
+    [
+      10.7408,
+      63.5359
+    ],
+    [
+      10.7408,
+      65.1359
+    ],
+    [
+      10.7408,
+      66.7359
+    ],
+    [
+      10.7408,
+      68.3359
+    ],
+    [
+      10.7408,
+      69.9359
+    ],
+    [
+      10.7408,
+      71.5359
+    ],
+    [
+      12.3408,
+      7.5359
+    ],
+    [
+      12.3408,
+      9.1359
+    ],
+    [
+      12.3408,
+      15.5359
+    ],
+    [
+      12.3408,
+      17.1359
+    ],
+    [
+      12.3408,
+      18.7359
+    ],
+    [
+      12.3408,
+      20.3359
+    ],
+    [
+      12.3408,
+      21.9359
+    ],
+    [
+      12.3408,
+      23.5359
+    ],
+    [
+      12.3408,
+      26.7359
+    ],
+    [
+      12.3408,
+      28.3359
+    ],
+    [
+      12.3408,
+      42.7359
+    ],
+    [
+      12.3408,
+      44.3359
+    ],
+    [
+      12.3408,
+      45.9359
+    ],
+    [
+      12.3408,
+      47.5359
+    ],
+    [
+      12.3408,
+      49.1359
+    ],
+    [
+      12.3408,
+      58.7359
+    ],
+    [
+      12.3408,
+      60.3359
+    ],
+    [
+      12.3408,
+      61.9359
+    ],
+    [
+      12.3408,
+      63.5359
+    ],
+    [
+      12.3408,
+      65.1359
+    ],
+    [
+      12.3408,
+      66.7359
+    ],
+    [
+      12.3408,
+      68.3359
+    ],
+    [
+      12.3408,
+      69.9359
+    ],
+    [
+      12.3408,
+      71.5359
+    ],
+    [
+      13.9408,
+      7.5359
+    ],
+    [
+      13.9408,
+      9.1359
+    ],
+    [
+      13.9408,
+      10.7359
+    ],
+    [
+      13.9408,
+      12.3359
+    ],
+    [
+      13.9408,
+      15.5359
+    ],
+    [
+      13.9408,
+      17.1359
+    ],
+    [
+      13.9408,
+      18.7359
+    ],
+    [
+      13.9408,
+      20.3359
+    ],
+    [
+      13.9408,
+      21.9359
+    ],
+    [
+      13.9408,
+      23.5359
+    ],
+    [
+      13.9408,
+      25.1359
+    ],
+    [
+      13.9408,
+      26.7359
+    ],
+    [
+      13.9408,
+      28.3359
+    ],
+    [
+      13.9408,
+      41.1359
+    ],
+    [
+      13.9408,
+      42.7359
+    ],
+    [
+      13.9408,
+      44.3359
+    ],
+    [
+      13.9408,
+      45.9359
+    ],
+    [
+      13.9408,
+      47.5359
+    ],
+    [
+      13.9408,
+      49.1359
+    ],
+    [
+      13.9408,
+      50.7359
+    ],
+    [
+      13.9408,
+      60.3359
+    ],
+    [
+      13.9408,
+      61.9359
+    ],
+    [
+      13.9408,
+      63.5359
+    ],
+    [
+      13.9408,
+      65.1359
+    ],
+    [
+      13.9408,
+      66.7359
+    ],
+    [
+      13.9408,
+      68.3359
+    ],
+    [
+      13.9408,
+      69.9359
+    ],
+    [
+      13.9408,
+      71.5359
+    ],
+    [
+      13.9408,
+      73.1359
+    ],
+    [
+      15.5408,
+      5.9359
+    ],
+    [
+      15.5408,
+      7.5359
+    ],
+    [
+      15.5408,
+      9.1359
+    ],
+    [
+      15.5408,
+      10.7359
+    ],
+    [
+      15.5408,
+      12.3359
+    ],
+    [
+      15.5408,
+      13.9359
+    ],
+    [
+      15.5408,
+      15.5359
+    ],
+    [
+      15.5408,
+      17.1359
+    ],
+    [
+      15.5408,
+      18.7359
+    ],
+    [
+      15.5408,
+      20.3359
+    ],
+    [
+      15.5408,
+      21.9359
+    ],
+    [
+      15.5408,
+      23.5359
+    ],
+    [
+      15.5408,
+      25.1359
+    ],
+    [
+      15.5408,
+      26.7359
+    ],
+    [
+      15.5408,
+      28.3359
+    ],
+    [
+      15.5408,
+      29.9359
+    ],
+    [
+      15.5408,
+      39.5359
+    ],
+    [
+      15.5408,
+      41.1359
+    ],
+    [
+      15.5408,
+      42.7359
+    ],
+    [
+      15.5408,
+      44.3359
+    ],
+    [
+      15.5408,
+      45.9359
+    ],
+    [
+      15.5408,
+      47.5359
+    ],
+    [
+      15.5408,
+      49.1359
+    ],
+    [
+      15.5408,
+      50.7359
+    ],
+    [
+      15.5408,
+      60.3359
+    ],
+    [
+      15.5408,
+      61.9359
+    ],
+    [
+      15.5408,
+      63.5359
+    ],
+    [
+      15.5408,
+      65.1359
+    ],
+    [
+      15.5408,
+      66.7359
+    ],
+    [
+      15.5408,
+      68.3359
+    ],
+    [
+      15.5408,
+      69.9359
+    ],
+    [
+      15.5408,
+      71.5359
+    ],
+    [
+      15.5408,
+      73.1359
+    ],
+    [
+      17.1408,
+      5.9359
+    ],
+    [
+      17.1408,
+      7.5359
+    ],
+    [
+      17.1408,
+      9.1359
+    ],
+    [
+      17.1408,
+      10.7359
+    ],
+    [
+      17.1408,
+      12.3359
+    ],
+    [
+      17.1408,
+      13.9359
+    ],
+    [
+      17.1408,
+      15.5359
+    ],
+    [
+      17.1408,
+      17.1359
+    ],
+    [
+      17.1408,
+      18.7359
+    ],
+    [
+      17.1408,
+      21.9359
+    ],
+    [
+      17.1408,
+      23.5359
+    ],
+    [
+      17.1408,
+      25.1359
+    ],
+    [
+      17.1408,
+      26.7359
+    ],
+    [
+      17.1408,
+      28.3359
+    ],
+    [
+      17.1408,
+      29.9359
+    ],
+    [
+      17.1408,
+      39.5359
+    ],
+    [
+      17.1408,
+      41.1359
+    ],
+    [
+      17.1408,
+      42.7359
+    ],
+    [
+      17.1408,
+      47.5359
+    ],
+    [
+      17.1408,
+      49.1359
+    ],
+    [
+      17.1408,
+      50.7359
+    ],
+    [
+      17.1408,
+      52.3359
+    ],
+    [
+      17.1408,
+      58.7359
+    ],
+    [
+      17.1408,
+      60.3359
+    ],
+    [
+      17.1408,
+      61.9359
+    ],
+    [
+      17.1408,
+      63.5359
+    ],
+    [
+      17.1408,
+      65.1359
+    ],
+    [
+      17.1408,
+      66.7359
+    ],
+    [
+      17.1408,
+      68.3359
+    ],
+    [
+      17.1408,
+      69.9359
+    ],
+    [
+      17.1408,
+      71.5359
+    ],
+    [
+      17.1408,
+      73.1359
+    ],
+    [
+      17.1408,
+      74.7359
+    ],
+    [
+      18.7408,
+      5.9359
+    ],
+    [
+      18.7408,
+      7.5359
+    ],
+    [
+      18.7408,
+      9.1359
+    ],
+    [
+      18.7408,
+      10.7359
+    ],
+    [
+      18.7408,
+      12.3359
+    ],
+    [
+      18.7408,
+      13.9359
+    ],
+    [
+      18.7408,
+      15.5359
+    ],
+    [
+      18.7408,
+      17.1359
+    ],
+    [
+      18.7408,
+      23.5359
+    ],
+    [
+      18.7408,
+      25.1359
+    ],
+    [
+      18.7408,
+      26.7359
+    ],
+    [
+      18.7408,
+      28.3359
+    ],
+    [
+      18.7408,
+      29.9359
+    ],
+    [
+      18.7408,
+      37.9359
+    ],
+    [
+      18.7408,
+      39.5359
+    ],
+    [
+      18.7408,
+      41.1359
+    ],
+    [
+      18.7408,
+      49.1359
+    ],
+    [
+      18.7408,
+      50.7359
+    ],
+    [
+      18.7408,
+      52.3359
+    ],
+    [
+      18.7408,
+      53.9359
+    ],
+    [
+      18.7408,
+      58.7359
+    ],
+    [
+      18.7408,
+      60.3359
+    ],
+    [
+      18.7408,
+      61.9359
+    ],
+    [
+      18.7408,
+      63.5359
+    ],
+    [
+      18.7408,
+      65.1359
+    ],
+    [
+      18.7408,
+      66.7359
+    ],
+    [
+      18.7408,
+      68.3359
+    ],
+    [
+      18.7408,
+      69.9359
+    ],
+    [
+      18.7408,
+      71.5359
+    ],
+    [
+      18.7408,
+      73.1359
+    ],
+    [
+      18.7408,
+      74.7359
+    ],
+    [
+      20.3408,
+      5.9359
+    ],
+    [
+      20.3408,
+      7.5359
+    ],
+    [
+      20.3408,
+      9.1359
+    ],
+    [
+      20.3408,
+      10.7359
+    ],
+    [
+      20.3408,
+      12.3359
+    ],
+    [
+      20.3408,
+      13.9359
+    ],
+    [
+      20.3408,
+      15.5359
+    ],
+    [
+      20.3408,
+      17.1359
+    ],
+    [
+      20.3408,
+      23.5359
+    ],
+    [
+      20.3408,
+      25.1359
+    ],
+    [
+      20.3408,
+      26.7359
+    ],
+    [
+      20.3408,
+      29.9359
+    ],
+    [
+      20.3408,
+      31.5359
+    ],
+    [
+      20.3408,
+      37.9359
+    ],
+    [
+      20.3408,
+      39.5359
+    ],
+    [
+      20.3408,
+      41.1359
+    ],
+    [
+      20.3408,
+      49.1359
+    ],
+    [
+      20.3408,
+      52.3359
+    ],
+    [
+      20.3408,
+      53.9359
+    ],
+    [
+      20.3408,
+      55.5359
+    ],
+    [
+      20.3408,
+      58.7359
+    ],
+    [
+      20.3408,
+      60.3359
+    ],
+    [
+      20.3408,
+      61.9359
+    ],
+    [
+      20.3408,
+      63.5359
+    ],
+    [
+      20.3408,
+      65.1359
+    ],
+    [
+      20.3408,
+      66.7359
+    ],
+    [
+      20.3408,
+      68.3359
+    ],
+    [
+      20.3408,
+      69.9359
+    ],
+    [
+      20.3408,
+      71.5359
+    ],
+    [
+      20.3408,
+      73.1359
+    ],
+    [
+      20.3408,
+      74.7359
+    ],
+    [
+      21.9408,
+      5.9359
+    ],
+    [
+      21.9408,
+      7.5359
+    ],
+    [
+      21.9408,
+      9.1359
+    ],
+    [
+      21.9408,
+      10.7359
+    ],
+    [
+      21.9408,
+      12.3359
+    ],
+    [
+      21.9408,
+      13.9359
+    ],
+    [
+      21.9408,
+      15.5359
+    ],
+    [
+      21.9408,
+      17.1359
+    ],
+    [
+      21.9408,
+      25.1359
+    ],
+    [
+      21.9408,
+      29.9359
+    ],
+    [
+      21.9408,
+      31.5359
+    ],
+    [
+      21.9408,
+      39.5359
+    ],
+    [
+      21.9408,
+      47.5359
+    ],
+    [
+      21.9408,
+      49.1359
+    ],
+    [
+      21.9408,
+      53.9359
+    ],
+    [
+      21.9408,
+      55.5359
+    ],
+    [
+      21.9408,
+      57.1359
+    ],
+    [
+      21.9408,
+      58.7359
+    ],
+    [
+      21.9408,
+      60.3359
+    ],
+    [
+      21.9408,
+      61.9359
+    ],
+    [
+      21.9408,
+      63.5359
+    ],
+    [
+      21.9408,
+      65.1359
+    ],
+    [
+      21.9408,
+      66.7359
+    ],
+    [
+      21.9408,
+      68.3359
+    ],
+    [
+      21.9408,
+      69.9359
+    ],
+    [
+      21.9408,
+      71.5359
+    ],
+    [
+      21.9408,
+      73.1359
+    ],
+    [
+      21.9408,
+      74.7359
+    ],
+    [
+      23.5408,
+      5.9359
+    ],
+    [
+      23.5408,
+      7.5359
+    ],
+    [
+      23.5408,
+      9.1359
+    ],
+    [
+      23.5408,
+      10.7359
+    ],
+    [
+      23.5408,
+      12.3359
+    ],
+    [
+      23.5408,
+      13.9359
+    ],
+    [
+      23.5408,
+      15.5359
+    ],
+    [
+      23.5408,
+      17.1359
+    ],
+    [
+      23.5408,
+      31.5359
+    ],
+    [
+      23.5408,
+      42.7359
+    ],
+    [
+      23.5408,
+      45.9359
+    ],
+    [
+      23.5408,
+      47.5359
+    ],
+    [
+      23.5408,
+      57.1359
+    ],
+    [
+      23.5408,
+      58.7359
+    ],
+    [
+      23.5408,
+      60.3359
+    ],
+    [
+      23.5408,
+      61.9359
+    ],
+    [
+      23.5408,
+      63.5359
+    ],
+    [
+      23.5408,
+      65.1359
+    ],
+    [
+      23.5408,
+      66.7359
+    ],
+    [
+      23.5408,
+      68.3359
+    ],
+    [
+      23.5408,
+      69.9359
+    ],
+    [
+      23.5408,
+      71.5359
+    ],
+    [
+      23.5408,
+      73.1359
+    ],
+    [
+      25.1408,
+      7.5359
+    ],
+    [
+      25.1408,
+      9.1359
+    ],
+    [
+      25.1408,
+      10.7359
+    ],
+    [
+      25.1408,
+      12.3359
+    ],
+    [
+      25.1408,
+      13.9359
+    ],
+    [
+      25.1408,
+      15.5359
+    ],
+    [
+      25.1408,
+      17.1359
+    ],
+    [
+      25.1408,
+      31.5359
+    ],
+    [
+      25.1408,
+      33.1359
+    ],
+    [
+      25.1408,
+      42.7359
+    ],
+    [
+      25.1408,
+      45.9359
+    ],
+    [
+      25.1408,
+      57.1359
+    ],
+    [
+      25.1408,
+      58.7359
+    ],
+    [
+      25.1408,
+      60.3359
+    ],
+    [
+      25.1408,
+      61.9359
+    ],
+    [
+      25.1408,
+      63.5359
+    ],
+    [
+      25.1408,
+      65.1359
+    ],
+    [
+      25.1408,
+      66.7359
+    ],
+    [
+      25.1408,
+      68.3359
+    ],
+    [
+      25.1408,
+      69.9359
+    ],
+    [
+      25.1408,
+      71.5359
+    ],
+    [
+      25.1408,
+      73.1359
+    ],
+    [
+      25.1408,
+      74.7359
+    ],
+    [
+      26.7408,
+      9.1359
+    ],
+    [
+      26.7408,
+      10.7359
+    ],
+    [
+      26.7408,
+      12.3359
+    ],
+    [
+      26.7408,
+      13.9359
+    ],
+    [
+      26.7408,
+      15.5359
+    ],
+    [
+      26.7408,
+      17.1359
+    ],
+    [
+      26.7408,
+      18.7359
+    ],
+    [
+      26.7408,
+      31.5359
+    ],
+    [
+      26.7408,
+      33.1359
+    ],
+    [
+      26.7408,
+      42.7359
+    ],
+    [
+      26.7408,
+      44.3359
+    ],
+    [
+      26.7408,
+      45.9359
+    ],
+    [
+      26.7408,
+      58.7359
+    ],
+    [
+      26.7408,
+      60.3359
+    ],
+    [
+      26.7408,
+      61.9359
+    ],
+    [
+      26.7408,
+      63.5359
+    ],
+    [
+      26.7408,
+      65.1359
+    ],
+    [
+      26.7408,
+      66.7359
+    ],
+    [
+      26.7408,
+      68.3359
+    ],
+    [
+      26.7408,
+      69.9359
+    ],
+    [
+      26.7408,
+      71.5359
+    ],
+    [
+      26.7408,
+      73.1359
+    ],
+    [
+      26.7408,
+      74.7359
+    ],
+    [
+      26.7408,
+      76.3359
+    ],
+    [
+      28.3408,
+      10.7359
+    ],
+    [
+      28.3408,
+      12.3359
+    ],
+    [
+      28.3408,
+      13.9359
+    ],
+    [
+      28.3408,
+      15.5359
+    ],
+    [
+      28.3408,
+      17.1359
+    ],
+    [
+      28.3408,
+      18.7359
+    ],
+    [
+      28.3408,
+      20.3359
+    ],
+    [
+      28.3408,
+      31.5359
+    ],
+    [
+      28.3408,
+      33.1359
+    ],
+    [
+      28.3408,
+      42.7359
+    ],
+    [
+      28.3408,
+      44.3359
+    ],
+    [
+      28.3408,
+      45.9359
+    ],
+    [
+      28.3408,
+      47.5359
+    ],
+    [
+      28.3408,
+      60.3359
+    ],
+    [
+      28.3408,
+      61.9359
+    ],
+    [
+      28.3408,
+      63.5359
+    ],
+    [
+      28.3408,
+      65.1359
+    ],
+    [
+      28.3408,
+      66.7359
+    ],
+    [
+      28.3408,
+      68.3359
+    ],
+    [
+      28.3408,
+      69.9359
+    ],
+    [
+      28.3408,
+      71.5359
+    ],
+    [
+      28.3408,
+      73.1359
+    ],
+    [
+      28.3408,
+      74.7359
+    ],
+    [
+      28.3408,
+      76.3359
+    ],
+    [
+      29.9408,
+      10.7359
+    ],
+    [
+      29.9408,
+      12.3359
+    ],
+    [
+      29.9408,
+      13.9359
+    ],
+    [
+      29.9408,
+      15.5359
+    ],
+    [
+      29.9408,
+      18.7359
+    ],
+    [
+      29.9408,
+      20.3359
+    ],
+    [
+      29.9408,
+      21.9359
+    ],
+    [
+      29.9408,
+      23.5359
+    ],
+    [
+      29.9408,
+      25.1359
+    ],
+    [
+      29.9408,
+      26.7359
+    ],
+    [
+      29.9408,
+      33.1359
+    ],
+    [
+      29.9408,
+      34.7359
+    ],
+    [
+      29.9408,
+      42.7359
+    ],
+    [
+      29.9408,
+      44.3359
+    ],
+    [
+      29.9408,
+      47.5359
+    ],
+    [
+      29.9408,
+      49.1359
+    ],
+    [
+      29.9408,
+      60.3359
+    ],
+    [
+      29.9408,
+      61.9359
+    ],
+    [
+      29.9408,
+      63.5359
+    ],
+    [
+      29.9408,
+      65.1359
+    ],
+    [
+      29.9408,
+      66.7359
+    ],
+    [
+      29.9408,
+      68.3359
+    ],
+    [
+      29.9408,
+      69.9359
+    ],
+    [
+      29.9408,
+      71.5359
+    ],
+    [
+      29.9408,
+      73.1359
+    ],
+    [
+      29.9408,
+      74.7359
+    ],
+    [
+      29.9408,
+      76.3359
+    ],
+    [
+      29.9408,
+      77.9359
+    ],
+    [
+      31.5408,
+      10.7359
+    ],
+    [
+      31.5408,
+      12.3359
+    ],
+    [
+      31.5408,
+      13.9359
+    ],
+    [
+      31.5408,
+      21.9359
+    ],
+    [
+      31.5408,
+      23.5359
+    ],
+    [
+      31.5408,
+      25.1359
+    ],
+    [
+      31.5408,
+      26.7359
+    ],
+    [
+      31.5408,
+      33.1359
+    ],
+    [
+      31.5408,
+      34.7359
+    ],
+    [
+      31.5408,
+      42.7359
+    ],
+    [
+      31.5408,
+      49.1359
+    ],
+    [
+      31.5408,
+      50.7359
+    ],
+    [
+      31.5408,
+      57.1359
+    ],
+    [
+      31.5408,
+      58.7359
+    ],
+    [
+      31.5408,
+      60.3359
+    ],
+    [
+      31.5408,
+      61.9359
+    ],
+    [
+      31.5408,
+      63.5359
+    ],
+    [
+      31.5408,
+      65.1359
+    ],
+    [
+      31.5408,
+      66.7359
+    ],
+    [
+      31.5408,
+      68.3359
+    ],
+    [
+      31.5408,
+      69.9359
+    ],
+    [
+      31.5408,
+      71.5359
+    ],
+    [
+      31.5408,
+      73.1359
+    ],
+    [
+      31.5408,
+      74.7359
+    ],
+    [
+      31.5408,
+      76.3359
+    ],
+    [
+      33.1408,
+      10.7359
+    ],
+    [
+      33.1408,
+      12.3359
+    ],
+    [
+      33.1408,
+      23.5359
+    ],
+    [
+      33.1408,
+      25.1359
+    ],
+    [
+      33.1408,
+      26.7359
+    ],
+    [
+      33.1408,
+      28.3359
+    ],
+    [
+      33.1408,
+      33.1359
+    ],
+    [
+      33.1408,
+      34.7359
+    ],
+    [
+      33.1408,
+      42.7359
+    ],
+    [
+      33.1408,
+      47.5359
+    ],
+    [
+      33.1408,
+      49.1359
+    ],
+    [
+      33.1408,
+      50.7359
+    ],
+    [
+      33.1408,
+      55.5359
+    ],
+    [
+      33.1408,
+      57.1359
+    ],
+    [
+      33.1408,
+      58.7359
+    ],
+    [
+      33.1408,
+      60.3359
+    ],
+    [
+      33.1408,
+      61.9359
+    ],
+    [
+      33.1408,
+      63.5359
+    ],
+    [
+      33.1408,
+      65.1359
+    ],
+    [
+      33.1408,
+      66.7359
+    ],
+    [
+      33.1408,
+      68.3359
+    ],
+    [
+      33.1408,
+      69.9359
+    ],
+    [
+      33.1408,
+      71.5359
+    ],
+    [
+      33.1408,
+      73.1359
+    ],
+    [
+      33.1408,
+      74.7359
+    ],
+    [
+      33.1408,
+      76.3359
+    ],
+    [
+      34.7408,
+      10.7359
+    ],
+    [
+      34.7408,
+      12.3359
+    ],
+    [
+      34.7408,
+      25.1359
+    ],
+    [
+      34.7408,
+      26.7359
+    ],
+    [
+      34.7408,
+      28.3359
+    ],
+    [
+      34.7408,
+      33.1359
+    ],
+    [
+      34.7408,
+      34.7359
+    ],
+    [
+      34.7408,
+      42.7359
+    ],
+    [
+      34.7408,
+      47.5359
+    ],
+    [
+      34.7408,
+      49.1359
+    ],
+    [
+      34.7408,
+      50.7359
+    ],
+    [
+      34.7408,
+      52.3359
+    ],
+    [
+      34.7408,
+      53.9359
+    ],
+    [
+      34.7408,
+      55.5359
+    ],
+    [
+      34.7408,
+      57.1359
+    ],
+    [
+      34.7408,
+      61.9359
+    ],
+    [
+      34.7408,
+      66.7359
+    ],
+    [
+      34.7408,
+      68.3359
+    ],
+    [
+      34.7408,
+      73.1359
+    ],
+    [
+      34.7408,
+      74.7359
+    ],
+    [
+      34.7408,
+      76.3359
+    ],
+    [
+      36.3408,
+      10.7359
+    ],
+    [
+      36.3408,
+      12.3359
+    ],
+    [
+      36.3408,
+      25.1359
+    ],
+    [
+      36.3408,
+      26.7359
+    ],
+    [
+      36.3408,
+      33.1359
+    ],
+    [
+      36.3408,
+      34.7359
+    ],
+    [
+      36.3408,
+      36.3359
+    ],
+    [
+      36.3408,
+      45.9359
+    ],
+    [
+      36.3408,
+      47.5359
+    ],
+    [
+      36.3408,
+      49.1359
+    ],
+    [
+      36.3408,
+      50.7359
+    ],
+    [
+      36.3408,
+      52.3359
+    ],
+    [
+      36.3408,
+      53.9359
+    ],
+    [
+      36.3408,
+      55.5359
+    ],
+    [
+      36.3408,
+      68.3359
+    ],
+    [
+      36.3408,
+      73.1359
+    ],
+    [
+      36.3408,
+      74.7359
+    ],
+    [
+      36.3408,
+      76.3359
+    ],
+    [
+      36.3408,
+      77.9359
+    ],
+    [
+      37.9408,
+      10.7359
+    ],
+    [
+      37.9408,
+      12.3359
+    ],
+    [
+      37.9408,
+      25.1359
+    ],
+    [
+      37.9408,
+      34.7359
+    ],
+    [
+      37.9408,
+      36.3359
+    ],
+    [
+      37.9408,
+      45.9359
+    ],
+    [
+      37.9408,
+      47.5359
+    ],
+    [
+      37.9408,
+      49.1359
+    ],
+    [
+      37.9408,
+      50.7359
+    ],
+    [
+      37.9408,
+      52.3359
+    ],
+    [
+      37.9408,
+      53.9359
+    ],
+    [
+      37.9408,
+      74.7359
+    ],
+    [
+      37.9408,
+      76.3359
+    ],
+    [
+      37.9408,
+      77.9359
+    ],
+    [
+      39.5408,
+      10.7359
+    ],
+    [
+      39.5408,
+      12.3359
+    ],
+    [
+      39.5408,
+      34.7359
+    ],
+    [
+      39.5408,
+      36.3359
+    ],
+    [
+      39.5408,
+      41.1359
+    ],
+    [
+      39.5408,
+      45.9359
+    ],
+    [
+      39.5408,
+      47.5359
+    ],
+    [
+      39.5408,
+      49.1359
+    ],
+    [
+      39.5408,
+      50.7359
+    ],
+    [
+      39.5408,
+      52.3359
+    ],
+    [
+      39.5408,
+      53.9359
+    ],
+    [
+      39.5408,
+      76.3359
+    ],
+    [
+      39.5408,
+      77.9359
+    ],
+    [
+      41.1408,
+      10.7359
+    ],
+    [
+      41.1408,
+      12.3359
+    ],
+    [
+      41.1408,
+      34.7359
+    ],
+    [
+      41.1408,
+      36.3359
+    ],
+    [
+      41.1408,
+      37.9359
+    ],
+    [
+      41.1408,
+      39.5359
+    ],
+    [
+      41.1408,
+      44.3359
+    ],
+    [
+      41.1408,
+      45.9359
+    ],
+    [
+      41.1408,
+      47.5359
+    ],
+    [
+      41.1408,
+      49.1359
+    ],
+    [
+      41.1408,
+      50.7359
+    ],
+    [
+      41.1408,
+      52.3359
+    ],
+    [
+      41.1408,
+      53.9359
+    ],
+    [
+      41.1408,
+      76.3359
+    ],
+    [
+      41.1408,
+      77.9359
+    ],
+    [
+      42.7408,
+      10.7359
+    ],
+    [
+      42.7408,
+      12.3359
+    ],
+    [
+      42.7408,
+      34.7359
+    ],
+    [
+      42.7408,
+      36.3359
+    ],
+    [
+      42.7408,
+      37.9359
+    ],
+    [
+      42.7408,
+      39.5359
+    ],
+    [
+      42.7408,
+      44.3359
+    ],
+    [
+      42.7408,
+      45.9359
+    ],
+    [
+      42.7408,
+      47.5359
+    ],
+    [
+      42.7408,
+      49.1359
+    ],
+    [
+      42.7408,
+      50.7359
+    ],
+    [
+      42.7408,
+      52.3359
+    ],
+    [
+      42.7408,
+      53.9359
+    ],
+    [
+      42.7408,
+      76.3359
+    ],
+    [
+      42.7408,
+      77.9359
+    ],
+    [
+      44.3408,
+      10.7359
+    ],
+    [
+      44.3408,
+      12.3359
+    ],
+    [
+      44.3408,
+      34.7359
+    ],
+    [
+      44.3408,
+      36.3359
+    ],
+    [
+      44.3408,
+      37.9359
+    ],
+    [
+      44.3408,
+      39.5359
+    ],
+    [
+      44.3408,
+      44.3359
+    ],
+    [
+      44.3408,
+      45.9359
+    ],
+    [
+      44.3408,
+      47.5359
+    ],
+    [
+      44.3408,
+      49.1359
+    ],
+    [
+      44.3408,
+      50.7359
+    ],
+    [
+      44.3408,
+      52.3359
+    ],
+    [
+      44.3408,
+      53.9359
+    ],
+    [
+      44.3408,
+      76.3359
+    ],
+    [
+      44.3408,
+      77.9359
+    ],
+    [
+      45.9408,
+      9.1359
+    ],
+    [
+      45.9408,
+      10.7359
+    ],
+    [
+      45.9408,
+      12.3359
+    ],
+    [
+      45.9408,
+      13.9359
+    ],
+    [
+      45.9408,
+      34.7359
+    ],
+    [
+      45.9408,
+      36.3359
+    ],
+    [
+      45.9408,
+      39.5359
+    ],
+    [
+      45.9408,
+      41.1359
+    ],
+    [
+      45.9408,
+      45.9359
+    ],
+    [
+      45.9408,
+      47.5359
+    ],
+    [
+      45.9408,
+      49.1359
+    ],
+    [
+      45.9408,
+      50.7359
+    ],
+    [
+      45.9408,
+      52.3359
+    ],
+    [
+      45.9408,
+      53.9359
+    ],
+    [
+      45.9408,
+      76.3359
+    ],
+    [
+      45.9408,
+      77.9359
+    ],
+    [
+      47.5408,
+      9.1359
+    ],
+    [
+      47.5408,
+      10.7359
+    ],
+    [
+      47.5408,
+      12.3359
+    ],
+    [
+      47.5408,
+      25.1359
+    ],
+    [
+      47.5408,
+      26.7359
+    ],
+    [
+      47.5408,
+      34.7359
+    ],
+    [
+      47.5408,
+      36.3359
+    ],
+    [
+      47.5408,
+      41.1359
+    ],
+    [
+      47.5408,
+      45.9359
+    ],
+    [
+      47.5408,
+      47.5359
+    ],
+    [
+      47.5408,
+      49.1359
+    ],
+    [
+      47.5408,
+      50.7359
+    ],
+    [
+      47.5408,
+      52.3359
+    ],
+    [
+      47.5408,
+      53.9359
+    ],
+    [
+      47.5408,
+      76.3359
+    ],
+    [
+      47.5408,
+      77.9359
+    ],
+    [
+      49.1408,
+      9.1359
+    ],
+    [
+      49.1408,
+      10.7359
+    ],
+    [
+      49.1408,
+      23.5359
+    ],
+    [
+      49.1408,
+      25.1359
+    ],
+    [
+      49.1408,
+      26.7359
+    ],
+    [
+      49.1408,
+      34.7359
+    ],
+    [
+      49.1408,
+      36.3359
+    ],
+    [
+      49.1408,
+      41.1359
+    ],
+    [
+      49.1408,
+      47.5359
+    ],
+    [
+      49.1408,
+      49.1359
+    ],
+    [
+      49.1408,
+      50.7359
+    ],
+    [
+      49.1408,
+      52.3359
+    ],
+    [
+      49.1408,
+      53.9359
+    ],
+    [
+      49.1408,
+      74.7359
+    ],
+    [
+      49.1408,
+      76.3359
+    ],
+    [
+      49.1408,
+      77.9359
+    ],
+    [
+      50.7408,
+      9.1359
+    ],
+    [
+      50.7408,
+      10.7359
+    ],
+    [
+      50.7408,
+      23.5359
+    ],
+    [
+      50.7408,
+      25.1359
+    ],
+    [
+      50.7408,
+      26.7359
+    ],
+    [
+      50.7408,
+      28.3359
+    ],
+    [
+      50.7408,
+      29.9359
+    ],
+    [
+      50.7408,
+      31.5359
+    ],
+    [
+      50.7408,
+      34.7359
+    ],
+    [
+      50.7408,
+      36.3359
+    ],
+    [
+      50.7408,
+      41.1359
+    ],
+    [
+      50.7408,
+      42.7359
+    ],
+    [
+      50.7408,
+      47.5359
+    ],
+    [
+      50.7408,
+      49.1359
+    ],
+    [
+      50.7408,
+      50.7359
+    ],
+    [
+      50.7408,
+      52.3359
+    ],
+    [
+      50.7408,
+      53.9359
+    ],
+    [
+      50.7408,
+      55.5359
+    ],
+    [
+      50.7408,
+      73.1359
+    ],
+    [
+      50.7408,
+      74.7359
+    ],
+    [
+      50.7408,
+      76.3359
+    ],
+    [
+      52.3408,
+      9.1359
+    ],
+    [
+      52.3408,
+      10.7359
+    ],
+    [
+      52.3408,
+      23.5359
+    ],
+    [
+      52.3408,
+      25.1359
+    ],
+    [
+      52.3408,
+      26.7359
+    ],
+    [
+      52.3408,
+      28.3359
+    ],
+    [
+      52.3408,
+      29.9359
+    ],
+    [
+      52.3408,
+      31.5359
+    ],
+    [
+      52.3408,
+      33.1359
+    ],
+    [
+      52.3408,
+      34.7359
+    ],
+    [
+      52.3408,
+      36.3359
+    ],
+    [
+      52.3408,
+      39.5359
+    ],
+    [
+      52.3408,
+      41.1359
+    ],
+    [
+      52.3408,
+      42.7359
+    ],
+    [
+      52.3408,
+      47.5359
+    ],
+    [
+      52.3408,
+      49.1359
+    ],
+    [
+      52.3408,
+      50.7359
+    ],
+    [
+      52.3408,
+      52.3359
+    ],
+    [
+      52.3408,
+      53.9359
+    ],
+    [
+      52.3408,
+      55.5359
+    ],
+    [
+      52.3408,
+      57.1359
+    ],
+    [
+      52.3408,
+      58.7359
+    ],
+    [
+      52.3408,
+      63.5359
+    ],
+    [
+      52.3408,
+      65.1359
+    ],
+    [
+      52.3408,
+      71.5359
+    ],
+    [
+      52.3408,
+      73.1359
+    ],
+    [
+      52.3408,
+      74.7359
+    ],
+    [
+      52.3408,
+      76.3359
+    ],
+    [
+      53.9408,
+      9.1359
+    ],
+    [
+      53.9408,
+      15.5359
+    ],
+    [
+      53.9408,
+      21.9359
+    ],
+    [
+      53.9408,
+      23.5359
+    ],
+    [
+      53.9408,
+      25.1359
+    ],
+    [
+      53.9408,
+      26.7359
+    ],
+    [
+      53.9408,
+      28.3359
+    ],
+    [
+      53.9408,
+      29.9359
+    ],
+    [
+      53.9408,
+      31.5359
+    ],
+    [
+      53.9408,
+      33.1359
+    ],
+    [
+      53.9408,
+      34.7359
+    ],
+    [
+      53.9408,
+      39.5359
+    ],
+    [
+      53.9408,
+      41.1359
+    ],
+    [
+      53.9408,
+      42.7359
+    ],
+    [
+      53.9408,
+      47.5359
+    ],
+    [
+      53.9408,
+      49.1359
+    ],
+    [
+      53.9408,
+      50.7359
+    ],
+    [
+      53.9408,
+      52.3359
+    ],
+    [
+      53.9408,
+      57.1359
+    ],
+    [
+      53.9408,
+      58.7359
+    ],
+    [
+      53.9408,
+      60.3359
+    ],
+    [
+      53.9408,
+      61.9359
+    ],
+    [
+      53.9408,
+      63.5359
+    ],
+    [
+      53.9408,
+      65.1359
+    ],
+    [
+      53.9408,
+      66.7359
+    ],
+    [
+      53.9408,
+      71.5359
+    ],
+    [
+      53.9408,
+      73.1359
+    ],
+    [
+      53.9408,
+      74.7359
+    ],
+    [
+      55.5408,
+      9.1359
+    ],
+    [
+      55.5408,
+      10.7359
+    ],
+    [
+      55.5408,
+      13.9359
+    ],
+    [
+      55.5408,
+      15.5359
+    ],
+    [
+      55.5408,
+      17.1359
+    ],
+    [
+      55.5408,
+      18.7359
+    ],
+    [
+      55.5408,
+      20.3359
+    ],
+    [
+      55.5408,
+      21.9359
+    ],
+    [
+      55.5408,
+      23.5359
+    ],
+    [
+      55.5408,
+      25.1359
+    ],
+    [
+      55.5408,
+      26.7359
+    ],
+    [
+      55.5408,
+      28.3359
+    ],
+    [
+      55.5408,
+      29.9359
+    ],
+    [
+      55.5408,
+      31.5359
+    ],
+    [
+      55.5408,
+      33.1359
+    ],
+    [
+      55.5408,
+      34.7359
+    ],
+    [
+      55.5408,
+      37.9359
+    ],
+    [
+      55.5408,
+      39.5359
+    ],
+    [
+      55.5408,
+      41.1359
+    ],
+    [
+      55.5408,
+      42.7359
+    ],
+    [
+      55.5408,
+      44.3359
+    ],
+    [
+      55.5408,
+      47.5359
+    ],
+    [
+      55.5408,
+      49.1359
+    ],
+    [
+      55.5408,
+      50.7359
+    ],
+    [
+      55.5408,
+      52.3359
+    ],
+    [
+      55.5408,
+      58.7359
+    ],
+    [
+      55.5408,
+      60.3359
+    ],
+    [
+      55.5408,
+      61.9359
+    ],
+    [
+      55.5408,
+      63.5359
+    ],
+    [
+      55.5408,
+      65.1359
+    ],
+    [
+      55.5408,
+      66.7359
+    ],
+    [
+      55.5408,
+      68.3359
+    ],
+    [
+      55.5408,
+      69.9359
+    ],
+    [
+      55.5408,
+      71.5359
+    ],
+    [
+      55.5408,
+      73.1359
+    ],
+    [
+      55.5408,
+      74.7359
+    ],
+    [
+      57.1408,
+      9.1359
+    ],
+    [
+      57.1408,
+      10.7359
+    ],
+    [
+      57.1408,
+      12.3359
+    ],
+    [
+      57.1408,
+      13.9359
+    ],
+    [
+      57.1408,
+      15.5359
+    ],
+    [
+      57.1408,
+      17.1359
+    ],
+    [
+      57.1408,
+      18.7359
+    ],
+    [
+      57.1408,
+      20.3359
+    ],
+    [
+      57.1408,
+      21.9359
+    ],
+    [
+      57.1408,
+      26.7359
+    ],
+    [
+      57.1408,
+      28.3359
+    ],
+    [
+      57.1408,
+      29.9359
+    ],
+    [
+      57.1408,
+      31.5359
+    ],
+    [
+      57.1408,
+      33.1359
+    ],
+    [
+      57.1408,
+      37.9359
+    ],
+    [
+      57.1408,
+      39.5359
+    ],
+    [
+      57.1408,
+      41.1359
+    ],
+    [
+      57.1408,
+      42.7359
+    ],
+    [
+      57.1408,
+      44.3359
+    ],
+    [
+      57.1408,
+      45.9359
+    ],
+    [
+      57.1408,
+      47.5359
+    ],
+    [
+      57.1408,
+      60.3359
+    ],
+    [
+      57.1408,
+      61.9359
+    ],
+    [
+      57.1408,
+      63.5359
+    ],
+    [
+      57.1408,
+      65.1359
+    ],
+    [
+      57.1408,
+      66.7359
+    ],
+    [
+      57.1408,
+      68.3359
+    ],
+    [
+      57.1408,
+      69.9359
+    ],
+    [
+      57.1408,
+      71.5359
+    ],
+    [
+      57.1408,
+      73.1359
+    ],
+    [
+      58.7408,
+      7.5359
+    ],
+    [
+      58.7408,
+      9.1359
+    ],
+    [
+      58.7408,
+      10.7359
+    ],
+    [
+      58.7408,
+      12.3359
+    ],
+    [
+      58.7408,
+      13.9359
+    ],
+    [
+      58.7408,
+      15.5359
+    ],
+    [
+      58.7408,
+      17.1359
+    ],
+    [
+      58.7408,
+      18.7359
+    ],
+    [
+      58.7408,
+      20.3359
+    ],
+    [
+      58.7408,
+      21.9359
+    ],
+    [
+      58.7408,
+      29.9359
+    ],
+    [
+      58.7408,
+      31.5359
+    ],
+    [
+      58.7408,
+      37.9359
+    ],
+    [
+      58.7408,
+      39.5359
+    ],
+    [
+      58.7408,
+      41.1359
+    ],
+    [
+      58.7408,
+      42.7359
+    ],
+    [
+      58.7408,
+      44.3359
+    ],
+    [
+      58.7408,
+      45.9359
+    ],
+    [
+      58.7408,
+      58.7359
+    ],
+    [
+      58.7408,
+      60.3359
+    ],
+    [
+      58.7408,
+      61.9359
+    ],
+    [
+      58.7408,
+      63.5359
+    ],
+    [
+      58.7408,
+      65.1359
+    ],
+    [
+      58.7408,
+      66.7359
+    ],
+    [
+      58.7408,
+      68.3359
+    ],
+    [
+      58.7408,
+      69.9359
+    ],
+    [
+      58.7408,
+      71.5359
+    ],
+    [
+      60.3408,
+      7.5359
+    ],
+    [
+      60.3408,
+      9.1359
+    ],
+    [
+      60.3408,
+      10.7359
+    ],
+    [
+      60.3408,
+      12.3359
+    ],
+    [
+      60.3408,
+      13.9359
+    ],
+    [
+      60.3408,
+      15.5359
+    ],
+    [
+      60.3408,
+      17.1359
+    ],
+    [
+      60.3408,
+      18.7359
+    ],
+    [
+      60.3408,
+      20.3359
+    ],
+    [
+      60.3408,
+      21.9359
+    ],
+    [
+      60.3408,
+      23.5359
+    ],
+    [
+      60.3408,
+      29.9359
+    ],
+    [
+      60.3408,
+      31.5359
+    ],
+    [
+      60.3408,
+      36.3359
+    ],
+    [
+      60.3408,
+      37.9359
+    ],
+    [
+      60.3408,
+      39.5359
+    ],
+    [
+      60.3408,
+      41.1359
+    ],
+    [
+      60.3408,
+      42.7359
+    ],
+    [
+      60.3408,
+      44.3359
+    ],
+    [
+      60.3408,
+      58.7359
+    ],
+    [
+      60.3408,
+      60.3359
+    ],
+    [
+      60.3408,
+      63.5359
+    ],
+    [
+      60.3408,
+      65.1359
+    ],
+    [
+      60.3408,
+      66.7359
+    ],
+    [
+      60.3408,
+      68.3359
+    ],
+    [
+      60.3408,
+      69.9359
+    ],
+    [
+      60.3408,
+      71.5359
+    ],
+    [
+      61.9408,
+      10.7359
+    ],
+    [
+      61.9408,
+      12.3359
+    ],
+    [
+      61.9408,
+      13.9359
+    ],
+    [
+      61.9408,
+      15.5359
+    ],
+    [
+      61.9408,
+      17.1359
+    ],
+    [
+      61.9408,
+      18.7359
+    ],
+    [
+      61.9408,
+      20.3359
+    ],
+    [
+      61.9408,
+      21.9359
+    ],
+    [
+      61.9408,
+      23.5359
+    ],
+    [
+      61.9408,
+      25.1359
+    ],
+    [
+      61.9408,
+      29.9359
+    ],
+    [
+      61.9408,
+      33.1359
+    ],
+    [
+      61.9408,
+      34.7359
+    ],
+    [
+      61.9408,
+      36.3359
+    ],
+    [
+      61.9408,
+      37.9359
+    ],
+    [
+      61.9408,
+      39.5359
+    ],
+    [
+      61.9408,
+      41.1359
+    ],
+    [
+      61.9408,
+      42.7359
+    ],
+    [
+      61.9408,
+      57.1359
+    ],
+    [
+      61.9408,
+      58.7359
+    ],
+    [
+      61.9408,
+      60.3359
+    ],
+    [
+      61.9408,
+      63.5359
+    ],
+    [
+      61.9408,
+      65.1359
+    ],
+    [
+      61.9408,
+      66.7359
+    ],
+    [
+      61.9408,
+      68.3359
+    ],
+    [
+      61.9408,
+      69.9359
+    ],
+    [
+      63.5408,
+      9.1359
+    ],
+    [
+      63.5408,
+      10.7359
+    ],
+    [
+      63.5408,
+      12.3359
+    ],
+    [
+      63.5408,
+      13.9359
+    ],
+    [
+      63.5408,
+      15.5359
+    ],
+    [
+      63.5408,
+      17.1359
+    ],
+    [
+      63.5408,
+      18.7359
+    ],
+    [
+      63.5408,
+      20.3359
+    ],
+    [
+      63.5408,
+      21.9359
+    ],
+    [
+      63.5408,
+      23.5359
+    ],
+    [
+      63.5408,
+      25.1359
+    ],
+    [
+      63.5408,
+      33.1359
+    ],
+    [
+      63.5408,
+      34.7359
+    ],
+    [
+      63.5408,
+      36.3359
+    ],
+    [
+      63.5408,
+      37.9359
+    ],
+    [
+      63.5408,
+      39.5359
+    ],
+    [
+      63.5408,
+      41.1359
+    ],
+    [
+      63.5408,
+      42.7359
+    ],
+    [
+      63.5408,
+      57.1359
+    ],
+    [
+      63.5408,
+      58.7359
+    ],
+    [
+      63.5408,
+      65.1359
+    ],
+    [
+      63.5408,
+      66.7359
+    ],
+    [
+      63.5408,
+      68.3359
+    ],
+    [
+      63.5408,
+      69.9359
+    ],
+    [
+      63.5408,
+      71.5359
+    ],
+    [
+      65.1408,
+      7.5359
+    ],
+    [
+      65.1408,
+      9.1359
+    ],
+    [
+      65.1408,
+      10.7359
+    ],
+    [
+      65.1408,
+      12.3359
+    ],
+    [
+      65.1408,
+      13.9359
+    ],
+    [
+      65.1408,
+      15.5359
+    ],
+    [
+      65.1408,
+      17.1359
+    ],
+    [
+      65.1408,
+      18.7359
+    ],
+    [
+      65.1408,
+      20.3359
+    ],
+    [
+      65.1408,
+      21.9359
+    ],
+    [
+      65.1408,
+      23.5359
+    ],
+    [
+      65.1408,
+      25.1359
+    ],
+    [
+      65.1408,
+      31.5359
+    ],
+    [
+      65.1408,
+      33.1359
+    ],
+    [
+      65.1408,
+      34.7359
+    ],
+    [
+      65.1408,
+      36.3359
+    ],
+    [
+      65.1408,
+      37.9359
+    ],
+    [
+      65.1408,
+      39.5359
+    ],
+    [
+      65.1408,
+      41.1359
+    ],
+    [
+      65.1408,
+      42.7359
+    ],
+    [
+      65.1408,
+      57.1359
+    ],
+    [
+      65.1408,
+      58.7359
+    ],
+    [
+      65.1408,
+      60.3359
+    ],
+    [
+      65.1408,
+      65.1359
+    ],
+    [
+      65.1408,
+      66.7359
+    ],
+    [
+      65.1408,
+      68.3359
+    ],
+    [
+      65.1408,
+      69.9359
+    ],
+    [
+      66.7408,
+      7.5359
+    ],
+    [
+      66.7408,
+      9.1359
+    ],
+    [
+      66.7408,
+      10.7359
+    ],
+    [
+      66.7408,
+      12.3359
+    ],
+    [
+      66.7408,
+      13.9359
+    ],
+    [
+      66.7408,
+      15.5359
+    ],
+    [
+      66.7408,
+      17.1359
+    ],
+    [
+      66.7408,
+      18.7359
+    ],
+    [
+      66.7408,
+      20.3359
+    ],
+    [
+      66.7408,
+      21.9359
+    ],
+    [
+      66.7408,
+      23.5359
+    ],
+    [
+      66.7408,
+      25.1359
+    ],
+    [
+      66.7408,
+      31.5359
+    ],
+    [
+      66.7408,
+      33.1359
+    ],
+    [
+      66.7408,
+      34.7359
+    ],
+    [
+      66.7408,
+      36.3359
+    ],
+    [
+      66.7408,
+      37.9359
+    ],
+    [
+      66.7408,
+      39.5359
+    ],
+    [
+      66.7408,
+      41.1359
+    ],
+    [
+      66.7408,
+      42.7359
+    ],
+    [
+      66.7408,
+      58.7359
+    ],
+    [
+      66.7408,
+      60.3359
+    ],
+    [
+      66.7408,
+      61.9359
+    ],
+    [
+      66.7408,
+      66.7359
+    ],
+    [
+      66.7408,
+      68.3359
+    ],
+    [
+      68.3408,
+      7.5359
+    ],
+    [
+      68.3408,
+      9.1359
+    ],
+    [
+      68.3408,
+      10.7359
+    ],
+    [
+      68.3408,
+      12.3359
+    ],
+    [
+      68.3408,
+      13.9359
+    ],
+    [
+      68.3408,
+      15.5359
+    ],
+    [
+      68.3408,
+      17.1359
+    ],
+    [
+      68.3408,
+      18.7359
+    ],
+    [
+      68.3408,
+      20.3359
+    ],
+    [
+      68.3408,
+      21.9359
+    ],
+    [
+      68.3408,
+      23.5359
+    ],
+    [
+      68.3408,
+      25.1359
+    ],
+    [
+      68.3408,
+      31.5359
+    ],
+    [
+      68.3408,
+      33.1359
+    ],
+    [
+      68.3408,
+      34.7359
+    ],
+    [
+      68.3408,
+      36.3359
+    ],
+    [
+      68.3408,
+      37.9359
+    ],
+    [
+      68.3408,
+      39.5359
+    ],
+    [
+      68.3408,
+      41.1359
+    ],
+    [
+      68.3408,
+      42.7359
+    ],
+    [
+      68.3408,
+      44.3359
+    ],
+    [
+      68.3408,
+      58.7359
+    ],
+    [
+      68.3408,
+      60.3359
+    ],
+    [
+      68.3408,
+      61.9359
+    ],
+    [
+      68.3408,
+      66.7359
+    ],
+    [
+      68.3408,
+      68.3359
+    ],
+    [
+      69.9408,
+      9.1359
+    ],
+    [
+      69.9408,
+      10.7359
+    ],
+    [
+      69.9408,
+      12.3359
+    ],
+    [
+      69.9408,
+      13.9359
+    ],
+    [
+      69.9408,
+      15.5359
+    ],
+    [
+      69.9408,
+      17.1359
+    ],
+    [
+      69.9408,
+      18.7359
+    ],
+    [
+      69.9408,
+      20.3359
+    ],
+    [
+      69.9408,
+      21.9359
+    ],
+    [
+      69.9408,
+      23.5359
+    ],
+    [
+      69.9408,
+      25.1359
+    ],
+    [
+      69.9408,
+      31.5359
+    ],
+    [
+      69.9408,
+      33.1359
+    ],
+    [
+      69.9408,
+      34.7359
+    ],
+    [
+      69.9408,
+      36.3359
+    ],
+    [
+      69.9408,
+      37.9359
+    ],
+    [
+      69.9408,
+      39.5359
+    ],
+    [
+      69.9408,
+      41.1359
+    ],
+    [
+      69.9408,
+      42.7359
+    ],
+    [
+      69.9408,
+      44.3359
+    ],
+    [
+      69.9408,
+      60.3359
+    ],
+    [
+      69.9408,
+      61.9359
+    ],
+    [
+      69.9408,
+      63.5359
+    ],
+    [
+      71.5408,
+      7.5359
+    ],
+    [
+      71.5408,
+      9.1359
+    ],
+    [
+      71.5408,
+      10.7359
+    ],
+    [
+      71.5408,
+      12.3359
+    ],
+    [
+      71.5408,
+      13.9359
+    ],
+    [
+      71.5408,
+      18.7359
+    ],
+    [
+      71.5408,
+      20.3359
+    ],
+    [
+      71.5408,
+      21.9359
+    ],
+    [
+      71.5408,
+      23.5359
+    ],
+    [
+      71.5408,
+      25.1359
+    ],
+    [
+      71.5408,
+      29.9359
+    ],
+    [
+      71.5408,
+      31.5359
+    ],
+    [
+      71.5408,
+      34.7359
+    ],
+    [
+      71.5408,
+      36.3359
+    ],
+    [
+      71.5408,
+      37.9359
+    ],
+    [
+      71.5408,
+      39.5359
+    ],
+    [
+      71.5408,
+      41.1359
+    ],
+    [
+      71.5408,
+      42.7359
+    ],
+    [
+      71.5408,
+      44.3359
+    ],
+    [
+      71.5408,
+      58.7359
+    ],
+    [
+      71.5408,
+      60.3359
+    ],
+    [
+      71.5408,
+      61.9359
+    ],
+    [
+      71.5408,
+      63.5359
+    ],
+    [
+      73.1408,
+      7.5359
+    ],
+    [
+      73.1408,
+      9.1359
+    ],
+    [
+      73.1408,
+      10.7359
+    ],
+    [
+      73.1408,
+      12.3359
+    ],
+    [
+      73.1408,
+      21.9359
+    ],
+    [
+      73.1408,
+      23.5359
+    ],
+    [
+      73.1408,
+      25.1359
+    ],
+    [
+      73.1408,
+      29.9359
+    ],
+    [
+      73.1408,
+      34.7359
+    ],
+    [
+      73.1408,
+      36.3359
+    ],
+    [
+      73.1408,
+      37.9359
+    ],
+    [
+      73.1408,
+      39.5359
+    ],
+    [
+      73.1408,
+      41.1359
+    ],
+    [
+      73.1408,
+      42.7359
+    ],
+    [
+      73.1408,
+      44.3359
+    ],
+    [
+      73.1408,
+      58.7359
+    ],
+    [
+      73.1408,
+      60.3359
+    ],
+    [
+      74.7408,
+      7.5359
+    ],
+    [
+      74.7408,
+      9.1359
+    ],
+    [
+      74.7408,
+      10.7359
+    ],
+    [
+      74.7408,
+      12.3359
+    ],
+    [
+      74.7408,
+      21.9359
+    ],
+    [
+      74.7408,
+      23.5359
+    ],
+    [
+      74.7408,
+      25.1359
+    ],
+    [
+      74.7408,
+      29.9359
+    ],
+    [
+      74.7408,
+      34.7359
+    ],
+    [
+      74.7408,
+      36.3359
+    ],
+    [
+      74.7408,
+      37.9359
+    ],
+    [
+      74.7408,
+      39.5359
+    ],
+    [
+      74.7408,
+      41.1359
+    ],
+    [
+      74.7408,
+      42.7359
+    ],
+    [
+      74.7408,
+      44.3359
+    ],
+    [
+      74.7408,
+      58.7359
+    ],
+    [
+      74.7408,
+      60.3359
+    ],
+    [
+      74.7408,
+      61.9359
+    ],
+    [
+      76.3408,
+      9.1359
+    ],
+    [
+      76.3408,
+      10.7359
+    ],
+    [
+      76.3408,
+      21.9359
+    ],
+    [
+      76.3408,
+      23.5359
+    ],
+    [
+      76.3408,
+      25.1359
+    ],
+    [
+      76.3408,
+      29.9359
+    ],
+    [
+      76.3408,
+      34.7359
+    ],
+    [
+      76.3408,
+      36.3359
+    ],
+    [
+      76.3408,
+      37.9359
+    ],
+    [
+      76.3408,
+      39.5359
+    ],
+    [
+      76.3408,
+      41.1359
+    ],
+    [
+      76.3408,
+      44.3359
+    ],
+    [
+      77.9408,
+      20.3359
+    ],
+    [
+      77.9408,
+      21.9359
+    ],
+    [
+      77.9408,
+      23.5359
+    ],
+    [
+      77.9408,
+      25.1359
+    ],
+    [
+      77.9408,
+      36.3359
+    ],
+    [
+      77.9408,
+      37.9359
+    ],
+    [
+      77.9408,
+      39.5359
+    ],
+    [
+      77.9408,
+      44.3359
+    ],
+    [
+      79.5408,
+      20.3359
+    ],
+    [
+      79.5408,
+      21.9359
+    ],
+    [
+      79.5408,
+      23.5359
+    ]
+  ]
+}

backend/static/game_positions.json

@@ -0,0 +1,362 @@
+{
+  "starting_positions": [
+    {
+      "x": 25.57603645324707,
+      "y": 84.8847885131836,
+      "minerals": [
+        {
+          "x": 19,
+          "y": 67
+        },
+        {
+          "x": 21,
+          "y": 67
+        },
+        {
+          "x": 21,
+          "y": 66
+        },
+        {
+          "x": 21,
+          "y": 69
+        },
+        {
+          "x": 19,
+          "y": 70
+        },
+        {
+          "x": 21,
+          "y": 71
+        }
+      ],
+      "geysers": [
+        {
+          "x": 22,
+          "y": 66
+        }
+      ]
+    },
+    {
+      "x": 85.71428680419922,
+      "y": 47.096771240234375,
+      "minerals": [
+        {
+          "x": 72,
+          "y": 37
+        },
+        {
+          "x": 67,
+          "y": 36
+        },
+        {
+          "x": 68,
+          "y": 41
+        },
+        {
+          "x": 70,
+          "y": 37
+        },
+        {
+          "x": 66,
+          "y": 39
+        },
+        {
+          "x": 69,
+          "y": 41
+        },
+        {
+          "x": 70,
+          "y": 36
+        }
+      ],
+      "geysers": [
+        {
+          "x": 66,
+          "y": 37
+        }
+      ]
+    },
+    {
+      "x": 24.654376983642578,
+      "y": 13.80184268951416,
+      "minerals": [
+        {
+          "x": 21,
+          "y": 8
+        },
+        {
+          "x": 22,
+          "y": 9
+        },
+        {
+          "x": 19,
+          "y": 10
+        },
+        {
+          "x": 21,
+          "y": 10
+        },
+        {
+          "x": 20,
+          "y": 13
+        },
+        {
+          "x": 22,
+          "y": 11
+        },
+        {
+          "x": 18,
+          "y": 12
+        }
+      ],
+      "geysers": [
+        {
+          "x": 22,
+          "y": 13
+        }
+      ]
+    }
+  ],
+  "expansion_positions": [
+    {
+      "x": 81.10598754882812,
+      "y": 17.373271942138672,
+      "minerals": [
+        {
+          "x": 64,
+          "y": 11
+        },
+        {
+          "x": 66,
+          "y": 15
+        },
+        {
+          "x": 65,
+          "y": 16
+        },
+        {
+          "x": 66,
+          "y": 14
+        },
+        {
+          "x": 65,
+          "y": 15
+        },
+        {
+          "x": 63,
+          "y": 16
+        },
+        {
+          "x": 67,
+          "y": 13
+        }
+      ],
+      "geysers": [
+        {
+          "x": 67,
+          "y": 10
+        }
+      ]
+    },
+    {
+      "x": 54.838706970214844,
+      "y": 61.49769592285156,
+      "minerals": [
+        {
+          "x": 42,
+          "y": 49
+        },
+        {
+          "x": 45,
+          "y": 52
+        },
+        {
+          "x": 44,
+          "y": 48
+        },
+        {
+          "x": 44,
+          "y": 50
+        },
+        {
+          "x": 45,
+          "y": 48
+        },
+        {
+          "x": 44,
+          "y": 46
+        },
+        {
+          "x": 43,
+          "y": 47
+        }
+      ],
+      "geysers": [
+        {
+          "x": 44,
+          "y": 53
+        }
+      ]
+    },
+    {
+      "x": 76.61289978027344,
+      "y": 83.38709259033203,
+      "minerals": [
+        {
+          "x": 61,
+          "y": 68
+        },
+        {
+          "x": 61,
+          "y": 70
+        },
+        {
+          "x": 61,
+          "y": 69
+        },
+        {
+          "x": 59,
+          "y": 65
+        },
+        {
+          "x": 62,
+          "y": 64
+        },
+        {
+          "x": 60,
+          "y": 66
+        },
+        {
+          "x": 60,
+          "y": 70
+        }
+      ],
+      "geysers": [
+        {
+          "x": 65,
+          "y": 66
+        }
+      ]
+    },
+    {
+      "x": 20.967741012573242,
+      "y": 32.926265716552734,
+      "minerals": [
+        {
+          "x": 19,
+          "y": 25
+        },
+        {
+          "x": 18,
+          "y": 27
+        },
+        {
+          "x": 20,
+          "y": 26
+        },
+        {
+          "x": 16,
+          "y": 26
+        },
+        {
+          "x": 14,
+          "y": 27
+        },
+        {
+          "x": 18,
+          "y": 28
+        },
+        {
+          "x": 17,
+          "y": 23
+        }
+      ],
+      "geysers": [
+        {
+          "x": 17,
+          "y": 23
+        }
+      ]
+    },
+    {
+      "x": 67.97235107421875,
+      "y": 36.036865234375,
+      "minerals": [
+        {
+          "x": 56,
+          "y": 31
+        },
+        {
+          "x": 57,
+          "y": 29
+        },
+        {
+          "x": 54,
+          "y": 28
+        },
+        {
+          "x": 52,
+          "y": 30
+        },
+        {
+          "x": 54,
+          "y": 29
+        },
+        {
+          "x": 52,
+          "y": 27
+        },
+        {
+          "x": 53,
+          "y": 31
+        }
+      ],
+      "geysers": [
+        {
+          "x": 53,
+          "y": 33
+        }
+      ]
+    },
+    {
+      "x": 16.705068588256836,
+      "y": 57.926265716552734,
+      "minerals": [
+        {
+          "x": 16,
+          "y": 46
+        },
+        {
+          "x": 15,
+          "y": 47
+        },
+        {
+          "x": 14,
+          "y": 46
+        },
+        {
+          "x": 14,
+          "y": 48
+        },
+        {
+          "x": 12,
+          "y": 49
+        },
+        {
+          "x": 10,
+          "y": 45
+        },
+        {
+          "x": 15,
+          "y": 44
+        }
+      ],
+      "geysers": [
+        {
+          "x": 15,
+          "y": 43
+        }
+      ]
+    }
+  ]
+}

backend/static/walkable.json

@@ -356,12 +356,12 @@
         12.373571395874023
       ],
       [
-        83.61827850341797,
-        8.538786888122559
+        84.77071380615234,
+        7.241750717163086
       ],
       [
-        86.0469741821289,
-        10.200526237487793
+        87.53814697265625,
+        9.529439926147461
       ],
       [
         91.03219604492188,
@@ -380,8 +380,8 @@
         20.17096710205078
       ],
       [
-        90.77654266357422,
-        22.727489471435547
+        90.1014633178711,
+        22.626026153564453
       ],
       [
         88.7313232421875,
@@ -392,24 +392,24 @@
         26.690099716186523
       ],
       [
-        96.65654754638672,
-        25.02836036682129
+        100,
+        24.53423309326172
       ],
       [
-        98.57393646240234,
-        30.141407012939453
+        100,
+        30.92753791809082
       ],
       [
-        92.18263244628906,
-        31.547494888305664
+        92.45945739746094,
+        32.453460693359375
       ],
       [
-        83.74610137939453,
-        31.164016723632812
+        84.401611328125,
+        31.450428009033203
       ],
       [
-        77.35479736328125,
-        32.18662643432617
+        77.79100799560547,
+        33.05105209350586
       ],
       [
         72.62522888183594,
@@ -466,12 +466,12 @@
         56.21794128417969
       ],
       [
-        28.141727447509766,
-        49.187503814697266
+        29.418794631958008,
+        49.158748626708984
       ],
       [
-        25.329551696777344,
-        46.375328063964844
+        24.801074981689453,
+        45.830467224121094
       ],
       [
         16.765199661254883,
@@ -532,8 +532,8 @@
         74.11360168457031
       ],
       [
-        77.35479736328125,
-        70.40664672851562
+        79.2590103149414,
+        69.9880142211914
       ],
       [
         86.55828094482422,
@@ -564,8 +564,8 @@
         77.30925750732422
       ],
       [
-        88.22001647949219,
-        80.24925994873047
+        88.57514953613281,
+        81.07293701171875
       ],
       [
         79.01653289794922,
@@ -622,8 +622,8 @@
         65.54924774169922
       ],
       [
-        47.18782424926758,
-        67.08316802978516
+        47.70072937011719,
+        67.28649139404297
       ],
       [
         41.69129943847656,
@@ -638,20 +638,20 @@
         80.88838958740234
       ],
       [
-        45.90956115722656,
-        84.59535217285156
+        46.48517608642578,
+        85.19413757324219
       ],
       [
-        42.33042907714844,
-        88.43013000488281
+        41.934173583984375,
+        88.30909729003906
       ],
       [
         51.15043640136719,
         95.20491790771484
       ],
       [
-        58.18087387084961,
-        94.4379653930664
+        58.30870056152344,
+        94.26060485839844
       ],
       [
         62.14348220825195,
@@ -730,8 +730,8 @@
         73.98577880859375
       ],
       [
-        43.99216842651367,
-        65.03794860839844
+        43.087799072265625,
+        65.17256164550781
       ]
     ],
     [

backend/voice/command_parser.py

@@ -50,7 +50,7 @@ supply_depot, barracks, engineering_bay, refinery, factory, armory, starport
 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
+my_base, enemy_base, center, top_left, top_right, bottom_left, bottom_right, front_line{resource_zones}
 
 === ÉTAT ACTUEL DU JOUEUR ===
 {player_state}
@@ -58,9 +58,9 @@ my_base, enemy_base, center, top_left, top_right, bottom_left, bottom_right, fro
 === 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".
+- Le champ "feedback_template" est une phrase courte DANS LA MÊME LANGUE que la commande, avec des placeholders pour les infos du jeu. Placeholders possibles: {n} (nombre d'unités), {zone}, {building}, {count}, {unit}, {resource}, {summary}, {mode}, {names}, {raw}. Ex: "Déplacement de {n} unités vers {zone}." ou "État: {summary}".
+- Ajoute le champ "language" avec le code ISO de la langue: "fr", "en".
+- Si la commande est incompréhensible, génère une action "query" avec feedback_template explicatif (ex: "Je n'ai pas compris. Voici ton état: {summary}").
 
 === FORMAT DE RÉPONSE ===
 {
@@ -72,26 +72,41 @@ my_base, enemy_base, center, top_left, top_right, bottom_left, bottom_right, fro
       "count": <entier, défaut 1>,
       "unit_selector": "<valeur ou omis>",
       "target_zone": "<valeur ou omis>",
-      "resource_type": "<valeur ou omis>",
+      "resource_type": "<'minerals' ou 'gas', omis sinon>",
       "group_index": <1, 2 ou 3 pour assign_to_group, omis sinon>,
-      "unit_ids": [<liste d'ids pour assign_to_group, vide si on enchaîne après query_units>]
+      "unit_ids": []
     }
   ],
-  "feedback": "<message en français>"
+  "feedback_template": "<phrase avec placeholders {n}, {zone}, etc. dans la langue du joueur>",
+  "language": "fr"
 }
 """
 
 
-async def parse(transcription: str, player: PlayerState) -> ParsedCommand:
+async def parse(
+    transcription: str,
+    player: PlayerState,
+    resource_zones: list[str] | None = None,
+) -> ParsedCommand:
     """
     Send transcription + player state to Mistral and return parsed command.
     Falls back to a query action if parsing fails.
+    resource_zones: list of zone names like ["mineral_1", ..., "geyser_1", ...]
+    sorted by proximity to the player's base.
     """
     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())
+    if resource_zones:
+        rz_str = ", " + ", ".join(resource_zones)
+    else:
+        rz_str = ""
+    system = (
+        _SYSTEM_PROMPT
+        .replace("{player_state}", player.summary())
+        .replace("{resource_zones}", rz_str)
+    )
 
     response = await client.chat.complete_async(
         model=MISTRAL_CHAT_MODEL,
@@ -109,13 +124,64 @@ async def parse(transcription: str, player: PlayerState) -> ParsedCommand:
     try:
         data = json.loads(raw)
         actions = [GameAction(**a) for a in data.get("actions", [])]
-        feedback = data.get("feedback", "Commande reçue.")
+        language = (data.get("language") or "fr").strip().lower() or "fr"
+        if language not in ("fr", "en"):
+            language = "fr"
+        feedback_template = data.get("feedback_template") or data.get("feedback") or "{summary}"
         if not actions:
             raise ValueError("Empty actions list")
-        return ParsedCommand(actions=actions, feedback=feedback)
+        return ParsedCommand(
+            actions=actions, feedback_template=feedback_template, language=language
+        )
     except Exception as exc:
         log.warning("Failed to parse Mistral response: %s — %s", exc, raw[:200])
+        lang = _detect_language(transcription)
+        fallback_template = (
+            "I didn't understand. Here is your status: {summary}"
+            if lang == "en"
+            else "Je n'ai pas compris. Voici ton état: {summary}"
+        )
         return ParsedCommand(
             actions=[GameAction(type=ActionType.QUERY)],
-            feedback="Je n'ai pas compris cette commande. Voici ton état actuel.",
+            feedback_template=fallback_template,
+            language=lang,
         )
+
+
+def _detect_language(text: str) -> str:
+    """Heuristic: if transcription looks like English, return 'en', else 'fr'."""
+    if not text or not text.strip():
+        return "fr"
+    lower = text.lower().strip()
+    en_words = {
+        "build", "train", "attack", "move", "send", "create", "gather", "stop",
+        "patrol", "go", "select", "unit", "units", "base", "minerals", "gas",
+        "barracks", "factory", "scv", "marine", "tank", "all", "my", "the",
+    }
+    words = set(lower.split())
+    if words & en_words:
+        return "en"
+    return "fr"
+
+
+async def generate_feedback(error_key: str, language: str) -> str:
+    """
+    Call the API to generate a short feedback message for an error, in the given language.
+    error_key: e.g. "game_not_in_progress"
+    """
+    if not MISTRAL_API_KEY:
+        return "Game is not in progress." if language == "en" else "La partie n'est pas en cours."
+
+    client = Mistral(api_key=MISTRAL_API_KEY)
+    prompt = f"""Generate exactly one short sentence for a strategy game feedback.
+Context/error: {error_key}.
+Language: {language}.
+Reply with only that sentence, no quotes, no explanation."""
+    response = await client.chat.complete_async(
+        model=MISTRAL_CHAT_MODEL,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.2,
+        max_tokens=80,
+    )
+    text = (response.choices[0].message.content or "").strip()
+    return text or ("Game is not in progress." if language == "en" else "La partie n'est pas en cours.")

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

@@ -27,20 +27,21 @@ export {};
 
 declare module "$app/types" {
 	export interface AppTypes {
-		RouteId(): "/" | "/admin" | "/admin/map" | "/admin/sounds" | "/admin/sprites" | "/game";
+		RouteId(): "/" | "/admin" | "/admin/compiled-map" | "/admin/map" | "/admin/sounds" | "/admin/sprites" | "/game";
 		RouteParams(): {
 			
 		};
 		LayoutParams(): {
 			"/": Record<string, never>;
 			"/admin": Record<string, never>;
+			"/admin/compiled-map": Record<string, never>;
 			"/admin/map": Record<string, never>;
 			"/admin/sounds": Record<string, never>;
 			"/admin/sprites": Record<string, never>;
 			"/game": Record<string, never>
 		};
-		Pathname(): "/" | "/admin/map" | "/admin/sounds" | "/admin/sprites" | "/game";
+		Pathname(): "/" | "/admin/compiled-map" | "/admin/map" | "/admin/sounds" | "/admin/sprites" | "/game";
 		ResolvedPathname(): `${"" | `/${string}`}${ReturnType<AppTypes['Pathname']>}`;
-		Asset(): string & {};
+		Asset(): "/logos/elevenlabs.svg" | "/logos/huggingface.svg" | "/logos/mistral.svg" | string & {};
 	}
 }