增加游戏玩法界面和各个弹窗初版
This commit is contained in:
1 parent
e84e14783e
commit
eb48d8e845
211 files changed
+59920
-21
No files matched your search
@@ -0,0 +1,178 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user