서버: Cloudflare Workers 멀티플레이 백엔드 (Phase 4~6 서버 측)

- 게스트/이메일/Google 계정, 게스트 기록 이전, 닉네임 정책
- GameRoomDO: 커스텀 1:1·FFA, 가비지 중계·배율·장기전, 타겟팅, KO, 재접속 유예, 리매치 투표
- MatchmakerDO + Glicko-2 + TR/18랭크 + 리그 결과 기록
- 리더보드·솔로 기록·시즌/RD 감쇠 Cron
- 단위 테스트 17개 + 종단 테스트 스크립트

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-04 09:27:15 +09:00
parent 845969297e
commit 8fcef8e720
18 changed files with 3558 additions and 0 deletions

177
server/test/room.test.js Normal file
View File

@@ -0,0 +1,177 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { RoomLogic } from "../src/room-logic.js";
function mkRoom(kind = "custom", extra = {}) {
let t = 1_000_000;
const clock = { now: () => t, adv: (ms) => (t += ms) };
let seed = 1;
const rand = () => ((seed = (seed * 16807) % 2147483647) / 2147483647);
const r = new RoomLogic({ id: "R", kind, code: "ABCDEF", now: clock.now, rand, ...extra });
return { r, clock };
}
const msgs = (r, uid, type) => r.drain().out.filter((o) => (o.to === null ? o.except !== uid : o.to === uid) && (!type || o.msg.t === type)).map((o) => o.msg);
const startPlaying = (r, clock) => { r.handle(r.host, { t: "start" }); clock.adv(3001); r.tick(); };
test("커스텀 1:1: 호스트 시작 → 가비지 → 톱아웃 → 라운드 승리", () => {
const { r, clock } = mkRoom();
r.join("a", { nick: "A" });
r.join("b", { nick: "B" });
assert.equal(r.host, "a");
r.drain();
r.handle("b", { t: "start" }); // 호스트 아님
assert.equal(r.phase, "lobby");
r.handle("a", { t: "start" });
assert.equal(r.phase, "countdown");
const starts = r.drain().out.filter((o) => o.msg.t === "round_start");
assert.equal(starts.length, 2);
assert.ok(starts.every((o) => o.msg.seed > 0));
clock.adv(3001);
r.tick();
assert.equal(r.phase, "playing");
r.handle("a", { t: "attack", lines: 4, pieces: 3 });
const g = msgs(r, "b", "garbage");
assert.deepEqual(g, [{ t: "garbage", from: "a", lines: 4 }]);
r.handle("b", { t: "topout" });
const out = r.drain().out.map((o) => o.msg);
assert.ok(out.find((m) => m.t === "ko" && m.who === "b" && m.by === "a"));
const end = out.find((m) => m.t === "round_end");
assert.equal(end.winner, "a");
assert.equal(end.score.a, 1);
assert.equal(r.phase, "between"); // FT 무제한 → 다음 라운드 대기
clock.adv(4001);
r.tick();
assert.equal(r.phase, "countdown");
assert.equal(r.round, 2);
});
test("가비지 배율 0.5× 는 소수 누적(carry)으로 공정하게", () => {
const { r, clock } = mkRoom();
r.join("a"); r.join("b");
r.handle("a", { t: "rules", rules: { garbageMul: 0.5, overtime: false } });
startPlaying(r, clock);
r.drain();
r.handle("a", { t: "attack", lines: 1, pieces: 1 });
assert.equal(msgs(r, "b", "garbage").length, 0);
r.handle("a", { t: "attack", lines: 1, pieces: 2 });
assert.equal(msgs(r, "b", "garbage")[0].lines, 1);
});
test("안티치트: 비정상 공격량·PPS 는 무시", () => {
const { r, clock } = mkRoom();
r.join("a"); r.join("b");
startPlaying(r, clock);
r.drain();
r.handle("a", { t: "attack", lines: 40, pieces: 1 });
r.handle("a", { t: "attack", lines: 4, pieces: 500 });
assert.equal(msgs(r, "b", "garbage").length, 0);
assert.equal(r.players.get("a").flagged, 2);
});
test("FFA 4인: 타겟 수동 지정, KO 순위, 최후 생존자 승리, FT1 → match_end → 리매치 과반", () => {
const { r, clock } = mkRoom();
for (const u of ["a", "b", "c", "d"]) r.join(u, { nick: u.toUpperCase() });
r.handle("a", { t: "rules", rules: { ft: 1 } });
startPlaying(r, clock);
r.drain();
r.handle("a", { t: "target", id: "c" });
r.handle("a", { t: "attack", lines: 2, pieces: 2 });
assert.equal(msgs(r, "c", "garbage")[0].from, "a");
r.handle("c", { t: "topout" });
assert.equal(r.players.get("c").place, 4);
r.handle("a", { t: "attack", lines: 2, pieces: 3 }); // 수동 타겟이 죽었으니 자동 타겟으로
const atk = r.drain().out.find((o) => o.msg.t === "garbage");
assert.ok(["b", "d"].includes(atk.to));
r.handle("d", { t: "topout" });
r.handle("b", { t: "topout" });
assert.equal(r.phase, "match_end");
const { effects } = r.drain();
assert.equal(effects[0].type, "custom_end");
assert.equal(effects[0].standings[0].id, "a");
r.handle("a", { t: "rematch", vote: true });
r.handle("b", { t: "rematch", vote: true });
assert.equal(r.phase, "match_end"); // 2/4 는 과반 아님
r.handle("c", { t: "rematch", vote: true });
assert.equal(r.phase, "countdown");
assert.equal(r.players.get("a").wins, 0);
});
test("도중 입장은 관전 후 다음 라운드부터 참전", () => {
const { r, clock } = mkRoom();
r.join("a"); r.join("b");
startPlaying(r, clock);
r.join("c");
assert.equal(r.players.get("c").inRound, false);
r.handle("b", { t: "topout" });
clock.adv(4001);
r.tick();
assert.equal(r.players.get("c").inRound, true);
});
test("호스트 퇴장 시 다음 입장자에게 위임", () => {
const { r } = mkRoom();
r.join("a"); r.join("b"); r.join("c");
r.handle("a", { t: "leave" });
assert.equal(r.host, "b");
});
test("재접속 유예 15초: 그 안에 돌아오면 유지, 넘기면 톱아웃", () => {
const { r, clock } = mkRoom();
r.join("a"); r.join("b"); r.join("c");
startPlaying(r, clock);
r.disconnect("b");
clock.adv(10_000); r.tick();
assert.equal(r.players.get("b").alive, true);
r.handle("a", { t: "target", id: "b" });
r.handle("a", { t: "attack", lines: 2, pieces: 2 });
r.drain();
r.join("b");
const back = msgs(r, "b");
assert.ok(back.find((m) => m.t === "sync"));
assert.ok(back.find((m) => m.t === "garbage" && m.lines === 2)); // 끊긴 동안 받은 가비지 재전달
r.disconnect("c");
clock.adv(15_001); r.tick();
assert.equal(r.players.get("c").alive, false);
});
test("리그: 지정된 2명만 입장, 둘 다 오면 자동 시작, FT3, 이탈은 몰수패", () => {
const { r, clock } = mkRoom("league", { allowed: ["a", "b"], ft: 3 });
assert.equal(r.join("x").ok, false);
r.join("a");
assert.equal(r.phase, "lobby");
r.join("b");
assert.equal(r.phase, "countdown");
for (let i = 0; i < 2; i++) {
clock.adv(3001); r.tick();
r.handle("b", { t: "topout" });
clock.adv(4001); r.tick();
}
assert.equal(r.players.get("a").wins, 2);
r.drain();
r.disconnect("a");
clock.adv(15_001); r.tick();
assert.equal(r.phase, "match_end");
const { effects } = r.drain();
assert.deepEqual({ w: effects[0].winner, l: effects[0].loser }, { w: "b", l: "a" });
assert.equal(r.finished, true);
});
test("직렬화 왕복 (하이버네이션 복원)", () => {
const { r } = mkRoom();
r.join("a", { nick: "A" }); r.join("b", { nick: "B" });
const j = JSON.parse(JSON.stringify(r.toJSON()));
const r2 = RoomLogic.fromJSON(j);
assert.equal(r2.players.get("a").nick, "A");
assert.equal(r2.host, "a");
});
test("보드 스냅샷 검증·중계", () => {
const { r, clock } = mkRoom();
r.join("a"); r.join("b");
startPlaying(r, clock);
r.drain();
r.handle("a", { t: "board", grid: "x".repeat(200) });
assert.equal(msgs(r, "b", "board").length, 0);
r.handle("a", { t: "board", grid: ".".repeat(190) + "GGGGGGGGG.", lock: true });
assert.equal(msgs(r, "b", "board").length, 1);
});

83
server/test/rules.test.js Normal file
View File

@@ -0,0 +1,83 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import { attackFor, overtimeMultiplier, trFor, rankFor, leagueFt, randomRoomCode, isRoomCode, randomGuestName, looksLikeGuestName, sanitizeRules } from "../src/rules.js";
import { glickoUpdate } from "../src/glicko.js";
import { findPairs, compatible } from "../src/matchmaking.js";
test("가비지 전송 테이블 (§6)", () => {
assert.equal(attackFor({ lines: 1 }), 0);
assert.equal(attackFor({ lines: 2 }), 1);
assert.equal(attackFor({ lines: 3 }), 2);
assert.equal(attackFor({ lines: 4, difficult: true, b2b: 0 }), 4);
assert.equal(attackFor({ lines: 4, difficult: true, b2b: 1 }), 5); // B2B +1
assert.equal(attackFor({ lines: 1, tspin: "mini" }), 1);
assert.equal(attackFor({ lines: 0, tspin: "mini" }), 0);
assert.equal(attackFor({ lines: 2, tspin: "tspin", difficult: true, b2b: 0 }), 4);
assert.equal(attackFor({ lines: 3, tspin: "tspin", difficult: true, b2b: 0 }), 6);
assert.equal(attackFor({ lines: 1, combo: 1 }), 1); // 콤보 2번째 → +1
assert.equal(attackFor({ lines: 1, combo: 20 }), 5); // 이후 5 고정
assert.equal(attackFor({ lines: 4, allClear: true }), 9);
});
test("장기전 배율", () => {
assert.equal(overtimeMultiplier(89_999), 1);
assert.equal(overtimeMultiplier(90_000), 1.25);
assert.equal(overtimeMultiplier(120_000), 1.5);
assert.equal(overtimeMultiplier(200_000, false), 1);
});
test("TR·랭크·FT", () => {
assert.ok(trFor(1500, 350) < 1000);
assert.ok(trFor(2500, 60) > 24000);
assert.equal(rankFor(0), "D");
assert.equal(rankFor(7800), "A+");
assert.equal(rankFor(9199), "A+");
assert.equal(rankFor(9200), "S-");
assert.equal(rankFor(25000), "X+");
assert.equal(leagueFt(7000, 9199), 3);
assert.equal(leagueFt(1000, 9200), 5);
});
test("방 코드·게스트명·규칙", () => {
for (let i = 0; i < 200; i++) {
const c = randomRoomCode();
assert.ok(isRoomCode(c), c);
assert.ok(!/[I1O0]/.test(c));
}
const n = randomGuestName();
assert.match(n, /\d{3}$/);
assert.ok(looksLikeGuestName(n));
assert.ok(!looksLikeGuestName("홍길동"));
assert.deepEqual(sanitizeRules({ garbageMul: 9, ft: 7, sameBag: true }), { garbageMul: 2, ft: 0, sameBag: true, overtime: true });
});
test("Glicko-2: Glickman 논문 예제", () => {
const p = glickoUpdate({ r: 1500, rd: 200, vol: 0.06 }, [
{ r: 1400, rd: 30, score: 1 },
{ r: 1550, rd: 100, score: 0 },
{ r: 1700, rd: 300, score: 0 },
]);
assert.ok(Math.abs(p.r - 1464.06) < 0.05, String(p.r));
assert.ok(Math.abs(p.rd - 151.52) < 0.05, String(p.rd));
assert.ok(Math.abs(p.vol - 0.05999) < 0.0001, String(p.vol));
});
test("Glicko-2: 승자는 오르고 패자는 내려간다, RD 하한 58", () => {
const w = glickoUpdate({ r: 1500, rd: 350, vol: 0.06 }, [{ r: 1500, rd: 350, score: 1 }]);
const l = glickoUpdate({ r: 1500, rd: 350, vol: 0.06 }, [{ r: 1500, rd: 350, score: 0 }]);
assert.ok(w.r > 1500 && l.r < 1500);
const tight = glickoUpdate({ r: 1500, rd: 58, vol: 0.06 }, [{ r: 1500, rd: 58, score: 1 }]);
assert.ok(tight.rd >= 58);
});
test("매치메이킹: R±2RD 겹침, 대기 시간에 따라 확장", () => {
const now = 1_000_000;
const a = { uid: "a", r: 1500, rd: 50, joinedAt: now };
const b = { uid: "b", r: 1750, rd: 50, joinedAt: now };
assert.equal(compatible(a, b, now), false); // 250 > 100+100
assert.equal(compatible({ ...a, joinedAt: now - 60_000 }, { ...b, joinedAt: now - 60_000 }, now), true); // ×1.44
const c = { uid: "c", r: 1520, rd: 50, joinedAt: now };
const pairs = findPairs([b, a, c], now);
assert.equal(pairs.length, 1);
assert.deepEqual(pairs[0].map((x) => x.uid).sort(), ["a", "c"]);
});