@betorigami/game-engine 0.0.0 → 1.0.0

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,s)=>(s=n==null?{}:e(i(n)),o(r||!n||!n.__esModule||!a.call(n,`default`)?t(s,`default`,{value:n,enumerable:!0}):s,n));let c=require("@betorigami/guard"),l=require("fast-deep-equal");l=s(l,1);let u=require("big.js");u=s(u,1);const d=Array.from({length:52},(e,t)=>t),f=[`Spades`,`Hearts`,`Diamonds`,`Clubs`],p=[`Ace`,`Two`,`Three`,`Four`,`Five`,`Six`,`Seven`,`Eight`,`Nine`,`Ten`,`Jack`,`Queen`,`King`],m=[`Jack`,`Queen`,`King`],h={Hearts:`red`,Diamonds:`red`,Spades:`black`,Clubs:`black`};var g=class{value;constructor(e){let t=d[e];c.Guard.againstNullOrUndefined(t,`Invalid card value: ${e}`),this.value=t}get suit(){let e=Math.floor(this.value/13),t=f[e];return c.Guard.againstNullOrUndefined(t,`Invalid suit index: ${e}`),t}get rank(){let e=this.value%13,t=p[e];return c.Guard.againstNullOrUndefined(t,`Invalid rank index: ${e}`),t}toDto(){return{rank:this.rank,suit:this.suit,cardValue:this.value}}};let _=function(e){return e.UNSUPPORTED_EDGE=`UNSUPPORTED_EDGE`,e.INPUT_VALIDATION_ERROR=`INPUT_VALIDATION_ERROR`,e}({});var v=class e extends Error{static createUnsupportedEdgeError(t){return new e(`UNSUPPORTED_EDGE`,t)}static createValidationError(t){return new e(`INPUT_VALIDATION_ERROR`,t)}static isGameError(t){return t instanceof e}errorCode;constructor(e,t){super(t),this.errorCode=e}},y=class{gameId;edge;constructor(e,t){this.gameId=e,this.edge=t,this.validateEdge(t)}play(e,t,n=[]){let r=this.createGameStore(),i=this.generateRandomValues(e),a=i.toMultipleRandomValues();for(let e of n)r.send({...e.playerArgument,randomValuePool:i});let o=n[n.length-1];o&&c.Guard.against(!(0,l.default)(o.state,this.toExternalState(r.getSnapshot().context.state)),`The final state of the game does not match the expected state based on the previous actions`),r.send({...t,randomValuePool:i});let s=r.getSnapshot().context;return{playerArgument:s.playerArgument,state:this.toExternalState(s.state),config:s.config,additionalBetAmount:s.additionalBetAmount,proof:{proofHash:a.proofHash,proofString:a.proofString}}}validateEdge(e){let t=this.supportedEdgeConfigurations.includes(e);c.Guard.against(!t,()=>v.createUnsupportedEdgeError(`${this.gameId} does not support ${e}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`))}},b=class{multipliers;constructor(e){this.multipliers=e}getMultipliers(e){let t=this.multipliers.get(e);if(t===void 0)throw Error(`Multipliers for ${e} not found`);return t}getAllMultipliers(){return Array.from(this.multipliers.entries()).map(([e,t])=>({edge:e,multipliers:t}))}};let x=function(e){return e.DICE=`DICE`,e.MINES=`MINES`,e.KENO=`KENO`,e.LIMBO=`LIMBO`,e.ADVANCED_DICE=`ADVANCED_DICE`,e.BACCARAT=`BACCARAT`,e.DIAMONDS=`DIAMONDS`,e.PLINKO=`PLINKO`,e.ROULETTE=`ROULETTE`,e.WHEEL=`WHEEL`,e.BLACKJACK=`BLACKJACK`,e.BLITZ=`BLITZ`,e.DARTS=`DARTS`,e}({});const S=({outcomes:e,totalWeight:t})=>(c.Guard.against(t<=0,`An outcome distribution must have a positive total weight`),e.reduce((e,{multiplier:t,weight:n})=>e.plus(t.times(n)),(0,u.default)(0)).div(t)),C=({outcomes:e})=>(c.Guard.againstEmptyArray(e,`An outcome distribution must have at least one outcome`),e.reduce((e,{multiplier:t})=>t.gt(e)?t:e,e[0].multiplier)),w=({outcomes:e,totalWeight:t},n)=>{c.Guard.against(t<=0,`An outcome distribution must have a positive total weight`);let r=e.filter(e=>e.slot===n);return c.Guard.againstEmptyArray(r,`Slot ${n} is not part of the outcome distribution`),(0,u.default)(r.reduce((e,t)=>e+t.weight,0)).div(t)},T=e=>e.legs.reduce((e,t)=>e.add(t.amount),new u.default(`0`));var E=class e{source;index=0;constructor(e){this.source=e}static from(t,n){return c.Guard.against(n<=0,`Count must be positive, got ${n}`),c.Guard.against(t.values.length!==n,`Expected ${n} values, got ${t.values.length}`),new e(t)}get consumedValues(){return this.source.values.slice(0,this.index)}toMultipleRandomValues(){return this.source}takeOne(){let e=this.source.values[this.index];return c.Guard.againstUndefined(e,`RandomValuePool exhausted`),this.index+=1,e}take(e){c.Guard.against(this.index+e>this.source.values.length,`RandomValuePool exhausted: requested ${e} but only ${this.source.values.length-this.index} remain`);let t=this.source.values.slice(this.index,this.index+e);return this.index+=e,t}},D=class{gameId;constructor(e){this.gameId=e}getGameResult(e){let t=this.supportedEdgeConfigurations.includes(e.edge);return c.Guard.against(!t,()=>v.createUnsupportedEdgeError(`${this.gameId} does not support ${e.edge}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`)),this.determineGameResult(e)}};const O=(e,t)=>e.gt(t)?e:t,k=(e,t)=>e.lt(t)?e:t;var A=class{static withMultiplier(e,t){return new u.default(e).times(new u.default(100-t).div(100))}static withWinChance(e,t){return(0,u.default)(100-e).div(t)}};const j=(e,t)=>{if(t<0||e<0||t>e)throw Error(`Invalid input: ensure 0 ≤ r ≤ n and n ≥ 0.`);t>e-t&&(t=e-t);let n=1;for(let r=1;r<=t;r++)n=n*(e-r+1)/r;return n};exports.CARD_RANKS=p,exports.CARD_SUITS=f,exports.CARD_SUIT_COLORS=h,exports.CARD_VALUES=d,exports.Card=g,exports.FACE_CARD_RANKS=m,exports.GameError=v,exports.GameErrorCode=_,exports.MAX_CARD_VALUE=51,exports.MIN_CARD_VALUE=0,exports.MultiActionGame=y,exports.MultiplierCalculator=A,exports.MultiplierContainer=b,exports.OrigamiGame=x,exports.RandomValuePool=E,exports.SingleActionGame=D,exports.bigMax=O,exports.bigMin=k,exports.maxMultiplierOf=C,exports.nCr=j,exports.probabilityOf=w,exports.rtpOf=S,exports.sumPayout=T;

package/dist/index.d.cts

@@ -0,0 +1,235 @@
+import { i as SingleRandomValue, n as Proof, r as RandomNumberGenerator, t as MultipleRandomValues } from "./random-l3djG58u.cjs";
+import Big from "big.js";
+//#region src/cards/types.d.ts
+export declare const MIN_CARD_VALUE = 0;
+export declare const MAX_CARD_VALUE = 51;
+export declare const CARD_VALUES: number[];
+export declare const CARD_SUITS: readonly ["Spades", "Hearts", "Diamonds", "Clubs"];
+export type CardSuit = (typeof CARD_SUITS)[number];
+export declare const CARD_RANKS: readonly ["Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"];
+export type CardRank = (typeof CARD_RANKS)[number];
+export declare const FACE_CARD_RANKS: readonly CardRank[];
+export type CardValue = (typeof CARD_VALUES)[number];
+export type CardDto = {
+  rank: CardRank;
+  suit: CardSuit;
+  cardValue: CardValue;
+};
+export declare const CARD_SUIT_COLORS: Record<CardSuit, 'red' | 'black'>;
+//#endregion
+//#region src/cards/card.d.ts
+export declare class Card {
+  readonly value: CardValue;
+  constructor(rawValue: number);
+  get suit(): CardSuit;
+  get rank(): CardRank;
+  toDto(): CardDto;
+}
+//#endregion
+//#region src/errors/game.error.d.ts
+export declare enum GameErrorCode {
+  UNSUPPORTED_EDGE = "UNSUPPORTED_EDGE",
+  INPUT_VALIDATION_ERROR = "INPUT_VALIDATION_ERROR"
+}
+export declare class GameError extends Error {
+  static createUnsupportedEdgeError(message: string): GameError;
+  static createValidationError(message: string): GameError;
+  static isGameError(error: unknown): error is GameError;
+  errorCode: GameErrorCode;
+  constructor(errorCode: GameErrorCode, message?: string);
+}
+//#endregion
+//#region src/origami-game.d.ts
+export declare enum OrigamiGame {
+  DICE = "DICE",
+  MINES = "MINES",
+  KENO = "KENO",
+  LIMBO = "LIMBO",
+  ADVANCED_DICE = "ADVANCED_DICE",
+  BACCARAT = "BACCARAT",
+  DIAMONDS = "DIAMONDS",
+  PLINKO = "PLINKO",
+  ROULETTE = "ROULETTE",
+  WHEEL = "WHEEL",
+  BLACKJACK = "BLACKJACK",
+  BLITZ = "BLITZ",
+  DARTS = "DARTS"
+}
+//#endregion
+//#region src/game.d.ts
+export interface Game {
+  gameId: OrigamiGame;
+  supportedEdgeConfigurations: [number, ...number[]];
+}
+//#endregion
+//#region src/payout.d.ts
+/**
+ * A single exact payout amount from a game round.
+ *
+ * A round returns zero or more legs. Neither their order nor their count is
+ * significant: a leg is not tied to a particular bet, an amount may be zero,
+ * and the number of legs need not match the number of bets placed. The only
+ * supported operation is summing them.
+ *
+ * Amounts are gross — they include returned stake — and unrounded. Rounding to
+ * a currency's precision is the consuming service's decision, not this
+ * package's.
+ */
+export type PayoutLeg = Readonly<{
+  amount: Big;
+}>;
+/**
+ * A round's payout, expressed as its constituent legs.
+ */
+export type Payout = Readonly<{
+  legs: readonly PayoutLeg[];
+}>;
+/**
+ * Totals a round's payout.
+ *
+ * Summing the legs is lossless; reconstructing the total from a rounded
+ * payout multiplier is not, so this is the only supported way to arrive at
+ * what a round pays.
+ */
+export declare const sumPayout: (payout: Payout) => Big;
+//#endregion
+//#region src/single-action-game.d.ts
+export type EmptyGameOutput = {};
+export interface GetGameResultRequest<TGameInputs> {
+  generator: RandomNumberGenerator;
+  edge: number;
+  gameInputs: TGameInputs;
+}
+export interface GameResult<TGameOutputs = EmptyGameOutput> {
+  isFinished: boolean;
+  payout: Payout;
+  payoutMultiplier: Big;
+  outputs: TGameOutputs & {
+    result: number[];
+  };
+  randomValues: SingleRandomValue | MultipleRandomValues;
+}
+export declare abstract class SingleActionGame<TGameInputs, TGameOutputs = EmptyGameOutput> implements Game {
+  readonly gameId: OrigamiGame;
+  protected constructor(gameId: OrigamiGame);
+  abstract get supportedEdgeConfigurations(): [number, ...number[]];
+  abstract getBetAmount(gameInputs: TGameInputs): Big;
+  getGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+  protected abstract determineGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+}
+//#endregion
+//#region src/game-descriptor.d.ts
+export interface GameDescriptor<TInputs, TOutputs = EmptyGameOutput> {
+  readonly id: OrigamiGame;
+  readonly create: () => SingleActionGame<TInputs, TOutputs>;
+  readonly suppliesOwnBetAmount: boolean;
+}
+//#endregion
+//#region src/random-value-pool.d.ts
+export declare class RandomValuePool {
+  private readonly source;
+  private index;
+  private constructor();
+  static from(result: MultipleRandomValues, count: number): RandomValuePool;
+  get consumedValues(): number[];
+  toMultipleRandomValues(): MultipleRandomValues;
+  takeOne(): number;
+  take(count: number): ReadonlyArray<number>;
+}
+//#endregion
+//#region src/multi-action-game.d.ts
+export type BaseInProgressState = Readonly<{
+  isFinished: false;
+  multiplier: Big;
+}>;
+export type BaseFinishedState = Readonly<{
+  isFinished: true;
+  payout: Payout;
+  multiplier: Big;
+  randomValues: number[];
+}>;
+export type BaseGameState = BaseInProgressState | BaseFinishedState;
+export type GameContext<TAction, TState extends BaseGameState, TConfig> = {
+  readonly playerArgument: TAction;
+  readonly state: TState;
+  readonly config: TConfig;
+  readonly additionalBetAmount?: Big;
+};
+export type RandomValuePoolEvent = Readonly<{
+  randomValuePool: RandomValuePool;
+}>;
+export type UntypedGameContext = GameContext<{
+  readonly type: string;
+}, BaseGameState, unknown>;
+export type PlayResult = UntypedGameContext & {
+  readonly proof: Proof;
+};
+export interface GameStore<TInternalState extends BaseGameState, TAction, TConfig> {
+  send(event: {
+    readonly type: string;
+  } & RandomValuePoolEvent & Record<string, unknown>): void;
+  getSnapshot(): {
+    readonly context: GameContext<TAction, TInternalState, TConfig>;
+  };
+}
+export declare abstract class MultiActionGame<TInternalState extends BaseGameState, TExternalState extends BaseGameState, TAction extends {
+  readonly type: string;
+}, TConfig> implements Game {
+  readonly gameId: OrigamiGame;
+  readonly edge: number;
+  protected constructor(gameId: OrigamiGame, edge: number);
+  abstract get supportedEdgeConfigurations(): [number, ...number[]];
+  abstract getValidNextActionTypes(state: TExternalState): ReadonlyArray<TAction['type']>;
+  protected abstract createGameStore(): GameStore<TInternalState, TAction, TConfig>;
+  protected abstract generateRandomValues(generator: RandomNumberGenerator): RandomValuePool;
+  protected abstract toExternalState(internal: TInternalState): TExternalState;
+  play(generator: RandomNumberGenerator, action: {
+    readonly type: string;
+  } & Record<string, unknown>, previousActions?: readonly UntypedGameContext[]): PlayResult;
+  private validateEdge;
+}
+//#endregion
+//#region src/multiplier-container.d.ts
+export declare class MultiplierContainer<TMultipliers> {
+  readonly multipliers: Map<number, TMultipliers>;
+  constructor(multipliers: Map<number, TMultipliers>);
+  getMultipliers(edge: number): TMultipliers;
+  getAllMultipliers(): {
+    edge: number;
+    multipliers: TMultipliers;
+  }[];
+}
+//#endregion
+//#region src/outcomes.d.ts
+export type Outcome<TSlot extends string = string> = Readonly<{
+  slot: TSlot;
+  multiplier: Big;
+  weight: number;
+}>;
+export type OutcomeDistribution<TSlot extends string = string> = Readonly<{
+  outcomes: readonly Outcome<TSlot>[];
+  totalWeight: number;
+}>;
+export interface DescribesOutcomes<TSelection, TSlot extends string = string> {
+  describeOutcomes(selection: TSelection, edge: number): OutcomeDistribution<TSlot>;
+}
+export declare const rtpOf: ({ outcomes, totalWeight }: OutcomeDistribution) => Big;
+export declare const maxMultiplierOf: ({ outcomes }: OutcomeDistribution) => Big;
+export declare const probabilityOf: <TSlot extends string>({ outcomes, totalWeight }: OutcomeDistribution<TSlot>, slot: TSlot) => Big;
+//#endregion
+//#region src/utils/big-max.d.ts
+export declare const bigMax: (a: Big, b: Big) => Big;
+//#endregion
+//#region src/utils/big-min.d.ts
+export declare const bigMin: (a: Big, b: Big) => Big;
+//#endregion
+//#region src/utils/multiplier-calculator.d.ts
+export declare abstract class MultiplierCalculator {
+  static withMultiplier(multiplier: Big, edge: number): Big;
+  static withWinChance(edge: number, winChance: Big): Big;
+}
+//#endregion
+//#region src/utils/ncr.d.ts
+export declare const nCr: (n: number, r: number) => number;
+//#endregion
+export { MultipleRandomValues, Proof, RandomNumberGenerator, SingleRandomValue };

package/dist/index.d.ts

@@ -0,0 +1,235 @@
+import { i as SingleRandomValue, n as Proof, r as RandomNumberGenerator, t as MultipleRandomValues } from "./random-l3djG58u.js";
+import Big from "big.js";
+//#region src/cards/types.d.ts
+export declare const MIN_CARD_VALUE = 0;
+export declare const MAX_CARD_VALUE = 51;
+export declare const CARD_VALUES: number[];
+export declare const CARD_SUITS: readonly ["Spades", "Hearts", "Diamonds", "Clubs"];
+export type CardSuit = (typeof CARD_SUITS)[number];
+export declare const CARD_RANKS: readonly ["Ace", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"];
+export type CardRank = (typeof CARD_RANKS)[number];
+export declare const FACE_CARD_RANKS: readonly CardRank[];
+export type CardValue = (typeof CARD_VALUES)[number];
+export type CardDto = {
+  rank: CardRank;
+  suit: CardSuit;
+  cardValue: CardValue;
+};
+export declare const CARD_SUIT_COLORS: Record<CardSuit, 'red' | 'black'>;
+//#endregion
+//#region src/cards/card.d.ts
+export declare class Card {
+  readonly value: CardValue;
+  constructor(rawValue: number);
+  get suit(): CardSuit;
+  get rank(): CardRank;
+  toDto(): CardDto;
+}
+//#endregion
+//#region src/errors/game.error.d.ts
+export declare enum GameErrorCode {
+  UNSUPPORTED_EDGE = "UNSUPPORTED_EDGE",
+  INPUT_VALIDATION_ERROR = "INPUT_VALIDATION_ERROR"
+}
+export declare class GameError extends Error {
+  static createUnsupportedEdgeError(message: string): GameError;
+  static createValidationError(message: string): GameError;
+  static isGameError(error: unknown): error is GameError;
+  errorCode: GameErrorCode;
+  constructor(errorCode: GameErrorCode, message?: string);
+}
+//#endregion
+//#region src/origami-game.d.ts
+export declare enum OrigamiGame {
+  DICE = "DICE",
+  MINES = "MINES",
+  KENO = "KENO",
+  LIMBO = "LIMBO",
+  ADVANCED_DICE = "ADVANCED_DICE",
+  BACCARAT = "BACCARAT",
+  DIAMONDS = "DIAMONDS",
+  PLINKO = "PLINKO",
+  ROULETTE = "ROULETTE",
+  WHEEL = "WHEEL",
+  BLACKJACK = "BLACKJACK",
+  BLITZ = "BLITZ",
+  DARTS = "DARTS"
+}
+//#endregion
+//#region src/game.d.ts
+export interface Game {
+  gameId: OrigamiGame;
+  supportedEdgeConfigurations: [number, ...number[]];
+}
+//#endregion
+//#region src/payout.d.ts
+/**
+ * A single exact payout amount from a game round.
+ *
+ * A round returns zero or more legs. Neither their order nor their count is
+ * significant: a leg is not tied to a particular bet, an amount may be zero,
+ * and the number of legs need not match the number of bets placed. The only
+ * supported operation is summing them.
+ *
+ * Amounts are gross — they include returned stake — and unrounded. Rounding to
+ * a currency's precision is the consuming service's decision, not this
+ * package's.
+ */
+export type PayoutLeg = Readonly<{
+  amount: Big;
+}>;
+/**
+ * A round's payout, expressed as its constituent legs.
+ */
+export type Payout = Readonly<{
+  legs: readonly PayoutLeg[];
+}>;
+/**
+ * Totals a round's payout.
+ *
+ * Summing the legs is lossless; reconstructing the total from a rounded
+ * payout multiplier is not, so this is the only supported way to arrive at
+ * what a round pays.
+ */
+export declare const sumPayout: (payout: Payout) => Big;
+//#endregion
+//#region src/single-action-game.d.ts
+export type EmptyGameOutput = {};
+export interface GetGameResultRequest<TGameInputs> {
+  generator: RandomNumberGenerator;
+  edge: number;
+  gameInputs: TGameInputs;
+}
+export interface GameResult<TGameOutputs = EmptyGameOutput> {
+  isFinished: boolean;
+  payout: Payout;
+  payoutMultiplier: Big;
+  outputs: TGameOutputs & {
+    result: number[];
+  };
+  randomValues: SingleRandomValue | MultipleRandomValues;
+}
+export declare abstract class SingleActionGame<TGameInputs, TGameOutputs = EmptyGameOutput> implements Game {
+  readonly gameId: OrigamiGame;
+  protected constructor(gameId: OrigamiGame);
+  abstract get supportedEdgeConfigurations(): [number, ...number[]];
+  abstract getBetAmount(gameInputs: TGameInputs): Big;
+  getGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+  protected abstract determineGameResult(request: GetGameResultRequest<TGameInputs>): GameResult<TGameOutputs>;
+}
+//#endregion
+//#region src/game-descriptor.d.ts
+export interface GameDescriptor<TInputs, TOutputs = EmptyGameOutput> {
+  readonly id: OrigamiGame;
+  readonly create: () => SingleActionGame<TInputs, TOutputs>;
+  readonly suppliesOwnBetAmount: boolean;
+}
+//#endregion
+//#region src/random-value-pool.d.ts
+export declare class RandomValuePool {
+  private readonly source;
+  private index;
+  private constructor();
+  static from(result: MultipleRandomValues, count: number): RandomValuePool;
+  get consumedValues(): number[];
+  toMultipleRandomValues(): MultipleRandomValues;
+  takeOne(): number;
+  take(count: number): ReadonlyArray<number>;
+}
+//#endregion
+//#region src/multi-action-game.d.ts
+export type BaseInProgressState = Readonly<{
+  isFinished: false;
+  multiplier: Big;
+}>;
+export type BaseFinishedState = Readonly<{
+  isFinished: true;
+  payout: Payout;
+  multiplier: Big;
+  randomValues: number[];
+}>;
+export type BaseGameState = BaseInProgressState | BaseFinishedState;
+export type GameContext<TAction, TState extends BaseGameState, TConfig> = {
+  readonly playerArgument: TAction;
+  readonly state: TState;
+  readonly config: TConfig;
+  readonly additionalBetAmount?: Big;
+};
+export type RandomValuePoolEvent = Readonly<{
+  randomValuePool: RandomValuePool;
+}>;
+export type UntypedGameContext = GameContext<{
+  readonly type: string;
+}, BaseGameState, unknown>;
+export type PlayResult = UntypedGameContext & {
+  readonly proof: Proof;
+};
+export interface GameStore<TInternalState extends BaseGameState, TAction, TConfig> {
+  send(event: {
+    readonly type: string;
+  } & RandomValuePoolEvent & Record<string, unknown>): void;
+  getSnapshot(): {
+    readonly context: GameContext<TAction, TInternalState, TConfig>;
+  };
+}
+export declare abstract class MultiActionGame<TInternalState extends BaseGameState, TExternalState extends BaseGameState, TAction extends {
+  readonly type: string;
+}, TConfig> implements Game {
+  readonly gameId: OrigamiGame;
+  readonly edge: number;
+  protected constructor(gameId: OrigamiGame, edge: number);
+  abstract get supportedEdgeConfigurations(): [number, ...number[]];
+  abstract getValidNextActionTypes(state: TExternalState): ReadonlyArray<TAction['type']>;
+  protected abstract createGameStore(): GameStore<TInternalState, TAction, TConfig>;
+  protected abstract generateRandomValues(generator: RandomNumberGenerator): RandomValuePool;
+  protected abstract toExternalState(internal: TInternalState): TExternalState;
+  play(generator: RandomNumberGenerator, action: {
+    readonly type: string;
+  } & Record<string, unknown>, previousActions?: readonly UntypedGameContext[]): PlayResult;
+  private validateEdge;
+}
+//#endregion
+//#region src/multiplier-container.d.ts
+export declare class MultiplierContainer<TMultipliers> {
+  readonly multipliers: Map<number, TMultipliers>;
+  constructor(multipliers: Map<number, TMultipliers>);
+  getMultipliers(edge: number): TMultipliers;
+  getAllMultipliers(): {
+    edge: number;
+    multipliers: TMultipliers;
+  }[];
+}
+//#endregion
+//#region src/outcomes.d.ts
+export type Outcome<TSlot extends string = string> = Readonly<{
+  slot: TSlot;
+  multiplier: Big;
+  weight: number;
+}>;
+export type OutcomeDistribution<TSlot extends string = string> = Readonly<{
+  outcomes: readonly Outcome<TSlot>[];
+  totalWeight: number;
+}>;
+export interface DescribesOutcomes<TSelection, TSlot extends string = string> {
+  describeOutcomes(selection: TSelection, edge: number): OutcomeDistribution<TSlot>;
+}
+export declare const rtpOf: ({ outcomes, totalWeight }: OutcomeDistribution) => Big;
+export declare const maxMultiplierOf: ({ outcomes }: OutcomeDistribution) => Big;
+export declare const probabilityOf: <TSlot extends string>({ outcomes, totalWeight }: OutcomeDistribution<TSlot>, slot: TSlot) => Big;
+//#endregion
+//#region src/utils/big-max.d.ts
+export declare const bigMax: (a: Big, b: Big) => Big;
+//#endregion
+//#region src/utils/big-min.d.ts
+export declare const bigMin: (a: Big, b: Big) => Big;
+//#endregion
+//#region src/utils/multiplier-calculator.d.ts
+export declare abstract class MultiplierCalculator {
+  static withMultiplier(multiplier: Big, edge: number): Big;
+  static withWinChance(edge: number, winChance: Big): Big;
+}
+//#endregion
+//#region src/utils/ncr.d.ts
+export declare const nCr: (n: number, r: number) => number;
+//#endregion
+export { MultipleRandomValues, Proof, RandomNumberGenerator, SingleRandomValue };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{Guard as e}from"@betorigami/guard";import t from"fast-deep-equal";import n from"big.js";const r=0,i=51,a=Array.from({length:52},(e,t)=>t),o=[`Spades`,`Hearts`,`Diamonds`,`Clubs`],s=[`Ace`,`Two`,`Three`,`Four`,`Five`,`Six`,`Seven`,`Eight`,`Nine`,`Ten`,`Jack`,`Queen`,`King`],c=[`Jack`,`Queen`,`King`],l={Hearts:`red`,Diamonds:`red`,Spades:`black`,Clubs:`black`};var u=class{value;constructor(t){let n=a[t];e.againstNullOrUndefined(n,`Invalid card value: ${t}`),this.value=n}get suit(){let t=Math.floor(this.value/13),n=o[t];return e.againstNullOrUndefined(n,`Invalid suit index: ${t}`),n}get rank(){let t=this.value%13,n=s[t];return e.againstNullOrUndefined(n,`Invalid rank index: ${t}`),n}toDto(){return{rank:this.rank,suit:this.suit,cardValue:this.value}}};let d=function(e){return e.UNSUPPORTED_EDGE=`UNSUPPORTED_EDGE`,e.INPUT_VALIDATION_ERROR=`INPUT_VALIDATION_ERROR`,e}({});var f=class e extends Error{static createUnsupportedEdgeError(t){return new e(`UNSUPPORTED_EDGE`,t)}static createValidationError(t){return new e(`INPUT_VALIDATION_ERROR`,t)}static isGameError(t){return t instanceof e}errorCode;constructor(e,t){super(t),this.errorCode=e}},p=class{gameId;edge;constructor(e,t){this.gameId=e,this.edge=t,this.validateEdge(t)}play(n,r,i=[]){let a=this.createGameStore(),o=this.generateRandomValues(n),s=o.toMultipleRandomValues();for(let e of i)a.send({...e.playerArgument,randomValuePool:o});let c=i[i.length-1];c&&e.against(!t(c.state,this.toExternalState(a.getSnapshot().context.state)),`The final state of the game does not match the expected state based on the previous actions`),a.send({...r,randomValuePool:o});let l=a.getSnapshot().context;return{playerArgument:l.playerArgument,state:this.toExternalState(l.state),config:l.config,additionalBetAmount:l.additionalBetAmount,proof:{proofHash:s.proofHash,proofString:s.proofString}}}validateEdge(t){let n=this.supportedEdgeConfigurations.includes(t);e.against(!n,()=>f.createUnsupportedEdgeError(`${this.gameId} does not support ${t}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`))}},m=class{multipliers;constructor(e){this.multipliers=e}getMultipliers(e){let t=this.multipliers.get(e);if(t===void 0)throw Error(`Multipliers for ${e} not found`);return t}getAllMultipliers(){return Array.from(this.multipliers.entries()).map(([e,t])=>({edge:e,multipliers:t}))}};let h=function(e){return e.DICE=`DICE`,e.MINES=`MINES`,e.KENO=`KENO`,e.LIMBO=`LIMBO`,e.ADVANCED_DICE=`ADVANCED_DICE`,e.BACCARAT=`BACCARAT`,e.DIAMONDS=`DIAMONDS`,e.PLINKO=`PLINKO`,e.ROULETTE=`ROULETTE`,e.WHEEL=`WHEEL`,e.BLACKJACK=`BLACKJACK`,e.BLITZ=`BLITZ`,e.DARTS=`DARTS`,e}({});const g=({outcomes:t,totalWeight:r})=>(e.against(r<=0,`An outcome distribution must have a positive total weight`),t.reduce((e,{multiplier:t,weight:n})=>e.plus(t.times(n)),n(0)).div(r)),_=({outcomes:t})=>(e.againstEmptyArray(t,`An outcome distribution must have at least one outcome`),t.reduce((e,{multiplier:t})=>t.gt(e)?t:e,t[0].multiplier)),v=({outcomes:t,totalWeight:r},i)=>{e.against(r<=0,`An outcome distribution must have a positive total weight`);let a=t.filter(e=>e.slot===i);return e.againstEmptyArray(a,`Slot ${i} is not part of the outcome distribution`),n(a.reduce((e,t)=>e+t.weight,0)).div(r)},y=e=>e.legs.reduce((e,t)=>e.add(t.amount),new n(`0`));var b=class t{source;index=0;constructor(e){this.source=e}static from(n,r){return e.against(r<=0,`Count must be positive, got ${r}`),e.against(n.values.length!==r,`Expected ${r} values, got ${n.values.length}`),new t(n)}get consumedValues(){return this.source.values.slice(0,this.index)}toMultipleRandomValues(){return this.source}takeOne(){let t=this.source.values[this.index];return e.againstUndefined(t,`RandomValuePool exhausted`),this.index+=1,t}take(t){e.against(this.index+t>this.source.values.length,`RandomValuePool exhausted: requested ${t} but only ${this.source.values.length-this.index} remain`);let n=this.source.values.slice(this.index,this.index+t);return this.index+=t,n}},x=class{gameId;constructor(e){this.gameId=e}getGameResult(t){let n=this.supportedEdgeConfigurations.includes(t.edge);return e.against(!n,()=>f.createUnsupportedEdgeError(`${this.gameId} does not support ${t.edge}% edge. Supported edge configurations include: ${this.supportedEdgeConfigurations}`)),this.determineGameResult(t)}};const S=(e,t)=>e.gt(t)?e:t,C=(e,t)=>e.lt(t)?e:t;var w=class{static withMultiplier(e,t){return new n(e).times(new n(100-t).div(100))}static withWinChance(e,t){return n(100-e).div(t)}};const T=(e,t)=>{if(t<0||e<0||t>e)throw Error(`Invalid input: ensure 0 ≤ r ≤ n and n ≥ 0.`);t>e-t&&(t=e-t);let n=1;for(let r=1;r<=t;r++)n=n*(e-r+1)/r;return n};export{s as CARD_RANKS,o as CARD_SUITS,l as CARD_SUIT_COLORS,a as CARD_VALUES,u as Card,c as FACE_CARD_RANKS,f as GameError,d as GameErrorCode,i as MAX_CARD_VALUE,r as MIN_CARD_VALUE,p as MultiActionGame,w as MultiplierCalculator,m as MultiplierContainer,h as OrigamiGame,b as RandomValuePool,x as SingleActionGame,S as bigMax,C as bigMin,_ as maxMultiplierOf,T as nCr,v as probabilityOf,g as rtpOf,y as sumPayout};

package/dist/random-l3djG58u.d.cts

@@ -0,0 +1,36 @@
+//#region src/random.d.ts
+type Proof = {
+  proofHash: string;
+  proofString: string;
+};
+type SingleRandomValue = {
+  value: number;
+  values: number[];
+  count: 1;
+  min: number;
+  max: number;
+} & Proof;
+type MultipleRandomValues = {
+  values: number[];
+  count: number;
+  min: number;
+  max: number;
+} & Proof;
+interface RandomNumberGenerator {
+  getRandomInt({ min, max }: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+  getUniqueRandomInts({ min, max, count }: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getRandomIntsWithReplacement({ min, max, count }: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+//#endregion
+export { SingleRandomValue as i, Proof as n, RandomNumberGenerator as r, MultipleRandomValues as t };

package/dist/random-l3djG58u.d.ts

@@ -0,0 +1,36 @@
+//#region src/random.d.ts
+type Proof = {
+  proofHash: string;
+  proofString: string;
+};
+type SingleRandomValue = {
+  value: number;
+  values: number[];
+  count: 1;
+  min: number;
+  max: number;
+} & Proof;
+type MultipleRandomValues = {
+  values: number[];
+  count: number;
+  min: number;
+  max: number;
+} & Proof;
+interface RandomNumberGenerator {
+  getRandomInt({ min, max }: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+  getUniqueRandomInts({ min, max, count }: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getRandomIntsWithReplacement({ min, max, count }: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+//#endregion
+export { SingleRandomValue as i, Proof as n, RandomNumberGenerator as r, MultipleRandomValues as t };

package/dist/testing/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=class{getRandomInt({}){throw Error(`Not implemented`)}getRandomIntsWithReplacement({}){throw Error(`Not implemented`)}getUniqueRandomInts({}){throw Error(`Not implemented`)}},t=class extends e{value;constructor(e){super(),this.value=e}getRandomInt(e){return{...e,value:this.value,values:[this.value],count:1,proofHash:`stub-proof-hash`,proofString:`stub-proof-string`}}},n=class extends e{values;constructor(e){super(),this.values=e}getRandomIntsWithReplacement(e){return{...e,values:this.values,proofHash:`stub-proof-hash`,proofString:`stub-proof-string`}}getUniqueRandomInts(e){return{...e,values:this.values,proofHash:`stub-proof-hash`,proofString:`stub-proof-string`}}};exports.MultipleRandomNumberGeneratorStub=n,exports.RandomNumberGeneratorStub=e,exports.SingleRandomNumberGeneratorStub=t;

package/dist/testing/index.d.cts

@@ -0,0 +1,41 @@
+import { i as SingleRandomValue, r as RandomNumberGenerator, t as MultipleRandomValues } from "../random-l3djG58u.cjs";
+//#region src/testing/index.d.ts
+export declare abstract class RandomNumberGeneratorStub implements RandomNumberGenerator {
+  getRandomInt({}: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+  getRandomIntsWithReplacement({}: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getUniqueRandomInts({}: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+export declare class SingleRandomNumberGeneratorStub extends RandomNumberGeneratorStub {
+  private readonly value;
+  constructor(value: number);
+  getRandomInt(args: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+}
+export declare class MultipleRandomNumberGeneratorStub extends RandomNumberGeneratorStub {
+  private readonly values;
+  constructor(values: number[]);
+  getRandomIntsWithReplacement(args: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getUniqueRandomInts(args: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+//#endregion

package/dist/testing/index.d.ts

@@ -0,0 +1,41 @@
+import { i as SingleRandomValue, r as RandomNumberGenerator, t as MultipleRandomValues } from "../random-l3djG58u.js";
+//#region src/testing/index.d.ts
+export declare abstract class RandomNumberGeneratorStub implements RandomNumberGenerator {
+  getRandomInt({}: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+  getRandomIntsWithReplacement({}: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getUniqueRandomInts({}: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+export declare class SingleRandomNumberGeneratorStub extends RandomNumberGeneratorStub {
+  private readonly value;
+  constructor(value: number);
+  getRandomInt(args: {
+    min: number;
+    max: number;
+  }): SingleRandomValue;
+}
+export declare class MultipleRandomNumberGeneratorStub extends RandomNumberGeneratorStub {
+  private readonly values;
+  constructor(values: number[]);
+  getRandomIntsWithReplacement(args: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+  getUniqueRandomInts(args: {
+    min: number;
+    max: number;
+    count: number;
+  }): MultipleRandomValues;
+}
+//#endregion

package/dist/testing/index.mjs

@@ -0,0 +1 @@
+var e=class{getRandomInt({}){throw Error(`Not implemented`)}getRandomIntsWithReplacement({}){throw Error(`Not implemented`)}getUniqueRandomInts({}){throw Error(`Not implemented`)}},t=class extends e{value;constructor(e){super(),this.value=e}getRandomInt(e){return{...e,value:this.value,values:[this.value],count:1,proofHash:`stub-proof-hash`,proofString:`stub-proof-string`}}},n=class extends e{values;constructor(e){super(),this.values=e}getRandomIntsWithReplacement(e){return{...e,values:this.values,proofHash:`stub-proof-hash`,proofString:`stub-proof-string`}}getUniqueRandomInts(e){return{...e,values:this.values,proofHash:`stub-proof-hash`,proofString:`stub-proof-string`}}};export{n as MultipleRandomNumberGeneratorStub,e as RandomNumberGeneratorStub,t as SingleRandomNumberGeneratorStub};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@betorigami/game-engine",
-  "version": "0.0.0",
+  "version": "1.0.0",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",