public void AnalyzeMessage(CSID messageId, byte[] bodyData)
{
switch (messageId)
{
case CSID.UDP_BATTLE_READY:
{
//接收战斗准备
UdpBattleReady _mes = CSData.DeserializeData <UdpBattleReady> (bodyData);
CheckBattleBegin(_mes.battleID);
dic_udp [_mes.battleID].RecvClientReady(_mes.uid);
}
break;
case CSID.UDP_UP_PLAYER_OPERATIONS:
{
UdpUpPlayerOperations pb_ReceiveMes = CSData.DeserializeData <UdpUpPlayerOperations>(bodyData);
UpdatePlayerOperation(pb_ReceiveMes.operation, pb_ReceiveMes.mesID);
}
break;
case CSID.UDP_UP_DELTA_FRAMES:
{
UdpUpDeltaFrames pb_ReceiveMes = CSData.DeserializeData <UdpUpDeltaFrames>(bodyData);
UdpDownDeltaFrames _downData = new UdpDownDeltaFrames();
for (int i = 0; i < pb_ReceiveMes.frames.Count; i++)
{
int framIndex = pb_ReceiveMes.frames [i];
UdpDownFrameOperations _downOp = new UdpDownFrameOperations();
_downOp.frameID = framIndex;
_downOp.operations = dic_gameOperation [framIndex];
_downData.framesData.Add(_downOp);
}
byte[] _data = CSData.GetSendMessage <UdpDownDeltaFrames> (_downData, SCID.UDP_DOWN_DELTA_FRAMES);
dic_udp [pb_ReceiveMes.battleID].SendMessage(_data);
}
break;
case CSID.UDP_UP_GAME_OVER:
{
UdpUpGameOver pb_ReceiveMes = CSData.DeserializeData <UdpUpGameOver>(bodyData);
UpdatePlayerGameOver(pb_ReceiveMes.battleID);
UdpDownGameOver _downData = new UdpDownGameOver();
byte[] _data = CSData.GetSendMessage <UdpDownGameOver> (_downData, SCID.UDP_DOWN_GAME_OVER);
dic_udp [pb_ReceiveMes.battleID].SendMessage(_data);
}
break;
default:
break;
}
}
public void AnalyzeMessage(SCID messageId, byte[] bodyData)
{
switch (messageId)
{
case SCID.TCP_RESPONSE_LOGIN:
{
TcpResponseLogin pb_ReceiveMes = CSData.DeserializeData <TcpResponseLogin>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_login_result(pb_ReceiveMes);
});
}
break;
case SCID.TCP_RESPONSE_REQUEST_MATCH:
{
TcpResponseRequestMatch pb_ReceiveMes = CSData.DeserializeData <TcpResponseRequestMatch>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_request_match_result(pb_ReceiveMes);
});
}
break;
case SCID.TCP_RESPONSE_CANCEL_MATCH:
{
TcpResponseCancelMatch pb_ReceiveMes = CSData.DeserializeData <TcpResponseCancelMatch>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_cancel_match_result(pb_ReceiveMes);
});
}
break;
case SCID.TCP_ENTER_BATTLE:
{
TcpEnterBattle pb_ReceiveMes = CSData.DeserializeData <TcpEnterBattle>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_enter_battle(pb_ReceiveMes);
});
}
break;
default:
break;
}
}
public void AnalyzeMessage(SCID messageId, byte[] bodyData)
{
switch (messageId)
{
case SCID.UDP_BATTLE_START:
{
UdpBattleStart pb_ReceiveMes = CSData.DeserializeData <UdpBattleStart>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_battle_start(pb_ReceiveMes);
});
}
break;
case SCID.UDP_DOWN_FRAME_OPERATIONS:
{
UdpDownFrameOperations pb_ReceiveMes = CSData.DeserializeData <UdpDownFrameOperations>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_frame_operation(pb_ReceiveMes);
});
}
break;
case SCID.UDP_DOWN_DELTA_FRAMES:
{
UdpDownDeltaFrames pb_ReceiveMes = CSData.DeserializeData <UdpDownDeltaFrames>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_delta_frame_data(pb_ReceiveMes);
});
}
break;
case SCID.UDP_DOWN_GAME_OVER:
{
UdpDownGameOver pb_ReceiveMes = CSData.DeserializeData <UdpDownGameOver>(bodyData);
NetGlobal.Instance().AddAction(() => {
mes_down_game_over(pb_ReceiveMes);
});
}
break;
default:
break;
}
}
public void AnalyzeMessage(PBCommon.CSID messageId, byte[] bodyData, string _socketIp)
{
switch (messageId)
{
case CSID.TCP_LOGIN:
{
TcpLogin _info = CSData.DeserializeData <TcpLogin> (bodyData);
int _uid = UserManage.Instance.UserLogin(_info.token, _socketIp);
TcpResponseLogin _result = new TcpResponseLogin();
_result.result = true;
_result.uid = _uid;
_result.udpPort = UdpManager.Instance.recvPort;
ServerTcp.Instance.SendMessage(_socketIp, CSData.GetSendMessage <TcpResponseLogin>(_result, SCID.TCP_RESPONSE_LOGIN));
}
break;
case CSID.TCP_REQUEST_MATCH:
{
TcpRequestMatch _mes = CSData.DeserializeData <TcpRequestMatch> (bodyData);
MatchManage.Instance.NewMatchUser(_mes.uid, _mes.roleID);
TcpResponseRequestMatch rmRes = new TcpResponseRequestMatch();
ServerTcp.Instance.SendMessage(_socketIp, CSData.GetSendMessage <TcpResponseRequestMatch>(rmRes, SCID.TCP_RESPONSE_REQUEST_MATCH));
}
break;
case CSID.TCP_CANCEL_MATCH:
{
TcpCancelMatch _mes = CSData.DeserializeData <TcpCancelMatch> (bodyData);
MatchManage.Instance.CancleMatch(_mes.uid);
TcpResponseCancelMatch cmRes = new TcpResponseCancelMatch();
ServerTcp.Instance.SendMessage(_socketIp, CSData.GetSendMessage <TcpResponseCancelMatch>(cmRes, SCID.TCP_RESPONSE_CANCEL_MATCH));
}
break;
default:
break;
}
}
