Add real server pool, race roster overhaul, and ship energy system

Server browsing & matchmaking:
- HL2-style main menu (QUICK PLAY/SERVER SELECT/OPTIONS/PROFILE/QUIT)
  replaces the old CASUAL/RANKED tiles; RANKED removed end-to-end
  (menu, matchmaking-api's Mode.ranked queue path, MMR matching) until
  ranked is real.
- New menu/server_select.gd lists real servers from the matchmaking
  API's GET /servers and connects directly, retiring the old
  unreachable menu/server_browser.gd.
- Real game-server pool: NetworkManager.host_server() self-registers on
  boot and heartbeats every 8s with live player counts; API computes
  available/full status from player_count, and a background sweep marks
  any server offline once its heartbeat goes stale (catches a crashed
  server that never deregistered).
- Server-select rows get a live UDP ping probe (query port = game port
  + 10000) instead of trusting stale DB numbers; post-connect HUD shows
  live RTT off ENet's own peer stats.

Race roster overhaul:
- Swapped Terran/Mechanos/Vorg for the pivoted roster — Apex Dynamics,
  Inner Sphere Navy, Outer Rim Collective — each with a 3-ship
  Fighter/Gunner/Tank lineup, art cropped from concept sheets with
  background removal + orientation fixes per sheet.
- Live headcount + roster + "TEAM FULL" lock on the race-select screen,
  shared between the initial pre-spawn pick and the pause menu's live
  SELECT TEAM swap.
- Bot personalities (bots/bot_personality.gd): aggression/caution/
  accuracy/reaction/awareness traits rolled per bot instead of one
  fixed AI profile.

HUD additions:
- Player list (roster, teammates white/enemies yellow, bots flagged),
  kill feed, minimap, and explosion VFX on death.
- Health and energy now render as bars (hud/stat_bar.gd) instead of
  text in the top-left HUD.

Ship energy system:
- Per-role max energy (Fighter 100 / Gunner 150 / Tank 250), 75 energy
  per shot, flat regen (100 per 2.5s), fully server-authoritative and
  piggybacked on the existing per-tick state broadcast alongside health.
- New blue "mirrored" bar top-middle of the screen (hud/energy_bar.gd)
  whose fill drains from both edges toward the center instead of
  left-to-right.

Ship handling tuning:
- Turn rate reduced (4.0 -> 1.0 rad/s) so a quick tap no longer
  over-rotates; holding past 0.15s ramps to double speed (2.0 rad/s) for
  fast full turns, gated the same way damage already is so replay during
  reconciliation can't double-count the hold timer.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

matchmaking-api/app/main.py

@@ -9,17 +9,30 @@ from app.database import Base, async_session, engine
 from app.models import GameServer, Mode, ServerStatus
 from app.queue_manager import queue_manager
 from app.routers import matchmaking, ranks, servers, stats
+from app.routers.servers import sweep_stale_servers
 
 
-async def _seed_dev_server() -> None:
+# Three fake rows so server_select.gd has a realistic-looking list before a
+# real server pool exists (see README's "Not set up yet"). Only the first
+# port matches DEV_SEED_SERVER_IP/PORT, so it's the only one of the three
+# that's actually reachable by running a real Godot server locally — the
+# other two are display-only until real servers self-register on those
+# ports. player_count here is just the DB fallback; a live server overrides
+# it via the UDP query responder the client probes directly (see
+# spacewar/autoload/network_manager.gd).
+_DEMO_PLAYER_COUNTS = [40, 20, 10]
+
+
+async def _seed_demo_servers() -> None:
     async with async_session() as db:
-        for mode in (Mode.casual, Mode.ranked):
+        for i, player_count in enumerate(_DEMO_PLAYER_COUNTS):
+            port = settings.dev_seed_server_port + i
             existing = (
                 await db.execute(
                     select(GameServer).where(
                         GameServer.ip == settings.dev_seed_server_ip,
-                        GameServer.port == settings.dev_seed_server_port,
-                        GameServer.mode == mode,
+                        GameServer.port == port,
+                        GameServer.mode == Mode.casual,
                     )
                 )
             ).scalars().first()
@@ -27,22 +40,33 @@ async def _seed_dev_server() -> None:
                 db.add(
                     GameServer(
                         ip=settings.dev_seed_server_ip,
-                        port=settings.dev_seed_server_port,
-                        mode=mode,
+                        port=port,
+                        mode=Mode.casual,
                         status=ServerStatus.available,
+                        player_count=player_count,
+                        max_players=50,
                     )
                 )
         await db.commit()
 
 
+async def _run_stale_sweep_loop() -> None:
+    while True:
+        await asyncio.sleep(5)
+        async with async_session() as db:
+            await sweep_stale_servers(db)
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
-    await _seed_dev_server()
+    await _seed_demo_servers()
     matching_task = asyncio.create_task(queue_manager.run_matching_loop())
+    sweep_task = asyncio.create_task(_run_stale_sweep_loop())
     yield
     matching_task.cancel()
+    sweep_task.cancel()
 
 
 app = FastAPI(title="Spacewar Matchmaking API", lifespan=lifespan)