@adiakys/feeling-lucky 0.0.0-stage → 0.2.0

package/dist/engine/pachinko.d.ts

@@ -0,0 +1,58 @@
+import type { Tier } from '../config/types';
+import { type Award, type Board } from './awards';
+declare module './rig' {
+    interface Decisions {
+        'pachinko.board': {
+            context: {
+                pegs: PachinkoPeg[];
+            };
+            value: {
+                violet: PachinkoPeg;
+                reds: PachinkoPeg[];
+            };
+        };
+        'pachinko.route': {
+            context: {
+                violet: PachinkoPeg;
+                reds: PachinkoPeg[];
+            };
+            value: {
+                through: PachinkoPeg[];
+                avoid: PachinkoPeg[];
+            };
+        };
+        'pachinko.wins': {
+            context: {
+                boost: number;
+                violet: boolean;
+            };
+            value: boolean;
+        };
+        'pachinko.pocket': {
+            context: {
+                near: number;
+            };
+            value: number;
+        };
+    }
+}
+export interface PachinkoPocket {
+    tier: Tier;
+    award: Award;
+}
+export declare const PACHINKO_POCKETS: Tier[];
+export declare function plainPockets(board: Board): PachinkoPocket[];
+export declare function pachinkoPocket(tier: Tier, near: number): number;
+export declare const PACHINKO_RED_PEGS = 8;
+export declare const PACHINKO_VIOLET_ROWS: readonly [180, 400];
+export interface PachinkoPeg {
+    x: number;
+    y: number;
+    hit: number;
+    divider?: boolean;
+    color?: 'blue' | 'red' | 'violet';
+    lit?: boolean;
+}
+export declare const pachinkoLadder: (board: Board) => PachinkoPocket[];
+export declare function pachinkoPockets(redHits: number, board: Board): PachinkoPocket[];
+export declare function pachinkoChance(multiplier: number, violetHit: boolean): number;

package/dist/engine/random.d.ts

@@ -0,0 +1,6 @@
+export declare const random: (min: number, max: number) => number;
+export declare const randomInt: (min: number, max: number) => number;
+export declare const pick: <T>(items: readonly T[]) => T;
+export declare const shuffle: <T>(items: readonly T[]) => T[];
+export declare const mod: (value: number, base: number) => number;
+export declare const range: (from: number, to: number) => number[];

package/dist/engine/rig.d.ts

@@ -0,0 +1,28 @@
+import type { GameId } from '../config/types';
+export interface Decisions {
+}
+type Settle<K extends keyof Decisions> = (context: Decisions[K] extends {
+    context: infer C;
+} ? C : never, draw: () => Decisions[K] extends {
+    value: infer V;
+} ? V : never) => Decisions[K] extends {
+    value: infer V;
+} ? V : never;
+export type Rig = {
+    [K in keyof Decisions]?: Settle<K>;
+};
+export declare const roomOpen: import("../runtime/signal").Signal<boolean>;
+export declare const restartRequest: import("../runtime/signal").Signal<{
+    game: GameId;
+} | undefined>;
+export declare const rigChanged: import("../runtime/signal").Signal<number>;
+export declare function installRig(next: Rig): void;
+export declare function restartGame(game: GameId): void;
+export declare function decide<K extends keyof Decisions>(key: K, context: Decisions[K] extends {
+    context: infer C;
+} ? C : never, draw: () => Decisions[K] extends {
+    value: infer V;
+} ? V : never): Decisions[K] extends {
+    value: infer V;
+} ? V : never;
+export {};

package/dist/engine/roulette.d.ts

@@ -0,0 +1,53 @@
+import type { Tier } from '../config/types';
+export declare const ROULETTE_ORDER: number[];
+export declare const ROULETTE_RED: Set<number>;
+export declare const ROULETTE_CHIPS = 6;
+export declare const ROULETTE_STORM = 3;
+export declare const stormNumbers: () => number[];
+export declare function rouletteNumber(storm: number[], boost: number): number;
+export type RouletteBetKind = 'straight' | 'split' | 'street' | 'corner' | 'line' | 'column' | 'dozen' | 'chance';
+export declare const ROULETTE_TIER: Record<RouletteBetKind, Tier>;
+export interface RouletteSpot {
+    id: string;
+    kind: RouletteBetKind;
+    numbers: number[];
+    name?: string;
+}
+export interface RouletteBet {
+    spot: string;
+    prizeId: string;
+    chips: number;
+}
+export declare const ROULETTE_SPOTS: RouletteSpot[];
+export declare const ROULETTE_ANNOUNCED: {
+    nassa: string[];
+    orphans: string[];
+    tiers: string[];
+};
+export type RouletteAnnounced = keyof typeof ROULETTE_ANNOUNCED;
+export declare const rouletteSpot: (id: string) => RouletteSpot;
+export declare const announcedNumbers: (name: RouletteAnnounced) => number[];
+export declare function rouletteWin(bets: RouletteBet[], number: number): {
+    bet: RouletteBet;
+    tier: Tier;
+} | null;
+declare module './rig' {
+    interface Decisions {
+        'roulette.storm': {
+            context: {
+                boost: number;
+            };
+            value: number[];
+        };
+        'roulette.number': {
+            context: {
+                bets: RouletteBet[];
+                storm: number[];
+                boost: number;
+            };
+            value: number;
+        };
+    }
+}
+export declare const drawStorm: (boost: number) => number[];
+export declare const drawRouletteNumber: (bets: RouletteBet[], storm: number[], boost: number) => number;

package/dist/engine/scratch.d.ts

@@ -0,0 +1,40 @@
+import type { Prize, PrizeTier, Tier } from '../config/types';
+import { type Award } from './awards';
+import type { DayTicket } from './tiers';
+declare module './rig' {
+    interface Decisions {
+        'scratch.award': {
+            context: {
+                tier: Tier;
+                prizeId: string;
+            };
+            value: Award;
+        };
+    }
+}
+export declare function scratchCard(tier: Tier, prizeIds: string[], prizeId?: string, award?: Award): {
+    prizeId: string;
+    cells: string[];
+    winning: string | null;
+    award: Award;
+};
+export type ScratchKind = 'classic' | DayTicket;
+export interface TicketPrize {
+    prizeId: string;
+    tier: PrizeTier;
+    award: Award;
+}
+export interface NumbersTicket {
+    winningNumbers: number[];
+    yours: {
+        value: number | string;
+        prize: TicketPrize | null;
+    }[];
+    second: (TicketPrize | null)[];
+    hit: string[];
+    how: 'match' | 'three' | 'pair' | 'logos' | null;
+}
+export declare const ticketPrizes: (prizes: Prize[]) => TicketPrize[];
+export declare const ticketPrizeKey: (prize: TicketPrize) => string;
+export declare function doubleTicket(tier: Tier, prizes: Prize[], prizeId: string, award: Award): NumbersTicket;
+export declare function foreverTicket(tier: Tier, prizes: Prize[], prizeId: string, award: Award): NumbersTicket;

package/dist/engine/slot.d.ts

@@ -0,0 +1,19 @@
+import type { Tier } from '../config/types';
+export type SlotSymbol = string;
+declare module './rig' {
+    interface Decisions {
+        'slot.line': {
+            context: {
+                tier: Tier;
+                prizeId: string;
+            };
+            value: SlotSymbol[];
+        };
+    }
+}
+export declare function slotStrips(prizeIds: string[]): SlotSymbol[][];
+export declare function slotLine(tier: Tier, prizeIds: string[], prizeId?: string): {
+    symbols: SlotSymbol[];
+    prizeId: string;
+};
+export declare function slotWinning(symbols: SlotSymbol[], prefer?: SlotSymbol): number[];

package/dist/engine/themes.d.ts

@@ -0,0 +1,30 @@
+declare module './rig' {
+    interface Decisions {
+        theme: {
+            context: Record<string, never>;
+            value: Theme | null;
+        };
+    }
+}
+export declare const THEMES: readonly ['christmas', 'halloween', 'easter', 'august'];
+export type Theme = (typeof THEMES)[number];
+export declare const THEME_CALENDAR: {
+    theme: Theme;
+    from: string;
+    to?: string;
+}[];
+export declare function easterSunday(year: number): Date;
+export declare function themeOfDay(date?: Date): Theme | null;
+export declare const roomTheme: () => "august" | "christmas" | "easter" | "halloween" | null;
+export declare const THEME_COLORS: Record<Theme, {
+    lights: string[];
+    confetti: string[];
+}>;
+export interface ArtPart {
+    d: string;
+    fill?: string;
+    stroke?: string;
+    width?: number;
+    glow?: boolean;
+}
+export declare const SANTA_SLEIGH: ArtPart[];

package/dist/engine/tiers.d.ts

@@ -0,0 +1,64 @@
+import type { GameId, Tier } from '../config/types';
+declare module './rig' {
+    interface Decisions {
+        boost: {
+            context: {
+                game: GameId;
+            };
+            value: number;
+        };
+        tier: {
+            context: {
+                game: GameId;
+                boost: number;
+            };
+            value: Tier;
+        };
+        prize: {
+            context: {
+                game: GameId;
+                prizeIds: string[];
+            };
+            value: string;
+        };
+    }
+}
+export declare const BONUS_GAMES: GameId[];
+export declare const PRIVATE_GAMES: GameId[];
+export declare const GAME_IDS: GameId[];
+export declare const TIER_ODDS: {
+    jackpot: number;
+    big: number;
+    small: number;
+};
+export declare const TIER_RANK: Tier[];
+export type DayTicket = 'double' | 'forever';
+export type DayMachine = 'takeoff' | 'breakaway';
+export declare const DAY_TICKETS: DayTicket[];
+export declare const DAY_MACHINES: DayMachine[];
+export declare function drawTier(boost?: number, roll?: number): Tier;
+export declare function dailyBonus(date?: Date): {
+    game: GameId;
+    multiplier: number;
+    ticket: DayTicket;
+    machine: DayMachine;
+};
+export declare const luckBoost: (game: GameId, date?: Date) => number;
+export declare const gameBoost: (game: GameId) => number;
+export declare const gameTier: (game: GameId, boost: number) => Tier;
+export declare const gamePrize: (game: GameId, prizeIds: string[]) => string;
+export declare function boostedGame(): GameId | undefined;
+declare module './rig' {
+    interface Decisions {
+        'slot.machine': {
+            context: Record<string, never>;
+            value: DayMachine;
+        };
+        'scratch.ticket': {
+            context: Record<string, never>;
+            value: DayTicket;
+        };
+    }
+}
+export declare const machineOfDay: () => DayMachine;
+export declare const ticketOfDay: () => DayTicket;

package/dist/engine/wheel.d.ts

@@ -0,0 +1,47 @@
+import type { Prize, Tier } from '../config/types';
+import { type Award, type Board } from './awards';
+export type WheelSegment = {
+    kind: 'none';
+} | {
+    kind: 'small';
+    award: Award;
+    pale: boolean;
+} | {
+    kind: 'big';
+    award: Award;
+} | {
+    kind: 'coin' | 'hunt' | 'pachinko';
+} | {
+    kind: 'jackpot';
+};
+declare module './rig' {
+    interface Decisions {
+        'wheel.booster': {
+            context: {
+                boost: number;
+                segments: WheelSegment[];
+            };
+            value: string;
+        };
+        'wheel.segment': {
+            context: {
+                tier: Tier;
+                segments: WheelSegment[];
+            };
+            value: number;
+        };
+    }
+}
+export declare function wheelSegments(board: Board): WheelSegment[];
+export declare const isBonus: (segment: WheelSegment) => boolean;
+export declare function wheelTarget(segments: WheelSegment[], tier: Tier): {
+    index: number;
+    bonus: boolean;
+};
+export declare const segmentKey: (segment: WheelSegment) => string;
+export declare const boosterKeys: (segments: WheelSegment[]) => string[];
+export declare function wheelLanding(segments: WheelSegment[], boosted: string, boost: number, roll?: number): {
+    index: number;
+    tier: Tier;
+};
+export declare function wheelPrize(prizes: Prize[], segment: WheelSegment): Prize<import("..").Variant>;