private void CheckState(MessageXieYi xieyi)
{
string messageInfo = SerializeHelper.ConvertToString(xieyi.MessageContent);
RoomActorUpdate roomActorUpdate = new RoomActorUpdate();
roomActorUpdate.SetSendInfo(messageInfo);
if (roomActorUpdate.userIndex == DataController.instance.MyLocateIndex)
{
RoomActorState state = (RoomActorState)int.Parse(roomActorUpdate.update);
Debug.Log("我的状态：" + state);
//判断我的状态为预准备
switch (state)
{
case RoomActorState.PrepareModel:
GameLoadingUI.Show();
//PrepareLocalModel();
break;
case RoomActorState.ModelPrepared:
break;
case RoomActorState.Invincible:
GameRunUI.instance.Open();
//MyJoystickManager.instance.Open();
break;
}
}
}
public void Update()
{
if (serverEvent.Count > 0)
{
MessageXieYi xieyi = serverEvent.Dequeue();
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.getRoomInfo)//房间信息
{
Have_RoomInfo();
}
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.getRoommateInfo)//房间中人物信息
{
Have_MateInfo();
}
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.prepareLocalModel)
{
RoomActorUpdate roomActorUpdate = new RoomActorUpdate();
roomActorUpdate.SetSendInfo(SerializeHelper.ConvertToString(xieyi.MessageContent));
if (allLoad.ContainsKey(roomActorUpdate.userIndex))
{
allLoad[roomActorUpdate.userIndex].UpdateSlider(int.Parse(roomActorUpdate.update));
}
else
{
Debug.LogError("在该UI未准备好的时候，收到了该用户的进度。");
}
}
}
}
/// <summary>
/// 广播消息逻辑
/// </summary>
/// <param name="convention">广播类型</param>
/// <param name="message">广播值</param>
/// <param name="uniqueID">除该用户以外都广播</param>
private void BoardcastMessage(MessageConvention convention, byte[] message, int uniqueID = -1, byte xieyiSecond = 0, ProtocolType netType = ProtocolType.Tcp)
{
MessageXieYi msgXY = new MessageXieYi((byte)convention, xieyiSecond, message);
for (int i = 0; i < ActorList.Count; i++)//逐个玩家遍历发送消息
{
if (ActorList[i].Register == null)
{
continue;
}
if (ActorList[i].CurState == RoomActorState.Offline)//离线玩家不发送
{
continue;
}
if (ActorList[i].UniqueID != uniqueID)
{
if (netType == ProtocolType.Tcp)
{
AsyncIOCPServer.instance.SendSave(UserTokenInfo[ActorList[i].UniqueID], msgXY.ToBytes());
}
else if (netType == ProtocolType.Udp)
{
if (udpUserInfo[i] == null)
{
Log4Debug("广播时，站位{0}用户udp未连接。" + i);
continue;
}
UdpServer.Instance.SendMessage(udpUserInfo[i].lastPoint, msgXY.ToBytes());
}
}
}
}
void Update()
{
if (
SocketManager.instance.MyUserToken != null &&
SocketManager.instance.MyUserToken.ConnectSocket.Connected == false
)
{
if (CurState != NetState.断线重连)
{
OffLine();
}
}
else
{
if (CurState == NetState.断线重连)
{
ChangeUIByState(NetState.显示UI);
}
}
if (serverEvent.Count > 0)
{
MessageXieYi xieyi = serverEvent.Dequeue();
for (int i = 0; i < messageHandle.Count; i++)
{
if ((MessageConvention)xieyi.XieYiFirstFlag == messageHandle[i])
{
ChangeUIByState(NetState.显示UI);
break;
}
}
}
}
public void Update()
{
if (serverEvent.Count > 0)
{
MessageXieYi xieyi = serverEvent.Dequeue();
}
}
/// <summary>
/// 向该用户广播该房间的人物模型准备数据
/// </summary>
public void GetRoommateNetData(int uniqueID, AsyncUserToken userToken)
{
byte[] message = null;
foreach (var item in ActorList)
{
MessageXieYi xieyi = null;
if (item.Value == null)
{
Log4Debug("检查，房间不该为空");
continue;
}
//准备数据发送完毕，打开UI
message = SerializeHelper.Serialize <GameModelData>(new GameModelData()
{
userIndex = item.Value.UniqueID,
pos = (NetVector3)GameTypeManager.BackStandPos(RoomInfo.RoomType, item.Value.UniqueID),
rotate = new NetVector3(0, GameTypeManager.BackLookAt(RoomInfo.RoomType, item.Value.UniqueID), 0),
animation = 0
});//此处是初始数据
xieyi = new MessageXieYi((byte)MessageConvention.updateModelInfo, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
}
//准备数据发送完毕，打开UI
message = new byte[] { 1 };//此处的数组应该是初始数据
MessageXieYi xieyiFinish = new MessageXieYi((byte)MessageConvention.getPreGameData, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyiFinish.ToBytes());
}
private byte[] SelectMessage(byte[] data, EndPoint endPoint)
{
byte[] backData = null;
try
{
MessageXieYi xieyi = MessageXieYi.FromBytes(data);
if (xieyi == null)
{
return(backData);
}
byte[] tempMessageContent = xieyi.MessageContent;
switch ((MessageConvention)xieyi.XieYiFirstFlag)
{
case MessageConvention.frameData:
DealFrameData(xieyi);
break;
}
//在数据处理后再执行委托响应脚本
lock (allHandle)
{
if (allHandle.ContainsKey((MessageConvention)xieyi.XieYiFirstFlag))
{
allHandle[(MessageConvention)xieyi.XieYiFirstFlag](xieyi);
}
}
}
catch
{
}
return(backData);
}
public void GetReConnectFrameData(int unique)
{
AsyncUserToken userToken = UserTokenInfo[unique];
int curFrame = FrameIndex;
byte[] message = null;
MessageXieYi xieyi = null;
xieyi = new MessageXieYi((byte)MessageConvention.reConnectIndex, 0, SerializeHelper.ConvertToByte(curFrame + ""));
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
Log4Debug("重连标记帧：" + curFrame);
//帧数据
int limetNum = 1800;
int count = curFrame / limetNum;
count += 1;
for (int i = 0; i < count; i++)
{
int min = i * limetNum;
int max = (i + 1) * limetNum + 1;//多加1帧
if (max > curFrame)
{
max = curFrame;
}
message = GetBoardFrame(min, max);
if (message == null)
{
Log4Debug("重连数据中有空数据->(" + min + "," + max + ")");
}
xieyi = new MessageXieYi((byte)MessageConvention.frameData, 0, message);
AsyncIOCPServer.instance.SendSave(userToken, xieyi.ToBytes());
Log4Debug("发送重连数据->(" + min + "," + max + ")");
}
}
public void ConnectedToServer()
{
//获取UdpClient的发送端口
//k_Socket = new KCPSocket(12345, 1, AddressFamily.InterNetwork);
//IPEndPoint localIpep = new IPEndPoint(IPAddress.Parse(Network.player.ipAddress), 12000);
IPEndPoint localIpep = new IPEndPoint(IPAddress.Any, 0);
remoteIpep = new IPEndPoint(IPAddress.Parse("192.168.1.110"), 12000);
kcpClient = new KCPPlayer();
//p2.Init("Player", IPAddress.Parse(Network.player.ipAddress), 12345, 12000);
kcpClient.Init(localIpep, remoteIpep, OnReceive);
UDPLogin login = new UDPLogin()
{
login = DataController.instance.UserID,
roomID = DataController.instance.MyRoomInfo.RoomID,
unique = DataController.instance.MyLocateIndex
};
byte[] message = SerializeHelper.Serialize <UDPLogin>(login);
//因为SendSave限制在断线重连时的重连，所以得绕过判断
MessageXieYi msgxy = new MessageXieYi((byte)MessageConvention.setUDP, 0, message);
byte[] sendBuffer = msgxy.ToBytes();
SendMessage(sendBuffer);
}
/// <summary>
/// byte[] 转换为 MessageXieYi
/// </summary>
/// <param name="buffer">字节数组缓冲器。</param>
/// <returns></returns>
public static MessageXieYi FromBytes(byte[] buffer)
{
int bufferLength = buffer.Length;
int limet = 2;
if (bufferLength < XieYiLength + limet)
{
return(null);
}
MessageXieYi messageXieYi = new MessageXieYi();
using (MemoryStream memoryStream = new MemoryStream(buffer)) //将字节数组填充至内存流
{
BinaryReader binaryReader = new BinaryReader(memoryStream); //以二进制读取器读取该流内容
byte start = binaryReader.ReadByte(); //把开头的标识符去掉
if (start != markStart)
{
Console.WriteLine("开头：" + start);
return(null);
}
messageXieYi.xieYiFirstFlag = binaryReader.ReadByte(); //读取协议一级标志，读1个字节
messageXieYi.xieYiSecondFlag = binaryReader.ReadByte(); //读取协议二级标志，读1个字节
messageXieYi.messageContentLength = binaryReader.ReadInt32(); //读取实际消息长度，读4个字节
//如果【进来的Bytes长度】大于【一个完整的MessageXieYi长度】
if ((bufferLength - 6) > messageXieYi.messageContentLength)
{
messageXieYi.messageContent = binaryReader.ReadBytes(messageXieYi.messageContentLength); //读取实际消息内容，从第7个字节开始读
//messageXieYi.duoYvBytes = binaryReader.ReadBytes(bufferLength - 6 - messageXieYi.messageContentLength);
}
//如果【进来的Bytes长度】等于【一个完整的MessageXieYi长度】
if ((bufferLength - 6) == messageXieYi.messageContentLength)
{
messageXieYi.messageContent = binaryReader.ReadBytes(messageXieYi.messageContentLength); //读取实际消息内容，从第7个字节开始读
}
//如果【进来的Bytes长度】小于【一个完整的MessageXieYi长度】
if ((bufferLength - 6) < messageXieYi.messageContentLength)
{
Console.WriteLine("数据接收不齐：" + (bufferLength - 6) + "/" + messageXieYi.messageContentLength);
return(null);
}
byte end = binaryReader.ReadByte();
if (end != markEnd)
{
Console.WriteLine("结尾：" + end + "消息长度：" + messageXieYi.messageContentLength);
return(null);
}
binaryReader.Close(); //关闭二进制读取器，是否资源
}
return(messageXieYi); //返回消息协议对象
}
public void DealFrameData(MessageXieYi xieyi)
{
try
{
byte[] tempMessageContent = xieyi.MessageContent;
List <FrameInfo> fInfos = null;
try
{
fInfos = SerializeHelper.Deserialize <List <FrameInfo> >(tempMessageContent);
}
catch (Exception e)
{
string frameError = "帧出错：" + e.Message + "：" + tempMessageContent.Length + "\n";
for (int i = 0; i < tempMessageContent.Length; i++)
{
frameError += tempMessageContent[i] + ",";
}
Debug.LogError(frameError);
UIManager.instance.ShowAlertTip(frameError);
return;
}
if (fInfos == null)
{
Debug.LogError("请检查，该逻辑不能为空。");
}
lock (GameManager.instance.FrameInfos)
{
for (int i = 0; i < fInfos.Count; i++)
{
FrameInfo fInfo = fInfos[i];
if (fInfo == null)
{
Debug.LogError("帧数据解析后有空值");
}
if (!GameManager.instance.FrameInfos.ContainsKey(fInfo.frameIndex))
{
GameManager.instance.FrameInfos.Add(fInfo.frameIndex, fInfo);
//Debug.Log("成功保存帧：" + fInfo.frameIndex);
if (GameManager.instance.frameMaxIndex < fInfo.frameIndex)
{
GameManager.instance.frameMaxIndex = fInfo.frameIndex;
}
}
else
{
//Debug.Log("重复保存帧数据：" + fInfo.frameIndex);
}
}
}
}
catch (Exception e)
{
}
}
private void DealReceive(MessageXieYi xieyi, AsyncUserToken userToken)
{
byte[] backInfo = ServerDataManager.instance.SelectMessage(xieyi, userToken); //判断逻辑
if (backInfo != null) //用户需要服务器返回值的话
{
//存储要发送的消息并判断是否发送
AsyncIOCPServer.instance.SaveSendMessage(userToken, backInfo);
}
}
public static ErrorType CheckIsError(MessageXieYi xieyi)
{
string message = SerializeHelper.ConvertToString(xieyi.MessageContent);
string[] sp = message.Split(new string[] { ErrorSplit }, StringSplitOptions.None);
if (sp.Length > 1)
{
return((ErrorType)int.Parse(sp[1]));
}
return(ErrorType.none);
}
public void Update()
{
if (serverEvent.Count > 0)
{
MessageXieYi xieyi = serverEvent.Dequeue();
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.getRoommateInfo)
{
ErrorType error = ClassGroup.CheckIsError(xieyi);
if (error != ErrorType.none)
{
Debug.LogError(error);
}
else
{
HomeUI.Close();
Debug.Log("根据玩家数据刷新房间UI");
ReflashBtnReady();
ReflashRoomInfo();
ReflashRoomState();
}
}
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.updateActorState)
{
ErrorType error = ClassGroup.CheckIsError(xieyi);
if (error != ErrorType.none)
{
Debug.LogError(error);
}
else
{
string messageInfo = SerializeHelper.ConvertToString(xieyi.MessageContent);
RoomActorUpdate roomActorUpdate = new RoomActorUpdate();
roomActorUpdate.SetSendInfo(messageInfo);
RoomActorState state = (RoomActorState)int.Parse(roomActorUpdate.update);
if (state == RoomActorState.Ready || state == RoomActorState.NoReady || state == RoomActorState.Offline)
{
ReflashRoomState();
}
}
}
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.updateRoom)
{
ErrorType error = ClassGroup.CheckIsError(xieyi);
if (error != ErrorType.none)
{
Debug.LogError(error);
}
else
{
UpdateUIInfo();
}
}
}
}
/// <summary>
/// 将需要发送给用户的协议发送
/// </summary>
/// <param name="userID"></param>
/// <param name="message"></param>
/// <param name="xieyiFirst"></param>
/// <param name="xieyiSecond"></param>
public void SendMessageToUser(string userID, byte[] message, byte xieyiFirst, byte xieyiSecond)
{
AsyncUserToken userToken = GetTokenByMemberID(userID);
if (userToken != null)
{
// 创建一个发送缓冲区。
MessageXieYi msgXY = new MessageXieYi(xieyiFirst, xieyiSecond, message);
//Log4Debug("给 ID:" + userID + "/发送消息协议号：" + (MessageConvention)xieyiFirst + "/大小：" + message.Length);
SaveSendMessage(userToken, msgXY.ToBytes());
}
}
public void SendSave(byte xieYiFirstFlage, byte[] message)
{
Debug.LogError("发送协议：" + (MessageConvention)xieYiFirstFlage);
if (GameManager.instance.CurrentPlayType == FramePlayType.断线重连)
{
return;
}
MessageXieYi msgxy = new MessageXieYi(xieYiFirstFlage, 0, message);
byte[] sendBuffer = msgxy.ToBytes();
SendMessage(sendBuffer);
}
private void XieYiThrd(object state)
{
object[] all = (object[])state;
AsyncUserToken userToken = (AsyncUserToken)all[0];
MessageXieYi xieyi = (MessageXieYi)all[1];
if (xieyi == null)
{
Debug.LogError("线程处理协议前，协议已为空。");
}
//将数据包交给前台去处理
DealXieYi(xieyi, userToken);
}
void WriteY()
{
for (int i = 0; i < 100; i++)
{
byte j = (byte)i;
MessageXieYi xieyi = new MessageXieYi(1, 0, new byte[5] {
j, j, j, j, j
});
byte[] send = xieyi.ToBytes();
byte[] buffer = AsyncUserToken.GetSendBytes(send);
SendSave(buffer);
}
Console.WriteLine("本次循环完成。");
}
private void XieYiThrd(object state)
{
object[] all = (object[])state;
AsyncUserToken userToken = (AsyncUserToken)all[0];
MessageXieYi xieyi = (MessageXieYi)all[1];
//将接收到的数据经过处理再发送出去
byte[] backInfo = ServerDataManager.instance.SelectMessage(xieyi, userToken); //判断逻辑
if (backInfo != null)
{
SendSave(userToken, backInfo);
}
}
/// <summary>
/// 转换
/// </summary>
/// <param name="xieYiFirstFlage"></param>
/// <param name="message"></param>
public void SendSave(byte xieYiFirstFlage, byte[] message, bool isMask = true)
{
if (isMask)
{
SocketConnectUI.instance.Open((MessageConvention)xieYiFirstFlage);
}
else
{
//Debug.Log("协议：" + (MessageConvention)xieYiFirstFlage + " 不需要显示Loading");
}
MessageXieYi msgxy = new MessageXieYi(xieYiFirstFlage, 0, message);
byte[] sendBuffer = msgxy.ToBytes();
SendSave(MyUserToken, sendBuffer);
}
public void CheckQuit(AsyncUserToken userToken, QuitInfo quitInfo)
{
if (quitInfo.userIndex != 0 && quitInfo.userIndex != quitInfo.quitUnique)//不是房主，并且踢的也不是自己
{
Log4Debug("无权踢人");
quitInfo.isQuit = false;
}
else
{
quitInfo.isQuit = Quit(quitInfo.quitUnique);
}
byte[] message = SerializeHelper.Serialize <QuitInfo>(quitInfo);
MessageXieYi xieyi = new MessageXieYi((byte)MessageConvention.quitRoom, 0, message);
AsyncIOCPServer.instance.SendSave(UserTokenInfo[quitInfo.quitUnique], xieyi.ToBytes());
}
private void EndGaming(MessageXieYi xieyi)
{
Debug.Log("结束游戏");
CurrentPlayType = FramePlayType.游戏未开始;
frameIndex = 0;
reConnectIndex = 0;//游戏结束的时候未完成复现，则清除重连记录帧
CameraManager.instance.SetCameraEnable(false);
CameraManager.instance.SetCameraFollow(transform);
foreach (var item in memberGroup)
{
item.Value.Init(item.Key);
}
GameRunUI.Close();
TeamType winTeam = (TeamType)int.Parse(SerializeHelper.ConvertToString(xieyi.MessageContent));
RoomUI.Show();
GameOverUI.Show(winTeam);
}
/// <summary>
/// 处理接收数据的主要逻辑（快进也是调该逻辑）
/// </summary>
private void FrameMainLogic()
{
//if (!FrameInfos.ContainsKey(frameIndex))
//{
// Debug.LogError("该执行帧不存在：" + frameIndex);
// return;
//}
//Debug.LogError("执行：" + frameIndex);
FrameInfo info = null;
lock (FrameInfos)
{
info = FrameInfos[frameIndex];
}
if (info.frameData != null)//有更新操作，更新数据
{
if (info.frameData.Count == 0)
{
Debug.LogError("检查指令数据长度为0的情况。");
}
for (int i = 0; i < info.frameData.Count; i++)
{
MessageXieYi frameXY = MessageXieYi.FromBytes(info.frameData[i]);
if (frameXY != null)
{
SelectFrameInfo(frameXY);
}
else
{
string debug = "";
for (int j = 0; j < info.frameData[i].Length; j++)
{
debug += info.frameData[i][j] + ",";
}
Debug.LogError("服务器数据无法解析还原:" + debug);
}
}
}
//子件需要每帧判断的逻辑
AllFrameObj();
//
frameIndex++;
}
private void Handle(AsyncUserToken userToken)
{
do
{
byte[] lenBytes = userToken.ReceiveBuffer.GetRange(0, sizeof(int)).ToArray();
int packageLen = BitConverter.ToInt32(lenBytes, 0);
if (packageLen <= userToken.ReceiveBuffer.Count - sizeof(int))
{
//包够长时,则提取出来,交给后面的程序去处理
byte[] buffer = userToken.ReceiveBuffer.GetRange(sizeof(int), packageLen).ToArray();
//从数据池中移除这组数据,为什么要lock,你懂的
lock (userToken.ReceiveBuffer)
{
userToken.ReceiveBuffer.RemoveRange(0, packageLen + sizeof(int));
}
while (buffer.Length > 0)
{
if (buffer[0] != MessageXieYi.markStart)
{
break;
}
MessageXieYi xieyi = MessageXieYi.FromBytes(buffer);
if (xieyi == null)
{
Log4Debug("奇怪为什么协议为空");
break;
}
int messageLength = xieyi.MessageContentLength + MessageXieYi.XieYiLength + 1 + 1;
buffer = buffer.Skip(messageLength).ToArray();
//将数据包交给前台去处理
//DealXieYi(xieyi, userToken);
//Log4Debug(xieyi.XieYiFirstFlag + ".");
}
}
else
{ //长度不够,还得继续接收,需要跳出循环
break;
}
} while (userToken.ReceiveBuffer.Count > sizeof(int));
}
public static MessageXieYi BackMessageType(byte[] buffer)
{
if (buffer.Length < MessageXieYi.XieYiLength)//如果长度不足6 就无法转换 return null
{
return(null);
}
MessageXieYi messageXieYi = new MessageXieYi();
using (MemoryStream memoryStream = new MemoryStream(buffer)) //将字节数组填充至内存流
{
BinaryReader binaryReader = new BinaryReader(memoryStream); //以二进制读取器读取该流内容
messageXieYi.xieYiFirstFlag = binaryReader.ReadByte(); //读取协议一级标志，读1个字节
messageXieYi.xieYiSecondFlag = binaryReader.ReadByte(); //读取协议二级标志，读1个字节
messageXieYi.messageContentLength = binaryReader.ReadInt32(); //读取实际消息长度，读4个字节
binaryReader.Close();
}
return(messageXieYi);
}
private void Update()
{
if (serverEvent.Count > 0)
{
MessageXieYi xieyi = serverEvent.Dequeue();
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.updateName)
{
ErrorType error = ClassGroup.CheckIsError(xieyi);
if (error != ErrorType.none)
{
UIManager.instance.ShowAlertTip("更新昵称失败：" + error);
}
else
{
UIManager.instance.ShowAlertTip("更新昵称成功");
ReflashShow();
}
}
}
}
public void UpdateMemberShoot(MessageXieYi xieyi)
{
BulletInfo bulletInfo = SerializeHelper.Deserialize <BulletInfo>(xieyi.MessageContent);
int bulletMaster = bulletInfo.userIndex;
int shootedIndex = int.Parse(bulletInfo.shootInfo);
//同队不杀
if (DataController.instance.ActorList[shootedIndex].MyTeam == DataController.instance.ActorList[bulletMaster].MyTeam)
{
return;
}
//
if (shootedIndex == DataController.instance.MyLocateIndex)
{
GameRunUI.instance.BeShoot();
//MyJoystickManager.instance.BeShoot();
UIManager.instance.ShowAlertTip("我被射中。");
}
GetControl(shootedIndex).SetOriginal();
GetControl(bulletMaster).ShowKill(DataController.instance.ActorList[bulletMaster].KillCount);
}
void TestMait()
{
//obj.GetComponent<MeshRenderer>().material = (Material)Resources.Load(DataController.materialPathSkill + DataController.materialNameSkill + id);
//string info = "8,0,172,0,0,0,0,1,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,12,2,0,0,0,64,83,101,114,105,97,108,105,122,101,44,32,86,101,114,115,105,111,110,61,49,46,48,46,48,46,48,44,32,67,117,108,116,117,114,101,61,110,101,117,116,114,97,108,44,32,80,117,98,108,105,99,75,101,121,84,111,107,101,110,61,110,117,108,108,5,1,0,0,0,17,65,99,116,111,114,78,101,116,65,110,105,109,97,116,105,111,110,3,0,0,0,9,114,111,111,109,73,110,100,101,120,9,117,115,101,114,73,110,100,101,120,14,97,110,105,109,97,116,105,111,110,73,110,100,101,120,0,0,0,8,8,8,2,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,11,7,0,19,0,0,0,48,44,48,44,48,44,45,57,50,44,45,51,44,48,44,48,44,48,44,7,0,19,0,0,0,48,44,48,44,48,44,45,57,49,44,45,53,44,48,44,48,44,48,44,7,0,20,0,0,0,48,44,48,44,45,49,44,45,57,49,44,45,57,44,48,44,48,44,48,44,7,0,21,0,0,0,48,44,48,44,45,51,44,45,57,49,44,45,49,51,44,48,44,48,44,48,44,44,48,44,48,44,48,44,7,0,18,0,0,0,48,44,48,44,48,44,45,57,49,44,48,44,48,44,48,44,48,44,7,0,18,0,0,0,48,44,48,44,48,44,45,57,49,44,48,44,48,44,48,44,48,44,7,0,18,0,0,0,4";
//Debug.LogError(info.Split(',').Length);
string sMsg = "{'ErrorType':'6'}";
byte[] bm = SerializeHelper.ConvertToByte(sMsg);
MessageXieYi xieyi = new MessageXieYi()
{
MessageContent = bm, MessageContentLength = bm.Length, XieYiFirstFlag = 0, XieYiSecondFlag = 0
};
string message = SerializeHelper.ConvertToString(xieyi.MessageContent);
JObject json = JObject.Parse(message);
if (json != null)
{
Debug.LogError("eee");
}
}
public void Update()
{
if (serverEvent.Count > 0)
{
MessageXieYi xieyi = serverEvent.Dequeue();
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.createRoom ||
(MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.joinRoom)
{
JoinRoom joinInfo = new JoinRoom();
joinInfo = SerializeHelper.Deserialize <JoinRoom>(xieyi.MessageContent);
ErrorType error = joinInfo.error;
if (error != ErrorType.none)
{
UIManager.instance.ShowAlertTip("加入房间失败" + error);
}
else
{
//GameManager.GetRoomInfo();
}
}
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.getRoomInfo)
{
RoomUI.Show();
CreateRoomUI.Close();
}
if ((MessageConvention)xieyi.XieYiFirstFlag == MessageConvention.updateRoom)
{
ErrorType error = ClassGroup.CheckIsError(xieyi);
if (error != ErrorType.none)
{
UIManager.instance.ShowAlertTip("更新房间失败：" + error);
}
else
{
UIManager.instance.ShowAlertTip("更新房间成功");
}
Close();
}
}
}
/// <summary>
/// 线程处理接收数据
/// </summary>
/// <param name="state"></param>
private void Handle(object state)
{
AsyncUserToken userToken = (AsyncUserToken)state;
lock (userToken.LockHanding)
{
while (userToken.ReceiveBuffer.Count > sizeof(int))//包整长判断
{
int packageLen = 0;
byte[] completeMessage = null;
lock (userToken.ReceiveBuffer)
{
byte[] lenBytes = userToken.ReceiveBuffer.GetRange(0, sizeof(int)).ToArray();
packageLen = BitConverter.ToInt32(lenBytes, 0);
if (packageLen <= userToken.ReceiveBuffer.Count - sizeof(int))//数据够长
{
completeMessage = userToken.ReceiveBuffer.GetRange(sizeof(int), packageLen).ToArray();
userToken.ReceiveBuffer.RemoveRange(0, packageLen + sizeof(int));
}
else//数据不够长
{
continue;
}
}
//处理Complete
MessageXieYi xieyi = MessageXieYi.FromBytes(completeMessage);
if (xieyi == null)
{
Log4Debug("完整长度数据不能反序列化成MessageXieYi，本段数据丢弃。");
}
else
{
object[] all = new object[] { userToken, xieyi };
ThreadPool.QueueUserWorkItem(new WaitCallback(XieYiThrd), all);
//DealXieYi(xieyi, userToken);
}
}
}
}
