增加游戏玩法界面和各个弹窗初版
This commit is contained in:
1 parent
e84e14783e
commit
eb48d8e845
211 files changed
+59920
-21
No files matched your search
@@ -0,0 +1,560 @@
|
||||
import { test } from 'node:test';
|
||||
import { strict as assert } from 'node:assert';
|
||||
import { BETS, PAYLINES, PAYTABLE, SYMBOLS, evaluate, spin } from '../assets/orchard/scripts/SlotsMath';
|
||||
import type { SpinResult, SymbolId } from '../assets/orchard/scripts/SlotsMath';
|
||||
import { GameSession, initialState } from '../assets/orchard/scripts/GameSession';
|
||||
import type { GameState } from '../assets/orchard/scripts/GameSession';
|
||||
import { GameRepository } from '../assets/orchard/scripts/GameRepository';
|
||||
|
||||
// 独立规则夹具,避免用被测常量证明自身。 / Independent fixtures, not production-derived expectations.
|
||||
const ORDINARY = ['seven', 'bell', 'bar', 'strawberry', 'blueberry', 'plum', 'cherry', 'watermelon'] as const;
|
||||
const SYMBOL_IDS: SymbolId[] = [...ORDINARY, 'wild', 'scatter'];
|
||||
const WEIGHTS = [3, 5, 7, 10, 11, 13, 15, 30, 2, 4];
|
||||
const ODDS: Record<typeof ORDINARY[number], [number, number, number]> = {
|
||||
seven: [45, 158, 675], bell: [36, 113, 450], bar: [27, 90, 360],
|
||||
strawberry: [18, 54, 203], blueberry: [14, 45, 158], plum: [9, 27, 90],
|
||||
cherry: [5, 18, 68], watermelon: [5, 14, 45],
|
||||
};
|
||||
const LINES = ['MMMMM', 'TTTTT', 'BBBBB', 'TMBMT', 'BMTMB', 'MTTTM', 'MBBBM', 'MTBTM', 'MBTBM',
|
||||
'TMMMT', 'BMMMB', 'TTMMB', 'BBMMT', 'TMMBB', 'BMMTT', 'MTMMM', 'MBMMM', 'MMMTM', 'MMMBM', 'MTMBM']
|
||||
.map(line => [...line].map(row => ({ T: 0, M: 1, B: 2 })[row as 'T' | 'M' | 'B']));
|
||||
const SCOPE = 'https://example.test/FruitFixture/guest-a';
|
||||
const DAY = 86_400_000;
|
||||
const NOW = Date.parse('2026-11-20T12:00:00Z');
|
||||
const copy = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;
|
||||
|
||||
function board(symbol: SymbolId = 'scatter'): SymbolId[][] {
|
||||
return Array.from({ length: 5 }, () => Array<SymbolId>(3).fill(symbol));
|
||||
}
|
||||
|
||||
function sample(symbol: SymbolId): number {
|
||||
const index = SYMBOL_IDS.indexOf(symbol);
|
||||
return (WEIGHTS.slice(0, index).reduce((sum, weight) => sum + weight, 0) + WEIGHTS[index] / 2) / 100;
|
||||
}
|
||||
|
||||
function draws(values: number[]): () => number {
|
||||
let index = 0;
|
||||
return () => {
|
||||
assert.ok(index < values.length, 'unexpected random draw');
|
||||
return values[index++];
|
||||
};
|
||||
}
|
||||
|
||||
function randomFor(value: SymbolId[][], extra: number[] = []): () => number {
|
||||
return draws([...value.flat().map(sample), ...extra]);
|
||||
}
|
||||
|
||||
// 全部候选按最长前缀算奖后取最大;与实现共享的只有公开类型。 / Independent line-award oracle.
|
||||
function expectedWins(value: SymbolId[][], bet: number) {
|
||||
return LINES.flatMap((rows, line) => {
|
||||
const candidates = ORDINARY.map(symbol => {
|
||||
let count = 0;
|
||||
while (count < 5 && (value[count][rows[count]] === symbol || value[count][rows[count]] === 'wild')) count++;
|
||||
return { line, symbol, count, amount: count < 3 ? 0 : bet / 20 * ODDS[symbol][count - 3] };
|
||||
}).sort((a, b) => b.amount - a.amount);
|
||||
return candidates[0].amount === 0 ? [] : [candidates[0]];
|
||||
});
|
||||
}
|
||||
|
||||
function verifyEvaluation(value: SymbolId[][], bet: number): SpinResult {
|
||||
const before = copy(value);
|
||||
const result = evaluate(value, bet);
|
||||
const expected = expectedWins(value, bet);
|
||||
assert.deepEqual(result.board, before);
|
||||
assert.deepEqual(value, before, 'evaluation must not mutate the caller board');
|
||||
assert.deepEqual(result.wins.map(win => ({ line: win.line, symbol: win.symbol, count: win.count, amount: win.amount })), expected);
|
||||
assert.equal(result.win, expected.reduce((sum, win) => sum + win.amount, 0));
|
||||
assert.equal(new Set(result.wins.map(win => win.line)).size, result.wins.length, 'at most one award per line');
|
||||
assert.equal(result.wildColumn, null);
|
||||
return result;
|
||||
}
|
||||
|
||||
function memory() {
|
||||
const values = new Map<string, string>();
|
||||
return {
|
||||
values, reads: 0, writes: 0, failRead: 0, failWrite: false, silent: false, corrupt: false,
|
||||
beforeWrite: null as (() => void) | null,
|
||||
afterWrite: null as (() => void) | null,
|
||||
getItem(key: string): string | null {
|
||||
this.reads++;
|
||||
if (this.failRead > 0) { this.failRead--; throw new Error('fixture read failure'); }
|
||||
return values.get(key) ?? null;
|
||||
},
|
||||
setItem(key: string, value: string): void {
|
||||
this.writes++;
|
||||
this.beforeWrite?.();
|
||||
if (this.failWrite) throw new Error('fixture quota failure');
|
||||
if (!this.silent) values.set(key, this.corrupt ? '{broken write' : value);
|
||||
this.afterWrite?.();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
type Memory = ReturnType<typeof memory>;
|
||||
|
||||
function session(random: () => number = () => sample('scatter'), now: () => number = () => NOW, storage = memory()) {
|
||||
const game = new GameSession(new GameRepository(storage, SCOPE), random, now);
|
||||
return { game, storage };
|
||||
}
|
||||
|
||||
function persisted(storage: Memory): GameState {
|
||||
const saved = new GameRepository(storage, SCOPE).load();
|
||||
assert.ok(saved);
|
||||
return saved;
|
||||
}
|
||||
|
||||
function assertUnchanged(game: GameSession, storage: Memory, action: () => unknown): void {
|
||||
const before = game.state;
|
||||
const raw = [...storage.values];
|
||||
assert.throws(action);
|
||||
assert.deepEqual(game.state, before, 'rejected operation mutated memory');
|
||||
assert.deepEqual([...storage.values], raw, 'rejected operation overwrote storage');
|
||||
}
|
||||
|
||||
function freeReady(random: () => number = () => sample('scatter')) {
|
||||
let triggered = false;
|
||||
let normalDraws = 0;
|
||||
const fixture = session(() => {
|
||||
if (!triggered) {
|
||||
normalDraws++;
|
||||
if (normalDraws === 15) triggered = true;
|
||||
return sample('scatter');
|
||||
}
|
||||
return random();
|
||||
});
|
||||
const trigger = fixture.game.beginSpin();
|
||||
assert.equal(trigger.awarded, 16);
|
||||
fixture.game.completeSpin();
|
||||
assert.equal(fixture.game.state.phase, 'free-trigger');
|
||||
fixture.game.startFree();
|
||||
assert.equal(fixture.game.state.phase, 'free-ready');
|
||||
return fixture;
|
||||
}
|
||||
|
||||
test('gameplay constants exactly match the approved weights, 20 ordered paylines and paytable', () => {
|
||||
assert.deepEqual(SYMBOLS, SYMBOL_IDS);
|
||||
assert.deepEqual(BETS, [1000, 2000, 5000, 10000, 20000, 50000]);
|
||||
assert.deepEqual(PAYLINES, LINES);
|
||||
assert.equal(new Set(PAYLINES.map(line => line.join(''))).size, 20);
|
||||
assert.deepEqual(PAYTABLE, ODDS);
|
||||
});
|
||||
|
||||
test('every payline pays all eight symbols at 3/4/5 from the left and sums overlapping lines', () => {
|
||||
for (let line = 0; line < LINES.length; line++) {
|
||||
for (const symbol of ORDINARY) {
|
||||
for (const count of [3, 4, 5]) {
|
||||
const value = board();
|
||||
for (let col = 0; col < count; col++) value[col][LINES[line][col]] = symbol;
|
||||
const result = verifyEvaluation(value, 2000);
|
||||
const target = result.wins.find(win => win.line === line);
|
||||
assert.ok(target, `missing line=${line}, symbol=${symbol}, count=${count}`);
|
||||
assert.deepEqual({ symbol: target.symbol, count: target.count, amount: target.amount },
|
||||
{ symbol, count, amount: 100 * ODDS[symbol][count - 3] });
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('all legal bet levels scale line awards from total bet divided by twenty', () => {
|
||||
for (const bet of [1000, 2000, 5000, 10000, 20000, 50000]) {
|
||||
const result = verifyEvaluation(board('cherry'), bet);
|
||||
assert.equal(result.win, bet * 68);
|
||||
assert.equal(result.wins.length, 20);
|
||||
}
|
||||
});
|
||||
|
||||
test('WILD substitution pays the highest candidate, including a shorter seven and all-WILD', () => {
|
||||
for (const [symbols, symbol, count, multiplier] of [
|
||||
[['wild', 'wild', 'wild', 'bell', 'bell'], 'bell', 5, 450],
|
||||
[['wild', 'wild', 'wild', 'watermelon', 'bell'], 'seven', 3, 45],
|
||||
[['wild', 'wild', 'wild', 'wild', 'wild'], 'seven', 5, 675],
|
||||
[['wild', 'wild', 'watermelon', 'watermelon', 'bell'], 'watermelon', 4, 14],
|
||||
[['cherry', 'wild', 'cherry', 'scatter', 'cherry'], 'cherry', 3, 5],
|
||||
] as const) {
|
||||
const value = symbols.map(value => Array<SymbolId>(3).fill(value));
|
||||
const result = verifyEvaluation(value, 2000);
|
||||
assert.equal(result.wins.length, 20);
|
||||
for (const win of result.wins) {
|
||||
assert.equal(win.symbol, symbol); assert.equal(win.count, count); assert.equal(win.amount, multiplier * 100);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('SCATTER interrupts ordinary lines, has no line award and cannot be substituted by WILD', () => {
|
||||
for (const symbols of [
|
||||
['scatter', 'cherry', 'cherry', 'cherry', 'cherry'],
|
||||
['cherry', 'scatter', 'cherry', 'cherry', 'cherry'],
|
||||
['wild', 'wild', 'scatter', 'wild', 'wild'],
|
||||
['watermelon', 'bell', 'watermelon', 'watermelon', 'watermelon'],
|
||||
] as SymbolId[][]) {
|
||||
assert.equal(verifyEvaluation(symbols.map(symbol => Array<SymbolId>(3).fill(symbol)), 2000).win, 0);
|
||||
}
|
||||
const scatter = verifyEvaluation(board(), 2000);
|
||||
assert.deepEqual(scatter.wins, []); assert.equal(scatter.scatters, 15);
|
||||
});
|
||||
|
||||
test('SCATTER anywhere awards exactly 8/12/16 normal spins at 3/4/5 through 15', () => {
|
||||
const positions = [14, 0, 7, 4, 11, 2, 9, 6, 13, 1, 8, 5, 12, 3, 10];
|
||||
for (let count = 0; count <= 15; count++) {
|
||||
const value = board('cherry');
|
||||
for (const position of positions.slice(0, count)) value[Math.floor(position / 3)][position % 3] = 'scatter';
|
||||
const result = evaluate(value, 2000);
|
||||
assert.equal(result.scatters, count);
|
||||
assert.equal(result.awarded, count < 3 ? 0 : count === 3 ? 8 : count === 4 ? 12 : 16);
|
||||
}
|
||||
});
|
||||
|
||||
test('normal draws independently use all exact weight intervals, with fifteen draws per spin', () => {
|
||||
let lower = 0;
|
||||
for (let symbol = 0; symbol < SYMBOL_IDS.length; symbol++) {
|
||||
for (const value of [lower / 100, (lower + WEIGHTS[symbol] - 0.000001) / 100]) {
|
||||
let calls = 0;
|
||||
const result = spin(2000, false, () => { calls++; return value; });
|
||||
assert.deepEqual(result.board, board(SYMBOL_IDS[symbol]));
|
||||
assert.equal(calls, 15);
|
||||
assert.equal(result.wildColumn, null);
|
||||
}
|
||||
lower += WEIGHTS[symbol];
|
||||
}
|
||||
const value: SymbolId[][] = [
|
||||
['seven', 'bell', 'bar'], ['strawberry', 'blueberry', 'plum'], ['cherry', 'watermelon', 'wild'],
|
||||
['scatter', 'seven', 'bell'], ['bar', 'cherry', 'plum'],
|
||||
];
|
||||
assert.deepEqual(spin(2000, false, randomFor(value)), evaluate(value, 2000));
|
||||
});
|
||||
|
||||
test('free spins uniformly select exactly one column, preserve SCATTER, evaluate after conversion and never retrigger', () => {
|
||||
const original = board('cherry');
|
||||
for (let column = 0; column < 5; column++) original[column][1] = 'scatter';
|
||||
const before = copy(original);
|
||||
for (let column = 0; column < 5; column++) {
|
||||
for (const selector of [column / 5, (column + 1) / 5 - 0.00000001]) {
|
||||
const result = spin(2000, true, randomFor(original, [selector]));
|
||||
const expected = copy(original);
|
||||
expected[column][0] = 'wild'; expected[column][2] = 'wild';
|
||||
assert.equal(result.wildColumn, column);
|
||||
assert.deepEqual(result.board, expected);
|
||||
assert.deepEqual(result.wins, evaluate(expected, 2000).wins);
|
||||
assert.equal(result.win, evaluate(expected, 2000).win);
|
||||
assert.equal(result.scatters, 5);
|
||||
assert.equal(result.awarded, 0);
|
||||
}
|
||||
}
|
||||
assert.deepEqual(original, before);
|
||||
const firstColumnWild = spin(2000, true, draws([...Array<number>(15).fill(sample('bell')), 0]));
|
||||
assert.equal(firstColumnWild.win, 2000 * 450);
|
||||
});
|
||||
|
||||
test('invalid random samples are rejected at every draw, including the free column selection', () => {
|
||||
for (const invalid of [-1, -Number.EPSILON, 1, 1.1, NaN, Infinity, -Infinity]) {
|
||||
for (const index of [0, 7, 14]) {
|
||||
const values = Array<number>(15).fill(sample('cherry')); values[index] = invalid;
|
||||
assert.throws(() => spin(2000, false, draws(values)));
|
||||
}
|
||||
assert.throws(() => spin(2000, true, draws([...Array<number>(15).fill(sample('cherry')), invalid])));
|
||||
}
|
||||
assert.throws(() => spin(2000, false, () => { throw Error('entropy unavailable'); }));
|
||||
});
|
||||
|
||||
test('malformed boards and unsupported bets fail before they can be settled', () => {
|
||||
const malformed: unknown[] = [null, [], board().slice(0, 4), [...board(), ['cherry']], board().map(col => col.slice(0, 2)),
|
||||
[['unknown', 'cherry', 'cherry'], ...board().slice(1)]];
|
||||
for (const value of malformed) assert.throws(() => evaluate(value as SymbolId[][], 2000));
|
||||
for (const bet of [0, -2000, 1500, NaN, Infinity, Number.MAX_SAFE_INTEGER]) {
|
||||
assert.throws(() => evaluate(board(), bet));
|
||||
assert.throws(() => spin(bet, false, () => sample('cherry')));
|
||||
}
|
||||
});
|
||||
|
||||
test('initial state grants once and returns fresh board, settings and snapshots', () => {
|
||||
const first = initialState(); const second = initialState();
|
||||
assert.equal(first.version, 1); assert.equal(first.balance, 100000); assert.equal(first.bet, 2000);
|
||||
assert.equal(first.lastWin, 0); assert.equal(first.phase, 'idle'); assert.equal(first.sequence, 0);
|
||||
assert.equal(first.free, null); assert.equal(first.pending, null); assert.equal(first.lastClaimDay, null);
|
||||
assert.deepEqual(Object.keys(first.settings).sort(), ['music', 'sound', 'vibration']);
|
||||
for (const value of Object.values(first.settings)) assert.equal(typeof value, 'boolean');
|
||||
first.board[0][0] = first.board[0][0] === 'seven' ? 'bell' : 'seven'; first.settings.music = !first.settings.music;
|
||||
assert.notDeepEqual(first, second); assert.deepEqual(initialState(), second);
|
||||
const { game, storage } = session(); const writes = storage.writes;
|
||||
assert.equal(storage.values.size, 1, 'one JSON snapshot per scope');
|
||||
const restored = new GameSession(new GameRepository(storage, SCOPE), () => { throw Error('restore must not draw'); });
|
||||
assert.deepEqual(restored.state, game.state); assert.equal(storage.writes, writes);
|
||||
});
|
||||
|
||||
test('beginSpin atomically commits the paid bet, winnings and pending animation exactly once', () => {
|
||||
const { game, storage } = session(() => sample('cherry'));
|
||||
const writes = storage.writes;
|
||||
const result = game.beginSpin(); const committed = game.state;
|
||||
assert.equal(result.win, 136000);
|
||||
assert.equal(committed.balance, 100000 - 2000 + 136000);
|
||||
assert.equal(committed.lastWin, result.win); assert.equal(committed.phase, 'spinning');
|
||||
assert.equal(committed.sequence, 1); assert.equal(committed.pending?.id, 1);
|
||||
assert.equal(committed.pending?.free, false); assert.deepEqual(committed.pending?.result, result);
|
||||
assert.deepEqual(committed.board, result.board); assert.equal(committed.free, null);
|
||||
assert.equal(storage.writes, writes + 1, 'money and pending result require one write');
|
||||
assert.deepEqual(persisted(storage), committed);
|
||||
assertUnchanged(game, storage, () => game.beginSpin());
|
||||
game.completeSpin();
|
||||
assert.equal(game.state.phase, 'idle'); assert.equal(game.state.pending, null);
|
||||
assert.equal(game.state.balance, committed.balance); assert.equal(game.state.lastWin, result.win);
|
||||
const after = game.state; const afterWrites = storage.writes;
|
||||
try { game.completeSpin(); } catch { /* Duplicate completion may reject or no-op; it cannot commit. */ }
|
||||
assert.deepEqual(game.state, after); assert.equal(storage.writes, afterWrites);
|
||||
});
|
||||
|
||||
test('pending refresh replays without RNG, charging, awarding or any restoration write', () => {
|
||||
const { game, storage } = session(() => sample('cherry'));
|
||||
game.beginSpin(); const before = persisted(storage); const writes = storage.writes;
|
||||
const restored = new GameSession(new GameRepository(storage, SCOPE), () => { throw Error('pending replay drew again'); });
|
||||
assert.equal(restored.state.phase, 'spinning'); assert.deepEqual(restored.state.pending, before.pending);
|
||||
assert.deepEqual(restored.state, before); assert.equal(storage.writes, writes);
|
||||
restored.completeSpin();
|
||||
assert.equal(restored.state.balance, before.balance); assert.equal(restored.state.lastWin, before.lastWin);
|
||||
assert.equal(restored.state.sequence, before.sequence); assert.equal(restored.state.pending, null);
|
||||
assertUnchanged(game, storage, () => game.completeSpin());
|
||||
});
|
||||
|
||||
test('bet changes are restricted to idle supported bets; insufficient balance never draws or commits', () => {
|
||||
let calls = 0;
|
||||
const { game, storage } = session(() => { calls++; return sample('scatter'); });
|
||||
for (const bet of [1000, 2000, 5000, 10000, 20000, 50000]) {
|
||||
game.setBet(bet); assert.equal(game.state.bet, bet); assert.equal(game.state.balance, 100000);
|
||||
}
|
||||
for (const bet of [0, 1500, NaN, Infinity]) assertUnchanged(game, storage, () => game.setBet(bet));
|
||||
const repo = new GameRepository(storage, SCOPE); const seed = repo.load()!; seed.balance = 49999; repo.save(seed);
|
||||
const poor = new GameSession(new GameRepository(storage, SCOPE), () => { calls++; return sample('cherry'); });
|
||||
const beforeCalls = calls;
|
||||
assertUnchanged(poor, storage, () => poor.beginSpin()); assert.equal(calls, beforeCalls);
|
||||
const active = session().game; active.beginSpin(); assert.throws(() => active.setBet(1000));
|
||||
});
|
||||
|
||||
test('normal award is separate from free total, free bets stay locked and scatter never retriggers', () => {
|
||||
// 3 scatter + 12 cherries still pays ordinary lines on the trigger. / Trigger payout is not free-spin total.
|
||||
const triggerBoard = board('cherry'); triggerBoard[4] = ['scatter', 'scatter', 'scatter'];
|
||||
let paid = false; let draw = 0;
|
||||
const triggerRandom = randomFor(triggerBoard);
|
||||
const { game, storage } = session(() => {
|
||||
if (!paid) { const result = triggerRandom(); if (++draw === 15) paid = true; return result; }
|
||||
return sample('bell');
|
||||
});
|
||||
const trigger = game.beginSpin(); const afterTrigger = game.state.balance;
|
||||
assert.equal(trigger.awarded, 8); assert.ok(trigger.win > 0);
|
||||
assert.deepEqual(game.state.free, { remaining: 8, awarded: 8, total: 0, bet: 2000 });
|
||||
assert.equal(game.state.lastWin, trigger.win);
|
||||
game.completeSpin(); assert.equal(game.state.phase, 'free-trigger');
|
||||
assertUnchanged(game, storage, () => game.beginSpin());
|
||||
assertUnchanged(game, storage, () => game.setBet(1000));
|
||||
game.startFree(); assert.equal(game.state.phase, 'free-ready');
|
||||
assertUnchanged(game, storage, () => game.setBet(5000));
|
||||
let total = 0;
|
||||
for (let index = 0; index < 8; index++) {
|
||||
const writes = storage.writes;
|
||||
const result = game.beginSpin(); total += result.win;
|
||||
assert.equal(result.awarded, 0); assert.equal(game.state.pending?.free, true);
|
||||
assert.equal(game.state.free?.remaining, 7 - index); assert.equal(game.state.free?.awarded, 8);
|
||||
assert.equal(game.state.free?.total, total); assert.equal(game.state.free?.bet, 2000);
|
||||
assert.equal(game.state.balance, afterTrigger + total); assert.equal(game.state.lastWin, result.win);
|
||||
assert.equal(storage.writes, writes + 1, 'free win, remaining count and pending must commit together');
|
||||
game.completeSpin();
|
||||
assert.equal(game.state.phase, index === 7 ? 'free-result' : 'free-ready');
|
||||
}
|
||||
assert.ok(total > 0); assert.equal(game.state.free?.total, total);
|
||||
assertUnchanged(game, storage, () => game.beginSpin());
|
||||
game.closeFreeResult();
|
||||
assert.equal(game.state.phase, 'idle'); assert.equal(game.state.free, null);
|
||||
assert.equal(game.state.balance, afterTrigger + total); game.setBet(5000);
|
||||
});
|
||||
|
||||
test('free SCATTER preserves all cells, consumes exactly the awarded spins and cannot add spins', () => {
|
||||
const { game } = freeReady(); const balance = game.state.balance;
|
||||
for (let index = 0; index < 16; index++) {
|
||||
const result = game.beginSpin();
|
||||
assert.deepEqual(result.board, board()); assert.equal(result.scatters, 15); assert.equal(result.awarded, 0);
|
||||
assert.equal(result.win, 0); assert.equal(game.state.free?.remaining, 15 - index);
|
||||
game.completeSpin(); assert.equal(game.state.balance, balance);
|
||||
}
|
||||
assert.equal(game.state.phase, 'free-result'); assert.equal(game.state.free?.total, 0);
|
||||
});
|
||||
|
||||
test('refresh preserves trigger, ready, intermediate pending, final pending and result without grants', () => {
|
||||
const { game, storage } = freeReady();
|
||||
const restore = () => new GameSession(new GameRepository(storage, SCOPE), () => sample('scatter'));
|
||||
assert.deepEqual(restore().state, game.state);
|
||||
let current = restore();
|
||||
for (let index = 0; index < 16; index++) {
|
||||
current.beginSpin(); const before = current.state; const writes = storage.writes;
|
||||
current = restore();
|
||||
assert.equal(current.state.phase, 'spinning'); assert.deepEqual(current.state, before);
|
||||
assert.equal(storage.writes, writes);
|
||||
current.completeSpin();
|
||||
}
|
||||
assert.equal(current.state.phase, 'free-result'); assert.deepEqual(restore().state, current.state);
|
||||
const triggerFixture = session(); triggerFixture.game.beginSpin(); triggerFixture.game.completeSpin();
|
||||
const trigger = new GameSession(new GameRepository(triggerFixture.storage, SCOPE), () => { throw Error('trigger restore draw'); });
|
||||
assert.equal(trigger.state.phase, 'free-trigger'); assert.deepEqual(trigger.state.free, triggerFixture.game.state.free);
|
||||
});
|
||||
|
||||
test('daily gift is once per UTC day and reset countdown crosses midnight and leap day', () => {
|
||||
let time = Date.parse('2028-02-28T23:59:59.000Z');
|
||||
const { game, storage } = session(undefined, () => time);
|
||||
assert.equal(game.canClaimDaily(), true); assert.equal(game.nextResetMs(), 1000);
|
||||
assert.equal(game.claimDaily(), true); assert.equal(game.state.balance, 120000);
|
||||
assert.equal(game.state.lastClaimDay, '2028-02-28'); assert.equal(game.canClaimDaily(), false);
|
||||
const writes = storage.writes;
|
||||
assert.equal(game.claimDaily(), false); assert.equal(storage.writes, writes);
|
||||
const restored = new GameSession(new GameRepository(storage, SCOPE), undefined, () => time);
|
||||
assert.equal(restored.canClaimDaily(), false); assert.equal(restored.claimDaily(), false);
|
||||
time += 1000;
|
||||
assert.equal(restored.nextResetMs(), DAY); assert.equal(restored.canClaimDaily(), true);
|
||||
assert.equal(restored.claimDaily(), true); assert.equal(restored.state.balance, 140000);
|
||||
assert.equal(restored.state.lastClaimDay, '2028-02-29');
|
||||
time = Date.parse('2028-03-01T00:00:00Z');
|
||||
assert.equal(restored.claimDaily(), true); assert.equal(restored.state.lastClaimDay, '2028-03-01');
|
||||
assert.equal(restored.state.balance, 160000);
|
||||
});
|
||||
|
||||
test('preferences persist independently and exposed state/results cannot mutate a saved snapshot', () => {
|
||||
const { game, storage } = session(() => sample('cherry'));
|
||||
for (const key of ['music', 'sound', 'vibration'] as const) game.setPreference(key, false);
|
||||
assert.deepEqual(game.state.settings, { music: false, sound: false, vibration: false });
|
||||
const result = game.beginSpin(); const committed = copy(game.state);
|
||||
result.board[0][0] = 'scatter'; result.wins[0].amount = 0; result.win = 0;
|
||||
const exposed = game.state; exposed.balance = 0; exposed.board[0][0] = 'scatter'; exposed.settings.music = true;
|
||||
exposed.pending!.result.board[1][0] = 'scatter'; exposed.pending!.result.wins[0].amount = 0;
|
||||
assert.deepEqual(game.state, committed); assert.deepEqual(persisted(storage), committed);
|
||||
game.completeSpin(); const restored = new GameSession(new GameRepository(storage, SCOPE));
|
||||
assert.deepEqual(restored.state.settings, { music: false, sound: false, vibration: false });
|
||||
});
|
||||
|
||||
test('repository snapshots and initial grants are isolated by caller-provided service/product/guest scope', () => {
|
||||
const storage = memory(); const first = new GameRepository(storage, SCOPE);
|
||||
assert.equal(first.load(), null);
|
||||
const state = initialState(); first.save(state); state.balance = 1; state.settings.music = false;
|
||||
const loaded = first.load()!; assert.equal(loaded.balance, 100000);
|
||||
loaded.balance = 2; loaded.board[0][0] = 'scatter';
|
||||
assert.equal(first.load()!.balance, 100000);
|
||||
for (const scope of ['https://other.test/FruitFixture/guest-a', 'https://example.test/OtherProduct/guest-a',
|
||||
'https://example.test/FruitFixture/guest-b']) {
|
||||
const another = new GameRepository(storage, scope); assert.equal(another.load(), null);
|
||||
const other = new GameSession(another); assert.equal(other.state.balance, 100000);
|
||||
other.claimDaily(); assert.equal(other.state.balance, 120000);
|
||||
assert.equal(first.load()!.balance, 100000);
|
||||
}
|
||||
assert.equal(storage.values.size, 4);
|
||||
});
|
||||
|
||||
test('repository rejects invalid state invariants before writing', () => {
|
||||
const { storage } = session();
|
||||
const mutations: ((value: GameState) => void)[] = [
|
||||
state => { state.version = 2 as 1; }, state => { state.balance = -1; }, state => { state.balance = 1.5; },
|
||||
state => { state.balance = Number.MAX_SAFE_INTEGER + 1; }, state => { state.bet = 1500; },
|
||||
state => { state.lastWin = -1; }, state => { state.sequence = -1; },
|
||||
state => { state.board.pop(); }, state => { state.board[0][0] = 'invalid' as SymbolId; },
|
||||
state => { state.lastClaimDay = '2026-02-30'; }, state => { state.phase = 'spinning'; },
|
||||
state => { state.phase = 'free-trigger'; }, state => { state.settings.music = 1 as unknown as boolean; },
|
||||
state => { state.free = { remaining: 9, awarded: 8, total: 0, bet: 2000 }; state.phase = 'free-ready'; },
|
||||
];
|
||||
for (const mutate of mutations) {
|
||||
const repository = new GameRepository(storage, SCOPE); const invalid = repository.load()!; mutate(invalid);
|
||||
const before = [...storage.values]; const writes = storage.writes;
|
||||
assert.throws(() => repository.save(invalid));
|
||||
assert.deepEqual([...storage.values], before); assert.equal(storage.writes, writes);
|
||||
}
|
||||
});
|
||||
|
||||
test('corrupt or incompatible existing JSON is rejected without overwriting or giving a new balance', () => {
|
||||
for (const corrupt of ['{invalid', 'null', '[]', '{}', '42', '"invalid"', '{"version":2}']) {
|
||||
const { storage } = session(); const key = [...storage.values.keys()][0]; storage.values.set(key, corrupt);
|
||||
const writes = storage.writes;
|
||||
assert.throws(() => new GameSession(new GameRepository(storage, SCOPE)));
|
||||
assert.equal(storage.values.get(key), corrupt); assert.equal(storage.writes, writes);
|
||||
}
|
||||
});
|
||||
|
||||
test('unavailable initial storage never silently creates an in-memory grant', () => {
|
||||
for (const mode of ['read', 'write', 'silent'] as const) {
|
||||
const storage = memory();
|
||||
if (mode === 'read') storage.failRead = 1;
|
||||
if (mode === 'write') storage.failWrite = true;
|
||||
if (mode === 'silent') storage.silent = true;
|
||||
assert.throws(() => new GameSession(new GameRepository(storage, SCOPE)));
|
||||
assert.equal(storage.values.size, 0);
|
||||
}
|
||||
});
|
||||
|
||||
test('failed and silent writes keep spin, bet, daily and preferences unchanged in memory', () => {
|
||||
for (const mode of ['failWrite', 'silent'] as const) {
|
||||
for (const action of [
|
||||
(game: GameSession) => game.beginSpin(), (game: GameSession) => game.setBet(5000),
|
||||
(game: GameSession) => game.claimDaily(), (game: GameSession) => game.setPreference('sound', false),
|
||||
]) {
|
||||
const { game, storage } = session(() => sample('cherry'));
|
||||
storage[mode] = true;
|
||||
assertUnchanged(game, storage, () => action(game));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('failed complete/start/close writes keep the current pending or free state replayable', () => {
|
||||
const { game, storage } = session(); game.beginSpin();
|
||||
storage.failWrite = true; assertUnchanged(game, storage, () => game.completeSpin());
|
||||
storage.failWrite = false; game.completeSpin();
|
||||
storage.failWrite = true; assertUnchanged(game, storage, () => game.startFree());
|
||||
storage.failWrite = false; game.startFree();
|
||||
for (let index = 0; index < 16; index++) { game.beginSpin(); game.completeSpin(); }
|
||||
assert.equal(game.state.phase, 'free-result');
|
||||
storage.failWrite = true; assertUnchanged(game, storage, () => game.closeFreeResult());
|
||||
storage.failWrite = false; game.closeFreeResult(); assert.equal(game.state.phase, 'idle');
|
||||
});
|
||||
|
||||
test('readback verification detects a corrupt write without publishing the new in-memory state', () => {
|
||||
const { game, storage } = session(() => sample('cherry')); const before = game.state;
|
||||
storage.corrupt = true;
|
||||
assert.throws(() => game.beginSpin()); assert.deepEqual(game.state, before);
|
||||
storage.corrupt = false;
|
||||
assert.throws(() => new GameSession(new GameRepository(storage, SCOPE)));
|
||||
});
|
||||
|
||||
test('an uncertain commit with failing readback recovers saved pending and cannot be charged twice', () => {
|
||||
const { game, storage } = session(() => sample('cherry')); const before = game.state;
|
||||
storage.afterWrite = () => { storage.failRead = 1; };
|
||||
assert.throws(() => game.beginSpin()); assert.deepEqual(game.state, before);
|
||||
storage.afterWrite = null;
|
||||
const committed = new GameSession(new GameRepository(storage, SCOPE), () => { throw Error('uncertain commit redraw'); });
|
||||
assert.equal(committed.state.phase, 'spinning'); assert.equal(committed.state.balance, 234000);
|
||||
assertUnchanged(game, storage, () => game.beginSpin());
|
||||
committed.completeSpin(); assert.equal(committed.state.balance, 234000);
|
||||
});
|
||||
|
||||
test('stale sessions cannot overwrite a concurrent spin or daily claim in the same guest scope', () => {
|
||||
for (const action of [(game: GameSession) => game.beginSpin(), (game: GameSession) => game.claimDaily()]) {
|
||||
const { game, storage } = session(() => sample('cherry'));
|
||||
const stale = new GameSession(new GameRepository(storage, SCOPE), () => sample('cherry'), () => NOW);
|
||||
action(game); const committed = persisted(storage); const writes = storage.writes;
|
||||
assertUnchanged(stale, storage, () => action(stale));
|
||||
assert.deepEqual(persisted(storage), committed); assert.equal(storage.writes, writes);
|
||||
}
|
||||
});
|
||||
|
||||
test('same-page reentrant storage writes cannot allow two sessions to settle the same revision', () => {
|
||||
const { game, storage } = session(() => sample('cherry'));
|
||||
const competitor = new GameSession(new GameRepository(storage, SCOPE), () => sample('cherry'));
|
||||
const competingBefore = competitor.state; let attempted = false;
|
||||
storage.beforeWrite = () => {
|
||||
storage.beforeWrite = null; attempted = true;
|
||||
assert.throws(() => competitor.beginSpin());
|
||||
};
|
||||
game.beginSpin();
|
||||
assert.equal(attempted, true); assert.deepEqual(competitor.state, competingBefore);
|
||||
assert.equal(game.state.balance, 234000); assert.deepEqual(persisted(storage), game.state);
|
||||
});
|
||||
|
||||
test('entropy failure aborts a spin before balance, sequence or persisted pending can change', () => {
|
||||
for (const invalidAt of [0, 14]) {
|
||||
let calls = 0;
|
||||
const { game, storage } = session(() => ++calls > invalidAt ? NaN : sample('cherry'));
|
||||
assertUnchanged(game, storage, () => game.beginSpin());
|
||||
}
|
||||
const { game, storage } = freeReady(draws([...Array<number>(15).fill(sample('bell')), 1]));
|
||||
assertUnchanged(game, storage, () => game.beginSpin());
|
||||
});
|
||||
Reference in new issue
Block a user