go-tcp フレームワークを 0 から 1 まで開発する [実践映像 - 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 グリッド (グリッド) を定義する

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管理モジュール

AOIMマネージャー：

AOI管理領域モジュールの初期化

各グリッドのX軸方向の幅を取得します

横軸と縦軸から GID を取得します。

PlayerId をグリッドに追加する

グリッドから playerId を削除する

GID ごとにすべての PlayerID を取得する

座標によってプレーヤーをグリッドに追加します

座標によってグリッドからプレーヤーを削除します

プレーヤー座標を通じて、現在のプレーヤーを中心とする九公歌内のすべてのプレーヤー ID を取得します。

プレイヤーに対応する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)
}

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

json: 読みやすくなり、エンコードとデコードに時間がかかる [Web フィールド]

XML: タグに基づく [フロントエンド/Web ページ]

protobuf (Google 開発): 高速エンコードとデコード、小さいサイズ、クロスプラットフォーム、あまり読みにくく、送信中はプレーンテキストではないが、バイナリ (すでにシリアル化されている) [バックエンドアプリケーション/マイクロサービス/サーバー]

2.1 インストール

ここでは Mac のインストールを例に挙げますが、他の OS は Baidu で実行できます。

# 安装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 の構文と使用法

①文法

人物.プロト

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

②ステップを利用する

protobufに対応するgo構造体を定義する

proto.Marshal はバイナリデータデータを取得するためにエンコードおよびシリアル化します。

データを転送したり、相手に送信したりする

相手はデータを受け取り、データを渡してproto.UnMarshalを通じて人物構造データを取得します。

1. .proto ファイルを書き込みます

2. protoc を実行して、対応する go コードをコンパイルします。

次のようにプロトコルコンパイラを呼び出して、.proto ファイルをコードにコンパイルします。

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

の：

–proto_path は、パッケージをインポートするときの .proto ファイルのパスを指定します。省略した場合は、デフォルトの現在のディレクトリが複数存在する可能性があります。
–go_out、生成された Go 言語コードファイルが配置されるフォルダーを指定します
protoc --go_out=./ *.proto を使用して複数の .proto ファイルを一度にコンパイルすることができます [オプション go_package オプションを .proto に追加する必要があります]。それ以外の場合は、次のようにレポートされます: protoc-gen-go: unavailable 「xxx.proto」の Go インポートパスを決定します

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

ここに画像の説明を挿入

コンパイル時に、protobuf コンパイラーは .proto ファイルを .pd.go ファイルにコンパイルします。

3. proto.Marshal を介してシリアル化 (データ送信)

data, err := proto2.Marshal(person)

4. proto.UnMarshal を使用してセッションを逆シリアル化します (データを受信します)。

err = proto2.Unmarshal(data, &newPerson)

③テスト送信

テスト用に myDemo/protobuf フォルダーに 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)
}

ここに画像の説明を挿入

3 ゲーム関連事業

3.1 ビジネスメッセージフォーマット定義

ここに画像の説明を挿入

MsgID: 1 (プレーヤーのローカルログイン ID を同期します)

メッセージID: 1

プレーヤーのローカルログイン ID (プレーヤーを識別するために使用) を同期します。プレーヤーがログインすると、サーバーはプレーヤー ID をアクティブに生成し、クライアントに送信します。

イニシエーター: サーバー

PID: プレイヤーID

対応するプロトタイプ:

message SyncPid{
    
    
	int32 Pid=1;
}

MsgID: 2 (ワールドチャット)

● プレーヤーの現在のログイン ID (プレーヤーを識別するために使用) を同期します。プレーヤーがログインすると、サーバーはプレーヤー ID をアクティブに生成し、クライアントに送信します。 ● イニシエーター: クライアント ● コンテンツ:
チャット
情報

message Talk{
    
    
	string Content=1;
}

MsgID: 3 (モバイル情報)

● 移動座標データ
● イニシエータ: クライアント
● P: 位置タイプ、マップの左点

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

MsgID: 200 (ブロードキャストチャット、座標、アクション)

●ブロードキャストメッセージ
●イニシエータ：サーバー
●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;
    }
}

メッセージID：201

● ブロードキャストメッセージが切断される/aoi が表示されなくなる
● イニシエーター: サーバー
● Pid: プレーヤー ID

message SyncPid{
    
    
	int32 Pid=1;
}

MsgID: 202 (位置情報の同期)

● 周囲の人々 (自分自身を含む) の位置情報を同期します
● イニシエーター: サーバー
● ps: プレーヤーのコレクション、同期する必要があるプレーヤー

message SyncPlayers{
    
    
	repeated Player ps=1;
}

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

3.2 プロジェクトモジュールの構築

mmo_game_zinx

apis: 基本ユーザー向けのカスタムルーティングサービスを保存します。1 つの msgId が 1 つのサービスに対応します

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

ここに画像の説明を挿入

①プレイヤーがオンラインになる

ここに画像の説明を挿入

プレーヤーの作成方法:

プロトファイルの書き込み

プレーヤーオブジェクト player.go を定義します。

プレーヤーがクライアントと通信できるメッセージを送信する方法:

msg のプロト形式をバイナリにシリアル化します。

zinx フレームワークによって提供される sendMsg を介して TLV 形式でデータをパックして送信します

オンラインビジネス機能を実現します。

接続を作成した後、サーバーのフック関数を登録します

プレーヤーに 2 つのメソッドを提供します。プレーヤー ID をクライアントに同期する方法と、プレーヤーのオンラインの初期位置をクライアントに同期する方法です。

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

テスト効果

サーバーを起動します
クライアント(client.exe)を起動します。

複数の表示効果を連続して開始します。

ここに画像の説明を挿入
サーバーコンソールには次のように出力されます。

②ワールドチャット

ここに画像の説明を挿入

proto3 チャットプロトコルの定義

チャットサービスの実現：

チャットのプロトプロトコルを解析する

すべてのオンラインプレーヤーにチャットデータをブロードキャストする -> ワールド管理モジュールを作成する
- 管理モジュールを初期化する
- プレーヤーを追加する
- プレーヤーを削除する
- プレーヤー 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)
	}
}

テスト効果

ここに画像の説明を挿入

サービスを開始する

go-tcpフレームワークを0から1へ開発する【実戦映像4本 - MMOプレイヤーチャット記事開発】

go-tcp フレームワークを 0 から 1 まで開発する [実践映像 - MMO の開発]

1 AOI 関心ポイントのアルゴリズム

1.1 AOI グリッド (グリッド) を定義する

mmo_game_zinx/core/grid.go

1.2 AOI管理モジュール

mmo_game_zinx/core/aoi.go

mmo_game_zinx/core/aoi_test.go

2 データ転送プロトコル(protobuf)の選択

2.1 インストール

2.2 profobuf の構文と使用法

①文法

②ステップを利用する

1. .proto ファイルを書き込みます

2. protoc を実行して、対応する go コードをコンパイルします。

3. proto.Marshal を介してシリアル化 (データ送信)

4. proto.UnMarshal を使用してセッションを逆シリアル化します (データを受信します)。

③テスト送信

3 ゲーム関連事業

3.1 ビジネスメッセージフォーマット定義

MsgID: 1 (プレーヤーのローカルログイン ID を同期します)

MsgID: 2 (ワールドチャット)

MsgID: 3 (モバイル情報)

MsgID: 200 (ブロードキャストチャット、座標、アクション)

メッセージID：201

MsgID: 202 (位置情報の同期)

3.2 プロジェクトモジュールの構築

①プレイヤーがオンラインになる

1. mmo_game_zinx/pb/msg.proto

2. mmo_game_zinx/core/player.go

3. mmo_game_zinx/main.go

テスト効果

②ワールドチャット

1. mmo_game_zinx/pb/msg.proto

2. mmo_game_zinx/apis/world_chat.go

3. mmo_game_zinx/main.go

4. mmo_game_zinx/core/world_manager.go

5. mmo_game_zinx/core/player.go

テスト効果

おすすめ

go-tcpフレームワークを0から1へ開発する【実戦映像4本 - MMOプレイヤーチャット記事開発】

go-tcp フレームワークを 0 から 1 まで開発する [実践映像 - MMO の開発]

1 AOI 関心ポイントのアルゴリズム

1.1 AOI グリッド (グリッド) を定義する

mmo_game_zinx/core/grid.go

1.2 AOI管理モジュール

mmo_game_zinx/core/aoi.go

mmo_game_zinx/core/aoi_test.go

2 データ転送プロトコル(protobuf)の選択

2.1 インストール

2.2 profobuf の構文と使用法

①文法

②ステップを利用する

1. .proto ファイルを書き込みます

2. protoc を実行して、対応する go コードをコンパイルします。

3. proto.Marshal を介してシリアル化 (データ送信)

4. proto.UnMarshal を使用してセッションを逆シリアル化します (データを受信します)。

③テスト送信

3 ゲーム関連事業

3.1 ビジネスメッセージフォーマット定義

MsgID: 1 (プレーヤーのローカル ログイン ID を同期します)

MsgID: 2 (ワールドチャット)

MsgID: 3 (モバイル情報)

MsgID: 200 (ブロードキャストチャット、座標、アクション)

メッセージID：201

MsgID: 202 (位置情報の同期)

3.2 プロジェクトモジュールの構築

①プレイヤーがオンラインになる

1. mmo_game_zinx/pb/msg.proto

2. mmo_game_zinx/core/player.go

3. mmo_game_zinx/main.go

テスト効果

②ワールドチャット

1. mmo_game_zinx/pb/msg.proto

2. mmo_game_zinx/apis/world_chat.go

3. mmo_game_zinx/main.go

4. mmo_game_zinx/core/world_manager.go

5. mmo_game_zinx/core/player.go

テスト効果

おすすめ

MsgID: 1 (プレーヤーのローカルログイン ID を同期します)