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

game.html <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8">…

  1. User

    game.html

        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background-color: #121212; /* Dark background */
            display: flex;
            flex-direction: column;
            align-items: center;
            min-height: 100vh;
            padding: 20px;
            color: #ffffff; /* White text */
        }
    
        h1 {
            margin-bottom: 20px;
            color: #ffffff;
        }
    
        /* Room Interface */
        #room-interface {
            display: flex;
            flex-direction: column;
            align-items: center;
            margin-bottom: 20px;
        }
    
        #room-interface input {
            padding: 10px;
            margin: 5px 0;
            width: 200px;
            background-color: #2c3e50;
            color: #ecf0f1;
            border: 1px solid #34495e;
            border-radius: 5px;
        }
    
        #room-interface button {
            padding: 10px 20px;
            margin-top: 10px;
            background-color: #1abc9c;
            border: none;
            color: #ffffff;
            border-radius: 5px;
            cursor: pointer;
            transition: background-color 0.3s ease;
        }
    
        #room-interface button:hover {
            background-color: #16a085;
        }
    
        /* Status Message */
        #status {
            margin-bottom: 20px;
            font-size: 1.2em;
            color: #cccccc;
        }
    
        /* Game Grid */
        #game {
            display: grid;
            grid-template-columns: repeat(3, 100px);
            grid-gap: 10px;
            margin-bottom: 20px;
        }
    
        .cell {
            width: 100px;
            height: 100px;
            background-color: #2c3e50; /* Dark cell background */
            border: 2px solid #34495e; /* Slightly lighter border */
            border-radius: 10px;
            font-size: 2.5em;
            color: #ecf0f1; /* Light cell text color */
            display: flex;
            align-items: center;
            justify-content: center;
            cursor: pointer;
            transition: background-color 0.3s ease, transform 0.1s ease, box-shadow 0.3s ease;
        }
    
        .cell:hover {
            background-color: #3b5998;
            box-shadow: 0 0 10px rgba(59, 89, 152, 0.5);
        }
    
        .cell.disabled {
            cursor: not-allowed;
            background-color: #34495e; /* Dark background */
            color: #7f8c8d; /* Muted text color */
        }
    
        .symbol-placed {
            animation: pop-in 0.3s ease;
        }
    
        @keyframes pop-in {
            0% {
                transform: scale(0.5);
                opacity: 0;
            }
            100% {
                transform: scale(1);
                opacity: 1;
            }
        }
    
        /* Restart Button */
        #restart {
            padding: 10px 20px;
            font-size: 1em;
            background-color: #e74c3c;
            border: none;
            color: #ffffff;
            border-radius: 5px;
            cursor: pointer;
            transition: background-color 0.3s ease;
        }
    
        #restart:hover {
            background-color: #c0392b;
        }
    
        /* Responsive Design */
        @media (max-width: 500px) {
            #game {
                grid-template-columns: repeat(3, 80px);
                grid-gap: 8px;
            }
    
            .cell {
                width: 80px;
                height: 80px;
                font-size: 2em;
            }
    
            #room-interface input {
                width: 160px;
            }
        }
    </style>
    

    server.py import asyncio import websockets import json import string import random

    PORT = 6789

    Dictionary to manage all active rooms

    rooms = {}

    def generate_room_code(length=6): """Generate a unique room code.""" while True: code = ''.join(random.choices(string.ascii_uppercase + string.digits, k=length)) if code not in rooms: return code

    class Game: def init(self, room_code, player1, player2): self.room_code = room_code self.players = [player1, player2] self.symbols = {player1: 'X', player2: 'O'} self.board = [''] * 9 self.current_turn = player1 self.active = True

    async def start(self):
        """Notify players that the game has started and assign symbols."""
        start_msg_p1 = {'type': 'start', 'symbol': self.symbols[self.players[0]], 'room': self.room_code}
        start_msg_p2 = {'type': 'start', 'symbol': self.symbols[self.players[1]], 'room': self.room_code}
        await asyncio.gather(
            self.players[0].send(json.dumps(start_msg_p1)),
            self.players[1].send(json.dumps(start_msg_p2))
        )
        await self.notify_turn()
    
    async def notify_turn(self):
        """Notify players whose turn it is."""
        if not self.active:
            return
        current_symbol = self.symbols[self.current_turn]
        turn_msg = {'type': 'turn', 'symbol': current_symbol}
        await asyncio.gather(
            self.players[0].send(json.dumps(turn_msg)),
            self.players[1].send(json.dumps(turn_msg))
        )
    
    def check_winner(self):
        """Check if there's a winner or a draw."""
        winning_combinations = [
            [0,1,2], [3,4,5], [6,7,8],  # rows
            [0,3,6], [1,4,7], [2,5,8],  # columns
            [0,4,8], [2,4,6]            # diagonals
        ]
        for combo in winning_combinations:
            a, b, c = combo
            if self.board[a] and self.board[a] == self.board[b] == self.board[c]:
                return self.board[a]
        if all(cell != '' for cell in self.board):
            return 'Draw'
        return None
    
    async def handle_move(self, player, index):
        """Process a player's move."""
        if player != self.current_turn or not self.active:
            await player.send(json.dumps({'type': 'error', 'message': 'Not your turn.'}))
            return
        if self.board[index] != '':
            await player.send(json.dumps({'type': 'error', 'message': 'Cell already occupied.'}))
            return
        symbol = self.symbols[player]
        self.board[index] = symbol
        move_msg = {'type': 'move', 'index': index, 'symbol': symbol}
        await asyncio.gather(
            self.players[0].send(json.dumps(move_msg)),
            self.players[1].send(json.dumps(move_msg))
        )
        # Check for winner
        result = self.check_winner()
        if result:
            self.active = False
            if result == 'Draw':
                end_msg = {'type': 'end', 'result': 'It\'s a draw!'}
            else:
                end_msg = {'type': 'end', 'result': f'{result} wins!'}
            await asyncio.gather(
                self.players[0].send(json.dumps(end_msg)),
                self.players[1].send(json.dumps(end_msg))
            )
        else:
            # Switch turn
            self.current_turn = self.players[1] if self.current_turn == self.players[0] else self.players[0]
            await self.notify_turn()
    
    async def handle_reset(self, player):
        """Handle game reset requests."""
        if not self.active:
            # Reset the game
            self.board = [''] * 9
            self.active = True
            await asyncio.gather(
                self.players[0].send(json.dumps({'type': 'reset'})),
                self.players[1].send(json.dumps({'type': 'reset'}))
            )
            # Decide who starts (player1 starts)
            self.current_turn = self.players[0]
            await self.start()
        else:
            # If game is active, do not allow reset
            await player.send(json.dumps({'type': 'error', 'message': 'Cannot reset during an active game.'}))
    
    async def handle_disconnect(self, player):
        """Handle player disconnections."""
        opponent = self.players[1] if self.players[0] == player else self.players[0]
        if self.active:
            end_msg = {'type': 'end', 'result': 'Opponent disconnected.'}
            await opponent.send(json.dumps(end_msg))
        # Clean up room
        del rooms[self.room_code]
        await asyncio.gather(
            opponent.close(),
            player.close()
        )
    

    async def handler(websocket, path): """ Handle incoming WebSocket connections. Expected protocol: - Client sends a JSON message to 'create' or 'join' a room. - After joining, the game starts when two players are in the room. """ try: async for message in websocket: data = json.loads(message) if data['type'] == 'create': # Create a new room room_code = generate_room_code() rooms[room_code] = {'players': [websocket], 'game': None} await websocket.send(json.dumps({'type': 'created', 'room': room_code})) print(f"Room {room_code} created by {websocket.remote_address}") elif data['type'] == 'join': # Join an existing room room_code = data.get('room') if room_code not in rooms: await websocket.send(json.dumps({'type': 'error', 'message': 'Room does not exist.'})) elif len(rooms[room_code]['players']) >= 2: await websocket.send(json.dumps({'type': 'error', 'message': 'Room is full.'})) else: rooms[room_code]['players'].append(websocket) player1, player2 = rooms[room_code]['players'] game = Game(room_code, player1, player2) rooms[room_code]['game'] = game await game.start() print(f"Player joined room {room_code} from {websocket.remote_address}") elif data['type'] == 'move': # Handle a move; ensure the player is part of a game room_code = data.get('room') game = rooms.get(room_code, {}).get('game') if not game: await websocket.send(json.dumps({'type': 'error', 'message': 'Game not found.'})) continue index = data.get('index') if index is not None and 0 <= index < 9: await game.handle_move(websocket, index) else: await websocket.send(json.dumps({'type': 'error', 'message': 'Invalid move.'})) elif data['type'] == 'reset': # Handle a reset request room_code = data.get('room') game = rooms.get(room_code, {}).get('game') if not game: await websocket.send(json.dumps({'type': 'error', 'message': 'Game not found.'})) continue await game.handle_reset(websocket) else: await websocket.send(json.dumps({'type': 'error', 'message': 'Unknown command.'})) except websockets.exceptions.ConnectionClosed: print(f"Connection closed: {websocket.remote_address}") # Find and handle disconnection for room_code, room in list(rooms.items()): if websocket in room['players']: game = room.get('game') if game: await game.handle_disconnect(websocket) else: # Room still has only one player room['players'].remove(websocket) del rooms[room_code] break

    Start the WebSocket server

    start_server = websockets.serve(handler, "0.0.0.0", PORT)

    print(f"Server started on port {PORT}") asyncio.get_event_loop().run_until_complete(start_server) asyncio.get_event_loop().run_forever()

    make it automatcly change x to o for each user and add name system

  2. Assistant

    Certainly! Below are the updated versions of game.html and server.py incorporating the requested features:

    1. Automatically alternate 'X' and 'O' for each user between games. This means that after each game reset, players will swap symbols and alternate who starts first.
    2. Add a name system. Players can enter their names when creating or joining a room. These names will be displayed during the game to show whose turn it is and who won.

    Updated game.html

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Multiplayer Tic Tac Toe</title>
        <style>
            /* [Existing CSS styles remain unchanged] */
            /* ... */
        </style>
    </head>
    <body>
    
    <h1>Multiplayer Tic Tac Toe</h1>
    
    <div id="room-interface">
        <!-- Added Name Input Field -->
        <input type="text" id="name-input" placeholder="Enter Your Name">
        <button id="create-room">Create Room</button>
        <div style="margin: 10px 0; font-weight: bold;">OR</div>
        <input type="text" id="room-code-input" placeholder="Enter Room Code" maxlength="6">
        <button id="join-room">Join Room</button>
    </div>
    
    <div id="current-room" style="display: none; margin-bottom: 10px; font-size: 1em; color: #ffffff;">
        Room Code: <span id="current-room-code"></span>
    </div>
    
    <div id="status">Please create or join a room to start the game.</div>
    
    <div id="game" style="display: none;">
        <!-- 9 cells -->
        <div class="cell" data-index="0"></div>
        <div class="cell" data-index="1"></div>
        <div class="cell" data-index="2"></div>
        <div class="cell" data-index="3"></div>
        <div class="cell" data-index="4"></div>
        <div class="cell" data-index="5"></div>
        <div class="cell" data-index="6"></div>
        <div class="cell" data-index="7"></div>
        <div class="cell" data-index="8"></div>
    </div>
    <button id="restart" disabled>Restart</button>
    
    <script>
        const createRoomButton = document.getElementById('create-room');
        const joinRoomButton = document.getElementById('join-room');
        const roomCodeInput = document.getElementById('room-code-input');
        const nameInput = document.getElementById('name-input'); // New
        const currentRoomDiv = document.getElementById('current-room');
        const currentRoomCodeSpan = document.getElementById('current-room-code');
    
        const statusDiv = document.getElementById('status');
        const gameDiv = document.getElementById('game');
        const cells = document.querySelectorAll('.cell');
        const restartButton = document.getElementById('restart');
    
        let socket;
        let mySymbol;
        let myTurn = false;
        let gameActive = false;
        let roomCode = null;
        let myName = '';
        let opponentName = '';
    
        function connect() {
            // Replace 'localhost' and port '6789' with your server's address and port if different
            socket = new WebSocket('ws://localhost:6789');
    
            socket.onopen = () => {
                console.log('Connected to server');
            };
    
            socket.onmessage = (event) => {
                const message = JSON.parse(event.data);
                switch(message.type) {
                    case 'created':
                        roomCode = message.room;
                        currentRoomCodeSpan.textContent = roomCode;
                        currentRoomDiv.style.display = 'block';
                        statusDiv.textContent = 'Waiting for an opponent to join...';
                        gameDiv.style.display = 'none';
                        break;
                    case 'start':
                        mySymbol = message.symbol;
                        opponentName = message.opponentName;
                        roomCode = message.room;
                        currentRoomCodeSpan.textContent = roomCode;
                        currentRoomDiv.style.display = 'block';
                        gameDiv.style.display = 'grid';
                        gameActive = true;
                        myTurn = mySymbol === 'X'; // X always starts
                        updateStatus();
                        break;
                    case 'turn':
                        const symbol = message.symbol;
                        myTurn = (symbol === mySymbol);
                        updateStatus();
                        break;
                    case 'move':
                        updateBoard(message.index, message.symbol);
                        break;
                    case 'end':
                        gameActive = false;
                        statusDiv.textContent = message.result;
                        restartButton.disabled = false;
                        break;
                    case 'reset':
                        resetGame();
                        break;
                    case 'error':
                        alert(message.message);
                        break;
                    default:
                        console.log('Unknown message type:', message.type);
                }
            };
    
            socket.onclose = () => {
                statusDiv.textContent = 'Disconnected from server.';
                gameActive = false;
                gameDiv.style.display = 'none';
                currentRoomDiv.style.display = 'none';
            };
    
            socket.onerror = (error) => {
                console.error('WebSocket error:', error);
            };
        }
    
        function updateStatus() {
            if (!gameActive) return;
            if (myTurn) {
                statusDiv.textContent = 'Your turn (' + mySymbol + ')';
            } else {
                const opponentSymbol = (mySymbol === 'X') ? 'O' : 'X';
                statusDiv.textContent = opponentName + '\'s turn (' + opponentSymbol + ')';
            }
        }
    
        function updateBoard(index, symbol) {
            const cell = document.querySelector(`.cell[data-index='${index}']`);
            if (cell && cell.textContent === '') {
                cell.textContent = symbol;
                cell.classList.add('disabled', 'symbol-placed');
            }
        }
    
        function resetGame() {
            cells.forEach(cell => {
                cell.textContent = '';
                cell.classList.remove('disabled', 'symbol-placed');
            });
            restartButton.disabled = true;
            myTurn = mySymbol === 'X'; // Update turn based on new symbol
            gameActive = true;
            updateStatus();
        }
    
        createRoomButton.addEventListener('click', () => {
            const name = nameInput.value.trim();
            if (name === '') {
                alert('Please enter your name.');
                return;
            }
            myName = name;
            socket.send(JSON.stringify({ type: 'create', name: myName }));
            createRoomButton.disabled = true;
            joinRoomButton.disabled = true;
            roomCodeInput.disabled = true;
            nameInput.disabled = true;
        });
    
        joinRoomButton.addEventListener('click', () => {
            const name = nameInput.value.trim();
            if (name === '') {
                alert('Please enter your name.');
                return;
            }
            const code = roomCodeInput.value.trim().toUpperCase();
            if (code.length !== 6) {
                alert('Please enter a valid 6-character room code.');
                return;
            }
            myName = name;
            socket.send(JSON.stringify({ type: 'join', room: code, name: myName }));
            createRoomButton.disabled = true;
            joinRoomButton.disabled = true;
            roomCodeInput.disabled = true;
            nameInput.disabled = true;
        });
    
        cells.forEach(cell => {
            cell.addEventListener('click', () => {
                if (!gameActive || !myTurn || cell.textContent !== '') return;
                const index = cell.getAttribute('data-index');
                socket.send(JSON.stringify({ type: 'move', index: parseInt(index), room: roomCode }));
                cell.textContent = mySymbol;
                cell.classList.add('disabled', 'symbol-placed');
                myTurn = false;
                updateStatus();
            });
        });
    
        restartButton.addEventListener('click', () => {
            socket.send(JSON.stringify({ type: 'reset', room: roomCode }));
            restartButton.disabled = true;
        });
    
        window.addEventListener('load', () => {
            connect();
        });
    </script>
    
    </body>
    </html>
    

    Changes in game.html:

    • Added Name Input Field:

      • An input field for the player to enter their name has been added to the room interface.
    • Modified JavaScript:

      • Captured the player's name and stored it in myName.
      • Sent the player's name to the server when creating or joining a room.
      • Stored the opponent's name received from the server.
      • Updated status messages to include the opponent's name during the game.
      • Updated the symbol assignment and turn logic to accommodate symbol swapping after resets.

    Updated server.py

    import asyncio
    import websockets
    import json
    import string
    import random
    
    PORT = 6789
    
    # Dictionary to manage all active rooms
    rooms = {}
    
    def generate_room_code(length=6):
        """Generate a unique room code."""
        while True:
            code = ''.join(random.choices(string.ascii_uppercase + string.digits, k=length))
            if code not in rooms:
                return code
    
    class Game:
        def __init__(self, room_code, player1, player2, names):
            self.room_code = room_code
            self.players = [player1, player2]
            self.names = names  # mapping of websocket to name
            self.symbols = {player1: 'X', player2: 'O'}
            self.board = [''] * 9
            self.starting_player_index = 0  # To keep track of who starts the game
            self.current_turn = self.players[self.starting_player_index]
            self.active = True
    
        async def start(self):
            """Notify players that the game has started and assign symbols."""
            opponent1 = self.names[self.players[1]]
            opponent2 = self.names[self.players[0]]
            start_msg_p1 = {'type': 'start', 'symbol': self.symbols[self.players[0]], 'room': self.room_code, 'opponentName': opponent1}
            start_msg_p2 = {'type': 'start', 'symbol': self.symbols[self.players[1]], 'room': self.room_code, 'opponentName': opponent2}
            await asyncio.gather(
                self.players[0].send(json.dumps(start_msg_p1)),
                self.players[1].send(json.dumps(start_msg_p2))
            )
            await self.notify_turn()
    
        async def notify_turn(self):
            """Notify players whose turn it is."""
            if not self.active:
                return
            current_symbol = self.symbols[self.current_turn]
            turn_msg = {'type': 'turn', 'symbol': current_symbol}
            await asyncio.gather(
                self.players[0].send(json.dumps(turn_msg)),
                self.players[1].send(json.dumps(turn_msg))
            )
    
        def check_winner(self):
            """Check if there's a winner or a draw."""
            winning_combinations = [
                [0,1,2], [3,4,5], [6,7,8],  # rows
                [0,3,6], [1,4,7], [2,5,8],  # columns
                [0,4,8], [2,4,6]            # diagonals
            ]
            for combo in winning_combinations:
                a, b, c = combo
                if self.board[a] and self.board[a] == self.board[b] == self.board[c]:
                    return self.board[a]
            if all(cell != '' for cell in self.board):
                return 'Draw'
            return None
    
        async def handle_move(self, player, index):
            """Process a player's move."""
            if player != self.current_turn or not self.active:
                await player.send(json.dumps({'type': 'error', 'message': 'Not your turn.'}))
                return
            if self.board[index] != '':
                await player.send(json.dumps({'type': 'error', 'message': 'Cell already occupied.'}))
                return
            symbol = self.symbols[player]
            self.board[index] = symbol
            move_msg = {'type': 'move', 'index': index, 'symbol': symbol}
            await asyncio.gather(
                self.players[0].send(json.dumps(move_msg)),
                self.players[1].send(json.dumps(move_msg))
            )
            # Check for winner
            result = self.check_winner()
            if result:
                self.active = False
                if result == 'Draw':
                    end_msg = {'type': 'end', 'result': 'It\'s a draw!'}
                else:
                    winner = self.names[player]
                    end_msg = {'type': 'end', 'result': f'{winner} ({symbol}) wins!'}
                await asyncio.gather(
                    self.players[0].send(json.dumps(end_msg)),
                    self.players[1].send(json.dumps(end_msg))
                )
            else:
                # Switch turn
                self.current_turn = self.players[1] if self.current_turn == self.players[0] else self.players[0]
                await self.notify_turn()
    
        async def handle_reset(self, player):
            """Handle game reset requests."""
            if not self.active:
                # Swap symbols
                self.symbols[self.players[0]], self.symbols[self.players[1]] = self.symbols[self.players[1]], self.symbols[self.players[0]]
                # Switch starting player
                self.starting_player_index = (self.starting_player_index + 1) % 2
                self.current_turn = self.players[self.starting_player_index]
                self.board = [''] * 9
                self.active = True
                reset_msg = {'type': 'reset'}
                await asyncio.gather(
                    self.players[0].send(json.dumps(reset_msg)),
                    self.players[1].send(json.dumps(reset_msg))
                )
                await self.start()
            else:
                # If game is active, do not allow reset
                await player.send(json.dumps({'type': 'error', 'message': 'Cannot reset during an active game.'}))
    
        async def handle_disconnect(self, player):
            """Handle player disconnections."""
            opponent = self.players[1] if self.players[0] == player else self.players[0]
            if self.active:
                end_msg = {'type': 'end', 'result': f'{self.names[player]} disconnected.'}
                await opponent.send(json.dumps(end_msg))
            # Clean up room
            if self.room_code in rooms:
                del rooms[self.room_code]
            await asyncio.gather(
                opponent.close(),
                player.close()
            )
    
    async def handler(websocket, path):
        """
        Handle incoming WebSocket connections.
        """
        try:
            async for message in websocket:
                data = json.loads(message)
                if data['type'] == 'create':
                    # Create a new room
                    name = data.get('name', 'Player')
                    room_code = generate_room_code()
                    rooms[room_code] = {'players': [websocket], 'names': {websocket: name}, 'game': None}
                    await websocket.send(json.dumps({'type': 'created', 'room': room_code}))
                    print(f"Room {room_code} created by {name} ({websocket.remote_address})")
                elif data['type'] == 'join':
                    # Join an existing room
                    name = data.get('name', 'Player')
                    room_code = data.get('room')
                    if room_code not in rooms:
                        await websocket.send(json.dumps({'type': 'error', 'message': 'Room does not exist.'}))
                    elif len(rooms[room_code]['players']) >= 2:
                        await websocket.send(json.dumps({'type': 'error', 'message': 'Room is full.'}))
                    else:
                        rooms[room_code]['players'].append(websocket)
                        rooms[room_code]['names'][websocket] = name
                        player1, player2 = rooms[room_code]['players']
                        game = Game(room_code, player1, player2, rooms[room_code]['names'])
                        rooms[room_code]['game'] = game
                        await game.start()
                        print(f"Player {name} joined room {room_code} from {websocket.remote_address}")
                elif data['type'] == 'move':
                    # Handle a move
                    room_code = data.get('room')
                    game = rooms.get(room_code, {}).get('game')
                    if not game:
                        await websocket.send(json.dumps({'type': 'error', 'message': 'Game not found.'}))
                        continue
                    index = data.get('index')
                    if index is not None and 0 <= index < 9:
                        await game.handle_move(websocket, index)
                    else:
                        await websocket.send(json.dumps({'type': 'error', 'message': 'Invalid move.'}))
                elif data['type'] == 'reset':
                    # Handle a reset request
                    room_code = data.get('room')
                    game = rooms.get(room_code, {}).get('game')
                    if not game:
                        await websocket.send(json.dumps({'type': 'error', 'message': 'Game not found.'}))
                        continue
                    await game.handle_reset(websocket)
                else:
                    await websocket.send(json.dumps({'type': 'error', 'message': 'Unknown command.'}))
        except websockets.exceptions.ConnectionClosed:
            print(f"Connection closed: {websocket.remote_address}")
            # Find and handle disconnection
            for room_code, room in list(rooms.items()):
                if websocket in room['players']:
                    game = room.get('game')
                    if game:
                        await game.handle_disconnect(websocket)
                    else:
                        # Room still has only one player
                        room['players'].remove(websocket)
                        del rooms[room_code]
                    break
    
    # Start the WebSocket server
    start_server = websockets.serve(handler, "0.0.0.0", PORT)
    
    print(f"Server started on port {PORT}")
    asyncio.get_event_loop().run_until_complete(start_server)
    asyncio.get_event_loop().run_forever()
    

    Changes in server.py:

    • Added Name Handling:

      • The server now expects a name field in the create and join messages.
      • Names are stored in the names dictionary within each room.
    • Modified Game Initialization:

      • The Game class now accepts a names parameter to store player names.
      • The start method sends the opponent's name to each player.
    • Symbol Swapping after Reset:

      • When a game reset is initiated, the symbols ('X' and 'O') are swapped between the two players.
      • The starting player alternates after each game reset.
    • Updated End Game Messages:

      • When the game ends, the server includes the winner's name in the result message.
    • Handle Disconnections:

      • If a player disconnects, the server notifies the opponent and cleans up the room.

    Note: Ensure that both the client and server code are updated together, as they depend on these synchronized changes to function correctly.

    Instructions to Run the Server:

    1. Install Dependencies:

      • Ensure you have Python 3.x installed.
      • Install the websockets library if you haven't already:
        pip install websockets
        
    2. Run the Server:

      • Save the updated server.py file.
      • Run the server script:
        python server.py
        
    3. Run the Client:

      • Open the updated game.html file in a modern web browser (e.g., Chrome, Firefox).
      • Ensure that the browser and server are on the same network or adjust the WebSocket URL in the client script to point to the correct server address.

    Testing the Game:

    • Open two separate browser windows or tabs with game.html.
    • In each, enter a unique name.
    • One player creates a room; the other joins using the provided room code.
    • Play the game. After ending, click "Restart" to play again with swapped symbols.
    • Observe that the players' names are displayed, and symbols alternate between games.

    This implementation should fulfill your requirements by automatically alternating symbols between players after each game and allowing players to enter and use names within the game.