/* global React, ReactDOM */ const { useState, useEffect, useRef, useCallback } = React; // ============================================================================= // Constants // ============================================================================= const GAME_UUID = 'mines_965'; const GRID_SIZES = [25, 36, 49, 64]; const DEFAULT_GRID_SIZE = 25; const MIN_MINES = 1; const DEFAULT_MINES = 3; const MIN_BET_DEFAULT = 1; const MAX_BET_DEFAULT = 100; function fmt(n) { return '$' + Number(n).toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 }); } function gridCols(totalTiles) { return Math.round(Math.sqrt(totalTiles)); } function maxMines(totalTiles) { return totalTiles - 1; } // ============================================================================= // Audio // ============================================================================= class AudioEngine { constructor() { this.ctx = null; this.enabled = true; } getCtx() { if (!this.ctx) this.ctx = new (window.AudioContext || window.webkitAudioContext)(); return this.ctx; } toggle() { this.enabled = !this.enabled; return this.enabled; } play(freq, dur, type = 'sine', vol = 0.15) { if (!this.enabled) return; try { const ctx = this.getCtx(); const osc = ctx.createOscillator(); const gain = ctx.createGain(); osc.type = type; osc.frequency.value = freq; gain.gain.setValueAtTime(vol, ctx.currentTime); gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + dur); osc.connect(gain); gain.connect(ctx.destination); osc.start(); osc.stop(ctx.currentTime + dur); } catch (e) {} } sndBet() { this.play(250, 0.12, 'sine', 0.08); } sndReveal() { this.play(600, 0.08, 'triangle', 0.1); setTimeout(() => this.play(800, 0.1, 'triangle', 0.08), 50); } sndMine() { if (!this.enabled) return; try { const ctx = this.getCtx(); const now = ctx.currentTime; const noiseLen = 0.4; const buf = ctx.createBuffer(1, ctx.sampleRate * noiseLen, ctx.sampleRate); const d = buf.getChannelData(0); for (let i = 0; i < d.length; i++) d[i] = (Math.random() * 2 - 1) * Math.pow(1 - i / d.length, 3); const noise = ctx.createBufferSource(); noise.buffer = buf; const ng = ctx.createGain(); ng.gain.setValueAtTime(0.35, now); ng.gain.exponentialRampToValueAtTime(0.001, now + noiseLen); const nf = ctx.createBiquadFilter(); nf.type = 'lowpass'; nf.frequency.setValueAtTime(3000, now); nf.frequency.exponentialRampToValueAtTime(200, now + noiseLen); noise.connect(nf); nf.connect(ng); ng.connect(ctx.destination); noise.start(now); const rumble = ctx.createOscillator(); rumble.type = 'sine'; rumble.frequency.setValueAtTime(60, now); rumble.frequency.exponentialRampToValueAtTime(20, now + 0.5); const rg = ctx.createGain(); rg.gain.setValueAtTime(0.3, now); rg.gain.exponentialRampToValueAtTime(0.001, now + 0.5); rumble.connect(rg); rg.connect(ctx.destination); rumble.start(now); rumble.stop(now + 0.5); const hit = ctx.createOscillator(); hit.type = 'sawtooth'; hit.frequency.setValueAtTime(200, now); hit.frequency.exponentialRampToValueAtTime(30, now + 0.15); const hg = ctx.createGain(); hg.gain.setValueAtTime(0.25, now); hg.gain.exponentialRampToValueAtTime(0.001, now + 0.15); hit.connect(hg); hg.connect(ctx.destination); hit.start(now); hit.stop(now + 0.15); } catch (e) {} } sndCashout() { this.play(500, 0.1, 'sine', 0.1); setTimeout(() => this.play(700, 0.1, 'sine', 0.1), 60); setTimeout(() => this.play(900, 0.15, 'sine', 0.12), 120); } sndBigWin() { this.play(660, 0.15, 'sine', 0.15); setTimeout(() => this.play(880, 0.15, 'sine', 0.15), 80); setTimeout(() => this.play(1100, 0.2, 'sine', 0.15), 160); setTimeout(() => this.play(1320, 0.2, 'sine', 0.15), 240); setTimeout(() => this.play(1540, 0.4, 'sine', 0.18), 320); } } // ============================================================================= // RGS Client // ============================================================================= const API_BASE = (typeof window !== 'undefined' && window.RGS_API_BASE != null) ? window.RGS_API_BASE : ''; // Session token comes from the URL only. The frontend never creates its own // demo session — a demo is started out-of-band via /api/v1/init-demo. let TOKEN = new URLSearchParams(window.location.search).get('token') || null; async function rgsFetch(path, opts = {}) { const headers = {}; if (TOKEN) headers['Authorization'] = 'Bearer ' + TOKEN; if (opts.body !== undefined) headers['Content-Type'] = 'application/json'; const r = await fetch(API_BASE + path, { method: opts.method || 'GET', headers, body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined, }); const data = await r.json().catch(() => ({})); if (data && data.error_code) { const err = new Error(data.error_description || data.error_code); err.errorCode = data.error_code; throw err; } if (!r.ok) throw new Error('HTTP ' + r.status); return data; } const getState = () => rgsFetch('/api/v1/state'); const placeBet = (amount, grid_size, mine_count) => rgsFetch('/api/v1/bet', { method: 'POST', body: { amount: Number(amount).toFixed(2), grid_size, mine_count } }); const revealTileRPC = (roundId, tile) => rgsFetch(`/api/v1/round/${roundId}/action`, { method: 'POST', body: { tile } }); const cashoutRound = (roundId) => rgsFetch(`/api/v1/round/${roundId}/cashout`, { method: 'POST', body: {} }); // ============================================================================= // SVG Components // ============================================================================= function GemSVG({ className }) { return ( ); } // ============================================================================= // GameInfoModal // ============================================================================= function GameInfoModal({ open, onClose, minBet, maxBet, rtp, mineCount, totalTiles }) { const rtpPct = (parseFloat(rtp) * 100).toFixed(1); const houseEdgePct = ((1 - parseFloat(rtp)) * 100).toFixed(1); const cols = gridCols(totalTiles); return (
{ if (e.target === e.currentTarget) onClose(); }}>

Game Info

Bet Range ${minBet.toFixed(2)} — ${maxBet.toFixed(2)}
Grid Size {cols} x {cols} ({totalTiles} tiles)
RTP {rtpPct}%
{'\uD83D\uDCA3'}

Mines is a grid-based game where you reveal tiles to find gems while avoiding hidden mines. Each gem increases your multiplier — cash out anytime or keep pushing for bigger wins!

How to Play

  1. Set grid & mines — choose grid size and how many mines to hide.
  2. Place your bet — enter the amount you want to wager.
  3. Click tiles — each safe tile reveals a gem and increases your multiplier.
  4. Cash out — lock in your winnings at any time.
  5. Hit a mine — you lose your entire bet.

House Edge & RTP

{'\uD83D\uDCCA'}

RTP: {rtpPct}% — House edge is {houseEdgePct}%. More mines = higher risk = higher multipliers. Every outcome is provably fair — tap Fair Play to verify.

); } // ============================================================================= // ProvablyFairModal // ============================================================================= function ProvablyFairModal({ open, onClose, seedHash }) { const [activeTab, setActiveTab] = useState('seeds'); const [clientSeed, setClientSeed] = useState(() => 'mines_' + Math.random().toString(36).slice(2, 10)); const [copied, setCopied] = useState(null); const hash = seedHash || 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'; const handleCopy = (text, label) => { if (navigator.clipboard) navigator.clipboard.writeText(text); setCopied(label); setTimeout(() => setCopied(null), 1500); }; return (
{ if (e.target === e.currentTarget) onClose(); }}>

Provably Fair

This game uses Provably Fair technology to generate mine placements. You can verify that every outcome is fair and unmanipulated.

{activeTab === 'seeds' && (
{'\uD83D\uDDA5'} Client Seed
Generated on your side — you control this
setClientSeed(e.target.value)} />
{'\uD83D\uDD12'} Server Seed SHA256
Committed before you bet — revealed after
{hash}

This hash is committed before you bet. After the game, the server seed is revealed so you can verify SHA256(seed) matches.

)} {activeTab === 'verify' && (
How Mines Provably Fair Works
  1. Server generates a secret seed and shows you its SHA256 hash
  2. You set your client seed (your influence on the randomness)
  3. You place a bet and select mine count
  4. Mine positions: HMAC-SHA256(server_seed, client_seed:nonce) mapped to grid positions
  5. You reveal tiles — each safe tile multiplies your winnings
  6. Cash out anytime to lock in winnings
  7. Server reveals the seed — verify SHA256 matches the pre-committed hash
)}
); } // ============================================================================= // NoSessionScreen — shown when opened without a session token. // ============================================================================= function NoSessionScreen() { return (

No active session

Open this game through your casino.

); } // ============================================================================= // MinesApp // ============================================================================= function MinesApp() { // Server state const [connected, setConnected] = useState(false); const [noSession, setNoSession] = useState(false); const [balance, setBalance] = useState(0); const [currency, setCurrency] = useState('USD'); const [minBet, setMinBet] = useState(MIN_BET_DEFAULT); const [maxBet, setMaxBet] = useState(MAX_BET_DEFAULT); const [rtp, setRtp] = useState(0.965); const [seedHash, setSeedHash] = useState(''); // Bet config const [betStr, setBetStr] = useState('10.00'); const [gridSize, setGridSize] = useState(DEFAULT_GRID_SIZE); const [mineCount, setMineCount] = useState(DEFAULT_MINES); // Round state const [roundId, setRoundId] = useState(null); const [tiles, setTiles] = useState(() => Array(DEFAULT_GRID_SIZE).fill('hidden')); const [revealedCount, setRevealedCount] = useState(0); const [currentMult, setCurrentMult] = useState(null); const [nextMult, setNextMult] = useState(null); const [currentPayout, setCurrentPayout] = useState(null); const [betAmount, setBetAmount] = useState(0); const [inFlight, setInFlight] = useState(false); const [lastResult, setLastResult] = useState(null); const [boom, setBoom] = useState(false); // Free rounds const [freeGrant, setFreeGrant] = useState(null); const isFreeMode = freeGrant != null; // Free bet summary const [freeBetSummary, setFreeBetSummary] = useState(null); const [freeBetTracker, setFreeBetTracker] = useState(null); const freeBetTrackerRef = useRef(null); // UI const [soundOn, setSoundOn] = useState(true); const [alert, setAlert] = useState(null); const [gameInfoOpen, setGameInfoOpen] = useState(false); const [pfModalOpen, setPfModalOpen] = useState(false); const [freeWelcome, setFreeWelcome] = useState(false); const [faved, setFaved] = useState(localStorage.getItem('fav_mines') === 'true'); const audioRef = useRef(null); const balRef = useRef(0); // Keep ref in sync with tracker state useEffect(() => { freeBetTrackerRef.current = freeBetTracker; }, [freeBetTracker]); useEffect(() => { audioRef.current = new AudioEngine(); }, []); useEffect(() => { balRef.current = balance; }, [balance]); const totalTiles = gridSize; const cols = gridCols(totalTiles); const maxM = maxMines(totalTiles); const gemsTotal = totalTiles - mineCount; const phase = roundId ? 'playing' : (lastResult ? 'result' : 'idle'); const profit = currentPayout != null ? currentPayout : 0; const showAlertMsg = useCallback((msg) => { setAlert(msg); setTimeout(() => setAlert(null), 2500); }, []); // Fetch free rounds grants const fetchFreeRounds = useCallback(async () => { // Preview mode: ?demo-free in URL shows mock free bet UI if (window.location.search.indexOf('demo-free') !== -1) { setFreeGrant(function (prev) { if (prev && prev._mock) { var left = prev.rounds_left - 1; if (left <= 0) { // Free bets exhausted — show summary if tracker has data var tracker = freeBetTrackerRef.current; if (tracker && tracker.rounds > 0) { setFreeBetSummary({ totalWinnings: tracker.totalWinnings, totalBet: tracker.totalBet, rounds: tracker.rounds }); setFreeBetTracker(null); } return null; } return Object.assign({}, prev, { rounds_left: left, rounds_used: prev.rounds_total - left }); } // First time — initialize tracker and show welcome var active = { _mock: true, id: 'mock', game_uuid: GAME_UUID, bet_amount: '5.00', rounds_total: 5, rounds_used: 0, rounds_left: 5, status: 'active' }; if (!prev && active) { setFreeWelcome(true); } setFreeBetTracker({ totalWinnings: 0, totalBet: 0, rounds: 0 }); return active; }); return; } try { const data = await rgsFetch('/api/v1/freerounds'); const grants = (data && data.grants) || []; const active = grants.find(function (g) { return g.status === 'active' && g.rounds_left > 0 && g.game_uuid === GAME_UUID; }); if (!active) { // No more grants — show summary if tracker has data var tracker = freeBetTrackerRef.current; if (tracker && tracker.rounds > 0) { setFreeBetSummary({ totalWinnings: tracker.totalWinnings, totalBet: tracker.totalBet, rounds: tracker.rounds }); setFreeBetTracker(null); } } setFreeGrant(function (prev) { if (!prev && active) { // First grant appearing — initialize tracker and show welcome setFreeBetTracker({ totalWinnings: 0, totalBet: 0, rounds: 0 }); setFreeWelcome(true); } return active || null; }); } catch (e) { // Silently ignore — demo sessions return empty or error var tracker = freeBetTrackerRef.current; if (tracker && tracker.rounds > 0) { setFreeBetSummary({ totalWinnings: tracker.totalWinnings, totalBet: tracker.totalBet, rounds: tracker.rounds }); setFreeBetTracker(null); } setFreeGrant(null); } }, []); // Grid size change (only when not playing) const handleGridSize = useCallback((size) => { if (roundId) return; setGridSize(size); setTiles(Array(size).fill('hidden')); setMineCount(prev => Math.min(prev, size - 1)); }, [roundId]); const getBet = useCallback(() => { const b = parseFloat(betStr); if (isNaN(b) || b < minBet) return minBet; if (b > maxBet) return maxBet; return Math.floor(b * 100) / 100; }, [betStr, minBet, maxBet]); // Boot: require a session token from the URL, then load state. useEffect(() => { let cancelled = false; if (!TOKEN) { setNoSession(true); return; } (async () => { try { const state = await getState(); if (cancelled) return; setBalance(parseFloat(state.balance)); balRef.current = parseFloat(state.balance); setCurrency(state.currency); if (state.config) { if (state.config.min_bet) setMinBet(parseFloat(state.config.min_bet)); if (state.config.max_bet) setMaxBet(parseFloat(state.config.max_bet)); if (state.config.rtp) setRtp(parseFloat(state.config.rtp)); } if (state.next_seed_hash) setSeedHash(state.next_seed_hash); setConnected(true); fetchFreeRounds(); } catch (e) { if (!cancelled) showAlertMsg('Connect failed: ' + e.message); } })(); return () => { cancelled = true; }; }, [showAlertMsg, fetchFreeRounds]); // Start game const startGame = useCallback(async () => { if (!connected) { showAlertMsg('Not connected'); return; } const amt = getBet(); if (!isFreeMode && amt > balRef.current) { showAlertMsg('Insufficient balance'); return; } if (mineCount < 1 || mineCount >= gridSize) { showAlertMsg('Invalid mine count'); return; } setInFlight(true); let resp; try { resp = await placeBet(amt, gridSize, mineCount); } catch (e) { setInFlight(false); showAlertMsg(e.message || 'Bet failed'); return; } setInFlight(false); if (audioRef.current) audioRef.current.sndBet(); setBalance(parseFloat(resp.balance)); balRef.current = parseFloat(resp.balance); if (resp.next_seed_hash) setSeedHash(resp.next_seed_hash); setRoundId(resp.round_id); setBetAmount(isFreeMode ? parseFloat(freeGrant.bet_amount) : amt); setTiles(Array(gridSize).fill('hidden')); setRevealedCount(0); setCurrentMult(null); setCurrentPayout(null); setLastResult(null); const gd = resp.game_data || {}; setNextMult(gd.next_multiplier || null); }, [connected, getBet, mineCount, gridSize, showAlertMsg, isFreeMode, freeGrant]); // Reveal tile const pickTile = useCallback(async (index) => { if (!roundId || inFlight) return; if (tiles[index] !== 'hidden') return; setInFlight(true); let resp; try { resp = await revealTileRPC(roundId, index); } catch (e) { setInFlight(false); showAlertMsg(e.message || 'Reveal failed'); return; } setInFlight(false); const gd = resp.game_data || {}; const outcome = gd.outcome; if (outcome === 'mine') { // Boom if (audioRef.current) audioRef.current.sndMine(); setBoom(true); setTimeout(() => setBoom(false), 600); const mines = new Set(gd.mines_revealed || []); setTiles(prev => prev.map((s, i) => { if (i === index) return 'mine'; if (mines.has(i)) return 'mine-other'; if (s === 'revealed') return 'revealed'; return 'safe'; })); setLastResult('lose'); setRoundId(null); if (resp.balance != null) { const nb = parseFloat(resp.balance); if (isFinite(nb)) { setBalance(nb); balRef.current = nb; } } if (resp.next_seed_hash) setSeedHash(resp.next_seed_hash); // Track free bet loss if (freeBetTrackerRef.current) { var updated = { totalWinnings: freeBetTrackerRef.current.totalWinnings, totalBet: freeBetTrackerRef.current.totalBet + betAmount, rounds: freeBetTrackerRef.current.rounds + 1 }; freeBetTrackerRef.current = updated; setFreeBetTracker(updated); fetchFreeRounds(); } return; } // Safe tile if (audioRef.current) audioRef.current.sndReveal(); const newRevealed = revealedCount + 1; setRevealedCount(newRevealed); setTiles(prev => { const n = [...prev]; n[index] = 'revealed'; return n; }); if (resp.finished) { // All gems found — auto cashout const payout = parseFloat(resp.total_payout || gd.payout || 0); if (resp.balance != null) { const nb = parseFloat(resp.balance); if (isFinite(nb)) { setBalance(nb); balRef.current = nb; } } if (resp.next_seed_hash) setSeedHash(resp.next_seed_hash); if (audioRef.current) { audioRef.current.sndCashout(); setTimeout(() => audioRef.current.sndBigWin(), 200); } const mines = new Set(gd.mines_revealed || []); setTiles(prev => prev.map((s, i) => mines.has(i) ? 'mine-other' : (s === 'revealed' ? 'revealed' : 'safe'))); setCurrentPayout(payout); setCurrentMult(gd.multiplier || gd.current_multiplier); setLastResult('win'); setRoundId(null); // Track free bet auto-cashout win if (freeBetTrackerRef.current) { var updated = { totalWinnings: freeBetTrackerRef.current.totalWinnings + payout, totalBet: freeBetTrackerRef.current.totalBet + betAmount, rounds: freeBetTrackerRef.current.rounds + 1 }; freeBetTrackerRef.current = updated; setFreeBetTracker(updated); fetchFreeRounds(); } return; } setCurrentMult(gd.current_multiplier || null); setCurrentPayout(gd.current_payout ? parseFloat(gd.current_payout) : null); setNextMult(gd.next_multiplier || null); if (gd.current_multiplier >= 10 && audioRef.current) audioRef.current.sndBigWin(); }, [roundId, inFlight, tiles, revealedCount, showAlertMsg, betAmount, fetchFreeRounds]); // Cashout const cashout = useCallback(async () => { if (!roundId || inFlight || revealedCount === 0) return; setInFlight(true); let resp; try { resp = await cashoutRound(roundId); } catch (e) { setInFlight(false); showAlertMsg(e.message || 'Cashout failed'); return; } setInFlight(false); const gd = resp.game_data || {}; const payout = parseFloat(resp.total_payout || gd.payout || 0); if (resp.balance != null) { const nb = parseFloat(resp.balance); if (isFinite(nb)) { setBalance(nb); balRef.current = nb; } } if (resp.next_seed_hash) setSeedHash(resp.next_seed_hash); if (audioRef.current) audioRef.current.sndCashout(); const mines = new Set(gd.mines_revealed || []); setTiles(prev => prev.map((s, i) => mines.has(i) ? 'mine-other' : (s === 'revealed' ? 'revealed' : 'safe'))); setCurrentPayout(payout); setCurrentMult(gd.multiplier || gd.current_multiplier); setLastResult('win'); setRoundId(null); // Track free bet cashout win if (freeBetTrackerRef.current) { var updated = { totalWinnings: freeBetTrackerRef.current.totalWinnings + payout, totalBet: freeBetTrackerRef.current.totalBet + betAmount, rounds: freeBetTrackerRef.current.rounds + 1 }; freeBetTrackerRef.current = updated; setFreeBetTracker(updated); fetchFreeRounds(); } }, [roundId, inFlight, revealedCount, showAlertMsg, betAmount, fetchFreeRounds]); // New game (reset to idle) const newGame = useCallback(() => { setLastResult(null); setTiles(Array(gridSize).fill('hidden')); setRevealedCount(0); setBetAmount(0); setCurrentMult(null); setCurrentPayout(null); setNextMult(null); }, [gridSize]); // Tile rendering const getTileClass = (state) => { if (state === 'revealed') return 'tile tile-revealed'; if (state === 'safe') return 'tile tile-revealed'; if (state === 'mine') return 'tile tile-mine'; if (state === 'mine-other') return 'tile tile-mine-other'; return 'tile'; }; const getTileContent = (state) => { if (state === 'safe') return ; if (state === 'revealed') return ; if (state === 'mine') return {'\uD83D\uDCA3'}; if (state === 'mine-other') return {'\uD83D\uDCA3'}; return null; }; // Slider background const sliderPct = maxM > MIN_MINES ? ((mineCount - MIN_MINES) / (maxM - MIN_MINES)) * 100 : 0; const sliderBg = `linear-gradient(to right, var(--accent) 0%, var(--accent) ${sliderPct}%, var(--red) ${sliderPct}%, var(--red) 100%)`; if (noSession) return ; return (
{/* HEADER */}
Mines
{'\uD83D\uDCB0'} {fmt(balance)}
setPfModalOpen(true)}>Fair Play
setGameInfoOpen(true)}>i
{/* MAIN BODY: sidebar + grid */}
{/* LEFT SIDEBAR */} {/* RIGHT SIDE — grid */}
{tiles.map((state, i) => ( ))}
{/* Result badge */}
{lastResult === 'win' ? `CASHED OUT ${currentPayout != null ? fmt(currentPayout) : ''}` : lastResult === 'lose' ? 'BOOM!' : '\u00A0'}
{/* FOOTER */}
{ const on = audioRef.current ? audioRef.current.toggle() : true; setSoundOn(on); }}>
{ const next = !faved; setFaved(next); localStorage.setItem('fav_mines', next); }}>
MYBC
{alert && !gameInfoOpen && !pfModalOpen && (
{'\u26A0'} {alert}
)} setGameInfoOpen(false)} minBet={minBet} maxBet={maxBet} rtp={rtp} mineCount={mineCount} totalTiles={totalTiles} /> setPfModalOpen(false)} seedHash={seedHash} /> {freeWelcome && freeGrant && (
setFreeWelcome(false)}>
e.stopPropagation()}>
{'\uD83C\uDF81'}

Free Rounds Available!

You have been awarded free rounds for this game. The bet amount is fixed at {fmt(parseFloat(freeGrant.bet_amount))} per round.

{freeGrant.rounds_total} Free Rounds
)} {freeBetSummary && (
setFreeBetSummary(null)}>
e.stopPropagation()}>
{'\uD83C\uDF81'}

Free Rounds Complete!

Rounds Played {freeBetSummary.rounds}
Total Won {fmt(freeBetSummary.totalWinnings)}
)} ); } ReactDOM.createRoot(document.getElementById('root')).render();