```
<!DOCTYPE html>
<html>
<head>
    <title>Card Bluff & Shoot</title>
    <style>
        body {
            margin: 0;
            padding: 20px;
            background: #1a1a1a;
            color: white;
            font-family: Arial, sans-serif;
        }

        .game-container {
            width: 100%;
            height: 100vh;
            display: grid;
            grid-template-rows: 1fr 2fr 1fr;
        }

        .top-players {
            display: flex;
            justify-content: space-around;
            align-items: center;
        }

        .middle-section {
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            gap: 20px;
        }

        .bottom-section {
            display: flex;
            flex-direction: column;
            align-items: center;
        }

        .player {
            background: #333;
            padding: 10px;
            border-radius: 8px;
            text-align: center;
        }

        .player.active {
            background: #4CAF50;
        }

        .player.eliminated {
            background: #f44336;
            opacity: 0.5;
        }

        .player-hand {
            display: flex;
            gap: 10px;
            margin-bottom: 20px;
        }

        .card {
            width: 60px;
            height: 90px;
            background: white;
            border-radius: 5px;
            display: flex;
            justify-content: center;
            align-items: center;
            color: black;
            cursor: pointer;
            user-select: none;
        }

        .card.selected {
            border: 2px solid yellow;
        }

        .actions {
            display: flex;
            gap: 10px;
        }

        button {
            padding: 10px 20px;
            border: none;
            border-radius: 5px;
            cursor: pointer;
            background: #4CAF50;
            color: white;
        }

        button:hover {
            opacity: 0.9;
        }

        button:disabled {
            opacity: 0.5;
            cursor: not-allowed;
        }

        .bullets {
            margin-top: 5px;
            font-size: 12px;
        }

        .game-info {
            text-align: center;
            font-size: 1.2em;
            color: #ddd;
        }

        .overlay {
            position: fixed;
            top: 0;
            left: 0;
            right: 0;
            bottom: 0;
            background: rgba(0,0,0,0.9);
            display: none;
            justify-content: center;
            align-items: center;
            flex-direction: column;
            gap: 20px;
        }

        .overlay.active {
            display: flex;
        }

        #debugControls {
            position: fixed;
            bottom: 10px;
            right: 10px;
            background: #333;
            padding: 10px;
            border-radius: 5px;
        }
    </style>
</head>
<body>
    <div class="game-container">
        <div class="top-players" id="players"></div>
        
        <div class="middle-section">
            <div class="game-info">
                Core Card: <span id="coreCard"></span>
            </div>
            <div class="game-info">
                Last Played: <span id="lastPlayed"></span>
            </div>
        </div>

        <div class="bottom-section">
            <div class="player-hand" id="currentHand"></div>
            <div class="actions">
                <button onclick="game.playSelectedCards()">Play Selected Cards</button>
                <button onclick="game.callBluff()" style="background: #f44336">Call Bluff</button>
            </div>
        </div>
    </div>

    <div class="overlay" id="shootingOverlay">
        <h2>🎲 Russian Roulette Time! 🔫</h2>
        <button onclick="game.pullTrigger()">Pull Trigger</button>
    </div>

    <div id="debugControls">
        <button onclick="bug.toggleAutoPlay()">Toggle AutoPlay</button>
        <button onclick="game.startNewGame()">New Game</button>
    </div>

    <script>
        class Card {
            constructor(value, suit) {
                this.value = value;
                this.suit = suit;
            }

            toString() {
                return `${this.value}${this.suit}`;
            }
        }

        class Player {
            constructor(id, name) {
                this.id = id;
                this.name = name;
                this.hand = [];
                this.bulletSlots = 6;
                this.isEliminated = false;
            }
        }

        class Game {
            constructor() {
                this.players = [];
                this.currentPlayerIndex = 0;
                this.coreCard = null;
                this.lastPlayedCards = [];
                this.deck = [];
                this.shootingPlayer = null;
                this.isGameOver = false;
                this.initialize();
            }

            initialize() {
                // Create deck
                const values = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'];
                const suits = ['♠', '♥', '♦', '♣'];
                this.deck = [];
                for (let value of values) {
                    for (let suit of suits) {
                        this.deck.push(new Card(value, suit));
                    }
                }

                // Create players
                for (let i = 0; i < 3; i++) {
                    this.players.push(new Player(i, `Player ${i + 1}`));
                }
            }

            startNewGame() {
                this.initialize();
                this.currentPlayerIndex = 0;
                this.isGameOver = false;
                this.dealNewRound();
                this.render();
            }

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

            dealNewRound() {
                this.shuffleDeck();
                this.coreCard = this.deck[0].value;
                
                // Deal 5 cards to each player
                this.players.forEach(player => {
                    if (!player.isEliminated) {
                        player.hand = this.deck.slice(1 + this.players.indexOf(player) * 5, 1 + (this.players.indexOf(player) + 1) * 5);
                    }
                });

                this.lastPlayedCards = [];
            }

            getCurrentPlayer() {
                return this.players[this.currentPlayerIndex];
            }

            nextPlayer() {
                do {
                    this.currentPlayerIndex = (this.currentPlayerIndex + 1) % this.players.length;
                } while (this.getCurrentPlayer().isEliminated);
            }

            playSelectedCards() {
                const selectedCards = Array.from(document.querySelectorAll('.card.selected'))
                    .map(el => this.getCurrentPlayer().hand[parseInt(el.dataset.index)]);
                
                if (selectedCards.length === 0) return;

                this.lastPlayedCards = selectedCards;
                selectedCards.forEach(card => {
                    const index = this.getCurrentPlayer().hand.indexOf(card);
                    if (index > -1) {
                        this.getCurrentPlayer().hand.splice(index, 1);
                    }
                });

                this.nextPlayer();
                this.render();
            }

            callBluff() {
                if (this.lastPlayedCards.length === 0) return;

                const isBluff = !this.lastPlayedCards.every(card => card.value === this.coreCard);
                const previousPlayer = this.players[(this.currentPlayerIndex - 1 + this.players.length) % this.players.length];
                
                this.shootingPlayer = isBluff ? previousPlayer : this.getCurrentPlayer();
                document.getElementById('shootingOverlay').classList.add('active');
            }

            pullTrigger() {
                const hitBullet = Math.random() < (1 / this.shootingPlayer.bulletSlots);
                
                if (hitBullet) {
                    this.shootingPlayer.isEliminated = true;
                    
                    // Check if game is over
                    const remainingPlayers = this.players.filter(p => !p.isEliminated);
                    if (remainingPlayers.length === 1) {
                        alert(`Game Over! ${remainingPlayers[0].name} wins!`);
                        this.isGameOver = true;
                    }
                } else {
                    this.shootingPlayer.bulletSlots--;
                }

                document.getElementById('shootingOverlay').classList.remove('active');
                this.dealNewRound();
                this.render();
            }

            render() {
                // Render players
                const playersContainer = document.getElementById('players');
                playersContainer.innerHTML = '';
                this.players.forEach(player => {
                    const playerEl = document.createElement('div');
                    playerEl.className = `player ${player === this.getCurrentPlayer() ? 'active' : ''} ${player.isEliminated ? 'eliminated' : ''}`;
                    playerEl.innerHTML = `
                        ${player.name}
                        <div class="bullets">${player.bulletSlots}/6</div>
                    `;
                    playersContainer.appendChild(playerEl);
                });

                // Render core card
                document.getElementById('coreCard').textContent = this.coreCard || '';

                // Render last played
                document.getElementById('lastPlayed').textContent = 
                    this.lastPlayedCards.length > 0 ? 
                    `${this.lastPlayedCards.length} cards` : 
                    'None';

                // Render current player's hand
                const handContainer = document.getElementById('currentHand');
                handContainer.innerHTML = '';
                this.getCurrentPlayer().hand.forEach((card, index) => {
                    const cardEl = document.createElement('div');
                    cardEl.className = 'card';
                    cardEl.dataset.index = index;
                    cardEl.textContent = card.toString();
                    cardEl.onclick = () => cardEl.classList.toggle('selected');
                    handContainer.appendChild(cardEl);
                });
            }
        }

        class Gamebug {
            constructor(game) {
                this.game = game;
                this.isAutoPlaying = false;
                this.autoPlayInterval = null;
            }

            toggleAutoPlay() {
                this.isAutoPlaying = !this.isAutoPlaying;
                if (this.isAutoPlaying) {
                    this.autoPlayInterval = setInterval(() => this.makeRandomMove(), 1000);
                } else {
                    clearInterval(this.autoPlayInterval);
                }
            }

            makeRandomMove() {
                if (this.game.isGameOver) {
                    this.toggleAutoPlay();
                    return;
                }

                const currentPlayer = this.game.getCurrentPlayer();
                
                // 30% chance to call bluff if there are cards played
                if (this.game.lastPlayedCards.length > 0 && Math.random() < 0.3) {
                    this.game.callBluff();
                    setTimeout(() => this.game.pullTrigger(), 500);
                    return;
                }

                // Play random cards
                const numCards = Math.floor(Math.random() * Math.min(3, currentPlayer.hand.length)) + 1;
                const selectedIndices = new Set();
                while (selectedIndices.size < numCards) {
                    selectedIndices.add(Math.floor(Math.random() * currentPlayer.hand.length));
                }

                const cards = Array.from(document.querySelectorAll('.card'));
                selectedIndices.forEach(index => cards[index].classList.add('selected'));
                
                setTimeout(() => this.game.playSelectedCards(), 500);
            }
        }

        const game = new Game();
        const bug = new Gamebug(game);
        game.startNewGame();
    </script>
</body>
</html>
```

Game Flow:
Players join (up to 5)
Each gets 5 cards + 6-slot revolver
Core card is shown for the round
Table only shows latest played cards
Players can:
Play cards (claiming they match core card)
Call previous player's bluff
When Bluff Called:
Latest cards are revealed
Loser pulls trigger
If survives: continues with one less slot
If dies: eliminated
New round starts (new hands dealt)
Game continues until one player remains = winner 👑


I need you finish to polish the game logic's.