Ranked Matchmaking

npm add rivetkit

/*
This matchmaker uses a rating window flow.
1. queueForMatch adds players to player_pool with current rating and queue time, then tries to pair them.
2. attemptPairing looks for two players whose rating windows overlap and removes both from the pool in one transaction.
3. createRankedMatch creates a match actor for the pair, stores assignments, and broadcasts assignmentReady.
4. A background loop retries pairing every few seconds, because rating windows widen while players wait.
5. matchCompleted updates player rating actors and leaderboard entries, then removes the match row.
*/
import { type ActorContextOf, actor, event } from "rivetkit";
import { db, type RawAccess } from "rivetkit/db";

import type { registry } from "../index.ts";
import {
	INITIAL_RATING_WINDOW,
	MAX_RATING_WINDOW,
	WINDOW_EXPAND_PER_SEC,
} from "./config.ts";

export interface RankedAssignment {
	matchId: string;
	username: string;
	rating: number;
	connId: string | null;
}

export type RankedQueueUpdate =
	| {
			queued: false;
			count: number;
	  }
	| {
			queued: true;
			count: number;
			username: string;
			rating: number;
			queueDurationMs: number;
			ratingWindow: number;
			ratingMin: number;
			ratingMax: number;
	  };

type QueuePlayerRow = {
	username: string;
	rating: number;
	queued_at: number;
	conn_id: string | null;
};

interface MatchmakerVars {
	// `onWake` stores its loops here so `onSleep` can wait for them.
	pairingRetryTicker: Promise<void> | null;
	queueUpdateTicker: Promise<void> | null;
}

const QUEUE_UPDATE_TICK_MS = 1000;
const PAIRING_RETRY_TICK_MS = 2000;

export const rankedMatchmaker = actor({
	options: { name: "Ranked - Matchmaker", icon: "ranking-star" },
	db: db({
		onMigrate: migrateTables,
	}),
	events: {
		assignmentReady: event<RankedAssignment>(),
		queueUpdate: event<RankedQueueUpdate>(),
	},
	createVars: (): MatchmakerVars => ({
		pairingRetryTicker: null,
		queueUpdateTicker: null,
	}),
	// `onWake` runs on every start, so both loops restart after a sleep or crash.
	// They run separately, because a pairing attempt waits for a match actor to
	// be created and must not hold up the queue updates.
	onWake: (c) => {
		c.vars.pairingRetryTicker = runPairingRetryTicker(c).catch((error) => {
			c.log.error({ msg: "pairing retry loop failed", error });
		});
		c.vars.queueUpdateTicker = runQueueUpdateTicker(c).catch((error) => {
			c.log.error({ msg: "queue update loop failed", error });
		});
	},
	// `c.abortSignal` fires on shutdown, so both loops exit on their own
	onSleep: async (c) => {
		await Promise.all([
			c.vars.pairingRetryTicker,
			c.vars.queueUpdateTicker,
		]);
	},
	actions: {
		queueForMatch: async (c, { username }: { username: string }) => {
			const connId = c.conn.id;

			const client = c.client<typeof registry>();
			const playerHandle = client.rankedPlayer.getOrCreate([username]);
			await playerHandle.initialize({ username });
			const rating = await playerHandle.getRating();

			// Clear any stale assignment for this username before re-queueing.
			await c.db.execute(
				`DELETE FROM assignments WHERE username = ?`,
				username,
			);

			await c.db.execute(
				`INSERT OR REPLACE INTO player_pool (username, rating, queued_at, conn_id) VALUES (?, ?, ?, ?)`,
				username,
				rating,
				Date.now(),
				connId,
			);

			await sendQueueUpdates(c);
			await attemptPairing(c);
			return { queued: true, connId };
		},
		getQueueSize: async (c) => {
			const rows = await c.db.execute<{ cnt: number }>(
				`SELECT COUNT(*) as cnt FROM player_pool`,
			);
			return rows[0]?.cnt ?? 0;
		},
		getAssignment: async (c, { username }: { username: string }) => {
			const rows = await c.db.execute<{
				match_id: string;
				username: string;
				rating: number;
				conn_id: string | null;
			}>(
				`SELECT * FROM assignments WHERE username = ? AND conn_id = ?`,
				username,
				c.conn.id,
			);
			if (rows.length === 0) return null;
			const row = rows[0]!;
			return {
				matchId: row.match_id,
				username: row.username,
				rating: row.rating,
				connId: row.conn_id,
			};
		},
		// Every step is safe to repeat: each player applies a match id once,
		// the leaderboard keeps the profile with the most games, and the
		// deletes do nothing the second time. A match can therefore send a
		// report again after one fails partway.
		matchCompleted: async (
			c,
			body: {
				matchId: string;
				winnerUsername: string;
				loserUsername: string;
				winnerNewRating: number;
				loserNewRating: number;
			},
		) => {
			const client = c.client<typeof registry>();

			if (body.winnerUsername && body.loserUsername) {
				const winnerHandle = client.rankedPlayer.getOrCreate([
					body.winnerUsername,
				]);
				await winnerHandle.applyMatchResult({
					matchId: body.matchId,
					won: true,
					newRating: body.winnerNewRating,
				});
				const loserHandle = client.rankedPlayer.getOrCreate([
					body.loserUsername,
				]);
				await loserHandle.applyMatchResult({
					matchId: body.matchId,
					won: false,
					newRating: body.loserNewRating,
				});

				const winnerProfile = await winnerHandle.getProfile();
				const loserProfile = await loserHandle.getProfile();

				const lb = client.rankedLeaderboard.getOrCreate(["main"]);
				await lb.updatePlayer(winnerProfile);
				await lb.updatePlayer(loserProfile);
			}

			await c.db.execute(
				`DELETE FROM matches WHERE match_id = ?`,
				body.matchId,
			);
			await c.db.execute(
				`DELETE FROM assignments WHERE match_id = ?`,
				body.matchId,
			);
		},
	},
	onDisconnect: async (c, conn) => {
		await c.db.execute(
			`DELETE FROM player_pool WHERE conn_id = ?`,
			conn.id,
		);
		await sendQueueUpdates(c);
	},
});

/** Retries pairing on a timer, because rating windows widen while players wait. */
async function runPairingRetryTicker(
	c: ActorContextOf<typeof rankedMatchmaker>,
): Promise<void> {
	while (!c.aborted) {
		await delay(PAIRING_RETRY_TICK_MS, c.abortSignal);
		if (c.aborted) break;

		try {
			await attemptPairing(c);
		} catch (error) {
			// The pair is back in the pool, so the next tick tries again.
			c.log.warn({ msg: "pairing retry failed", error });
		}
	}
}

async function attemptPairing(c: ActorContextOf<typeof rankedMatchmaker>) {
	// queueForMatch and the retry loop can pair at the same time, so pick the
	// pair and remove both players in one transaction. A player can't be
	// claimed by two matches.
	const pair = await c.db.transaction(
		async (tx) => {
			const pool = await tx.execute<QueuePlayerRow>(
				`SELECT * FROM player_pool ORDER BY queued_at ASC`,
			);
			const found = findPair(pool, Date.now());
			if (!found) return null;

			const [a, b] = found;
			await tx.execute(
				`DELETE FROM player_pool WHERE username IN (?, ?)`,
				a.username,
				b.username,
			);
			return found;
		},
		{ name: "claim-pair" },
	);
	if (!pair) return;

	const [a, b] = pair;
	await createRankedMatch(c, a, b);
}

/**
 * Returns the longest-waiting player and their closest opponent whose rating
 * windows both fit the difference, or null if no two players fit.
 */
function findPair(
	pool: QueuePlayerRow[],
	now: number,
): [QueuePlayerRow, QueuePlayerRow] | null {
	if (pool.length < 2) return null;

	for (let i = 0; i < pool.length; i++) {
		const a = pool[i]!;
		const aWaitSec = (now - a.queued_at) / 1000;
		const aWindow = Math.min(
			INITIAL_RATING_WINDOW + WINDOW_EXPAND_PER_SEC * aWaitSec,
			MAX_RATING_WINDOW,
		);

		let bestIdx = -1;
		let bestDiff = Infinity;

		for (let j = i + 1; j < pool.length; j++) {
			const b = pool[j]!;
			const bWaitSec = (now - b.queued_at) / 1000;
			const bWindow = Math.min(
				INITIAL_RATING_WINDOW + WINDOW_EXPAND_PER_SEC * bWaitSec,
				MAX_RATING_WINDOW,
			);

			const diff = Math.abs(a.rating - b.rating);
			if (diff <= aWindow && diff <= bWindow && diff < bestDiff) {
				bestDiff = diff;
				bestIdx = j;
			}
		}

		if (bestIdx >= 0) {
			return [a, pool[bestIdx]!];
		}
	}
	return null;
}

async function createRankedMatch(
	c: ActorContextOf<typeof rankedMatchmaker>,
	a: QueuePlayerRow,
	b: QueuePlayerRow,
) {
	const matchId = crypto.randomUUID();
	const assignedPlayers = [
		{
			username: a.username,
			rating: a.rating,
			connId: a.conn_id,
		},
		{
			username: b.username,
			rating: b.rating,
			connId: b.conn_id,
		},
	] as const;

	// Create the match outside the claim transaction, because a transaction
	// must not wait on another actor.
	const client = c.client<typeof registry>();
	try {
		await client.rankedMatch.create([matchId], {
			input: {
				assignedPlayers: assignedPlayers.map((p) => ({
					username: p.username,
					rating: p.rating,
				})),
			},
		});
	} catch (error) {
		await returnToPool(c, [a, b]);
		throw error;
	}

	await c.db.transaction(
		async (tx) => {
			await tx.execute(
				`INSERT INTO matches (match_id, created_at) VALUES (?, ?)`,
				matchId,
				Date.now(),
			);
			for (const player of assignedPlayers) {
				await tx.execute(
					`INSERT OR REPLACE INTO assignments (username, match_id, rating, conn_id) VALUES (?, ?, ?, ?)`,
					player.username,
					matchId,
					player.rating,
					player.connId,
				);
			}
		},
		{ name: "save-match" },
	);

	await sendQueueUpdates(c);

	for (const player of assignedPlayers) {
		c.broadcast("assignmentReady", {
			matchId,
			username: player.username,
			rating: player.rating,
			connId: player.connId,
		} satisfies RankedAssignment);
	}
}

/** Puts claimed players back at their original place in the pool. */
async function returnToPool(
	c: ActorContextOf<typeof rankedMatchmaker>,
	players: QueuePlayerRow[],
) {
	// A player who left while the match was being created stays out of the
	// pool, because their disconnect found no row to remove.
	const stillConnected = players.filter(
		(player) => player.conn_id !== null && c.conns.has(player.conn_id),
	);

	await c.db.transaction(
		async (tx) => {
			for (const player of stillConnected) {
				// A player who queued again in the meantime keeps the newer entry.
				await tx.execute(
					`INSERT OR IGNORE INTO player_pool (username, rating, queued_at, conn_id) VALUES (?, ?, ?, ?)`,
					player.username,
					player.rating,
					player.queued_at,
					player.conn_id,
				);
			}
		},
		{ name: "return-players" },
	);
	await sendQueueUpdates(c);
}

function calculateRatingWindow(now: number, queuedAt: number): number {
	const waitSec = Math.max(0, (now - queuedAt) / 1000);
	return Math.min(
		INITIAL_RATING_WINDOW + WINDOW_EXPAND_PER_SEC * waitSec,
		MAX_RATING_WINDOW,
	);
}

async function sendQueueUpdates(c: ActorContextOf<typeof rankedMatchmaker>) {
	if (c.conns.size === 0) return;

	const now = Date.now();
	const pool = await c.db.execute<QueuePlayerRow>(
		`SELECT * FROM player_pool`,
	);
	const count = pool.length;

	const playerByConnId = new Map<string, QueuePlayerRow>();
	for (const row of pool) {
		if (!row.conn_id) continue;
		const existing = playerByConnId.get(row.conn_id);
		if (!existing || row.queued_at > existing.queued_at) {
			playerByConnId.set(row.conn_id, row);
		}
	}

	for (const [connId, conn] of c.conns.entries()) {
		const player = playerByConnId.get(connId);
		if (!player) {
			conn.send("queueUpdate", {
				queued: false,
				count,
			});
			continue;
		}

		const ratingWindow = calculateRatingWindow(now, player.queued_at);
		conn.send("queueUpdate", {
			queued: true,
			count,
			username: player.username,
			rating: player.rating,
			queueDurationMs: Math.max(0, now - player.queued_at),
			ratingWindow: Math.round(ratingWindow),
			ratingMin: Math.round(player.rating - ratingWindow),
			ratingMax: Math.round(player.rating + ratingWindow),
		});
	}
}

async function runQueueUpdateTicker(
	c: ActorContextOf<typeof rankedMatchmaker>,
): Promise<void> {
	while (!c.aborted) {
		await delay(QUEUE_UPDATE_TICK_MS, c.abortSignal);
		if (c.aborted) break;
		await sendQueueUpdates(c);
	}
}

/** Resolves after `ms`, or as soon as the actor starts shutting down. */
function delay(ms: number, signal: AbortSignal): Promise<void> {
	return new Promise((resolve) => {
		if (signal.aborted) {
			resolve();
			return;
		}

		const finish = () => {
			clearTimeout(timer);
			signal.removeEventListener("abort", finish);
			resolve();
		};
		const timer = setTimeout(finish, ms);
		signal.addEventListener("abort", finish, { once: true });
	});
}

async function migrateTables(dbHandle: RawAccess) {
	await dbHandle.execute(`
		CREATE TABLE IF NOT EXISTS player_pool (
			username TEXT PRIMARY KEY,
			rating INTEGER NOT NULL,
			queued_at INTEGER NOT NULL,
			conn_id TEXT
		)
	`);
	await dbHandle.execute(`
		CREATE TABLE IF NOT EXISTS matches (
			match_id TEXT PRIMARY KEY,
			created_at INTEGER NOT NULL
		)
	`);
	await dbHandle.execute(`
		CREATE TABLE IF NOT EXISTS assignments (
			username TEXT PRIMARY KEY,
			match_id TEXT NOT NULL,
			rating INTEGER NOT NULL,
			conn_id TEXT
		)
	`);
}

import { type ActorContextOf, actor, event, UserError } from "rivetkit";
import { db } from "rivetkit/db";
import { interval } from "rivetkit/utils";
import type { registry } from "../index.ts";
import { getPlayerColor } from "../player-color.ts";
import {
	K_FACTOR,
	MAX_SPEED,
	SCORE_LIMIT,
	SHOOT_ANGLE,
	SHOOT_RANGE,
	SNAPSHOT_INTERVAL_MS,
	TICK_MS,
	WORLD_SIZE,
} from "./config.ts";

// How long to wait before sending a failed match report again
const REPORT_RETRY_MS = 1_000;

interface PlayerEntry {
	connId: string | null;
	color: string;
	x: number;
	y: number;
	lastPositionAt: number;
	alive: boolean;
	score: number;
	rating: number;
}

interface MatchVars {
	matchId: string;
	tick: number;
	phase: "waiting" | "live" | "finished";
	players: Record<string, PlayerEntry>;
	winnerId: string | null;
	resultReported: boolean;
	// A failed report armed a retry schedule, so the loop stops sending it.
	reportRetryScheduled: boolean;
	// `onWake` stores its loop here so `onSleep` can wait for it.
	loop: Promise<void> | null;
}

interface AssignedPlayer {
	username: string;
	rating: number;
}

type MatchInfoRow = {
	tick: number;
	phase: MatchVars["phase"];
	winner_id: string | null;
	result_reported: number;
};

type RosterRow = {
	username: string;
	rating: number;
	x: number;
	y: number;
	score: number;
};

export const rankedMatch = actor({
	options: { name: "Ranked - Match", icon: "ranking-star" },
	events: {
		snapshot: event<Snapshot>(),
		shoot: event<ShootEvent>(),
	},
	db: db({
		onMigrate: async (db) => {
			await db.execute(`
				CREATE TABLE IF NOT EXISTS match_info (
					id INTEGER PRIMARY KEY CHECK (id = 1),
					tick INTEGER NOT NULL DEFAULT 0,
					phase TEXT NOT NULL DEFAULT 'waiting',
					winner_id TEXT,
					result_reported INTEGER NOT NULL DEFAULT 0
				)
			`);
			await db.execute(`
				CREATE TABLE IF NOT EXISTS roster (
					username TEXT PRIMARY KEY,
					rating INTEGER NOT NULL,
					x REAL NOT NULL,
					y REAL NOT NULL,
					score INTEGER NOT NULL DEFAULT 0
				)
			`);
		},
	}),
	onCreate: async (
		c,
		input: { assignedPlayers: AssignedPlayer[] },
	) => {
		// Save the two players, their ratings, and a random spawn point once,
		// so every start of this match sees the same roster.
		await c.db.transaction(
			async (tx) => {
				await tx.execute("INSERT INTO match_info (id) VALUES (1)");
				for (const ap of input.assignedPlayers) {
					await tx.execute(
						"INSERT INTO roster (username, rating, x, y) VALUES (?, ?, ?, ?)",
						ap.username,
						ap.rating,
						Math.random() * WORLD_SIZE,
						Math.random() * WORLD_SIZE,
					);
				}
			},
			{ name: "create-match" },
		);
	},
	createVars: async (c): Promise<MatchVars> => {
		const [info] = await c.db.execute<MatchInfoRow>(
			"SELECT tick, phase, winner_id, result_reported FROM match_info WHERE id = 1",
		);
		const roster = await c.db.execute<RosterRow>(
			"SELECT username, rating, x, y, score FROM roster",
		);

		// The live duel runs in memory and starts from the last save. No
		// connection survives a restart, so both players start unbound.
		const players: Record<string, PlayerEntry> = {};
		for (const row of roster) {
			players[row.username] = {
				connId: null,
				color: getPlayerColor(row.username),
				x: row.x,
				y: row.y,
				lastPositionAt: Date.now(),
				alive: true,
				score: row.score,
				rating: row.rating,
			};
		}
		return {
			matchId: c.key[0]!,
			tick: info!.tick,
			phase: info!.phase,
			players,
			winnerId: info!.winner_id,
			resultReported: info!.result_reported === 1,
			reportRetryScheduled: false,
			loop: null,
		};
	},
	onConnect: (c, conn) => {
		const params = conn.params as { username?: string; playerId?: string };
		const playerId = params.username ?? params.playerId;
		if (!playerId) {
			conn.disconnect("invalid_player");
			return;
		}
		const player = c.vars.players[playerId];
		if (!player) {
			conn.disconnect("invalid_player");
			return;
		}
		player.connId = conn.id;

		if (c.vars.phase === "waiting") {
			const allConnected = Object.values(c.vars.players).every(
				(p) => p.connId !== null,
			);
			if (allConnected) {
				c.vars.phase = "live";
			}
		}
		broadcastSnapshot(c);
	},
	onDestroy: async (c) => {
		// `c.abortSignal` also fires on destroy. Wait for the loop to exit, so a
		// result it is still reporting is not reported a second time here.
		await c.vars.loop;
		await reportMatchCompletedIfNeeded(c, { allowNoResult: true });
	},
	onDisconnect: (c, conn) => {
		const found = findPlayerByConnId(c.vars, conn.id);
		if (!found) return;
		const [, player] = found;
		player.connId = null;
		broadcastSnapshot(c);
	},
	// `onWake` runs on every start, so the loop restarts after a sleep or crash
	onWake: (c) => {
		c.vars.loop = runMatch(c).catch((error) => {
			c.log.error({ msg: "match loop failed", error });
		});
	},
	// `c.abortSignal` fires on shutdown, so the loop saves and exits on its own
	onSleep: async (c) => {
		await c.vars.loop;
	},
	actions: {
		// Runs from the schedule that `reportResult` arms after a failed report.
		retryReport: async (c) => {
			if (!c.scheduledFire) {
				throw new UserError("retryReport only runs from a schedule", {
					code: "schedule_only",
				});
			}
			c.vars.reportRetryScheduled = false;
			await reportResult(c);
		},
		updatePosition: (c, input: { x: number; y: number }) => {
			const found = findPlayerByConnId(c.vars, c.conn.id);
			if (!found) {
				return;
			}
			const [, player] = found;
			if (!player.alive) {
				throw new UserError("player is not alive", {
					code: "not_alive",
				});
			}

			const now = Date.now();
			const elapsed = Math.max(0, (now - player.lastPositionAt) / 1000);
			const maxDist = MAX_SPEED * elapsed;

			const dx = input.x - player.x;
			const dy = input.y - player.y;
			const dist = Math.sqrt(dx * dx + dy * dy);

			let newX: number;
			let newY: number;
			if (dist > maxDist && dist > 0) {
				newX = player.x + (dx / dist) * maxDist;
				newY = player.y + (dy / dist) * maxDist;
			} else {
				newX = input.x;
				newY = input.y;
			}

			player.x = Math.max(0, Math.min(WORLD_SIZE, newX));
			player.y = Math.max(0, Math.min(WORLD_SIZE, newY));
			player.lastPositionAt = now;
		},
		shoot: (c, input: { dirX: number; dirY: number }) => {
			const found = findPlayerByConnId(c.vars, c.conn.id);
			if (!found) {
				return;
			}
			const [shooterId, shooter] = found;
			if (!shooter.alive) {
				throw new UserError("player is not alive", {
					code: "not_alive",
				});
			}
			if (c.vars.phase !== "live") {
				throw new UserError("match is not live", { code: "not_live" });
			}

			const mag = Math.sqrt(
				input.dirX * input.dirX + input.dirY * input.dirY,
			);
			if (mag === 0) return;
			const ndx = input.dirX / mag;
			const ndy = input.dirY / mag;

			let closestId: string | null = null;
			let closestDist = Infinity;

			for (const [targetId, target] of Object.entries(c.vars.players)) {
				if (targetId === shooterId) continue;
				if (!target.alive) continue;

				const tx = target.x - shooter.x;
				const ty = target.y - shooter.y;
				const targetDist = Math.sqrt(tx * tx + ty * ty);
				if (targetDist > SHOOT_RANGE || targetDist === 0) continue;

				const dot = (tx / targetDist) * ndx + (ty / targetDist) * ndy;
				const angle = Math.acos(Math.max(-1, Math.min(1, dot)));
				if (angle > SHOOT_ANGLE) continue;

				if (targetDist < closestDist) {
					closestDist = targetDist;
					closestId = targetId;
				}
			}

			if (closestId) {
				const victim = c.vars.players[closestId]!;
				shooter.score += 1;
				victim.x = Math.random() * WORLD_SIZE;
				victim.y = Math.random() * WORLD_SIZE;
				victim.lastPositionAt = Date.now();
			}

			const shootEvent: ShootEvent = {
				shooterId,
				fromX: shooter.x,
				fromY: shooter.y,
				dirX: ndx,
				dirY: ndy,
				hitPlayerId: closestId,
			};
			c.broadcast("shoot", shootEvent);

			checkWinCondition(c);
			if ((c.vars.phase as string) === "finished") {
				broadcastSnapshot(c);
			}
		},
		getSnapshot: (c) => buildSnapshot(c),
	},
});

function checkWinCondition(c: ActorContextOf<typeof rankedMatch>) {
	if (c.vars.phase !== "live") return;
	for (const [id, player] of Object.entries(c.vars.players)) {
		if (player.score >= SCORE_LIMIT) {
			c.vars.phase = "finished";
			c.vars.winnerId = id;
			return;
		}
	}
}

/** Sends the match result to the matchmaker once. Returns true if this call sent it. */
async function reportMatchCompletedIfNeeded(
	c: ActorContextOf<typeof rankedMatch>,
	options?: { allowNoResult?: boolean },
): Promise<boolean> {
	const allowNoResult = options?.allowNoResult ?? false;

	if (c.vars.resultReported) return false;
	if (c.vars.phase !== "finished" && !allowNoResult) return false;

	const client = c.client<typeof registry>();
	const entries = Object.entries(c.vars.players);
	if (c.vars.winnerId && entries.length === 2) {
		const loserUsername = entries.find(
			([id]) => id !== c.vars.winnerId,
		)?.[0];
		const winner = c.vars.players[c.vars.winnerId];
		const loser = loserUsername
			? c.vars.players[loserUsername]
			: undefined;
		if (winner && loser && loserUsername) {
			const [newWR, newLR] = calculateElo(winner.rating, loser.rating);
			await client.rankedMatchmaker.getOrCreate(["main"]).matchCompleted({
				matchId: c.vars.matchId,
				winnerUsername: c.vars.winnerId,
				loserUsername,
				winnerNewRating: newWR,
				loserNewRating: newLR,
			});
			c.vars.resultReported = true;
			return true;
		}
	}
	if (!allowNoResult) return false;

	await client.rankedMatchmaker.getOrCreate(["main"]).matchCompleted({
		matchId: c.vars.matchId,
		winnerUsername: "",
		loserUsername: "",
		winnerNewRating: 0,
		loserNewRating: 0,
	});
	c.vars.resultReported = true;
	return true;
}

function calculateElo(
	winnerRating: number,
	loserRating: number,
): [number, number] {
	const expectedW = 1 / (1 + 10 ** ((loserRating - winnerRating) / 400));
	const expectedL = 1 - expectedW;
	return [
		Math.round(winnerRating + K_FACTOR * (1 - expectedW)),
		Math.round(loserRating + K_FACTOR * (0 - expectedL)),
	];
}

function broadcastSnapshot(c: ActorContextOf<typeof rankedMatch>) {
	c.broadcast("snapshot", buildSnapshot(c));
}

/** Steps the duel every `TICK_MS` until the actor starts shutting down. */
async function runMatch(c: ActorContextOf<typeof rankedMatch>): Promise<void> {
	const tick = interval(TICK_MS);
	let savedAt = Date.now();
	while (!c.aborted) {
		await tick();
		if (c.aborted) break;

		// Ticks and actions only change memory. Save to SQLite every
		// SNAPSHOT_INTERVAL_MS in every phase, so a finished match stays
		// finished after a crash.
		const now = Date.now();
		if (now - savedAt >= SNAPSHOT_INTERVAL_MS) {
			await saveMatch(c);
			savedAt = now;
		}

		if (c.vars.phase !== "live") {
			if (!c.vars.reportRetryScheduled) await reportResult(c);
			continue;
		}
		c.vars.tick += 1;
		checkWinCondition(c);
		broadcastSnapshot(c);
	}

	// Save once more when the Actor stops, so a clean restart loses nothing.
	await saveMatch(c);
}

/**
 * Reports a finished match and saves that it did, so a restart does not send
 * the report again. The report is safe to send again, so a failure arms a
 * retry schedule instead of stopping the loop. A schedule wakes the match
 * even after both players have left and it went to sleep.
 */
async function reportResult(c: ActorContextOf<typeof rankedMatch>) {
	try {
		if (await reportMatchCompletedIfNeeded(c)) await saveMatch(c);
	} catch (error) {
		c.log.warn({ msg: "reporting the match result failed; retrying", error });
		c.vars.reportRetryScheduled = true;
		await c.schedule.after(REPORT_RETRY_MS, "retryReport");
	}
}

/**
 * Writes the phase, tick, winner, whether the result was reported, and both
 * players' positions and scores to SQLite in one transaction, so a crash
 * leaves either the previous save or this one, never part of both.
 */
async function saveMatch(c: ActorContextOf<typeof rankedMatch>) {
	// Copy the values first, because actions such as updatePosition can run
	// while the transaction waits on SQLite.
	const { tick, phase, winnerId, resultReported } = c.vars;
	const players = Object.entries(c.vars.players).map(
		([username, player]) => ({
			username,
			x: player.x,
			y: player.y,
			score: player.score,
		}),
	);

	await c.db.transaction(
		async (tx) => {
			await tx.execute(
				"UPDATE match_info SET tick = ?, phase = ?, winner_id = ?, result_reported = ? WHERE id = 1",
				tick,
				phase,
				winnerId,
				resultReported ? 1 : 0,
			);
			for (const player of players) {
				await tx.execute(
					"UPDATE roster SET x = ?, y = ?, score = ? WHERE username = ?",
					player.x,
					player.y,
					player.score,
					player.username,
				);
			}
		},
		{ name: "save-match" },
	);
}

interface Snapshot {
	matchId: string;
	tick: number;
	phase: "waiting" | "live" | "finished";
	winnerId: string | null;
	worldSize: number;
	scoreLimit: number;
	players: Record<
		string,
		{ x: number; y: number; color: string; score: number; rating: number }
	>;
}

interface ShootEvent {
	shooterId: string;
	fromX: number;
	fromY: number;
	dirX: number;
	dirY: number;
	hitPlayerId: string | null;
}

function buildSnapshot(c: ActorContextOf<typeof rankedMatch>): Snapshot {
	const players: Snapshot["players"] = {};
	for (const [id, entry] of Object.entries(c.vars.players)) {
		players[id] = {
			x: entry.x,
			y: entry.y,
			color: entry.color,
			score: entry.score,
			rating: entry.rating,
		};
	}
	return {
		matchId: c.vars.matchId,
		tick: c.vars.tick,
		phase: c.vars.phase,
		winnerId: c.vars.winnerId,
		worldSize: WORLD_SIZE,
		scoreLimit: SCORE_LIMIT,
		players,
	};
}

function findPlayerByConnId(
	vars: MatchVars,
	connId: string,
): [string, PlayerEntry] | null {
	for (const [id, entry] of Object.entries(vars.players)) {
		if (entry.connId === connId) return [id, entry];
	}
	return null;
}

/** Sends the match result to the matchmaker once. Returns true if this call sent it. */
async function reportMatchCompletedIfNeeded(
	c: ActorContextOf<typeof rankedMatch>,
	options?: { allowNoResult?: boolean },
): Promise<boolean> {
	const allowNoResult = options?.allowNoResult ?? false;

	if (c.vars.resultReported) return false;
	if (c.vars.phase !== "finished" && !allowNoResult) return false;

	const client = c.client<typeof registry>();
	const entries = Object.entries(c.vars.players);
	if (c.vars.winnerId && entries.length === 2) {
		const loserUsername = entries.find(
			([id]) => id !== c.vars.winnerId,
		)?.[0];
		const winner = c.vars.players[c.vars.winnerId];
		const loser = loserUsername
			? c.vars.players[loserUsername]
			: undefined;
		if (winner && loser && loserUsername) {
			const [newWR, newLR] = calculateElo(winner.rating, loser.rating);
			await client.rankedMatchmaker.getOrCreate(["main"]).matchCompleted({
				matchId: c.vars.matchId,
				winnerUsername: c.vars.winnerId,
				loserUsername,
				winnerNewRating: newWR,
				loserNewRating: newLR,
			});
			c.vars.resultReported = true;
			return true;
		}
	}
	if (!allowNoResult) return false;

	await client.rankedMatchmaker.getOrCreate(["main"]).matchCompleted({
		matchId: c.vars.matchId,
		winnerUsername: "",
		loserUsername: "",
		winnerNewRating: 0,
		loserNewRating: 0,
	});
	c.vars.resultReported = true;
	return true;
}

function calculateElo(
	winnerRating: number,
	loserRating: number,
): [number, number] {
	const expectedW = 1 / (1 + 10 ** ((loserRating - winnerRating) / 400));
	const expectedL = 1 - expectedW;
	return [
		Math.round(winnerRating + K_FACTOR * (1 - expectedW)),
		Math.round(loserRating + K_FACTOR * (0 - expectedL)),
	];
}