Files
fruit-pop-googleplay/assets/orchard/scripts/GameRepository.ts
T

179 lines
8.2 KiB
TypeScript

import { assertBet, assertBoard, evaluate } from './SlotsMath';
import type { SpinResult } from './SlotsMath';
import type { GameState } from './GameSession';
export interface GameStorage {
getItem(key: string): string | null;
setItem(key: string, value: string): void;
}
interface Snapshot {
revision: number;
state: GameState;
}
/** Shared across repository instances, including writes reentered from a storage adapter. */
const writing = new WeakMap<GameStorage, Set<string>>();
function requireValue(condition: unknown, message: string): asserts condition {
if (!condition) throw new Error(`Invalid game snapshot: ${message}`);
}
function record(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value);
}
function coins(value: unknown): value is number {
return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
}
function validDay(value: unknown): boolean {
if (value === null) return true;
if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
const time = new Date(`${value}T00:00:00.000Z`);
return Number.isFinite(time.getTime()) && time.toISOString().slice(0, 10) === value;
}
function validateResult(value: unknown, bet: number, free: boolean): asserts value is SpinResult {
requireValue(record(value), 'missing spin result');
assertBoard(value.board);
const expected = evaluate(value.board, bet);
requireValue(value.win === expected.win && value.scatters === expected.scatters, 'incorrect spin award or scatter count');
requireValue(value.awarded === (free ? 0 : expected.awarded), 'incorrect free-spin award');
requireValue(Array.isArray(value.wins) && value.wins.length === expected.wins.length, 'incorrect winning lines');
for (let index = 0; index < expected.wins.length; index++) {
const actual: unknown = value.wins[index];
const award = expected.wins[index];
requireValue(record(actual) && actual.line === award.line && actual.count === award.count
&& actual.symbol === award.symbol && actual.amount === award.amount, 'incorrect line award');
}
if (free) {
const column = value.wildColumn;
requireValue(typeof column === 'number' && Number.isInteger(column) && column >= 0 && column < 5, 'invalid wild column');
requireValue(value.board[column].every(symbol => symbol === 'wild' || symbol === 'scatter'), 'unconverted free-spin column');
} else {
requireValue(value.wildColumn === null, 'ordinary spin has a wild column');
}
}
function validateState(value: unknown): asserts value is GameState {
requireValue(record(value), 'state is not an object');
requireValue(value.version === 1, 'unsupported version');
requireValue(coins(value.balance) && coins(value.lastWin) && coins(value.sequence), 'invalid coin amount or sequence');
assertBet(value.bet);
assertBoard(value.board);
requireValue(validDay(value.lastClaimDay), 'invalid claim day');
requireValue(record(value.settings) && typeof value.settings.music === 'boolean'
&& typeof value.settings.sound === 'boolean' && typeof value.settings.vibration === 'boolean', 'invalid preferences');
requireValue(['idle', 'spinning', 'free-trigger', 'free-ready', 'free-result'].includes(value.phase as string), 'unknown phase');
const free = value.free;
requireValue(free === null || record(free), 'invalid free-spin state');
if (free !== null) {
requireValue(typeof free.awarded === 'number' && [8, 12, 16].includes(free.awarded), 'invalid awarded spin count');
requireValue(coins(free.remaining) && free.remaining <= free.awarded && coins(free.total), 'invalid remaining spins or free total');
assertBet(free.bet);
requireValue(free.bet === value.bet, 'free-spin bet is not locked');
if (free.remaining === free.awarded) requireValue(free.total === 0, 'unplayed free spins have winnings');
}
const pending = value.pending;
requireValue(pending === null || record(pending), 'invalid pending state');
requireValue((value.phase === 'spinning') === (pending !== null), 'phase and pending result disagree');
if (pending !== null) {
requireValue(coins(pending.id) && pending.id > 0 && pending.id === value.sequence, 'invalid pending identifier');
requireValue(typeof pending.free === 'boolean', 'invalid pending round type');
validateResult(pending.result, value.bet, pending.free);
requireValue(JSON.stringify(value.board) === JSON.stringify(pending.result.board), 'pending board differs from displayed board');
requireValue(value.lastWin === pending.result.win && value.balance >= pending.result.win, 'pending award is not settled');
if (pending.free) {
requireValue(free !== null && (free.remaining as number) < (free.awarded as number)
&& (free.total as number) >= pending.result.win, 'pending free spin has invalid counters');
} else if (pending.result.awarded > 0) {
requireValue(free !== null && free.awarded === pending.result.awarded
&& free.remaining === free.awarded && free.total === 0, 'missing free-spin trigger');
} else {
requireValue(free === null, 'ordinary round retains unrelated free spins');
}
}
switch (value.phase) {
case 'idle':
requireValue(free === null, 'idle phase retains free spins');
break;
case 'free-trigger':
requireValue(free !== null && free.remaining === free.awarded && free.total === 0, 'invalid free-spin trigger');
break;
case 'free-ready':
requireValue(free !== null && (free.remaining as number) > 0, 'no free spins to start');
break;
case 'free-result':
requireValue(free !== null && free.remaining === 0, 'free-spin result has unfinished rounds');
break;
}
}
function decode(raw: string): Snapshot {
const value: unknown = JSON.parse(raw);
requireValue(record(value) && coins(value.revision) && value.revision > 0, 'invalid snapshot revision');
validateState(value.state);
return { revision: value.revision, state: value.state };
}
/**
* One JSON value per scope. A revision and exact observed bytes reject stale writers.
* Readback failure leaves the commit uncertain: never roll back or grant a new balance.
* Callers must reload after a conflict or uncertain write. Synchronous storage has no
* cross-process compare-and-swap; the shared lock additionally protects same-page reentry.
*/
export class GameRepository {
private readonly key: string;
private loaded = false;
private observed: string | null = null;
private revision = 0;
constructor(private readonly storage: GameStorage, scope: string) {
if (storage === null || typeof storage !== 'object' || typeof storage.getItem !== 'function'
|| typeof storage.setItem !== 'function') throw new Error('Storage is unavailable');
if (typeof scope !== 'string' || scope.trim().length === 0) throw new Error('A game storage scope is required');
this.key = `fruit-pop:game:v1:${encodeURIComponent(scope)}`;
}
load(): GameState | null {
const raw = this.storage.getItem(this.key);
if (raw !== null && typeof raw !== 'string') throw new Error('Storage returned an invalid value');
const snapshot = raw === null ? null : decode(raw);
this.observed = raw;
this.revision = snapshot === null ? 0 : snapshot.revision;
this.loaded = true;
// Parsing created fresh arrays and objects; nothing exposed is retained internally.
return snapshot === null ? null : snapshot.state;
}
save(state: GameState): void {
validateState(state);
let locks = writing.get(this.storage);
if (locks === undefined) {
locks = new Set<string>();
writing.set(this.storage, locks);
}
if (locks.has(this.key)) throw new Error('A write for this game scope is already in progress');
locks.add(this.key);
try {
if (!this.loaded) this.load();
if (this.storage.getItem(this.key) !== this.observed) throw new Error('Stale game snapshot; reload before retrying');
const revision = this.revision + 1;
if (!Number.isSafeInteger(revision)) throw new Error('Snapshot revision exhausted');
const raw = JSON.stringify({ revision, state });
// Validate the serialized representation as well, before any storage mutation.
decode(raw);
this.storage.setItem(this.key, raw);
if (this.storage.getItem(this.key) !== raw) throw new Error('Game snapshot readback verification failed');
this.observed = raw;
this.revision = revision;
} finally {
locks.delete(this.key);
}
}
}