다빈치 코드 조커 숨김·공개 타일 표시, 바퀴벌레 포커 내 빠른 말 표시, 난수를 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:
@@ -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);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -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);
|
||||
|
||||
Reference in New Issue
Block a user