public void WithData_SerializedDeserialized_Success()
{
var target = ServerCurrentStateTransferMessage.Create()
.AddDoor(3, 4)
.SetExit(1, 2)
.AddPlayer(43, 5, 6)
.AddUnit(0, 3, 7, 8, 9);
target.Map.Add(Base.Screens.RegionValue.Path);
target.Map.Add(Base.Screens.RegionValue.Wall);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerCurrentStateTransferMessage)parser.Read(data);
Assert.AreEqual(target.Doors.Count, obj.Doors.Count);
Assert.AreEqual(target.Doors[0].X, obj.Doors[0].X);
Assert.AreEqual(target.Doors[0].Y, obj.Doors[0].Y);
Assert.AreEqual(target.Exit.X, obj.Exit.X);
Assert.AreEqual(target.Exit.Y, obj.Exit.Y);
Assert.AreEqual(target.Players.Count, obj.Players.Count);
Assert.AreEqual(target.Players[0].PlayerId, obj.Players[0].PlayerId);
Assert.AreEqual(target.Players[0].Units.Count, obj.Players[0].Units.Count);
Assert.AreEqual(target.Players[0].Units[0].UnitId, obj.Players[0].Units[0].UnitId);
Assert.AreEqual(target.Players[0].Units[0].Position.X, obj.Players[0].Units[0].Position.X);
Assert.AreEqual(target.Players[0].Units[0].Position.Y, obj.Players[0].Units[0].Position.Y);
Assert.AreEqual(target.Map.Count, obj.Map.Count);
Assert.AreEqual(target.Map[0], obj.Map[0]);
Assert.AreEqual(target.Map[1], obj.Map[1]);
}
protected override void DoAction(Entity entity, System.TimeSpan gameTime)
{
base.DoAction(entity, gameTime);
var localServer = entity.GetComponent <LocalServerComponent>();
var server = entity.GetComponent <ServerComponent>();
if (localServer.PendingConnections.Count > 0)
{
for (var i = 0; i < localServer.PendingConnections.Count; i++)
{
server.ConnectedPlayers++;
var tcpClient = localServer.PendingConnections[i];
localServer.Clients.Add(tcpClient);
localServer.ConnectionKeyToClient[server.ConnectedPlayers] = tcpClient;
localServer.ClientToConnectionKey[tcpClient] = server.ConnectedPlayers;
server.Request[localServer.ClientToConnectionKey[tcpClient]] = new Queue <ITransferMessage>();
server.Response[localServer.ClientToConnectionKey[tcpClient]] = new Queue <ITransferMessage>();
localServer.Request[tcpClient] = new Queue <string>();
localServer.Response[tcpClient] = new Queue <string>();
}
localServer.PendingConnections.Clear();
}
for (var i = 0; i < localServer.Clients.Count; i++)
{
var client = localServer.Clients[i];
var connectionKey = localServer.ClientToConnectionKey[client];
if (localServer.Request.ContainsKey(client) && localServer.Request[client].Count > 0)
{
var request = localServer.Request[client];
while (request.Count > 0)
{
var data = request.Dequeue();
var parser = TransferMessageParserUtils.FindReader(data, parsers);
var transferMessage = parser.Read(data);
server.Request[connectionKey].Enqueue(transferMessage);
}
}
if (server.Response.ContainsKey(connectionKey) && server.Response[connectionKey].Count > 0)
{
var response = server.Response[connectionKey];
while (response.Count > 0)
{
var transferMessage = response.Dequeue();
var parser = TransferMessageParserUtils.FindWriter(transferMessage, parsers);
var data = parser.Write(transferMessage);
localServer.Response[client].Enqueue(data);
(transferMessage as IPoolableTransferMessage)?.Free();
}
}
}
}
public void NewPositionNotExists_SerializedDeserialized_Success()
{
var target = ClientTurnDoneTransferMessage.Create();
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ClientTurnDoneTransferMessage)parser.Read(data);
Assert.AreEqual(target.UnitActions.Count, obj.UnitActions.Count);
}
public void EmptyObject_SerializedDeserialized_Success()
{
var target = ServerYourTurnTransferMessage.Create();
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerYourTurnTransferMessage)parser.Read(data);
Assert.NotNull(obj);
}
public void MinimumData_SerializedDeserialized_Success()
{
var target = ClientConnectTransferMessage.Create();
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ClientConnectTransferMessage)parser.Read(data);
Assert.AreEqual(target.PlayerName, obj.PlayerName);
}
public void EmptyData_SerializedDeserialized_Success()
{
var target = ServerYouConnectedTransferMessage.Create();
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerYouConnectedTransferMessage)parser.Read(data);
Assert.AreEqual(target.PlayerId, obj.PlayerId);
Assert.AreEqual(target.UnitsData, obj.UnitsData);
}
public void WithData_SerializedDeserialized_Success()
{
var target = ServerPlayerTurnMadeTransferMessage.Create()
.SetPlayerId(43);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerPlayerTurnMadeTransferMessage)parser.Read(data);
Assert.AreEqual(target.PlayerId, obj.PlayerId);
}
public void WithData_SerializedDeserialized_Success()
{
var target = ServerGameStartedTransferMessage.Create()
.SetSize(43, 76);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerGameStartedTransferMessage)parser.Read(data);
Assert.AreEqual(target.Width, obj.Width);
Assert.AreEqual(target.Height, obj.Height);
}
public void AllDataWithoutPlayerNameAndUnits_SerializedDeserialized_Success()
{
var target = ServerClientConnectedTransferMessage.Create()
.SetData(34, null, 43, 12);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerClientConnectedTransferMessage)parser.Read(data);
Assert.AreEqual(target.CurrentCount, obj.CurrentCount);
Assert.AreEqual(target.PlayerId, obj.PlayerId);
Assert.AreEqual(target.PlayerName, obj.PlayerName);
Assert.AreEqual(target.WaitingCount, obj.WaitingCount);
}
public void NoSkills_SerializedDeserialized_Success()
{
var target = ClientConnectTransferMessage.Create()
.SetPlayerName("Player1")
.AddUnitType(UnitUtils.UnitType.Mage);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ClientConnectTransferMessage)parser.Read(data);
Assert.AreEqual(target.PlayerName, obj.PlayerName);
Assert.AreEqual(target.UnitsData.Count, obj.UnitsData.Count);
Assert.AreEqual(target.UnitsData[0].UnitType, obj.UnitsData[0].UnitType);
Assert.AreEqual(target.UnitsData[0].Skills, obj.UnitsData[0].Skills);
}
public void WithoutData_SerializedDeserialized_Success()
{
var target = ServerCurrentStateTransferMessage.Create()
.AddPlayer(43, 2, 3);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerCurrentStateTransferMessage)parser.Read(data);
Assert.AreEqual(target.Doors, obj.Doors);
Assert.AreEqual(target.Exit, obj.Exit);
Assert.AreEqual(target.Players.Count, obj.Players.Count);
Assert.AreEqual(target.Players[0].PlayerId, obj.Players[0].PlayerId);
Assert.AreEqual(target.Players[0].Units, obj.Players[0].Units);
Assert.AreEqual(target.Map, obj.Map);
}
public void AllDataWithPlayerName_SerializedDeserialized_Success()
{
var target = ServerClientConnectedTransferMessage.Create()
.SetData(34, "Player1", 43, 12)
.AddUnit(16, UnitUtils.UnitType.Warrior);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerClientConnectedTransferMessage)parser.Read(data);
Assert.AreEqual(target.CurrentCount, obj.CurrentCount);
Assert.AreEqual(target.PlayerId, obj.PlayerId);
Assert.AreEqual(target.PlayerName, obj.PlayerName);
Assert.AreEqual(target.WaitingCount, obj.WaitingCount);
Assert.AreEqual(target.Units.Count, obj.Units.Count);
Assert.AreEqual(target.Units[0].UnitId, obj.Units[0].UnitId);
Assert.AreEqual(target.Units[0].UnitType, obj.Units[0].UnitType);
}
public void WithData_SerializedDeserialized_Success()
{
var target = ServerYouConnectedTransferMessage.Create()
.SetPlayerId(35)
.AddUnit(3, UnitUtils.UnitType.Ranger, 2, 1, 0, 0, true, 0, 0, 0);
var parser = TransferMessageParserUtils.FindWriter(target);
Assert.IsTrue(parser.IsWritable(target));
var data = parser.Write(target);
Console.WriteLine(data);
var obj = (ServerYouConnectedTransferMessage)parser.Read(data);
Assert.AreEqual(target.PlayerId, obj.PlayerId);
Assert.AreEqual(target.UnitsData.Count, obj.UnitsData.Count);
Assert.AreEqual(target.UnitsData[0].UnitType, obj.UnitsData[0].UnitType);
Assert.AreEqual(target.UnitsData[0].VisionRange, obj.UnitsData[0].VisionRange);
Assert.AreEqual(target.UnitsData[0].MoveRange, obj.UnitsData[0].MoveRange);
Assert.AreEqual(target.UnitsData[0].UnitId, obj.UnitsData[0].UnitId);
Assert.AreEqual(target.UnitsData[0].AttackFriendlyFire, obj.UnitsData[0].AttackFriendlyFire);
}
protected override void DoAction(Entity entity, TimeSpan gameTime)
{
base.DoAction(entity, gameTime);
var localClient = entity.GetComponent <LocalClientComponent>();
var client = entity.GetComponent <ClientComponent>();
var serverEntity = this.scene.FindEntity(localClient.ServerEntity);
var localServer = serverEntity.GetComponent <LocalServerComponent>();
if (localClient.Identifier == Guid.Empty)
{
localClient.Identifier = Guid.NewGuid();
localServer.PendingConnections.Add(localClient.Identifier);
return;
}
if (client.Message != null)
{
var transferMessage = client.Message;
var parser = TransferMessageParserUtils.FindWriter(transferMessage, this.parsers);
var data = parser.Write(transferMessage);
localServer.Request[localClient.Identifier].Enqueue(data);
(client.Message as IPoolableTransferMessage)?.Free();
client.Message = null;
}
var response = localServer.Response[localClient.Identifier];
(client.Response as IPoolableTransferMessage)?.Free();
client.Response = null;
if (response.Count > 0)
{
var data = response.Dequeue();
var parser = TransferMessageParserUtils.FindReader(data, parsers);
var transferMessage = parser.Read(data);
client.Response = transferMessage;
}
}
protected override void DoAction(Entity entity, TimeSpan gameTime)
{
base.DoAction(entity, gameTime);
#if Bridge
System.Diagnostics.Debug.WriteLine("Network server is not available for web version.");
#else
var networkServer = entity.GetComponent <NetworkServerComponent>();
var server = entity.GetComponent <ServerComponent>();
if (networkServer.Listener == null)
{
networkServer.Listener = new TcpListener(IPAddress.Parse(networkServer.Ip), networkServer.Port);
networkServer.Listener.Start();
}
if (networkServer.ConnectResult == null)
{
networkServer.ConnectResult = networkServer.Listener.BeginAcceptTcpClient((a) => { }, null);
}
if (networkServer.ConnectResult.IsCompleted)
{
server.ConnectedPlayers++;
var tcpClient = networkServer.Listener.EndAcceptTcpClient(networkServer.ConnectResult);
networkServer.Clients.Add(tcpClient);
networkServer.ConnectionKeyToClient[server.ConnectedPlayers] = tcpClient;
networkServer.ClientToConnectionKey[tcpClient] = server.ConnectedPlayers;
server.Request[networkServer.ClientToConnectionKey[tcpClient]] = new Queue <ITransferMessage>();
server.Response[networkServer.ClientToConnectionKey[tcpClient]] = new Queue <ITransferMessage>();
networkServer.ConnectResult = null;
}
for (var i = 0; i < networkServer.Clients.Count; i++)
{
var tcpClient = networkServer.Clients[i];
var connectionKey = networkServer.ClientToConnectionKey[tcpClient];
if (tcpClient.Available > 0)
{
byte[] bytes = new byte[tcpClient.Available];
tcpClient.GetStream().Read(bytes, 0, tcpClient.Available);
string data = Encoding.UTF8.GetString(bytes);
if (Regex.IsMatch(data, "^GET", RegexOptions.IgnoreCase))
{
// 1. Obtain the value of the "Sec-WebSocket-Key" request header without any leading or trailing whitespace
// 2. Concatenate it with "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" (a special GUID specified by RFC 6455)
// 3. Compute SHA-1 and Base64 hash of the new value
// 4. Write the hash back as the value of "Sec-WebSocket-Accept" response header in an HTTP response
string swk = Regex.Match(data, "Sec-WebSocket-Key: (.*)").Groups[1].Value.Trim();
string swka = swk + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
byte[] swkaSha1 = System.Security.Cryptography.SHA1.Create().ComputeHash(Encoding.UTF8.GetBytes(swka));
string swkaSha1Base64 = Convert.ToBase64String(swkaSha1);
var value = "HTTP/1.1 101 Switching Protocols\r\n" +
"Connection: Upgrade\r\n" +
"Upgrade: websocket\r\n" +
"Sec-WebSocket-Accept: " + swkaSha1Base64 + "\r\n\r\n";
byte[] responseBytes = Encoding.UTF8.GetBytes(value);
tcpClient.GetStream().Write(responseBytes, 0, value.Length);
continue;
}
data = Encoding.UTF8.GetString(GetDecodedData(bytes, bytes.Length));
var parser = TransferMessageParserUtils.FindReader(data, parsers);
var transferMessage = parser.Read(data);
server.Request[connectionKey].Enqueue(transferMessage);
continue;
}
var response = server.Response[connectionKey];
if (response.Count > 0)
{
var transferMessage = response.Dequeue();
var parser = TransferMessageParserUtils.FindWriter(transferMessage, parsers);
var data = parser.Write(transferMessage);
(transferMessage as IPoolableTransferMessage)?.Free();
byte[] frame = GetFrameFromBytes(Encoding.UTF8.GetBytes(data));
tcpClient.GetStream().Write(frame, 0, frame.Length);
tcpClient.GetStream().Flush();
return;
}
}
#endif
}
protected override void DoAction(Entity entity, TimeSpan gameTime)
{
base.DoAction(entity, gameTime);
var networkClient = entity.GetComponent <NetworkClientComponent>();
var client = entity.GetComponent <ClientComponent>();
if (networkClient.Client == null)
{
networkClient.Client = new ClientWebSocket();
networkClient.Client.ConnectAsync(networkClient.ServerAddress, CancellationToken.None);
}
if (networkClient.Client.State != WebSocketState.Open)
{
return;
}
(client.Response as IPoolableTransferMessage)?.Free();
client.Response = null;
if (client.Message != null)
{
var transferMessage = client.Message;
var parser = TransferMessageParserUtils.FindWriter(transferMessage, parsers);
var data = parser.Write(transferMessage);
networkClient.Client.SendAsync(
new ArraySegment <byte>(Encoding.UTF8.GetBytes(data)),
WebSocketMessageType.Text,
true,
CancellationToken.None);
(client.Message as IPoolableTransferMessage)?.Free();
client.Message = null;
return;
}
if (networkClient.RecievingTask == null)
{
networkClient.RecievingTask = networkClient.Client.ReceiveAsync(networkClient.RecievingBuffer, CancellationToken.None);
}
if (networkClient.RecievingTask.IsCompleted)
{
var result = networkClient.RecievingTask.Result;
networkClient.RecievingTask = null;
ms.Seek(0, SeekOrigin.Begin);
ms.SetLength(0);
ms.Write(networkClient.RecievingBuffer.Array, networkClient.RecievingBuffer.Offset, result.Count);
while (!result.EndOfMessage)
{
result = networkClient.Client.ReceiveAsync(networkClient.RecievingBuffer, CancellationToken.None).Result;
ms.Write(networkClient.RecievingBuffer.Array, networkClient.RecievingBuffer.Offset, result.Count);
}
;
ms.Seek(0, SeekOrigin.Begin);
var data = reader.ReadToEnd();
var parser = TransferMessageParserUtils.FindReader(data, parsers);
var transferMessage = parser.Read(data);
client.Response = transferMessage;
}
}
