Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

index.html [code] server.js [code] Find the reason, why after a second bluff, when the…

  1. User

    index.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Card Bluff & Shoot - Multiplayer</title>
        <link rel="stylesheet" href="style.css">
        <style>
            /* Basic styling for visibility */
            .selected {
                border: 2px solid blue;
            }
            .player {
                margin: 5px 0;
            }
            .active {
                background-color: #e0ffe0;
            }
            .eliminated {
                text-decoration: line-through;
                color: gray;
            }
            .card {
                display: inline-block;
                width: 50px;
                height: 70px;
                border: 1px solid #000;
                border-radius: 5px;
                margin: 5px;
                text-align: center;
                line-height: 70px;
                font-size: 1.2em;
                cursor: pointer;
                position: relative;
                perspective: 1000px; /* For flip animation */
            }
            .card-inner {
                position: absolute;
                width: 100%;
                height: 100%;
                transition: transform 0.6s;
                transform-style: preserve-3d;
            }
            .card.flipped .card-inner {
                transform: rotateY(180deg);
            }
            .card-front, .card-back {
                position: absolute;
                width: 100%;
                height: 100%;
                backface-visibility: hidden;
                border: 1px solid #000;
                border-radius: 5px;
                display: flex;
                align-items: center;
                justify-content: center;
                font-size: 1.2em;
            }
            .card-front {
                background-color: #333; /* Card back color */
                color: #333;
            }
            .card-back {
                background-color: #fff; /* Card face color */
                color: inherit; /* Inherit color for suit */
                transform: rotateY(180deg);
            }
            .hearts, .diamonds {
                color: red;
            }
            .spades, .clubs {
                color: black;
            }
            .match {
                border: 2px solid green; /* Highlight matching cards */
            }
            .mismatch {
                border: 2px solid red; /* Highlight non-matching cards */
            }
            .overlay-content {
                background-color: rgba(0, 0, 0, 0.8);
                color: white;
                padding: 20px;
                border-radius: 10px;
                text-align: center;
            }
            .overlay-button {
                padding: 10px 20px;
                margin-top: 15px;
                font-size: 1em;
                cursor: pointer;
            }
        </style>
    </head>
    <body>
        <div class="container">
            <!-- Waiting Room Section -->
            <div id="waitingRoom" class="section">
                <h3>Room: <span id="roomDisplay">ABC123</span></h3>
                <div id="playersList">
                    <h4>Players in room:</h4>
                    <!-- List of players will be appended here -->
                </div>
                <button id="startGameBtn" style="display: none;">Start Game</button>
                <button id="resetRoomBtn" style="display: none; margin-top: 10px;">Reset Room</button>
            </div>
    
            <!-- Game Section -->
            <div id="gameSection" class="game-container" style="display: none;">
                <div class="top-section" id="players"></div>
    
                <div class="middle-section">
                    <div class="game-info">
                        <strong>Core Card:</strong> <span id="coreCard">-</span>
                    </div>
                    <div class="game-info">
                        <strong>Last Played:</strong> <span id="lastPlayed">None</span>
                    </div>
                    <!-- Central Card Table -->
                    <div class="central-table" id="centralTable"></div>
                </div>
    
                <div class="bottom-section">
                    <div class="player-hand" id="currentHand"></div>
                    <div class="actions">
                        <button id="playButton" onclick="playSelectedCards()">Play Selected Cards</button>
                        <button id="callBluffButton" onclick="callBluff()" style="background: #f44336">Call Bluff</button>
                    </div>
                </div>
    
                <!-- Overlay for Bluff Result -->
                <div class="overlay" id="resultOverlay" style="display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; 
                     background: rgba(0,0,0,0.5); align-items: center; justify-content: center;">
                    <div class="overlay-content">
                        <h2 id="overlayTitle">Result</h2>
                        <p id="overlayMessage"></p>
                        <button id="overlayButton" class="overlay-button" onclick="handleOverlayAction()">Shoot</button>
                    </div>
                </div>
            </div>
    
            <!-- Game Over Overlay -->
            <div class="shooting-overlay" id="gameOverOverlay" style="display: none;">
                <div class="overlay-content">
                    <h2>Game Over!</h2>
                    <p id="gameOverText"></p>
                    <button onclick="resetToLobby()" class="overlay-button">Return to Lobby</button>
                </div>
            </div>
        </div>
    
        <script>
            let ws;
            let username;
            const roomId = 'ABC123'; // Predefined room ID
            let isCreator = false;
            let userHand = [];
            let gameState = null;
            let isWaitingForShot = false; // Flag to prevent multiple shots
    
            // Utility function to generate random username
            function generateRandomUsername() {
                const adjectives = ['Swift', 'Silent', 'Mighty', 'Brave', 'Clever', 'Nimble', 'Fierce', 'Sly', 'Bold', 'Wise'];
                const nouns = ['Lion', 'Tiger', 'Eagle', 'Shark', 'Wolf', 'Panther', 'Dragon', 'Falcon', 'Leopard', 'Cobra'];
                const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
                const noun = nouns[Math.floor(Math.random() * nouns.length)];
                const number = Math.floor(Math.random() * 1000);
                return `${adj}${noun}${number}`;
            }
    
            // Connect to WebSocket server
            function connectWebSocket() {
                ws = new WebSocket('ws://localhost:3000'); // Ensure this URL matches your server's address and port
    
                ws.onopen = () => {
                    console.log('Connected to server');
                    // Assign random username
                    username = generateRandomUsername();
                    // Send JOIN_ROOM message
                    ws.send(JSON.stringify({
                        type: 'JOIN_ROOM',
                        username: username,
                        roomId: roomId
                    }));
                };
    
                ws.onmessage = (event) => {
                    const data = JSON.parse(event.data);
                    handleWebSocketMessage(data);
                };
    
                ws.onclose = () => {
                    console.log('Disconnected from server');
                    alert('Disconnected from server');
                    resetToLobby();
                };
            }
    
            // Handle WebSocket messages
            function handleWebSocketMessage(data) {
                switch(data.type) {
                    case 'PLAYER_JOINED':
                        updatePlayersList(data.players, data.creator);
                        break;
                    case 'PLAYER_LEFT':
                        updatePlayersList(data.players, null); // Creator remains unchanged
                        break;
                    case 'NEW_CREATOR':
                        isCreator = false;
                        alert(`New room creator is: ${data.newCreator}`);
                        updateStartButton(); // Update button visibility
                        break;
                    case 'CREATOR':
                        isCreator = data.isCreator;
                        updateStartButton();
                        break;
                    case 'GAME_STARTED':
                        gameState = data.gameState;
                        userHand = data.hand || [];
                        startGameUI(data.gameState);
                        break;
                    case 'GAME_UPDATE':
                        gameState = data.gameState;
                        if (data.gameState.hand !== undefined) {
                            userHand = data.gameState.hand || [];
                        }
                        updateGameUI();
                        break;
                    case 'BLUFF_RESULT':
                        handleBluffResult(data);
                        break;
                    case 'SHOT_RESULT':
                        handleShotResult(data);
                        break;
                    case 'GAME_OVER':
                        showGameOver(data);
                        break;
                    case 'RESET':
                        alert(data.message);
                        resetToLobby();
                        break;
                    case 'ERROR':
                        alert(data.message);
                        break;
                    default:
                        console.log('Unknown message type:', data.type);
                }
            }
    
            // Update players list in waiting room
            function updatePlayersList(players, creatorUsername) {
                const list = document.getElementById('playersList');
                list.innerHTML = '<h4>Players in room:</h4>';
                players.forEach(player => {
                    const div = document.createElement('div');
                    div.className = 'player';
                    div.textContent = player;
                    list.appendChild(div);
                });
    
                // Determine if the current user is the creator
                if (creatorUsername && creatorUsername === username) {
                    isCreator = true;
                    updateStartButton();
                }
    
                // Show start button only to creator and if at least two players
                if (isCreator && players.length >=2 ) {
                    document.getElementById('startGameBtn').style.display = 'block';
                } else {
                    document.getElementById('startGameBtn').style.display = 'none';
                }
    
                // Show reset button only to creator
                if (isCreator) {
                    document.getElementById('resetRoomBtn').style.display = 'block';
                } else {
                    document.getElementById('resetRoomBtn').style.display = 'none';
                }
            }
    
            // Update start button based on creator status and player count
            function updateStartButton() {
                const players = document.querySelectorAll('#playersList .player');
                if (isCreator && players.length >= 2) {
                    document.getElementById('startGameBtn').style.display = 'block';
                } else {
                    document.getElementById('startGameBtn').style.display = 'none';
                }
    
                // Show reset button only to creator
                if (isCreator) {
                    document.getElementById('resetRoomBtn').style.display = 'block';
                } else {
                    document.getElementById('resetRoomBtn').style.display = 'none';
                }
            }
    
            // Start Game UI
            function startGameUI(gameStateData) {
                document.getElementById('waitingRoom').style.display = 'none';
                document.getElementById('gameSection').style.display = 'grid';
                renderGame(gameStateData);
            }
    
            // Update Game UI
            function updateGameUI() {
                if (!gameState) return;
                renderGame(gameState);
            }
    
            // Render Game UI
            function renderGame(gameState) {
                // Render players
                const playersContainer = document.getElementById('players');
                playersContainer.innerHTML = '';
                gameState.players.forEach(player => {
                    const playerEl = document.createElement('div');
                    playerEl.className = `player ${player.username === gameState.currentPlayer ? 'active' : ''} ${player.isEliminated ? 'eliminated' : ''}`;
                    playerEl.innerHTML = `
                        <strong>${player.username}${player.username === username ? ' (You)' : ''}</strong>
                        <div class="bullets">Bullets: ${player.bulletSlots}/6</div>
                    `;
                    playersContainer.appendChild(playerEl);
                });
    
                // Render core card
                const coreCardSpan = document.getElementById('coreCard');
                if (gameState.coreCard && gameState.coreCard !== '-') {
                    coreCardSpan.innerHTML = formatCard(gameState.coreCard);
                } else {
                    coreCardSpan.textContent = '-';
                }
    
                // Render last played
                const lastPlayedSpan = document.getElementById('lastPlayed');
                if (gameState.lastPlayedCount > 0) {
                    lastPlayedSpan.textContent = `${gameState.lastPlayedCount} card(s) played`;
                } else {
                    lastPlayedSpan.textContent = 'None';
                }
    
                // Render central table
                const centralTable = document.getElementById('centralTable');
                centralTable.innerHTML = '';
                gameState.centralTableCards.forEach(cardObj => {
                    const cardEl = document.createElement('div');
                    cardEl.className = `card ${getSuitClass(cardObj.card)}`;
    
                    // Set color based on suit
                    cardEl.style.color = getCardColor(cardObj.card);
    
                    // Card inner structure for flip animation
                    cardEl.innerHTML = `
                        <div class="card-inner">
                            <div class="card-front">🂠</div> <!-- Card back -->
                            <div class="card-back">${cardObj.card}</div> <!-- Card face -->
                        </div>
                    `;
    
                    // If the card is revealed, add the 'flipped' class to display the front
                    if (cardObj.revealed) {
                        cardEl.classList.add('flipped');
    
                        // Highlight card based on core card matching
                        const coreValue = gameState.coreCard.slice(0, -1); // Extract value without suit
                        const cardValue = cardObj.card.slice(0, -1); // Extract value without suit
    
                        if (cardValue === coreValue) {
                            cardEl.classList.add('match');
                        } else {
                            cardEl.classList.add('mismatch');
                        }
                    }
    
                    centralTable.appendChild(cardEl);
                });
    
                // Always render current player's hand
                const handContainer = document.getElementById('currentHand');
                handContainer.innerHTML = '';
                userHand.forEach((card, index) => {
                    const cardEl = document.createElement('div');
                    cardEl.className = `card ${getSuitClass(card)}`;
                    cardEl.style.color = getCardColor(card);
                    cardEl.dataset.index = index;
                    cardEl.textContent = card; // Display the card face
                    cardEl.onclick = () => {
                        // Only allow selection if it's the player's turn
                        if (gameState.currentPlayer === username && !gameState.isGameOver) {
                            cardEl.classList.toggle('selected');
                        }
                    };
                    handContainer.appendChild(cardEl);
                });
    
                // Enable/Disable action buttons based on turn
                if (gameState.currentPlayer === username && !gameState.isGameOver) {
                    document.getElementById('playButton').disabled = (userHand.length === 0);
                    document.getElementById('callBluffButton').disabled = (gameState.lastPlayedCount === 0);
                } else {
                    document.getElementById('playButton').disabled = true;
                    document.getElementById('callBluffButton').disabled = true;
                }
            }
    
            // Format card HTML
            function formatCard(cardStr) {
                const color = getCardColor(cardStr);
                return `<span style="color: ${color};">${cardStr}</span>`;
            }
    
            // Get card color based on suit
            function getCardColor(cardStr) {
                const suit = cardStr.slice(-1);
                return (suit === '♥' || suit === '♦') ? 'red' : 'black';
            }
    
            // Get suit class for styling
            function getSuitClass(cardStr) {
                const suit = cardStr.slice(-1);
                return suit === '♠' ? 'spades' :
                       suit === '♣' ? 'clubs' :
                       suit === '♥' ? 'hearts' :
                       'diamonds';
            }
    
            // Play selected cards
            function playSelectedCards() {
                // Get selected cards
                const selectedCards = Array.from(document.querySelectorAll('.card.selected'));
                if (selectedCards.length === 0) {
                    alert('Please select at least one card to play.');
                    return;
                }
    
                const selectedIndices = selectedCards.map(card => parseInt(card.dataset.index));
    
                // Send PLAY_CARDS message to server
                ws.send(JSON.stringify({
                    type: 'PLAY_CARDS',
                    selectedIndices: selectedIndices
                }));
    
                // Remove selected cards from userHand
                selectedIndices.sort((a, b) => b - a); // Remove from higher index to lower
                selectedIndices.forEach(index => {
                    userHand.splice(index, 1);
                });
    
                // Clear selected classes
                selectedCards.forEach(card => {
                    card.classList.remove('selected');
                });
            }
    
            // Call bluff
            function callBluff() {
                // Send CALL_BLUFF message to server
                ws.send(JSON.stringify({
                    type: 'CALL_BLUFF'
                }));
            }
    
            // Handle Bluff Result
            function handleBluffResult(data) {
                // Reveal the central table cards based on 'revealed' flag
                const centralTable = document.getElementById('centralTable');
                centralTable.innerHTML = '';
                const coreCard = data.coreCard;
    
                data.centralTableCards.forEach(cardObj => {
                    const cardEl = document.createElement('div');
                    cardEl.className = `card ${getSuitClass(cardObj.card)}`;
    
                    // Set color based on suit
                    cardEl.style.color = getCardColor(cardObj.card);
    
                    // Card inner structure for flip animation
                    cardEl.innerHTML = `
                        <div class="card-inner">
                            <div class="card-front">🂠</div> <!-- Card back -->
                            <div class="card-back">${cardObj.card}</div> <!-- Card face -->
                        </div>
                    `;
    
                    // If the card is revealed, add the 'flipped' class to display the front
                    if (cardObj.revealed) {
                        cardEl.classList.add('flipped');
    
                        // Highlight card based on core card matching
                        const coreValue = coreCard.slice(0, -1); // Extract value without suit
                        const cardValue = cardObj.card.slice(0, -1); // Extract value without suit
    
                        if (cardValue === coreValue) {
                            cardEl.classList.add('match');
                        } else {
                            cardEl.classList.add('mismatch');
                        }
                    }
    
                    centralTable.appendChild(cardEl);
                });
    
                // After a 2-second delay, show the shooting overlay
                setTimeout(() => {
                    const overlay = document.getElementById('resultOverlay');
                    const overlayTitle = document.getElementById('overlayTitle');
                    const overlayMessage = document.getElementById('overlayMessage');
                    const overlayButton = document.getElementById('overlayButton');
    
                    // Determine if the current user is the one who lost the bluff
                    const lostPlayer = data.player;
                    const isUser = lostPlayer === username;
    
                    if (isUser) {
                        overlayTitle.textContent = '⛳ You must Trigger the Gun!';
                        overlayMessage.textContent = 'Click the button below to Pull the Trigger.';
                        overlayButton.style.display = 'inline-block';
                        overlayButton.textContent = 'Shoot';
                    } else {
                        overlayTitle.textContent = `${lostPlayer} must Trigger the Gun!`;
                        overlayMessage.textContent = 'Wait for the outcome.';
                        overlayButton.style.display = 'none';
                    }
    
                    overlay.style.display = 'flex';
                }, 2000); // 2-second delay
            }
    
            // Handle Shot Result
            function handleShotResult(data) {
                const overlay = document.getElementById('resultOverlay');
                const overlayTitle = document.getElementById('overlayTitle');
                const overlayMessage = document.getElementById('overlayMessage');
                const overlayButton = document.getElementById('overlayButton');
    
                if (data.player === username) {
                    if (data.result === 'SHOT') {
                        overlayTitle.textContent = '💀 You have been Shot!';
                        overlayMessage.textContent = 'You have been eliminated.';
                    } else if (data.result === 'SURVIVED') {
                        overlayTitle.textContent = '✨ You Survived!';
                        overlayMessage.textContent = 'You can continue playing.';
                    }
                } else {
                    // For observers or other players
                    overlayTitle.textContent = `${data.player} has ${data.result === 'SHOT' ? 'been Shot!' : 'Survived!'}`;
                    overlayMessage.textContent = '';
                }
    
                // Hide the 'Shoot' button if present
                overlayButton.style.display = 'none';
    
                // After 2 seconds, hide the overlay and reset the game state
                setTimeout(() => {
                    overlay.style.display = 'none';
                    // Update game UI via GAME_UPDATE
                }, 2000);
            }
    
            // Show game over overlay
            function showGameOver(data) {
                document.getElementById('gameSection').style.display = 'none';
                document.getElementById('gameOverOverlay').style.display = 'flex';
                if (data.winner) {
                    document.getElementById('gameOverText').textContent = `Winner: ${data.winner}`;
                } else if (data.message) {
                    document.getElementById('gameOverText').textContent = data.message;
                } else {
                    document.getElementById('gameOverText').textContent = 'The game has ended.';
                }
            }
    
            // Reset to lobby
            function resetToLobby() {
                document.getElementById('gameSection').style.display = 'none';
                document.getElementById('gameOverOverlay').style.display = 'none';
                document.getElementById('resultOverlay').style.display = 'none';
                document.getElementById('waitingRoom').style.display = 'block';
                // Reset variables
                isCreator = false;
                gameState = null;
                userHand = [];
                isWaitingForShot = false;
                // Reload the page to rejoin
                window.location.reload();
            }
    
            // Handle overlay button (Shoot)
            function handleOverlayAction() {
                if (isWaitingForShot) return; // Prevent multiple shots
                isWaitingForShot = true;
                // Send PULL_TRIGGER message to server
                ws.send(JSON.stringify({
                    type: 'PULL_TRIGGER'
                }));
            }
    
            // Handle start game button
            document.getElementById('startGameBtn').addEventListener('click', () => {
                ws.send(JSON.stringify({
                    type: 'START_GAME'
                }));
            });
    
            // Handle reset room button
            document.getElementById('resetRoomBtn').addEventListener('click', () => {
                if (confirm('Are you sure you want to reset the room? This will end the current game.')) {
                    ws.send(JSON.stringify({
                        type: 'RESET_ROOM'
                    }));
                }
            });
    
            // Initialize connection on page load
            window.onload = () => {
                username = generateRandomUsername();
                connectWebSocket();
            };
        </script>
    </body>
    </html>
    

    server.js

    // server.js
    
    const express = require('express');
    const http = require('http');
    const WebSocket = require('ws');
    const { v4: uuidv4 } = require('uuid');
    
    // Define Game Classes
    class Card {
        constructor(value, suit) {
            this.value = value;
            this.suit = suit; // '♠', '♥', '♦', '♣'
        }
    
        toString() {
            return `${this.value}${this.suit}`;
        }
    
        getSuitClass() {
            switch (this.suit) {
                case '♠':
                    return 'spades';
                case '♥':
                    return 'hearts';
                case '♦':
                    return 'diamonds';
                case '♣':
                    return 'clubs';
                default:
                    return '';
            }
        }
    
        getColor() {
            return (this.suit === '♥' || this.suit === '♦') ? 'red' : 'black';
        }
    }
    
    class Player {
        constructor(id, username, ws) {
            this.id = id;
            this.username = username;
            this.ws = ws;
            this.hand = [];
            this.bulletSlots = 6;
            this.isEliminated = false;
        }
    }
    
    class Game {
        constructor(roomId, players) {
            this.roomId = roomId;
            this.players = players; // Array of Player objects
            this.currentPlayerIndex = 0;
            this.coreCard = null;
            this.lastPlayedCards = [];
            this.deck = [];
            this.isGameOver = false;
            this.centralTableCards = [];
            this.shootingPlayer = null; // Player object
            this.initializeDeck();
            this.shuffleDeck();
            this.dealCards();
        }
    
        initializeDeck() {
            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));
                }
            }
        }
    
        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]];
            }
        }
    
        dealCards() {
            // Assign a core card
            if (this.deck.length === 0) {
                throw new Error('Deck is empty. Cannot deal cards.');
            }
            this.coreCard = this.deck.shift();
    
            // Deal 5 cards to each player
            this.players.forEach(player => {
                for (let i = 0; i < 5; i++) {
                    if (this.deck.length > 0) {
                        player.hand.push(this.deck.shift());
                    }
                }
            });
        }
    
        getCurrentPlayer() {
            return this.players[this.currentPlayerIndex];
        }
    
        nextPlayer() {
            if (this.isGameOver) return;
            let attempts = 0;
            do {
                this.currentPlayerIndex = (this.currentPlayerIndex + 1) % this.players.length;
                attempts++;
                if (attempts > this.players.length) break; // Prevent infinite loop
            } while (this.getCurrentPlayer().isEliminated);
        }
    
        getGameState(requestingPlayerId) {
            return {
                roomId: this.roomId,
                players: this.players.map(player => ({
                    id: player.id,
                    username: player.username,
                    isEliminated: player.isEliminated,
                    bulletSlots: player.bulletSlots,
                    // Only send hand to the requesting player
                    hand: player.id === requestingPlayerId ? player.hand.map(card => card.toString()) : undefined
                })),
                currentPlayer: this.getCurrentPlayer().username,
                coreCard: this.coreCard ? this.coreCard.toString() : '-',
                lastPlayedCount: this.lastPlayedCards.length, // Only send count, not actual cards
                centralTableCards: this.centralTableCards.map(cardObj => ({
                    card: cardObj.card.toString(),
                    revealed: cardObj.revealed
                })),
                isGameOver: this.isGameOver
            };
        }
    
        // Assign a new core card for the next round
        assignNewCoreCard() {
            if (this.deck.length === 0) {
                // Reshuffle central table cards back into the deck if needed
                this.deck = this.centralTableCards.map(cardObj => cardObj.card);
                this.shuffleDeck();
                this.centralTableCards = [];
            }
            if (this.deck.length > 0) {
                this.coreCard = this.deck.shift();
            } else {
                // If deck is still empty, set coreCard to null (shouldn't happen with proper deck management)
                this.coreCard = null;
            }
        }
    }
    
    // Initialize Express server
    const app = express();
    const server = http.createServer(app);
    const wss = new WebSocket.Server({ server });
    
    // Serve static files from 'public' directory
    app.use(express.static('public'));
    
    // Define the single room ID
    const ROOM_ID = 'ABC123';
    
    // Initialize the room
    const room = {
        id: ROOM_ID,
        creator: null, // Will be set to the first player
        players: [], // Array of Player objects
        isStarted: false
    };
    
    // Initialize games
    let currentGame = null;
    
    // Handle WebSocket connections
    wss.on('connection', (ws) => {
        ws.id = uuidv4(); // Assign a unique ID to each connection
    
        ws.on('message', (message) => {
            let data;
            try {
                data = JSON.parse(message);
            } catch (e) {
                ws.send(JSON.stringify({ type: 'ERROR', message: 'Invalid JSON' }));
                return;
            }
    
            switch (data.type) {
                case 'JOIN_ROOM':
                    handleJoinRoom(ws, data);
                    break;
                case 'START_GAME':
                    handleStartGame(ws, data);
                    break;
                case 'PLAY_CARDS':
                    handlePlayCards(ws, data);
                    break;
                case 'CALL_BLUFF':
                    handleCallBluff(ws, data);
                    break;
                case 'PULL_TRIGGER':
                    handlePullTrigger(ws, data);
                    break;
                case 'RESET_ROOM':
                    handleResetRoom(ws, data);
                    break;
                default:
                    ws.send(JSON.stringify({ type: 'ERROR', message: 'Unknown command' }));
            }
        });
    
        ws.on('close', () => {
            handleDisconnect(ws);
        });
    });
    
    // Handle joining the room
    function handleJoinRoom(ws, data) {
        const username = data.username;
        const dataRoomId = data.roomId;
    
        if (!username) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Username is required to join the room' }));
            return;
        }
    
        // Validate room ID
        if (dataRoomId !== ROOM_ID) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Room not found' }));
            return;
        }
    
        if (room.isStarted) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Game already started in this room. Please wait for the next round.' }));
            return;
        }
    
        if (room.players.length >= 5) { // Assuming max 5 players
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Room is full' }));
            return;
        }
    
        const playerId = uuidv4();
        const player = new Player(playerId, username, ws);
        room.players.push(player);
    
        ws.roomId = room.id;
        ws.playerId = playerId;
    
        // Assign creator if first player
        let isCreator = false;
        if (room.creator === null) {
            room.creator = playerId;
            isCreator = true;
        }
    
        // Notify all players in the room about the new player and current creator
        broadcastToRoom(room.id, {
            type: 'PLAYER_JOINED',
            players: room.players.map(p => p.username),
            creator: isCreator ? player.username : getPlayerById(room.creator).username
        });
    
        // If the new player is the creator, send a separate message
        if (isCreator) {
            ws.send(JSON.stringify({ type: 'CREATOR', isCreator: true }));
        }
    }
    
    // Handle starting the game
    function handleStartGame(ws, data) {
        const roomId = ws.roomId;
        const playerId = ws.playerId;
    
        if (roomId !== ROOM_ID) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Invalid room' }));
            return;
        }
    
        if (room.creator !== playerId) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Only the room creator can start the game' }));
            return;
        }
    
        if (room.isStarted) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Game already started' }));
            return;
        }
    
        if (room.players.length < 2) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'At least two players are required to start the game' }));
            return;
        }
    
        try {
            // Initialize game
            currentGame = new Game(roomId, room.players);
            room.isStarted = true;
        } catch (error) {
            ws.send(JSON.stringify({ type: 'ERROR', message: error.message }));
            return;
        }
    
        // Broadcast game start and initial game state to all players
        room.players.forEach(player => {
            player.ws.send(JSON.stringify({
                type: 'GAME_STARTED',
                gameState: currentGame.getGameState(player.id),
                hand: player.hand.map(card => card.toString())
            }));
        });
    }
    
    // Handle playing cards
    function handlePlayCards(ws, data) {
        if (!currentGame || currentGame.isGameOver) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Game not found or already over' }));
            return;
        }
    
        const playerId = ws.playerId;
        const selectedIndices = data.selectedIndices; // Array of indices
    
        const player = currentGame.players.find(p => p.id === playerId);
        if (!player) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Player not found in the game' }));
            return;
        }
    
        if (currentGame.getCurrentPlayer().id !== playerId) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Not your turn' }));
            return;
        }
    
        if (!Array.isArray(selectedIndices) || selectedIndices.length === 0) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'No cards selected' }));
            return;
        }
    
        // Validate selected indices
        if (selectedIndices.some(index => index < 0 || index >= player.hand.length)) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Invalid card indices' }));
            return;
        }
    
        // Get selected cards
        const selectedCards = selectedIndices.map(index => player.hand[index]);
    
        // Remove selected cards from player's hand (reverse sort to remove from higher index to lower)
        selectedIndices.sort((a, b) => b - a);
        selectedIndices.forEach(index => {
            player.hand.splice(index, 1);
        });
    
        // Update game state's last played cards
        currentGame.lastPlayedCards = selectedCards;
    
        // Reset the central table to only hold the latest played cards
        currentGame.centralTableCards = []; // Clear previous cards
    
        // Add to central table as face-down
        selectedCards.forEach(card => {
            currentGame.centralTableCards.push({
                card: card,
                revealed: false
            });
        });
    
        // Broadcast game state to all players
        broadcastGameState(room.id);
    
        // Move to next player
        currentGame.nextPlayer();
    
        // Broadcast updated game state after moving the turn
        broadcastGameState(room.id);
    }
    
    // Handle calling bluff
    function handleCallBluff(ws, data) {
        if (!currentGame || currentGame.isGameOver) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Game not found or already over' }));
            return;
        }
    
        const playerId = ws.playerId;
        const caller = currentGame.players.find(p => p.id === playerId);
        if (!caller) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Player not found in the game' }));
            return;
        }
    
        // Cannot call bluff if no one has played yet
        if (currentGame.lastPlayedCards.length === 0) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'No cards have been played yet' }));
            return;
        }
    
        // Determine if the last played cards are a bluff
        // Assuming in this game, players must play the coreCard value
        const coreCard = currentGame.coreCard;
        if (!coreCard) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Core card is not set' }));
            return;
        }
    
        const actual = currentGame.lastPlayedCards.every(card => card.value === coreCard.value);
    
        if (!actual) {
            // Bluff was called, and player who played the last cards was bluffing
            const lastPlayerIndex = (currentGame.currentPlayerIndex - 1 + currentGame.players.length) % currentGame.players.length;
            const lastPlayer = currentGame.players[lastPlayerIndex];
    
            lastPlayer.bulletSlots -= 1;
    
            // Check if player is eliminated
            const isEliminated = lastPlayer.bulletSlots <= 0;
            if (isEliminated) {
                lastPlayer.isEliminated = true;
            }
    
            // Notify all players about the result
            broadcastToRoom(room.id, {
                type: 'BLUFF_RESULT',
                result: 'PLAYER_BLUFFED',
                player: lastPlayer.username,
                bulletSlots: lastPlayer.bulletSlots,
                isEliminated: isEliminated,
                centralTableCards: currentGame.centralTableCards.map(cardObj => ({
                    card: cardObj.card.toString(),
                    revealed: true // Reveal the cards
                })),
                coreCard: coreCard.toString()
            });
    
            // Set shootingPlayer to the last player who bluffed
            currentGame.shootingPlayer = lastPlayer;
    
        } else {
            // Bluff was called, but it was not a bluff
            caller.bulletSlots -= 1;
    
            // Check if caller is eliminated
            const isEliminated = caller.bulletSlots <= 0;
            if (isEliminated) {
                caller.isEliminated = true;
            }
    
            // Notify all players about the result
            broadcastToRoom(room.id, {
                type: 'BLUFF_RESULT',
                result: 'PLAYER_NOT_BLUFFED',
                player: caller.username,
                bulletSlots: caller.bulletSlots,
                isEliminated: isEliminated,
                centralTableCards: currentGame.centralTableCards.map(cardObj => ({
                    card: cardObj.card.toString(),
                    revealed: true // Reveal the cards
                })),
                coreCard: coreCard.toString()
            });
    
            // Set shootingPlayer to the caller who called a false bluff
            currentGame.shootingPlayer = caller;
        }
    
        // Update the revealed status of the cards on the central table
        currentGame.centralTableCards.forEach(cardObj => {
            cardObj.revealed = true;
        });
    
        // Optionally, broadcast the updated game state to all players
        broadcastGameState(room.id);
    
        // No longer assign a new core card or clear centralTableCards here
        // The shot overlay will handle the next steps
    }
    
    // Handle pulling trigger
    function handlePullTrigger(ws, data) {
        if (!currentGame || currentGame.isGameOver) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Game not found or already over' }));
            return;
        }
    
        const playerId = ws.playerId;
    
        if (!currentGame.shootingPlayer) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'No shooting action pending' }));
            return;
        }
    
        const shootingPlayer = currentGame.shootingPlayer;
    
        // Ensure that only the shooting player can pull the trigger
        if (shootingPlayer.id !== playerId) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'You are not authorized to pull the trigger' }));
            return;
        }
    
        // Pull the trigger: determine if the player is shot
        const bulletChance = 1 / shootingPlayer.bulletSlots;
        const shot = Math.random() < bulletChance;
    
        if (shot) {
            shootingPlayer.bulletSlots -= 1;
            shootingPlayer.isEliminated = true;
    
            broadcastToRoom(room.id, {
                type: 'SHOT_RESULT',
                result: 'SHOT',
                player: shootingPlayer.username,
                bulletSlots: shootingPlayer.bulletSlots,
                isEliminated: shootingPlayer.isEliminated
            });
        } else {
            shootingPlayer.bulletSlots -= 1;
    
            broadcastToRoom(room.id, {
                type: 'SHOT_RESULT',
                result: 'SURVIVED',
                player: shootingPlayer.username,
                bulletSlots: shootingPlayer.bulletSlots,
                isEliminated: shootingPlayer.isEliminated
            });
        }
    
        // Reset shooting player
        currentGame.shootingPlayer = null;
    
        // Check if the game is over
        const remainingPlayers = currentGame.players.filter(p => !p.isEliminated);
        if (remainingPlayers.length === 1) {
            currentGame.isGameOver = true;
            broadcastToRoom(room.id, {
                type: 'GAME_OVER',
                winner: remainingPlayers[0].username
            });
            currentGame = null;
            room.isStarted = false;
            return;
        }
    
        // Reset for next round
        // Assign a new core card here after the shot is resolved
        currentGame.assignNewCoreCard();
    
        // Move to next player
        currentGame.nextPlayer();
    
        // Broadcast updated game state
        broadcastGameState(room.id);
    
        // Clear central table cards for the next round
        currentGame.centralTableCards = [];
    }
    
    // Handle resetting the room
    function handleResetRoom(ws, data) {
        const playerId = ws.playerId;
        if (room.creator !== playerId) {
            ws.send(JSON.stringify({ type: 'ERROR', message: 'Only the room creator can reset the room' }));
            return;
        }
    
        // Reset game state
        if (currentGame && !currentGame.isGameOver) {
            currentGame.isGameOver = true;
            broadcastToRoom(room.id, {
                type: 'GAME_OVER',
                winner: null,
                message: 'Game has been reset by the creator.'
            });
            currentGame = null;
        }
    
        // Reset room state
        room.isStarted = false;
    
        // Notify all players to reset
        broadcastToRoom(room.id, {
            type: 'RESET',
            message: 'Room has been reset. You can join again.'
        });
    
        // Reset all players' states
        room.players.forEach(player => {
            player.hand = [];
            player.bulletSlots = 6;
            player.isEliminated = false;
        });
    }
    
    // Handle disconnects
    function handleDisconnect(ws) {
        const roomId = ws.roomId;
        const playerId = ws.playerId;
    
        if (roomId !== ROOM_ID) return;
    
        const playerIndex = room.players.findIndex(p => p.id === playerId);
        if (playerIndex === -1) return;
    
        const player = room.players.splice(playerIndex, 1)[0];
    
        // Notify remaining players
        broadcastToRoom(room.id, {
            type: 'PLAYER_LEFT',
            players: room.players.map(p => p.username)
        });
    
        // If game is ongoing, mark player as eliminated
        if (currentGame) {
            const gamePlayer = currentGame.players.find(p => p.id === playerId);
            if (gamePlayer) {
                gamePlayer.isEliminated = true;
    
                // Check for game over
                const remainingPlayers = currentGame.players.filter(p => !p.isEliminated);
                if (remainingPlayers.length === 1) {
                    currentGame.isGameOver = true;
                    broadcastToRoom(room.id, {
                        type: 'GAME_OVER',
                        winner: remainingPlayers[0].username
                    });
                    currentGame = null;
                    room.isStarted = false;
                    return;
                }
    
                // Broadcast updated game state
                broadcastGameState(room.id);
            }
        }
    
        // If room is empty, reset creator and game state
        if (room.players.length === 0) {
            room.creator = null;
            room.isStarted = false;
            currentGame = null;
        } else {
            // If creator disconnected, assign a new creator
            if (room.creator === playerId) {
                room.creator = room.players[0].id;
                room.players[0].ws.send(JSON.stringify({
                    type: 'NEW_CREATOR',
                    newCreator: room.players[0].username
                }));
            }
        }
    }
    
    // Broadcast game state to all players in the room
    function broadcastGameState(roomId) {
        if (!currentGame) return;
    
        room.players.forEach(player => {
            player.ws.send(JSON.stringify({
                type: 'GAME_UPDATE',
                gameState: currentGame.getGameState(player.id)
            }));
        });
    }
    
    // Broadcast a message to all players in a room
    function broadcastToRoom(roomId, message) {
        const targetRoom = roomId === ROOM_ID ? room : null;
        if (!targetRoom) return;
    
        targetRoom.players.forEach(player => {
            if (player.ws.readyState === WebSocket.OPEN) {
                player.ws.send(JSON.stringify(message));
            }
        });
    }
    
    // Helper function to get a player by ID
    function getPlayerById(playerId) {
        return room.players.find(p => p.id === playerId);
    }
    
    const PORT = process.env.PORT || 3000;
    
    server.listen(PORT, () => {
        console.log(`Server is listening on port ${PORT}`);
    });
    

    Find the reason, why after a second bluff, when the player hit to shooting, nothing happens and the stuck there. Happens, after the first bluff. Don't take my words, go deeper and find the reason behind.

  2. Assistant

    The issue you're encountering stems from the isWaitingForShot flag in your client-side JavaScript code (index.html). This flag is intended to prevent multiple shots from being triggered by the user rapidly clicking the "Shoot" button. However, after the first bluff and shooting event, this flag is set to true and never reset back to false. As a result, when the second shooting event occurs, the handleOverlayAction() function immediately returns without sending the PULL_TRIGGER message to the server, causing the game to appear stuck.

    Here's a step-by-step breakdown of what's happening:

    1. First Bluff and Shooting Event:

      • When a player calls a bluff, the server processes this in handleCallBluff().
      • The server determines if the bluff was successful and sets currentGame.shootingPlayer appropriately.
      • The server broadcasts a BLUFF_RESULT message.
      • On the client side, handleBluffResult() processes this message and displays an overlay with a "Shoot" button for the shooting player.
      • When the shooting player clicks "Shoot", handleOverlayAction() is called.
      • Inside handleOverlayAction(), the isWaitingForShot flag is checked (it's initially false), so the function proceeds.
      • The flag isWaitingForShot is set to true to prevent multiple shots.
      • A PULL_TRIGGER message is sent to the server.
      • The server processes the shooting in handlePullTrigger(), updates the game state, and broadcasts a SHOT_RESULT message.
      • The client receives the SHOT_RESULT message and processes it in handleShotResult(), displaying the result.
      • Problem: At this point, isWaitingForShot is not reset back to false.
    2. Second Bluff and Shooting Event:

      • The same sequence of events occurs up until the shooting player clicks "Shoot".
      • handleOverlayAction() is called again.
      • This time, since isWaitingForShot is still true (it was never reset after the first shooting), the function immediately returns.
      • The PULL_TRIGGER message is not sent to the server.
      • The server is waiting for the shooting player to send the PULL_TRIGGER message, but it never arrives.
      • The game appears to be stuck as no further actions can be taken.

    Solution:

    To fix this issue, you need to reset the isWaitingForShot flag back to false after the shooting event is resolved. This can be done by modifying the handleShotResult() function in your client-side code to reset the flag when the overlay is hidden after displaying the shooting result.

    Here's the corrected handleShotResult() function with the necessary change:

    // Handle Shot Result
    function handleShotResult(data) {
        const overlay = document.getElementById('resultOverlay');
        const overlayTitle = document.getElementById('overlayTitle');
        const overlayMessage = document.getElementById('overlayMessage');
        const overlayButton = document.getElementById('overlayButton');
    
        if (data.player === username) {
            if (data.result === 'SHOT') {
                overlayTitle.textContent = '💀 You have been Shot!';
                overlayMessage.textContent = 'You have been eliminated.';
            } else if (data.result === 'SURVIVED') {
                overlayTitle.textContent = '✨ You Survived!';
                overlayMessage.textContent = 'You can continue playing.';
            }
        } else {
            // For observers or other players
            overlayTitle.textContent = `${data.player} has ${data.result === 'SHOT' ? 'been Shot!' : 'Survived!'}`;
            overlayMessage.textContent = '';
        }
    
        // Hide the 'Shoot' button if present
        overlayButton.style.display = 'none';
    
        // After 2 seconds, hide the overlay and reset the game state
        setTimeout(() => {
            overlay.style.display = 'none';
            isWaitingForShot = false; // Reset the flag here
            // Update game UI via GAME_UPDATE
        }, 2000);
    }
    

    By adding isWaitingForShot = false; in the timeout callback, you ensure that the flag is reset after the shooting result is processed, allowing future shooting events to proceed correctly.

    Conclusion:

    The game gets stuck after the second bluff because the isWaitingForShot flag remains true after the first shooting event, preventing the PULL_TRIGGER message from being sent to the server in subsequent shooting events. Resetting this flag resolves the issue.


    Summary:

    After the first shooting, the isWaitingForShot flag remains true, blocking future shooting actions. Resetting isWaitingForShot to false in handleShotResult() after the shooting result is processed fixes the problem, allowing the game to continue after subsequent bluffs.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.