Upload folder using huggingface_hub

app.py

@@ -7,6 +7,7 @@ import os
 import re
 import secrets
 from pathlib import Path
+from typing import Optional
 
 import uvicorn
 import httpx
@@ -29,7 +30,7 @@ mimetypes.add_type("model/gltf+json", ".gltf")
 class ClaimBody(BaseModel):
     username: str = Field(..., min_length=1)
     seat: str = Field(..., min_length=1)
-    avatarUrl: str | None = None
+    avatarUrl: Optional[str] = None
 
 
 class LeaveBody(BaseModel):

lobbies.py

@@ -104,8 +104,11 @@ class LobbyBoard:
         if lobby and lobby["seats"].get(seat) == username:
             lobby["seats"][seat] = None
             lobby.get("_avatars", {}).pop(username, None)
+            lobby.get("_hb", {}).pop(username, None)
             lobby["last_change"] = _now()
-            if lobby["status"] == "live" and not any(lobby["seats"].values()):
+            # Empty live/starting lobby must reset — otherwise match_id lingers
+            # and the next WS wait loop "starts" a ghost match with no players.
+            if lobby["status"] in ("live", "starting") and not any(lobby["seats"].values()):
                 self._reset_lobby(lobby)
 
     def _reset_lobby(self, lobby: dict[str, Any]) -> None:
@@ -138,8 +141,8 @@ class LobbyBoard:
             return {"ok": False, "error": "lobby not found"}
         if seat not in lobby["seats"]:
             return {"ok": False, "error": "invalid seat"}
-        if lobby["status"] == "live":
-            return {"ok": False, "error": "match already live"}
+        if lobby["status"] in ("live", "starting"):
+            return {"ok": False, "error": "match already starting"}
         if lobby["seats"][seat] is not None:
             return {"ok": False, "error": "seat taken"}
 
@@ -183,7 +186,9 @@ class LobbyBoard:
                 stale_users.append(username)
                 continue
             hb = lobby.get("_hb", {}).get(username, lobby["last_change"])
-            if now - hb > SEAT_STALE_SEC and lobby["status"] != "live":
+            # Protect both live AND starting — otherwise both seats get wiped
+            # in the window between "lobby full" and match_start / mark_live.
+            if now - hb > SEAT_STALE_SEC and lobby["status"] not in ("live", "starting"):
                 stale_users.append(username)
         for u in stale_users:
             self._clear_user(u)

relay.py

@@ -115,10 +115,19 @@ async def handle_match_ws(
     for _ in range(180):
         lobby = board.get(lobby_id)
         if lobby and not spectate:
+            # Keep seat alive while parked in the wait loop (HTTP HB can lag).
+            board.heartbeat(username)
             board._maybe_start(lobby)
             lobby = board.get(lobby_id)
+            # Seat was wiped (stale / leave) — stop waiting instead of crashing later.
+            if not board.by_user.get(username) or board.by_user.get(username)[0] != lobby_id:
+                await ws.send_text(json.dumps({"type": "error", "error": "seat lost — rejoin lobby"}))
+                await ws.close()
+                return
         if lobby and lobby.get("match_id") and lobby["status"] in ("starting", "live"):
-            break
+            # Only proceed if this player is still seated (or spectating).
+            if spectate or (board.by_user.get(username) and board.by_user[username][0] == lobby_id):
+                break
         if spectate and lobby and lobby["status"] == "open" and not lobby.get("match_id"):
             await ws.send_text(
                 json.dumps({"type": "waiting", "lobby": board._public(lobby), "spectating": True})
@@ -139,13 +148,25 @@ async def handle_match_ws(
         return
 
     lobby = board.get(lobby_id)
-    assert lobby and lobby["match_id"]
+    if not lobby or not lobby.get("match_id"):
+        await ws.send_text(json.dumps({"type": "error", "error": "lobby reset — rejoin"}))
+        await ws.close()
+        return
+
+    seat = None
+    if not spectate:
+        seat_info = board.by_user.get(username)
+        if not seat_info or seat_info[0] != lobby_id:
+            await ws.send_text(json.dumps({"type": "error", "error": "not seated in lobby"}))
+            await ws.close()
+            return
+        seat = seat_info[1]
+
     match_id = lobby["match_id"]
     room = await get_or_create_room(lobby_id, mode, match_id)
     await room.add(username, ws, spectate=spectate)
 
     players = board.players_in(lobby_id)
-    seat = None if spectate else board.by_user[username][1]
     start_payload = {
         "type": "match_start",
         "matchId": match_id,
@@ -197,14 +218,20 @@ async def handle_match_ws(
     finally:
         await room.remove(username, ws, spectate=spectate)
         if not spectate:
-            board.leave(username)
-            await room.broadcast(
-                {
-                    "type": "player_left",
-                    "username": username,
-                    "players": board.players_in(lobby_id),
-                }
-            )
+            # HF WS often blips right at match_start. Instant leave was wiping BOTH
+            # seats and bootstrapping players back to an empty lobby.
+            await asyncio.sleep(3.0)
+            still = board.by_user.get(username)
+            reconnected = username in room.clients
+            if still and still[0] == lobby_id and not reconnected:
+                board.leave(username)
+                await room.broadcast(
+                    {
+                        "type": "player_left",
+                        "username": username,
+                        "players": board.players_in(lobby_id),
+                    }
+                )
         async with rooms_lock:
             if room.lobby_id == lobby_id and not room.clients and not room.spectators:
                 rooms.pop(f"{mode}:{lobby_id}", None)

www/index.html

@@ -87,6 +87,6 @@
     }
   }
   </script>
-  <script type="module" src="js/main.js?v=39"></script>
+  <script type="module" src="js/main.js?v=44"></script>
 </body>
 </html>

www/js/collision.js

@@ -143,26 +143,205 @@ export class CollisionWorld {
   }
 
   dropToGround(x, z, box) {
-    const feet = new THREE.Vector3(x, box.max.y + DROP_HEIGHT, z);
-    const state = { velocityY: 0, onGround: false };
+    return this.dropFromAbove(x, z, box, DROP_HEIGHT);
+  }
+
+  /**
+   * Start `metersAbove` over the floor under (x,z) (or over map top if unknown),
+   * then run the same vertical settle as gameplay gravity until onGround.
+   * Spirals outward if that XZ is a pit/gap so someone still lands on real floor.
+   */
+  dropFromAbove(x, z, box, metersAbove = 12) {
+    const tryOne = (px, pz) => {
+      const groundY = this.findWalkableGroundY(px, pz, box.max.y + DROP_HEIGHT);
+      const startY = (groundY != null ? groundY : box.max.y) + metersAbove;
+      const feet = new THREE.Vector3(px, startY, pz);
+      const state = { velocityY: 0, onGround: false };
+
+      for (let i = 0; i < 2000; i += 1) {
+        state.velocityY -= 28 * (1 / 60);
+        this.moveVertical(feet, state.velocityY, 1 / 60, state);
+        if (state.onGround) break;
+        // Fell through the world — abort this XZ.
+        if (feet.y < box.min.y - 5) {
+          state.onGround = false;
+          break;
+        }
+      }
 
-    for (let i = 0; i < 1000; i += 1) {
-      state.velocityY -= 28 * (1 / 60);
-      this.moveVertical(feet, state.velocityY, 1 / 60, state);
-      if (state.onGround) break;
+      if (!state.onGround) {
+        const y = this.findWalkableGroundY(px, pz, box.max.y + DROP_HEIGHT);
+        if (y == null) return null;
+        feet.y = y;
+        state.onGround = true;
+      }
+
+      this.snapToGroundSkin(feet);
+      if (this.probeGround(feet) == null) return null;
+      if (this.intersectsWalls(feet)) return null;
+      return feet;
+    };
+
+    const direct = tryOne(x, z);
+    if (direct) return direct;
+
+    // Pit / gap under the pick — walk outward until a real landing.
+    for (let ring = 1; ring <= 14; ring += 1) {
+      const step = ring * 2.5;
+      const samples = [
+        [x + step, z],
+        [x - step, z],
+        [x, z + step],
+        [x, z - step],
+        [x + step, z + step],
+        [x - step, z + step],
+        [x + step, z - step],
+        [x - step, z - step],
+      ];
+      for (const [px, pz] of samples) {
+        const feet = tryOne(px, pz);
+        if (feet) return feet;
+      }
     }
 
-    if (!state.onGround) {
-      const y = this.findWalkableGroundY(x, z, box.max.y + DROP_HEIGHT);
-      feet.y = y ?? box.max.y;
-      state.onGround = true;
+    // Absolute last resort: known map drop candidates near box min corner.
+    return (
+      tryOne(box.min.x + SPAWN_INSET_X, box.min.z + SPAWN_INSET_Z)
+      || new THREE.Vector3(x, box.max.y, z)
+    );
+  }
+
+  /**
+   * Min distance to a non-walkable surface (walls) around the body.
+   * Used to reject spawns hugging walls / outside-map shells.
+   */
+  wallClearance(feet, maxDist = 2.8) {
+    let minClear = maxDist;
+    const heights = [
+      feet.y + BODY_PROBE_MIN_Y,
+      feet.y + PLAYER_HEIGHT * 0.55,
+      feet.y + PLAYER_HEIGHT - PLAYER_RADIUS,
+    ];
+    for (const y of heights) {
+      for (const dir of HORIZONTAL_DIRS) {
+        this.origin.set(feet.x, y, feet.z);
+        this.raycaster.set(this.origin, dir);
+        this.raycaster.far = maxDist;
+        const hits = this.raycaster.intersectObjects(this.meshes, false);
+        let hitDist = maxDist;
+        for (const hit of hits) {
+          if (isWalkableHit(hit)) continue;
+          hitDist = hit.distance;
+          break;
+        }
+        minClear = Math.min(minClear, hitDist);
+      }
     }
+    return minClear;
+  }
 
-    this.snapToGroundSkin(feet);
-    this.clampToBounds(feet);
+  /**
+   * Strict spawn probe: walkable floor, open interior (not in/near walls), not void.
+   */
+  tryValidFeet(x, z, box, { minClearance = PLAYER_RADIUS + 0.85 } = {}) {
+    const y = this.findWalkableGroundY(x, z, box.max.y + DROP_HEIGHT);
+    if (y == null) return null;
+    const feet = new THREE.Vector3(x, y, z);
+    // Do NOT clamp toward AABB edges — those edges are often outside playable geometry.
+    if (this.bounds) {
+      if (
+        feet.x < this.bounds.minX + 1.5
+        || feet.x > this.bounds.maxX - 1.5
+        || feet.z < this.bounds.minZ + 1.5
+        || feet.z > this.bounds.maxZ - 1.5
+      ) {
+        return null;
+      }
+    }
+    if (this.intersectsWalls(feet)) return null;
+    if (this.probeGround(feet) == null) return null;
+    const clear = this.wallClearance(feet);
+    if (clear < minClearance) return null;
+    // Neighbor pads must also be walkable (rejects thin ledges / wall lips).
+    for (const dir of HORIZONTAL_DIRS) {
+      const nx = feet.x + dir.x * 0.55;
+      const nz = feet.z + dir.z * 0.55;
+      if (this.findWalkableGroundY(nx, nz, box.max.y + DROP_HEIGHT) == null) return null;
+    }
+    feet.clearance = clear;
     return feet;
   }
 
+  /**
+   * Grid-scan for open interior floors only. Farthest-point among high-clearance
+   * candidates — never prefer raw AABB corners (those hug walls / out-of-map boxes).
+   */
+  collectSpreadSpawns(box, count = 8) {
+    const step = 2.75;
+    // Pull well inside the AABB — outer shell of Dust2 is walls / void / props.
+    const edge = 16;
+    const minX = (this.bounds?.minX ?? box.min.x) + edge;
+    const maxX = (this.bounds?.maxX ?? box.max.x) - edge;
+    const minZ = (this.bounds?.minZ ?? box.min.z) + edge;
+    const maxZ = (this.bounds?.maxZ ?? box.max.z) - edge;
+    if (minX >= maxX || minZ >= maxZ) return [];
+
+    const raw = [];
+    for (let x = minX; x <= maxX; x += step) {
+      for (let z = minZ; z <= maxZ; z += step) {
+        const feet = this.tryValidFeet(x, z, box);
+        if (feet) raw.push(feet);
+      }
+    }
+    if (!raw.length) {
+      // Relax clearance once if the map is tight.
+      for (let x = minX; x <= maxX; x += step) {
+        for (let z = minZ; z <= maxZ; z += step) {
+          const feet = this.tryValidFeet(x, z, box, { minClearance: PLAYER_RADIUS + 0.45 });
+          if (feet) raw.push(feet);
+        }
+      }
+    }
+    if (!raw.length) return [];
+
+    const ys = raw.map((p) => p.y).sort((a, b) => a - b);
+    const medianY = ys[Math.floor(ys.length / 2)];
+    let pool = raw.filter((p) => Math.abs(p.y - medianY) <= 3.5);
+    if (pool.length < count) pool = raw;
+
+    // Keep the open-est half so farthest-point can't run to wall-hugging extremes.
+    pool.sort((a, b) => (b.clearance ?? 0) - (a.clearance ?? 0));
+    const open = pool.slice(0, Math.max(count * 4, Math.ceil(pool.length * 0.45)));
+
+    // Seed with the most open point (interior), not a corner.
+    const picked = [open[0].clone()];
+    picked[0].clearance = open[0].clearance;
+    while (picked.length < count && picked.length < open.length) {
+      let best = null;
+      let bestScore = -1;
+      for (const c of open) {
+        let minD = Infinity;
+        for (const p of picked) {
+          const dx = c.x - p.x;
+          const dz = c.z - p.z;
+          minD = Math.min(minD, dx * dx + dz * dz);
+        }
+        // Clearance bonus so we don't pick a far-but-cramped alley.
+        const clear = c.clearance ?? 0;
+        const score = minD + clear * clear * 4;
+        if (score > bestScore) {
+          bestScore = score;
+          best = c;
+        }
+      }
+      if (!best || bestScore < 4) break;
+      const next = best.clone();
+      next.clearance = best.clearance;
+      picked.push(next);
+    }
+    return picked;
+  }
+
   findWalkableGroundY(x, z, fromY) {
     this.origin.set(x, fromY, z);
     this.raycaster.set(this.origin, this.down);

www/js/controls.js

@@ -135,38 +135,42 @@ export class PlayerController {
   }
 
   update(delta) {
-    if (!this.enabled || !this.pointerLocked) return;
-
-    this.timeSinceMouseMove += delta;
-
-    const sprinting = this.keys.has('ShiftLeft') || this.keys.has('ShiftRight');
-    const speed = MOVE_SPEED * (sprinting ? SPRINT_MULT : 1);
+    if (!this.enabled) return;
 
-    this.direction.set(-this.moveInput.right, 0, this.moveInput.forward);
-    if (this.direction.lengthSq() > 0) {
-      this.direction.normalize();
-    }
+    // Gravity always runs while enabled so a mid-air spawn still lands before click-lock.
+    // Movement / jump only with pointer lock.
+    if (this.pointerLocked) {
+      this.timeSinceMouseMove += delta;
 
-    const forward = this.getCameraForward(new THREE.Vector3());
-    const right = new THREE.Vector3().crossVectors(new THREE.Vector3(0, 1, 0), forward).normalize();
-    const wish = new THREE.Vector3()
-      .addScaledVector(forward, this.direction.z)
-      .addScaledVector(right, this.direction.x);
+      const sprinting = this.keys.has('ShiftLeft') || this.keys.has('ShiftRight');
+      const speed = MOVE_SPEED * (sprinting ? SPRINT_MULT : 1);
 
-    if (wish.lengthSq() > 0) {
-      wish.normalize().multiplyScalar(speed * delta);
-      this.collisionWorld.moveAndSlide(this.position, wish);
+      this.direction.set(-this.moveInput.right, 0, this.moveInput.forward);
+      if (this.direction.lengthSq() > 0) {
+        this.direction.normalize();
+      }
 
-      if (this.isMouseIdle()) {
-        this.characterYaw = Math.atan2(wish.x, wish.z);
+      const forward = this.getCameraForward(new THREE.Vector3());
+      const right = new THREE.Vector3().crossVectors(new THREE.Vector3(0, 1, 0), forward).normalize();
+      const wish = new THREE.Vector3()
+        .addScaledVector(forward, this.direction.z)
+        .addScaledVector(right, this.direction.x);
+
+      if (wish.lengthSq() > 0) {
+        wish.normalize().multiplyScalar(speed * delta);
+        this.collisionWorld.moveAndSlide(this.position, wish);
+
+        if (this.isMouseIdle()) {
+          this.characterYaw = Math.atan2(wish.x, wish.z);
+        }
+      } else if (!this.isMouseIdle()) {
+        this.characterYaw = this.cameraYaw;
       }
-    } else if (!this.isMouseIdle()) {
-      this.characterYaw = this.cameraYaw;
-    }
 
-    if (this.onGround && this.keys.has('Space')) {
-      this.velocityY = JUMP_VELOCITY;
-      this.onGround = false;
+      if (this.onGround && this.keys.has('Space')) {
+        this.velocityY = JUMP_VELOCITY;
+        this.onGround = false;
+      }
     }
 
     this.velocityY -= GRAVITY * delta;

www/js/main.js

@@ -1,13 +1,13 @@
 import * as THREE from 'three';
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
-import { PlayerController } from './controls.js';
+import { PlayerController } from './controls.js?v=2';
 import { InteractableManager } from './interactables.js';
-import { setupMapCollision, dropSpawnFromCorner, CollisionWorld, PLAYER_HEIGHT } from './collision.js';
+import { setupMapCollision, dropSpawnFromCorner, CollisionWorld, PLAYER_HEIGHT } from './collision.js?v=4';
 import { WeatherSystem } from './weather.js';
 import { Minimap, collectMapMeshes } from './minimap.js?v=10';
 import { WeaponSystem } from './weapons.js?v=29';
 import { GameMenu } from './ui-menu.js?v=35';
-import { NetClient, SPAWN_OFFSETS } from './net.js?v=35';
+import { NetClient, SPAWN_OFFSETS } from './net.js?v=36';
 import { SpectatorController } from './spectator.js?v=35';
 
 const DAMAGE_VIGNETTE_SEC = 2;
@@ -163,6 +163,10 @@ function setStatus(text) {
 let bootComplete = false;
 let gameplayActive = false;
 let baseSpawn = new THREE.Vector3();
+/** Full map AABB — needed so spawn offsets can drop-to-ground at new XZ. */
+let mapBoundsBox = new THREE.Box3();
+/** Precomputed on-floor spawns (opposite corners etc). Index 0 = T-ish, 1 = CT-ish. */
+let spawnPoints = [];
 
 window.addEventListener('error', (event) => {
   console.error(event.error || event.message);
@@ -262,6 +266,10 @@ const net = new NetClient({
   onLobbyUpdate: (board, mode, error = null) => {
     menu.renderBoard(board, mode, error);
   },
+  onMatchConnectionLost: () => {
+    exitGameplayToMenu();
+    setStatus('Match connection lost — lobby seats were freed. Rejoin.');
+  },
 });
 
 const spectator = new SpectatorController({
@@ -472,14 +480,31 @@ function initWeapons() {
   if (ammoHud) ammoHud.textContent = weapons.getAmmoDisplay();
 }
 
+/** Drop-in height (meters) above floor before settle — same gravity path for every seat. */
+const SPAWN_DROP_METERS = 12;
+
 function applySpawn(spawnIndex) {
-  if (!player) return;
-  const off = SPAWN_OFFSETS[spawnIndex % SPAWN_OFFSETS.length];
-  player.setPosition(baseSpawn.x + off.x, baseSpawn.y, baseSpawn.z + off.z);
+  if (!player || !collisionWorld) return;
+  let x = baseSpawn.x;
+  let z = baseSpawn.z;
+  if (spawnPoints.length) {
+    const i = ((spawnIndex % spawnPoints.length) + spawnPoints.length) % spawnPoints.length;
+    x = spawnPoints[i].x;
+    z = spawnPoints[i].z;
+  }
+  // Everyone: start SPAWN_DROP_METERS above ground at this XZ, then land with drop sim.
+  const feet = collisionWorld.dropFromAbove(x, z, mapBoundsBox, SPAWN_DROP_METERS);
+  player.position.set(feet.x, feet.y, feet.z);
+  player.velocityY = 0;
+  player.onGround = true;
 }
 
 function enterGameplay(info) {
-  if (!player || !mapLoaded) return;
+  // Match can start before map/player boot finishes — wait instead of no-op (blank screen).
+  if (!player || !mapLoaded) {
+    requestAnimationFrame(() => enterGameplay(info));
+    return;
+  }
   const spectating = !!info.spectating || !net.playAllowed || net.host === 'space';
   net.spectating = spectating;
 
@@ -652,18 +677,26 @@ mapLoader.load(
       scene.add(mapRoot);
 
       const mapBox = new THREE.Box3().setFromObject(mapRoot);
+      mapBoundsBox.copy(mapBox);
       const collisionMeshes = setupMapCollision(mapRoot);
       collisionWorld = new CollisionWorld(collisionMeshes);
       collisionWorld.setBounds(mapBox);
       const spawn = dropSpawnFromCorner(mapRoot, collisionWorld);
       baseSpawn.set(spawn.x, spawn.y, spawn.z);
+      spawnPoints = collisionWorld.collectSpreadSpawns(mapBox, 8);
+      if (!spawnPoints.length) {
+        // Last resort: only keep corner drop if it passes interior clearance.
+        const safe = collisionWorld.tryValidFeet(spawn.x, spawn.z, mapBox);
+        spawnPoints = [safe || spawn.clone()];
+      }
+      baseSpawn.copy(spawnPoints[0]);
       mapHitMeshes = collectMapMeshes(mapRoot);
 
       setStatus('Building minimap…');
       minimap.bake(collectMapMeshes(mapRoot), mapBox);
 
       player = new PlayerController(renderer.domElement, collisionWorld);
-      player.setPosition(spawn.x, spawn.y, spawn.z);
+      player.setPosition(spawnPoints[0].x, spawnPoints[0].y, spawnPoints[0].z);
       // Do not enable until match / menu chooses play
 
       interactables = new InteractableManager(scene, mapRoot);

www/js/net.js

@@ -16,12 +16,13 @@ function wsUrl(spaceUrl, mode, lobbyId, username, role = 'play') {
 }
 
 export class NetClient {
-  constructor({ scene, onStatus, onMatchStart, onMatchEnd, onLobbyUpdate }) {
+  constructor({ scene, onStatus, onMatchStart, onMatchEnd, onLobbyUpdate, onMatchConnectionLost }) {
     this.scene = scene;
     this.onStatus = onStatus || (() => {});
     this.onMatchStart = onMatchStart || (() => {});
     this.onMatchEnd = onMatchEnd || (() => {});
     this.onLobbyUpdate = onLobbyUpdate || (() => {});
+    this.onMatchConnectionLost = onMatchConnectionLost || (() => {});
 
     this.username = null;
     this.avatarUrl = null;
@@ -216,9 +217,15 @@ export class NetClient {
     };
 
     ws.onclose = () => {
-      if (this.ws === ws) {
-        this.inMatch = false;
-        this.onStatus('Match connection closed');
+      if (this.ws !== ws) return;
+      const wasInMatch = this.inMatch;
+      const wasSpectating = this.spectating;
+      this.ws = null;
+      this.inMatch = false;
+      this.onStatus('Match connection closed');
+      // Don't leave the user on a black gameplay canvas with an empty lobby.
+      if (wasInMatch || wasSpectating) {
+        this.onMatchConnectionLost({ wasInMatch, wasSpectating });
       }
     };
 
@@ -228,17 +235,18 @@ export class NetClient {
   }
 
   disconnectMatch(clearGhosts = true) {
-    if (this.ws) {
+    const ws = this.ws;
+    this.ws = null; // prevent onclose from treating intentional close as a drop
+    this.inMatch = false;
+    this.matchId = null;
+    this.spectating = false;
+    if (ws) {
       try {
-        this.ws.close();
+        ws.close();
       } catch {
         // ignore
       }
     }
-    this.ws = null;
-    this.inMatch = false;
-    this.matchId = null;
-    this.spectating = false;
     if (clearGhosts) this.ghosts.clear();
   }
 
@@ -256,6 +264,14 @@ export class NetClient {
     }
     if (type === 'error') {
       this.onStatus(msg.error || 'Server error');
+      // Fatal seat/match errors — drop the socket so UI can recover.
+      if (/seat|seated|rejoin|lobby reset|match did not start/i.test(msg.error || '')) {
+        try {
+          this.ws?.close();
+        } catch {
+          // ignore
+        }
+      }
       return;
     }
     if (type === 'match_start') {