Tarokka/server.ts

import next from 'next';
import { createServer } from 'http';
import { Server as SocketIOServer, type Socket } from 'socket.io';

import GameStore from '@/lib/GameStore';
import { omit } from '@/tools';

import { thirtyFPS } from '@/constants/time';
import type { ClientUpdate, GameUpdate, Tilt } from '@/types';

const dev = process.env.NODE_ENV !== 'production';
const hostname = '0.0.0.0';
const port = 3000;

const app = next({ dev, hostname, port });
const handler = app.getRequestHandler();

const gameStore = new GameStore();

const timedReleases = {};

app.prepare().then(() => {
	const httpServer = createServer(handler);
	const io = new SocketIOServer(httpServer);

	const broadcast = (event: string, gameUpdate: GameUpdate) => {
		io.to(gameUpdate.dmID).emit(event, gameUpdate);
		io.to(gameUpdate.spectatorID).emit(event, omit(gameUpdate, 'dmID'));
	};

	const timedRelease = (event: string, gameUpdate: GameUpdate, threshold: number) => {
		const now = Date.now();
		const lastEvent = timedReleases[event];
		clearTimeout(lastEvent?.to);

		if (lastEvent?.embargo >= now) {
			const embargo = lastEvent.embargo - now;

			const to = setTimeout(() => {
				broadcast(event, gameUpdate);
			}, embargo);

			timedReleases[event] = { embargo, to };
		} else {
			broadcast(event, gameUpdate);
			timedReleases[event] = { embargo: now + threshold };
		}
	};

	io.on('connection', (socket: Socket) => {
		//console.log(Date.now(), `Client connected: ${socket.id}`);

		socket.on('start', () => {
			const gameUpdate = gameStore.createGame(socket.id);

			console.log(
				Date.now(),
				`Socket ${socket.id} started game ${gameUpdate.dmID}/${gameUpdate.spectatorID}`,
			);

			socket.emit('new-game', gameUpdate);
		});

		socket.on('join', (gameID) => {
			try {
				const gameUpdate = gameStore.joinGame(gameID, socket.id);

				const ipAddress = Array.isArray(socket.handshake.headers['x-forwarded-for'])
					? socket.handshake.headers['x-forwarded-for'][0]
					: socket.handshake.headers['x-forwarded-for']?.split(',')[0];

				console.log(Date.now(), `Socket ${socket.id}[${ipAddress}] joined game ${gameID}`);

				socket.join(gameID);

				if (gameID === gameUpdate.spectatorID) {
					socket.emit('init', omit(gameUpdate, 'dmID'));
				} else {
					socket.emit('init', gameUpdate);
				}
			} catch (e) {
				const error = e instanceof Error ? e.message : e;

				console.error(Date.now(), 'Error[join]', error);
				socket.emit('join-error', error);
			}
		});

		socket.on('flip-card', ({ gameID, cardIndex }: ClientUpdate) => {
			try {
				//console.log(Date.now(), 'Card flipped:', { gameID, cardIndex });

				const gameUpdate = gameStore.flipCard(gameID, cardIndex);

				broadcast('game-update', gameUpdate);
			} catch (e) {
				const error = e instanceof Error ? e.message : e;

				console.error(Date.now(), 'Error[flip-card]', error);
				socket.emit('flip-error', error);
			}
		});

		socket.on('redraw', ({ gameID, cardIndex }: ClientUpdate) => {
			try {
				//console.log(Date.now(), 'Redraw', { gameID, cardIndex });

				const gameUpdate = gameStore.redraw(gameID, cardIndex);

				broadcast('game-update', gameUpdate);
			} catch (e) {
				const error = e instanceof Error ? e.message : e;

				console.error(Date.now(), 'Error[redraw]', error);
				socket.emit('redraw-error', error);
			}
		});

		socket.on('select', ({ gameID, cardIndex, cardID = '' }: ClientUpdate) => {
			try {
				//console.log(Date.now(), 'select', { gameID, cardIndex });

				const gameUpdate = gameStore.select(gameID, cardIndex, cardID);

				broadcast('game-update', gameUpdate);
			} catch (e) {
				const error = e instanceof Error ? e.message : e;

				console.error(Date.now(), 'Error[select]', error);
				socket.emit('select-error', error);
			}
		});

		socket.on('settings', ({ gameID, gameData }: { gameID: string; gameData: GameUpdate }) => {
			try {
				const gameUpdate = gameStore.updateSettings(gameID, gameData.settings);
				broadcast('game-update', gameUpdate);
			} catch (e) {
				const error = e instanceof Error ? e.message : e;
				console.error(Date.now(), 'Error[settings]', error);
			}
		});

		socket.on('tilt', ({ cardIndex, tilt }: { cardIndex: number; tilt: Tilt }) => {
			try {
				const gameState = gameStore.tilt(socket.id, cardIndex, tilt);
				timedRelease('game-update', gameState, thirtyFPS);
			} catch (e) {
				const error = e instanceof Error ? e.message : e;
				console.error(Date.now(), 'Error[tilt]', error);
			}
		});

		socket.on('disconnect', () => {
			try {
				const game = gameStore.playerExit(socket.id);

				if (game) {
					console.log(
						Date.now(),
						`Client disconnected: ${socket.id} from ${game.dmID}/${game.spectatorID}`,
					);
				}
			} catch (e) {
				const error = e instanceof Error ? e.message : e;
				console.error(Date.now(), 'Error[disconnect]', error);
			}
		});
	});

	httpServer
		.once('error', (err) => {
			console.error(Date.now(), 'Server error:', err);
			process.exit(1);
		})
		.listen(port, () => {
			console.log(Date.now(), `> Ready on http://${hostname}:${port}`);
		});
});