andras/decla-red
andras/decla-red
Watch
1
0
Fork
You've already forked decla-red
 0
Code Issues Pull requests 8 Projects Releases Packages 1 Wiki Activity Actions

more

Browse source
This commit is contained in:
Andras Schmelczer 2026-08-22 20:59:46 +01:00
commit 98c4d63756
18 changed files with 155 additions and 223 deletions
Download patch file Download diff file Expand all files Collapse all files

95
backend/src/game-server.ts
View file

@ -1,5 +1,6 @@
import { PhysicalContainer } from './physics/containers/physical-container';
import { Server, Socket } from 'socket.io';
import { randomUUID } from 'node:crypto';
import {
TransportEvents,
deserialize,
@ -19,7 +20,7 @@ import {
} from 'shared';
import { createWorld } from './create-world';
import { Options } from './options';
import { PlayerContainer } from './players/player-container';
import { CarriedScore, PlayerContainer } from './players/player-container';
import { ServerFullError } from './players/server-full-error';
import { Player } from './players/player';
import { StepCommand, GeneratePointsCommand, AnnounceCommand } from './commands/commands';
@ -29,7 +30,7 @@ const gameStateSubscribedRoom = 'gameStateSubscribedRoom';
export class GameServer extends CommandReceiver {
private objects!: PhysicalContainer;
private players!: PlayerContainer;
private lastPhysicsBase: [number, number] = process.hrtime();
private lastPhysicsBase = process.hrtime.bigint();
private bluePoints = 0;
private redPoints = 0;
@ -50,7 +51,7 @@ export class GameServer extends CommandReceiver {
this.options.playerLimit,
this.options.npcCount,
);
this.lastPhysicsBase = process.hrtime();
this.lastPhysicsBase = process.hrtime.bigint();
this.bluePoints = 0;
this.redPoints = 0;
this.matchPointAnnounced = {};
@ -85,7 +86,10 @@ export class GameServer extends CommandReceiver {
});
}
private readonly joinedSockets = new Map<Socket, Player>();
private readonly joinedSockets = new Map<
Socket,
{ player: Player; release: () => void }
>();
private handleJoin(socket: Socket, playerInfo: PlayerInformation) {
if (this.joinedSockets.has(socket)) {
@ -98,6 +102,11 @@ export class GameServer extends CommandReceiver {
return;
}
// A reconnect arrives seconds after the drop, long before engine.io times
// the dead socket out. Retire that ghost first so its slot, team and score
// go back to the returning client.
const carried = this.retireGhost(playerInfo.reconnectToken);
if (this.players.isFull) {
socket.emit(TransportEvents.JoinRejected, JoinRejectionReason.ServerFull);
return;
@ -105,7 +114,7 @@ export class GameServer extends CommandReceiver {
let player: Player;
try {
player = this.players.createPlayer(playerInfo, socket);
player = this.players.createPlayer(playerInfo, socket, carried);
} catch (e) {
console.error('Failed to register joining player', e);
socket.emit(
@ -134,31 +143,22 @@ export class GameServer extends CommandReceiver {
};
const onDisconnect = () => {
const p = this.joinedSockets.get(socket);
this.joinedSockets.delete(socket);
this.inboundBudget.delete(socket);
if (!p) {
return;
}
p.detachFromSocket();
const { kills, deaths } = player.scoreSnapshot;
this.players.reserveScore(
player.reconnectToken,
player.team,
kills,
deaths,
Date.now(),
);
player.destroy();
this.players.deletePlayer(player);
this.removeJoined(socket);
this.sendServerStateUpdate();
};
socket.on(TransportEvents.PlayerToServer, onPlayerToServer);
socket.on('disconnect', onDisconnect);
this.joinedSockets.set(socket, player);
this.joinedSockets.set(socket, {
player,
release: () => {
socket.off(TransportEvents.PlayerToServer, onPlayerToServer);
socket.off('disconnect', onDisconnect);
player.detachFromSocket();
},
});
player.reconnectToken = this.players.issueToken();
player.reconnectToken = randomUUID();
socket.emit(TransportEvents.PlayerJoined, player.reconnectToken);
this.sendServerStateUpdate();
@ -188,11 +188,36 @@ export class GameServer extends CommandReceiver {
return true;
}
private releaseJoinedSockets() {
for (const [socket, player] of this.joinedSockets) {
socket.removeAllListeners();
player.detachFromSocket();
private retireGhost(token?: string): CarriedScore | undefined {
if (!token) {
return undefined;
}
for (const [socket, { player }] of this.joinedSockets) {
if (player.reconnectToken === token) {
const carried = { team: player.team, ...player.scoreSnapshot };
this.removeJoined(socket);
return carried;
}
}
return undefined;
}
private removeJoined(socket: Socket) {
const joined = this.joinedSockets.get(socket);
if (!joined) {
return;
}
this.joinedSockets.delete(socket);
this.inboundBudget.delete(socket);
// Only the listeners this join added: socket.io keeps its own internal
// 'error' guard and the connection-scoped PlayerJoining handler here.
joined.release();
joined.player.destroy();
this.players.deletePlayer(joined.player);
}
private releaseJoinedSockets() {
this.joinedSockets.forEach(({ release }) => release());
this.joinedSockets.clear();
this.inboundBudget.clear();
}
@ -255,9 +280,9 @@ export class GameServer extends CommandReceiver {
private saturatedFrames = 0;
private handlePhysics() {
const now = process.hrtime(this.lastPhysicsBase);
const delta = now[0] + now[1] / 1e9;
this.lastPhysicsBase = process.hrtime();
const frameStart = process.hrtime.bigint();
const delta = Number(frameStart - this.lastPhysicsBase) / 1e9;
this.lastPhysicsBase = frameStart;
if (Date.now() - this.statReportMs > 30000) {
this.statReportMs = Date.now();
@ -317,13 +342,9 @@ export class GameServer extends CommandReceiver {
this.players.stepCommunication(delta);
this.objects.resetRemoteCalls();
const elapsed = process.hrtime(now);
const physicsDelta = elapsed[0] + elapsed[1] / 1e9;
const elapsed = Number(process.hrtime.bigint() - frameStart) / 1e9;
setTimeout(
this.handlePhysics.bind(this),
Math.max(0, fixedDelta - physicsDelta) * 1000,
);
setTimeout(this.handlePhysics.bind(this), Math.max(0, fixedDelta - elapsed) * 1000);
}
public get serverInfo(): ServerInformation {

3
backend/src/objects/character-physical.ts
View file

@ -249,7 +249,7 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
}
}
public shootTowards(position: vec2, charge = 0, catchUpSeconds = 0) {
public shootTowards(position: vec2, charge = 0) {
if (
!this.isAlive ||
this.timeSinceLastShot < settings.projectileCreationInterval ||
@ -295,7 +295,6 @@ export class CharacterPhysical extends CharacterBase implements DynamicPhysical
c,
);
this.container.addObject(projectile);
projectile.fastForward(catchUpSeconds);
if (c > 0) {
vec2.scaleAndAdd(

18
backend/src/objects/planet-physical.ts
View file

@ -175,24 +175,8 @@ export class PlanetPhysical extends PlanetBase implements StaticPhysical {
}
}
private get flipTeam(): CharacterTeam {
const control = this.ownership - 0.5;
const enter = settings.planetControlThreshold + settings.planetFlipHysteresis;
if (control > enter) {
return CharacterTeam.red;
}
if (control < -enter) {
return CharacterTeam.blue;
}
if (Math.abs(control) < settings.planetControlThreshold) {
return CharacterTeam.neutral;
}
return this.lastTeam;
}
private detectFlip(game: CommandReceiver) {
const currentTeam = this.flipTeam;
const currentTeam = this.team;
if (currentTeam === this.lastTeam) {
return;
}

19
backend/src/objects/projectile-physical.ts
View file

@ -82,25 +82,6 @@ export class ProjectilePhysical extends ProjectileBase implements DynamicPhysica
wasCollision = hitSurface;
this.object.syncBoundingBox();
}
vec2.add(this.center, this.center, delta);
vec2.add(this.center, this.center, delta);
this.object.syncBoundingBox();
}
/**
* Lag compensation: runs the projectile forward by the time its command spent
* travelling to the server. Capped by settings.maxProjectileCatchUpSeconds so
* a forged timestamp cannot spawn a shot arbitrarily far downrange.
*/
public fastForward(seconds: number) {
const step = settings.targetPhysicsDeltaTimeInSeconds;
let remaining = Math.min(Math.max(seconds, 0), settings.maxProjectileCatchUpSeconds);
while (remaining > 0 && this.isAlive) {
const delta = Math.min(step, remaining);
this.advance(delta);
remaining -= delta;
}
}
// Live view of the circle's box, not a snapshot — the circle keeps it in sync

8
backend/src/physics/containers/bounding-box-list.ts
View file

@ -9,10 +9,10 @@ export class BoundingBoxList {
}
public remove(object: DynamicPhysical) {
this.objects.splice(
this.objects.findIndex((i) => i === object),
1,
);
const index = this.objects.indexOf(object);
if (index >= 0) {
this.objects.splice(index, 1);
}
}
public forEach(func: (object: DynamicPhysical) => unknown) {

2
backend/src/players/player-base.ts
View file

@ -8,10 +8,10 @@ import {
settings,
sanitizeName,
boundRadius,
evaluateSdf,
} from 'shared';
import { PhysicalContainer } from '../physics/containers/physical-container';
import { getBoundingBoxOfCircle } from '../physics/functions/get-bounding-box-of-circle';
import { evaluateSdf } from 'shared';
import { CharacterPhysical } from '../objects/character-physical';
import { PlanetPhysical } from '../objects/planet-physical';
import { PlayerContainer } from './player-container';

81
backend/src/players/player-container.ts
View file

@ -5,21 +5,18 @@ import { NPC } from './npc';
import { Player } from './player';
import { PlayerBase } from './player-base';
import { ServerFullError } from './server-full-error';
import { randomUUID } from 'node:crypto';
// Score held for a dropped player so a reconnect inside the grace window
// resumes the match instead of starting from zero.
interface ReservedScore {
// Team and score carried over from the connection a reconnecting client is
// replacing, so it resumes the match instead of starting from zero.
export interface CarriedScore {
team: CharacterTeam;
kills: number;
deaths: number;
expiresAtMs: number;
}
export class PlayerContainer {
private _players: Array<Player> = [];
private _npcs: Array<NPC> = [];
private reservedScores = new Map<string, ReservedScore>();
constructor(
private readonly objects: PhysicalContainer,
@ -42,80 +39,34 @@ export class PlayerContainer {
}
}
public createPlayer(playerInfo: PlayerInformation, socket: Socket): Player {
public createPlayer(
playerInfo: PlayerInformation,
socket: Socket,
carried?: CarriedScore,
): Player {
if (this._players.length >= this.playerMaxCount) {
throw new ServerFullError();
}
const reserved = this.claimReservedScore(playerInfo.reconnectToken);
const team = reserved ? reserved.team : this.getTeamOfNextPlayer();
const team = carried ? carried.team : this.getTeamOfNextPlayer();
const player = new Player(playerInfo, this, this.objects, team, socket);
let npcToReplace = this._npcs.find((n) => n.team === team);
if (!npcToReplace) {
npcToReplace = this._npcs.find((n) => n.team !== team);
}
// Retire the bot before the player spawns: its body would otherwise push
// the spawn search away from the position it picked.
const npcToReplace =
this._npcs.find((n) => n.team === team) ?? this._npcs.find((n) => n.team !== team);
npcToReplace?.destroy();
this._npcs = this._npcs.filter((n) => n !== npcToReplace);
const player = new Player(playerInfo, this, this.objects, team, socket);
this._players.push(player);
if (reserved) {
player.restoreScore(reserved.kills, reserved.deaths);
if (carried) {
player.restoreScore(carried.kills, carried.deaths);
}
return player;
}
/**
* A fresh token for a joining player; only redeemable once the player
* actually drops (see reserveScore).
*/
public issueToken(): string {
return randomUUID();
}
/**
* Hold a dropped player's team and score against its token for the grace
* window, so a reconnecting client rejoins as itself.
*/
public reserveScore(
token: string,
team: CharacterTeam,
kills: number,
deaths: number,
nowMs: number,
) {
this.expireReservations(nowMs);
this.reservedScores.set(token, {
team,
kills,
deaths,
expiresAtMs: nowMs + settings.reconnectGraceSeconds * 1000,
});
}
private claimReservedScore(token?: string): ReservedScore | undefined {
if (!token || typeof token !== 'string') {
return undefined;
}
const reserved = this.reservedScores.get(token);
if (!reserved) {
return undefined;
}
this.reservedScores.delete(token);
return reserved;
}
private expireReservations(nowMs: number) {
for (const [token, reserved] of this.reservedScores) {
if (reserved.expiresAtMs <= nowMs) {
this.reservedScores.delete(token);
}
}
}
public get players(): Array<PlayerBase> {
return [...this._players, ...this._npcs];
}

12
backend/src/players/player.ts
View file

@ -92,11 +92,7 @@ export class Player extends PlayerBase {
return;
}
this.observeClientTime(c.clientTimeMs);
this.character?.shootTowards(
position,
finiteInRange(c.charge, 0, 1, 0),
this.catchUpSeconds,
);
this.character?.shootTowards(position, finiteInRange(c.charge, 0, 1, 0));
},
[LeapActionCommand.type]: (c: LeapActionCommand) => {
if (!isFiniteNumber(c.clientTimeMs)) {
@ -125,12 +121,6 @@ export class Player extends PlayerBase {
}
}
// Derived from the measured RTT, NOT the client's timestamp, so a forged
// stamp cannot buy extra lag compensation. fastForward caps the result.
private get catchUpSeconds(): number {
return Math.max(0, this.rttMs / 2 / 1000);
}
constructor(
playerInfo: PlayerInformation,
playerContainer: PlayerContainer,

7
frontend/src/index.ts
View file

@ -173,4 +173,9 @@ const main = async () => {
}
};
main();
main().catch((error) => {
console.error(error);
hide(spinner);
joinNotice.innerText = 'Something went wrong. Please reload the page.';
joinNotice.style.display = 'block';
});

1
frontend/src/scripts/game.ts
View file

@ -93,6 +93,7 @@ export class Game extends CommandReceiver {
this.gameObjects = new GameObjectContainer(this);
this.overlay.innerHTML = '';
this.keystoneArrow = undefined;
this.connectionBanner = undefined;
this.lastMinimap = undefined;
this.isEnding = false;
this.lastAnnouncementText = '';

1
frontend/tsconfig.json
View file

@ -5,6 +5,7 @@
"target": "es6",
"esModuleInterop": true,
"strict": true,
"experimentalDecorators": true,
"moduleResolution": "node",
"ignoreDeprecations": "6.0",
"skipLibCheck": true,

38
shared/src/helper/random.ts
View file

@ -1,23 +1,7 @@
let _seed = Math.random();
let seed = Math.random();
export function setRandomSeed(value: number) {
_seed = value;
}
export function chooseRandom<T>(values: Array<T>): T | undefined {
const to = values.length;
if (to === 0) {
return undefined;
}
return values[Math.floor(getRandomInRange(0, to))];
}
export function getRandomInRange(from: number, to: number): number {
return from + getRandom() * (to - from);
}
export function getRandom(): number {
let t = (_seed += 0x6d2b79f5);
function getRandom(): number {
let t = (seed += 0x6d2b79f5);
t = Math.imul(t ^ (t >>> 15), t | 1);
t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
@ -25,12 +9,18 @@ export function getRandom(): number {
export const Random = {
get seed() {
return _seed;
return seed;
},
set seed(v: number) {
_seed = v;
set seed(value: number) {
seed = value;
},
choose: chooseRandom,
getRandomInRange,
getRandom,
getRandomInRange(from: number, to: number): number {
return from + getRandom() * (to - from);
},
choose<T>(values: Array<T>): T | undefined {
return values.length === 0
? undefined
: values[Math.floor(getRandom() * values.length)];
},
};

4
shared/src/objects/types/planet-base.ts
View file

@ -34,8 +34,8 @@ export class PlanetBase extends GameObject {
this.vertices.length;
}
// Single rule for the dead-band: scoring (server) and every tint (client)
// read this rather than duplicating the comparison.
// The one capture rule: server flips and scoring, client tints and the
// keystone arrow all read this.
public get team(): CharacterTeam {
return Math.abs(this.ownership - 0.5) < settings.planetControlThreshold
? CharacterTeam.neutral

4
shared/src/physics/march-circle.ts
View file

@ -78,7 +78,9 @@ export const marchCircle = (
);
}
vec2.scaleAndAdd(body.center, body.center, direction, deltaLength);
// lastFreeDistance, not deltaLength: on a completed march they are equal, and
// if the step budget ran out it is the furthest point actually checked.
vec2.scaleAndAdd(body.center, body.center, direction, lastFreeDistance);
return {
hitSurface: false,

12
shared/src/settings.ts
View file

@ -30,12 +30,9 @@ export const settings = {
maxGravityDistance: 800,
minGravityDistance: 1,
maxGravityQ: 5000,
// Neutral dead-band around 50% ownership; the rendered ring uses the same
// threshold as scoring so visuals match state.
// Neutral dead-band around 50% ownership. The single capture rule: flips,
// scoring and every client-side tint all read PlanetBase.team.
planetControlThreshold: 0.12,
// Schmitt trigger: extra margin beyond planetControlThreshold before a flip
// pays out again, so boundary-hovering doesn't re-trigger the reward.
planetFlipHysteresis: 0.06,
playerMaxHealth: 100,
maxGravityStrength: 50000,
planetMinReferenceRadius: 150,
@ -171,11 +168,6 @@ export const settings = {
chargeShotRecoilMax: 650,
// Capped so a forged timestamp cannot spawn a shot arbitrarily far downrange.
maxProjectileCatchUpSeconds: 0.2,
reconnectGraceSeconds: 30,
// DoS guard: parsing is synchronous with the physics loop, so one oversized
// message stalls the tick for everyone.
maxInboundMessageBytes: 16 * 1024,

1
shared/tsconfig.json
View file

@ -7,6 +7,7 @@
"target": "es6",
"esModuleInterop": true,
"strict": true,
"experimentalDecorators": true,
"moduleResolution": "node",
"ignoreDeprecations": "6.0",
"module": "commonjs",

31
test/backend-regressions.test.ts
View file

@ -69,31 +69,7 @@ describe('projectile broadphase registration', () => {
expect(container.findIntersecting(boxAround([0, 0], 100))).not.toContain(projectile);
});
it('fast-forwards a shot by the sender latency', () => {
const container = new PhysicalContainer();
container.initialize();
const spawn = vec2.fromValues(0, 0);
const make = () =>
new ProjectilePhysical(
vec2.clone(spawn),
20,
40,
CharacterTeam.blue,
vec2.fromValues(3000, 0),
{ team: CharacterTeam.blue } as never,
container,
0,
);
const plain = make();
const compensated = make();
compensated.fastForward(0.1);
expect(compensated.center[0]).toBeGreaterThan(plain.center[0] + 200);
});
it('never fast-forwards further than the cap', () => {
it('spawns a shot just clear of the shooter, not a jump downrange', () => {
const container = new PhysicalContainer();
container.initialize();
const projectile = new ProjectilePhysical(
@ -106,9 +82,8 @@ describe('projectile broadphase registration', () => {
container,
0,
);
projectile.fastForward(10);
const cap = settings.chargeShotSpeedMax * settings.maxProjectileCatchUpSeconds;
expect(projectile.center[0]).toBeLessThanOrEqual(cap + 50);
expect(projectile.center[0]).toBeLessThanOrEqual(15);
});
});

41
test/connection-lifecycle.test.ts
View file

@ -255,6 +255,44 @@ describe('reconnect tokens', () => {
});
});
describe('reconnect while the dropped socket is still live', () => {
// engine.io needs ~45 s to notice a transport drop; the client is back in ~1 s.
it('retires the ghost so the returning player keeps its slot, team and score', () => {
const { server, attach } = startServer({ playerLimit: 1, npcCount: 0 });
const first = attach();
first.fire(TransportEvents.PlayerJoining, { name: 'flaky' });
const token = first.lastPayloadFor(TransportEvents.PlayerJoined) as string;
expect(server.serverInfo.playerCount).toBe(1);
// No 'disconnect' fired: the server still holds the dead socket's player.
const second = attach();
second.fire(TransportEvents.PlayerJoining, { name: 'flaky', reconnectToken: token });
expect(second.lastPayloadFor(TransportEvents.JoinRejected)).toBeUndefined();
expect(second.lastPayloadFor(TransportEvents.PlayerJoined)).toBeTruthy();
expect(server.serverInfo.playerCount).toBe(1);
expect(first.listenerCount(TransportEvents.PlayerToServer)).toBe(0);
});
it('does not hand a slot to an unknown token', () => {
const { server, attach } = startServer({ playerLimit: 1, npcCount: 0 });
attach().fire(TransportEvents.PlayerJoining, { name: 'holder' });
const stranger = attach();
stranger.fire(TransportEvents.PlayerJoining, {
name: 'stranger',
reconnectToken: 'not-a-real-token',
});
expect(stranger.lastPayloadFor(TransportEvents.JoinRejected)).toBe(
JoinRejectionReason.ServerFull,
);
expect(server.serverInfo.playerCount).toBe(1);
});
});
describe('socket listeners', () => {
it('takes every listener back off when the player drops', () => {
const { attach } = startServer({ playerLimit: 4, npcCount: 0 });
@ -266,7 +304,8 @@ describe('socket listeners', () => {
socket.fire('disconnect');
expect(socket.listenerCount(TransportEvents.Pong)).toBe(0);
expect(socket.listenerCount(TransportEvents.PlayerToServer)).toBe(1);
expect(socket.listenerCount(TransportEvents.PlayerToServer)).toBe(0);
expect(socket.listenerCount('disconnect')).toBe(0);
});
it('does not stack a listener per reconnect', () => {