anekdotin
edcda92812
Networked play, end to end: connect, get matched, spawn, fight, respawn. Godot side: - Replace the single hardcoded Player with per-peer networked ships (MultiplayerSpawner + custom spawn_function), driven by client-side prediction with server reconciliation for movement. - Server-authoritative combat: bullets, health, death/respawn all decided by the server and broadcast to every peer over RPC. - Fix a Camera2D bug where Godot auto-promotes the first camera to ever enter the scene tree as the active one regardless of its own `current` value — with MultiplayerSpawner catch-up replication that was almost never the local player's own ship. `make_current()` on the owner's camera fixes it; property assignment doesn't reliably override the auto-claim. - Fix two "late joiner never learns already-established state" gaps (health, visibility) by folding both into the existing per-tick position broadcast instead of relying on one-shot RPCs that only reach peers already connected when they fire. - Make the 2 offered factions in team select match for every player in a match: the server decides once and clients either read it directly (server's own instance) or request it over RPC, rather than each client rolling its own random pair. - New MatchmakingClient autoload wires the main menu's CASUAL/RANKED buttons to the matchmaking API instead of connecting directly. New matchmaking-api/ (FastAPI + Postgres, Docker Compose): - Queue/match/stats/ranks endpoints. In-memory matchmaking queue in a single API process — no Redis until there's an actual reason to shard the queue across instances. - Background loop forms a match once enough players are queued for a mode, assigns the first available registered game server. - No real server pool yet: one dev server is auto-seeded from DEV_SEED_SERVER_IP/PORT; POST /servers/register exists for real servers to self-register later but nothing calls it yet. Docs: CLAUDE.md and overview/tech.md updated to match — networking checklist mostly checked off, matchmaking backend section rewritten to describe what was actually built vs. the original Go/Redis plan, and Current Tasks reordered around what's actually left (bot fill, real server pool, ranked/MMR refinement, lag compensation). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
45 lines
1.5 KiB
Python
45 lines
1.5 KiB
Python
from datetime import datetime
|
|
|
|
from fastapi import APIRouter, Depends
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.database import get_db
|
|
from app.models import GameServer, ServerStatus
|
|
from app.schemas import ServerRegisterRequest
|
|
|
|
router = APIRouter(prefix="/servers", tags=["servers"])
|
|
|
|
|
|
# Real game servers should call this on boot and periodically (heartbeat) once
|
|
# NetworkManager grows that integration. Until then, a dev server is seeded
|
|
# on API startup (see main.py) from DEV_SEED_SERVER_IP/PORT so matchmaking is
|
|
# testable end-to-end without it.
|
|
@router.post("/register")
|
|
async def register_server(req: ServerRegisterRequest, db: AsyncSession = Depends(get_db)) -> dict:
|
|
existing = (
|
|
await db.execute(select(GameServer).where(GameServer.ip == req.ip, GameServer.port == req.port, GameServer.mode == req.mode))
|
|
).scalars().first()
|
|
if existing:
|
|
existing.status = ServerStatus.available
|
|
existing.last_heartbeat = datetime.utcnow()
|
|
else:
|
|
db.add(GameServer(ip=req.ip, port=req.port, mode=req.mode, status=ServerStatus.available))
|
|
await db.commit()
|
|
return {"status": "registered"}
|
|
|
|
|
|
@router.get("")
|
|
async def list_servers(db: AsyncSession = Depends(get_db)) -> list[dict]:
|
|
servers = (await db.execute(select(GameServer))).scalars().all()
|
|
return [
|
|
{
|
|
"ip": s.ip,
|
|
"port": s.port,
|
|
"mode": s.mode,
|
|
"status": s.status,
|
|
"last_heartbeat": s.last_heartbeat,
|
|
}
|
|
for s in servers
|
|
]
|