SoFunction
Updated on 2025-04-11

Python implementation of online game scenarios

introduction

What is ?

It is a real-time two-way communication library based on WebSocket, allowing long connections between clients and servers to support real-time data transmission. It can pass messages through an event-driven way, not only supports the WebSocket protocol, but also fall back to HTTP long polling mechanisms when necessary, with good compatibility.

Application scenarios

It is widely used in scenarios where real-time communication is required, such as:

  • Online chat application
  • Real-time game
  • Multiple collaborative editing
  • Real-time notification and message push system

Advantages in online games

In multiplayer online games, real-time communication is crucial. Changes in the game (such as player movements, attacks, etc.) need to be synchronized between multiple clients. It provides a stable and efficient communication method, which can ensure low-latency transmission of data, and supports automatic reconnection and heartbeat mechanisms to ensure the stability of the connection.

Overview of this article

This article will introduce how to implement a simple multiplayer online real-time battle game using Python's library. In the game, players can move and attack other players in real time. All operations and statuses need to be synchronized through the server and broadcast to all connected clients in real time.

How it works

Event-driven mechanism

The core is the event-driven model. Between the server and the client, it can be done throughemit()Send events and data, throughon()Listen and handle these events. Event-driven models are very suitable for game scenarios, because various actions (such as movement and attack) in the game can be regarded as different events.

Comparison between WebSocket and .

WebSocket is a full-duplex communication protocol, but is implemented based on WebSocket, providing more functions. Not only does it support WebSocket, it can also be automatically downgraded to other transmission methods, such as HTTP long polling, in environments that do not support WebSocket. In addition, it provides functions such as automatic reconnection, heartbeat detection, message confirmation, etc., which are suitable for complex application scenarios.

Handshake and connection mechanism

When the client connects to the server, the handshake is first completed over HTTP and then an attempt is made to upgrade to a WebSocket connection. If WebSocket is not available, it falls back to another mechanism. In this way, very stable communication connections are provided.

Online multiplayer game scene

Scene introduction: Multiplayer real-time battle game

The scene in this article is a simple multiplayer online battle game where multiple players control their characters to move in the game map through the browser. Each player can see the location of other players and be able to launch an attack. The server needs to process each player's movement and attack instructions and synchronize these states to all other players.

Communication requirements for games

In this game, communication requirements mainly include:

  • Location synchronization: Each player's movement needs to be synchronized to other players in real time.
  • Attack Synchronization: When a player launches an attack, the behavior and effects of the attack need to be broadcast to all players.
  • Real-time feedback: The server needs to broadcast the behavior of other players to all clients immediately to ensure the real-time nature of the game.

Use to solve real-time synchronization issues

Through , we can easily achieve two-way communication between the server and multiple clients. When the player initiates any action (such as movement or attack), the client will send these actions to the server, and the server will broadcast these actions to other players.

Server-side implementation

Using PythonsocketioLibrary

On the server side, we use Pythonpython-socketioThe library is used to handle player connection, disconnection, messaging and other events. This library provides a very convenient API to easily build a live gaming server.

Installpython-socketioandeventlet：

pip install python-socketio eventlet

Object-oriented design: Creating game server classes

We will create aGameServerclass to manage game logic such as player connection, location synchronization, attack synchronization, etc. The status of each player (such as location and health) will be saved on the server side and passed to other players through events.

Game server code implementation

import socketio
import random

class GameServer:
    def __init__(self):
         = (cors_allowed_origins='*')
         = ()
         = {}

        ('connect', self.handle_connect)
        ('disconnect', self.handle_disconnect)
        ('move', self.handle_move)
        ('attack', self.handle_attack)

    def handle_connect(self, sid, environ):
        print(f"Players {sid} Connected")
        # Randomly generate player positions        [sid] = {'x': (0, 100), 'y': (0, 100), 'hp': 100}
        # Notify other players that new players will join        ('new_player', {'id': sid, 'position': [sid]}, skip_sid=sid)

    def handle_disconnect(self, sid):
        print(f"Players {sid} Disconnected")
        # Remove player        if sid in :
            del [sid]
        # Notify other players that the player has left        ('player_left', {'id': sid})

    def handle_move(self, sid, data):
        if sid in :
            # Update player location            [sid]['x'] = data['x']
            [sid]['y'] = data['y']
            # Broadcast location to other players            ('player_moved', {'id': sid, 'position': [sid]})

    def handle_attack(self, sid, data):
        if sid in :
            # Assuming the attack range is 10 units, check whether other players are within the attack range            for player_id, player_data in ():
                if player_id != sid:
                    distance = (([sid]['x'] - player_data['x']) ** 2 + ([sid]['y'] - player_data['y']) ** 2) ** 0.5
                    if distance <= 10:
                        player_data['hp'] -= 10
                        if player_data['hp'] <= 0:
                            ('player_killed', {'id': player_id})
                        ('player_attacked', {'id': player_id, 'hp': player_data['hp']})

    def run(self, host='0.0.0.0', port=5000):
        import eventlet
        (((host, port)), )

# Start the game serverif __name__ == '__main__':
    server = GameServer()
    ()

Detailed code explanation

  1. Player connection and disconnection: When a player connects, the server generates a random location for the player and notifies other players that new players have joined. When the player is disconnected, other players are notified to leave.
  2. Location synchronization: When the player moves, the client will send a movement command to the server, and the server updates the player's location and broadcasts it to other players.
  3. Attack Synchronization: When a player initiates an attack, the server will calculate whether other players are within the attack range. If within the range, the amount of health is deducted and all players are notified.

Client implementation

Client communication logic

The client needs to receive the status of other players in real time and communicate with the server by sending commands such as movement and attack. We use HTML and JavaScript to build clients and communicate through the JavaScript client library.

Front-end HTML and JavaScript implementation

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Online

Battle games</title>
    <script src="/4.0.1/"></script>
</head>
<body>
    <canvas  width="500" height="500"></canvas>
    <script>
        const canvas = ('gameCanvas');
        const ctx = ('2d');
        const socket = io('http://localhost:5000');
        let players = {};
        let myId = null;

        ('connect', () => {
            myId = ;
        });

        ('new_player', (data) => {
            players[] = ;
            drawGame();
        });

        ('player_left', (data) => {
            delete players[];
            drawGame();
        });

        ('player_moved', (data) => {
            players[] = ;
            drawGame();
        });

        ('player_attacked', (data) => {
            (`Players ${} Attacked，Remaining blood volume：${}`);
        });

        function drawGame() {
            (0, 0, , );
            for (let id in players) {
                const player = players[id];
                (, , 10, 10);
            }
        }

        ('keydown', (e) => {
            if ( === 'ArrowUp') ('move', { x: players[myId].x, y: players[myId].y - 5 });
            if ( === 'ArrowDown') ('move', { x: players[myId].x, y: players[myId].y + 5 });
            if ( === 'ArrowLeft') ('move', { x: players[myId].x - 5, y: players[myId].y });
            if ( === 'ArrowRight') ('move', { x: players[myId].x + 5, y: players[myId].y });
            if ( === ' ') ('attack', {});
        });
    </script>
</body>
</html>

Detailed code explanation

  1. Connect to the server: Client passesio()The function connects to the server and listens to various events.
  2. Draw player position: After receiving the player location broadcast by the server, the client draws the corresponding player on the canvas.
  3. Player moves: When the arrow key is pressed, the client will send a moving command to the server, and the server will broadcast the command to all other players.

Complete case: Multiplayer online battle game

In this case, all players' movements and attacks are synchronized through the server, ensuring consistency in the game state. Each client can see the location and status of other players in real time, and all operations communicate through .

Game rules description

  1. Players can control their characters to move in the map through the arrow keys.
  2. Press the Space Bar to launch an attack, with an attack range of 10 units.
  3. If the player is within the attack range, the health volume will be reduced, and when the health volume is 0, the player will die.

Implementation of game logic

  • Every time a move or attack is performed, the client sends instructions to the server, and after the server processes the instructions, the result will be broadcast to all clients.
  • The server manages the status of all players to ensure that the status of each player is consistent across different clients.

Challenges and solutions for real-time synchronization

Latency and packet loss are common problems in multiplayer real-time games. Through automatic reconnection and message confirmation mechanisms, the impact of packet loss can be reduced. For delays, a heartbeat mechanism is also provided to ensure the activity of the connection.

Summarize

With Python and we can easily achieve real-time communication of a multiplayer online battle game. In this case, the server is responsible for handling all the players' operations and broadcasting them to other players, and the client realizes two-way communication with the server. There is great application prospect in real-time games, especially when dealing with scenes such as player synchronization and status broadcasting.

Application prospects in online games

With the increase in the demand for real-time communication, it has become more and more widely used in scenarios such as multiplayer online games and real-time collaboration applications. Its automatic reconnection, message acknowledgement and event-driven mechanisms make it ideal for real-time applications.

How to further optimize performance and user experience

To further improve performance, the following optimizations can be considered:

  1. Reduce message volume: Optimize the amount of data sent to reduce latency.
  2. Parallel processing: The server can adopt multi-threaded or distributed architecture to improve processing capabilities.
  3. Accelerate with CDN: Host the front-end code on the CDN to reduce loading time.

Comparison with other real-time communication technologies

Compared with WebSocket, long polling and other technologies, it is better in compatibility and functionality. It not only supports WebSocket, but also automatically falls back to other protocols when WebSocket is not available, thus providing a better user experience.

In this way, we completed a multiplayer online real-time battle game case based on Python and , and showed how to build servers and clients for real-time communication using object-oriented programming ideas. By , developers can more easily implement complex real-time communication applications.

The above is personal experience. I hope you can give you a reference and I hope you can support me more.