function showdown() {
            // Determine winner with proper hand evaluation
            const activePlayers = gameState.activePlayers.filter(p => !p.folded);
            
            if (activePlayers.length === 1) {
                // Only one player left
                const winner = activePlayers[0];
                winner.chips += gameState.pot;
                winner.action = 'Wins!';
                
                if (winner.isUser) {
                    gameState.userStats.handsWon++;
                }
                
                showWinnerAnnouncement(winner, 'Everyone else folded', []);
            } else {
                // Multiple players - evaluate hands
                gameState.userStats.showdownsTotal++;
                
                let bestScore = -1;
                let winner = null;
                let winningHand = '';
                let allResults = [];
                
                activePlayers.forEach(player => {
                    const result = evaluatePokerHand(player.cards, gameState.communityCards);
                    allResults.push({ player, ...result });
                    
                    if (result.score > bestScore) {
                        bestScore = result.score;
                        winner = player;
                        winningHand = result.handName;
                    }
                });
                
                if (winner) {
                    winner.chips += gameState.pot;
                    winner.action = 'Wins!';
                    
                    if (winner.isUser) {
                        gameState.userStats.handsWon++;
                        gameState.userStats.showdownsWon++;
                    }
                    
                    showWinnerAnnouncement(winner, winningHand, allResults);
                }
            }
            
            updateUI();
        }

        function showWinnerAnnouncement(winner, handName, allResults) {
            // Create showdown results display
            let showdownHtml = `
                <div class="showdown-results" id="showdown-results">
                    <div class="winner-announcement">🏆 ${winner.name} Wins!</div>
                    <div class="winning-hand">${handName}</div>
                    <div style="font-size: 1.2rem; color: #ffd700; margin: 10px 0;">
                        Pot: ${gameState.pot}
                    </div>
            `;

            // Show all player hands if multiple players
            if (allResults.length > 1) {
                showdownHtml += '<div style="margin-top: 15px; font-size: 0.9rem; color: #ccc;">All Hands:</div>';
                allResults.forEach(result => {
                    const cardIcons = result.player.cards.map(card => 
                        `<span class="${card.suit === '♥' || card.suit === '♦' ? 'red' : 'black'}">${card.rank}${card.suit}</span>`
                    ).join(' ');
                    
                    showdownHtml += `
                        <div style="margin: 8px 0; padding: 8px; background: rgba(255,255,255,0.1); border-radius: 5px;">
                            <strong>${result.player.name}:</strong> ${cardIcons} - ${result.handName}
                        </div>
                    `;
                });
            } else {
                // Show winner's cards
                const cardIcons = winner.cards.map(card => 
                    `<span class="${card.suit === '♥' || card.suit === '♦' ? 'red' : 'black'}">${card.rank}${card.suit}</span>`
                ).join(' ');
                showdownHtml += `<div style="margin: 10px 0;">Winner's Hand: ${cardIcons}</div>`;
            }

            showdownHtml += '</div>';
            
            // Add to table
            document.getElementById('poker-table').insertAdjacentHTML('beforeend', showdownHtml);
            
            // Remove after 4 seconds
            setTimeout(() => {
                const resultsDiv = document.getElementById('showdown-results');
                if (resultsDiv) {
                    resultsDiv.remove();
                }
                
                // Continue game
                continueAfterShowdown();
            }, 4000);
        }

        function continueAfterShowdown() {
            // Remove eliminated players
            gameState.activePlayers = gameState.activePlayers.filter(p => p.chips > 0);
            
            // Update stats
            gameState.userStats.handsPlayed++;
            
            // Check for tournament end
            if (gameState.activePlayers.length <= 1) {
                endTournament();
            } else {
                // Increase blinds if needed
                gameState.handsUntilBlindIncrease--;
                if (gameState.handsUntilBlindIncrease <= 0) {
                    gameState.smallBlind *= 2;
                    gameState.bigBlind *= 2;
                    gameState.handsUntilBlindIncrease = 5;
                }
                
                gameState.handNumber++;
                startNewHand();
            }
        }

        function evaluatePokerHand(playerCards, communityCards) {
            const allCards = [...playerCards, ...communityCards];
            if (allCards.length < 5) {
                return { score: Math.random() * 1000, handName: 'High Card' };
            }
            
            // Count ranks and suits
            const rankCounts = {};
            const suitCounts = {};
            const ranks = [];
            
            allCards.forEach(card => {
                rankCounts[card.value] = (rankCounts[card.value] || 0) + 1;
                suitCounts[card.suit] = (suitCounts[card.suit] || 0) + 1;
                ranks.push(card.value);
            });
            
            ranks.sort((a, b) => b - a);
            const uniqueRanks = [...new Set(ranks)].sort((a, b) => b - a);
            
            // Check for flush
            const isFlush = Object.values(suitCounts).some(count => count >= 5);
            
            // Check for straight
            let isStraight = false;
            let straightHigh = 0;
            
            // Check normal straight
            for (let i = 0; i <= uniqueRanks.length - 5; i++) {
                if (uniqueRanks[i] - uniqueRanks[i + 4] === 4) {
                    isStraight = true;
                    straightHigh = uniqueRanks[i];
                    break;
                }
            }
            
            // Check wheel straight (A-2-3-4-5)
            if (!isStraight && uniqueRanks.includes(14) && uniqueRanks.includes(5) && 
                uniqueRanks.includes(4) && uniqueRanks.includes(3) && uniqueRanks.includes(2)) {
                isStraight = true;
                straightHigh = 5;
            }
            
            // Count pairs, trips, quads
            const counts = Object.values(rankCounts).sort((a, b) => b - a);
            
            // Determine hand ranking
            let score = 0;
            let handName = '';
            
            if (isStraight && isFlush) {
                if (straightHigh === 14) {
                    score = 9000 + straightHigh;
                    handName = 'Royal Flush';
                } else {
                    score = 8000 + straightHigh;
                    handName = 'Straight Flush';
                }
            } else if (counts[0] === 4) {
                score = 7000 + Math.max(...Object.keys(rankCounts).filter(k => rankCounts[k] === 4).map(Number));
                handName = 'Four of a Kind';
            } else if (counts[0] === 3 && counts[1] === 2) {
                score = 6000 + Math.max(...Object.keys(rankCounts).filter(k => rankCounts[k] === 3).map(Number));
                handName = 'Full House';
            } else if (isFlush) {
                score = 5000 + Math.max(...ranks);
                handName = 'Flush';
            } else if (isStraight) {
                score = 4000 + straightHigh;
                handName = 'Straight';
            } else if (counts[0] === 3) {
                score = 3000 + Math.max(...Object.keys(rankCounts).filter(k => rankCounts[k] === 3).map(Number));
                handName = 'Three of a Kind';
            } else if (counts[0] === 2 && counts[1] === 2) {
                const pairs = Object.keys(rankCounts).filter(k => rankCounts[k] === 2).map(Number).sort((a,b) => b-a);
                score = 2000 + pairs[0] * 20 + pairs[1];
                handName = 'Two Pair';
            } else if (counts[0] === 2) {
                score = 1000 + Math.max(...Object.keys(rankCounts).filter(k => rankCounts[k] === 2).map(Number));
                handName = 'One Pair';
            } else {
                score = Math.max(...ranks);
                handName = 'High Car<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Poker Trainer Pro</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #0f2027, #203a43, #2c5364);
            color: white;
            min-height: 100vh;
            overflow-x: hidden;
        }

        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }

        .header {
            text-align: center;
            margin-bottom: 30px;
        }

        .header h1 {
            font-size: 2.5rem;
            color: #ffd700;
            text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
            margin-bottom: 10px;
        }

        .game-info {
            display: flex;
            justify-content: space-between;
            align-items: center;
            background: rgba(0,0,0,0.3);
            padding: 15px;
            border-radius: 10px;
            margin-bottom: 20px;
            flex-wrap: wrap;
            gap: 10px;
        }

        .info-item {
            display: flex;
            flex-direction: column;
            align-items: center;
            min-width: 100px;
        }

        .info-label {
            font-size: 0.8rem;
            opacity: 0.8;
            margin-bottom: 5px;
        }

        .info-value {
            font-size: 1.2rem;
            font-weight: bold;
            color: #ffd700;
        }

        .poker-table {
            position: relative;
            width: 100%;
            max-width: 800px;
            height: 500px;
            margin: 0 auto;
            background: #0a5a3a;
            border: 8px solid #8b4513;
            border-radius: 50%;
            box-shadow: 0 0 30px rgba(0,0,0,0.5);
            overflow: visible;
        }

        .community-cards {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            display: flex;
            gap: 10px;
            z-index: 10;
        }

        .card {
            width: 50px;
            height: 70px;
            background: white;
            border-radius: 8px;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 1.2rem;
            font-weight: bold;
            box-shadow: 0 2px 8px rgba(0,0,0,0.3);
            transition: all 0.3s ease;
        }

        .card.back {
            background: linear-gradient(45deg, #1e3c72, #2a5298);
            color: white;
        }

        .card.red {
            color: #dc3545;
        }

        .card.black {
            color: #000;
        }

        .pot-info {
            position: absolute;
            top: 35%;
            left: 50%;
            transform: translateX(-50%);
            text-align: center;
            background: rgba(0,0,0,0.7);
            padding: 10px 20px;
            border-radius: 20px;
            z-index: 5;
        }

        .pot-amount {
            font-size: 1.5rem;
            font-weight: bold;
            color: #ffd700;
        }

        .player-seat {
            position: absolute;
            width: 110px;
            height: 110px;
            background: rgba(0,0,0,0.8);
            border-radius: 10px;
            padding: 8px;
            text-align: center;
            border: 2px solid transparent;
            transition: all 0.3s ease;
            z-index: 20;
        }

        .player-seat.active {
            border-color: #ffd700;
            box-shadow: 0 0 20px rgba(255, 215, 0, 0.5);
        }

        .player-seat.user {
            border-color: #28a745;
            background: rgba(40, 167, 69, 0.2);
        }

        .player-name {
            font-size: 0.9rem;
            font-weight: bold;
            margin-bottom: 5px;
            color: #ffd700;
        }

        .player-chips {
            font-size: 0.8rem;
            color: #fff;
            margin-bottom: 5px;
        }

        .player-cards {
            display: flex;
            gap: 5px;
            justify-content: center;
            margin-bottom: 5px;
        }

        .player-cards .card {
            width: 25px;
            height: 35px;
            font-size: 0.7rem;
        }

        .bet-controls {
            display: flex;
            flex-direction: column;
            gap: 10px;
            align-items: center;
            margin-top: 15px;
        }

        .bet-buttons {
            display: flex;
            gap: 8px;
            flex-wrap: wrap;
            justify-content: center;
        }

        .bet-btn {
            padding: 8px 12px;
            border: 2px solid #ffd700;
            border-radius: 5px;
            background: rgba(255, 215, 0, 0.1);
            color: #ffd700;
            font-size: 0.9rem;
            cursor: pointer;
            transition: all 0.3s ease;
        }

        .bet-btn:hover {
            background: rgba(255, 215, 0, 0.3);
        }

        .bet-slider-container {
            display: flex;
            align-items: center;
            gap: 10px;
            width: 100%;
            max-width: 400px;
        }

        .bet-slider {
            flex: 1;
            height: 6px;
            border-radius: 3px;
            background: rgba(255, 255, 255, 0.3);
            outline: none;
            -webkit-appearance: none;
        }

        .bet-slider::-webkit-slider-thumb {
            -webkit-appearance: none;
            appearance: none;
            width: 20px;
            height: 20px;
            border-radius: 50%;
            background: #ffd700;
            cursor: pointer;
        }

        .bet-slider::-moz-range-thumb {
            width: 20px;
            height: 20px;
            border-radius: 50%;
            background: #ffd700;
            cursor: pointer;
            border: none;
        }

        .bet-amount-display {
            background: rgba(0,0,0,0.7);
            padding: 8px 12px;
            border-radius: 5px;
            font-weight: bold;
            color: #ffd700;
            min-width: 80px;
            text-align: center;
        }

        .showdown-results {
            position: absolute;
            top: 60%;
            left: 50%;
            transform: translateX(-50%);
            background: rgba(0,0,0,0.9);
            padding: 20px;
            border-radius: 15px;
            border: 2px solid #ffd700;
            text-align: center;
            z-index: 100;
            min-width: 300px;
        }

        .winner-announcement {
            font-size: 1.5rem;
            font-weight: bold;
            color: #ffd700;
            margin-bottom: 15px;
        }

        .winning-hand {
            font-size: 1.1rem;
            color: #28a745;
            margin-bottom: 10px;
        }

        .showdown-cards {
            display: flex;
            justify-content: center;
            gap: 5px;
            margin: 10px 0;
        }

        .showdown-cards .card {
            width: 40px;
            height: 56px;
            font-size: 0.9rem;
        }

        .player-action {
            font-size: 0.7rem;
            color: #ffd700;
            font-weight: bold;
        }

        .dealer-button {
            position: absolute;
            width: 25px;
            height: 25px;
            background: #ffd700;
            color: #000;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            font-weight: bold;
            font-size: 0.8rem;
            z-index: 15;
        }

        .controls {
            margin-top: 30px;
            text-align: center;
        }

        .user-hand {
            display: flex;
            justify-content: center;
            gap: 15px;
            margin-bottom: 20px;
        }

        .user-hand .card {
            width: 80px;
            height: 112px;
            font-size: 1.5rem;
        }

        .action-buttons {
            display: flex;
            justify-content: center;
            gap: 10px;
            flex-wrap: wrap;
            margin-bottom: 20px;
        }

        .btn {
            padding: 12px 24px;
            border: none;
            border-radius: 8px;
            font-size: 1rem;
            font-weight: bold;
            cursor: pointer;
            transition: all 0.3s ease;
            min-width: 100px;
        }

        .btn:hover {
            transform: translateY(-2px);
            box-shadow: 0 4px 12px rgba(0,0,0,0.3);
        }

        .btn:disabled {
            opacity: 0.5;
            cursor: not-allowed;
            transform: none;
        }

        .btn-fold {
            background: #dc3545;
            color: white;
        }

        .btn-call {
            background: #28a745;
            color: white;
        }

        .btn-raise {
            background: #ffc107;
            color: #000;
        }

        .btn-allin {
            background: #fd7e14;
            color: white;
        }

        .btn-start {
            background: #17a2b8;
            color: white;
            font-size: 1.2rem;
            padding: 15px 30px;
        }

        .raise-controls {
            display: flex;
            align-items: center;
            gap: 10px;
            justify-content: center;
            margin-top: 10px;
        }

        .raise-input {
            padding: 8px;
            border: 2px solid #ffd700;
            border-radius: 5px;
            background: rgba(0,0,0,0.8);
            color: white;
            width: 120px;
            text-align: center;
        }

        .analysis-panel {
            background: rgba(0,0,0,0.8);
            padding: 30px;
            border-radius: 15px;
            margin-top: 30px;
            display: none;
        }

        .analysis-title {
            font-size: 1.8rem;
            color: #ffd700;
            margin-bottom: 20px;
            text-align: center;
        }

        .play-style {
            text-align: center;
            margin-bottom: 20px;
        }

        .style-label {
            font-size: 2rem;
            font-weight: bold;
            color: #28a745;
            margin-bottom: 10px;
        }

        .style-description {
            font-size: 1.1rem;
            opacity: 0.9;
            line-height: 1.6;
        }

        .stats-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 20px;
            margin-bottom: 20px;
        }

        .stat-item {
            background: rgba(255,255,255,0.1);
            padding: 15px;
            border-radius: 10px;
            text-align: center;
        }

        .stat-value {
            font-size: 1.5rem;
            font-weight: bold;
            color: #ffd700;
        }

        .stat-label {
            font-size: 0.9rem;
            opacity: 0.8;
        }

        .advice {
            background: rgba(40, 167, 69, 0.2);
            padding: 20px;
            border-radius: 10px;
            border-left: 4px solid #28a745;
        }

        .advice h3 {
            color: #28a745;
            margin-bottom: 10px;
        }

        .advice p {
            line-height: 1.6;
            margin-bottom: 10px;
        }

        @media (max-width: 768px) {
            .poker-table {
                height: 400px;
            }
            
            .player-seat {
                width: 100px;
                height: 100px;
                padding: 8px;
            }
            
            .community-cards .card {
                width: 40px;
                height: 56px;
                font-size: 1rem;
            }
            
            .user-hand .card {
                width: 60px;
                height: 84px;
                font-size: 1.2rem;
            }
            
            .header h1 {
                font-size: 2rem;
            }
            
            .action-buttons {
                gap: 5px;
            }
            
            .btn {
                padding: 10px 16px;
                font-size: 0.9rem;
                min-width: 80px;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>♠️ Poker Trainer Pro ♠️</h1>
            <p>Master No-Limit Texas Hold'em</p>
        </div>

        <div class="game-info">
            <div class="info-item">
                <div class="info-label">Tournament</div>
                <div class="info-value" id="tournament-status">Sit & Go</div>
            </div>
            <div class="info-item">
                <div class="info-label">Players Left</div>
                <div class="info-value" id="players-left">9</div>
            </div>
            <div class="info-item">
                <div class="info-label">Blinds</div>
                <div class="info-value" id="blinds">25/50</div>
            </div>
            <div class="info-item">
                <div class="info-label">Next Blind</div>
                <div class="info-value" id="next-blind">5 hands</div>
            </div>
            <div class="info-item">
                <div class="info-label">Hand #</div>
                <div class="info-value" id="hand-number">1</div>
            </div>
        </div>

        <div class="poker-table" id="poker-table">
            <div class="community-cards" id="community-cards">
                <!-- Community cards will be added here -->
            </div>
            
            <div class="pot-info">
                <div class="pot-amount" id="pot-amount">$0</div>
                <div>POT</div>
            </div>

            <!-- Player seats will be positioned around the table -->
            <div class="dealer-button" id="dealer-button" style="display: none;">D</div>
        </div>

        <div class="controls">
            <div class="user-hand" id="user-hand">
                <!-- User's cards will be displayed here -->
            </div>

            <div class="action-buttons" id="action-buttons" style="display: none;">
                <button class="btn btn-fold" onclick="playerAction('fold')">Fold</button>
                <button class="btn btn-call" id="call-btn" onclick="playerAction('call')">Call $0</button>
                <button class="btn btn-raise" onclick="showBetControls()">Raise</button>
                <button class="btn btn-allin" onclick="playerAction('allin')">All-In</button>
            </div>

            <div class="bet-controls" id="bet-controls" style="display: none;">
                <div class="bet-buttons">
                    <button class="bet-btn" onclick="setBetAmount('min')">Min Bet</button>
                    <button class="bet-btn" onclick="setBetAmount('quarter')">1/4 Pot</button>
                    <button class="bet-btn" onclick="setBetAmount('half')">1/2 Pot</button>
                    <button class="bet-btn" onclick="setBetAmount('pot')">Pot</button>
                </div>
                
                <div class="bet-slider-container">
                    <span style="color: #ffd700; font-size: 0.9rem;">Min</span>
                    <input type="range" class="bet-slider" id="bet-slider" oninput="updateBetAmount()">
                    <span style="color: #ffd700; font-size: 0.9rem;">All-In</span>
                </div>
                
                <div class="bet-amount-display" id="bet-amount-display">$0</div>
                
                <div style="display: flex; gap: 10px;">
                    <button class="btn btn-raise" onclick="playerAction('raise')">Raise</button>
                    <button class="btn" onclick="hideBetControls()" style="background: #6c757d; color: white;">Cancel</button>
                </div>
            </div>

            <button class="btn btn-start" id="start-btn" onclick="startTournament()">Start Tournament</button>
        </div>

        <div class="analysis-panel" id="analysis-panel">
            <div class="analysis-title">🎯 Post-Game Analysis</div>
            
            <div class="play-style">
                <div class="style-label" id="play-style-label">Tight Aggressive</div>
                <div class="style-description" id="play-style-description">
                    You played a solid, selective style with well-timed aggression.
                </div>
            </div>

            <div class="stats-grid">
                <div class="stat-item">
                    <div class="stat-value" id="vpip-stat">22%</div>
                    <div class="stat-label">VPIP (Hands Played)</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="pfr-stat">18%</div>
                    <div class="stat-label">PFR (Pre-flop Raise)</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="aggression-stat">2.1</div>
                    <div class="stat-label">Aggression Factor</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="showdown-stat">65%</div>
                    <div class="stat-label">Showdowns Won</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="position-stat">Final Position</div>
                    <div class="stat-label">Tournament Finish</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="hands-stat">0</div>
                    <div class="stat-label">Total Hands</div>
                </div>
            </div>

            <div class="advice">
                <h3>💡 Improvement Tips</h3>
                <div id="advice-content">
                    <p>Great job! Here are some ways to improve your game:</p>
                    <p>• Consider playing more hands in late position</p>
                    <p>• Work on your bet sizing for value</p>
                    <p>• Practice reading opponent tendencies</p>
                </div>
            </div>

            <div style="text-align: center; margin-top: 20px;">
                <button class="btn btn-start" onclick="restartGame()">Play Again</button>
            </div>
        </div>
    </div>

    <script>
        // Game state
        let gameState = {
            players: [],
            activePlayers: [],
            currentPlayer: 0,
            dealerPosition: 0,
            smallBlind: 25,
            bigBlind: 50,
            pot: 0,
            communityCards: [],
            currentBet: 0,
            gamePhase: 'preflop', // preflop, flop, turn, river, showdown
            handNumber: 1,
            handsUntilBlindIncrease: 5,
            userStats: {
                handsPlayed: 0,
                handsWon: 0,
                vpip: 0,
                pfr: 0,
                totalBets: 0,
                totalCalls: 0,
                showdownsWon: 0,
                showdownsTotal: 0,
                finalPosition: 0
            },
            deck: [],
            tournamentFinished: false
        };

        // Bot personalities
        const botPersonalities = [
            { name: 'Aggressive Annie', style: 'loose-aggressive', vpip: 0.4, pfr: 0.3, aggression: 3.5 },
            { name: 'Tight Tom', style: 'tight-passive', vpip: 0.15, pfr: 0.1, aggression: 1.2 },
            { name: 'Maniac Mike', style: 'loose-passive', vpip: 0.6, pfr: 0.15, aggression: 0.8 },
            { name: 'Solid Sarah', style: 'tight-aggressive', vpip: 0.22, pfr: 0.18, aggression: 2.8 },
            { name: 'Calling Carl', style: 'loose-passive', vpip: 0.5, pfr: 0.05, aggression: 0.5 },
            { name: 'Bluff Betty', style: 'tight-aggressive', vpip: 0.18, pfr: 0.25, aggression: 4.2 },
            { name: 'Rock Rick', style: 'tight-passive', vpip: 0.12, pfr: 0.08, aggression: 1.0 },
            { name: 'Wild Will', style: 'loose-aggressive', vpip: 0.55, pfr: 0.35, aggression: 3.8 }
        ];

        // Card utilities
        const suits = ['♠', '♥', '♦', '♣'];
        const ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'];
        const rankValues = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '10': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 14};

        function createDeck() {
            const deck = [];
            for (let suit of suits) {
                for (let rank of ranks) {
                    deck.push({ rank, suit, value: rankValues[rank] });
                }
            }
            return shuffleDeck(deck);
        }

        function shuffleDeck(deck) {
            for (let i = deck.length - 1; i > 0; i--) {
                const j = Math.floor(Math.random() * (i + 1));
                [deck[i], deck[j]] = [deck[j], deck[i]];
            }
            return deck;
        }

        function startTournament() {
            // Initialize players
            gameState.players = [
                { id: 0, name: 'You', chips: 1500, cards: [], isUser: true, isActive: true, currentBet: 0, action: '', position: 0 }
            ];

            // Add 8 random bots
            const shuffledBots = [...botPersonalities].sort(() => Math.random() - 0.5);
            for (let i = 0; i < 8; i++) {
                gameState.players.push({
                    id: i + 1,
                    name: shuffledBots[i].name,
                    chips: 1500,
                    cards: [],
                    isUser: false,
                    isActive: true,
                    currentBet: 0,
                    action: '',
                    personality: shuffledBots[i],
                    position: i + 1
                });
            }

            gameState.activePlayers = [...gameState.players];
            gameState.tournamentFinished = false;
            gameState.userStats = {
                handsPlayed: 0,
                handsWon: 0,
                vpip: 0,
                pfr: 0,
                totalBets: 0,
                totalCalls: 0,
                showdownsWon: 0,
                showdownsTotal: 0,
                finalPosition: 0
            };

            document.getElementById('start-btn').style.display = 'none';
            document.getElementById('analysis-panel').style.display = 'none';
            
            setupTable();
            startNewHand();
        }

        function setupTable() {
            const table = document.getElementById('poker-table');
            table.innerHTML = `
                <div class="community-cards" id="community-cards"></div>
                <div class="pot-info">
                    <div class="pot-amount" id="pot-amount">$0</div>
                    <div>POT</div>
                </div>
                <div class="dealer-button" id="dealer-button">D</div>
            `;

            // Position players around the table - better spacing
            const positions = [
                { top: '80%', left: '50%', transform: 'translateX(-50%)' }, // User (bottom center)
                { top: '65%', left: '80%', transform: 'translateX(-50%)' }, // Position 1 (bottom right)
                { top: '40%', left: '85%', transform: 'translateX(-50%)' }, // Position 2 (right)
                { top: '15%', left: '70%', transform: 'translateX(-50%)' }, // Position 3 (top right)
                { top: '5%', left: '50%', transform: 'translateX(-50%)' }, // Position 4 (top center)
                { top: '15%', left: '30%', transform: 'translateX(-50%)' }, // Position 5 (top left)
                { top: '40%', left: '15%', transform: 'translateX(-50%)' }, // Position 6 (left)
                { top: '65%', left: '20%', transform: 'translateX(-50%)' }, // Position 7 (bottom left)
                { top: '80%', left: '30%', transform: 'translateX(-50%)' }  // Position 8 (bottom left-center)
            ];

            gameState.activePlayers.forEach((player, index) => {
                const seat = document.createElement('div');
                seat.className = `player-seat ${player.isUser ? 'user' : ''}`;
                seat.id = `seat-${player.id}`;
                seat.style.top = positions[index].top;
                seat.style.left = positions[index].left;
                if (positions[index].transform) {
                    seat.style.transform = positions[index].transform;
                }

                seat.innerHTML = `
                    <div class="player-name">${player.name}</div>
                    <div class="player-chips">$${player.chips}</div>
                    <div class="player-cards" id="cards-${player.id}"></div>
                    <div class="player-action" id="action-${player.id}"></div>
                `;

                table.appendChild(seat);
            });

            updateUI();
        }

        function startNewHand() {
            if (gameState.activePlayers.length <= 1) {
                endTournament();
                return;
            }

            // Reset for new hand
            gameState.deck = createDeck();
            gameState.communityCards = [];
            gameState.pot = 0;
            gameState.currentBet = 0;
            gameState.gamePhase = 'preflop';

            // Clear player actions and cards
            gameState.activePlayers.forEach(player => {
                player.cards = [];
                player.currentBet = 0;
                player.action = '';
                player.folded = false;
            });

            // Move dealer button
            gameState.dealerPosition = (gameState.dealerPosition + 1) % gameState.activePlayers.length;
            
            // Post blinds
            postBlinds();
            
            // Deal cards
            dealCards();
            
            // Update UI
            updateUI();
            updateGameInfo();
            
            // Start betting round
            gameState.currentPlayer = (gameState.dealerPosition + 3) % gameState.activePlayers.length;
            nextAction();
        }

        function postBlinds() {
            const sbPosition = (gameState.dealerPosition + 1) % gameState.activePlayers.length;
            const bbPosition = (gameState.dealerPosition + 2) % gameState.activePlayers.length;
            
            const sbPlayer = gameState.activePlayers[sbPosition];
            const bbPlayer = gameState.activePlayers[bbPosition];
            
            // Small blind
            const sbAmount = Math.min(sbPlayer.chips, gameState.smallBlind);
            sbPlayer.chips -= sbAmount;
            sbPlayer.currentBet = sbAmount;
            gameState.pot += sbAmount;
            sbPlayer.action = `SB $${sbAmount}`;
            
            // Big blind
            const bbAmount = Math.min(bbPlayer.chips, gameState.bigBlind);
            bbPlayer.chips -= bbAmount;
            bbPlayer.currentBet = bbAmount;
            gameState.pot += bbAmount;
            gameState.currentBet = bbAmount;
            bbPlayer.action = `BB $${bbAmount}`;
        }

        function dealCards() {
            // Deal 2 cards to each player
            for (let i = 0; i < 2; i++) {
                gameState.activePlayers.forEach(player => {
                    player.cards.push(gameState.deck.pop());
                });
            }
        }

        function updateUI() {
            // Update community cards
            const communityCardsDiv = document.getElementById('community-cards');
            communityCardsDiv.innerHTML = '';
            
            for (let i = 0; i < 5; i++) {
                const card = document.createElement('div');
                card.className = 'card';
                
                if (i < gameState.communityCards.length) {
                    const cardData = gameState.communityCards[i];
                    card.textContent = cardData.rank + cardData.suit;
                    card.className += cardData.suit === '♥' || cardData.suit === '♦' ? ' red' : ' black';
                } else {
                    card.className += ' back';
                    card.textContent = '?';
                }
                
                communityCardsDiv.appendChild(card);
            }

            // Update pot
            document.getElementById('pot-amount').textContent = `$${gameState.pot}`;

            // Update player displays
            gameState.activePlayers.forEach(player => {
                const seat = document.getElementById(`seat-${player.id}`);
                if (seat) {
                    seat.querySelector('.player-chips').textContent = `${player.chips}`;
                    seat.querySelector('.player-action').textContent = player.action;
                    
                    // Update player cards
                    const cardsDiv = document.getElementById(`cards-${player.id}`);
                    cardsDiv.innerHTML = '';
                    
                    // Show card backs for all players at the table
                    if (player.cards && player.cards.length > 0 && !player.folded) {
                        for (let i = 0; i < player.cards.length; i++) {
                            const card = document.createElement('div');
                            card.className = 'card back';
                            card.textContent = '?';
                            cardsDiv.appendChild(card);
                        }
                    }
                    
                    // Highlight current player
                    seat.classList.toggle('active', gameState.activePlayers.indexOf(player) === gameState.currentPlayer);
                }
            });

            // Update user's hand display separately
            const userPlayer = gameState.activePlayers.find(p => p.isUser);
            if (userPlayer && userPlayer.cards && userPlayer.cards.length > 0 && !userPlayer.folded) {
                const userHandDiv = document.getElementById('user-hand');
                userHandDiv.innerHTML = '';
                
                userPlayer.cards.forEach(cardData => {
                    const card = document.createElement('div');
                    card.className = 'card';
                    card.textContent = cardData.rank + cardData.suit;
                    card.className += cardData.suit === '♥' || cardData.suit === '♦' ? ' red' : ' black';
                    userHandDiv.appendChild(card);
                });
            } else if (userPlayer && (userPlayer.folded || userPlayer.chips === 0)) {
                // Clear user hand if folded or eliminated
                document.getElementById('user-hand').innerHTML = '';
            }

            // Update dealer button position
            const dealerButton = document.getElementById('dealer-button');
            if (gameState.activePlayers.length > 0) {
                const dealerPlayer = gameState.activePlayers[gameState.dealerPosition];
                const dealerSeat = document.getElementById(`seat-${dealerPlayer.id}`);
                if (dealerSeat) {
                    const rect = dealerSeat.getBoundingClientRect();
                    const tableRect = document.getElementById('poker-table').getBoundingClientRect();
                    dealerButton.style.display = 'flex';
                    dealerButton.style.top = (rect.top - tableRect.top - 15) + 'px';
                    dealerButton.style.left = (rect.left - tableRect.left + rect.width - 15) + 'px';
                }
            }
        }

        function updateGameInfo() {
            document.getElementById('players-left').textContent = gameState.activePlayers.length;
            document.getElementById('blinds').textContent = `${gameState.smallBlind}/${gameState.bigBlind}`;
            document.getElementById('next-blind').textContent = `${gameState.handsUntilBlindIncrease} hands`;
            document.getElementById('hand-number').textContent = gameState.handNumber;
        }

        function nextAction() {
            if (gameState.tournamentFinished) return;

            const currentPlayer = gameState.activePlayers[gameState.currentPlayer];
            
            if (!currentPlayer || currentPlayer.folded || currentPlayer.chips === 0) {
                moveToNextPlayer();
                return;
            }

            if (currentPlayer.isUser) {
                showUserActions();
            } else {
                setTimeout(() => {
                    botAction(currentPlayer);
                }, 1000);
            }
        }

        function showUserActions() {
            const callAmount = Math.max(0, gameState.currentBet - gameState.activePlayers[gameState.currentPlayer].currentBet);
            const userChips = gameState.activePlayers[gameState.currentPlayer].chips;
            
            document.getElementById('action-buttons').style.display = 'flex';
            
            const callBtn = document.getElementById('call-btn');
            if (callAmount === 0) {
                callBtn.textContent = 'Check';
            } else {
                callBtn.textContent = `Call ${Math.min(callAmount, userChips)}`;
            }
            
            // Set up raise input
            const raiseInput = document.getElementById('raise-amount');
            const minRaise = gameState.currentBet * 2 || gameState.bigBlind;
            raiseInput.min = minRaise;
            raiseInput.max = userChips;
            raiseInput.value = minRaise;
        }

        function hideUserActions() {
            document.getElementById('action-buttons').style.display = 'none';
            document.getElementById('raise-controls').style.display = 'none';
        }

        function showRaiseControls() {
            document.getElementById('raise-controls').style.display = 'flex';
        }

        function hideRaiseControls() {
            document.getElementById('raise-controls').style.display = 'none';
        }

        function playerAction(action) {
            const player = gameState.activePlayers[gameState.currentPlayer];
            if (!player || !player.isUser) return;

            let amount = 0;
            let actionText = '';

            switch (action) {
                case 'fold':
                    player.folded = true;
                    actionText = 'Fold';
                    break;
                    
                case 'call':
                    amount = Math.max(0, gameState.currentBet - player.currentBet);
                    amount = Math.min(amount, player.chips);
                    player.chips -= amount;
                    player.currentBet += amount;
                    gameState.pot += amount;
                    actionText = amount === 0 ? 'Check' : `Call ${amount}`;
                    
                    if (amount > 0) {
                        gameState.userStats.totalCalls++;
                    }
                    break;
                    
                case 'raise':
                    const raiseAmount = parseInt(document.getElementById('raise-amount').value) || 0;
                    const callAmount = Math.max(0, gameState.currentBet - player.currentBet);
                    const totalAmount = Math.min(raiseAmount, player.chips);
                    
                    if (totalAmount <= callAmount) {
                        alert('Raise amount must be higher than the call amount');
                        return;
                    }
                    
                    player.chips -= totalAmount;
                    player.currentBet += totalAmount;
                    gameState.pot += totalAmount;
                    gameState.currentBet = player.currentBet;
                    actionText = `Raise ${totalAmount}`;
                    gameState.userStats.totalBets++;
                    break;
                    
                case 'allin':
                    amount = player.chips;
                    player.chips = 0;
                    player.currentBet += amount;
                    gameState.pot += amount;
                    if (player.currentBet > gameState.currentBet) {
                        gameState.currentBet = player.currentBet;
                    }
                    actionText = `All-In ${amount}`;
                    gameState.userStats.totalBets++;
                    break;
            }

            player.action = actionText;
            
            // Track VPIP and PFR
            if (gameState.gamePhase === 'preflop' && (action === 'call' || action === 'raise' || action === 'allin')) {
                gameState.userStats.vpip++;
                if (action === 'raise' || action === 'allin') {
                    gameState.userStats.pfr++;
                }
            }

            hideUserActions();
            updateUI();
            
            setTimeout(() => {
                moveToNextPlayer();
            }, 500);
        }

        function botAction(bot) {
            if (bot.folded || bot.chips === 0) {
                moveToNextPlayer();
                return;
            }

            const callAmount = Math.max(0, gameState.currentBet - bot.currentBet);
            const personality = bot.personality;
            
            // Simple bot decision making based on personality
            let action = 'fold';
            let amount = 0;
            
            // Calculate hand strength (simplified)
            const handStrength = evaluateHand(bot.cards, gameState.communityCards);
            const potOdds = callAmount / (gameState.pot + callAmount);
            
            // Decision based on personality and hand strength
            const random = Math.random();
            
            if (gameState.gamePhase === 'preflop') {
                if (random < personality.vpip) {
                    if (random < personality.pfr && callAmount === 0) {
                        action = 'raise';
                        amount = gameState.bigBlind * (2 + Math.random() * 2);
                    } else if (callAmount <= bot.chips * 0.1 || handStrength > 0.6) {
                        action = 'call';
                        amount = callAmount;
                    }
                }
            } else {
                // Post-flop play
                if (handStrength > 0.8 || (handStrength > 0.5 && random < personality.aggression / 5)) {
                    if (random < 0.3) {
                        action = 'raise';
                        amount = Math.min(gameState.pot * 0.5, bot.chips);
                    } else {
                        action = 'call';
                        amount = callAmount;
                    }
                } else if (handStrength > 0.3 && callAmount <= bot.chips * 0.1) {
                    action = 'call';
                    amount = callAmount;
                }
            }
            
            // Execute action
            let actionText = '';
            
            switch (action) {
                case 'fold':
                    bot.folded = true;
                    actionText = 'Fold';
                    break;
                    
                case 'call':
                    amount = Math.min(amount, bot.chips);
                    bot.chips -= amount;
                    bot.currentBet += amount;
                    gameState.pot += amount;
                    actionText = amount === 0 ? 'Check' : `Call ${amount}`;
                    break;
                    
                case 'raise':
                    amount = Math.min(amount, bot.chips);
                    const callPart = Math.max(0, gameState.currentBet - bot.currentBet);
                    const totalBet = Math.min(amount + callPart, bot.chips);
                    
                    bot.chips -= totalBet;
                    bot.currentBet += totalBet;
                    gameState.pot += totalBet;
                    gameState.currentBet = bot.currentBet;
                    actionText = `Raise ${totalBet}`;
                    break;
            }
            
            bot.action = actionText;
            updateUI();
            
            setTimeout(() => {
                moveToNextPlayer();
            }, 800);
        }

        function evaluateHand(playerCards, communityCards) {
            // Simplified hand evaluation - returns a value between 0 and 1
            if (!playerCards || playerCards.length === 0) return 0;
            
            const allCards = [...playerCards, ...communityCards];
            if (allCards.length < 2) return Math.random() * 0.3; // Pre-flop random
            
            // Check for pairs, high cards, etc. (simplified)
            const ranks = allCards.map(card => card.value).sort((a, b) => b - a);
            const suits = allCards.map(card => card.suit);
            
            // Check for pair
            const hasPair = ranks.some((rank, i) => ranks.indexOf(rank) !== i);
            
            // Check for high cards
            const highCard = Math.max(...ranks);
            
            let strength = 0;
            if (hasPair) strength += 0.4;
            if (highCard >= 11) strength += 0.2; // Jack or higher
            if (highCard >= 13) strength += 0.2; // King or higher
            
            return Math.min(strength + Math.random() * 0.2, 1);
        }

        function moveToNextPlayer() {
            // Check if betting round is complete
            const activePlayers = gameState.activePlayers.filter(p => !p.folded && p.chips > 0);
            const playersWithBets = activePlayers.filter(p => p.currentBet === gameState.currentBet || p.chips === 0);
            
            if (playersWithBets.length === activePlayers.length) {
                // Move to next phase
                nextPhase();
                return;
            }
            
            // Move to next player
            do {
                gameState.currentPlayer = (gameState.currentPlayer + 1) % gameState.activePlayers.length;
            } while (gameState.activePlayers[gameState.currentPlayer].folded || gameState.activePlayers[gameState.currentPlayer].chips === 0);
            
            nextAction();
        }

        function nextPhase() {
            // Reset current bets for next round
            gameState.activePlayers.forEach(player => {
                player.currentBet = 0;
                player.action = '';
            });
            gameState.currentBet = 0;
            
            switch (gameState.gamePhase) {
                case 'preflop':
                    gameState.gamePhase = 'flop';
                    // Deal flop (3 cards)
                    for (let i = 0; i < 3; i++) {
                        gameState.communityCards.push(gameState.deck.pop());
                    }
                    break;
                    
                case 'flop':
                    gameState.gamePhase = 'turn';
                    // Deal turn (1 card)
                    gameState.communityCards.push(gameState.deck.pop());
                    break;
                    
                case 'turn':
                    gameState.gamePhase = 'river';
                    // Deal river (1 card)
                    gameState.communityCards.push(gameState.deck.pop());
                    break;
                    
                case 'river':
                    showdown();
                    return;
            }
            
            updateUI();
            
            // Start next betting round from first active player after dealer
            gameState.currentPlayer = (gameState.dealerPosition + 1) % gameState.activePlayers.length;
            while (gameState.activePlayers[gameState.currentPlayer].folded || gameState.activePlayers[gameState.currentPlayer].chips === 0) {
                gameState.currentPlayer = (gameState.currentPlayer + 1) % gameState.activePlayers.length;
            }
            
            setTimeout(() => {
                nextAction();
            }, 1000);
        }

        function showdown() {
            // Determine winner (simplified)
            const activePlayers = gameState.activePlayers.filter(p => !p.folded);
            
            if (activePlayers.length === 1) {
                // Only one player left
                const winner = activePlayers[0];
                winner.chips += gameState.pot;
                winner.action = 'Wins!';
                
                if (winner.isUser) {
                    gameState.userStats.handsWon++;
                }
            } else {
                // Multiple players - simplified showdown
                let bestScore = -1;
                let winner = null;
                
                activePlayers.forEach(player => {
                    const score = evaluateHand(player.cards, gameState.communityCards);
                    if (score > bestScore) {
                        bestScore = score;
                        winner = player;
                    }
                });
                
                if (winner) {
                    winner.chips += gameState.pot;
                    winner.action = 'Wins!';
                    
                    if (winner.isUser) {
                        gameState.userStats.handsWon++;
                        gameState.userStats.showdownsWon++;
                    }
                    
                    gameState.userStats.showdownsTotal++;
                }
            }
            
            updateUI();
            
            // Remove eliminated players
            gameState.activePlayers = gameState.activePlayers.filter(p => p.chips > 0);
            
            // Update stats
            gameState.userStats.handsPlayed++;
            
            setTimeout(() => {
                // Check for tournament end
                if (gameState.activePlayers.length <= 1) {
                    endTournament();
                } else {
                    // Increase blinds if needed
                    gameState.handsUntilBlindIncrease--;
                    if (gameState.handsUntilBlindIncrease <= 0) {
                        gameState.smallBlind *= 2;
                        gameState.bigBlind *= 2;
                        gameState.handsUntilBlindIncrease = 5;
                    }
                    
                    gameState.handNumber++;
                    startNewHand();
                }
            }, 3000);
        }

        function endTournament() {
            gameState.tournamentFinished = true;
            hideUserActions();
            
            // Determine final position
            if (gameState.activePlayers.length === 1 && gameState.activePlayers[0].isUser) {
                gameState.userStats.finalPosition = 1;
            } else {
                gameState.userStats.finalPosition = gameState.activePlayers.length + 1;
            }
            
            // Show analysis
            setTimeout(() => {
                showAnalysis();
            }, 2000);
        }

        function showAnalysis() {
            const stats = gameState.userStats;
            
            // Calculate percentages
            const vpipPercent = stats.handsPlayed > 0 ? Math.round((stats.vpip / stats.handsPlayed) * 100) : 0;
            const pfrPercent = stats.handsPlayed > 0 ? Math.round((stats.pfr / stats.handsPlayed) * 100) : 0;
            const aggressionFactor = stats.totalCalls > 0 ? (stats.totalBets / stats.totalCalls).toFixed(1) : '0.0';
            const showdownWinRate = stats.showdownsTotal > 0 ? Math.round((stats.showdownsWon / stats.showdownsTotal) * 100) : 0;
            
            // Determine play style
            let playStyle = 'Beginner';
            let styleDescription = 'Keep practicing to develop your poker skills!';
            let advice = ['• Play more hands to gain experience', '• Study basic poker strategy', '• Pay attention to position'];
            
            if (vpipPercent >= 15 && vpipPercent <= 25 && pfrPercent >= 12) {
                if (parseFloat(aggressionFactor) >= 2.0) {
                    playStyle = 'Tight Aggressive';
                    styleDescription = 'Excellent! You play a solid, selective style with well-timed aggression.';
                    advice = ['• Continue this balanced approach', '• Work on reading opponents better', '• Consider position more in marginal spots'];
                } else {
                    playStyle = 'Tight Passive';
                    styleDescription = 'You play tight but could be more aggressive with strong hands.';
                    advice = ['• Bet more for value with good hands', '• Don\'t be afraid to raise', '• Use aggression to win more pots'];
                }
            } else if (vpipPercent > 25) {
                if (parseFloat(aggressionFactor) >= 2.0) {
                    playStyle = 'Loose Aggressive';
                    styleDescription = 'You play many hands with aggression - be careful not to overdo it.';
                    advice = ['• Tighten up your starting hand selection', '• Focus on position play', '• Don\'t bluff too often'];
                } else {
                    playStyle = 'Calling Station';
                    styleDescription = 'You play too many hands and call too often. Focus on hand selection.';
                    advice = ['• Play fewer hands pre-flop', '• Be more selective with calls', '• Increase aggression with strong hands'];
                }
            } else if (vpipPercent < 15) {
                playStyle = 'Rock';
                styleDescription = 'You play very tight - consider playing a few more hands.';
                advice = ['• Play more hands in good position', '• Don\'t fold too much to small bets', '• Mix up your play occasionally'];
            }
            
            // Special case for winners
            if (stats.finalPosition === 1) {
                playStyle = 'Tournament Winner! 🏆';
                styleDescription = 'Congratulations! You outlasted all opponents and won the tournament!';
                advice = ['• Great job! You showed excellent skills', '• Try to replicate this performance', '• Continue studying advanced strategy'];
            }
            
            // Update analysis display
            document.getElementById('play-style-label').textContent = playStyle;
            document.getElementById('play-style-description').textContent = styleDescription;
            
            document.getElementById('vpip-stat').textContent = vpipPercent + '%';
            document.getElementById('pfr-stat').textContent = pfrPercent + '%';
            document.getElementById('aggression-stat').textContent = aggressionFactor;
            document.getElementById('showdown-stat').textContent = showdownWinRate + '%';
            document.getElementById('position-stat').textContent = getPositionText(stats.finalPosition);
            document.getElementById('hands-stat').textContent = stats.handsPlayed;
            
            const adviceHtml = advice.map(tip => `<p>${tip}</p>`).join('');
            document.getElementById('advice-content').innerHTML = `
                <p>Here are some ways to improve your game:</p>
                ${adviceHtml}
            `;
            
            document.getElementById('analysis-panel').style.display = 'block';
        }

        function getPositionText(position) {
            const positions = ['1st Place 🥇', '2nd Place 🥈', '3rd Place 🥉'];
            return positions[position - 1] || `${position}th Place`;
        }

        function restartGame() {
            // Reset all game state
            gameState = {
                players: [],
                activePlayers: [],
                currentPlayer: 0,
                dealerPosition: 0,
                smallBlind: 25,
                bigBlind: 50,
                pot: 0,
                communityCards: [],
                currentBet: 0,
                gamePhase: 'preflop',
                handNumber: 1,
                handsUntilBlindIncrease: 5,
                userStats: {
                    handsPlayed: 0,
                    handsWon: 0,
                    vpip: 0,
                    pfr: 0,
                    totalBets: 0,
                    totalCalls: 0,
                    showdownsWon: 0,
                    showdownsTotal: 0,
                    finalPosition: 0
                },
                deck: [],
                tournamentFinished: false
            };
            
            document.getElementById('analysis-panel').style.display = 'none';
            document.getElementById('start-btn').style.display = 'inline-block';
            document.getElementById('user-hand').innerHTML = '';
            document.getElementById('poker-table').innerHTML = `
                <div class="community-cards" id="community-cards"></div>
                <div class="pot-info">
                    <div class="pot-amount" id="pot-amount">$0</div>
                    <div>POT</div>
                </div>
                <div class="dealer-button" id="dealer-button" style="display: none;">D</div>
            `;
            
            updateGameInfo();
        }
    </script>
</body>
</html>