anekdotin
be5c41f82f
Match phases (autoload/match_manager.gd, world/game_modes/):
- New server-authoritative MatchManager loops PRE_MATCH (30s countdown,
ships held invisible/uncollidable, flagships creep into formation) ->
IN_PROGRESS (active GameMode's clock runs) -> POST_MATCH (winner
banner, result reported to matchmaking-api) -> back to a fresh
PRE_MATCH forever, matching the always-on server-pool model instead
of kicking players to the menu at match end.
- Win-condition logic lives in a new GameMode abstraction (game_mode.gd
base + team_deathmatch_mode.gd, the only mode so far) so a future
mode is a new subclass plus one factory branch, no timer/scoreboard/
banner code changes needed.
- Three new HUD pieces: match_timer.gd (countdown/clock), scoreboard.gd
(hold-Tab two-team panel), match_banner.gd (winner banner).
- New MatchStats autoload tracks per-match kills/deaths by peer_id
(including bots), hooked into kill_feed_manager's existing
report_kill() call site.
Persistent stats (matchmaking-api/):
- Player gains kills/deaths/hours_played columns; new
POST /matches/report endpoint (server-only, called once at
POST_MATCH) upserts each real player's totals by callsign via a
shared app/crud.py helper also used by the matchmaking-queue join
path. GET /stats/{callsign} returns the new fields alongside mmr/
wins/losses.
Capital-ship fleet polish (world/flagship.gd, world/world.gd,
ships/ship_movement.gd, autoload/game_config.gd):
- Flagship formations are now a clean vertical line (no per-ship
position/rotation jitter) so play_creep_in()'s rigid-group tween
reads as one disciplined fleet arriving together, rising from
directly below (not a random compass direction) over the full 30s
countdown.
- Fixed a real bug where the creep-in tween only ever played on the
server -- MatchManager._run_pre_match() called straight into World,
server-only code a remote client's own process never runs, leaving
their flagships static all match. World now triggers it off
MatchManager.phase_changed instead, which fires identically on every
peer.
- Fixed a second bug (only reachable on a fresh server boot's very
first spawn): a phase==PRE_MATCH check that's true even before the
match loop has genuinely started that phase for the first time fired
play_creep_in() with a bogus zero-duration tween, corrupting the
target the real 30s tween read moments later -- flagships would
settle 4000 units off from their intended formation slot and fire
from there instead. Guarded on get_remaining_seconds() > 0 too.
- The held ship's camera now actively tracks its own team's flagship
centroid every tick during the countdown (position_smoothing
disabled for the hold, since it fights a manually-driven target and
was the reason the fleet read as invisible) instead of sitting fixed
and wide-angle; local offset/zoom/smoothing are explicitly reset on
release so control handback doesn't inherit a stale camera transform.
- _apply_pre_match_hold()/_apply_respawn() now set _dead/
_held_for_pre_match inside the RPC itself, not just in the
server-only caller -- those flags never reached remote clients
before, so WASD wasn't actually blocked for them during the hold.
- Ships now launch from a narrow point directly beneath their own
flagship formation instead of a full-circle scatter around the spawn
marker (which could land a spawn behind/inside a hull). Bumped
flagship_defense_radius so it still comfortably reaches a player who
flies a straight line to the enemy side without correcting for that
new offset.
ISN gets a Stealth Corvette hull mixed into its flagship formation
(assets/images/ships/isn/), banner art renamed off opaque UUID
filenames to isn_banner.jpeg/orc_banner.jpeg.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
82 lines
3.4 KiB
Python
82 lines
3.4 KiB
Python
import enum
|
|
import uuid
|
|
from datetime import datetime
|
|
|
|
from sqlalchemy import DateTime, Float, ForeignKey, Integer, String
|
|
from sqlalchemy import Enum as SAEnum
|
|
from sqlalchemy.orm import Mapped, mapped_column, relationship
|
|
|
|
from app.database import Base
|
|
|
|
|
|
class Mode(str, enum.Enum):
|
|
casual = "casual"
|
|
|
|
|
|
class ServerStatus(str, enum.Enum):
|
|
available = "available"
|
|
full = "full"
|
|
offline = "offline"
|
|
|
|
|
|
# No account/auth system yet (GodotSteam auth is still on the networking
|
|
# checklist), so callsign is the identity key for now — same as the game
|
|
# client itself, which only has a free-text name field today.
|
|
class Player(Base):
|
|
__tablename__ = "players"
|
|
|
|
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
|
callsign: Mapped[str] = mapped_column(String(32), unique=True, index=True)
|
|
mmr: Mapped[int] = mapped_column(Integer, default=1000)
|
|
wins: Mapped[int] = mapped_column(Integer, default=0)
|
|
losses: Mapped[int] = mapped_column(Integer, default=0)
|
|
# Match-history stats (see spacewar/autoload/match_manager.gd's
|
|
# _report_match_result(), POST /matches/report) -- kills/deaths accumulate
|
|
# across every match reported for this callsign; hours_played is derived
|
|
# from each match's full duration for every player present at match end
|
|
# (not precise per-player join/leave timing -- a documented simplification).
|
|
kills: Mapped[int] = mapped_column(Integer, default=0)
|
|
deaths: Mapped[int] = mapped_column(Integer, default=0)
|
|
hours_played: Mapped[float] = mapped_column(Float, default=0.0)
|
|
created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
|
|
|
|
|
|
class GameServer(Base):
|
|
__tablename__ = "game_servers"
|
|
|
|
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
|
ip: Mapped[str] = mapped_column(String(255))
|
|
port: Mapped[int] = mapped_column(Integer)
|
|
mode: Mapped[Mode] = mapped_column(SAEnum(Mode))
|
|
status: Mapped[ServerStatus] = mapped_column(SAEnum(ServerStatus), default=ServerStatus.available)
|
|
last_heartbeat: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
|
|
# DB-stored fallback shown immediately in the server list; a live server
|
|
# is queried directly for its real-time count (see
|
|
# spacewar/autoload/network_manager.gd's UDP query responder and
|
|
# menu/server_select.gd's ping probe), which overrides this in the UI
|
|
# once that probe answers.
|
|
player_count: Mapped[int] = mapped_column(Integer, default=0)
|
|
max_players: Mapped[int] = mapped_column(Integer, default=50)
|
|
|
|
|
|
class Match(Base):
|
|
__tablename__ = "matches"
|
|
|
|
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
|
mode: Mapped[Mode] = mapped_column(SAEnum(Mode))
|
|
server_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("game_servers.id"))
|
|
started_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
|
|
|
|
players: Mapped[list["MatchPlayer"]] = relationship(back_populates="match")
|
|
|
|
|
|
class MatchPlayer(Base):
|
|
__tablename__ = "match_players"
|
|
|
|
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
|
match_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("matches.id"))
|
|
player_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("players.id"))
|
|
team: Mapped[int] = mapped_column(Integer) # 0 or 1
|
|
|
|
match: Mapped["Match"] = relationship(back_populates="players")
|