@v12-engine/engine 0.1.1 → 0.4.0

package/dist/server/gameServer.js

@@ -0,0 +1,643 @@
+import { engineMessage } from "../messages.js";
+import { readPlayerMessage } from "../session/wire.js";
+import { isFiniteNumber } from "../session/protocol.js";
+import { delayed } from "../session/delay.js";
+import { nodeNavigationBuilder } from "./navigation.js";
+import { serverLogger } from "./log.js";
+import { sameSecret } from "./secret.js";
+import { Doorman } from "./doorman.js";
+import { Lobby } from "./lobby.js";
+import { answerOps } from "./ops.js";
+import { Match } from "./match.js";
+import { startSocketServer } from "./websocket.js";
+//#region src/server/gameServer.ts
+/** The messages of the lobby: each told to everyone, or a key tried (`lobbyRate`) */
+var LOBBY_MESSAGES = /* @__PURE__ */ new Set([
+	"join",
+	"sit",
+	"ready",
+	"resume",
+	"name",
+	"start",
+	"setting",
+	"seatSetting",
+	"admin",
+	"lobbyChat",
+	"kick"
+]);
+/** How long a line said in the lobby may be */
+var LOBBY_LINE = 200;
+/** A token bucket: so many at once, filled again at so many a second */
+var Bucket = class {
+	rate;
+	tokens;
+	toppedUp = performance.now();
+	constructor(rate) {
+		this.rate = rate;
+		this.tokens = rate.burst;
+	}
+	/** Whether one more goes now: taken from the bucket, when it does */
+	take() {
+		const now = performance.now();
+		this.tokens = Math.min(this.rate.burst, this.tokens + (now - this.toppedUp) / 1e3 * this.rate.perSecond);
+		this.toppedUp = now;
+		if (this.tokens < 1) return false;
+		this.tokens--;
+		return true;
+	}
+};
+/**
+* A server of a game: its connections, who joins and where they go (`Doorman`), its lobby (`Lobby`: the seats, the
+* settings, when a game starts) and its game while one is on (`Match`)
+*
+* @beta
+*/
+var GameServer = class GameServer {
+	source;
+	options;
+	navigation;
+	/** Where the server is: `lobby` before the game, `game` while it is on, `ended` once it is over */
+	phase = "lobby";
+	clients = /* @__PURE__ */ new Set();
+	/** The keys of those the lobby voted out (`kick`): kept out until the server starts afresh (`reset`) */
+	kickedOut = /* @__PURE__ */ new Set();
+	/** Where each who joins goes */
+	doorman = new Doorman(this);
+	/** The seats, the settings, and when a game starts */
+	lobby;
+	/** The game on, or the one that ended while its players are still on its screen */
+	match;
+	constructor(source, options, logger, navigation) {
+		this.source = source;
+		this.options = options;
+		this.navigation = navigation;
+		const server = this;
+		this.logger = logger;
+		this.lobby = new Lobby({
+			options,
+			logger,
+			get phase() {
+				return server.phase;
+			},
+			tellAll: (message) => this.tellAll(message),
+			startGame: () => void this.startGame()
+		});
+		source.onConnection((connection) => this.accept(connection));
+	}
+	/** Starts a server, and resolves once it listens */
+	static async start(options) {
+		const logger = serverLogger(options.log);
+		const builder = options.navigationWorker !== false ? nodeNavigationBuilder() : void 0;
+		let server;
+		const socket = await startSocketServer({
+			port: options.port,
+			compress: options.compress,
+			idleTimeout: options.idleTimeout,
+			maxBuffered: options.maxBuffered,
+			maxConnections: options.maxConnections,
+			log: logger,
+			onRequest: (request, response) => {
+				if (server && answerOps(request, response, options.http, () => ({
+					draining: server.draining,
+					rooms: /* @__PURE__ */ new Map([["", server.metrics()]])
+				}), () => ({ games: [server.listing("")] }), {
+					ratings: options.ratings,
+					modes: [options.mode.id]
+				})) return;
+				response.writeHead(426, { "content-type": "text/plain" });
+				response.end("A game server: connect with a WebSocket\n");
+			}
+		});
+		server = new GameServer(socket, options, logger, builder && { builder });
+		return server.begin();
+	}
+	/**
+	* A server whose connections come from elsewhere (`ConnectionSource`): a room of `GameRooms`, those a port it shares
+	* hands it. Closing it closes those, and leaves where they come from to whoever owns it
+	*/
+	static async attach(source, options) {
+		return new GameServer(source, {
+			...options,
+			port: source.port
+		}, serverLogger(options.log)).begin();
+	}
+	/** Says it is there, and starts a game at once where the computer has every seat */
+	async begin() {
+		const { options, source } = this;
+		this.log(`${options.mode.name} (${options.mode.rules.id}) on port ${source.port}, ${this.seats.length} seats`);
+		if ((options.autoStart ?? true) && this.seats.every((seat) => seat.ai)) await this.startGame();
+		return this;
+	}
+	/**
+	* Its seats, in the mode's order: the server's own (its doorman's), a seat of a player is `publicSeat`'s
+	*
+	* @internal
+	*/
+	get seats() {
+		return this.lobby.seats;
+	}
+	/** The game's settings (`ServerHooks.settings`), as chosen in the lobby */
+	get settings() {
+		return this.lobby.settings;
+	}
+	/** The world of the game on, or of the one that ended while its players are still on its screen */
+	get world() {
+		return this.match?.world;
+	}
+	/** What sends the game to its players, while there is one */
+	get host() {
+		return this.match?.host;
+	}
+	/** Who paused the game: an admin, or a player (with a pause of theirs, for so long at most). Nobody while it runs */
+	get pausedBy() {
+		return this.match?.pausedBy;
+	}
+	/** When it started, for its uptime */
+	startedAt = performance.now();
+	/** Games played to their end */
+	played = 0;
+	/** What the hosts of the games before this one counted: the numbers go on from there */
+	past = {
+		ticks: 0,
+		tickTime: 0,
+		sends: 0,
+		sendTime: 0
+	};
+	/** It takes no new games: it is stopping once the running one is over (`close({ drain })`) */
+	draining = false;
+	/** Tells a stop that waits that the running game is over */
+	drained;
+	/** What a list of games says of it (`GET /games`, `GameListing`), as the room it is reached at */
+	listing(room) {
+		const { mode } = this.options;
+		const rating = this.lobby.rating();
+		return {
+			room,
+			game: mode.rules.id,
+			mode: mode.name,
+			phase: this.phase,
+			players: this.seats.filter((seat) => !seat.ai && seat.connected).length,
+			free: this.seats.filter((seat) => !seat.ai && seat.isFree).length,
+			computer: this.seats.filter((seat) => seat.ai).length,
+			watchers: this.watching,
+			settings: { ...this.settings },
+			draining: this.draining,
+			...rating !== void 0 && { rating }
+		};
+	}
+	/** How many are connected to it, playing or watching: none, for a room that may be closed */
+	get connections() {
+		return this.clients.size;
+	}
+	/** How many watch */
+	get watching() {
+		return [...this.clients].filter((client) => client.watching).length;
+	}
+	/** Its numbers now: what `/metrics` says (see `ServerMetrics`) */
+	metrics() {
+		const totals = this.host?.totals;
+		return {
+			phase: this.phase,
+			draining: this.draining,
+			uptime: (performance.now() - this.startedAt) / 1e3,
+			games: {
+				running: this.phase === "game" ? 1 : 0,
+				played: this.played
+			},
+			players: this.seats.filter((seat) => seat.connected).length,
+			watching: this.watching,
+			connections: this.clients.size,
+			ticks: this.past.ticks + (totals?.ticks ?? 0),
+			tickSeconds: (this.past.tickTime + (totals?.tickTime ?? 0)) / 1e3,
+			lastTickSeconds: (totals?.lastTick ?? 0) / 1e3,
+			sends: this.past.sends + (totals?.sends ?? 0),
+			sendSeconds: (this.past.sendTime + (totals?.sendTime ?? 0)) / 1e3,
+			bytesSent: this.bytesSent
+		};
+	}
+	/** The game let go of, what its host counted kept for the numbers */
+	dropMatch(options) {
+		const { match } = this;
+		if (!match) return;
+		const { host } = match;
+		match.stop();
+		this.past.ticks += host.totals.ticks;
+		this.past.tickTime += host.totals.tickTime;
+		this.past.sends += host.totals.sends;
+		this.past.sendTime += host.totals.sendTime;
+		host.dispose(options);
+		this.match = void 0;
+	}
+	/** The port the server listens on, the real one where 0 was asked for */
+	get port() {
+		return this.source.port;
+	}
+	/** Bytes sent to those connected now, as they went over the wire: compressed, where they are */
+	get bytesSent() {
+		let total = 0;
+		for (const client of this.clients) total += client.connection.bytesSent;
+		return total;
+	}
+	/** What the server and its games say: see `GameServerOptions.log` */
+	logger;
+	log(line, fields) {
+		this.logger.info("server", line, fields);
+	}
+	accept(connection) {
+		const { options } = this;
+		const client = {
+			connection,
+			watching: false,
+			commands: new Bucket(options.rate ?? {
+				perSecond: 30,
+				burst: 60
+			}),
+			messages: new Bucket(options.messageRate ?? {
+				perSecond: 100,
+				burst: 200
+			}),
+			lobby: new Bucket(options.lobbyRate ?? {
+				perSecond: 4,
+				burst: 20
+			}),
+			toGame: () => {},
+			fromGameClosed: () => {},
+			relay: void 0
+		};
+		client.relay = {
+			send: (message) => connection.send(message),
+			onMessage: (handler) => client.toGame = handler,
+			onClose: (handler) => client.fromGameClosed = handler,
+			close: () => connection.close()
+		};
+		this.clients.add(client);
+		connection.onMessage((text) => this.receive(client, text));
+		connection.onClose(() => this.leave(client));
+		const within = options.joinWithin ?? 10;
+		if (Number.isFinite(within)) {
+			client.deadline = setTimeout(() => {
+				if (client.joined || client.joining || !this.clients.has(client)) return;
+				this.log("a connection that did not join in time was closed", { address: connection.address });
+				connection.close();
+			}, Math.max(0, within) * 1e3);
+			client.deadline.unref?.();
+		}
+	}
+	tell(client, message) {
+		client.connection.send(JSON.stringify(message));
+	}
+	/** Tells everyone who joined: never a connection that has not (RV38) */
+	tellAll(message) {
+		for (const client of this.clients) if (client.joined) this.tell(client, message);
+	}
+	receive(client, text) {
+		if (!this.clients.has(client)) return;
+		const message = readPlayerMessage(text);
+		const { seat } = client;
+		if (!(message?.type === "command" && seat && this.phase === "game") && !client.messages.take()) return;
+		if (!message) return;
+		if (LOBBY_MESSAGES.has(message.type) && !client.lobby.take()) return;
+		switch (message.type) {
+			case "join": return this.join(client, {
+				type: "join",
+				name: typeof message.name === "string" ? message.name : void 0,
+				token: typeof message.token === "string" ? message.token : void 0,
+				ticket: typeof message.ticket === "string" ? message.ticket : void 0,
+				watch: message.watch === true,
+				key: typeof message.key === "string" ? message.key : void 0,
+				who: typeof message.who === "string" && message.who.length <= 128 ? message.who : void 0,
+				back: message.back === true,
+				protocol: isFiniteNumber(message.protocol) ? message.protocol : void 0
+			});
+			case "sit":
+				if (typeof message.player === "number") this.move(client, message.player);
+				return;
+			case "ready":
+				if (seat && typeof message.ready === "boolean") this.lobby.ready(seat, message.ready);
+				return;
+			case "resume":
+				if (seat && this.phase === "game" && this.pausedBy !== void 0 && this.pausedBy !== "admin") this.pause(false);
+				return;
+			case "name":
+				if (seat && typeof message.name === "string") this.lobby.rename(seat, message.name);
+				return;
+			case "start":
+				if (seat && this.phase === "lobby") this.startGame();
+				return;
+			case "setting": {
+				const { name, value } = message;
+				if (seat && typeof name === "string" && typeof value === "string") this.lobby.set(name, value);
+				return;
+			}
+			case "seatSetting": {
+				const { player, name, value } = message;
+				if (seat && typeof name === "string" && typeof value === "string" && typeof player === "number") this.lobby.setSeat(seat, player, name, value);
+				return;
+			}
+			case "lobbyChat": {
+				const text = typeof message.text === "string" ? message.text.trim().slice(0, LOBBY_LINE) : "";
+				if (!client.joined || this.phase !== "lobby" || !text) return;
+				return this.tellAll({
+					type: "lobbyChat",
+					...seat && { player: seat.player },
+					name: seat?.name ?? "A watcher",
+					text
+				});
+			}
+			case "kick": {
+				if (!seat || typeof message.player !== "number") return;
+				const out = this.lobby.voteKick(seat, message.player);
+				if (!out) return;
+				const theirs = [...this.clients].find((each) => each.seat === out);
+				if (theirs?.who) this.kickedOut.add(theirs.who);
+				return this.kick(out.player, "let go by a vote of the lobby");
+			}
+			case "admin": {
+				const { key, action } = message;
+				if (typeof key !== "string" || action !== "pause" && action !== "resume" && action !== "stop") return;
+				return this.admin(client, {
+					type: "admin",
+					key,
+					action
+				});
+			}
+			default: client.toGame(text);
+		}
+	}
+	/** Whether a command of this client's goes in: a bucket that fills at the rate allowed. Why not, when it does not */
+	allow(client) {
+		return client.commands.take() || engineMessage("tooManyCommands");
+	}
+	join(client, message) {
+		if (client.seat || client.watching || client.joining) return;
+		client.who = message.who;
+		client.name = message.name?.trim().slice(0, 24) || void 0;
+		if (message.who && this.kickedOut.has(message.who)) return this.enter(client, message, {
+			to: "refuse",
+			reason: "let go by a vote of the lobby"
+		});
+		const wrong = this.doorman.wrongWire(message);
+		if (wrong) {
+			this.log(`${message.name ?? "someone"} was refused: protocol ${message.protocol}, this server's is 13`, {
+				name: message.name,
+				protocol: message.protocol
+			});
+			return this.enter(client, message, {
+				to: "refuse",
+				reason: wrong
+			});
+		}
+		if (this.phase === "ended" && !message.back && message.token && this.seats.some((each) => each.token === message.token)) this.backToLobby(message.token);
+		const door = this.doorman.place(message, client.connection.address);
+		if (!(door instanceof Promise)) return this.enter(client, message, door);
+		client.joining = true;
+		door.then((placed) => {
+			client.joining = false;
+			if (this.clients.has(client) && !client.seat && !client.watching) this.enter(client, message, placed);
+		});
+	}
+	/** Takes who joined where the doorman said: a seat, watching, told every seat is taken, or away with why */
+	enter(client, message, door) {
+		if (door.to !== "refuse") {
+			client.joined = true;
+			clearTimeout(client.deadline);
+		}
+		switch (door.to) {
+			case "seat":
+				if ("id" in door) door.seat.id = door.id;
+				if ("rated" in door) door.seat.rated = door.rated;
+				return this.sit(client, door.seat, door.name, door.named);
+			case "watch": return this.watch(client);
+			case "full": return this.tell(client, { type: "full" });
+			case "refuse":
+				this.log(`${message.name ?? "someone"} was refused: ${door.reason}`, {
+					name: message.name,
+					reason: door.reason
+				});
+				this.tell(client, {
+					type: "refused",
+					reason: door.reason
+				});
+				return client.connection.close();
+		}
+	}
+	/** A seated player moves to another seat, free, in the lobby */
+	move(client, player) {
+		if (!client.seat) return;
+		const to = this.lobby.move(client.seat, player);
+		if (!to) return;
+		client.seat = to;
+		this.tell(client, {
+			type: "seated",
+			player: to.player,
+			token: to.token
+		});
+	}
+	/** Seats a client, and lets go whoever had the seat before: a player back from another page. A name the game gave goes in any phase */
+	sit(client, seat, name, named = false) {
+		const token = seat.take(client.connection, this.phase === "lobby" || named ? name : void 0);
+		client.seat = seat;
+		this.tell(client, {
+			type: "seated",
+			player: seat.player,
+			token
+		});
+		this.log(`${seat.name} took seat ${seat.player}`, {
+			name: seat.name,
+			player: seat.player
+		});
+		this.hooks.onPlayerJoin?.(this.publicSeat(seat), this.world);
+		if (this.phase === "lobby") return this.lobby.seated();
+		this.match?.keep();
+		this.seatInGame(client, seat);
+	}
+	/** The game's hooks */
+	get hooks() {
+		return this.options.mode.rules.server ?? {};
+	}
+	/**
+	* Who comes once the seats are taken watches, when the server lets them (`watch`): everything, the whole map without fog, every player's resources. From
+	* the side of the world's neutral player, so that nobody's units are theirs; from the first seat's, in a world without one
+	*/
+	watch(client) {
+		client.watching = true;
+		const { world, host } = this;
+		if (this.phase === "lobby" || !host || !world) {
+			this.tell(client, {
+				type: "watching",
+				player: this.seats[0].player
+			});
+			return this.lobby.broadcast();
+		}
+		const side = [...world.players.values()].find((player) => player.neutral)?.id ?? this.seats[0].player;
+		this.tell(client, {
+			type: "watching",
+			player: side
+		});
+		const delay = this.options.watchDelay ?? 0;
+		host.connect(side, delay > 0 ? delayed(client.relay, delay) : client.relay, {
+			readOnly: true,
+			observer: true,
+			name: client.name
+		});
+		if (!host.running && this.phase === "game") host.start();
+	}
+	seatInGame(client, seat) {
+		const { host } = this;
+		if (!host) return;
+		if (this.options.debug) this.world?.debugPlayers.add(seat.player);
+		host.connect(seat.player, client.relay, { allow: () => this.allow(client) });
+		if (!host.running && this.phase === "game") host.start();
+	}
+	leave(client) {
+		if (!this.clients.delete(client)) return;
+		clearTimeout(client.deadline);
+		client.fromGameClosed();
+		const { seat } = client;
+		if (!seat || seat.connection !== client.connection) return;
+		seat.drop();
+		this.log(`${seat.name} left seat ${seat.player}`, {
+			name: seat.name,
+			player: seat.player
+		});
+		this.hooks.onPlayerLeave?.(this.publicSeat(seat), this.world);
+		const anyone = this.seats.some((each) => each.connected);
+		if (this.phase === "lobby") this.lobby.left(seat);
+		else if (this.phase === "ended" && !anyone) this.reset();
+		else if (this.phase === "game" && !anyone) this.match?.abandon();
+	}
+	/**
+	* A seat as everyone is told it (the lobby, the hooks)
+	*
+	* @internal
+	*/
+	publicSeat(seat) {
+		return this.lobby.publicSeat(seat);
+	}
+	/** Makes the world, seats everyone at it, and runs it */
+	async startGame() {
+		if (this.phase !== "lobby" || this.draining) return;
+		this.phase = "game";
+		this.lobby.again = false;
+		const server = this;
+		const match = await Match.make({
+			options: this.options,
+			logger: this.logger,
+			seats: this.seats,
+			navigation: this.navigation,
+			fill: () => this.lobby.fill(),
+			get watching() {
+				return server.watching;
+			},
+			publicSeat: (seat) => this.publicSeat(seat),
+			tellAll: (message) => this.tellAll(message),
+			kick: (player, reason) => this.kick(player, reason),
+			end: () => void this.endGame()
+		}, this.settings);
+		this.match = match;
+		this.lobby.broadcast();
+		for (const client of this.clients) if (client.seat) this.seatInGame(client, client.seat);
+		else if (client.watching) this.watch(client);
+		match.run();
+	}
+	/** Lets a player go for good: told why, their connection closed, and their token and id no good any more */
+	kick(player, reason) {
+		const held = this.lobby.seat(player);
+		if (!held) return;
+		const client = [...this.clients].find((each) => each.seat === held);
+		held.revoke();
+		this.log(`${held.name} was let go from seat ${held.player}: ${reason}`, {
+			name: held.name,
+			player: held.player,
+			reason
+		});
+		if (!client) return;
+		this.tell(client, {
+			type: "refused",
+			reason
+		});
+		client.connection.close();
+	}
+	/** The game is over: the result told to everyone and kept. The game goes on being shown until everyone has left */
+	async endGame() {
+		const { match } = this;
+		if (!match || this.phase !== "game") return void 0;
+		this.phase = "ended";
+		this.played++;
+		const result = await match.end();
+		if (!this.seats.some((seat) => seat.connected)) this.reset();
+		this.drained?.();
+		return result;
+	}
+	/**
+	* Back to the lobby after a game, with who is still there in their seats: a player of it who joins again ("Again",
+	* with their seat's token) takes theirs, the seats of those gone are free
+	*/
+	backToLobby(keepToken) {
+		this.dropMatch({ closeTransports: false });
+		for (const client of this.clients) {
+			client.toGame = () => {};
+			client.fromGameClosed = () => {};
+		}
+		this.phase = "lobby";
+		this.lobby.backFromGame(keepToken);
+		this.log("back to the lobby, for another game");
+		this.lobby.broadcast();
+	}
+	/** Back to the lobby, for a new game: the old one gone, every seat free */
+	reset() {
+		this.dropMatch();
+		this.phase = "lobby";
+		this.lobby.reset();
+		this.kickedOut.clear();
+		this.log("back to the lobby");
+	}
+	admin(client, message) {
+		if (!this.options.adminKey || !sameSecret(message.key, this.options.adminKey)) return this.tell(client, {
+			type: "refused",
+			reason: "not an admin"
+		});
+		if (message.action === "stop") {
+			this.endGame();
+			return;
+		}
+		this.pause(message.action === "pause");
+	}
+	/**
+	* Pauses the game for everyone, or lets it go on. A player's pause (`by`, from the `pause` command) ends by itself
+	* after its seconds, or when a seated player says `resume`; an admin's, when the admin says so
+	*/
+	pause(paused, by) {
+		this.match?.pause(paused, by);
+	}
+	/**
+	* Stops the server: every connection closed. With `drain`, it first takes no new games (its health says so, for a
+	* load balancer to send nobody new) and waits for the running one to end, up to so many seconds: then it is ended
+	* (no winner, the players told the server stopped) and the server closes
+	*/
+	async close(options = {}) {
+		if (options.drain && !this.draining) {
+			this.draining = true;
+			this.log(`stopping: no new games, ${this.phase === "game" ? `the running one has ${options.drain} s to end` : "none running"}`);
+			if (this.phase === "game") {
+				let limit;
+				const over = await new Promise((resolve) => {
+					this.drained = () => resolve(true);
+					limit = setTimeout(() => resolve(false), options.drain * 1e3);
+				});
+				clearTimeout(limit);
+				this.drained = void 0;
+				if (!over) {
+					if (this.match) this.match.failed = "The server stopped";
+					await this.endGame();
+				}
+			}
+		}
+		this.dropMatch();
+		await this.source.close();
+	}
+};
+//#endregion
+export { GameServer };
+
+//# sourceMappingURL=gameServer.js.map