@adiakys/feeling-lucky 0.0.0-stage → 0.2.0

package/dist/de-B56NsnDF.js

@@ -0,0 +1,458 @@
+import { t as e } from "./merge-iGSNfZkz.js";
+// src/locales/de/index.ts
+var t = e({
+	title: "Auf gut Glück",
+	room: "Spielsaal",
+	backToOverview: "Zur Übersicht",
+	backToGames: "Zu den Spielen",
+	soundOn: "Ton an",
+	soundOff: "Ton aus",
+	rules: "Regeln",
+	chips: "Preis der Chips",
+	ticker: {
+		1: "Auf gut Glück",
+		2: "Großes Rad: Der Jackpot ist auf dem Rad",
+		3: "Drei ∞ auf der Linie: Jackpot",
+		4: "Ein Plein beim Roulette ist den Jackpot wert",
+		5: "Drei gleiche Logos unter der Rubbelschicht",
+		6: "Das mittlere Pachinko-Fach zahlt den Jackpot"
+	},
+	win: {
+		title: "Gewonnen",
+		jackpot: "Jackpot"
+	},
+	tier: {
+		small: "Kleiner Gewinn",
+		big: "Großer Gewinn",
+		jackpot: "Jackpot",
+		symbol: {
+			small: "★",
+			big: "★★",
+			jackpot: "★★★"
+		}
+	},
+	boost: {
+		badge: "×{n}",
+		title: "Bonus des Tages",
+		odds: "Bonus des Tages: Gewinne {n}-mal so wahrscheinlich",
+		dealer: "Croupier am Tisch",
+		dealerOdds: "Croupier am Tisch: Gewinne {n}-mal so wahrscheinlich"
+	},
+	themes: {
+		christmas: {
+			name: "Weihnachten",
+			greeting: "Frohe Festtage: Unterm Baum wartet ein Preis"
+		},
+		halloween: {
+			name: "Halloween",
+			greeting: "Süßes oder Preis?"
+		},
+		easter: {
+			name: "Ostern",
+			greeting: "Frohe Ostern: Was steckt wohl im Ei?"
+		},
+		august: {
+			name: "August",
+			greeting: "Schöne Sommerferien wünscht der Spielsaal"
+		}
+	},
+	lobby: {
+		games: "Spielsaal",
+		private: "Salon Privé",
+		privateLine: "Reservierte Tische",
+		pager: "Säle"
+	},
+	chipCount: {
+		hint: "Setz bis zu {n} Chips",
+		left: "Noch {n} Chips",
+		leftOne: "Noch 1 Chip",
+		none: "Keine Chips mehr"
+	},
+	cert: {
+		title: "Preis gewonnen",
+		prize: "Preis",
+		variant: "Variante",
+		fullPrize: "Der ganze Preis",
+		wonOn: "Gewonnen am",
+		notClaimed: "Einzulösen",
+		claimed: "Eingelöst",
+		claim: "Preis einlösen",
+		claiming: "Wird eingelöst…",
+		claimFailed: "Der Preis konnte nicht eingelöst werden. Versuch es noch einmal.",
+		seal: "AUF GUT GLÜCK · PREIS GEWONNEN ·",
+		sealClaimed: "EINGELÖST · AUF GUT GLÜCK ·",
+		again: "{game} noch mal spielen",
+		otherGame: "Spiel wechseln"
+	}
+}, {
+	games: { wheel: {
+		name: "Großes Rad",
+		summary: "Multiplikator: Preis · Rad: Gewinn",
+		rules: "Der Multiplikator wählt den Preis, das Rad den Gewinn: einen kleinen oder einen großen Preis. Kopf oder Zahl, Preisjagd und Pachinko decken den Gewinn auf; Großes Rad ist der Jackpot."
+	} },
+	wheel: {
+		booster: "MULTIPLIKATOR",
+		spin: "Rad drehen",
+		hint: "Oder pack das Rad und schleudere es; zoome auf das Rad, um es aus der Nähe zu sehen",
+		segment: {
+			coin: "KOPF ODER ZAHL",
+			hunt: "PREISJAGD",
+			pachinko: "PACHINKO",
+			jackpot: "GROSSES RAD"
+		},
+		pachinkoTitle: "Pachinko-Bonus",
+		pachinkoText: "Die Kugel entscheidet den Gewinn. Der Preis bleibt {prize}.",
+		toPachinko: "Zum Pachinko",
+		boosterRules: "Multiplikator des Tages: Bei jeder Drehung wählt der Multiplikator auch eine Feldart, die {n}-mal so oft kommt. Der Multiplikator wählt den Preis, das Rad den Gewinn: einen kleinen oder einen großen Preis. Kopf oder Zahl, Preisjagd und Pachinko decken den Gewinn auf; Großes Rad ist der Jackpot."
+	},
+	coin: {
+		text: "Gold oder Rubin: Die Münze entscheidet den Gewinn.",
+		gold: "Gold",
+		ruby: "Rubin",
+		flip: "Münze werfen"
+	},
+	hunt: {
+		text: "Achtzehn Felder, unter jedem ein Gewinn. Wähl eins.",
+		tile: "Feld {n}"
+	},
+	detail: { wheel: {
+		small: "Gewinnfeld",
+		big: "Gewinnfeld",
+		jackpot: "Jackpotfeld",
+		coin: "Kopf oder Zahl",
+		hunt: "Preisjagd",
+		pachinko: "Pachinko-Bonus"
+	} }
+}, {
+	games: { slot: {
+		name: "Slot",
+		summary: "Drei Symbole auf der Linie",
+		rules: "Zwei gleiche Preise auf der Linie: ein kleiner Preis. Drei Preise oder drei 7: ein großer Preis. Drei ∞: der Jackpot."
+	} },
+	slot: {
+		sign: "JACKPOT",
+		ready: "Zieh den Hebel",
+		spinning: "Die Walzen drehen sich…",
+		line: "Auf der Linie",
+		spin: "Walzen drehen",
+		lever: "Hebel ziehen",
+		result: {
+			none: "Keine Kombination",
+			small: "Paar auf der Linie",
+			big: "Drilling auf der Linie",
+			jackpot: "Drei ∞"
+		},
+		names: {
+			takeoff: "Abheben",
+			breakaway: "Konter"
+		},
+		takeoff: {
+			rules: "Flug des Tages: Gewinne kommen {n}-mal so oft. Das Flugzeug hebt ab und der Multiplikator steigt: Kassier, bevor es davonfliegt. Ab ×2 gewinnst du einen kleinen Preis, ab ×10 einen großen, bei ×50 den Jackpot: Je länger du wartest, desto größer der Preis.",
+			start: "Abheben",
+			again: "Neuer Flug",
+			cashOut: "{prize} kassieren",
+			cashFrom: "Kassieren ab ×{m}",
+			ready: "Bereit zum Abheben",
+			gone: "Davongeflogen!",
+			cashed: "Kassiert bei ×{m}: {prize}",
+			hint: "Kassier, wann du willst: Fliegt das Flugzeug vorher davon, gewinnst du nichts"
+		},
+		breakaway: {
+			rules: "Spiel des Tages: Gewinne kommen {n}-mal so oft. Lauf aufs Tor zu und wähl in jeder Spalte ein Feld: In einem steht der Verteidiger. Jede geschaffte Spalte erhöht den Preis und du kannst jederzeit kassieren; vor dem Tor schießt du: Mit dem Tor gewinnst du, was du gesammelt hast, bis zum Jackpot.",
+			pick: "Wähl ein Feld in Spalte {n}",
+			shoot: "Wähl, wohin du schießt",
+			tackled: "Abgegrätscht! Der gesammelte Preis ist weg",
+			goal: "TOR!",
+			again: "Neues Spiel",
+			cashOut: "{prize} kassieren",
+			cashFrom: "Kassieren ab Spalte {n}",
+			square: "Spalte {column}, Feld {row}",
+			zone: "Auf Zone {n} schießen"
+		}
+	},
+	detail: { slot: {
+		small: "Paar auf der Linie",
+		big: "Drilling auf der Linie",
+		jackpot: "drei ∞",
+		takeoff: "kassiert bei ×{m}",
+		breakaway: "{n} Spalten geschafft",
+		goal: "Tor"
+	} }
+}, {
+	games: { roulette: {
+		name: "Roulette",
+		summary: "Setz deine Chips, dann wirf die Kugel",
+		rules: "Setz bis zu {n} Chips eines Preises, auf den Tisch oder mit Nassa, Orphelins und Tiers, die sie auf ihre Pleins und Chevaux verteilen: Alle Chips gehören zum Preis des ersten. Ein Plein gewinnt den Jackpot; Cheval, Transversale pleine, Carré und Transversale simple einen großen Preis; Kolonnen, Dutzende und einfache Chancen einen kleinen Preis. Gewinnen mehrere Einsätze, zählt der beste."
+	} },
+	roulette: {
+		launch: "Kugel werfen",
+		clear: "Chips zurücknehmen",
+		table: "Tisch",
+		call: {
+			made: "Les jeux sont faits",
+			closed: "Rien ne va plus"
+		},
+		board: {
+			column: "2:1",
+			dozen1: "12P",
+			dozen2: "12M",
+			dozen3: "12D",
+			low: "Manque",
+			even: "Pair",
+			odd: "Impair",
+			high: "Passe"
+		},
+		kind: {
+			straight: "Plein {numbers}",
+			split: "Cheval {numbers}",
+			street: "Transversale pleine {numbers}",
+			corner: "Carré {numbers}",
+			line: "Transversale simple {numbers}"
+		},
+		spot: {
+			column: {
+				1: "Kolonne 1-34",
+				2: "Kolonne 2-35",
+				3: "Kolonne 3-36"
+			},
+			dozen: {
+				1: "Erstes Dutzend",
+				2: "Mittleres Dutzend",
+				3: "Letztes Dutzend"
+			},
+			chance: {
+				low: "Manque, 1 bis 18",
+				even: "Pair",
+				red: "Rouge",
+				black: "Noir",
+				odd: "Impair",
+				high: "Passe, 19 bis 36"
+			}
+		},
+		track: "Annoncen",
+		announced: {
+			nassa: "Nassa",
+			orphans: "Orphelins",
+			tiers: "Tiers",
+			cost: "{n} Chips",
+			label: "{name}, {n} Chips"
+		},
+		surface: "Wo setzen",
+		storm: {
+			title: "Sturm",
+			rules: "Sturm-Roulette, der Bonus des Tages. Setz bis zu {n} Chips wie beim Roulette; bei jedem Wurf schlägt nach Rien ne va plus der Blitz in 3 Zahlen ein, die {m}-mal so oft kommen. Ein Plein gewinnt den Jackpot; Chevaux, Transversales pleines, Carrés und Transversales simples einen großen Preis; Kolonnen, Dutzende und einfache Chancen einen kleinen Preis.",
+			odds: "Kommen {n}× so oft",
+			numbers: "Blitzzahlen"
+		},
+		undo: "Letzten Chip entfernen",
+		rebet: "Einsatz wiederholen"
+	},
+	detail: {
+		roulette: "Zahl {n}",
+		storm: "Blitzzahl {n}"
+	}
+}, {
+	games: { pachinko: {
+		name: "Pachinko",
+		summary: "Das Fach entscheidet den Preis",
+		rules: "Wähl den Preis und wo die Kugel fällt: Das Fach entscheidet, was du gewinnst, einen kleinen oder einen großen Preis; das mittlere Fach ist der Jackpot. Fächer mit Strich zahlen nichts.",
+		bonusRules: "Bonus vom Großen Rad: Der Preis bleibt {prize}. Wähl, wo die Kugel fällt; das Fach zeigt, was du gewinnst."
+	} },
+	pachinko: {
+		launch: "Kugel fallen lassen",
+		hint: "Fahr mit der Maus über das Brett, um zu wählen, wo sie fällt, dann klick. Pfeiltasten und Leertaste gehen auch.",
+		redHits: "Rote getroffen",
+		powerOn: "Violett aktiv",
+		powerOff: "Triff den Violetten",
+		chance: "Gewinnchance",
+		detail: "Pachinko · bunte Stifte",
+		colorRules: "Fächer mit Strich zahlen nichts; die anderen steigen mit jedem getroffenen Roten, von einem kleinen bis zu einem großen Preis. Mit allen 8 Roten ist das mittlere Fach der Jackpot. Die violette Kugel vervielfacht die Chancen des Tages noch einmal.",
+		fever: "Goldfieber",
+		feverTitle: "ALLE ROTEN!"
+	},
+	detail: { pachinko: "Gewinnfach" }
+}, {
+	games: { scratch: {
+		name: "Rubbellos",
+		summary: "Drei gleiche Logos",
+		rules: "Drei gleiche Logos gewinnen diesen Preis; der Streifen unten zeigt, was er zahlt, bis zum Jackpot."
+	} },
+	scratch: {
+		title: "Rubbel deinen Preis frei",
+		rule: "Drei gleiche Logos gewinnen den Preis. Der Streifen unten zeigt, was er zahlt.",
+		award: "Gewinn",
+		series: "AUF GUT GLÜCK · SERIE FORTUNA",
+		watermark: "GLÜCK",
+		revealAll: "Alles freirubbeln",
+		newTicket: "Neues Los",
+		hint: "Rubbel mit der Maus oder dem Finger",
+		locked: "Freirubbeln mit drei gleichen Logos",
+		prize: "PREIS",
+		winningNumbers: "GEWINNZAHLEN",
+		yourNumbers: "DEINE ZAHLEN",
+		game: "SPIEL {n}",
+		topPrize: "HAUPTPREIS: DER JACKPOT",
+		double: {
+			first: "DOPPEL",
+			second: "GLÜCK",
+			tagline: "2 Spiele in einem!",
+			rules: "Zwei Arten zu gewinnen: Eine Gewinnzahl unter deinen Zahlen gewinnt den Preis darunter; drei gleiche Preise gewinnen diesen Preis. Unter den Logos liegt kein Preis: Drei gleiche Logos gewinnen den Jackpot."
+		},
+		forever: {
+			first: "FÜR",
+			middle: "∞",
+			second: "IMMER",
+			jackpot: "3 gleiche Logos: der Jackpot",
+			pairRule: "Zwei gleiche Preise gewinnen diesen Preis",
+			rules: "Spiel 1: Eine Gewinnzahl unter deinen Zahlen gewinnt den Preis darunter; unter den Logos liegt kein Preis, aber drei gleiche Logos gewinnen den Jackpot. Spiel 2: Zwei gleiche Preise gewinnen diesen Preis."
+		},
+		names: {
+			double: "Doppelglück",
+			forever: "Für Immer"
+		},
+		dayRules: "Los des Tages: Gewinnlose kommen {n}-mal so oft."
+	},
+	detail: { scratch: {
+		small: "drei gleiche Logos",
+		big: "drei gleiche Logos",
+		jackpot: "drei gleiche Logos",
+		match: "Gewinnzahl",
+		three: "drei gleiche Preise",
+		pair: "zwei gleiche Preise",
+		logos: "drei gleiche Logos"
+	} }
+}, {
+	games: {
+		blackjack: {
+			name: "Blackjack",
+			summary: "Schlag die Bank, ohne über 21 zu kommen",
+			rules: "Setz bis zu 5 Chips eines Preises in den Kreis vor deinem Platz: Alle Chips gehören zum Preis des ersten. Dann schlag die Bank, ohne über 21 zu kommen; die Bank steht bei 17. Auf deine ersten zwei Karten kannst du verdoppeln, mit einem zweiten Stapel Chips und nur einer Karte, oder zwei gleichwertige Karten in zwei Hände mit je einem Stapel teilen; nach dem Teilen zählt die beste Hand, geteilte Asse bekommen nur eine Karte. Gewinnst du die Hand, gibt es den Preis der Chips: einen kleinen Preis, einen großen mit einem ausgeteilten Blackjack, Ass und Zehn oder Bild. Der Pik-Blackjack, Pik-Ass und Pik-Bube, ist der Jackpot."
+		},
+		holdem: {
+			name: "Texas Hold'em",
+			summary: "Die beste Hand gegen die Bank",
+			rules: "Du und die Bank bekommt je zwei Karten, dann kommen die drei Karten des Flops: mitgehen oder aussteigen. Gehst du mit, folgen Turn und River, und die beste Hand aus fünf Karten gewinnt. Ein Sieg mit höchster Karte, Paar, zwei Paaren oder Drilling bringt einen kleinen Preis, mit Straße oder besser einen großen; der Royal Flush ist der Jackpot. Wer aussteigt, verliert die Hand."
+		}
+	},
+	cards: {
+		you: "Du",
+		dealer: "Bank",
+		deal: "Geben"
+	},
+	blackjack: {
+		print: "Bank steht bei 17 · Pik-Blackjack: Jackpot",
+		hit: "Karte",
+		stand: "Stehen",
+		double: "Verdoppeln",
+		split: "Teilen",
+		bet: "Chip für {prize} setzen",
+		result: {
+			bust: "Überkauft",
+			lose: "Die Bank gewinnt",
+			win: "Du schlägst die Bank",
+			dealerBust: "Die Bank überkauft sich",
+			natural: "Blackjack!",
+			spades: "Pik-Blackjack!"
+		}
+	},
+	holdem: {
+		print: "Die Bank spielt jede Hand · Royal Flush: Jackpot",
+		call: "Mitgehen",
+		fold: "Aussteigen",
+		hands: {
+			highCard: "Höchste Karte",
+			pair: "Paar",
+			twoPair: "Zwei Paare",
+			trips: "Drilling",
+			straight: "Straße",
+			flush: "Flush",
+			fullHouse: "Full House",
+			quads: "Vierling",
+			straightFlush: "Straight Flush",
+			royalFlush: "Royal Flush"
+		},
+		result: {
+			folded: "Du bist ausgestiegen",
+			won: "Du gewinnst mit {hand}",
+			lost: "Die Bank gewinnt mit {hand}",
+			split: "Unentschieden"
+		}
+	},
+	detail: {
+		blackjack: {
+			win: "Hand gewonnen",
+			dealerBust: "Bank überkauft",
+			natural: "ausgeteilter Blackjack",
+			spades: "Pik-Blackjack"
+		},
+		holdem: "gewonnen mit {hand}"
+	}
+}, { developer: {
+	title: "Entwickler-Steuerung",
+	restore: "Entwickler-Steuerung öffnen",
+	minimize: "Auf Symbol verkleinern",
+	close: "Entwickler-Steuerung schließen",
+	password: "Passwort",
+	unlock: "Entsperren",
+	wrongPassword: "Falsches Passwort.",
+	hint: "Strg+Umschalt+L öffnet und schließt dieses Fenster. Design und Sprache wechseln sofort; die Spieleinstellungen gelten ab dem Neustart des Spiels.",
+	game: "Spiel",
+	multiplier: "Multiplikator",
+	daily: "Tageswert",
+	result: "Ergebnis",
+	automatic: "Automatisch",
+	loss: "Verlust",
+	win: "Gewinn",
+	jackpot: "Jackpot",
+	decidedBy: "Die erweiterte Einstellung „{field}“ entscheidet das Ergebnis.",
+	advanced: "Erweitert",
+	field: {
+		segment: "Feld",
+		prize: "Preis",
+		combination: "Kombination",
+		number: "Zahl",
+		violet: "Violette Kugel",
+		pocket: "Fach",
+		award: "Variante",
+		storm: "Sturmzahl",
+		booster: "Multiplikator-Feld"
+	},
+	option: {
+		nothing: "Nichts",
+		award: "{tier} · {award}",
+		pair: "Logo-Paar",
+		logos: "Drei Logos",
+		sevens: "Drei Siebenen",
+		infinities: "Dreimal unendlich",
+		hit: "Getroffen",
+		miss: "Verfehlt",
+		pocket: "Fach {n}",
+		lands: "Kommt",
+		misses: "Kommt nicht"
+	},
+	about: {
+		roulette: "Die gewählte Zahl kommt immer. Bei einem erzwungenen Ergebnis oder einer Sturmzahl, die kommen soll oder nicht, kommt die Zahl aus denen, die die Einsätze auf dem Tisch zulassen; lässt keine es zu, wird normal gezogen. Mit einem Multiplikator wird das Roulette zum Sturm-Roulette.",
+		pachinko: "Die violette Kugel gibt es nur beim bunten Pachinko, mit einem Multiplikator. Dort hängt der Preis von den getroffenen Roten ab: Beim Jackpot reihen sich die Roten entlang der Fallbahn auf und die Kugel trifft sie alle.",
+		wheel: "Mit einem Multiplikator wählt der Multiplikator eine Feldart, die öfter kommt: Hier legst du fest, welche. Das gewählte Feld entscheidet trotzdem, wo das Rad stehen bleibt.",
+		slot: "Normalerweise läuft der klassische Slot. Am Bonustag tritt der Slot des Tages an seine Stelle, Abheben oder Konter, nach dem Datum gezogen: Hier lässt er sich zusammen mit dem Multiplikator festlegen. Das gezogene Ergebnis ist das Höchste, was erreichbar ist.",
+		scratch: "Normalerweise gibt es das klassische Los. Am Bonustag tritt das Los des Tages an seine Stelle, eines der beiden Zahlenlose, nach dem Datum gezogen: Hier lässt es sich zusammen mit dem Multiplikator festlegen. Eine ohne Preis gewählte Variante geht an einen Preis, der sie auszahlt.",
+		blackjack: "Der Kartenschlitten inszeniert das gezogene Ergebnis, egal was der Spieler entscheidet: Mit Gewinn wird die Hand gewonnen, mit Jackpot kommt der Pik-Blackjack.",
+		holdem: "Die Karten werden aus denen gewählt, die das gezogene Ergebnis ergeben: Mit Gewinn gewinnt man, wenn man mitgeht, mit Jackpot kommt der Royal Flush. Wer aussteigt, verliert die Hand trotzdem."
+	},
+	reset: "Alle Spiele zurücksetzen",
+	apply: "Anwenden und Spiel neu starten",
+	variant: {
+		scratch: "Los des Tages",
+		slot: "Slot des Tages"
+	},
+	theme: "Saal-Design",
+	calendar: "Nach Kalender",
+	noTheme: "Keins",
+	language: "Sprache",
+	autoLanguage: "Automatisch",
+	dealer: "Croupier",
+	dealerShifts: "Nach den Schichten des Tages",
+	dealerAbsent: "Abwesend",
+	dealerNumber: "Croupier {n}"
+} });
+export { t as default };

package/dist/developer/panel.d.ts

@@ -0,0 +1,61 @@
+import { nothing } from 'lit';
+import { LuckyElement } from '../runtime/element';
+export declare class Developer extends LuckyElement {
+    passwordHash?: string;
+    private open;
+    private unlocked;
+    private password;
+    private wrong;
+    private minimized;
+    private position;
+    private selected;
+    private draft;
+    private loads;
+    private advancedOpen;
+    private box?;
+    private first?;
+    private iconButton?;
+    private drag;
+    private dragged;
+    private lastFocus;
+    constructor();
+    protected willUpdate(): void;
+    private get activeElement();
+    private load;
+    private save;
+    private place;
+    private focusFirst;
+    private grab;
+    private move;
+    private release;
+    private minimize;
+    private restore;
+    private grant;
+    private unlock;
+    private apply;
+    private reset;
+    private toggle;
+    private setLanguage;
+    private setDealer;
+    private setTheme;
+    private shortcut;
+    private keydown;
+    private fit;
+    connectedCallback(): void;
+    firstUpdated(): void;
+    disconnectedCallback(): void;
+    private awardLabel;
+    private segmentOption;
+    private options;
+    private change;
+    private changeAdvanced;
+    private selectGame;
+    private choices;
+    private renderBody;
+    render(): typeof nothing | import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'fl-developer': Developer;
+    }
+}

package/dist/developer/rig.d.ts

@@ -0,0 +1,2 @@
+import type { Rig } from '../engine/rig';
+export declare const developerRig: Rig;

package/dist/developer/settings.d.ts

@@ -0,0 +1,30 @@
+import type { GameId, Prize, PrizeTier, Tier } from '../config/types';
+import type { Award } from '../engine/awards';
+import type { Theme } from '../engine/themes';
+export type Result = 'automatic' | 'loss' | 'win' | 'jackpot';
+export type Field = 'segment' | 'booster' | 'prize' | 'combination' | 'number' | 'storm' | 'violet' | 'pocket' | 'award';
+export interface GameSettings {
+    multiplier?: number;
+    variant?: string;
+    result: Result;
+    advanced: Partial<Record<Field, string>>;
+}
+export declare const RESULTS: Result[];
+export declare const ADVANCED: Record<GameId, Field[]>;
+export declare const DECISIVE: Field[];
+export declare const settings: Partial<Record<GameId, GameSettings>>;
+export declare const room: {
+    theme?: Theme | 'none';
+    locale?: string;
+    dealer?: number | 'none';
+    prizes: Prize[];
+};
+export declare const blankSettings: () => GameSettings;
+export declare const VARIANTS: Partial<Record<GameId, readonly string[]>>;
+export declare const settingsOf: (game: GameId) => GameSettings;
+export declare function parseAward(key: string): {
+    tier: PrizeTier;
+    award: Award;
+};
+export declare const COMBINATION_TIER: Record<string, Tier>;
+export declare function passwordMatches(password: string, hash: string): Promise<boolean>;

package/dist/engine/awards.d.ts

@@ -0,0 +1,12 @@
+import type { Prize, PrizeTier, Tier, Variant } from '../config/types';
+export type Award = string | null;
+export type Board = Record<PrizeTier, Award[]>;
+export declare const PRIZE_TIERS: PrizeTier[];
+export declare const variantsOf: (prize: Prize, tier: PrizeTier) => Variant[];
+export declare const awardOf: (variant: Variant) => string;
+export declare function boardOf(prizes: Prize[]): Board;
+export declare function drawAward(prize: Prize, tier: Tier): Award;
+export declare function prizesPaying(prizes: Prize[], tier: PrizeTier, award: Award): Prize[];
+export declare function resolveVariant(prize: Prize, tier: PrizeTier, award: Award): Promise<Variant | null>;
+export declare const spread: <T>(items: readonly T[], count: number) => T[];
+export declare const awardKey: (tier: PrizeTier, award: Award) => string;

package/dist/engine/cards.d.ts

@@ -0,0 +1,44 @@
+import type { Tier } from '../config/types';
+export declare const SUITS: readonly ['spades', 'hearts', 'diamonds', 'clubs'];
+export type Suit = (typeof SUITS)[number];
+export interface Card {
+    rank: number;
+    suit: Suit;
+}
+export declare const DECK: Card[];
+export declare const rankLabel: (rank: number) => string;
+export declare function handTotal(cards: Card[]): {
+    total: number;
+    soft: boolean;
+};
+export declare const isNatural: (cards: Card[]) => boolean;
+export declare const canSplit: (cards: Card[]) => boolean;
+export declare function blackjackDeal(tier: Tier): {
+    player: Card[];
+    dealer: Card[];
+};
+export declare function blackjackHit(tier: Tier, player: Card[]): Card;
+export declare function blackjackDealer(tier: Tier, dealer: Card[], playerTotal: number | null): Card[];
+export declare const blackjackPrize: (player: Card[]) => Tier;
+export declare const HAND_NAMES: readonly ['highCard', 'pair', 'twoPair', 'trips', 'straight', 'flush', 'fullHouse', 'quads', 'straightFlush', 'royalFlush'];
+export interface PokerHand {
+    category: number;
+    ranks: number[];
+    cards: Card[];
+}
+export declare const compareHands: (a: PokerHand, b: PokerHand) => number;
+export declare function bestHand(cards: Card[]): PokerHand;
+export declare function holdemDeal(tier: Tier): {
+    player: Card[];
+    dealer: Card[];
+    board: Card[];
+};
+export declare const holdemResult: (player: Card[], dealer: Card[], board: Card[]) => {
+    mine: PokerHand;
+    theirs: PokerHand;
+    tier: Tier;
+    lost: boolean;
+};
+export declare const SUIT_PATHS: Record<Suit, string>;
+export declare const isRed: (card: Card) => boolean;
+export declare function combination(hand: PokerHand): Card[];

package/dist/engine/cashout.d.ts

@@ -0,0 +1,32 @@
+import type { PrizeTier, Tier } from '../config/types';
+import { type Award, type Board } from './awards';
+declare module './rig' {
+    interface Decisions {
+        'breakaway.tackle': {
+            context: {
+                tier: Tier;
+            };
+            value: number | null;
+        };
+    }
+}
+export interface CashStep {
+    tier: PrizeTier;
+}
+export interface TakeoffStep extends CashStep {
+    at: number;
+}
+export type Priced<T> = T extends null ? null : T & {
+    award: Award;
+};
+export declare function cashAwards<T extends CashStep | null>(steps: T[], board: Board): Priced<T>[];
+export declare const TAKEOFF_STEPS: TakeoffStep[];
+export declare const TAKEOFF_TOP = 50;
+export declare const takeoffAt: (seconds: number) => number;
+export declare const takeoffTime: (multiplier: number) => number;
+export declare function takeoffCrash(tier: Tier, roll?: number): number;
+export declare const takeoffStep: <T extends TakeoffStep>(multiplier: number, steps: T[]) => T | undefined;
+export declare const BREAKAWAY_LANES = 4;
+export declare const BREAKAWAY_STEPS: (CashStep | null)[];
+export declare const breakawayTackle: (tier: Tier) => number | null;
+export declare const breakawayStep: <T extends CashStep>(cleared: number, steps: (T | null)[]) => T | null | undefined;

package/dist/engine/dealer.d.ts

@@ -0,0 +1,21 @@
+declare module './rig' {
+    interface Decisions {
+        dealer: {
+            context: {
+                count: number;
+            };
+            value: number | null;
+        };
+    }
+}
+export declare const DEALER_BOOST = 2;
+export interface Shift {
+    start: number;
+    end: number;
+    dealer: number;
+}
+export declare function dealerShifts(date: Date, count: number): Shift[];
+export declare function shiftAt(date: Date, count: number): number | null;
+export declare const roster: import("../runtime/signal").Signal<number>;
+export declare const onDuty: import("../runtime/signal").Signal<number | null>;
+export declare function checkDuty(now?: Date): void;

package/dist/engine/outcome.d.ts

@@ -0,0 +1,13 @@
+import type { GameId, Tier } from '../config/types';
+import type { Award } from './awards';
+export interface Message {
+    key: string;
+    params?: Record<string, string | number>;
+}
+export interface Outcome {
+    game: GameId;
+    tier: Tier;
+    prizeId: string;
+    award: Award;
+    detail: Message;
+}