/// <summary>
/// 处理客户端请求
/// </summary>
public void ProcessMessage(ServerMsg msg, NamedPipeServerStream pipeServer)
{
switch (msg.ServerMsgType)
{
case ServerMsgType.OpenUrl:
Execute.OnUIThread(() => {
if (p == null) //初始化
{
p = new Player();
p.Show();
p.InDeskTop();
}
p.Play(msg.Value.ToString());
System.Console.WriteLine();
});
break;
case ServerMsgType.InDeskTop:
break;
case ServerMsgType.Volume:
Execute.OnUIThread(() => {
p.SetVolume(msg.IntValue);
});
break;
}
pipeServer.Close();
}
public void HandleReceiveMsg(byte[] dataBuffer, int dataLength)
{
int begin = 0;
//Debug.Log(dataLength);
while (begin < dataLength)
{
int msgLen = System.BitConverter.ToInt32(dataBuffer, begin);
if (begin + msgLen > dataLength)
{
break;
}
begin += NetworkSettings.NET_HEAD_LENGTH_SIZE;
int dataLen = msgLen - NetworkSettings.NET_HEAD_LENGTH_SIZE;
ServerMsg serverMsg = MessageHandler.ParseFrom(dataBuffer, begin, msgLen);
receiveMessages.Enqueue(serverMsg);
begin += dataLen;
}
if (begin < dataLength)
{
Array.Copy(dataBuffer, 0, dataBuffer, begin, dataLength - begin);
}
dataBufferLength = dataLength - begin;
}
private void ReadServerMessage(ServerMsg srvMsg)
{
if (srvMsg.msgType == MsgType.MSG_TYPE_IMAGE)
{
Debug.Log("Updating texture...");
String message = srvMsg.msg;
Mat image = str2mat(message);
if (image.width() > 0 && image.height() > 0)
{
Core.flip(image, image, 0);
Core.flip(image, image, 1);
if (image.type() == CvType.CV_8UC3)
{
Imgproc.cvtColor(image, image, Imgproc.COLOR_BGR2RGB);
Utils.matToTexture2D(image, ImageTexture_);
}
else if (image.type() == CvType.CV_32FC1)
{
Mat disp_colormap = DisparityController.Disparity2Colormap(image, 255, false);
Imgproc.cvtColor(disp_colormap, disp_colormap, Imgproc.COLOR_BGR2RGB);
Utils.matToTexture2D(disp_colormap, ImageTexture_);
}
else
{
Debug.Log("Unsupported CV image type: " + image.type().ToString());
}
}
}
else if (srvMsg.msgType == MsgType.MSG_TYPE_STRING)
{
Debug.Log(srvMsg.msg);
}
}
public void ServerBroadcastTest()
{
var msg = new ServerMsg("Testing");
FakeSrv.Broadcast(msg);
Assert.IsTrue(FakeSrv.Clients.Cast <FakeMuClient>().All(x => x.Msg == msg));
}
private void btnMotdUpdate_Click(object sender, EventArgs e)
{
txtMotd.Text = txtMotd.Text.Trim();
Config.MOTD = txtMotd.Text;
Config.Save();
ServerMsg.Broadcast(txtMotd.Text);
UpdateLog(string.Format("[SERVER] {0}", txtMotd.Text));
}
internal void RegisterServer(MessageSession session, ServerMsg msg)
{
_serverMapLock.DoWrite(() =>
{
_serverMap.Add(session, msg);
Logger.Write("Connected: [{0}] {1}:{2}", msg.Name, msg.Host, msg.Port);
});
}
// Update is called once per frame
void Update()
{
if (this.tmpMsg == null)
{
return;
}
ServerMsg data = JsonUtility.FromJson <ServerMsg> (this.tmpMsg);
this.tmpMsg = null;
switch ((Exec)data.exec)
{
case Exec.Enter:
{
this.strPlayerID = data.uid;
}
break;
case Exec.Ready:
{
int start = data.start;
int end = data.end;
// GameManager.Instance.setupConfig (start, end);
EnemyConfig enA = new EnemyConfig();
enA.name = "A";
enA.speed = 14;
enA.health = 100;
EnemyConfig enB = new EnemyConfig();
enB.name = "B";
enB.speed = 6;
enB.health = 200;
EnemyConfig[] enemyCon = { enA, enB };
// GameManager.Instance.setupEnemyInfo (data.team, enemyCon);
}
break;
case Exec.UpdatePath:
{
string userID = data.userID;
if (userID != this.strPlayerID)
{
// GameManager.Instance.recieveBuildingInfo (data.tileIdx, data.tower);
}
}
break;
default:
break;
}
}
public static int GetCode(this ServerMsg msg)
{
switch (msg.MessageCase)
{
case ServerMsg.MessageOneofCase.Ctrl: return(msg.Ctrl.Code);
case ServerMsg.MessageOneofCase.Meta: return(0);
default:
throw new NotSupportedException("cannot get message Code of type " + msg.MessageCase);
}
}
public static string GetId(this ServerMsg msg)
{
switch (msg.MessageCase)
{
case ServerMsg.MessageOneofCase.Ctrl: return(msg.Ctrl.Id);
case ServerMsg.MessageOneofCase.Meta: return(msg.Meta.Id);
default:
throw new NotSupportedException("cannot get message id of type " + msg.MessageCase);
}
}
// Update is called once per frame
void Update()
{
if (loginSuccessfully)
{
return;
}
networkHost.ReceiveData();
while (networkHost.receiveMessages.Count > 0)
{
ServerMsg serverMessage = networkHost.receiveMessages.Dequeue();
Debug.Log("receive server msg type: " + Convert.ToString(serverMessage.msgType, 16));
if (serverMessage.msgType == NetworkSettings.SERVER_FEEDBACK)
{
switch (((ServerFeedbackMsg)serverMessage).code)
{
case NetworkSettings.COMMAND_LOGIN_SUCCESSFUL:
loginSuccessfully = true;
Debug.Log("jump to gamescene");
SceneManager.LoadScene("Halloween_Level");
break;
case NetworkSettings.COMMAND_SEND_CLIENTID:
Debug.Log(Convert.ToString(((ServerClientIDMsg)serverMessage).clientID));
GameSettings.clientID = ((ServerClientIDMsg)serverMessage).clientID;
break;
case NetworkSettings.COMMAND_REGISTER_SUCCESSFUL:
tips.text = "[Accept] Register Successfully!";
break;
case NetworkSettings.COMMAND_WRONG_PASSWORD:
tips.text = "[Wrong] Wrong Password!";
break;
case NetworkSettings.COMMAND_NAME_ALREADY_EXISTS:
tips.text = "[Wrong] This Name Already Exist!";
break;
case NetworkSettings.COMMAND_DATABASE_ERROR:
tips.text = "[Wrong] Database Wrong in Server";
break;
case NetworkSettings.COMMAND_LOGIN_ALREADY:
tips.text = "[Wrong] User Login Already!";
break;
}
}
}
}
public void Update()
{
while (_serverMsgCache.Count > 0)
{
ServerMsg serverMsg = _serverMsgCache.Dequeue();
if (_receiveMsgHanlerDic.ContainsKey(serverMsg.MsgId))
{
_receiveMsgHanlerDic[serverMsg.MsgId].Invoke(serverMsg.MsgBody);
}
else
{
Debug.LogError("并未在服务器响应字典中注册对应Action!");
}
}
}
private void txtBroadcast_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode != Keys.Enter)
{
return;
}
try
{
ServerMsg.Broadcast(txtBroadcast.Text);
UpdateLog(string.Format("[SERVER] {0}", txtBroadcast.Text));
txtBroadcast.Clear();
}
catch (Exception ex)
{
UpdateLog("Error sending broadcast: " + ex.Message);
}
}
// Update is called once per frame
void Update()
{
// fisrt register a player entity at server
if (!playerEneityRegistered && networkHost.connected)
{
SendPlayerEntityRegisterMsg();
playerEneityRegistered = true;
}
// sync the player location to server
if (networkHost.connected && timer >= NetworkSettings.SERVER_SYNC_INTERVAL)
{
if (!GameSettings.gameOver)
{
SendPlayerEntitySyncMsg();
}
timer -= NetworkSettings.SERVER_SYNC_INTERVAL;
}
else
{
timer += Time.deltaTime;
}
// receive data to message queue
networkHost.ReceiveData();
while (networkHost.receiveMessages.Count > 0)
{
ServerMsg serverMessage = networkHost.receiveMessages.Dequeue();
HandleServerMsg(serverMessage);
}
// change gameobject's position
ChangeServerGameObjectPosotion(Time.deltaTime);
if (GameSettings.gameOver && PlayerInput.GetR())
{
SendRestartMsg();
InitPlayerData();
SceneManager.LoadScene("Login Scene");
}
}
/// <summary>
/// 处理客户端请求
/// </summary>
public static void ProcessMessage(ServerMsg msg, NamedPipeServerStream pipeServer)
{
switch (msg.ServerMsgType)
{
case ServerMsgType.OpenUrl:
Execute.OnUIThread(() => {
play.Play(msg.Value);
});
break;
case ServerMsgType.InDeskTop:
break;
case ServerMsgType.Volume:
Execute.OnUIThread(() => {
play.SetVolume(msg.IntValue);
});
break;
}
pipeServer.Close();
}
public TinodeSeverExcpetion(ServerMsg msg) => _msg = msg;
void HandleServerMsg(ServerMsg serverMsg)
{
switch (serverMsg.msgType)
{
case NetworkSettings.SERVER_CLIENTID_DATA:
Debug.Log("client id: " + Convert.ToString(((ServerClientIDMsg)serverMsg).clientID));
GameSettings.clientID = ((ServerClientIDMsg)serverMsg).clientID;
break;
case NetworkSettings.SERVER_CREATE_MONSTER:
Debug.Log("Create Monster of id " + ((ServerMonsterMsg)serverMsg).monsterEntity.entityID);
CreateMonster(((ServerMonsterMsg)serverMsg).monsterEntity);
break;
case NetworkSettings.SERVER_SYNC_MONSTER:
//Debug.Log("Sync the monste location of id " + ((ServerMonsterMsg)serverMsg).monsterEntity.entityID);
SyncMonster(((ServerMonsterMsg)serverMsg).monsterEntity);
break;
case NetworkSettings.SERVER_KILL_MONSTER:
int monsterID = ((ServerPlayerKillMsg)serverMsg).monsterID;
Debug.Log("monser is killed " + monsterID);
KillMonster(monsterID);
break;
case NetworkSettings.SERVER_SYNC_PLAYER:
SyncPlayer((ServerSyncPlayerMsg)serverMsg);
break;
case NetworkSettings.SERVER_PLAYER_DIE:
Debug.Log("Player Die");
PlayerDie((ServerPlayerDieMsg)serverMsg);
break;
case NetworkSettings.SERVER_CREATE_MISSILE:
Debug.Log("Create Missile of id " + ((ServerMissileMsg)serverMsg).missileEntity.entityID);
CreateMissile(((ServerMissileMsg)serverMsg).missileEntity);
break;
case NetworkSettings.SERVER_SYNC_MISSILE:
SyncMissile((ServerSyncMissileMsg)serverMsg);
break;
case NetworkSettings.SERVER_DESTORY_MISSILE:
DestoryMissile((ServerDestoryMissileMsg)serverMsg);
break;
case NetworkSettings.SERVER_MISSILE_EXPLOSION:
MissileExplosion((ServerMissileExplosionMsg)serverMsg);
break;
case NetworkSettings.SERVER_CREATE_OTHER_PLAYER:
CreateOtherPlayer((ServerOtherPlayerMsg)serverMsg);
break;
case NetworkSettings.SERVER_ALL_ENTITIES:
HandleAllEntityMsg((ServerAllEntityDataMsg)serverMsg);
break;
case NetworkSettings.SERVER_SYNC_OTHER_PLAYER:
SyncOtherPlayer((ServerOtherPlayerMsg)serverMsg);
break;
case NetworkSettings.SERVER_SYNC_OTHER_PLAYER_SHOOT:
SyncOtherPlayerShoot((ServerOtherPlayerShootMsg)serverMsg);
break;
case NetworkSettings.SERVER_CREATE_TRAP:
CreateTrap(((ServerTrapMsg)serverMsg).trapEntity);
break;
case NetworkSettings.SERVER_ELEPHANT_ATTACK:
ElephantAttack((ServerElephantAttackMsg)serverMsg);
break;
case NetworkSettings.SERVER_PLAYER_DISCONNECT:
PlayerDisconnect((ServerPlayerDisconnectMsg)serverMsg);
break;
case NetworkSettings.SERVER_NEXT_LEVEL_TIME:
SetNextLevelTime((ServerNextLevelTimeMsg)serverMsg);
break;
case NetworkSettings.SERVER_HIGHEST_SCORE:
SetHighestScore((ServerHighestScoreMsg)serverMsg);
break;
}
}
static public ServerMsg ParseFrom(byte[] buffer, int begin, int length)
{
if (begin < 0 || length <= 0 || begin + length > buffer.Length)
{
return(null);
}
short msgId = System.BitConverter.ToInt16(buffer, begin);
begin += sizeof(short);
short msgType = System.BitConverter.ToInt16(buffer, begin);
begin += sizeof(short);
int dataLength = System.BitConverter.ToInt32(buffer, begin);
begin += sizeof(int);
string dataStr = System.Text.Encoding.Default.GetString(buffer, begin, dataLength);
ServerMsg serverMsg = null;
//Debug.Log("receive server msg type: " + Convert.ToString(msgType, 16));
//Debug.Log(dataStr);
switch (msgType)
{
case NetworkSettings.SERVER_FEEDBACK:
serverMsg = JsonConvert.DeserializeObject <ServerFeedbackMsg>(dataStr);
break;
case NetworkSettings.SERVER_CLIENTID_DATA:
serverMsg = JsonConvert.DeserializeObject <ServerClientIDMsg>(dataStr);
break;
case NetworkSettings.SERVER_CREATE_MONSTER:
case NetworkSettings.SERVER_SYNC_MONSTER:
serverMsg = JsonConvert.DeserializeObject <ServerMonsterMsg>(dataStr);
break;
case NetworkSettings.SERVER_KILL_MONSTER:
serverMsg = JsonConvert.DeserializeObject <ServerPlayerKillMsg>(dataStr);
break;
case NetworkSettings.SERVER_SYNC_PLAYER:
serverMsg = JsonConvert.DeserializeObject <ServerSyncPlayerMsg>(dataStr);
break;
case NetworkSettings.SERVER_PLAYER_DIE:
serverMsg = JsonConvert.DeserializeObject <ServerPlayerDieMsg>(dataStr);
break;
case NetworkSettings.SERVER_CREATE_MISSILE:
serverMsg = JsonConvert.DeserializeObject <ServerMissileMsg>(dataStr);
break;
case NetworkSettings.SERVER_SYNC_MISSILE:
serverMsg = JsonConvert.DeserializeObject <ServerSyncMissileMsg>(dataStr);
break;
case NetworkSettings.SERVER_DESTORY_MISSILE:
serverMsg = JsonConvert.DeserializeObject <ServerDestoryMissileMsg>(dataStr);
break;
case NetworkSettings.SERVER_MISSILE_EXPLOSION:
serverMsg = JsonConvert.DeserializeObject <ServerMissileExplosionMsg>(dataStr);
break;
case NetworkSettings.SERVER_CREATE_OTHER_PLAYER:
case NetworkSettings.SERVER_SYNC_OTHER_PLAYER:
serverMsg = JsonConvert.DeserializeObject <ServerOtherPlayerMsg>(dataStr);
break;
case NetworkSettings.SERVER_ALL_ENTITIES:
Debug.Log(dataStr);
serverMsg = JsonConvert.DeserializeObject <ServerAllEntityDataMsg>(dataStr);
break;
case NetworkSettings.SERVER_SYNC_OTHER_PLAYER_SHOOT:
serverMsg = JsonConvert.DeserializeObject <ServerOtherPlayerShootMsg>(dataStr);
break;
case NetworkSettings.SERVER_CREATE_TRAP:
serverMsg = JsonConvert.DeserializeObject <ServerTrapMsg>(dataStr);
break;
case NetworkSettings.SERVER_ELEPHANT_ATTACK:
serverMsg = JsonConvert.DeserializeObject <ServerElephantAttackMsg>(dataStr);
break;
case NetworkSettings.SERVER_PLAYER_DISCONNECT:
serverMsg = JsonConvert.DeserializeObject <ServerPlayerDisconnectMsg>(dataStr);
break;
case NetworkSettings.SERVER_NEXT_LEVEL_TIME:
serverMsg = JsonConvert.DeserializeObject <ServerNextLevelTimeMsg>(dataStr);
break;
case NetworkSettings.SERVER_HIGHEST_SCORE:
serverMsg = JsonConvert.DeserializeObject <ServerHighestScoreMsg>(dataStr);
break;
}
if (serverMsg != null)
{
serverMsg.msgType = msgType;
}
return(serverMsg);
}
public void UpdatePackets(ServerMsg opcode)
{
if ((ServerMsg.SERVER_MSG_LOGICBEGIN < opcode) && (this._packets.Count > 0))
{
PacketProcessInfo info = (PacketProcessInfo) this._packets[0];
if (((ServerMsg) (info.Packet.Opcode + 1)) == opcode)
{
this._packets.RemoveAt(0);
this.DisConnect();
}
}
}
public TinodeUnauthorizedExcpetion(ServerMsg msg) : base(msg)
{
}
private void ProcessData(byte[] receiveBuffer, int bufferSize)
{
//Copy the recieved data into new buffer , to avoid null bytes
byte[] recData = new byte[bufferSize];
Buffer.BlockCopy(receiveBuffer, 0, recData, 0, bufferSize);
full_message_buffer += Encoding.ASCII.GetString(recData);
if (full_message_buffer.Contains('\n'))
{
//Debug.Log("Message buffer contains new line");
// split buffer into packets
string[] packets = full_message_buffer.Split('\n');
int packet_index = 0;
foreach (string packet in packets)
{
if (packet_index == packets.Length - 1)
{
break; //ignore last packet as will be incomplete
}
ServerMsg srvMsg = new ServerMsg(packet + '\n');
if (srvMsg.msgIndex != -1 || srvMsg.msgEndIndex != -1)
{
validSrvMsgs.Add(srvMsg);
}
packet_index++;
}
full_message_buffer = packets[packets.Length - 1];
// sort server messages
foreach (ServerMsg validSrvMsg in validSrvMsgs)
{
if (validSrvMsg.senderClientId == -2)
{
serverSrvMsgs.Add(validSrvMsg);
}
else if (validSrvMsg.senderClientId >= 0)
{
clientSrvMsgLists[validSrvMsg.senderClientId].Add(validSrvMsg);
}
}
validSrvMsgs.Clear();
//TODO process direct server messages
serverSrvMsgs.Clear(); // clear server messages after processed
// process server messages from clients
List <bool>[] items_processed = new List <bool> [max_clients_];
for (int client_num = 0; client_num < max_clients_; client_num++)
{
items_processed[client_num] = new List <bool>();
for (int item_index = 0; item_index < clientSrvMsgLists[client_num].Count; item_index++)
{
items_processed[client_num].Add(false);
}
}
for (int client_num = 0; client_num < max_clients_; client_num++)
{
List <ServerMsg> clientSrvMsgList = clientSrvMsgLists[client_num];
for (int item_index = 0; item_index < clientSrvMsgList.Count; item_index++)
{
ServerMsg clientSrvMsg = clientSrvMsgList[item_index];
if (clientSrvMsg.msgEndIndex == 1)
{
// process single packet message
for (int i = 0; i < item_index; i++)
{
items_processed[client_num][i] = true;
}
// remove from process list
items_processed[client_num][item_index] = true;
}
else if (clientSrvMsg.msgEndIndex >= 2 && clientSrvMsg.msgIndex == 0 && (clientSrvMsgList.Count - item_index > clientSrvMsg.msgEndIndex))
{
// mark all preview items as processed
for (int i = 0; i < item_index; i++)
{
items_processed[client_num][i] = true;
}
// search next n items to build complete packet
bool valid_next_items = true;
List <ServerMsg> multiPacketServerMsgs = new List <ServerMsg>();
int item_loc = item_index;
for (int i = 0; i < clientSrvMsg.msgEndIndex; i++)
{
item_loc = item_index + i;
items_processed[client_num][item_loc] = true;
//clientSrvMsgListsUnprocesssed[client_num].RemoveAt(item_loc);
if (i != clientSrvMsgList[item_loc].msgIndex)
{
valid_next_items = false;
break;
}
else
{
multiPacketServerMsgs.Add(clientSrvMsgList[item_loc]);
}
}
item_index = item_loc; //skip processing items that have been process inside here
if (valid_next_items)
{
Debug.Log("found packet list");
// process multi packet server message
String joint_packet_msg = "";
foreach (ServerMsg srvMsgPacket in multiPacketServerMsgs)
{
joint_packet_msg += srvMsgPacket.msg;
}
ServerMsg srvMsg_full = new ServerMsg(
multiPacketServerMsgs[0].senderClientId, multiPacketServerMsgs[0].targetClientId,
multiPacketServerMsgs[0].msgType, joint_packet_msg
);
ReadServerMessage(srvMsg_full);
}
}
}
}
// re-populate client server message lists with only unprocessed items
for (int client_num = 0; client_num < max_clients_; client_num++)
{
List <ServerMsg> newClientSrvMsgList = new List <ServerMsg>();
for (int item_index = 0; item_index < items_processed[client_num].Count; item_index++)
{
if (!items_processed[client_num][item_index])
{
newClientSrvMsgList.Add(clientSrvMsgLists[client_num][item_index]);
}
}
clientSrvMsgLists[client_num] = new List <ServerMsg>(newClientSrvMsgList);
}
}
}
