EP.115 Advanced Multiplayer Game System with WebSocket in Golang

Creating a real-time multiplayer game like a battle arena, co-op, or shooting game requires an ultra-fast system that can transmit high-frequency data such as:

• Player positions
• Attacks
• Jumps
• Game events

And Go + WebSocket is the perfect combination for this challenge.

✅ Why Go + WebSocket?

• Low latency
• Bi-directional communication
• Supports tens of thousands of concurrent connections
• Goroutines in Go are lightweight and efficient for handling many WebSocket clients

🧠 Core Challenges of Real-Time Multiplayer Games

1. Player State Sync

All players must see the same data: HP, score, status, etc.

2. Position Sync

Player X/Y/Z coordinates must update in real-time.

3. Event Sync

When someone shoots, jumps, or picks up an item, all players must know instantly.

⚠️ If syncing is delayed even by 100–200ms, users will feel laggy or unresponsive gameplay.

🧩 Designing Game Rooms

In real-world multiplayer games, players are not all in a single room. They're divided into multiple rooms (instances).

type Player struct {
    ID    string
    X     float64
    Y     float64
    Conn  *websocket.Conn
}

type GameRoom struct {
    ID      string
    Players map[string]*Player
    Mutex   sync.Mutex
}

Each room holds multiple players. The Mutex ensures safe concurrent access. Whenever a player moves, the new position is broadcasted to all others in the same room.

⚙️ Receiving & Broadcasting Player Position

Handling client message:

func (room *GameRoom) handlePlayerMessage(player *Player) {
    for {
        _, message, err := player.Conn.ReadMessage()
        if err != nil {
            room.removePlayer(player.ID)
            return
        }

        var data map[string]interface{}
        json.Unmarshal(message, &data)

        if data["type"] == "move" {
            player.X = data["x"].(float64)
            player.Y = data["y"].(float64)

            room.broadcast(map[string]interface{}{
                "type": "player_move",
                "id":   player.ID,
                "x":    player.X,
                "y":    player.Y,
            })
        }
    }
}

Broadcasting to everyone in the room:

func (room *GameRoom) broadcast(msg interface{}) {
    room.Mutex.Lock()
    defer room.Mutex.Unlock()

    jsonMsg, _ := json.Marshal(msg)

    for _, p := range room.Players {
        p.Conn.WriteMessage(websocket.TextMessage, jsonMsg)
    }
}

🔧 How to Reduce Latency Like a Pro

🔐 Handling Disconnected Players

func (room *GameRoom) removePlayer(playerID string) {
    room.Mutex.Lock()
    delete(room.Players, playerID)
    room.Mutex.Unlock()

    room.broadcast(map[string]interface{}{
        "type": "player_left",
        "id":   playerID,
    })
}

When a player disconnects, they are removed from the room and all others are notified immediately.

🏗 Building a Production-Ready Multiplayer System

🎯 Challenge Yourself!

Try building a simple game like:

• ✅ 2D Arena Game
• ✅ Multiplayer Drawing Board
• ✅ Real-time Movement Demo

Make it work with 10 players moving simultaneously. If you succeed congratulations, you've taken your first real step into building professional multiplayer systems with Go + WebSocket! 🚀

🔮 Next Episode EP.116: Real-time Voice/Video with WebRTC

In the next episode, you’ll explore how to build:

• WebRTC Peer Connections
• WebSocket Signaling
• Real-time Voice & Video Chat system

You'll learn how to integrate WebRTC with WebSocket to build Zoom/Discord-like features for your app!