public void CheckMessageDie(MessageToClient m)
{
Assert.AreEqual(m.cmd, "update");
Assert.AreEqual(m.id, 101112);
Assert.AreEqual(((MessageDie)m.data.data).killer, "jill");
Assert.AreEqual(((MessageDie)m.data.data).crash, true);
}
private void SocketMessage(object sender, MessageEventArgs e)
{
//invoke when socket message
if (e != null && e.Type == Opcode.Text)
{
try {
MessageToClient m = m_deserializer.Deserialize <MessageToClient>(e.Data);
// TODO: make this a dict to callback
if (m.cmd.Equals("start"))
{
StartPlayer(m.id, "");
}
else if (m.cmd.Equals("remove"))
{
RemovePlayer(m.id);
}
else if (m.cmd.Equals("update"))
{
UpdatePlayer(m.id, m.data);
}
else
{
Debug.LogError("unknown client message: " + m.cmd);
}
} catch (Exception ex) {
Debug.LogException(ex); // TODO: Add object if possible
return;
}
}
}
/// <summary>
///We will get a commannd for the client and by the command know what to do
///The format is commandid#string for example let suppose 1 is for sending config it will be 1x where x is the json string of the object.
/// </summary>
/// <param name="client"> The client</param>
/// <param name="locker">The object we want to lock </param>
public void HandleClient(TcpClient client, object locker)
{
//creating a task that will handle the client's commands.
Task t = new Task(() =>
{
NetworkStream stream = client.GetStream();
BinaryReader reader = new BinaryReader(stream);
BinaryWriter writer = new BinaryWriter(stream);
while (true)
{
//Getting the command.
//readMutex.WaitOne();
string commandLine = reader.ReadString();
// readMutex.ReleaseMutex();
Console.WriteLine("Got input: {0}", commandLine);
//Getting id of command
int id = int.Parse(commandLine[0] + "");
string result = ExecuteCommand(commandLine, client);
Console.WriteLine("Write the result");
Console.WriteLine("Im here for " + commandLine);
//Sending to the client the result - false because we handle specific client
MessageToClient message = new MessageToClient(id, result,false);
//Locking this critical place
lock (locker)
{
writer.Write(message.ToJSON());
}
}
//client.Close();
});
t.Start();
}
public void OnReceive(IMessage message)
{
if (!(message is MessageToClient))
{
throw new Exception("Recieve Error !");
}
MessageToClient msg = message as MessageToClient;
//自己的id小于0时为未初始化状态，此时初始化自己的id，然后发送message选择天赋
if (this.id < 0)
{
isStartedGame = true;
foreach (var gameObject in msg.GameObjectList)
{
this.id = gameObject.Key;
this.team = gameObject.Value.Team;
Console.WriteLine("\nThis Player :\n" + "\t" + id.ToString() + "\n\tposition: " + Position.ToString());
ClientCommunication.SendMessage(new MessageToServer
{
Talent = playerTalent,
IsSetTalent = true
});
break;
}
messageToServer.ID = this.id;
}
this.Position = new XYPosition(msg.GameObjectList[this.id].PositionX, msg.GameObjectList[this.id].PositionY);
this._facingDirection = (THUnity2D.Direction)msg.GameObjectList[this.id].Direction;
ChangeAllLabels(msg);
}
/// <summary>
/// a function that handles the receiving of the incomming messages from the server.
/// </summary>
/// <returns></returns>
public MessageToClient recieveMessage()
{
Task <MessageToClient> t = new Task <MessageToClient>(() =>
{
stream = client.GetStream();
reader = new BinaryReader(stream);
string result;
try
{
result = reader.ReadString();
}
catch (Exception)
{
connected = false;
return(null);
}
MessageToClient message = new MessageToClient();
message.FromJson(result);
// Get result from server
return(message);
});
t.Start();
if (t.Result == null)
{
throw new Exception("Problem connecting");
}
return(t.Result);
}
public void OnReciveNormal(MessageToClient msg, long clock) //处理游戏消息
{
switch (msg.MessageType)
{
case MessageType.StartGame:
Hashable = new Dictionary <Int64, Tuple <int, int> >();
for (int i = 0; i < msg.PlayerGUIDs.Count; i++)
{
for (int j = 0; j < msg.PlayerGUIDs[0].TeammateGUIDs.Count; j++)
{
Hashable.Add(msg.PlayerGUIDs[i].TeammateGUIDs[j], new Tuple <int, int>(i, j));
}
}
gameform.movespeed = msg.SelfInfo.MoveSpeed;
break;
case MessageType.Gaming:
if (System.Environment.TickCount64 - clock > 50)
{
break;
}
Refresh(msg);
break;
case MessageType.EndGame:
Application.Exit();
break;
default: break;
}
}
public void CheckMessageSetColor(MessageToClient m)
{
Assert.AreEqual(m.cmd, "update");
Assert.AreEqual(m.id, 123);
Assert.AreEqual(((MessageSetColor)m.data.data).color, "red");
Assert.AreEqual(((MessageSetColor)m.data.data).style, "bold");
}
private void Refresh(MessageToClient msg) //刷新界面
{
gameform.selfguid = msg.SelfInfo.Guid;
gameform.movespeed = msg.SelfInfo.MoveSpeed;
for (int i = 0; i < 50; i++) //读取颜色
{
for (int j = 0; j < 50; j++)
{
if (gameform.ColorState[i, j] == (int)msg.CellColors[j].RowColors[i])
{
gameform.ColorChange[i, j] = false;
}
else
{
gameform.ColorState[i, j] = (int)msg.CellColors[j].RowColors[i];
gameform.ColorChange[i, j] = true;
}
}
}
foreach (var objinfo in msg.GameObjs)
{
Objdeal(objinfo);
}
gameform.Rebuild();
}
public void WriteOne(MessageToClient msg)
{
cos.WriteMessage(msg);
if (ms.Length > memoryCapacity)
{
Flush();
}
}
public void ChangeTaskLabel(MessageToClient msg)
{
Program.form.ControlLabels["Task"].Text = "Task : ";
foreach (var task in msg.Tasks)
{
Program.form.ControlLabels["Task"].Text += "\n" + (DishType)task;
}
}
private void UpdatePlayer(MessageToClient msg)
{
NetPlayer player;
if (!m_players.TryGetValue(msg.id, out player))
{
return;
}
player.SendUnparsedEvent(msg.data);
}
public void SendMessage(MessageToClient msg)
{
Message message = new Message();
message.Content = msg;
message.PacketType = PacketType.MessageToClient;
byte[] bytes;
message.WriteTo(out bytes);
Send(bytes);
}
public Server(ushort serverPort, ushort playerCount, ushort agentCount, uint MaxGameTimeSeconds, string token)
{
Communication.Proto.Constants.PlayerCount = playerCount;
Communication.Proto.Constants.AgentCount = agentCount;
MaxRunTimeInSecond = MaxGameTimeSeconds;
ServerCommunication = new CommunicationImpl
{
ServerPort = serverPort,
Token = token
};
ServerCommunication.Initialize();
ServerCommunication.MsgProcess += OnRecieve;
ServerCommunication.GameStart();
//初始化playerList
//向所有Client发送他们自己的ID
XYPosition[] bornPoints = { new XYPosition(2.5, 1.5), new XYPosition(48.5, 2.5), new XYPosition(48.5, 48.5), new XYPosition(2.5, 48.5) };
for (int a = 0; a < Constants.AgentCount; a++)
{
Program.MessageToClient.Scores.Add(a, 0);
Program.ScoreLocks.TryAdd(a, new object());
for (int c = 0; c < Constants.PlayerCount; c++)
{
Tuple <int, int> playerIDTuple = new Tuple <int, int>(a, c);
Program.PlayerList.TryAdd(playerIDTuple, new Player(bornPoints[a].x, bornPoints[a].y));//new Random().Next(2, WORLD_MAP_WIDTH - 2), new Random().Next(2, WORLD_MAP_HEIGHT - 2)));
Program.PlayerList[playerIDTuple].CommunicationID = playerIDTuple;
MessageToClient msg = new MessageToClient();
msg.GameObjectList.Add(
Program.PlayerList[playerIDTuple].ID,
new Communication.Proto.GameObject
{
ObjType = ObjType.People,
IsMoving = false,
Team = playerIDTuple.Item1,
PositionX = Program.PlayerList[playerIDTuple].Position.x,
PositionY = Program.PlayerList[playerIDTuple].Position.y,
Direction = (Communication.Proto.Direction)Program.PlayerList[playerIDTuple].FacingDirection
});
ServerCommunication.SendMessage(new ServerMessage
{
Agent = a,
Client = c,
Message = msg
}
);
}
}
SendMessageToAllClient();
ServerRunThread = new Thread(Run);
ServerRunThread.Start();
Server.ServerDebug("Server constructed");
}
public int CompareTo(object o)
{
MessageToClient m = o as MessageToClient;
if (m != null)
{
return(id.CompareTo(m.id));
}
else
{
throw new NullReferenceException("Невозможно сравнить два объекта");
}
}
private void LogMessage(MessageToClient msg)
{
MessageLogMessage data = m_deserializer.Deserialize <MessageLogMessage>(msg.data);
if (data.type == "error")
{
m_log.Error(data.msg);
}
else
{
m_log.Tell(data.msg);
}
}
public void sendMessage(MessageToClient msgToClt)
{
try
{
byte[] sendByte = Encoding.Default.GetBytes(msgToClt.ToString());
socket.Send(sendByte, sendByte.Length, 0);
}
catch (Exception ex)
{
Console.WriteLine("发送失败。");
Console.WriteLine(ex);
throw;
}
}
/// <summary>
/// sending messages to all the clients.
/// </summary>
/// <param name="type"></param>
/// <param name="content"></param>
/// <param name="client"></param>
/// <param name="allClients"></param>
public void SendMessage(int type, string content, TcpClient client, bool allClients)
{
NetworkStream stream = client.GetStream();
BinaryReader reader = new BinaryReader(stream);
BinaryWriter writer = new BinaryWriter(stream);
//Convert to type of message
MessageToClient message = new MessageToClient(type, content, allClients);
//Locking this critical place
lock (locker)
{
writer.Write(message.ToJSON());
}
}
private void StartGame(MessageToClient msg)
{
HFTMessageGameStart data = m_deserializer.Deserialize <HFTMessageGameStart>(msg.data);
m_id = data.id;
QueueEvent(() =>
{
var handler = OnConnect;
if (handler != null)
{
handler();
}
});
}
public void OnReceive(IMessage message)
{
UnityEngine.Debug.Log("received:" + message.ToString());
if (!(message is MessageToClient))
{
throw new Exception("Recieve Error !");
}
MessageToClient msg = message as MessageToClient;
//this.id.Item1 = msg.PlayerIDAgent;
//this.id.Item2 = msg.PlayerIDClient;
x = (float)BitConverter.Int64BitsToDouble(msg.PlayerPositionX);
y = (float)BitConverter.Int64BitsToDouble(msg.PlayerPositionY);
UnityEngine.Debug.Log("Player " + msg.PlayerIDAgent.ToString() + " , " + msg.PlayerIDClient.ToString() + " position: " + $"{x},{y}");
}
public void ChangeAllLabels(MessageToClient msg)
{
if (lastRecieveMessage.GetHashCode() == msg.GetHashCode())
{
//Console.WriteLine("Same messageToClient");
return;
}
IDsToDelete = new HashSet <long>(Program.form.playerLabels.Keys);
foreach (var gameObject in msg.GameObjectList)
{
moveFormLabel(gameObject.Key, gameObject.Value, ref IDsToDelete);
}
foreach (var number in IDsToDelete)
{
Console.WriteLine("Delete Form : " + number);
if (Program.form.InvokeRequired)
{
Program.form.Invoke(new Action(() =>
{
Program.form.Controls.Remove(Program.form.playerLabels[number]);
}));
}
else
{
Program.form.Controls.Remove(Program.form.playerLabels[number]);
}
Program.form.playerLabels.Remove(number);
}
if (lastRecieveMessage.Tasks.GetHashCode() != msg.Tasks.GetHashCode())
{
if (Program.form.ControlLabels["Task"].InvokeRequired)
{
Program.form.ControlLabels["Task"].Invoke(new Action <MessageToClient>(ChangeTaskLabel), msg);
}
else
{
ChangeTaskLabel(msg);
}
}
if (msg.Scores.ContainsKey(team))
{
ChangeControlLabelText("Score", msg.Scores[team].ToString());
}
}
private void UpdateGame(MessageToClient msg)
{
try
{
HFTMessageCmd cmd = m_deserializer.Deserialize <HFTMessageCmd>(msg.data);
CmdEventHandler handler;
if (!m_handlers.TryGetValue(cmd.cmd, out handler))
{
m_log.Error("unhandled GameServer cmd: " + cmd.cmd);
return;
}
handler(m_deserializer, this, cmd.data, msg.id);
}
catch (Exception ex)
{
m_log.Error(ex);
}
}
public void MoreAdvancedTest()
{
Deserializer deserializer = new Deserializer();
MessageCmdDataCreator mcdc = new MessageCmdDataCreator();
mcdc.RegisterCreator <MessageSetColor>();
mcdc.RegisterCreator <MessageSetName>();
mcdc.RegisterCreator <MessageLaunch>();
mcdc.RegisterCreator <MessageDie>();
deserializer.RegisterCreator(mcdc);
string ja = "{\"cmd\":\"update\",\"id\":123,\"data\":{\"cmd\":\"setColor\",\"data\":{\"color\":\"red\",\"style\":\"bold\"}}}";
string jb = "{\"cmd\":\"update\",\"id\":345,\"data\":{\"cmd\":\"setName\",\"data\":{\"name\":\"gregg\"}}}";
string jc = "{\"cmd\":\"update\",\"id\":789,\"data\":{\"cmd\":\"launch\",\"data\":{}}}";
string jd = "{\"cmd\":\"update\",\"id\":101112,\"data\":{\"cmd\":\"die\",\"data\":{\"killer\":\"jill\",\"crash\":true}}}";
MessageToClient ma = deserializer.Deserialize <MessageToClient>(ja);
MessageToClient mb = deserializer.Deserialize <MessageToClient>(jb);
MessageToClient mc = deserializer.Deserialize <MessageToClient>(jc);
MessageToClient md = deserializer.Deserialize <MessageToClient>(jd);
CheckMessageSetColor(ma);
CheckMessageSetName(mb);
CheckMessageLaunch(mc);
CheckMessageDie(md);
string sa = Serialize.From(ma);
string sb = Serialize.From(mb);
string sc = Serialize.From(mc);
string sd = Serialize.From(md);
MessageToClient ma2 = deserializer.Deserialize <MessageToClient>(sa);
MessageToClient mb2 = deserializer.Deserialize <MessageToClient>(sb);
MessageToClient mc2 = deserializer.Deserialize <MessageToClient>(sc);
MessageToClient md2 = deserializer.Deserialize <MessageToClient>(sd);
CheckMessageSetColor(ma2);
CheckMessageSetName(mb2);
CheckMessageLaunch(mc2);
CheckMessageDie(md2);
}
private async Task OnMessageAsync(MessageToClient message)
{
try
{
var networkCommand = JsonUtility.FromJson <NetworkCommand>(message.data);
if (networkCommand.commandInternalIsResponse)
{
_connection.ResolveTransaction(networkCommand, message.data);
}
else
{
try
{
var responseToMaster = await _commands.ProcessIncomingMessage(_connection, networkCommand, message.data, _client);
responseToMaster.commandInternalType = NetworkCommand.CommandTypeFor(responseToMaster.GetType());
responseToMaster.commandInternalIsResponse = true;
responseToMaster.commandInternalId = networkCommand.commandInternalId;
await _connection.Send(responseToMaster);
}
catch (Exception error)
{
_manager.Logger.OnError(error);
await _connection.Send(new NetworkCommandError()
{
message = error.Message,
commandInternalType = NetworkCommand.CommandTypeFor(typeof(NetworkCommandError)),
commandInternalIsResponse = true,
commandInternalId = networkCommand.commandInternalId
});
}
}
}
catch (Exception error)
{
_manager.Logger.OnError(error);
}
}
public MessageToClient?ReadOne()
{
beginRead:
if (Finished)
{
return(null);
}
var pos = cos.Position;
try
{
MessageToClient?msg = new MessageToClient();
cos.ReadMessage(msg);
return(msg);
}
catch (InvalidProtocolBufferException)
{
var leftByte = buffer.Length - pos; // 上次读取剩余的字节
for (int i = 0; i < leftByte; ++i)
{
buffer[i] = buffer[pos + i];
}
var bufferSize = gzs.Read(buffer, (int)leftByte, (int)(buffer.Length - leftByte)) + leftByte;
if (bufferSize == leftByte)
{
Finished = true;
return(null);
}
if (bufferSize != buffer.Length) // 不留空位，防止 CodedInputStream 获取信息错误
{
var tmpBuffer = new byte[bufferSize];
Array.Copy(buffer, tmpBuffer, bufferSize);
buffer = tmpBuffer;
}
cos = new CodedInputStream(buffer);
goto beginRead;
}
}
private void StartPlayer(MessageToClient msg)
{
if (m_players.ContainsKey(msg.id))
{
return;
}
string name = "";
RealNetPlayer.Options options = new RealNetPlayer.Options();
if (msg.data != null)
{
DeJson.Deserializer deserializer = new DeJson.Deserializer();
HFTPlayerStartData startData = deserializer.Deserialize <HFTPlayerStartData>(msg.data);
if (startData != null)
{
options.sessionId = startData.__hft_session_id__;
name = startData.__hft_name__;
}
}
if (System.String.IsNullOrEmpty(name))
{
name = "Player" + (++m_totalPlayerCount);
}
NetPlayer player = new RealNetPlayer(this, msg.id, name, options);
m_players[msg.id] = player;
QueueEvent(() =>
{
var handler = OnPlayerConnect;
if (handler != null)
{
handler(new PlayerConnectMessageArgs(player, name, msg.data));
}
});
}
private void GameStart(MessageToClient message)
{
//根据agent发来的消息初始化各个角色
foreach (var obj in message.GameObjs)
{
if (obj.GameObjType == GameObjType.Character)
{
if (heros.ContainsKey(obj.Guid))
{
heros[obj.Guid].Renew(obj); //存在就更新数据
}
else
{
if (!isCharactersExisted.ContainsKey(obj.Guid))
{
isCharactersExisted.TryAdd(obj.Guid, true);
TaskQueue.Enqueue(new KeyValuePair <long, GameObjInfo>(obj.Guid, obj)); //不存在就标记并创建，下面同理
}
}
}
}
isGameStarted = true;
}
void ReadPlayback()
{
// 新建一个timer，每隔固定时间读一段消息
IMessage <MessageToClient> message;
playbackTimer = new System.Threading.Timer(
(o) =>
{
lock (playbackLock)
{
message = new MessageToClient();
if (playbackReader.Read(ref message))
{
OnReceive(message);
}
else
{
Debug.Log("回放结束");
playbackTimer.Dispose();
}
}
}, null, 0, 50);
}
public void MoreAdvancedTest()
{
MessageCmdDataCreator.Instance.RegisterCreator <MessageSetColor>();
MessageCmdDataCreator.Instance.RegisterCreator <MessageSetName>();
MessageCmdDataCreator.Instance.RegisterCreator <MessageLaunch>();
MessageCmdDataCreator.Instance.RegisterCreator <MessageDie>();
string ja = "{\"cmd\":\"update\",\"id\":123,\"data\":{\"cmd\":\"setColor\",\"data\":{\"color\":\"red\",\"style\":\"bold\"}}}";
string jb = "{\"cmd\":\"update\",\"id\":345,\"data\":{\"cmd\":\"setName\",\"data\":{\"name\":\"gregg\"}}}";
string jc = "{\"cmd\":\"update\",\"id\":789,\"data\":{\"cmd\":\"launch\",\"data\":{}}}";
string jd = "{\"cmd\":\"update\",\"id\":101112,\"data\":{\"cmd\":\"die\",\"data\":{\"killer\":\"jill\",\"crash\":true}}}";
MessageToClient ma = JsonUtil.ToObject <MessageToClient>(ja);
MessageToClient mb = JsonUtil.ToObject <MessageToClient>(jb);
MessageToClient mc = JsonUtil.ToObject <MessageToClient>(jc);
MessageToClient md = JsonUtil.ToObject <MessageToClient>(jd);
CheckMessageSetColor(ma);
CheckMessageSetName(mb);
CheckMessageLaunch(mc);
CheckMessageDie(md);
string sa = JsonUtil.ToJson(ma);
string sb = JsonUtil.ToJson(mb);
string sc = JsonUtil.ToJson(mc);
string sd = JsonUtil.ToJson(md);
MessageToClient ma2 = JsonUtil.ToObject <MessageToClient>(sa);
MessageToClient mb2 = JsonUtil.ToObject <MessageToClient>(sb);
MessageToClient mc2 = JsonUtil.ToObject <MessageToClient>(sc);
MessageToClient md2 = JsonUtil.ToObject <MessageToClient>(sd);
CheckMessageSetColor(ma2);
CheckMessageSetName(mb2);
CheckMessageLaunch(mc2);
CheckMessageDie(md2);
}
public void PlayBack()
{
Console.WriteLine("Press any key to start playback");
Console.ReadKey();
IMessage <MessageToClient> message;
playBackTimer = new System.Threading.Timer(
(o) =>
{
lock (PlayBackLock)
{
message = new MessageToClient();
if (Reader.Read(ref message))
{
OnReceive(message);
}
else
{
Console.WriteLine("PlayBack End !");
playBackTimer.Dispose();
}
}
}, null, 0, 50);
}
private void SocketMessage(object sender, MessageEventArgs e)
{
m_gotMessages = true;
//invoke when socket message
if (e != null && e.IsText)
{
try
{
// Handle ping.
if (e.Data == "P")
{
Send("P");
return;
}
if (m_options.showMessages)
{
m_log.Tell("r[" + (m_recvCount++) + "] " + e.Data);
}
MessageToClient m = m_deserializer.Deserialize <MessageToClient>(e.Data);
MessageHandler handler = null;
if (m_msgHandlers.TryGetValue(m.cmd, out handler))
{
handler(m);
}
else
{
m_log.Error("unknown client message: " + m.cmd);
}
}
catch (Exception ex)
{
m_log.Error(ex); // TODO: Add object if possible
return;
}
}
}
