Divákov: ${s.spectators}. Hra sa začne až po kliknutí tvorcu miestnosti na „Spustiť hru“. Potrební sú aspoň dvaja hráči a všetci pripojení hráči musia mať pripravený tím. Po začatí sa ďalší môžu pripojiť ako diváci.
${I?(I.ready?``:``):`Si divák; hra už beží alebo sú všetky miesta obsadené.`}${s.you===0&&s.players.filter(Boolean).length>=2&&s.players.filter(Boolean).every(p=>p.ready)?``:""}
Divákov: ${s.spectators}. Hra sa začne až po kliknutí tvorcu miestnosti na „Spustiť hru“. Potrební sú aspoň dvaja hráči a všetci pripojení hráči musia mať pripravený tím. Po začatí sa ďalší môžu pripojiť ako diváci.
${I?(I.ready?``:``):`Si divák; hra už beží alebo sú všetky miesta obsadené.`}${s.you===(s.host??0)&&s.players.filter(Boolean).length>=2&&s.players.filter(Boolean).every(p=>p.ready)?``:""}
`}
function draftHTML(){const D=UI.draft,pel=D.picks.includes("pellegrini"),r=pel?D.res:1,nT=TEAM-r;const who=D.online||D.vsAI?"Vyber si tím":`Hráč ${D.p+1} si vyberá tím`;const line=D.picks.length?`Stôl: ${D.picks.slice(0,nT).map(k=>DB[k].name).join(", ")||"–"}${D.picks.length>nT?` · Rezerva: ${D.picks.slice(nT).map(k=>DB[k].name).join(", ")}`:""}`:"Poradie výberu určuje, kto ide na stôl a kto do rezervy.";return `
`}
function render(){const s=UI.screen;const body=s==="menu"?menuHTML():s==="draft"?draftHTML():s==="lobby"?lobbyHTML():s==="room"?roomHTML():G?battleHTML():menuHTML();$.innerHTML=(UI.msg?`
${UI.msg}
`:"")+body}
diff --git a/server.js b/server.js
index 308a5f3..3288f79 100644
--- a/server.js
+++ b/server.js
@@ -16,6 +16,8 @@ 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áč";
@@ -24,16 +26,23 @@ function roomCode() {
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) => room.seats.findIndex(s => s && s.token === token);
+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, maxPlayers: room.seats.length, mode: room.mode,
+ 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 => c.seat < 0).length, G: room.G };
+ spectators: [...room.clients].filter(c => seatOf(room, c.token) < 0).length, G: room.G };
}
function broadcast(room) {
- room.touched = Date.now();
- for (const c of room.clients) c.res.write(`data: ${JSON.stringify(view(room, c.seat))}\n\n`);
+ 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)); }
@@ -68,8 +77,11 @@ function act(room, seat, a) {
return;
}
if (a.type === "start") {
- if (seat !== 0) return "Hru môže spustiť iba tvorca miestnosti.";
+ 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.";
@@ -77,18 +89,33 @@ function act(room, seat, a) {
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.forEach(s => { if (s) s.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()].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 })));
+ 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ť)
@@ -106,13 +133,14 @@ const server = http.createServer(async (req, res) => {
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 client = { res, seat }; room.clients.add(client); totalClients++;
- if (seat >= 0) room.seats[seat].conns++;
+ 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);
- req.on("close", () => {
+ res.on("close", () => {
if (room.clients.delete(client)) totalClients--;
- const s = seat >= 0 && room.seats[seat]; if (s) { s.conns = Math.max(0, s.conns - 1); s.lastSeen = Date.now(); }
- broadcast(room);
+ if (s) { s.conns = Math.max(0, s.conns - 1); s.lastSeen = Date.now(); }
+ if (rooms.get(room.id) === room) broadcast(room);
});
return;
}
@@ -123,7 +151,7 @@ const server = http.createServer(async (req, res) => {
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(), touched: Date.now() };
+ 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 });
@@ -131,6 +159,7 @@ const server = http.createServer(async (req, res) => {
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);
@@ -152,6 +181,13 @@ const server = http.createServer(async (req, res) => {
// 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(() => { for (const r of rooms.values()) if (!r.clients.size && Date.now() - r.touched > 30 * 60000) rooms.delete(r.id); }, 60000);
+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}`));
diff --git a/tests/rooms.js b/tests/rooms.js
new file mode 100644
index 0000000..4b7f724
--- /dev/null
+++ b/tests/rooms.js
@@ -0,0 +1,66 @@
+"use strict";
+// Životný cyklus miestností: odchod hráča, prenos zakladateľa, zánik prázdnej miestnosti.
+const assert = require("node:assert/strict");
+const { spawn } = require("node:child_process");
+const http = require("node:http");
+const path = require("node:path");
+
+const PORT = 3900 + Math.floor(Math.random() * 90);
+const base = `http://127.0.0.1:${PORT}`;
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+const post = async (p, b) => (await fetch(base + p, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(b) })).json();
+const rooms = async () => (await fetch(base + "/api/rooms")).json();
+// SSE pripojenie; vráti posledný prijatý stav a funkciu na zatvorenie
+function listen(room, token) {
+ const st = { last: null, ended: false };
+ const req = http.get(`${base}/api/events?room=${room}&token=${token}`, res => {
+ let buf = "";
+ res.on("data", d => { buf += d; let i; while ((i = buf.indexOf("\n\n")) >= 0) { const m = buf.slice(0, i); buf = buf.slice(i + 2); if (m.startsWith("data: ")) st.last = JSON.parse(m.slice(6)); } });
+ res.on("end", () => { st.ended = true; });
+ });
+ req.on("error", () => {});
+ st.close = () => req.destroy();
+ return st;
+}
+
+(async () => {
+ const srv = spawn(process.execPath, [path.join(__dirname, "..", "server.js")], { env: { ...process.env, PORT, ROOM_GRACE_MS: "600" }, stdio: "ignore" });
+ try {
+ for (let i = 0; i < 50; i++) { try { await fetch(base + "/api/ping"); break; } catch (e) { await sleep(100); } }
+
+ // 1) odchod jediného hráča zruší miestnosť hneď
+ const a = await post("/api/create", { name: "A", maxPlayers: 4 });
+ const ea = listen(a.room, a.token); await sleep(150);
+ assert.ok((await rooms()).some(r => r.id === a.room));
+ await post("/api/leave", { room: a.room, token: a.token }); await sleep(150);
+ assert.ok(!(await rooms()).some(r => r.id === a.room), "room should vanish after its only player leaves");
+ assert.ok(ea.ended, "open streams should be closed when the room is removed");
+
+ // 2) zakladateľ odíde pred hrou -> miesto sa uvoľní a zakladateľom je ďalší hráč
+ const b = await post("/api/create", { name: "B", maxPlayers: 4 });
+ const c = await post("/api/join", { room: b.room, name: "C" });
+ const eb = listen(b.room, b.token), ec = listen(b.room, c.token); await sleep(150);
+ await post("/api/leave", { room: b.room, token: b.token }); eb.close(); await sleep(150);
+ assert.equal(ec.last.players.filter(Boolean).length, 1);
+ assert.equal(ec.last.host, ec.last.you, "remaining player becomes host");
+ assert.deepEqual((await rooms()).find(r => r.id === b.room).players, ["C"]);
+
+ // 3) všetci sa odpoja bez odchodu -> miestnosť zmizne zo zoznamu hneď a po limite zanikne
+ ec.close(); await sleep(150);
+ assert.ok(!(await rooms()).some(r => r.id === b.room), "room without online players is hidden");
+ await sleep(1200);
+ assert.equal((await post("/api/join", { room: b.room, name: "D" })).error, "Miestnosť neexistuje.");
+
+ // 4) odchod počas hry = vzdanie sa, druhý hráč vyhráva
+ const d = await post("/api/create", { name: "D", maxPlayers: 2 });
+ const e = await post("/api/join", { room: d.room, name: "E" });
+ const ed = listen(d.room, d.token), ee = listen(d.room, e.token); await sleep(150);
+ await post("/api/act", { room: d.room, token: d.token, action: { type: "team", team: ["babis", "sutaj", "meciar", "lenart"] } });
+ await post("/api/act", { room: d.room, token: e.token, action: { type: "team", team: ["mihal", "kazimir", "kamenicky", "horvath"] } });
+ assert.deepEqual(await post("/api/act", { room: d.room, token: d.token, action: { type: "start" } }), { ok: true });
+ await post("/api/leave", { room: d.room, token: d.token }); ed.close(); await sleep(150);
+ assert.equal(ee.last.G.over, "Vyhráva E");
+ ee.close();
+ console.log("Rooms test OK: leave, host handover, cleanup of empty rooms, leave during game.");
+ } finally { srv.kill(); }
+})().catch(e => { console.error(e); process.exit(1); });
diff --git a/tests/smoke.js b/tests/smoke.js
index 5db4d24..facf7a1 100644
--- a/tests/smoke.js
+++ b/tests/smoke.js
@@ -22,8 +22,8 @@ for (const mode of ["fun", "balanced"]) {
}
if (mode === "balanced") {
const horvath = [...G.p[2].table, ...G.p[2].reserve].find(c => c.key === "horvath");
- assert.equal(horvath.hp, 250);
- assert.equal(horvath.atk, 60);
+ assert.equal(horvath.hp, 380);
+ assert.equal(horvath.atk, 100);
}
const attackerSeat = G.turn;
const attacker = G.p[attackerSeat].table[0];
diff --git a/tools/sim.js b/tools/sim.js
new file mode 100644
index 0000000..98c44bf
--- /dev/null
+++ b/tools/sim.js
@@ -0,0 +1,29 @@
+"use strict";
+// AI-vs-AI simulácia, vypíše úspešnosť každej karty:
+// node tools/sim.js public/game.js balanced 40000 2
+const fs=require("fs"),vm=require("vm");
+const [file,mode="balanced",N="3000",NP="2"]=process.argv.slice(2);
+let src=fs.readFileSync(file,"utf8").replace("const sleep=ms=>new Promise(r=>setTimeout(r,ms));","const sleep=ms=>Promise.resolve();");
+const mod={exports:{}};vm.runInNewContext(src,{module:mod,console,Math,Promise,setTimeout});
+const E=mod.exports;
+const keys=E.CARDS.map(c=>c[0]);
+const stat={};keys.forEach(k=>stat[k]={g:0,w:0});
+let firstW=0,draws=0,lens=[];
+(async()=>{
+for(let i=0;i<+N;i++){
+ const pool=E.shuffle(keys),teams=[],res=[];
+ for(let p=0;p<+NP;p++){const t=pool.slice(p*4,p*4+4);teams.push(t);res.push(t.includes("pellegrini")?E.rnd([0,1,2]):1)}
+ const G=E.newGame(teams,res,{ai:teams.map(()=>true),mode});
+ let guard=0;while(!G.over&&guard++<100000)await new Promise(r=>setImmediate(r));
+ const m=/Vyhráva Hráč (\d)/.exec(G.over||"");lens.push(G.round);
+ if(!m){draws++;continue}
+ const w=+m[1]-1;if(w===G.first)firstW++;
+ teams.forEach((t,p)=>t.forEach(k=>{stat[k].g++;if(p===w)stat[k].w++}));
+}
+const rows=keys.map(k=>[k,stat[k].g,stat[k].w/Math.max(1,stat[k].g)]).sort((a,b)=>b[2]-a[2]);
+console.log(`mode=${mode} games=${N} players=${NP} draws=${draws} firstPlayerWin=${(firstW/(N-draws)).toFixed(3)} avgRounds=${(lens.reduce((a,b)=>a+b,0)/lens.length).toFixed(1)}`);
+for(const r of rows)console.log(r[0].padEnd(12),String(r[1]).padStart(5),(r[2]*100).toFixed(1));
+const ws=rows.map(r=>r[2]),mean=ws.reduce((a,b)=>a+b)/ws.length;
+console.log("spread(sd)",(Math.sqrt(ws.reduce((a,b)=>a+(b-mean)**2,0)/ws.length)*100).toFixed(1));
+process.exit(0);
+})();
diff --git a/tools/tune.js b/tools/tune.js
new file mode 100644
index 0000000..f740342
--- /dev/null
+++ b/tools/tune.js
@@ -0,0 +1,39 @@
+"use strict";
+// Iteratívne ladenie BALANCED_STATS podľa AI-vs-AI simulácie (2 hráči); výsledok zapíše do tuned.json:
+// node tools/tune.js public/game.js 16 30000
+const fs=require("fs"),vm=require("vm");
+const FILE=process.argv[2],ITERS=+process.argv[3]||10,N=+process.argv[4]||30000;
+const base=fs.readFileSync(FILE,"utf8").replace("const sleep=ms=>new Promise(r=>setTimeout(r,ms));","const sleep=ms=>Promise.resolve();");
+function load(stats){
+ const src=base.replace(/const BALANCED_STATS=\{[^\n]*\};/,"const BALANCED_STATS="+JSON.stringify(stats)+";");
+ const mod={exports:{}};vm.runInNewContext(src,{module:mod,console,Math,Promise,setTimeout});return mod.exports;
+}
+async function run(E,n,np){
+ const keys=E.CARDS.map(c=>c[0]),st={};keys.forEach(k=>st[k]={g:0,w:0});
+ for(let i=0;itrue),mode:"balanced"});
+ let g=0;while(!G.over&&g++<100000)await new Promise(r=>setImmediate(r));
+ const m=/Vyhráva Hráč (\d)/.exec(G.over||"");if(!m)continue;const w=+m[1]-1;
+ teams.forEach((t,p)=>t.forEach(k=>{st[k].g++;if(p===w)st[k].w++}));
+ }
+ return Object.fromEntries(keys.map(k=>[k,st[k].w/Math.max(1,st[k].g)]));
+}
+const r10=x=>Math.max(10,Math.round(x/10)*10);
+(async()=>{
+ const E0=load({});const keys=E0.CARDS.map(c=>c[0]);
+ const f=Object.fromEntries(keys.map(k=>[k,1]));
+ const statsOf=()=>Object.fromEntries(keys.map(k=>{const d=E0.DB[k];return [k,[r10(d.hp*f[k]),d.atk?r10(d.atk*f[k]):0]]}));
+ for(let it=0;it=ITERS-4?N*2:N,2);
+ const ws=Object.values(wr),mean=ws.reduce((a,b)=>a+b)/ws.length,sd=Math.sqrt(ws.reduce((a,b)=>a+(b-mean)**2,0)/ws.length);
+ const ext=Object.entries(wr).sort((a,b)=>b[1]-a[1]);
+ console.error(`iter ${it} sd=${(sd*100).toFixed(1)} max=${ext[0][0]} ${(ext[0][1]*100).toFixed(1)} min=${ext.at(-1)[0]} ${(ext.at(-1)[1]*100).toFixed(1)}`);
+ const damp=it<4?0.8:ita+Math.log(f[k]),0)/keys.length);for(const k of keys)f[k]/=gm}
+ }
+ fs.writeFileSync("tuned.json",JSON.stringify(statsOf()));
+ console.log(JSON.stringify(statsOf()));
+ process.exit(0);
+})();