// mmo_game/core/world_manager.go
package core

import (
    "sync"
)

/*
    The overall management module of the current game world
*/
type WorldManager struct {
    AoiMgr  *AOIManager       // The AOI planner manager for the current world map
    Players map[int32]*Player // Collection of currently online players
    pLock   sync.RWMutex       // Mutex for protecting Players for concurrent read and write
}

// mmo_game/core/world_manager.go

// Provide an external world management module handle
var WorldMgrObj *WorldManager

// Provide the initialization method for WorldManager
func init() {
    WorldMgrObj = &WorldManager{
        Players: make(map[int32]*Player),
        AoiMgr:  NewAOIManager(AOI_MIN_X, AOI_MAX_X, AOI_CNTS_X, AOI_MIN_Y, AOI_MAX_Y, AOI_CNTS_Y),
    }
}

// The minimum and maximum coordinates and grid counts for AOI
const (
    AOI_MIN_X  int = 85
    AOI_MAX_X  int = 410
    AOI_CNTS_X int = 10
    AOI_MIN_Y  int = 75
    AOI_MAX_Y  int = 400
    AOI_CNTS_Y int = 20
)

// WorldManager is the overall management module of the current game world
type WorldManager struct {
    AoiMgr  *AOIManager       // The AOI planner manager for the current world map
    Players map[int32]*Player // Collection of currently online players
    pLock   sync.RWMutex       // Mutex for protecting Players for concurrent read and write
}

// AddPlayer provides a function to add a player to the player information table Players
func (wm *WorldManager) AddPlayer(player *Player) {
    // Add the player to the world manager
    wm.pLock.Lock()
    wm.Players[player.Pid] = player
    wm.pLock.Unlock()

    // Add the player to the AOI network planning
    wm.AoiMgr.AddToGridByPos(int(player.Pid), player.X, player.Z)
}

// RemovePlayerByPid removes a player from the player information table by player ID
func (wm *WorldManager) RemovePlayerByPid(pid int32) {
    wm.pLock.Lock()
    delete(wm.Players, pid)
    wm.pLock.Unlock()
}

// GetPlayerByPid retrieves player information by player ID
func (wm *WorldManager) GetPlayerByPid(pid int32) *Player {
    wm.pLock.RLock()
    defer wm.pLock.RUnlock()

    return wm.Players[pid]
}

// GetAllPlayers retrieves information about all players
func (wm *WorldManager) GetAllPlayers() []*Player {
    wm.pLock.RLock()
    defer wm.pLock.RUnlock()

    // Create a return player slice
    players := make([]*Player, 0)

    // Append to the slice
    for _, v := range wm.Players {
        players = append(players, v)
    }

    // Return
    return players
}

//mmo_game/server.go

// Hook function when a client establishes a connection
func OnConnecionAdd(conn ziface.IConnection)  {
    // Create a player
    player := core.NewPlayer(conn)

    // Synchronize the current PlayerID to the client using MsgID: 1
    player.SyncPid()

    // Synchronize the initial coordinates of the current player to the client using MsgID: 200
    player.BroadCastStartPosition()

    // Add the currently newly logged-in player to the WorldManager
    core.WorldMgrObj.AddPlayer(player)

    fmt.Println("=====> Player pidId = ", player.Pid, " arrived ====")
}

//mmo_game/pb/msg.proto

syntax = "proto3";                    // Proto protocol
package pb;                            // Current package name
option csharp_namespace = "Pb";   // Option provided for C#

// Synchronize the client's player ID
message SyncPid {
    int32 Pid = 1;
}

// Player position
message Position {
    float X = 1;
    float Y = 2;
    float Z = 3;
    float V = 4;
}

// Player broadcast data
message BroadCast {
    int32 Pid = 1;
    int32 Tp = 2;              // 1 - World chat, 2 - Player position
    oneof Data {
        string Content = 3;    // Chat content
        Position P = 4;        // Location of the broadcasting user
        int32 ActionData = 5;
    }
}

// Player chat data
message Talk {
    string Content = 1;    // Chat content
}

//mmo_game/api/world_chat.go
package api

import (
    "fmt"
    "github.com/golang/protobuf/proto"
    "zinx/ziface"
    "zinx/zinx_app_demo/mmo_game/core"
    "zinx/zinx_app_demo/mmo_game/pb"
    "zinx/znet"
)

// WorldChat API for world chat routing business
type WorldChatApi struct {
    znet.BaseRouter
}

func (*WorldChatApi) Handle(request ziface.IRequest) {
    // 1. Decode the proto protocol sent by the client
    msg := &pb.Talk{}
    err := proto.Unmarshal(request.GetData(), msg)
    if err != nil {
        fmt.Println("Talk Unmarshal error ", err)
        return
    }

    // 2. Determine which player sent the message, get it from the connection's "pid" attribute
    pid, err := request.GetConnection().GetProperty("pid")
    if err != nil {
        fmt.Println("GetProperty pid error", err)
        request.GetConnection().Stop()
        return
    }

    // 3. Get the player object based on pid
    player := core.WorldMgrObj.GetPlayerByPid(pid.(int32))

    // 4. Have the player object initiate a chat broadcast request
    player.Talk(msg.Content)
}

//mmo_game/server.go

// Hook function executed when a client connection is established
func OnConnecionAdd(conn ziface.IConnection)  {
    // Create a player
    player := core.NewPlayer(conn)
    // Synchronize the current PlayerID to the client using MsgID:1 message
    player.SyncPid()
    // Synchronize the initial coordinates of the current player to the client using MsgID:200 message
    player.BroadCastStartPosition()
    // Add the newly logged-in player to the worldManager
    core.WorldMgrObj.AddPlayer(player)

    // Add: Bind the PID to this connection as an attribute
    conn.SetProperty("pid", player.Pid)

    fmt.Println("=====> Player pidId = ", player.Pid, " arrived ====")
}

// mmo_game/core/player.go

// Broadcast player chat
func (p *Player) Talk(content string) {
    // 1. Assemble the MsgId200 proto data
    msg := &pb.BroadCast{
        Pid: p.Pid,
        Tp:  1, // TP 1 represents chat broadcast
        Data: &pb.BroadCast_Content{
            Content: content,
        },
    }

    // 2. Get all currently online players in the world
    players := WorldMgrObj.GetAllPlayers()

    // 3. Send MsgId:200 messages to all players
    for _, player := range players {
        player.SendMsg(200, msg)
    }
}

$ go run server.go
Add api msgId = 2
[START] Server name: Zinx Game, listener at IP: 0.0.0.0, Port 8999 is starting
[Zinx] Version: V0.11, MaxConn: 3000, MaxPacketSize: 4096
Start Zinx server Zinx Game successfully, now listening...
Worker ID = 9 is started.
Worker ID = 4 is started.
Worker ID = 5 is started.
Worker ID = 6 is started.
Worker ID = 7 is started.
Worker ID = 8 is started.
Worker ID = 0 is started.
Worker ID = 1 is started.
Worker ID = 2 is started.
Worker ID = 3 is started.