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

这篇具有很好参考价值的文章主要介绍了从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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

MMO(MassiveMultiplayerOnlineGame):大型多人在线游戏(多人在线网游)

1 AOI兴趣点的算法

游戏中的坐标模型:

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程
场景相关数值计算

● 场景大小: 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 AOI管理模块

AOIManager:

  • 初始化一个AOI管理区域模块
  • 得到每个格子在X轴方向的宽度
  • 通过横纵轴得到GID
  • 添加一个PlayerId到一个格子中
  • 移除一个格子中的playerId
  • 通过GID获取全部的PlayerID
  • 通过坐标将Player添加到一个格子中
  • 通过坐标把一个Player从一个格子中删除
  • 通过Player坐标得到当前Player周边九宫格内全部的PlayerIDs
  • 通过坐标获取对应玩家所在的GID
  • 通过横纵轴得到周围的九宫格
  • 根据GID获取GID周围的九宫格
    从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程
    • 获取思路:先求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)
}

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)
	}
}

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

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;
}
②使用步骤
  • 定义一个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. –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"; //配置包依赖路径

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

  1. 编译时,protobuf 编译器会把 .proto 文件编译成 .pd.go 文件
    从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程
3. 通过proto.Marshal进行序列化(发数据)
data, err := proto2.Marshal(person)
4. 通过proto.UnMarshal进行反序列话(收数据)
err = proto2.Unmarshal(data, &newPerson)
③测试传输

在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)
}

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

3 游戏相关业务

3.1 业务消息格式定义

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

MsgID:1(同步玩家本地登录ID)
  1. MsgID:1
  • 同步玩家本地登录的ID(用来标识玩家),玩家登录之后,由Server端主动生成玩家ID发送给客户端
  • 发起者:Server
  • Pid:玩家ID

对应proto:

message SyncPid{
	int32 Pid=1;
}
MsgID:2(世界聊天)

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

message Talk{
	string Content=1;
}
MsgID:3(移动信息)

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

message Position{
	float X=1;
	float Y=2;
	float Z=3;
	float V=4;
}
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;
    }
}
MsgID:201

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

message SyncPid{
	int32 Pid=1;
}
MsgID:202(同步位置信息)

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

message SyncPlayers{
	repeated Player ps=1;
}

message Player{
	int32 Pid=1;
	Position P=2;
}

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

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

①玩家上线

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

  • 创建一个玩家的方法:
  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;
  }
}

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

mmo_game_zinx/pb/build.sh:

#!/bin/bash
protoc --go_out=. *.proto
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)
}
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. 启动客户端(client.exe)
    从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

连续启动多个查看效果:

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程
服务端控制台打印:
从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

②世界聊天

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

  1. proto3聊天协议的定义
  2. 聊天业务的实现:
  • 解析聊天的proto协议
  • 将聊天数据广播给全部在线玩家->创建一个世界管理模块
    - 初始化管理模块
    - 添加一个玩家
    - 删除一个玩家
    - 通过玩家ID查询Player对象
    - 获取全部的在线玩家
1. mmo_game_zinx/pb/msg.proto

在之前的基础上,在末尾追加:

message Talk{
  string Content=1;
}

执行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)
}
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()
}
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
}
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)
	}
}
测试效果

从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】,go,框架,golang,tcp/ip,游戏开发,框架实战,教程

启动服务文章来源地址https://www.toymoban.com/news/detail-635331.html

到了这里,关于从0到1开发go-tcp框架【4实战片— — 开发MMO之玩家聊天篇】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 从零开始手写mmo游戏从框架到爆炸(十三)— 地图与野怪模板

             导航:从零开始手写mmo游戏从框架到爆炸(零)—— 导航-CSDN博客           首先祝大家龙年大吉,大吉大利,财源滚滚,事事如意!          角色有了,那么基本的功能应该包括选择地图,打怪,掉落装备,升级等等,我们一一来完成。首先我们设计野怪

    2024年02月19日
    浏览(40)
  • [golang 微服务] 7. go-micro框架介绍,go-micro脚手架,go-micro结合consul搭建微服务案例

    上一节讲解了 GRPC微服务集群 + Consul集群 + grpc-consul-resolver 相关的案例,知道了微服务之间通信采用的 通信协议 ,如何实现 服务的注册和发现 ,搭建 服务管理集群 ,以及服务与服务之间的 RPC通信方式 ,具体的内容包括: protobuf协议 , consul 及 docker部署consul集群 , GRPC框架 的

    2024年02月09日
    浏览(37)
  • 100天精通Golang(基础入门篇)——第23天:错误处理的艺术: Go语言实战指南

    🌷🍁 博主猫头虎🐅🐾 带您进入 Golang 语言的新世界✨✨🍁 🦄 博客首页 ——🐅🐾猫头虎的博客🎐 🐳 《面试题大全专栏》 🦕 文章图文并茂🦖生动形象🐅简单易学!欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍专栏》 🐾 学会IDEA常用操作,工作效率翻倍~💐 🌊 《100天精通

    2024年02月07日
    浏览(64)
  • 【Golang】go编程语言适合哪些项目开发?

    前言 在当今数字化时代,软件开发已成为各行各业的核心需求之一。 而选择适合的编程语言对于项目的成功开发至关重要。 本文将重点探讨Go编程语言适合哪些项目开发,以帮助读者在选择合适的编程语言时做出明智的决策。 Go 编程语言适合哪些项目开发? Go是由Google开发

    2024年02月04日
    浏览(76)
  • 【WebSocket项目实战】聊天室(前端vue3、后端spring框架)

    最近我学习了WebSocket,为了更好地掌握这一技术,我决定通过做一个项目来巩固学习成果。在这个项目中,我将使用JavaScript和WebSocket来实现实时通信,让客户端和服务器端能够实时地传递和接收数据。通过这个项目,我希望能够更深入地了解WebSocket的工作原理,并且能够在实

    2024年02月04日
    浏览(47)
  • 计算机网络 TCP/UDP程序开发网络聊天室

    TCP/UDP程序开发 开发TCP/UDP协议应用程序,掌握网络应用程序的工作原理。通过该实验,深入理解UDP和TCP协议的异同点,了解网络协议的工作过程,学会网络通信编程的基本方法,能够编制网络应用程序。 (1)了解和掌握“基于UDP-面向无连接的应用程序/基于TCP-面向连接的

    2024年02月05日
    浏览(86)
  • Go语言实战:网络编程与TCP_UDP

    Go语言是一种现代的编程语言,由Google的Robert Griesemer、Rob Pike和Ken Thompson于2009年开发。Go语言的设计目标是简单、高效、可扩展和易于使用。它具有垃圾回收、类型安全、并发性能等优点。Go语言的网络编程库 net 包提供了TCP/UDP的实现,使得开发者可以轻松地编写网络应用程序

    2024年02月21日
    浏览(60)
  • 【Golang】VsCode下开发Go语言的环境配置(超详细图文详解)

    📓推荐网站(不断完善中):个人博客 📌个人主页:个人主页 👉相关专栏:CSDN专栏、个人专栏 🏝立志赚钱,干活想躺,瞎分享的摸鱼工程师一枚 ​ 话说在前,Go语言的编码方式是 UTF-8 ,理论上你直接使用文本进行编辑也是可以的,当然为了提升我们的开发效率我们还是需

    2024年02月07日
    浏览(83)
  • 【Golang项目实战】用Go写一个学生信息管理系统,真的太酷啦| 保姆级详解,附源码——建议收藏

    博主简介: 努力学习的大一在校计算机专业学生,热爱学习和创作。目前在学习和分享:数据结构、Go,Java等相关知识。 博主主页: @是瑶瑶子啦 所属专栏: Go语言核心编程 近期目标: 写好专栏的每一篇文章 学习了Go的基础语法知识,如何巩固和提升呢?跟着瑶瑶子写一个

    2024年02月02日
    浏览(53)
  • Golang个人web框架开发-学习流程

    github地址:ameamezhou/golang-web-frame 后续还将继续学习更新 设置免密登录 ssh-keygen 一路回车就OK 上面有告诉你密钥生成地址 红框为需要上传的公钥 首先明确目标– 我们学习开发web框架的目的是 : 在日常的web开发中,我们经常要使用到web框架, python 就有很多好用的框架,比如

    2024年01月19日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包