从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】_golang tcp框架

从0到1开发go-tcp框架【实战片— — 开发MMO】

MMO（MassiveMultiplayerOnlineGame）：大型多人在线游戏（多人在线网游）

1 AOI兴趣点的算法

游戏中的坐标模型：

场景相关数值计算

● 场景大小： 250*250 ， w(x轴宽度) = 250，l(y轴长度) = 250
● x轴格子数量：nx = 5
● y轴格子数量：ny = 5
● 格子宽度: dx = w / nx = 250 / 5 = 50
● 格子长度: dy = l / ny = 250 / 5 = 50
● 格子的x轴坐标：idx
● 格子的y轴坐标：idy
● 格子编号：id = idy *nx + idx (利用格子坐标得到格子编号)
● 格子坐标：idx = id % nx , idy = id / nx (利用格子id得到格子坐标)
● 格子的x轴坐标: idx = id % nx (利用格子id得到x轴坐标编号)
● 格子的y轴坐标: idy = id / nx (利用格子id得到y轴坐标编号)

1.1 定义AOI格子（Grid）

AOI格子：

• 格子ID
• 格子的左边界坐标
• 格子的右边界坐标
• 格子的上边界坐标
• 格子的下边界坐标
• 当前格子内玩家/物体成员的ID集合
• 保护当前集合的锁

AOI格子应该有的方法：

• 初始化当前格子
• 给格子添加一个玩家
• 从格子中删除一个玩家
• 得到当前格子中所有的玩家
• 调试使用：打印出格子的基本信息

mmo_game_zinx/core/grid.go

package core

import (
	"fmt"
	"sync"
)

/*
一个AOI地图中的格子类型
*/
type Grid struct {
	//格子ID
	GID int
	//格子的左边界坐标
	MinX int
	//格子的右边界坐标
	MaxX int
	//格子的上边界坐标
	MinY int
	//格子的下边界坐标
	MaxY int
	//当前格子内玩家或物体成员对的ID集合
	playerIDs map[int]bool
	//保护当前集合的锁
	pIDLock sync.RWMutex
}

//初始化当前格子的方法
func NewGrid(gId, minX, maxX, minY, maxY int) *Grid {
	return &Grid{
		GID:       gId,
		MinX:      minX,
		MaxX:      maxX,
		MinY:      minY,
		MaxY:      maxY,
		playerIDs: make(map[int]bool),
	}
}

//给格子添加一个玩家
func (g *Grid) Add(playerId int) {
	g.pIDLock.Lock()
	defer g.pIDLock.Unlock()
	g.playerIDs[playerId] = true
}

//从格子中删除一个玩家
func (g *Grid) Remove(playerId int) {
	g.pIDLock.Lock()
	defer g.pIDLock.Unlock()
	delete(g.playerIDs, playerId)
}

//得到当前格子中所有玩家的id
func (g *Grid) GetPlayerIds() (playerIds []int) {
	g.pIDLock.RLock()
	defer g.pIDLock.RUnlock()
	for k, _ := range g.playerIDs {
		playerIds = append(playerIds, k)
	}
	return
}

func (g *Grid) String() string {
	return fmt.Sprintf("Grid id: %d, minX: %d, maxX: %d, minY: %d, maxY: %d, playerIds: %v",
		g.GID, g.MinX, g.MaxX, g.MinY, g.MaxY, g.playerIDs)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

1.2 AOI管理模块

AOIManager：

• 初始化一个AOI管理区域模块
• 得到每个格子在X轴方向的宽度
• 通过横纵轴得到GID
• 添加一个PlayerId到一个格子中
• 移除一个格子中的playerId
• 通过GID获取全部的PlayerID
• 通过坐标将Player添加到一个格子中
• 通过坐标把一个Player从一个格子中删除
• 通过Player坐标得到当前Player周边九宫格内全部的PlayerIDs
• 通过坐标获取对应玩家所在的GID
• 通过横纵轴得到周围的九宫格
• 根据GID获取GID周围的九宫格
  
  • 获取思路：先求x，再求y。先根据GID判断该GID左边和右边是否有格子 。然后将X轴上的格子添加到集合中，再遍历集合判断集合中的上下是否有格子。

mmo_game_zinx/core/aoi.go

package core

import "fmt"

// 定义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
)

type AOIManager struct {
	//区域的左边界坐标
	MinX int
	//区域的右界坐标
	MaxX int
	//X方向格子的数量
	CountsX int
	//区域的上边界坐标
	MinY int
	//区域的下边界坐标
	MaxY int
	//Y方向上格子的数量
	CountsY int
	//当前区域中有哪些格子map-key=格子的ID
	grids map[int]*Grid
}

func NewAOIManager(minX, maxX, countsX, minY, maxY, countsY int) *AOIManager {
	aoiMgr := &AOIManager{
		MinX:    minX,
		MaxX:    maxX,
		CountsX: countsX,
		MinY:    minY,
		MaxY:    maxY,
		CountsY: countsY,
		grids:   make(map[int]*Grid),
	}
	//给AOI初始化区域的所有格子进行编号和初始化
	for y := 0; y < countsY; y++ {
		for x := 0; x < countsX; x++ {
			//计算格子的ID 根据x，y编号
			//格子的编号：id = idy * countsX + idx
			gid := y*countsX + x
			//初始化gid格子
			aoiMgr.grids[gid] = NewGrid(gid,
				aoiMgr.MinX+x*aoiMgr.gridXWidth(),
				aoiMgr.MinX+(x+1)*aoiMgr.gridXWidth(),
				aoiMgr.MinY+y*aoiMgr.gridYLength(),
				aoiMgr.MinY+(y+1)*aoiMgr.gridYLength())
		}
	}
	return aoiMgr
}

// 得到每个格子在x轴方向的宽度
func (m *AOIManager) gridXWidth() int {
	return (m.MaxX - m.MinX) / m.CountsX
}

// 得到每个格子在y轴方向的宽度
func (m *AOIManager) gridYLength() int {
	return (m.MaxY - m.MinY) / m.CountsY
}

// 打印信息方法
func (m *AOIManager) String() string {
	s := fmt.Sprintf("AOIManagr:\nminX:%d, maxX:%d, cntsX:%d, minY:%d, maxY:%d, cntsY:%d\n Grids in AOI Manager:\n",
		m.MinX, m.MaxX, m.CountsX, m.MinY, m.MaxY, m.CountsY)
	for _, grid := range m.grids {
		s += fmt.Sprintln(grid)
	}

	return s
}

// 根据格子的gID得到当前周边的九宫格信息
func (m *AOIManager) GetSurroundGridsByGid(gID int) (grids []*Grid) {
	//判断gID是否存在
	if _, ok := m.grids[gID]; !ok {
		return
	}

	//将当前gid添加到九宫格中
	grids = append(grids, m.grids[gID])

	//根据gid得到当前格子所在的X轴编号
	idx := gID % m.CountsX

	//判断当前idx左边是否还有格子
	if idx > 0 {
		grids = append(grids, m.grids[gID-1])
	}
	//判断当前的idx右边是否还有格子
	if idx < m.CountsX-1 {
		grids = append(grids, m.grids[gID+1])
	}

	//将x轴当前的格子都取出，进行遍历，再分别得到每个格子的上下是否有格子

	//得到当前x轴的格子id集合
	gidsX := make([]int, 0, len(grids))
	for _, v := range grids {
		gidsX = append(gidsX, v.GID)
	}

	//遍历x轴格子
	for _, v := range gidsX {
		//计算该格子处于第几列
		idy := v / m.CountsX

		//判断当前的idy上边是否还有格子
		if idy > 0 {
			grids = append(grids, m.grids[v-m.CountsX])
		}
		//判断当前的idy下边是否还有格子
		if idy < m.CountsY-1 {
			grids = append(grids, m.grids[v+m.CountsX])
		}
	}

	return
}

// 通过横纵坐标获取对应的格子ID
func (m *AOIManager) GetGIDByPos(x, y float32) int {
	gx := (int(x) - m.MinX) / m.gridXWidth()
	gy := (int(y) - m.MinY) / m.gridYLength()
	return gy*m.CountsX + gx
}

// 通过横纵坐标得到周边九宫格内的全部PlayerIDs
func (m *AOIManager) GetPIDsByPos(x, y float32) (playerIDs []int) {
	//根据横纵坐标得到当前坐标属于哪个格子ID
	gID := m.GetGIDByPos(x, y)

	//根据格子ID得到周边九宫格的信息
	grids := m.GetSurroundGridsByGid(gID)
	for _, v := range grids {
		playerIDs = append(playerIDs, v.GetPlayerIds()...)
		fmt.Printf("===> grid ID : %d, pids : %v  ====\n", v.GID, v.GetPlayerIds())
	}
	return
}

// 添加一个PlayerId到一个格子中
func (m *AOIManager) AddPidToGrid(pId, gId int) {
	m.grids[gId].Add(pId)
}

// 移除一个格子中的playerID
func (m *AOIManager) RemovePidFromGrid(pId, gId int) {
	m.grids[gId].Remove(pId)
}

// 通过GID获取全部的playerID
func (m *AOIManager) GetPidsByGid(gId int) (playerIds []int) {
	playerIds = m.grids[gId].GetPlayerIds()
	return
}

// 通过坐标将一个Player添加到一个格子中
func (m *AOIManager) AddToGridByPos(pId int, x, y float32) {
	gId := m.GetGIDByPos(x, y)
	grid := m.grids[gId]
	grid.Add(pId)
}

// 通过一个坐标把一个player从一个格子中删除
func (m *AOIManager) RemoveFromGridByPos(pId int, x, y float32) {
	gId := m.GetGIDByPos(x, y)
	grid := m.grids[gId]
	grid.Remove(pId)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

mmo_game_zinx/core/aoi_test.go

package core

import (
	"fmt"
	"testing"
)

func TestNewAOIManager(t *testing.T) {
	//初始化AOIManager
	aoiMgr := NewAOIManager(0, 250, 5, 0, 250, 5)
	//打印AOIManager
	fmt.Println(aoiMgr)
}

//根据GID获取九宫格
func TestAOIManager_GetSurroundGridsByGid(t *testing.T) {
	//初始化AOIManager
	aoiMgr := NewAOIManager(0, 250, 5, 0, 250, 5)
	for gid, _ := range aoiMgr.grids {
		grids := aoiMgr.GetSurroundGridsByGid(gid)
		fmt.Println("gid : ", gid, " grids len = ", len(grids))
		gIds := make([]int, 0, len(grids))
		for _, grid := range grids {
			gIds = append(gIds, grid.GID)
		}
		fmt.Println("surrounding grid IDs are : ", gIds)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2 数据传输协议的选择（protobuf）

常见的传输格式：json、xml、protobuf

1. json：可读性比较强；编解码比较耗时【web领域】
2. xml：基于标签【前端/网页】
3. protobuf（Google开发的）：编解码很快、体积小、跨平台；可读性不强，传输过程中不是明文，是二进制（已经序列化完毕的）【后端应用/微服务/服务器】

2.1 安装

我这里以mac安装为例，其他os自行百度即可

# 安装protobuf
brew install protobuf

# 安装用于编译生成go文件的插件
brew install protoc-gen-go
brew install protoc-gen-go-grpc

# 查看版本
protoc --version
protoc-gen-go --version

# 安装golang插件
go get github.com/golang/protobuf/protoc-gen-go
go get -u -v github.com/golang/protobuf/protoc-gen-go
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2 profobuf语法及使用

①语法

person.proto

syntax = "proto3"; 						//指定版本信息，不指定会报错
package pb;						//后期生成go文件的包名

option go_package = "./;proto"; //配置包依赖路径
//message为关键字，作用为定义一种消息类型
message Person {
  string	name = 1;					//姓名
  int32	age = 2;					//年龄
  repeated string emails = 3; 		//电子邮件（repeated表示字段允许重复）【类比go中的切片】
  repeated PhoneNumber phones = 4;	//手机号
}

//enum为关键字，作用为定义一种枚举类型
enum PhoneType {
  MOBILE = 0;
  HOME = 1;
  WORK = 2;
}

//message为关键字，作用为定义一种消息类型可以被另外的消息类型嵌套使用
message PhoneNumber {
  string number = 1;
  PhoneType type = 2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

②使用步骤

• 定义一个go的与protobuf对应的结构体
• proto.Marshal进行编码序列化，得到二进制数据data
• 将data进行传输，或者发送给对方
• 对方收到data数据，将data通过proto.UnMarshal得到person结构体数据

1. 编写.proto文件

2. 执行protoc编译出对应go代码

通过如下方式调用protocol编译器，把 .proto 文件编译成代码

 protoc --proto_path=IMPORT_PATH --go_out=DST_DIR path/to/file.proto
1

其中：

1. –proto_path，指定了 .proto 文件导包时的路径，可以有多个，如果忽略则默认当前目录。
2. –go_out， 指定了生成的go语言代码文件放入的文件夹
3. 允许使用protoc --go_out=./ *.proto的方式一次性编译多个 .proto 文件 【.proto中需要添加option go_package选项】，否则会报：protoc-gen-go: unable to determine Go import path for “xxx.proto”

option go_package = "./;proto"; //配置包依赖路径
1

4. 编译时，protobuf 编译器会把 .proto 文件编译成 .pd.go 文件
   

3. 通过proto.Marshal进行序列化（发数据）

data, err := proto2.Marshal(person)
1

4. 通过proto.UnMarshal进行反序列话（收数据）

err = proto2.Unmarshal(data, &newPerson)
1

③测试传输

在myDemo/protobuf文件夹下编写main.go进行测试

main.go

package main

import (
	"fmt"
	proto2 "google.golang.org/protobuf/proto"
	pb "myTest/myDemo/protobuf/pb"
)

func main() {
	person := &pb.Person{
		Name:   "ziyi",
		Age:    18,
		Emails: []string{"ziyi.atgmai.com", "ziyi_at163.com"},
		Phones: []*pb.PhoneNumber{
			&pb.PhoneNumber{
				Number: "181234567",
				Type:   pb.PhoneType_MOBILE,
			},
			&pb.PhoneNumber{
				Number: "33331111",
				Type:   pb.PhoneType_HOME,
			},
		},
	}
	//编码：将person对象编码，将protobuf的message进行序列化，得到一个[]byte数组
	data, err := proto2.Marshal(person)
	if err != nil {
		fmt.Println("protobuf marshal err =", err)
		return
	}
	//解码
	newPerson := pb.Person{}
	err = proto2.Unmarshal(data, &newPerson)
	if err != nil {
		fmt.Println("protobuf unmarshal err =", err)
		return
	}
	fmt.Println("传输的数据：", person)
	fmt.Println("接收到的数据：", &newPerson)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

3 游戏相关业务

3.1 业务消息格式定义

MsgID：1（同步玩家本地登录ID）

1. MsgID:1

• 同步玩家本地登录的ID（用来标识玩家），玩家登录之后，由Server端主动生成玩家ID发送给客户端
• 发起者：Server
• Pid：玩家ID

对应proto：

message SyncPid{
	int32 Pid=1;
}
1
2
3

MsgID：2（世界聊天）

● 同步玩家本次登录的ID(用来标识玩家), 玩家登陆之后，由Server端主动生成玩家ID发送给客户端
● 发起者： Client
● Content: 聊天信息

message Talk{
	string Content=1;
}
1
2
3

MsgID：3（移动信息）

● 移动的坐标数据
● 发起者： Client
● P: Position类型，地图的左边点

message Position{
	float X=1;
	float Y=2;
	float Z=3;
	float V=4;
}
1
2
3
4
5
6

MsgID：200（广播聊天、坐标、动作）

● 广播消息
● 发起者： Server
● Tp: 1 世界聊天, 2 坐标, 3 动作, 4 移动之后坐标信息更新
● Pid: 玩家ID

message BroadCast{
	int32 Pid=1;
	int32 Tp=2;
	//oneof表示只能选三个中的一个
	oneof Data {
        string Content=3;
        Position P=4;
		int32 ActionData=5;
    }
}
1
2
3
4
5
6
7
8
9
10

MsgID：201

● 广播消息 掉线/aoi消失在视野
● 发起者： Server
● Pid: 玩家ID

message SyncPid{
	int32 Pid=1;
}
1
2
3

MsgID：202（同步位置信息）

● 同步周围的人位置信息(包括自己)
● 发起者： Server
● ps: Player 集合,需要同步的玩家

message SyncPlayers{
	repeated Player ps=1;
}

message Player{
	int32 Pid=1;
	Position P=2;
}
1
2
3
4
5
6
7
8

3.2 项目模块搭建

mmo_game_zinx

• apis:存放基本用户的自定义路由业务，一个msgId对应一个业务
• conf：存放zinx.json（自定义框架的配置文件）
• pb：protobuf相关文件
• core：存放核心功能
• main.go:服务器的主入口
• game_client:unity客户端

最终项目结构

.
└── mmo_game_zinx
    ├── apis
    ├── conf
    │   └── zinx.json
    ├── core
    │   ├── aoi.go
    │   ├── aoi_test.go
    │   ├── grid.go
    ├── game_client
    │   └── client.exe
    ├── pb
    │   ├── build.sh
    │   └── msg.proto
    ├── README.md
    └── server.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

①玩家上线

• 创建一个玩家的方法：

1. 编写proto文件
2. 定义玩家对象player.go

• 玩家可以和客户端通信的发送消息的方法：

1. 将msg的proto格式进行序列化改成二进制
2. 通过zinx框架提供的sendMsg将数据进行TLV格式的打包发包

• 实现上线业务功能：

1. 给server注册一个创建连接之后的hook函数
2. 给Player提供两个方法：将PlayerID同步给客户端、将Player上线的初始位置同步给客户端

1. mmo_game_zinx/pb/msg.proto

定义proto文件（消息类型）

syntax = "proto3";                //Proto协议
package pb;                     //当前包名
option csharp_namespace = "Pb";   //给C#提供的选项[因为我们的游戏画面采用unity3D，基于C#的]
option go_package = "./;pb"; //配置包依赖路径

//同步客户端玩家ID
message SyncPid{
  int32 Pid=1;
}

//玩家位置
message Position{
  float X=1;
  float Y=2;
  float Z=3;
  float V=4;
}

//玩家广播数据
message BroadCast{
  int32 Pid=1;
  int32 Tp=2;//1 世界聊天, 2 坐标, 3 动作, 4 移动之后坐标信息更新
  oneof Data {
    string Content=3;
    Position P=4;
    int32 ActionData=5;
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

为了方便后续更新proto文件，我们这里直接编写一个脚本

mmo_game_zinx/pb/build.sh:

#!/bin/bash
protoc --go_out=. *.proto
1
2

2. mmo_game_zinx/core/player.go

package core

import (
	"fmt"
	"google.golang.org/protobuf/proto"
	"math/rand"
	pb "myTest/mmo_game_zinx/pb"
	"myTest/zinx/ziface"
	"sync"
)

// 玩家
type Player struct {
	Pid  int32              //玩家ID
	Conn ziface.IConnection //当前玩家的连接（用于和客户端的连接）
	X    float32            //平面的X坐标
	Y    float32            //高度
	Z    float32            //平面y坐标（注意：Z字段才是玩家的平面y坐标，因为unity的客户端已经定义好了）
	V    float32            //旋转的0-360角度
}

var PidGen int32 = 1  //用于生成玩家id
var IdLock sync.Mutex //保护PidGen的锁

func NewPlayer(conn ziface.IConnection) *Player {
	IdLock.Lock()
	id := PidGen
	PidGen++
	IdLock.Unlock()

	p := &Player{
		Pid:  id,
		Conn: conn,
		X:    float32(160 + rand.Intn(10)), //随机在160坐标点，基于X轴若干便宜
		Y:    0,
		Z:    float32(140 + rand.Intn(20)), //随机在140坐标点，基于Y轴若干偏移
		V:    0,
	}
	return p
}

/*
提供一个发送给客户端消息的方法
主要是将pb的protobuf数据序列化后，再调用zinx的sendMsg方法
*/
func (p *Player) SendMsg(msgId uint32, data proto.Message) {
	//将proto Message结构体序列化 转换成二进制
	msg, err := proto.Marshal(data)
	if err != nil {
		fmt.Println("marshal msg err: ", err)
		return
	}
	//将二进制文件 通过zinx框架的sendMsg将数据发送给客户端
	if p.Conn == nil {
		fmt.Println("connection in player is nil")
		return
	}
	if err := p.Conn.SendMsg(msgId, msg); err != nil {
		fmt.Println("player send msg is err, ", err)
		return
	}
}

// 告知客户端玩家的pid，同步已经生成的玩家ID给客户端
func (p *Player) SyncPid() {
	//组件MsgID：0的proto数据
	proto_msg := &pb.SyncPid{
		Pid: p.Pid,
	}
	//将消息发送给客户端
	p.SendMsg(1, proto_msg)
}

// 广播玩家自己的出生地点
func (p *Player) BroadCastStartPosition() {
	//组建MsgID：200 的proto数据
	proto_msg := &pb.BroadCast{
		Pid: p.Pid,
		Tp:  2, //Tp2 代表广播位置的坐标
		Data: &pb.BroadCast_P{
			P: &pb.Position{
				X: p.X,
				Y: p.Y,
				Z: p.Z,
				V: p.V,
			},
		},
	}
	//将消息发送给客户端
	p.SendMsg(200, proto_msg)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

3. mmo_game_zinx/main.go

package main

import (
	"fmt"
	"myTest/mmo_game_zinx/core"
	"myTest/zinx/ziface"
	"myTest/zinx/znet"
)

// 当前客户端建立连接之后的hook函数
func OnConnectionAdd(conn ziface.IConnection) {
	//创建一个player对象
	player := core.NewPlayer(conn)
	//给客户端发送MsgID：1的消息，同步当前的playerID给客户端
	player.SyncPid()
	//给客户端发送MsgID：200的消息，同步当前Player的初始位置给客户端
	player.BroadCastStartPosition()
	fmt.Println("======>Player pid = ", player.Pid, " is arrived ====")
}

func main() {
	//创建服务句柄
	s := znet.NewServer("MMO Game Zinx")
	s.SetOnConnStart(OnConnectionAdd)
	s.Serve()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

测试效果

1. 启动服务端
2. 启动客户端（client.exe）
   

连续启动多个查看效果：

服务端控制台打印：

②世界聊天

1. proto3聊天协议的定义
2. 聊天业务的实现：

• 解析聊天的proto协议
• 将聊天数据广播给全部在线玩家->创建一个世界管理模块
  - 初始化管理模块
  - 添加一个玩家
  - 删除一个玩家
  - 通过玩家ID查询Player对象
  - 获取全部的在线玩家

1. mmo_game_zinx/pb/msg.proto

在之前的基础上，在末尾追加：

message Talk{
  string Content=1;
}
1
2
3

执行build.sh脚本重新编译

2. mmo_game_zinx/apis/world_chat.go

package apis

import (
	"fmt"
	"google.golang.org/protobuf/proto"
	"myTest/mmo_game_zinx/core"
	pb "myTest/mmo_game_zinx/pb"
	"myTest/zinx/ziface"
	"myTest/zinx/znet"
)

// 世界聊天路由业务
type WorldChatApi struct {
	znet.BaseRouter
}

// 重写handler方法
func (wc *WorldChatApi) Handler(request ziface.IRequest) {
	//1 解析客户端传递进来的proto协议
	proto_msg := &pb.Talk{}
	err := proto.Unmarshal(request.GetData(), proto_msg)
	if err != nil {
		fmt.Println("Talk Unmarshal err ", err)
		return
	}
	//2 当前的聊天数据 属于哪个玩家发送的
	pid, err := request.GetConnection().GetProperty("pid")
	//3 根据pid得到对应的player对象
	player := core.WorldMgrObj.GetPlayerByPid(pid.(int32))
	//4 将这个消息广播给其他全部在线的用户
	player.Talk(proto_msg.Content)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

3. mmo_game_zinx/main.go

package main

import (
	"fmt"
	"myTest/mmo_game_zinx/apis"
	"myTest/mmo_game_zinx/core"
	"myTest/zinx/ziface"
	"myTest/zinx/znet"
)

// 当前客户端建立连接之后的hook函数
func OnConnectionAdd(conn ziface.IConnection) {
	//创建一个player对象
	player := core.NewPlayer(conn)
	//给客户端发送MsgID：1的消息，同步当前的playerID给客户端
	player.SyncPid()
	//给客户端发送MsgID：200的消息，同步当前Player的初始位置给客户端
	player.BroadCastStartPosition()
	//将当前新上线的玩家添加到WorldManager中
	core.WorldMgrObj.AddPlayer(player)
	//将playerId添加到连接属性中，方便后续广播知道是哪个玩家发送的消息
	conn.SetProperty("pid", player.Pid)
	fmt.Println("======>Player pid = ", player.Pid, " is arrived ====")
}

func main() {
	//创建服务句柄
	s := znet.NewServer("MMO Game Zinx")
	s.SetOnConnStart(OnConnectionAdd)
	//注册一些路由业务
	s.AddRouter(2, &apis.WorldChatApi{})
	s.Serve()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

4. mmo_game_zinx/core/world_manager.go

package core

import "sync"

/*
当前游戏的世界总管理模块
*/
type WorldManager struct {
	//AOIManager 当前世界地图AOI的管理模块
	AoiMgr *AOIManager
	//当前全部在线的players集合
	Players map[int32]*Player
	//保护Players集合的锁
	pLock sync.RWMutex
}

// 提供一个对外的世界管理模块的句柄
var WorldMgrObj *WorldManager

func init() {
	WorldMgrObj = &WorldManager{
		//创建世界AOI地图规划
		AoiMgr: NewAOIManager(AOI_MIN_X, AOI_MAX_X, AOI_CNTS_X, AOI_MIN_Y, AOI_MAX_Y, AOI_CNTS_Y),
		//初始化player集合
		Players: make(map[int32]*Player),
	}
}

// 添加一个玩家
func (wm *WorldManager) AddPlayer(player *Player) {
	wm.pLock.Lock()
	wm.Players[player.Pid] = player
	wm.pLock.Unlock()
	//将player添加到AOIManager中
	wm.AoiMgr.AddToGridByPos(int(player.Pid), player.X, player.Z)
}

// 删除一个玩家
func (wm *WorldManager) RemovePlayerByPid(pid int32) {
	//得到当前的玩家
	player := wm.Players[pid]
	//将玩家从AOIManager中删除
	wm.AoiMgr.RemoveFromGridByPos(int(pid), player.X, player.Z)
	//将玩家从世界管理中删除
	wm.pLock.Lock()
	delete(wm.Players, pid)
	wm.pLock.Unlock()
}

// 通过玩家ID查询player对象
func (wm *WorldManager) GetPlayerByPid(pid int32) *Player {
	wm.pLock.RLock()
	defer wm.pLock.RUnlock()
	return wm.Players[pid]
}

// 获取全部的在线玩家
func (wm *WorldManager) GetAllPlayers() []*Player {
	wm.pLock.Lock()
	defer wm.pLock.Unlock()
	players := make([]*Player, 0)
	//遍历集合，将玩家添加到players切片中
	for _, p := range wm.Players {
		players = append(players, p)
	}
	return players
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

5. mmo_game_zinx/core/player.go

package core

import (
	"fmt"
	"google.golang.org/protobuf/proto"
	"math/rand"
	pb "myTest/mmo_game_zinx/pb"
	"myTest/zinx/ziface"
	"sync"
)

// 玩家
type Player struct {
	Pid  int32              //玩家ID
	Conn ziface.IConnection //当前玩家的连接（用于和客户端的连接）
	X    float32            //平面的X坐标
	Y    float32            //高度
	Z    float32            //平面y坐标（注意：Z字段才是玩家的平面y坐标，因为unity的客户端已经定义好了）
	V    float32            //旋转的0-360角度
}

var PidGen int32 = 1  //用于生成玩家id
var IdLock sync.Mutex //保护PidGen的锁

func NewPlayer(conn ziface.IConnection) *Player {
	IdLock.Lock()
	id := PidGen
	PidGen++
	IdLock.Unlock()

	p := &Player{
		Pid:  id,
		Conn: conn,
		X:    float32(160 + rand.Intn(10)), //随机在160坐标点，基于X轴若干便宜
		Y:    0,
		Z:    float32(140 + rand.Intn(20)), //随机在140坐标点，基于Y轴若干偏移
		V:    0,
	}
	return p
}

/*
提供一个发送给客户端消息的方法
主要是将pb的protobuf数据序列化后，再调用zinx的sendMsg方法
*/
func (p *Player) SendMsg(msgId uint32, data proto.Message) {
	//将proto Message结构体序列化 转换成二进制
	msg, err := proto.Marshal(data)
	if err != nil {
		fmt.Println("marshal msg err: ", err)
		return
	}
	//将二进制文件 通过zinx框架的sendMsg将数据发送给客户端
	if p.Conn == nil {
		fmt.Println("connection in player is nil")
		return
	}
	if err := p.Conn.SendMsg(msgId, msg); err != nil {
		fmt.Println("player send msg is err, ", err)
		return
	}
}

// 告知客户端玩家的pid，同步已经生成的玩家ID给客户端
func (p *Player) SyncPid() {
	//组件MsgID：0的proto数据
	proto_msg := &pb.SyncPid{
		Pid: p.Pid,
	}
	//将消息发送给客户端
	p.SendMsg(1, proto_msg)
}

// 广播玩家自己的出生地点
func (p *Player) BroadCastStartPosition() {
	//组建MsgID：200 的proto数据
	proto_msg := &pb.BroadCast{
		Pid: p.Pid,
		Tp:  2, //Tp2 代表广播位置的坐标
		Data: &pb.BroadCast_P{
			P: &pb.Position{
				X: p.X,
				Y: p.Y,
				Z: p.Z,
				V: p.V,
			},
		},
	}
	//将消息发送给客户端
	p.SendMsg(200, proto_msg)
}

// 玩家广播世界聊天消息
func (p *Player) Talk(content string) {
	//1 组建MsgID：200 proto数据
	proto_msg := &pb.BroadCast{
		Pid: p.Pid,
		Tp:  1, //tp-1 代表聊天广播
		Data: &pb.BroadCast_Content{
			Content: content,
		},
	}
	//2 得到当前世界所有在线的玩家
	players := WorldMgrObj.GetAllPlayers()
	for _, player := range players {
		//player分别给对应的客户端发送消息
		player.SendMsg(200, proto_msg)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

测试效果

启动服务