feat(lobbies): create lobbies module

Author: NathanFlurry

modules/lobbies/actors/lobby_manager.ts

@@ -0,0 +1,59 @@
+export const DEFAULT_CONFIG: FullConfig = {
+    lobbies: {
+        destroyOnEmptyAfter: 60 * 1000,
+        unreadyExpireAfter: 5 * 60 * 1000,
+        maxPlayers: 16,
+        maxPlayersDirect: 16,
+        enableCreate: false,
+        enableDestroy: false,
+        enableFind: true,
+        enableFindOrCreate: true,
+        enableJoin: true,
+        enableList: true,
+    },
+    lobbyRules: [],
+    players: {
+        maxPerIp: 8,
+        maxUnconnected: 128,
+        unconnectedExpireAfter: 60 * 1000,
+        autoDestroyAfter: 48 * 24 * 60 * 60 * 1000,
+    }
+};
+
+export type Config = Partial<FullConfig>;
+
+export interface FullConfig {
+    lobbies: LobbyConfig,
+    lobbyRules: LobbyRule[],
+	players: {
+		maxPerIp?: number;
+		maxUnconnected?: number;
+		unconnectedExpireAfter: number;
+		autoDestroyAfter?: number;
+	}
+}
+
+export interface LobbyRule {
+    tags: Record<string, string>,
+    config: LobbyConfig,
+}
+
+export interface LobbyConfig {
+    destroyOnEmptyAfter?: number | null;
+    unreadyExpireAfter: number;
+    maxPlayers: number;
+    maxPlayersDirect: number;
+    enableDynamicMaxPlayers?: PlayerRange,
+    enableDynamicMaxPlayersDirect?: PlayerRange,
+    enableCreate: boolean,
+    enableDestroy: boolean,
+    enableFind: boolean,
+    enableFindOrCreate: boolean,
+    enableJoin: boolean,
+    enableList: boolean,
+}
+
+export interface PlayerRange {
+    min: number,
+    max: number,
+}

modules/lobbies/config.ts

@@ -0,0 +1,15 @@
+# Unconnected Players
+
+## Why it exists?
+
+- high load & low player caps
+- preventing botting
+
+## What happens when players fail to connect?
+
+- Unconnected players stack up
+- How lobbies API handles it
+  - Max players per IP: if creating another player and goes over ip limit, will
+    delete the old unconnected player for the same IP
+  - Maximum unconnected players: if too many unconnected players, we'll start
+    discarding the oldest unconnected player

modules/lobbies/docs/UNCONNECTED_PLAYERS.md

@@ -0,0 +1,45 @@
+{
+	"scripts": {
+		"create": {
+			"public": true
+		},
+		"destroy": {},
+		"find_or_create": {},
+		"join": {},
+		"list": {},
+		"set_lobby_ready": {},
+		"set_player_connected": {},
+		"set_player_disconnected": {},
+		"find": {
+			"description": "TODO: Doc connect to server asap afterwards."
+		},
+		"force_gc": {}
+	},
+	"actors": {
+		"lobby_manager": {
+			"storage_id": "lobby_manager"
+		}
+	},
+	"errors": {
+		"lobby_not_found": {},
+		"lobby_create_missing_players": {
+			"description": "When creating a lobby with `config.lobbies.autoDestroyWhenEmpty`, a lobby must be created with players in order to avoid creating an empty lobby."
+		},
+		"lobby_full": {},
+		"more_players_than_max": {
+			"description": "More players were passed to the create lobby than the number of max players in a lobby."
+		},
+		"lobby_already_ready": {},
+		"player_already_connected": {
+			"description": "The player has already connected to this server. This error helps mitigate botting attacks by only allowing one scoket to connect to a game server for every player."
+		},
+		"player_disconnected": {
+			"description": "The player has already disconnected from the server. Create a new player for the specified lobby using the `join` script."
+		},
+		"no_matching_lobbies": {},
+		"too_many_players_for_ip": {}
+	},
+	"dependencies": {
+		"tokens": {}
+	}
+}

modules/lobbies/module.json

@@ -0,0 +1,81 @@
+import {
+	CreateLobbyRequest,
+	CreateLobbyResponse,
+} from "../actors/lobby_manager.ts";
+import { ScriptContext } from "../module.gen.ts";
+import {
+	Lobby,
+	Player,
+	PlayerRequest,
+	PlayerWithToken,
+} from "../utils/types.ts";
+
+export interface Request {
+    version: string;
+	tags: Record<string, string>;
+	maxPlayers: number;
+    destroyOnEmptyAfter: number;
+
+	players: PlayerRequest[];
+}
+
+export interface Response {
+	lobby: Lobby;
+	players: PlayerWithToken[];
+}
+
+// TODO: Doc why we create tokens on the script and not the DO
+
+export async function run(
+	ctx: ScriptContext,
+	req: Request,
+): Promise<Response> {
+	let manager;
+	if (!await ctx.actors.lobbies.lobbyManager.exists("default")) {
+		manager = await ctx.actors.lobbies.lobbyManager.create("default", {});
+	} else {
+		manager = ctx.actors.lobbies.lobbyManager.get("default");
+	}
+
+	// Setup lobby
+	//
+	// This token will be disposed if the lobby is not created
+	const lobbyId = crypto.randomUUID();
+	const { token: lobbyToken } = await ctx.modules.tokens.create({
+		type: "lobby",
+		meta: { lobbyId: lobbyId },
+	});
+
+	// Setup players
+	const playerOpts: PlayerRequest[] = [];
+	const playerTokens: Record<string, string> = {};
+	for (const _player of req.players) {
+		const playerId = crypto.randomUUID();
+		const { token: playerToken } = await ctx.modules.tokens.create({
+			type: "player",
+			meta: { lobbyId: lobbyId, playerId: playerId },
+		});
+		playerOpts.push({ playerId });
+		playerTokens[playerId] = playerToken.token;
+	}
+
+	const { lobby, players }: CreateLobbyResponse = await manager.call(
+		"createLobby",
+		{
+			lobby: {
+                lobbyId,
+                version: req.version,
+                tags: req.tags,
+                lobbyToken: lobbyToken.token,
+                maxPlayers: req.maxPlayers,
+                destroyOnEmptyAfter: req.destroyOnEmptyAfter,
+			},
+            players: playerOpts,
+		} as CreateLobbyRequest,
+	);
+
+	return {
+		lobby,
+		players: players.map((x) => ({ token: playerTokens[x.id], ...x })),
+	};
+}

modules/lobbies/scripts/create.ts

@@ -0,0 +1,28 @@
+import { DestroyLobbyRequest } from "../actors/lobby_manager.ts";
+import { ScriptContext } from "../module.gen.ts";
+
+export interface Request {
+	lobbyId: string;
+}
+
+export interface Response {
+}
+
+export async function run(
+	ctx: ScriptContext,
+	req: Request,
+): Promise<Response> {
+	let manager;
+	if (!await ctx.actors.lobbies.lobbyManager.exists("default")) {
+		manager = await ctx.actors.lobbies.lobbyManager.create("default", {});
+	} else {
+		manager = ctx.actors.lobbies.lobbyManager.get("default");
+	}
+
+	await manager.call(
+		"destroyLobby",
+		{ lobbyId: req.lobbyId } as DestroyLobbyRequest,
+	);
+
+	return {};
+}

modules/lobbies/scripts/destroy.ts

@@ -0,0 +1,58 @@
+import {
+	FindLobbyRequest,
+	FindLobbyResponse,
+} from "../actors/lobby_manager.ts";
+import { ScriptContext } from "../module.gen.ts";
+import { Lobby, PlayerRequest, PlayerWithToken } from "../utils/types.ts";
+
+export interface Request {
+    version: string;
+	tags: Record<string, string>;
+	players: PlayerRequest[];
+}
+
+export interface Response {
+	lobby: Lobby;
+	players: PlayerWithToken[];
+}
+
+export async function run(
+	ctx: ScriptContext,
+	req: Request,
+): Promise<Response> {
+	let manager;
+	if (!await ctx.actors.lobbies.lobbyManager.exists("default")) {
+		manager = await ctx.actors.lobbies.lobbyManager.create("default", {});
+	} else {
+		manager = ctx.actors.lobbies.lobbyManager.get("default");
+	}
+
+	// Setup players
+	const playerOpts: PlayerRequest[] = [];
+	const playerTokens: Record<string, string> = {};
+	for (const _player of req.players) {
+		const playerId = crypto.randomUUID();
+		const { token: playerToken } = await ctx.modules.tokens.create({
+			type: "player",
+			meta: { playerId: playerId },
+		});
+		playerOpts.push({ playerId });
+		playerTokens[playerId] = playerToken.token;
+	}
+
+	const { lobby, players }: FindLobbyResponse = await manager.call(
+		"findLobby",
+		{
+            query: {
+                version: req.version,
+                tags: req.tags,
+            },
+            players: playerOpts,
+        } as FindLobbyRequest,
+	);
+
+	return {
+		lobby,
+		players: players.map((x) => ({ token: playerTokens[x.id], ...x })),
+	};
+}

modules/lobbies/scripts/find.ts

@@ -0,0 +1,79 @@
+import {
+	FindOrCreateLobbyRequest,
+	FindOrCreateLobbyResponse,
+} from "../actors/lobby_manager.ts";
+import { ScriptContext } from "../module.gen.ts";
+import { Lobby, PlayerRequest, PlayerWithToken } from "../utils/types.ts";
+
+export interface Request {
+    version: string,
+	tags: Record<string, string>;
+	players: PlayerRequest[];
+
+    createConfig: {
+        tags: Record<string, string>;
+        maxPlayers: number;
+        destroyOnEmptyAfter: number;
+    }
+}
+
+export interface Response {
+	lobby: Lobby;
+	players: PlayerWithToken[];
+}
+
+export async function run(
+	ctx: ScriptContext,
+	req: Request,
+): Promise<Response> {
+	let manager;
+	if (!await ctx.actors.lobbies.lobbyManager.exists("default")) {
+		manager = await ctx.actors.lobbies.lobbyManager.create("default", {});
+	} else {
+		manager = ctx.actors.lobbies.lobbyManager.get("default");
+	}
+
+	// Setup lobby
+	const lobbyId = crypto.randomUUID();
+	const { token: lobbyToken } = await ctx.modules.tokens.create({
+		type: "lobby",
+		meta: { lobbyId: lobbyId },
+	});
+
+	// Setup players
+	const playerOpts: PlayerRequest[] = [];
+	const playerTokens: Record<string, string> = {};
+	for (const _player of req.players) {
+		const playerId = crypto.randomUUID();
+		const { token: playerToken } = await ctx.modules.tokens.create({
+			type: "player",
+			meta: { playerId: playerId },
+		});
+		playerOpts.push({ playerId });
+		playerTokens[playerId] = playerToken.token;
+	}
+
+	const { lobby, players }: FindOrCreateLobbyResponse = await manager.call(
+		"findOrCreateLobby",
+		{
+            query: {
+                version: req.version,
+                tags: req.tags,
+            },
+            lobby: {
+                lobbyId,
+                version: req.version,
+                tags: req.createConfig.tags,
+                lobbyToken: lobbyToken.token,
+                maxPlayers: req.createConfig.maxPlayers,
+                destroyOnEmptyAfter: req.createConfig.destroyOnEmptyAfter,
+            },
+            players: playerOpts,
+		} as FindOrCreateLobbyRequest,
+	);
+
+	return {
+		lobby,
+		players: players.map((x) => ({ token: playerTokens[x.id], ...x })),
+	};
+}

modules/lobbies/scripts/find_or_create.ts

@@ -0,0 +1,23 @@
+import { ScriptContext } from "../module.gen.ts";
+
+export interface Request {
+}
+
+export interface Response {
+}
+
+export async function run(
+	ctx: ScriptContext,
+	req: Request,
+): Promise<Response> {
+	let manager;
+	if (!await ctx.actors.lobbies.lobbyManager.exists("default")) {
+		manager = await ctx.actors.lobbies.lobbyManager.create("default", {});
+	} else {
+		manager = ctx.actors.lobbies.lobbyManager.get("default");
+	}
+
+	await manager.call("gc");
+
+	return {};
+}