server.js

const express = require("express");
const http = require("http");
const app = express();
const path = require("path");
const { WebSocketServer } = require("ws");
const {readFileSync} = require("fs");

const server = http.createServer(app);

const wss = new WebSocketServer({server: server});

const FLAG = readFileSync(path.join(__dirname, "flag.txt")).toString();

wss.on("connection", ws => {
	console.log("New connection!");
	let level = 0;
	let gameState = JSON.parse(JSON.stringify(levels[level]));
	let interval = setInterval(physicsLoop, 20);
	let goalTimer = 0;

	function physicsLoop() {
		applyVelocity(gameState.circle, gameState.rects);

		for (let obj of gameState.rects) {
			circleRectCollision(gameState.circle, obj);
		}
		if (circlesIntersecting(gameState.goal, gameState.circle)) {
			goalTimer++;
		} else {
			goalTimer = 0;
		}
		if (goalTimer > 50) {
			level++;
			if (level >= levels.length) {
				ws.send(JSON.stringify({
					type: "congrats",
					value: process.env.GZCTF_FLAG
				}));
				ws.close();
				return;
			}
			goalTimer = 0;
			gameState = JSON.parse(JSON.stringify(levels[level]));
			init();
		}
		ws.send(JSON.stringify({
			type: "ball",
			value: {
				x: gameState.circle.x,
				y: gameState.circle.y,
				moving: gameState.circle.dx + gameState.circle.dy > 0
			}
		}));
	}

	ws.send(JSON.stringify({
		type: "start"
	}));

	function init() {
		ws.send(JSON.stringify({
			type: "colliders",
			value: gameState.rects
		}));
		ws.send(JSON.stringify({
			type: "flag",
			value: gameState.goal
		}));
	}
	init();

	ws.on("message", data => {
		let parsed;
		try {
			parsed = JSON.parse(data.toString?.());
		} catch (e) {}
		if (!parsed) return;
		
		switch (parsed?.type) {
			case "launch":
				if (!parsed?.value) return;
				if (typeof parsed?.value?.dx !== "number") return;
				if (typeof parsed?.value?.dy !== "number") return;
				launchBall(gameState.circle, parsed.value);
			break;
			case "cheat":
				gameState.circle.x = gameState.goal.x;
				gameState.circle.y = gameState.goal.y;
			break;
		}
	});

	ws.on("close", () => {
		clearInterval(interval);
	});
})

app.get("/", (req, res)=>{
	res.sendFile(path.join(__dirname, "public", "index.html"))
});

const WALL_THICKNESS = 30;
const MAX_SPEED = 52;
const DECELERATION = 0.985;
let levels = [{
	goal: { x: 230, y: 420, r: 20 },
	circle: { x: 200, y: 200, dx: 0, dy: 0, r: 12 },
	rects: [
		[150, 500, 1000, WALL_THICKNESS],
		[150, 300, WALL_THICKNESS, 230],
		[150, 300, 800, WALL_THICKNESS],
		[1150, 50, WALL_THICKNESS, 480],
		[150, 50, 1000, WALL_THICKNESS],
		[150, 50, WALL_THICKNESS, 280],
		[400, 50, WALL_THICKNESS, 180],
		[600, 150, WALL_THICKNESS, 150],
		[800, 50, WALL_THICKNESS, 180],
		[500, 400, 450, WALL_THICKNESS]
	]
},{
	goal: { x: 340, y: 425, r: 20 },
	circle: { x: 100, y: 100, dx: 0, dy: 0, r: 12 },
	rects: [
		[50, 50, 1200, WALL_THICKNESS],
		[1200 + WALL_THICKNESS, 50, WALL_THICKNESS, 700 + WALL_THICKNESS],
		[50, 50, WALL_THICKNESS, 700],
		[50, 750, 1200, WALL_THICKNESS],

		[50, 120, 1130, WALL_THICKNESS],
		[1150, 130, WALL_THICKNESS, 580],
		[120, 680, 1050, WALL_THICKNESS],
		[120, 200, WALL_THICKNESS, 500],

		[120, 200, 980, WALL_THICKNESS],
		[1070, 220, WALL_THICKNESS, 400],
		[200, 590, 900, WALL_THICKNESS],
		[200, 270, WALL_THICKNESS, 330],

		[200, 270, 800, WALL_THICKNESS],
		[1000, 270, WALL_THICKNESS, 270],
		[300, 510, 700, WALL_THICKNESS],
		[280, 340, WALL_THICKNESS, 200],

		[280, 330, 670, WALL_THICKNESS],
		[920, 330, WALL_THICKNESS, 140],

		// :3
		[370, 390, 25, 25],
		[370, 440, 25, 25],
		[420, 370, 60, 25],
		[460, 370, 25, 110],
		[420, 415, 60, 25],
		[420, 460, 65, 25],
	]
},{
	goal: { x: 1100, y: 630, r: 20 },
	circle: { x: 250, y: 250, dx: 0, dy: 0, r: 12 },
	rects: [
		[50, 50, 400, WALL_THICKNESS],
		[50, 400, 420, WALL_THICKNESS],
		[50, 50, WALL_THICKNESS, 350],
		[450, 50, WALL_THICKNESS, 380],

		[700, 100, 200, WALL_THICKNESS],
		[700, 700, 500, WALL_THICKNESS],
		[700, 100, WALL_THICKNESS, 600],
		[900, 100, WALL_THICKNESS, 450],
		[900, 530, 300, WALL_THICKNESS],
		[1200, 530, WALL_THICKNESS, 200],
	]
}];

function circlesIntersecting(circle1, circle2) {	
	return Math.sqrt((circle2.x - circle1.x) ** 2 + (circle2.y - circle1.y) ** 2) <= circle1.r + circle2.r;
}

function launchBall(circle, vel) {
	if (circle.dx === 0 && circle.dy === 0) {
			circle.dx = vel.dx;
			circle.dy = vel.dy;
		if (circle.dx > MAX_SPEED) {
			circle.dx = MAX_SPEED;
		} else if (circle.dx < -MAX_SPEED) {
			circle.dx = -MAX_SPEED;
		}
		if (circle.dy > MAX_SPEED) {
			circle.dy = MAX_SPEED;
		} else if (circle.dy < -MAX_SPEED) {
			circle.dy = -MAX_SPEED;
		}
	}
}

function applyVelocity(circle, rects) {
	let initialX = circle.x;
	let initialY = circle.y;

	while (initialX === circle.x && initialY === circle.y &&
		(circle.dy !== 0 || circle.dx !== 0)) {
		circle.x += circle.dx;
		circle.y += circle.dy;

		for (let rect of rects) {
			if (circleRectCollision(circle, rect)) {
				circle.x = initialX;
				circle.y = initialY;

				while (circleRectCollision(circle, rect)) {
					circle.x += (circle.dx / Math.abs(circle.dx)) * circle.r;
					circle.y += (circle.dy / Math.abs(circle.dy)) * circle.r;
				}
			}
		}

		circle.dx = circle.dx * DECELERATION;
		circle.dy = circle.dy * DECELERATION;
		if (Math.abs(circle.dx * DECELERATION) < 0.15 && Math.abs(circle.dy * DECELERATION) < 0.15) {
			circle.dx = 0;
			circle.dy = 0;
		}
	}
}

function circleRectCollision(circle, rect) {
	let closestX = clamp(circle.x, rect[0], rect[0] + rect[2]);
	let closestY = clamp(circle.y, rect[1], rect[1] + rect[3]);

	let distanceX = circle.x - closestX;
	let distanceY = circle.y - closestY;
	let distanceSquared = (distanceX * distanceX) + (distanceY * distanceY);

	if (distanceSquared < (circle.r * circle.r)) {
		let distance = Math.sqrt(distanceSquared);
		let overlap = circle.r - distance;

		if (distance > 0) {
			circle.x += overlap * (distanceX / distance);
			circle.y += overlap * (distanceY / distance);
		}

		let velocityMagnitude = Math.sqrt(circle.dx * circle.dx + circle.dy * circle.dy);
		if (velocityMagnitude > 0) {
			let normalX = distanceX / distance;
			let normalY = distanceY / distance;
			let dotProduct = circle.dx * normalX + circle.dy * normalY;

			if (dotProduct < 0) {
				circle.dx -= 2 * dotProduct * normalX;
				circle.dy -= 2 * dotProduct * normalY;
			}
		}
		return true;
	}
	return false;
}

function clamp(value, min, max) {
	return Math.min(Math.max(value, min), max);
}

app.use(express.static(path.join(__dirname, "public")))

server.listen(8080);