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 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 OnCliclCancelMatch()
{
//取消匹配
TcpCancelMatch _mes = new TcpCancelMatch();
_mes.uid = NetGlobal.Instance().userUid;
MarsTcp.Instance.SendMessage(CSData.GetSendMessage <TcpCancelMatch>(_mes, CSID.TCP_CANCEL_MATCH));
}
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));
}
public int Post(CSRequest request)
{
var c = new CS()
{
Id = request.Id,
Name = request.Name,
Price = request.Price
};
CSData cd = new CSData(Db);
return(cd.addCS(c));
}
public CS Put(CSRequest request)
{
var c = new CS()
{
Id = request.Id,
Name = request.Name,
Price = request.Price
};
CSData cd = new CSData(Db);
return(cd.UpdateCS(c));
}
public static List <CSData> GetGroupData()
{
List <CSData> datas = new List <CSData>();
int cc = 10;
List <CCompany> Companys = new List <CCompany>();
for (int i = 0; i < cc; i++)
{
CCompany cmp = new CCompany()
{
CompanyID = "CID" + (i + 1), CompanyName = "CNAME" + (i + 1)
};
Companys.Add(cmp);
}
int dd = 100;
List <CDepartment> dps = new List <CDepartment>();
for (int i = 0; i < dd; i++)
{
CDepartment dp = new CDepartment()
{
CompanyID = Companys.ElementAt(i % cc).CompanyID, DepartmentID = "DPID" + (i + 1), DepartmentName = "DPNAME" + (i + 1)
};
dps.Add(dp);
}
int pp = 1500;
List <CPersion> ps = new List <CPersion>();
for (int i = 0; i < pp; i++)
{
CPersion p = new CPersion()
{
CompanyID = dps.ElementAt(i % dd).CompanyID, DepartmentID = dps.ElementAt(i % dd).DepartmentID, PersionName = "PName" + (i + 1)
};
ps.Add(p);
}
int j = 0;
foreach (var p in ps)
{
CSData d1 = new CSData()
{
CompanyID = p.CompanyID, DepartmentID = p.DepartmentID, PersionID = p.PersionID, Say = "hello" + (j + 1)
};
datas.Add(d1);
j++;
}
return(datas);
}
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(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;
}
}
public static byte[] GetSendMessage <T> (T pb_Body, PBCommon.CSID messageID)
{
byte[] packageBody = CSData.SerializeData <T> (pb_Body);
byte packMessageId = (byte)messageID; //消息id (1个字节)
int packlength = PackageConstant.PacketHeadLength + packageBody.Length; //消息包长度 (2个字节)
byte[] packlengthByte = BitConverter.GetBytes((short)packlength);
List <byte> packageHeadList = new List <byte> ();
//包头信息
packageHeadList.Add(packMessageId);
packageHeadList.AddRange(packlengthByte);
//包体
packageHeadList.AddRange(packageBody);
return(packageHeadList.ToArray());
}
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);
}
});
}
public void Delete(CSIdRequest request)
{
CSData cd = new CSData(Db);
cd.DeleteCSById(request.CSId);
}
public CS Get(CSIdRequest request)
{
CSData cd = new CSData(Db);
return(cd.getCSById(request.CSId));
}
public List <CS> Get(GetCSRequest request)
{
CSData cd = new CSData(Db);
return(cd.GetCSList());
}
public static void SetData(this CreatureSpawner cs, CSData data) => cs?.m_nview?.GetZDO()?.Set("Areas CustomCS Data", Serialization.Serialize(data));
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("帧数据发送线程结束.....................");
}
