public void SendGameOver(int _battleID)
{
UdpUpGameOver _gameOver = new UdpUpGameOver();
_gameOver.battleID = _battleID;
_upd.SendMessage(CSData.GetSendMessage <UdpUpGameOver>(_gameOver, CSID.UDP_UP_GAME_OVER));
}
public void OnCliclCancelMatch()
{
//取消匹配
TcpCancelMatch _mes = new TcpCancelMatch();
_mes.uid = NetGlobal.Instance().userUid;
MarsTcp.Instance.SendMessage(CSData.GetSendMessage <TcpCancelMatch>(_mes, CSID.TCP_CANCEL_MATCH));
}
public void SendBattleReady(int _uid, int _battleID)
{
UdpBattleReady _ready = new UdpBattleReady();
_ready.uid = _uid;
_ready.battleID = _battleID;
_upd.SendMessage(CSData.GetSendMessage <UdpBattleReady>(_ready, CSID.UDP_BATTLE_READY));
}
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 SendDeltaFrames(int _battleID, List <int> _frames)
{
UdpUpDeltaFrames _framespb = new UdpUpDeltaFrames();
_framespb.battleID = _battleID;
_framespb.frames.AddRange(_frames);
_upd.SendMessage(CSData.GetSendMessage <UdpUpDeltaFrames>(_framespb, CSID.UDP_UP_DELTA_FRAMES));
}
public void OnClickMatch()
{
//开始匹配
// SceneManager.LoadScene (GameConfig.battleScene);
TcpRequestMatch _mes = new TcpRequestMatch();
_mes.uid = NetGlobal.Instance().userUid;
_mes.roleID = 1;
MarsTcp.Instance.SendMessage(CSData.GetSendMessage <TcpRequestMatch>(_mes, CSID.TCP_REQUEST_MATCH));
}
private float finishTime; //结束倒计时
public void CreatBattle(int _battleID, List <MatchUserInfo> _battleUser)
{
int randSeed = UnityEngine.Random.Range(0, 100);
ThreadPool.QueueUserWorkItem((obj) => {
battleID = _battleID;
dic_battleUserUid = new Dictionary <int, int> ();
dic_udp = new Dictionary <int, ClientUdp> ();
dic_battleReady = new Dictionary <int, bool>();
int userBattleID = 0;
TcpEnterBattle _mes = new TcpEnterBattle();
_mes.randSeed = randSeed;
for (int i = 0; i < _battleUser.Count; i++)
{
int _userUid = _battleUser [i].uid;
userBattleID++;
dic_battleUserUid [_userUid] = userBattleID;
string _ip = UserManage.Instance.GetUserInfo(_userUid).socketIp;
var _upd = new ClientUdp();
_upd.StartClientUdp(_ip, _userUid);
_upd.delegate_analyze_message = AnalyzeMessage;
dic_udp [userBattleID] = _upd;
dic_battleReady[userBattleID] = false;
BattleUserInfo _bUser = new BattleUserInfo();
_bUser.uid = _userUid;
_bUser.battleID = userBattleID;
_bUser.roleID = _battleUser [i].roleID;
_mes.battleUserInfo.Add(_bUser);
}
for (int i = 0; i < _battleUser.Count; i++)
{
int _userUid = _battleUser [i].uid;
string _ip = UserManage.Instance.GetUserInfo(_userUid).socketIp;
ServerTcp.Instance.SendMessage(_ip, CSData.GetSendMessage <TcpEnterBattle>(_mes, SCID.TCP_ENTER_BATTLE));
}
}, null);
}
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;
}
}
public void SendOperation()
{
mesNum++;
UdpUpPlayerOperations _up = new UdpUpPlayerOperations();
_up.mesID = mesNum;
_up.operation = BattleData.Instance.selfOperation;
// _up.operation = new PlayerOperation ();
// _up.operation.battleID = BattleData.Instance.selfOperation.battleID;
// _up.operation.move = BattleData.Instance.selfOperation.move;
//
// if (BattleData.Instance.selfOperation.rightOperation != RightOpType.noop) {
// _up.operation.operationID = BattleData.Instance.selfOperation.operationID;
// _up.operation.rightOperation = BattleData.Instance.selfOperation.rightOperation;
// _up.operation.operationValue1 = BattleData.Instance.selfOperation.operationValue1;
// _up.operation.operationValue2 = BattleData.Instance.selfOperation.operationValue2;
// }
_upd.SendMessage(CSData.GetSendMessage <UdpUpPlayerOperations>(_up, CSID.UDP_UP_PLAYER_OPERATIONS));
}
public void OnClickLogin()
{
Debug.Log(inputField.text);
waitTip.SetActive(true);
string _ip = inputField.text;
MarsTcp.Instance.ConnectServer(_ip, (_result) => {
if (_result)
{
Debug.Log("连接成功～～");
NetGlobal.Instance().serverIP = _ip;
TcpLogin _loginInfo = new TcpLogin();
_loginInfo.token = SystemInfo.deviceUniqueIdentifier;
MarsTcp.Instance.SendMessage(CSData.GetSendMessage <TcpLogin>(_loginInfo, CSID.TCP_LOGIN));
}
else
{
Debug.Log("连接失败～～");
waitTip.SetActive(false);
}
});
}
private void Thread_SendFrameData()
{
//向玩家发送战斗开始
bool isFinishBS = false;
while (!isFinishBS)
{
UdpBattleStart _btData = new UdpBattleStart();
byte[] _data = CSData.GetSendMessage <UdpBattleStart> (_btData, SCID.UDP_BATTLE_START);
foreach (var item in dic_udp)
{
item.Value.SendMessage(_data);
}
bool _allData = true;
for (int i = 0; i < frameOperation.Length; i++)
{
if (frameOperation[i] == null)
{
_allData = false;
break;
}
}
if (_allData)
{
LogManage.Instance.AddLog("战斗服务器:收到全部玩家的第一次操作数据....");
frameNum = 1;
isFinishBS = true;
}
Thread.Sleep(500);
}
LogManage.Instance.AddLog("开始发送帧数据～～～～");
while (_isRun)
{
UdpDownFrameOperations _dataPb = new UdpDownFrameOperations();
if (oneGameOver)
{
_dataPb.frameID = lastFrame;
_dataPb.operations = dic_gameOperation [lastFrame];
}
else
{
_dataPb.operations = new AllPlayerOperation();
_dataPb.operations.operations.AddRange(frameOperation);
_dataPb.frameID = frameNum;
dic_gameOperation [frameNum] = _dataPb.operations;
lastFrame = frameNum;
frameNum++;
}
byte[] _data = CSData.GetSendMessage <UdpDownFrameOperations> (_dataPb, SCID.UDP_DOWN_FRAME_OPERATIONS);
foreach (var item in dic_udp)
{
int _index = item.Key - 1;
if (!playerGameOver [_index])
{
item.Value.SendMessage(_data);
}
}
Thread.Sleep(ServerConfig.frameTime);
}
LogManage.Instance.AddLog("帧数据发送线程结束.....................");
}