14. 编译Xlua第三方库
14-1. 编译Xlua第三方库
通信协议：
- protobuf、sproto、pbc、pblua、json、cjson……用于服务器与客户端通信的数据格式
Xlua不带这些第三方库
需要把第三方库下载下来，编译，，，对于网络部分已经有现成的项目https://github.com/chexiongsheng/build_xlua_with_libs
查看Xlua文档添加第三库
public void Init()
{
//初始化虚拟机
LuaEnv = new LuaEnv();
//添加第三方库扩展
LuaEnv.AddBuildin("rapidjson", XLua.LuaDLL.Lua.LoadRapidJson);
//外部调用require时，会自动调用loader来获取文件
LuaEnv.AddLoader(Loader);
m_LuaScripts = new Dictionary<string, byte[]>();
#if UNITY_EDITOR
if (AppConst.GameMode == GameMode.EditorMode)
EditorLoadLuaScript();
else
#endif
LoadLuaScript();
}
然后使用Cmake安装
上面的第三方库的build文件夹中有CMakeList，里面有#Begin lua-rapidjson的字段，因此直接编译即可。
编译过程见博客。
https://blog.csdn.net/weixin_42264818/article/details/128116856
将编译好的dll放入Xlua项目的Asset/Plugins/x86_64路径下面，覆盖原有的xlua.dll
function Main()
print("hello main")
local rapidjson = require('rapidjson')
local t = rapidjson.decode('{"a":123}')--解码json字符串为table
print(t.a)
t.a = 456
local s = rapidjson.encode(t)--编码json字符串
print('json', s)
end
14-2. 网络客户端（C#）
需要完成：服务器连接、消息发送、消息接收、数据解析
创建Framework/Network/NetClient脚本
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using UnityEngine;
public class NetClient
{
private TcpClient m_Client;//基于TCP封装好的socket
private NetworkStream m_TcpStream;//可以从TCP里获取网络流
private const int BufferSize = 1024 * 64;//接收数据的大小
private byte[] m_Buffer = new byte[BufferSize];//接收数据的缓存区
private MemoryStream m_MemStream;//MemoryStream类用于向内存而不是磁盘读写数据
private BinaryReader m_BinaryReader;//用特定的编码将基元数据类型读作二进制值
//构造方法，实例化m_MemStream、m_BinaryReader
public NetClient()
{
m_MemStream = new MemoryStream();
m_BinaryReader = new BinaryReader(m_MemStream);
}
/// <summary>
/// 连接服务器
/// </summary>
/// <param name="host">ip地址</param>
/// <param name="port">端口号</param>
public void OnConnectServer(string host, int port)
{
try
{
IPAddress[] addresses = Dns.GetHostAddresses(host);
if (addresses.Length == 0)
{
Debug.LogError("host invalid");
return;
}
//判断地址族是ipv6还是ipv4
if (addresses[0].AddressFamily == AddressFamily.InterNetworkV6)
m_Client = new TcpClient(AddressFamily.InterNetworkV6);
else
m_Client = new TcpClient(AddressFamily.InterNetwork);
//判断好地址族后，设置参数
m_Client.SendTimeout = 1000;
m_Client.ReceiveTimeout = 1000;
m_Client.NoDelay = true;
//开始连接，连接成功发起异步回调OnConnect
m_Client.BeginConnect(host, port, OnConnect, null);
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
//连接成功后执行
private void OnConnect(IAsyncResult asyncResult)
{
//判断是否连接成功
if (m_Client == null || !m_Client.Connected)
{
Debug.LogError("Connect server error!");
return;
}
Manager.Net.OnNetConnected();
m_TcpStream = m_Client.GetStream();
//开始接收数据
m_TcpStream.BeginRead(m_Buffer, 0, BufferSize, OnRead, null);
}
//开始接收数据执行
private void OnRead(IAsyncResult asyncResult)
{
try
{
if (m_Client == null || m_TcpStream == null)
return;
//判断是否读取到了空消息,这个是有效字节数
int length = m_TcpStream.EndRead(asyncResult);
if (length < 1)
{
OnDisConnected();
return;
}
ReceiveData(length);//解析数据
lock (m_TcpStream)//还需要下一次接收数据，需要清空
{
Array.Clear(m_Buffer, 0, m_Buffer.Length);
m_TcpStream.BeginRead(m_Buffer, 0, BufferSize, OnRead, null);
}
}
catch (Exception e)
{
Debug.LogError(e.Message);
OnDisConnected();
}
}
/// <summary>
/// 解析数据
/// </summary>
private void ReceiveData(int len)
{
m_MemStream.Seek(0, SeekOrigin.End);//从末尾追加数据，因为前面可能有残余
m_MemStream.Write(m_Buffer, 0, len);//写数据
m_MemStream.Seek(0, SeekOrigin.Begin);//移动指针到前面开始读数据
//如果服务器有延迟等情况，发过来了很多条，需要通过While语句一条一条解析
//如果剩余字节数>8，说明消息是完整的，，，=8说明只要id和len没有消息内容是空消息
while (RemainingBytesLength() >= 8)
{
//定义了消息msgId和消息长度msgLen，，读两个int，指针往后走
int msgId = m_BinaryReader.ReadInt32();
int msgLen = m_BinaryReader.ReadInt32();
if (RemainingBytesLength() >= msgLen)//说明消息完整
{
byte[] data = m_BinaryReader.ReadBytes(msgLen);//读这么多个字节的消息
string message = System.Text.Encoding.UTF8.GetString(data);//从服务器读出来是json转成字符串
//转到lua
Manager.Net.Receive(msgId, message);
}
else//说明消息不完整或没有消息导致读取有问题，要把前面的id和len这8个字节还回去，然后break出去。
{
m_MemStream.Position = m_MemStream.Position - 8;
break;
}
}
//剩余字节，重新写入m_MemStream
byte[] leftover = m_BinaryReader.ReadBytes(RemainingBytesLength());
m_MemStream.SetLength(0);
m_MemStream.Write(leftover, 0, leftover.Length);
}
//剩余长度，字节数
private int RemainingBytesLength()
{
return (int)(m_MemStream.Length - m_MemStream.Position);
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="msgID">消息id</param>
/// <param name="message">json格式数据消息</param>
public void SendMessage(int msgID, string message)
{
using (MemoryStream ms = new MemoryStream())
{
ms.Position = 0;
BinaryWriter bw = new BinaryWriter(ms);
byte[] data = System.Text.Encoding.UTF8.GetBytes(message);
//协议id
bw.Write(msgID);
//消息长度
bw.Write((int)data.Length);
//消息内容
bw.Write(data);
bw.Flush();
if (m_Client != null && m_Client.Connected)
{
byte[] sendData = ms.ToArray();//把内存流的数据拿出来变为Byte发送出去
m_TcpStream.BeginWrite(sendData, 0, sendData.Length, OnEndSend, null);//发送
}
else
{
Debug.LogError("服务器未连接");
}
}
}
//结束发送
void OnEndSend(IAsyncResult ar)
{
try
{
m_TcpStream.EndWrite(ar);
}
catch (Exception ex)
{
OnDisConnected();
Debug.LogError(ex.Message);
}
}
//断开连接
public void OnDisConnected()
{
if (m_Client != null && m_Client.Connected)
{
m_Client.Close();
m_Client = null;
m_TcpStream.Close();
m_TcpStream = null;
}
Manager.Net.OnDisConnected();
}
}
创建Framework/Manager/NetManager脚本
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class NetManager : MonoBehaviour
{
private NetClient m_NetClient;//客户端
//消息队列，用来接收消息
private Queue<KeyValuePair<int, string>> m_MessageQueue = new Queue<KeyValuePair<int, string>>();
private XLua.LuaFunction ReceiveMessage;//接收的消息发给lua的方法
public void Init()
{
m_NetClient = new NetClient();
//因为要从lua获取这个方法，肯定要在lua完成初始化之后，而lua的初始化是start之后才初始化好
ReceiveMessage = Manager.Lua.LuaEnv.Global.Get<XLua.LuaFunction>("ReceiveMessage");
}
//发送消息
public void SendMessage(int messageId, string message)
{
m_NetClient.SendMessage(messageId,message);
}
//连接服务器
public void ConnectServer(string post, int port)
{
m_NetClient.OnConnectServer(post, port);
}
//下面两个可以自己添加逻辑，当连接到网络或者断开连接，执行逻辑
//网络连接
public void OnNetConnected()
{
}
//被服务器断开连接
public void OnDisConnected()
{
}
//接收数据
public void Receive(int msgId, string message)
{
//接收到的消息放到队列
m_MessageQueue.Enqueue(new KeyValuePair<int, string>(msgId, message));
}
private void Update()
{
if (m_MessageQueue.Count > 0)
{
KeyValuePair<int, string> msg = m_MessageQueue.Dequeue();
ReceiveMessage?.Call(msg.Key, msg.Value);
}
}
}
Manager中添加NetManager
private static NetManager _net;
public static NetManager Net
{
get { return _net; }
}
public void Awake()
{
_resource = this.gameObject.AddComponent<ResourceManager>();
_lua = this.gameObject.AddComponent<LuaManager>();
_ui = this.gameObject.AddComponent<UIManager>();
_entity = this.gameObject.AddComponent<EntityManager>();
_scene = this.gameObject.AddComponent<MySceneManager>();
_sound = this.gameObject.AddComponent<SoundManager>();
_event = this.gameObject.AddComponent<EventManager>();
_pool = this.gameObject.AddComponent<PoolManager>();
_net = this.gameObject.AddComponent<NetManager>();
}
14-3. 网络客户端（Lua）
- 功能模块化：消息注册、消息发送、消息接收
- 模块管理器：模块初始化、模块获取、消息接收、消息发送
不同的客户端都有类似的功能，需要在lua中将这些功能抽象出来，放进父类中。对于这么多模块，需要做一个模块管理器，将这些模块作为接口进行使用。同样这个模块管理器需要和C#进行交互
function Class(super)--super是传进来的父类
local class = nil;--实例都是table
--构建实例时有父类，那么实例必然有super，如果实例没有父类，实例就有一个构造函数ctor
if super then
class = setmetatable({}, {__index = super})--设置传入的父类为元表
class.super = super;
else
class = {ctor = function() end}--如果没有父类传进来，就直接构造一个新的表，只有一个构造函数ctor
end
class.__index = class--__index指向自己
--new的方法为了调用子类和父类的构造函数
function class.new(...)
local instance = setmetatable({}, class)
local function create(inst, ...)
--判断如果传进来的实例有没有父类，有父类就递归，知道没有父类了，用他自己的构造方法
if type(inst.super) == "table" then
create(inst.super, ...);
end
--判断如果构造函数ctor是个方法，就用构造方法
if type(inst.ctor) == "function" then
inst.ctor(instance, ...);
end
end
create(instance, ...);
return instance;
end
return class;
end
--这个是消息的父类
local base_msg = Class();--使用Class()创建了一个类
--消息注册方法，，，，添加请求和接收，，...是参数列表，需要向服务器发送的key，没有value
function base_msg:add_req_res(msg_name, msg_id, ...)
local keys = {...};
--Class本质是个table，self[]是相当于给这个table加了一个键值
--消息请求，，这个方法是发起request请求时调用的方法，传入一些参数
self["req_"..msg_name] = function(self, ...)
local values = {...};
if #keys ~= #values then
Log.Error("参数不正确：", msg_name);
end
local send_data = {};
--keys values一一对应上，然后发送
for i =1, #keys do
send_data[keys[i]] = values[i];
end
msg_mgr.send_msg(msg_id, send_data);--manager发送消息
end
--消息接收的注册，，，，必须要先写进message接收模块，这里是直接判断，没有定义
if type(self["res_".. msg_name]) == "function" then--如果定义了这个消息接收方法，就调用mgr注册进回调
msg_mgr.register(msg_id,
function(data)
local msg = Json.decode(data);--Json解析为table
--检查错误码
if msg.code ~= 0 then
Log.Error("错误码：", msg.code);
return;
end
self["res_"..msg_name](self, msg);--将信息传入这个消息接收方法（message注册的模块方法）
end)
else
Log.Error("请注册消息返回回调：".. msg_name);--有请求一定有接收
end
end
return base_msg;
Json = require('rapidjson')
Log = require('log')
local msg_mgr = {}
local msg_module_list = {} --模块的列表，存放所有模块
local msg_responses = {} --接收消息的回调的列表
--手动添加每个模块名字
local msg_name_list =
{
--"msg_test",
}
--遍历一下模块名字列表，require后new一下，将实例存到模块列表中
function msg_mgr.init()
for k,v in pairs(msg_name_list) do
msg_module_list[v] = require("message"..v).new()
end
end
--获取消息，，通过传入模块名字，获取模块
function msg_mgr.get_msg(key)
if not msg_module_list[key] then
Log.Error("脚本不存在："..key)
return
end
return msg_module_list[key]
end
--注册，也就是base_msg调用的register，收到消息时调用的回调方法
function msg_mgr.register(msg_id, func)
if msg_responses[msg_id] then
Log.Error("消息已注册："..msg_id)
return
end
msg_responses[msg_id] = func;
end
--接收消息
function ReceiveMessage(msg_id, message)--NetManager调用了，如果有消息传进来就调用
Log.Info("<color=#A0522D>receive:<<<<<<<<<<<<<<<<<<<<<<<<:id = "..msg_id.." : "..message.."</color>");
--如果定义了接收这个消息的方法
if type(msg_responses[msg_id]) == "function" then
msg_responses[msg_id](message)
else
Log.Error("此消息么有res: ", msg_id)
end
end
--发送消息
function msg_mgr.send_msg(msg_id, send_data)--base_msg调用，如果有消息请求，kv一致时，发送信息
local str = Json.encode(send_data)
Log.Info("<color=#9400D3>receive:>>>>>>>>>>>>>>>>>>>>>>>>:id = "..msg_id.." : "..str.."</color>");
Manager.Net:SendMessage(msg_id, str)
end
return msg_mgr;
因为测试的时候，需要打日志，用lua打断点不方便，如果删掉日志，真机包看不见不方便，
希望日志存在，正式环境不存在，通过一个开关控制，，，，因此Debug.log不行。需要自己封装打印日志的方法，并且可以输出打印lua的table的方法。
local Log = {}
local function read_table(tab,tab_count)
local function get_symbol(count)
local symol = "";
for i = 1,count do
symol = symol .. " ";
end
return symol;
end
local symbol = get_symbol(tab_count);
local str = "";
for k,v in pairs(tab) do
if type(v) == "table" then
str = str .. symbol .. k .. ":\n" .. symbol .."{\n"..read_table(v,tab_count + 1)..symbol.."}\n";
elseif type(v) == "userdata" then
str = str ..symbol .. k .. " = userdata,\n";
elseif type(v) == "function" then
str = str ..symbol .. k .. " = function,\n";
else
str = str ..symbol .. k .. " = " .. tostring(v)..",\n";
end
end
return str;
end
local function get_log_string(...)
local str = "";
local pram = {...};
for k,v in pairs(pram) do
if type(v) == "table" then
str = str .. "{\n".. read_table(v,1) .."}\n";
elseif type(v) == "function" then
str = str .. v .. "function,\n";
elseif type(v) == "userdata" then
str = str .. "userdata,\n";
else
str = str .. tostring(v) .. " ";
end
end
return str;
end
function Log.Info(...)
if not AppConst.OpenLog then
return
end
CS.Log.Info(get_log_string(...));
end
function Log.Warning(...)
if not AppConst.OpenLog then
return
end
CS.Log.Warning(get_log_string(...));
end
function Log.Error(...)
if not AppConst.OpenLog then
return
end
local str = get_log_string(...);
CS.Log.Error(str .. debug.traceback());
end
return Log;
还需要去Unity中添加一下调用，因为C#中有时候也要调用，，创建Framework/Util/Log
public static class Log
{
public static void Info(string msg)
{
if (!AppConst.OpenLog)
return;
Debug.Log(msg);
}
public static void Warning(string msg)
{
if (!AppConst.OpenLog)
return;
Debug.LogWarning(msg);
}
public static void Error(string msg)
{
if (!AppConst.OpenLog)
return;
Debug.LogError(msg);
}
}
public static bool OpenLog = true;
public class GameStart : MonoBehaviour
{
public bool OpenLog;
// Start is called before the first frame update
void Start()
{
AppConst.OpenLog = this.OpenLog;
}
}
14-4. 测试网络部分
修改main.bytes开始调用网络接口。
创建LuaScripts/message/msg_test.bytes脚本用于消息测试，同时msg_mgr中给msg_name_list添加模块名字
local msg_name_list =
{
"msg_test",
}
Manager = CS.Manager --引用C#里面定义的类
PathUtil = CS.PathUtil
Vector3 = CS.UnityEngine.Vector3
Input = CS.UnityEngine.Input
KeyCode = CS.UnityEngine.KeyCode
Time = CS.UnityEngine.Time
AppConst = CS.AppConst
Log = require('log')
Json = require('rapidjson')
require('class')
base_msg = require('message.base_msg')
msg_mgr = require('message.msg_mgr')
--定义UI层级
local ui_group =
{
"Main",
"UI",
"Box",
}
local entity_group =
{
"Player",
"Monster",
"Effect",
}
Manager.UI:SetUIGroup(ui_group)
Manager.Entity:SetEntityGroup(entity_group)
function Main()
msg_mgr.init();--加载所有message模块
Manager.Net:Init();--初始化TCP客户端
Manager.Net:ConnectServer("127.0.0.1", 8000);--连接网络
--连接网络ConnectServer调用的NetClient的OnConnectServer，设置端口
--在调用OnConnect中GetStream和BeginRead获取网络数据流，读取到数据调用OnRead，OnRead中有ReceiveData解析数据
--解析完继续BeginRead，获取后面的数据
--print("hello main")
Manager.UI:OpenUI("TestUI", "UI", "ui.TestUI")
--Manager.Scene:LoadScene("Test01","scene.Scene01")
end
--Main()
这是项目服务器
protocl是数据类型
修改TestUI
btn_pooltest:OnClickSet(
function()
--Manager.UI:OpenUI("Login/LoginUI", "UI", "ui.TestUI");
--发送消息请求
--main.bytes用msg_mgr:Init后，根据msg_name_list就require('msg_test').new()给msg_module_list赋值，require('msg_test')先执行Class(base_msg)
--Class(base_msg)返回一个class实例，此时msg_test = class实例，msg_test.super = base_msg，然后用require('msg_test').new()就是msg_test.new()
--new的时候创建了一个instance表，元表是msg_test，然后开始调用create(instance,...)，instance没有super去找msg_test.super，由于base_msg = Class()没有super父类，因此base_msg = {ctor = function() end}，不需要递归
--执行第二个if，instance的ctor是msg_test的ctor，msg_test脚本中创建了ctor，因此执行了构造方法。
--在ctor中执行add_req_res("first_test", 1000, "id", "user", "password", "listTest")
--add_req_res方法设置好了msg_test的req_first_test请求方法，然后判断res_first_test的响应回调是否已经定义，只有定义了响应回调，收到消息的时候才能ReceiveMessage执行时，响应回调
--运行最后面的req_first_test方法，方法内调用msg_mgr的send_msg，再调用Manager.Net:SendMessage向服务器发送消息
msg_mgr.get_msg("msg_test"):req_first_test(99999, "zhe1123", "******", {1,3,5});
end
)
btn_close:OnClickSet(
function()
--self:Close();
end
)