gambling-bot-shared 1.0.4 → 1.0.5

package/dist/casino/index.d.ts

@@ -2,6 +2,7 @@ export * from './constants';
 export * from './types/casinoSettings';
 export * from './types/blackjackGame';
 export * from './utils/calculateRTP';
+export * from './utils/calculateRouletteWin';
 export * from './utils/validateBetAmount';
 export * from './utils/normalizeCasinoSettings';
 export * from './utils/winAnnouncements';

package/dist/casino/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./types/casinoSettings"), exports);
 __exportStar(require("./types/blackjackGame"), exports);
 __exportStar(require("./utils/calculateRTP"), exports);
+__exportStar(require("./utils/calculateRouletteWin"), exports);
 __exportStar(require("./utils/validateBetAmount"), exports);
 __exportStar(require("./utils/normalizeCasinoSettings"), exports);
 __exportStar(require("./utils/winAnnouncements"), exports);

package/dist/casino/utils/calculateRouletteWin.d.ts

@@ -0,0 +1,9 @@
+import type { TCasinoSettings } from '../types/casinoSettings';
+export type RouletteBetType = keyof TCasinoSettings['roulette']['winMultipliers'];
+export type RouletteBet = {
+    type: RouletteBetType;
+    value: string;
+    amount: number;
+};
+export type RouletteWinMultipliers = TCasinoSettings['roulette']['winMultipliers'];
+export declare function calculateRouletteWin(bet: RouletteBet, result: string, payouts: RouletteWinMultipliers): number;

package/dist/casino/utils/calculateRouletteWin.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRouletteWin = calculateRouletteWin;
+const rouletteConfig_1 = require("../constants/rouletteConfig");
+function calculateRouletteWin(bet, result, payouts) {
+    const amount = bet.amount;
+    const numResult = Number(result);
+    switch (bet.type) {
+        case 'number':
+            return bet.value === result ? amount * payouts.number : 0;
+        case 'color':
+            if (result === '0')
+                return 0;
+            return rouletteConfig_1.MINI_NUMBERS[result] === bet.value.toLowerCase()
+                ? amount * payouts.color
+                : 0;
+        case 'parity':
+            if (result === '0')
+                return 0;
+            return bet.value.toLowerCase() === (numResult % 2 === 0 ? 'even' : 'odd')
+                ? amount * payouts.parity
+                : 0;
+        case 'range':
+            if (result === '0')
+                return 0;
+            return bet.value.toLowerCase() ===
+                (numResult >= 1 && numResult <= 9 ? 'low' : 'high')
+                ? amount * payouts.range
+                : 0;
+        case 'dozen':
+            if (result === '0')
+                return 0;
+            return Number(bet.value) === Math.ceil(numResult / 6)
+                ? amount * payouts.dozen
+                : 0;
+        case 'column':
+            if (result === '0')
+                return 0;
+            return Number(bet.value) === ((numResult - 1) % 3) + 1
+                ? amount * payouts.column
+                : 0;
+        default:
+            return 0;
+    }
+}

package/dist/dev/bonusStressTest.d.ts

@@ -0,0 +1,18 @@
+import type { BonusSettings } from '../bonus/types/bonus';
+import type { PreviewDay } from '../bonus/utils/generateBonusPreview';
+export type BonusStressSummary = {
+    days: number;
+    totalReward: number;
+    avgReward: number;
+    maxReward: number;
+    maxDay: number;
+    resetCount: number;
+    weeklyBonuses: number;
+    monthlyBonuses: number;
+    cycleLength: number;
+    elapsedMs: number;
+};
+export type BonusStressResult = BonusStressSummary & {
+    preview: PreviewDay[];
+};
+export declare function runBonusStressTest(settings: BonusSettings, days: number, onProgress?: (completed: number, total: number) => void, chunkSize?: number): Promise<BonusStressResult>;

package/dist/dev/bonusStressTest.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBonusStressTest = runBonusStressTest;
+const calculateBonusReward_1 = require("../bonus/utils/calculateBonusReward");
+const yieldToEventLoop_1 = require("./yieldToEventLoop");
+const summarizePreview = (preview, settings, elapsedMs) => {
+    let totalReward = 0;
+    let maxReward = 0;
+    let maxDay = 1;
+    let resetCount = 0;
+    let weeklyBonuses = 0;
+    let monthlyBonuses = 0;
+    for (const day of preview) {
+        totalReward += day.reward;
+        if (day.reward > maxReward) {
+            maxReward = day.reward;
+            maxDay = day.day;
+        }
+        if (day.isReset)
+            resetCount++;
+        if (day.weekly > 0)
+            weeklyBonuses++;
+        if (day.monthly > 0)
+            monthlyBonuses++;
+    }
+    const cycleLength = (0, calculateBonusReward_1.getBonusCycleLength)(settings.rewardMode, settings.baseReward, settings.maxReward, settings.streakIncrement ?? 0, settings.streakMultiplier ?? 1);
+    return {
+        days: preview.length,
+        totalReward: Number(totalReward.toFixed(2)),
+        avgReward: preview.length
+            ? Number((totalReward / preview.length).toFixed(2))
+            : 0,
+        maxReward,
+        maxDay,
+        resetCount,
+        weeklyBonuses,
+        monthlyBonuses,
+        cycleLength,
+        elapsedMs,
+        preview
+    };
+};
+async function runBonusStressTest(settings, days, onProgress, chunkSize = 5000) {
+    const started = performance.now();
+    const preview = [];
+    let completed = 0;
+    while (completed < days) {
+        const batch = Math.min(chunkSize, days - completed);
+        for (let i = 0; i < batch; i++) {
+            const day = completed + i + 1;
+            const reward = (0, calculateBonusReward_1.calculateBonusReward)({ streak: day, settings });
+            preview.push({
+                day,
+                reward: reward.reward,
+                base: reward.base,
+                weekly: reward.weekly,
+                monthly: reward.monthly,
+                isReset: reward.isReset
+            });
+        }
+        completed += batch;
+        onProgress?.(completed, days);
+        await (0, yieldToEventLoop_1.yieldToEventLoop)();
+    }
+    return summarizePreview(preview, settings, Math.round(performance.now() - started));
+}

package/dist/dev/casinoMonteCarlo.d.ts

@@ -0,0 +1,16 @@
+import type { TCasinoSettings } from '../casino/types/casinoSettings';
+import { type RouletteBetType } from '../casino/utils/calculateRouletteWin';
+export type MonteCarloTarget = 'dice' | 'coinflip' | 'slots' | 'lottery' | 'plinko' | 'goldenJackpot' | `roulette:${RouletteBetType}`;
+export declare const MONTE_CARLO_TARGETS: MonteCarloTarget[];
+export type MonteCarloResult = {
+    target: MonteCarloTarget;
+    label: string;
+    iterations: number;
+    theoreticalRtp: number | null;
+    empiricalRtp: number;
+    delta: number | null;
+    elapsedMs: number;
+    distribution?: Record<string, number>;
+};
+export declare function runMonteCarloSimulation(target: MonteCarloTarget, settings: TCasinoSettings, iterations: number, onProgress?: (completed: number, total: number) => void, chunkSize?: number): Promise<MonteCarloResult>;
+export declare function runAllMonteCarloSimulations(settings: TCasinoSettings, iterations: number, onProgress?: (completed: number, total: number) => void): Promise<MonteCarloResult[]>;

package/dist/dev/casinoMonteCarlo.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MONTE_CARLO_TARGETS = void 0;
+exports.runMonteCarloSimulation = runMonteCarloSimulation;
+exports.runAllMonteCarloSimulations = runAllMonteCarloSimulations;
+const lotteryConfig_1 = require("../casino/constants/lotteryConfig");
+const plinkoConfig_1 = require("../casino/constants/plinkoConfig");
+const plinkoConfig_2 = require("../casino/constants/plinkoConfig");
+const rouletteConfig_1 = require("../casino/constants/rouletteConfig");
+const calculateRTP_1 = require("../casino/utils/calculateRTP");
+const calculateRouletteWin_1 = require("../casino/utils/calculateRouletteWin");
+const yieldToEventLoop_1 = require("./yieldToEventLoop");
+const toNumber = (val) => {
+    if (typeof val === 'string')
+        return parseFloat(val) || 0;
+    if (typeof val === 'number')
+        return val;
+    return 0;
+};
+const ROULETTE_NUMBERS = Object.keys(rouletteConfig_1.MINI_NUMBERS);
+const ROULETTE_BET_TYPES = [
+    'number',
+    'color',
+    'parity',
+    'range',
+    'dozen',
+    'column'
+];
+const ROULETTE_REP_BETS = {
+    number: { type: 'number', value: '1', amount: 1 },
+    color: { type: 'color', value: 'red', amount: 1 },
+    parity: { type: 'parity', value: 'even', amount: 1 },
+    range: { type: 'range', value: 'low', amount: 1 },
+    dozen: { type: 'dozen', value: '1', amount: 1 },
+    column: { type: 'column', value: '2', amount: 1 }
+};
+exports.MONTE_CARLO_TARGETS = [
+    'dice',
+    'coinflip',
+    'slots',
+    'lottery',
+    'plinko',
+    'goldenJackpot',
+    ...ROULETTE_BET_TYPES.map((type) => `roulette:${type}`)
+];
+const drawUnique = (count, max) => {
+    const pool = Array.from({ length: max }, (_, index) => index + 1);
+    const picks = [];
+    for (let i = 0; i < count; i++) {
+        const index = Math.floor(Math.random() * pool.length);
+        picks.push(pool[index]);
+        pool.splice(index, 1);
+    }
+    return picks;
+};
+const pickWeightedSymbol = (weights) => {
+    const entries = Object.entries(weights);
+    const total = entries.reduce((sum, [, weight]) => sum + toNumber(weight), 0);
+    let roll = Math.random() * total;
+    let selected = entries[entries.length - 1]?.[0] ?? '';
+    for (const [symbol, weight] of entries) {
+        roll -= toNumber(weight);
+        if (roll <= 0) {
+            selected = symbol;
+            break;
+        }
+    }
+    return selected;
+};
+const spinSlots = (settings) => {
+    const combo = Array.from({ length: 3 }, () => pickWeightedSymbol(settings.symbolWeights)).join('');
+    return toNumber(settings.winMultipliers[combo] ?? 0);
+};
+const spinRoulette = () => ROULETTE_NUMBERS[Math.floor(Math.random() * ROULETTE_NUMBERS.length)];
+const simulateRound = (target, settings) => {
+    switch (target) {
+        case 'dice': {
+            const rolled = Math.floor(Math.random() * 6) + 1;
+            const guessed = Math.floor(Math.random() * 6) + 1;
+            return {
+                multiplier: rolled === guessed ? toNumber(settings.dice.winMultiplier) : 0
+            };
+        }
+        case 'coinflip': {
+            const flipped = Math.random() < 0.5 ? 'heads' : 'tails';
+            const picked = Math.random() < 0.5 ? 'heads' : 'tails';
+            return {
+                multiplier: flipped === picked ? toNumber(settings.coinflip.winMultiplier) : 0
+            };
+        }
+        case 'slots':
+            return { multiplier: spinSlots(settings.slots) };
+        case 'lottery': {
+            const picks = drawUnique(lotteryConfig_1.LOTTERY_NUM_TO_DRAW, lotteryConfig_1.LOTTERY_TOTAL_NUMBERS);
+            const drawn = drawUnique(lotteryConfig_1.LOTTERY_NUM_TO_DRAW, lotteryConfig_1.LOTTERY_TOTAL_NUMBERS);
+            const matched = picks.filter((pick) => drawn.includes(pick)).length;
+            return {
+                multiplier: toNumber(settings.lottery.winMultipliers[matched] ?? 0),
+                bucket: String(matched)
+            };
+        }
+        case 'plinko': {
+            let rights = 0;
+            for (let row = 0; row < plinkoConfig_1.PLINKO_ROW_COUNT; row++) {
+                if (Math.random() < 0.5)
+                    rights++;
+            }
+            const multipliers = (0, plinkoConfig_2.normalizePlinkoBinMultipliers)(settings.plinko.binMultipliers);
+            return {
+                multiplier: (0, plinkoConfig_2.getPlinkoMultiplierAtPathIndex)(multipliers, rights),
+                bucket: String(rights)
+            };
+        }
+        case 'goldenJackpot': {
+            const chance = Math.max(1, toNumber(settings.goldenJackpot.oneInChance));
+            const won = Math.floor(Math.random() * chance) === 0;
+            return {
+                multiplier: won ? toNumber(settings.goldenJackpot.winMultiplier) : 0
+            };
+        }
+        default: {
+            const betType = target.replace('roulette:', '');
+            const result = spinRoulette();
+            return {
+                multiplier: (0, calculateRouletteWin_1.calculateRouletteWin)(ROULETTE_REP_BETS[betType], result, settings.roulette.winMultipliers)
+            };
+        }
+    }
+};
+const getTheoreticalRtp = (target, settings) => {
+    if (target.startsWith('roulette:')) {
+        const betType = target.replace('roulette:', '');
+        const rtp = (0, calculateRTP_1.calculateRTP)('roulette', settings.roulette);
+        if (typeof rtp !== 'object')
+            return null;
+        return rtp[betType] ?? null;
+    }
+    const game = target;
+    const rtp = (0, calculateRTP_1.calculateRTP)(game, settings[game]);
+    return typeof rtp === 'number' ? rtp : null;
+};
+const targetLabel = (target) => {
+    if (target.startsWith('roulette:')) {
+        return `Roulette · ${target.replace('roulette:', '')}`;
+    }
+    const labels = {
+        dice: 'Dice',
+        coinflip: 'Coin flip',
+        slots: 'Slots',
+        lottery: 'Lottery',
+        plinko: 'Plinko',
+        goldenJackpot: 'Golden jackpot'
+    };
+    return labels[target];
+};
+async function runMonteCarloSimulation(target, settings, iterations, onProgress, chunkSize = 25000) {
+    const started = performance.now();
+    let totalMultiplier = 0;
+    const distribution = {};
+    let completed = 0;
+    while (completed < iterations) {
+        const batch = Math.min(chunkSize, iterations - completed);
+        for (let i = 0; i < batch; i++) {
+            const round = simulateRound(target, settings);
+            totalMultiplier += round.multiplier;
+            if (round.bucket) {
+                distribution[round.bucket] = (distribution[round.bucket] ?? 0) + 1;
+            }
+        }
+        completed += batch;
+        onProgress?.(completed, iterations);
+        await (0, yieldToEventLoop_1.yieldToEventLoop)();
+    }
+    const empiricalRtp = (totalMultiplier / iterations) * 100;
+    const theoreticalRtp = getTheoreticalRtp(target, settings);
+    const delta = theoreticalRtp == null ? null : empiricalRtp - theoreticalRtp;
+    return {
+        target,
+        label: targetLabel(target),
+        iterations,
+        theoreticalRtp,
+        empiricalRtp,
+        delta,
+        elapsedMs: Math.round(performance.now() - started),
+        distribution: Object.keys(distribution).length > 0 ? distribution : undefined
+    };
+}
+async function runAllMonteCarloSimulations(settings, iterations, onProgress) {
+    const results = [];
+    const total = exports.MONTE_CARLO_TARGETS.length;
+    for (let index = 0; index < exports.MONTE_CARLO_TARGETS.length; index++) {
+        const target = exports.MONTE_CARLO_TARGETS[index];
+        const result = await runMonteCarloSimulation(target, settings, iterations, (completed, targetIterations) => {
+            onProgress?.(index + completed / targetIterations, total);
+        });
+        results.push(result);
+    }
+    onProgress?.(total, total);
+    return results;
+}

package/dist/dev/devAccess.d.ts

@@ -0,0 +1,5 @@
+/** Discord guild IDs where dev tooling is enabled for all guild members. */
+export declare const DEV_GUILDS: string[];
+/** Discord user IDs allowed to use dev tooling outside dev guilds. */
+export declare const DEV_USERS: string[];
+export declare function hasDevAccess(userId: string, guildId: string | null | undefined): boolean;

package/dist/dev/devAccess.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEV_USERS = exports.DEV_GUILDS = void 0;
+exports.hasDevAccess = hasDevAccess;
+/** Discord guild IDs where dev tooling is enabled for all guild members. */
+exports.DEV_GUILDS = ['1298805664654561340'];
+/** Discord user IDs allowed to use dev tooling outside dev guilds. */
+exports.DEV_USERS = [];
+function hasDevAccess(userId, guildId) {
+    if (guildId && exports.DEV_GUILDS.includes(guildId)) {
+        return true;
+    }
+    return exports.DEV_USERS.includes(userId);
+}

package/dist/dev/index.d.ts

@@ -0,0 +1,4 @@
+export * from './devAccess';
+export * from './bonusStressTest';
+export * from './casinoMonteCarlo';
+export * from './yieldToEventLoop';

package/dist/dev/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./devAccess"), exports);
+__exportStar(require("./bonusStressTest"), exports);
+__exportStar(require("./casinoMonteCarlo"), exports);
+__exportStar(require("./yieldToEventLoop"), exports);

package/dist/dev/yieldToEventLoop.d.ts

@@ -0,0 +1 @@
+export declare const yieldToEventLoop: () => Promise<void>;

package/dist/dev/yieldToEventLoop.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yieldToEventLoop = void 0;
+const yieldToEventLoop = () => new Promise((resolve) => {
+    setTimeout(resolve, 0);
+});
+exports.yieldToEventLoop = yieldToEventLoop;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gambling-bot-shared",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "license": "MIT",
   "type": "commonjs",
   "repository": {
@@ -58,6 +58,10 @@
     "./mongoose": {
       "types": "./dist/mongoose/index.d.ts",
       "default": "./dist/mongoose/index.js"
+    },
+    "./dev": {
+      "types": "./dist/dev/index.d.ts",
+      "default": "./dist/dev/index.js"
     }
   },
   "scripts": {