Files
politickekarty/server.js
T
2026-11-18 10:59:06 +01:00

194 lines
11 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Politické karty – jednoduchý server na online hru.
// Bez závislostí: stačí Node.js 18+ a príkaz `node server.js`.
// Server drží stav každej miestnosti, sám vyhodnocuje pravidlá (public/game.js)
// a posiela stav všetkým pripojeným cez Server-Sent Events.
"use strict";
const http = require("http"), fs = require("fs"), path = require("path"), crypto = require("crypto");
const E = require("./public/game.js");
const PORT = process.env.PORT || 3000;
const PUB = path.join(__dirname, "public");
const MIME = { ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8",
".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif", ".svg": "image/svg+xml" };
const IMG_EXT = [".jpg", ".jpeg", ".png", ".webp", ".gif"];
const rooms = new Map(); // kód -> miestnosť
// limity živých SSE spojení (ochrana pred vyčerpaním pamäte)
const MAX_CLIENTS_PER_ROOM = Number(process.env.MAX_CLIENTS_PER_ROOM) || 64;
const MAX_CLIENTS_TOTAL = Number(process.env.MAX_CLIENTS_TOTAL) || 2000;
// miestnosť bez jediného pripojeného hráča sa zruší po tejto dobe (diváci ju nedržia)
const ROOM_GRACE_MS = Number(process.env.ROOM_GRACE_MS) || 2 * 60000;
let totalClients = 0;
const tok = () => crypto.randomBytes(12).toString("hex");
const clean = s => String(s || "").replace(/[<>&"'`]/g, "").trim().slice(0, 20) || "Hráč";
function roomCode() {
const A = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
for (;;) { let c = ""; for (let i = 0; i < 4; i++) c += A[crypto.randomInt(A.length)]; if (!rooms.has(c)) return c; }
}
const newSeat = name => ({ name, token: tok(), team: null, res: 1, conns: 0, lastSeen: Date.now() });
const seatOf = (room, token) => token ? room.seats.findIndex(s => s && s.token === token) : -1;
const hostOf = room => room.seats.findIndex(Boolean); // tvorca, po jeho odchode ďalší hráč v poradí
const hasOnlinePlayer = room => room.seats.some(s => s && s.conns > 0);
// presunie obsadené miesta na začiatok, aby index miesta = index hráča v hre
function compact(room) { const n = room.seats.length, live = room.seats.filter(Boolean); room.seats = live.concat(Array(n - live.length).fill(null)); }
function view(room, seat) {
return { room: room.id, phase: room.G ? "battle" : "pick", you: seat, host: hostOf(room), maxPlayers: room.seats.length, mode: room.mode,
players: room.seats.map(s => s && { name: s.name, ready: !!s.team, online: s.conns > 0 }),
spectators: [...room.clients].filter(c => seatOf(room, c.token) < 0).length, G: room.G };
}
function broadcast(room) {
for (const c of room.clients) c.res.write(`data: ${JSON.stringify(view(room, seatOf(room, c.token)))}\n\n`);
}
function closeRoom(room) {
rooms.delete(room.id);
for (const c of room.clients) c.res.end(); // klient sa skúsi znova pripojiť, dostane 404 a ukáže „Miestnosť už neexistuje“
}
function json(res, code, obj) { res.writeHead(code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }); res.end(JSON.stringify(obj)); }
function body(req) {
return new Promise((ok, bad) => {
let d = ""; req.on("data", c => { d += c; if (d.length > 20000) { bad(new Error("big")); req.destroy(); } });
req.on("end", () => { try { ok(JSON.parse(d || "{}")); } catch (e) { bad(e); } });
});
}
function join(room, name, token) {
let seat = token ? seatOf(room, token) : -1;
if (seat >= 0) return { room: room.id, token, seat }; // návrat toho istého hráča
if (room.G) return { room: room.id, token: tok(), seat: -1 }; // po začiatku hry už len divák
seat = room.seats.findIndex(s => !s);
// pred začiatkom hry sa dá prevziať miesto po hráčovi, ktorý je dlhšie preč
if (seat < 0) seat = room.seats.findIndex(s => s.conns === 0 && Date.now() - s.lastSeen > 30000);
if (seat < 0) return { room: room.id, token: tok(), seat: -1 }; // divák
room.seats[seat] = newSeat(name);
return { room: room.id, token: room.seats[seat].token, seat };
}
function act(room, seat, a) {
if (seat < 0) return "Diváci nehrajú.";
const me = room.seats[seat];
if (!a || typeof a.type !== "string") return "Neplatná akcia.";
if (a.type === "team") {
if (room.G) return "Hra už beží.";
const t = a.team;
if (!Array.isArray(t) || t.length !== E.TEAM || new Set(t).size !== t.length || !t.every(k => typeof k === "string" && Object.hasOwn(E.DB, k))) return "Neplatný tím.";
me.team = t; me.res = t.includes("pellegrini") && [0, 1, 2].includes(a.res) ? a.res : 1;
return;
}
if (a.type === "start") {
if (seat !== hostOf(room)) return "Hru môže spustiť iba zakladateľ miestnosti.";
if (room.G) return "Hra už beží.";
// odpojení hráči bez tímu nebránia štartu, ich miesta sa uvoľnia
room.seats = room.seats.map(s => s && (s.team || s.conns > 0) ? s : null);
compact(room);
const players = room.seats.filter(Boolean);
if (players.length < 2) return "Na hru treba aspoň dvoch hráčov.";
if (!players.every(s => s.team)) return "Všetci pripojení hráči musia mať pripravený tím.";
room.G = E.newGame(players.map(s => s.team), players.map(s => s.res), { names: players.map(s => s.name), ai: players.map(() => false), mode: room.mode });
return;
}
if (a.type === "unready") { if (!room.G) me.team = null; return; }
if (a.type === "rematch") {
if (room.G && room.G.over) { room.G = null; room.seats = room.seats.map(s => s && !s.left ? s : null); room.seats.forEach(s => { if (s) s.team = null; }); }
return;
}
if (!room.G) return "Hra ešte nezačala.";
E.G = room.G; // pravidlá pracujú nad stavom tejto miestnosti
return E.applyAction(seat, a);
}
// hráč opúšťa miestnosť: pred hrou a po nej sa miesto uvoľní, počas hry sa vzdá
function leave(room, token) {
const seat = seatOf(room, token);
if (seat < 0) return;
if (room.G && !room.G.over) {
room.seats[seat].left = true;
E.G = room.G;
E.applyAction(seat, { type: "resign" });
} else room.seats[seat] = null;
if (!room.seats.some(Boolean)) closeRoom(room);
}
const server = http.createServer(async (req, res) => {
const u = new URL(req.url, "http://x");
try {
if (u.pathname === "/api/ping") return json(res, 200, { ok: true });
if (u.pathname === "/api/rooms")
return json(res, 200, [...rooms.values()].filter(hasOnlinePlayer).map(r => ({ id: r.id, phase: r.G ? "battle" : "pick", players: r.seats.filter(Boolean).map(s => s.name), maxPlayers: r.seats.length, mode: r.mode })));
if (u.pathname === "/api/images") {
const out = {};
// meciar.webp = hotový obrázok, meciar.kandidat.webp = dočasný kandidát z webu (hotový má prednosť)
try { for (const f of fs.readdirSync(path.join(PUB, "img"))) {
const e = path.extname(f).toLowerCase(), b = path.basename(f, path.extname(f)).toLowerCase();
const cand = b.endsWith(".kandidat"), k = cand ? b.slice(0, -9) : b;
if (IMG_EXT.includes(e) && Object.hasOwn(E.DB, k) && (!out[k] || !cand)) out[k] = "img/" + encodeURIComponent(f);
} } catch (e) {}
return json(res, 200, out);
}
if (u.pathname === "/api/events") {
const room = rooms.get(u.searchParams.get("room"));
if (!room) return json(res, 404, { error: "Miestnosť neexistuje." });
const seat = seatOf(room, u.searchParams.get("token"));
if (totalClients >= MAX_CLIENTS_TOTAL || (seat < 0 && room.clients.size >= MAX_CLIENTS_PER_ROOM))
return json(res, 503, { error: "Príliš veľa pripojení, skús neskôr." });
res.writeHead(200, { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-store", Connection: "keep-alive", "X-Accel-Buffering": "no" });
const s = seat >= 0 ? room.seats[seat] : null; // samotné miesto, nie index (index sa môže zmeniť)
const client = { res, token: u.searchParams.get("token") }; room.clients.add(client); totalClients++;
if (s) s.conns++;
broadcast(room);
res.on("close", () => {
if (room.clients.delete(client)) totalClients--;
if (s) { s.conns = Math.max(0, s.conns - 1); s.lastSeen = Date.now(); }
if (rooms.get(room.id) === room) broadcast(room);
});
return;
}
if (req.method === "POST" && u.pathname.startsWith("/api/")) {
const b = await body(req);
if (u.pathname === "/api/create") {
if (rooms.size >= 500) return json(res, 200, { error: "Server je plný, skús neskôr." });
const requested = Number(b.maxPlayers);
const maxPlayers = Number.isInteger(requested) ? Math.max(2, Math.min(8, requested)) : 6;
const mode = b.mode === "balanced" ? "balanced" : "fun";
const room = { id: roomCode(), seats: Array(maxPlayers).fill(null), G: null, mode, clients: new Set(), emptySince: 0 };
room.seats[0] = newSeat(clean(b.name));
rooms.set(room.id, room);
return json(res, 200, { room: room.id, token: room.seats[0].token, seat: 0, maxPlayers, mode });
}
const room = rooms.get(String(b.room || "").toUpperCase());
if (!room) return json(res, 200, { error: "Miestnosť neexistuje." });
if (u.pathname === "/api/join") { const r = join(room, clean(b.name), b.token); broadcast(room); return json(res, 200, r); }
if (u.pathname === "/api/leave") { leave(room, b.token); if (rooms.get(room.id) === room) broadcast(room); return json(res, 200, { ok: true }); }
if (u.pathname === "/api/act") {
let err; try { err = act(room, seatOf(room, b.token), b.action); } catch (e) { console.error(e); err = "Chyba servera pri ťahu."; }
broadcast(room);
return json(res, 200, err ? { error: err } : { ok: true });
}
return json(res, 404, { error: "Neznáma adresa." });
}
// statické súbory z public/
let rel; try { rel = decodeURIComponent(u.pathname); } catch (e) { rel = "/"; }
const file = path.join(PUB, path.normalize(rel === "/" ? "/index.html" : rel));
if (!file.startsWith(PUB + path.sep)) { res.writeHead(403); return res.end(); }
fs.readFile(file, (e, data) => {
if (e) { res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" }); return res.end("Nenájdené"); }
res.writeHead(200, { "Content-Type": MIME[path.extname(file).toLowerCase()] || "application/octet-stream", "Cache-Control": "no-cache" });
res.end(data);
});
} catch (e) { json(res, 400, { error: "Neplatná požiadavka." }); }
});
// udržiavanie spojení a upratovanie opustených miestností
setInterval(() => { for (const r of rooms.values()) for (const c of r.clients) c.res.write(": ping\n\n"); }, 25000);
setInterval(() => {
const now = Date.now();
for (const r of [...rooms.values()]) {
if (hasOnlinePlayer(r)) { r.emptySince = 0; continue; }
if (!r.emptySince) r.emptySince = now;
else if (now - r.emptySince > ROOM_GRACE_MS) closeRoom(r);
}
}, Math.min(10000, ROOM_GRACE_MS / 2));
server.listen(PORT, () => console.log(`Politické karty bežia na http://localhost:${PORT}`));