다빈치 코드 조커 숨김·공개 타일 표시, 바퀴벌레 포커 내 빠른 말 표시, 난수를 ChaCha20으로

- 다빈치 코드: 조커를 놓는 단계(placeJoker)를 상대·관전자 화면에는 바로 전 단계로 보여 줌(서버 view)
- 다빈치 코드: 공개된 타일은 반 칸 위로 올리고 아래에 노란 줄, 숨은 타일은 제자리
- 바퀴벌레 포커: 내가 한 빠른 말도 내 자리 위 말풍선으로 표시
- 난수: 새 게임은 256비트 OS 시드 + ChaCha20(RFC 8439, 암호학적 생성기). 옛 게임(128비트)은 sfc32 그대로라 다시 보기 동일
- 테스트: RFC 테스트 벡터, 균등성(카이제곱), 상태 이어받기, 조커 단계 비공개

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
EJClaw
2026-10-11 03:12:48 +09:00
parent 92e8b2100f
commit 0fe7e27eb2
10 changed files with 207 additions and 41 deletions

View File

@@ -1,5 +1,5 @@
import { describe, expect, test } from 'bun:test';
import { SeededRng, createSeed, seedFromHex, seedToHex } from './rng';
import { SeededRng, chachaBlock, createSeed, seedFromHex, seedToHex } from './rng';
describe('SeededRng', () => {
test('is deterministic for the same seed', () => {
@@ -34,3 +34,67 @@ describe('SeededRng', () => {
expect(seedFromHex(seedToHex(seed))).toEqual(seed);
});
});
describe('ChaCha20 (new games)', () => {
test('block function matches the RFC 8439 §2.3.2 test vector', () => {
const key = [0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c, 0x13121110, 0x17161514, 0x1b1a1918, 0x1f1e1d1c];
const out = chachaBlock(key, 1, [0x09000000, 0x4a000000, 0x00000000]);
expect([...out].map((n) => n.toString(16).padStart(8, '0'))).toEqual([
'e4e7f110', '15593bd1', '1fdd0f50', 'c47120a3', 'c7f4d1c7', '0368c033', '9aaa2204', '4e6cd4c3',
'466482d2', '09aa9f07', '05d7c214', 'a2028bd9', 'd19c12b5', 'b94e16de', 'e883d0cb', '4e3c50a2',
]);
});
test('new seeds are 256 bits from the OS and pick ChaCha20; old 128-bit seeds keep sfc32', () => {
const seed = createSeed();
expect(seed).toHaveLength(8);
expect(seedToHex(seed)).toMatch(/^[0-9a-f]{64}$/);
expect(seedFromHex(seedToHex(seed))).toEqual(seed);
expect(SeededRng.fromSeed(seed).state()).toHaveLength(11);
expect(SeededRng.fromSeed(seedFromHex('00000001000000020000000300000004')).state()).toHaveLength(4);
// Old games replay exactly as before.
const old = SeededRng.fromSeed([1, 2, 3, 4]);
expect([old.nextUint32(), old.nextUint32(), old.nextUint32()]).toEqual([417285410, 1196253302, 123583739]); // sfc32 output before 2026-10-11
});
test('deterministic, and the saved state resumes exactly (also at a block boundary)', () => {
const seed = createSeed();
const a = SeededRng.fromSeed(seed);
const b = SeededRng.fromSeed(seed);
for (let i = 0; i < 100; i++) expect(a.nextUint32()).toBe(b.nextUint32());
for (const k of [0, 1, 15, 16, 17, 31, 32, 33]) {
const r = SeededRng.fromSeed(seed);
for (let i = 0; i < k; i++) r.nextUint32();
const saved = JSON.parse(JSON.stringify(r.state()));
const resumed = new SeededRng(saved);
for (let i = 0; i < 40; i++) expect(resumed.nextUint32()).toBe(r.nextUint32());
}
});
test('uniform: dice, cards and bits', () => {
const r = SeededRng.fromSeed(createSeed());
const counts = new Array(6).fill(0);
for (let i = 0; i < 60000; i++) counts[r.int(6)]++;
// chi-square with 5 degrees of freedom: 20.5 is the 0.1% tail.
const chi = counts.reduce((acc, c) => acc + (c - 10000) ** 2 / 10000, 0);
expect(chi).toBeLessThan(20.5);
const first = new Array(52).fill(0);
for (let i = 0; i < 52000; i++) first[r.shuffle(Array.from({ length: 52 }, (_, j) => j))[0]!]++;
const chi52 = first.reduce((acc, c) => acc + (c - 1000) ** 2 / 1000, 0);
expect(chi52).toBeLessThan(97); // 51 dof, 0.01% tail
let ones = 0;
for (let i = 0; i < 10000; i++) {
let x = r.nextUint32();
while (x) {
ones += x & 1;
x >>>= 1;
}
}
expect(Math.abs(ones / 320000 - 0.5)).toBeLessThan(0.005);
});
test('two games never share a seed', () => {
const seen = new Set(Array.from({ length: 1000 }, () => seedToHex(createSeed())));
expect(seen.size).toBe(1000);
});
});

View File

@@ -1,8 +1,18 @@
/**
* Deterministic seeded PRNG (sfc32). The state is four 32-bit unsigned ints and is
* JSON-serialisable so it can be persisted next to the game state (docs/09 §3).
* Deterministic seeded random numbers, JSON-serialisable so the state is persisted next to the game state (docs/09 §3)
* and a whole game can be replayed and checked from its seed (docs/04 §5).
*
* New games (2026-10-11): ChaCha20 (RFC 8439) keyed by a 256-bit seed from the OS (`crypto.getRandomValues`).
* It is a cryptographic generator: seeing any number of dice, cards or tiles tells nothing about the next ones
* (sfc32 is fast but its state can be worked out from enough outputs). Games started before keep sfc32 (4-word
* seeds/states), so their replays and saved games stay exactly the same.
*
* State layouts: sfc32 `[a, b, c, d]`; ChaCha20 seed `[k0..k7]`, state `[k0..k7, block, used, 0]`.
*/
export type RngState = [number, number, number, number];
export type Sfc32State = [number, number, number, number];
export type ChaChaSeed = [number, number, number, number, number, number, number, number];
export type ChaChaState = [number, number, number, number, number, number, number, number, number, number, number];
export type RngState = Sfc32State | ChaChaSeed | ChaChaState;
export interface Rng {
/** Float in [0, 1). */
@@ -13,46 +23,99 @@ export interface Rng {
shuffle<T>(arr: readonly T[]): T[];
}
export function createSeed(): RngState {
const buf = new Uint32Array(4);
/** A fresh 256-bit seed from the operating system's secure random source. */
export function createSeed(): ChaChaSeed {
const buf = new Uint32Array(8);
crypto.getRandomValues(buf);
// An all-zero state would be degenerate for sfc32's counter; guard anyway.
if (buf[0] === 0 && buf[1] === 0 && buf[2] === 0 && buf[3] === 0) buf[3] = 1;
return [buf[0]!, buf[1]!, buf[2]!, buf[3]!];
return [...buf] as ChaChaSeed;
}
export function seedToHex(seed: RngState): string {
return seed.map((n) => (n >>> 0).toString(16).padStart(8, '0')).join('');
}
export function seedFromHex(hex: string): RngState {
if (!/^[0-9a-f]{32}$/.test(hex)) throw new Error('invalid seed hex');
return [0, 1, 2, 3].map((i) => parseInt(hex.slice(i * 8, i * 8 + 8), 16) >>> 0) as RngState;
/** 32 hex digits = an sfc32 seed (older games), 64 = a ChaCha20 seed. */
export function seedFromHex(hex: string): Sfc32State | ChaChaSeed {
if (!/^([0-9a-f]{32}|[0-9a-f]{64})$/.test(hex)) throw new Error('invalid seed hex');
return Array.from({ length: hex.length / 8 }, (_, i) => parseInt(hex.slice(i * 8, i * 8 + 8), 16) >>> 0) as Sfc32State | ChaChaSeed;
}
/** Mutable PRNG over a copy of `state`; read the advanced state back with `rng.state()`. */
const rotl = (x: number, n: number) => ((x << n) | (x >>> (32 - n))) >>> 0;
/** ChaCha20 block (RFC 8439 §2.3) for `key`, block counter `counter`, nonce 0. Exported for the test vector. */
export function chachaBlock(key: readonly number[], counter: number, nonce: readonly number[] = [0, 0, 0]): Uint32Array {
const init = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574, ...key.map((k) => k >>> 0), counter >>> 0, ...nonce.map((n) => n >>> 0)];
const x = Uint32Array.from(init);
const qr = (a: number, b: number, c: number, d: number) => {
x[a] = (x[a]! + x[b]!) >>> 0;
x[d] = rotl(x[d]! ^ x[a]!, 16);
x[c] = (x[c]! + x[d]!) >>> 0;
x[b] = rotl(x[b]! ^ x[c]!, 12);
x[a] = (x[a]! + x[b]!) >>> 0;
x[d] = rotl(x[d]! ^ x[a]!, 8);
x[c] = (x[c]! + x[d]!) >>> 0;
x[b] = rotl(x[b]! ^ x[c]!, 7);
};
for (let i = 0; i < 10; i++) {
qr(0, 4, 8, 12);
qr(1, 5, 9, 13);
qr(2, 6, 10, 14);
qr(3, 7, 11, 15);
qr(0, 5, 10, 15);
qr(1, 6, 11, 12);
qr(2, 7, 8, 13);
qr(3, 4, 9, 14);
}
for (let i = 0; i < 16; i++) x[i] = (x[i]! + init[i]!) >>> 0;
return x;
}
/** Mutable generator over a copy of `state`; read the advanced state back with `rng.state()`. */
export class SeededRng implements Rng {
private a: number;
private b: number;
private c: number;
private d: number;
private a = 0;
private b = 0;
private c = 0;
private d = 0;
/** ChaCha20: key, current block number and words of it already used; null for sfc32. */
private key: number[] | null = null;
private blockNo = 0;
private used = 16;
private block: Uint32Array | null = null;
constructor(state: RngState) {
[this.a, this.b, this.c, this.d] = state.map((n) => n >>> 0) as RngState;
if (state.length === 4) {
[this.a, this.b, this.c, this.d] = state.map((n) => n >>> 0) as Sfc32State;
} else if (state.length === 11) {
this.key = state.slice(0, 8).map((n) => n >>> 0);
this.blockNo = state[8] >>> 0;
this.used = state[9];
} else throw new Error(`SeededRng: bad state length ${(state as number[]).length}`);
}
/** Seeds from a hex string, running a few warm-up rounds as recommended for sfc32. */
static fromSeed(seed: RngState): SeededRng {
/** sfc32 seeds run a few warm-up rounds as recommended; ChaCha20 seeds start at block 0. */
static fromSeed(seed: Sfc32State | ChaChaSeed | RngState): SeededRng {
if (seed.length === 8) return new SeededRng([...seed, 0, 0, 0] as ChaChaState);
const rng = new SeededRng(seed);
for (let i = 0; i < 12; i++) rng.nextUint32();
return rng;
}
state(): RngState {
if (this.key) return [...this.key, this.blockNo, this.used, 0] as ChaChaState;
return [this.a, this.b, this.c, this.d];
}
nextUint32(): number {
if (this.key) {
if (this.used >= 16) {
// This block is used up (also right after restoring a state saved at its end): move to the next one.
this.blockNo = (this.blockNo + 1) >>> 0;
this.used = 0;
this.block = null;
}
this.block ??= chachaBlock(this.key, this.blockNo);
return this.block[this.used++]!;
}
const t = (((this.a + this.b) >>> 0) + this.d) >>> 0;
this.d = (this.d + 1) >>> 0;
this.a = this.b ^ (this.b >>> 9);