public void TestMessageReadDefaults()
{
// Make sure reading past the end of a message will apply defaults.
IncomingMessage incomingMsg;
using (var outgoingMsg = new OutgoingMessage())
{
incomingMsg = new IncomingMessage(outgoingMsg.ToByteArray());
}
Assert.AreEqual(false, incomingMsg.ReadBoolean());
Assert.AreEqual(true, incomingMsg.ReadBoolean(defaultValue: true));
Assert.AreEqual(0, incomingMsg.ReadInt32());
Assert.AreEqual(42, incomingMsg.ReadInt32(defaultValue: 42));
Assert.AreEqual(0.0f, incomingMsg.ReadFloat32());
Assert.AreEqual(1337.0f, incomingMsg.ReadFloat32(defaultValue: 1337.0f));
Assert.AreEqual(default(string), incomingMsg.ReadString());
Assert.AreEqual("foo", incomingMsg.ReadString(defaultValue: "foo"));
Assert.AreEqual(default(float[]), incomingMsg.ReadFloatList());
Assert.AreEqual(new float[] { 1001, 1002 }, incomingMsg.ReadFloatList(new float[] { 1001, 1002 }));
}
public void TestMessageReadWrites()
{
var boolVal = true;
var intVal = 1337;
var floatVal = 4.2f;
var floatListVal = new float[] { 1001, 1002 };
var stringVal = "mlagents!";
IncomingMessage incomingMsg;
using (var outgoingMsg = new OutgoingMessage())
{
outgoingMsg.WriteBoolean(boolVal);
outgoingMsg.WriteInt32(intVal);
outgoingMsg.WriteFloat32(floatVal);
outgoingMsg.WriteString(stringVal);
outgoingMsg.WriteFloatList(floatListVal);
incomingMsg = new IncomingMessage(outgoingMsg.ToByteArray());
}
Assert.AreEqual(boolVal, incomingMsg.ReadBoolean());
Assert.AreEqual(intVal, incomingMsg.ReadInt32());
Assert.AreEqual(floatVal, incomingMsg.ReadFloat32());
Assert.AreEqual(stringVal, incomingMsg.ReadString());
Assert.AreEqual(floatListVal, incomingMsg.ReadFloatList());
}
public override void ReadSyncData(IncomingMessage m)
{
wo.SetMaxHealth(m.ReadSingle());
wo.SetHealth(m.ReadSingle());
ActionEnum act = (ActionEnum)m.ReadInt32();
if (wo.GetAction() == ActionEnum.Move && act != ActionEnum.Move)
{
//We were moving and now we are not. Clearing the path
Owner.FindComponent <MovementBehavior>().SetPathForClient(new List <LayerTile>());
}
//If its a building, and we have finished, recover it
if (wo.GetAction() == ActionEnum.Build && act == ActionEnum.Idle && !wo.Mobile())
{
Owner.FindComponent <Sprite>().TintColor = Color.White;
}
wo.SetAction(act);
wo.genericSpeed = m.ReadSingle();
wo.attacking = m.ReadBoolean();
Player p = UIBehavior.ui.activePlayer;
if (p != null && p.selectedWO == this.wo)
{
UIBehavior.ui.UpdateSpeedSlider();
}
}
public void LocalNetworkConnection_OneMessage()
{
LocalNetworkConnection localNetworkConnectionA = new LocalNetworkConnection(1300);
LocalNetworkConnection localNetworkConnectionB = localNetworkConnectionA.GetPairedNetworkConnection();
{
OutgoingMessage outgoingMessage = localNetworkConnectionA.GetOutgoingMessageToSend();
Assert.AreEqual(1300, outgoingMessage.MessageData.Length);
outgoingMessage.Write(true);
outgoingMessage.Write(123);
outgoingMessage.Write("yes");
Assert.AreEqual(9, outgoingMessage.Length);
localNetworkConnectionA.SendMessage(outgoingMessage);
}
{
IncomingMessage incomingMessage = localNetworkConnectionB.GetNextIncomingMessage();
Assert.IsNotNull(incomingMessage);
Assert.AreEqual(1300, incomingMessage.MessageData.Length);
Assert.AreEqual(9, incomingMessage.Length);
Assert.AreEqual(0, incomingMessage.Position);
Assert.AreEqual(true, incomingMessage.ReadBoolean());
Assert.AreEqual(1, incomingMessage.Position);
Assert.AreEqual(8, incomingMessage.BytesLeft);
Assert.AreEqual(123, incomingMessage.ReadInt32());
Assert.AreEqual(5, incomingMessage.Position);
Assert.AreEqual(4, incomingMessage.BytesLeft);
Assert.AreEqual("yes", incomingMessage.ReadString());
Assert.AreEqual(9, incomingMessage.Position);
Assert.AreEqual(0, incomingMessage.BytesLeft);
Assert.IsNull(localNetworkConnectionB.GetNextIncomingMessage());
}
}
/// <summary>
/// Read this instance fields from an incoming message.
/// </summary>
/// <param name="incomingMessage">The incoming message</param>
internal void Read(IncomingMessage incomingMessage)
{
this.RoomName = incomingMessage.ReadString();
this.IsVisible = incomingMessage.ReadBoolean();
this.MaxPlayers = incomingMessage.ReadByte();
this.PropertiesListedInLobby = new HashSet <string>(incomingMessage.ReadStringArray());
}
private void ExecuteAction(object sender, IncomingMessage receivedMessage)
{
Entity owner = networkedScene.EntityManager.Find(receivedMessage.ReadString());
Entity other = networkedScene.EntityManager.Find(receivedMessage.ReadString());
if (owner != null && !owner.IsDisposed && other != null && !other.IsDisposed)
{
WorldObject wo = owner.FindComponent <WorldObject>();
CommandEnum cmd = (CommandEnum)receivedMessage.ReadInt32();
foreach (ActionBehavior act in wo.allActions)
{
if (act.GetCommand() == cmd)
{
bool store = receivedMessage.ReadBoolean();
if (store)
{
wo.EnqueueAction(() => act.Act(other.FindComponent <WorldObject>()));
}
else
{
act.Act(other.FindComponent <WorldObject>());
}
break;
}
}
}
}
public void LocalNetworkConnection_ManyMessages_Queued()
{
LocalNetworkConnection localNetworkConnectionA = new LocalNetworkConnection(1300);
LocalNetworkConnection localNetworkConnectionB = localNetworkConnectionA.GetPairedNetworkConnection();
for (int i = 0; i < 20; i++)
{
OutgoingMessage outgoingMessage = localNetworkConnectionA.GetOutgoingMessageToSend();
outgoingMessage.Write(((i % 2) == 0));
outgoingMessage.Write(i);
outgoingMessage.Write(i / 2.0f);
outgoingMessage.Write(i.ToString());
localNetworkConnectionA.SendMessage(outgoingMessage);
}
for (int i = 0; i < 20; i++)
{
IncomingMessage incomingMessage = localNetworkConnectionB.GetNextIncomingMessage();
Assert.IsNotNull(incomingMessage);
Assert.AreEqual(0, incomingMessage.Position);
Assert.AreEqual(((i % 2) == 0), incomingMessage.ReadBoolean());
Assert.AreEqual(i, incomingMessage.ReadInt32());
Assert.AreEqual(i / 2.0f, incomingMessage.ReadSingle());
Assert.AreEqual(i.ToString(), incomingMessage.ReadString());
}
Assert.IsNull(localNetworkConnectionB.GetNextIncomingMessage());
}
/**
* <summary>
* Modifies the color or team of a player
* </summary>
*/
private void ChangePlayerData(object sender, IncomingMessage receivedMessage)
{
string playerIdentifier = receivedMessage.ReadString();
int dataType = receivedMessage.ReadInt32();
Entity ent = networkedScene.EntityManager.Find("playerInfo" + playerIdentifier);
if (ent != null)
{
PlayerInfo info = ent.FindComponent <PlayerInfo>();
bool next = receivedMessage.ReadBoolean();
switch (dataType)
{
case PlayerInfo.READY:
info.ready = !info.ready;
info.ChangeReady();
break;
case PlayerInfo.COLOR:
if (!info.ready)
{
info.playerColor = FindNextColor(info.playerColor);
info.nextColor.Text = ClientDispatcher.colorNames[info.playerColor];
info.nextColor.Foreground = ClientDispatcher.colors[info.playerColor];
info.nextColor.BorderColor = ClientDispatcher.colors[info.playerColor];
}
break;
case PlayerInfo.TEAM:
if (!info.ready)
{
if (next)
{
info.playerTeam = info.playerTeam + 1;
if (info.playerTeam >= ids.Count)
{
info.playerTeam = -1;
}
}
else
{
if (info.playerTeam == -1)
{
info.playerTeam = info.playerTeam + ids.Count;
}
else
{
info.playerTeam = info.playerTeam - 1;
}
}
info.textTeam.Text = info.playerTeam == -1 ? "No team" : "Team " + info.playerTeam;
}
break;
default:
break;
}
}
}
/// <summary>
/// Reads the synchronize data.
/// </summary>
/// <param name="reader">The reader.</param>
internal void ReadSyncData(IncomingMessage reader)
{
for (int componentIndex = 0; componentIndex < this.NetworkSyncComponents.Length; componentIndex++)
{
if (reader.ReadBoolean())
{
var component = this.NetworkSyncComponents[componentIndex];
component.ReadSyncData(reader);
}
}
}
public override void ReadSyncData(IncomingMessage binaryReader)
{
player.playerColor = binaryReader.ReadInt32();
player.playerTeam = binaryReader.ReadInt32();
player.nextColor.Text = ClientDispatcher.colorNames[player.playerColor];
player.textTeam.Text = player.playerTeam == -1 ? "No team" : "Team " + player.playerTeam;
player.nextColor.Foreground = ClientDispatcher.colors[player.playerColor];
player.nextColor.BorderColor = ClientDispatcher.colors[player.playerColor];
player.ready = binaryReader.ReadBoolean();
player.ChangeReady();
}
public override void ReadSyncData(IncomingMessage binaryReader)
{
int nChanges = binaryReader.ReadInt32();
for (int i = 0; i < nChanges; i++)
{
int changeType = binaryReader.ReadInt32();
int x = binaryReader.ReadInt32();
int y = binaryReader.ReadInt32();
if (changeType == OCCUPIED)
{
map.SetTileOccupied(x, y, binaryReader.ReadBoolean());
}
else
{
string woName = binaryReader.ReadString();
if (string.IsNullOrEmpty(woName))
{
if (changeType == MOBILE)
{
map.SetMobile(x, y, null);
}
else if (changeType == WO)
{
map.SetWorldObject(x, y, null);
}
}
else
{
Entity ent = EntityManager.Find(woName);
if (ent != null)
{
if (changeType == MOBILE)
{
map.SetMobile(x, y, ent.FindComponent <WorldObject>());
}
else if (changeType == WO)
{
map.SetWorldObject(x, y, ent.FindComponent <WorldObject>());
}
}
else
{
recover.AddChange(x, y, woName, changeType);
}
}
}
}
}
public void OutgoingAndIncoming_Boolean()
{
byte[] data = new byte[256];
OutgoingMessage outgoingMessage = new OutgoingMessage(data);
Assert.AreEqual(0, outgoingMessage.Length);
for (int value = byte.MinValue; value <= byte.MaxValue; value++)
{
outgoingMessage.Write(((value % 2) == 0));
}
Assert.AreEqual(data.Length, outgoingMessage.Length);
IncomingMessage incomingMessage = new IncomingMessage(data);
for (int value = byte.MinValue; value <= byte.MaxValue; value++)
{
Assert.AreEqual(((value % 2) == 0), incomingMessage.ReadBoolean());
}
}
/// <summary>
/// Refresh the player fields based on the given message.
/// </summary>
/// <param name="message">The received message</param>
internal void ReadFromMessage(IncomingMessage message)
{
var changedFields = (RoomFieldsFlags)message.ReadByte();
if (changedFields.HasFlag(RoomFieldsFlags.IsVisible))
{
this.IsVisible = message.ReadBoolean();
}
if (changedFields.HasFlag(RoomFieldsFlags.MaxPlayers))
{
this.MaxPlayers = message.ReadByte();
}
if (changedFields.HasFlag(RoomFieldsFlags.CustomProperties))
{
this.CustomProperties.ReadFromMessage(message);
}
this.OnChange(changedFields);
}
private void Move(object sender, IncomingMessage receivedMessage)
{
Entity owner = networkedScene.EntityManager.Find(receivedMessage.ReadString());
if (owner != null && !owner.IsDisposed)
{
bool recalculate = receivedMessage.ReadBoolean();
int pathLength = receivedMessage.ReadInt32();
Trace.WriteLine("moving tiles:" + pathLength);
MovementBehavior movement = owner.FindComponent <MovementBehavior>();
if (movement != null && pathLength > 1)
{
List <LayerTile> path = new List <LayerTile>(pathLength);
bool validPath = true;
Map map = Map.map;
//First tile
path.Add(map.GetTileByMapCoordinates(receivedMessage.ReadInt32(), receivedMessage.ReadInt32()));
for (int i = 1; i < pathLength; i++)
{
LayerTile tile = map.GetTileByMapCoordinates(receivedMessage.ReadInt32(), receivedMessage.ReadInt32());
if (tile != null && !path.Contains(tile) && map.Adjacent(tile, path[i - 1])) //Cuando haya restricciones para pasar por una casilla se deben añadir también aquí
{
path.Add(tile);
}
else
{
validPath = false;
break;
}
}
if (validPath)
{
NewPath(owner, movement, path, recalculate);
}
}
}
}
public void LocalNetworkConnection_TwoMessages()
{
LocalNetworkConnection localNetworkConnectionA = new LocalNetworkConnection(1300);
LocalNetworkConnection localNetworkConnectionB = localNetworkConnectionA.GetPairedNetworkConnection();
{
OutgoingMessage outgoingMessage = localNetworkConnectionA.GetOutgoingMessageToSend();
Assert.AreEqual(1300, outgoingMessage.MessageData.Length);
outgoingMessage.Write(true);
outgoingMessage.Write(100.1f);
outgoingMessage.Write("yes");
localNetworkConnectionA.SendMessage(outgoingMessage);
}
{
OutgoingMessage outgoingMessage = localNetworkConnectionA.GetOutgoingMessageToSend();
Assert.AreEqual(1300, outgoingMessage.MessageData.Length);
outgoingMessage.Write(false);
outgoingMessage.Write(200.2f);
outgoingMessage.Write("no");
outgoingMessage.Write(123);
localNetworkConnectionA.SendMessage(outgoingMessage);
}
{
IncomingMessage incomingMessage = localNetworkConnectionB.GetNextIncomingMessage();
Assert.IsNotNull(incomingMessage);
Assert.AreEqual(1300, incomingMessage.MessageData.Length);
Assert.AreEqual(true, incomingMessage.ReadBoolean());
Assert.AreEqual(100.1f, incomingMessage.ReadSingle());
Assert.AreEqual("yes", incomingMessage.ReadString());
}
{
IncomingMessage incomingMessage = localNetworkConnectionB.GetNextIncomingMessage();
Assert.IsNotNull(incomingMessage);
Assert.AreEqual(1300, incomingMessage.MessageData.Length);
Assert.AreEqual(false, incomingMessage.ReadBoolean());
Assert.AreEqual(200.2f, incomingMessage.ReadSingle());
Assert.AreEqual("no", incomingMessage.ReadString());
Assert.AreEqual(123, incomingMessage.ReadInt32());
Assert.IsNull(localNetworkConnectionB.GetNextIncomingMessage());
}
}
public void ClientMessageDispatcher(object sender, IncomingMessage receivedMessage)
{
if (networkedScene.IsDisposed)
{
return;
}
int messageType = receivedMessage.ReadInt32();
switch (messageType)
{
case KICK:
KickClient(sender, receivedMessage);
break;
case ADD_PLAYER:
ClientNewPlayer(sender, receivedMessage);
break;
case NEW_PLAYER:
NewPlayerInfo(sender, receivedMessage);
break;
case REMOVE_PLAYER:
RemovePlayerInfo(sender, receivedMessage);
break;
case UI:
SetAllElementsAndStart(receivedMessage.ReadBoolean());
break;
case ADD_WO:
if (!networkedScene.isHost)
{
ReceiveWOMessage(sender, receivedMessage);
}
break;
case ADD_CASTLE:
if (!networkedScene.isHost)
{
ReceiveCastleMessage(sender, receivedMessage);
}
break;
case DESTROY_WO:
if (!networkedScene.isHost)
{
DestroyWO(sender, receivedMessage);
}
break;
case SYNC:
if (!networkedScene.isHost)
{
Synchro(sender, receivedMessage);
}
break;
case MOVE:
if (!networkedScene.isHost)
{
SynchroPath(sender, receivedMessage);
}
break;
case FINISH:
UIBehavior.ui.Owner.FindComponent <VictoryBehavior>().Finish(receivedMessage.ReadString(), receivedMessage.ReadString());
break;
default:
Trace.WriteLine("Mensaje erróneo recibido desde el servidor");
break;
}
}