public void OutgoingAndIncoming_StringToStringBuilder()
{
byte[] data = new byte[512];
OutgoingMessage outgoingMessage = new OutgoingMessage(data);
Assert.AreEqual(0, outgoingMessage.Length);
outgoingMessage.Write(string.Empty);
outgoingMessage.Write("");
outgoingMessage.Write("yyyyyyyyyes");
outgoingMessage.Write("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()-_=+[{]}\\|;:'\"/?.>,<\r\n\t");
Assert.AreEqual(112, outgoingMessage.Length);
IncomingMessage incomingMessage = new IncomingMessage(data);
{
StringBuilder stringBuilder = new StringBuilder(16);
incomingMessage.ReadString(stringBuilder);
Assert.AreEqual(string.Empty, stringBuilder.ToString());
}
{
StringBuilder stringBuilder = new StringBuilder(16);
incomingMessage.ReadString(stringBuilder);
Assert.AreEqual("", stringBuilder.ToString());
}
{
StringBuilder stringBuilder = new StringBuilder(16);
incomingMessage.ReadString(stringBuilder);
Assert.AreEqual("yyyyyyyyyes", stringBuilder.ToString());
}
{
StringBuilder stringBuilder = new StringBuilder(16);
incomingMessage.ReadString(stringBuilder);
Assert.AreEqual("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()-_=+[{]}\\|;:'\"/?.>,<\r\n\t", stringBuilder.ToString());
}
}
public void Write(OutgoingMessage msgOut)
{
msgOut.Write(MessageTypes.Spawn);
msgOut.Write(Id);
msgOut.Write(Position);
msgOut.Write(Color);
}
private void HandleSetPlayerProperties(NetworkEndpoint fromEndpoint, IncomingMessage receivedMessage)
{
var fromPlayer = this.FindPlayer(fromEndpoint);
if (fromPlayer != null)
{
OutgoingMessage refreshPlayerPropsMsg = null;
if (fromPlayer.Room != null)
{
// Send to players in the same room
refreshPlayerPropsMsg = this.CreateServerMessage(ClientIncomingMessageTypes.RefreshOtherPlayerProperties);
refreshPlayerPropsMsg.Write(fromPlayer.Id);
refreshPlayerPropsMsg.Write(receivedMessage);
}
fromPlayer.ReadFromMessage(receivedMessage);
if (refreshPlayerPropsMsg != null)
{
var otherPlayersInRoom = this.GetOtherPlayersInRoom(fromPlayer);
this.SendToPlayers(refreshPlayerPropsMsg, otherPlayersInRoom);
}
this.PlayerSynchronized?.Invoke(this, fromPlayer);
}
}
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());
}
}
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>
/// Writes this instance fields to an outgoing message.
/// </summary>
/// <param name="outgoingMessage">The outgoing message</param>
internal void Write(OutgoingMessage outgoingMessage)
{
outgoingMessage.Write(this.RoomName);
outgoingMessage.Write(this.IsVisible);
outgoingMessage.Write(this.MaxPlayers);
outgoingMessage.Write(this.PropertiesListedInLobby);
}
public void Write(OutgoingMessage msgOut)
{
msgOut.Write((byte)MessageTypes.Move);
msgOut.Write(Id);
msgOut.Write(Input);
msgOut.Write(Sequence);
}
public override void WriteSyncData(OutgoingMessage writer)
{
lastWood = player.woodAmount;
lastWO = player.selectedWO != null?player.selectedWO.GetWoName() : string.Empty;
writer.Write(lastWood);
writer.Write(lastWO);
}
private void SendFinish(string playerName, string v)
{
OutgoingMessage mes = ns.networkService.CreateServerMessage();
mes.Write(NetworkedScene.FINISH);
mes.Write(playerName);
mes.Write(v);
ns.networkService.SendToClients(mes, DeliveryMethod.ReliableOrdered);
}
public override void WriteSyncData(OutgoingMessage writer)
{
lastPeople = cot.GetOccupation();
writer.Write(lastPeople);
foreach (WorldObject wo in cot.GetPeople())
{
writer.Write(wo.Owner.Name);
}
}
public override void WriteSyncData(OutgoingMessage writer)
{
lastTeam = player.playerTeam;
lastColor = player.playerColor;
lastReady = player.ready;
writer.Write(lastColor);
writer.Write(lastTeam);
writer.Write(lastReady);
}
public void OutgoingMessage_Reset()
{
byte[] data = new byte[256];
OutgoingMessage outgoingMessage = new OutgoingMessage(data);
outgoingMessage.Write(1234.555f);
outgoingMessage.Write(1200);
Assert.AreEqual(8, outgoingMessage.Length);
outgoingMessage.Reset();
Assert.AreEqual(0, outgoingMessage.Length);
}
public override void WriteSyncData(OutgoingMessage writer)
{
lastBuildings = person.buildings;
lastTrees = person.trees;
lastHeals = person.heals;
lastFights = person.fights;
writer.Write(lastBuildings);
writer.Write(lastTrees);
writer.Write(lastHeals);
writer.Write(lastFights);
}
private void Introduce(RemoteConnection remote, IPEndPoint endPoint)
{
Debug.Log("NATServer: Introducing: ", endPoint.ToString(), " to: ", remote.EndPoint.ToString());
OutgoingMessage message = MessagePool.CreateMessage();
message.Write(NATMessageType.INTRODUCTION);
message.Write(endPoint);
remote.Send(message);
MessagePool.Recycle(message);
}
// Param == connection to be introduced
public void Introduce(NATRemote conn)
{
Debug.Log("NATServer: Introducing: ", conn.Remote.EndPoint.ToString(), " to: ", Remote.EndPoint.ToString());
OutgoingMessage message = MessagePool.CreateMessage();
message.Write(NATMessageType.INTRODUCTION);
message.Write(conn.Remote.EndPoint);
Remote.Send(message);
MessagePool.Recycle(message);
}
public void Write(OutgoingMessage msgOut)
{
msgOut.Write(MessageTypes.SynchronizeMessage);
msgOut.Write(Players.Length);
for (int i = 0; i < Players.Length; i++)
{
msgOut.Write(Players[i].Id);
msgOut.Write(Players[i].Position);
msgOut.Write(Players[i].Color);
}
}
/// <summary>
/// Writes the specified fields to an outgoing message.
/// </summary>
/// <param name="message">The outgoing message</param>
/// <param name="includedFields">Indicates the fields that must synchronized</param>
protected void WriteToMessage(OutgoingMessage message, PlayerFliedsFlags includedFields)
{
message.Write((byte)includedFields);
if (includedFields.HasFlag(PlayerFliedsFlags.Nickname))
{
message.Write(this.Nickname);
}
if (includedFields.HasFlag(PlayerFliedsFlags.CustomProperties))
{
this.CustomProperties.WriteToMessage(message);
}
}
/// <summary>
/// Writes the synchronize data.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="components">The components.</param>
internal void WriteSyncData(OutgoingMessage writer, NetworkSyncComponent[] components)
{
for (int componentIndex = 0; componentIndex < components.Length; componentIndex++)
{
var component = components[componentIndex];
if (component != null)
{
writer.Write(true);
component.WriteSyncData(writer);
}
else
{
writer.Write(false);
}
}
}
/// <summary>
/// Sends a message to a remote connection
/// </summary>
public void RequestIntroduction(ulong hostId)
{
OutgoingMessage request = MessagePool.CreateMessage();
// IPAddress local = NetUtilities.GetLocalAddress();
request.Write(NATMessageType.REQUEST_INTRODUCTION);
request.Write(hostId);
fixed(byte *bytes = request.Data)
{
ENet.MicroSend(Peer, 0, bytes, (IntPtr)request.ByteCount, DeliveryMethod.Reliable);
}
MessagePool.Recycle(request);
}
public static IEnumerable <OutgoingMessage> TrySplit(OutgoingMessage msg, int mtu)
{
if (msg.BodyLength <= mtu) //does not need split this message
{
return new OutgoingMessage[1] {
msg
}
}
;
if (msg.BodyLength > (byte.MaxValue + 1) * mtu)
{
throw new AgNetException("Message too long. Maximum message size is " + (byte.MaxValue * mtu).ToString());
}
List <OutgoingMessage> list = new List <OutgoingMessage>();
byte[] data = msg.GetBody();
int needMessages = (int)Math.Ceiling(msg.BodyLength / (double)mtu);
for (byte i = 0; i < needMessages; i++)
{
OutgoingMessage newMsg = new OutgoingMessage(PacketType.PartialMessage);
newMsg.Channel = i;
if (i == needMessages - 1)
{
newMsg.Channel = byte.MaxValue;
}
int offset = i * mtu;
newMsg.Write(data, offset, Math.Min(mtu, data.Length - offset));
list.Add(newMsg);
}
return(list);
}
public override void WriteSyncData(OutgoingMessage writer)
{
lastMaxHealth = wo.GetMaxHealth();
lastHealth = wo.GetHealth();
lastAction = wo.GetAction();
lastSpeed = wo.genericSpeed;
lastAttacking = wo.attacking;
writer.Write(lastMaxHealth);
writer.Write(lastHealth);
writer.Write((int)lastAction);
writer.Write(lastSpeed);
writer.Write(lastAttacking);
}
private void Sync()
{
for (int i = 0; i < NetworkSyncComponents.Length; i++)
{
NetworkSyncComponent c = NetworkSyncComponents[i];
if (c.NeedSendSyncData())
{
OutgoingMessage mes = scene.networkService.CreateServerMessage();
mes.Write(NetworkedScene.SYNC);
mes.Write(c.Owner.Name);
mes.Write(c.GetType().ToString());
c.WriteSyncData(mes);
scene.networkService.SendToClients(mes, DeliveryMethod.ReliableOrdered);
Trace.WriteLine("sending to clients: " + c.Owner.Name);
}
}
}
private void NewPlayerInfo(object sender, IncomingMessage receivedMessage)
{
if (playerInfo.Count == 0)
{
AddHeader();
}
string playerIdentifier = receivedMessage.ReadString();
string playerName = receivedMessage.ReadString();
bool playerAlreadyExists = false;
for (int i = 0; i < playerInfo.Count; i++)
{
if (playerInfo[i].playerIdentifier == playerIdentifier)
{
playerAlreadyExists = true;
//break;
}
else if (networkedScene.isHost)
{
//We must resend the all the info as the new player does not have any of that
PlayerInfoSync infoSync = playerInfo[i].Owner.FindComponent <PlayerInfoSync>();
OutgoingMessage mes = networkedScene.networkService.CreateServerMessage();
mes.Write(NetworkedScene.SYNC);
mes.Write(infoSync.Owner.Name);
mes.Write(infoSync.GetType().ToString());
infoSync.WriteSyncData(mes);
networkedScene.networkService.SendToClients(mes, DeliveryMethod.ReliableOrdered);
}
}
if (!playerAlreadyExists)
{
Entity p = new Entity("playerInfo" + playerIdentifier);
PlayerInfo info = new PlayerInfo();
info.Set(playerIdentifier, playerName,
networkedScene.networkService.ClientIdentifier == playerIdentifier,
playerInfo.Count,
networkedScene);
p.AddComponent(info)
.AddComponent(new PlayerInfoSync())
.AddComponent(new SyncBehavior());
playerInfo.Add(info);
networkedScene.EntityManager.Add(p);
}
}
public void HandleHostListRequest(RemoteConnection remote)
{
Debug.Log(config.Name, ": Request for a list of hosts was received");
OutgoingMessage listMsg = MessagePool.CreateMessage();
listMsg.Write(NATMessageType.REQUEST_HOST_LIST);
listMsg.Write(registeredHosts.Count);
foreach (NATHost item in registeredHosts.Values)
{
item.Info.WriteMessage(listMsg);
}
remote.Send(listMsg);
MessagePool.Recycle(listMsg);
}
/// <summary>
/// Writes all room fields to an outgoing message.
/// </summary>
/// <param name="message">The outgoing message</param>
/// <param name="joinedPlayer">The player that will receive the message</param>
internal void WriteJoinToMessage(OutgoingMessage message, ServerPlayer joinedPlayer)
{
this.WriteToMessage(message, RoomFieldsFlags.All);
message.Write(this.PlayerCount - 1);
foreach (var player in this.AllPlayers)
{
if (player != joinedPlayer)
{
message.Write(player.Id);
player.WriteToMessage(message);
}
}
message.Write(joinedPlayer.Id);
this.CustomProperties.ForceFullSync();
this.CustomProperties.WriteToMessage(message);
}
/// <summary>
/// Writes the specified fields to an outgoing message.
/// </summary>
/// <param name="message">The outgoing message</param>
/// <param name="includedFields">Indicates the fields that must synchronized</param>
protected void WriteToMessage(OutgoingMessage message, RoomFieldsFlags includedFields)
{
message.Write((byte)includedFields);
if (includedFields.HasFlag(RoomFieldsFlags.IsVisible))
{
message.Write(this.IsVisible);
}
if (includedFields.HasFlag(RoomFieldsFlags.MaxPlayers))
{
message.Write(this.MaxPlayers);
}
if (includedFields.HasFlag(RoomFieldsFlags.CustomProperties))
{
this.CustomProperties.WriteToMessage(message);
}
}
public void CreateAndSync(SendData data)
{
networkedScene.sentMessages++;
if (data.creating != "Castle")
{
Entity ent = UIBehavior.ui.Create(data);
if (ent != null && ent.Scene != null)
{
OutgoingMessage mes = networkService.CreateServerMessage();
mes.Write(ADD_WO);
mes.Write(data.clientId);
mes.Write(data.creating);
mes.Write(data.position.X);
mes.Write(data.position.Y);
mes.Write(ent.Name);
networkService.SendToClients(mes, WaveEngine.Networking.Messages.DeliveryMethod.ReliableOrdered);
}
}
else
{
LayerTile tile = Map.map.GetTileByWorldPosition(data.position);
if (tile != null)
{
Castle castle = new Castle();
Entity entity = new Entity()
.AddComponent(new Transform2D())
.AddComponent(castle);
Player p = UIBehavior.ui.FindPlayer(data.clientId);
bool createdCastle = castle.SetCastle(tile.X, tile.Y,
PopulateNetworkedGame.castleWidth, PopulateNetworkedGame.castleHeight,
p, data.clientId);
if (createdCastle)
{
entity.Name = ("WO-Castle" + data.clientId + "-" + new Random().NextDouble() + "-" + data.creating);
networkedScene.EntityManager.Add(entity);
p.castle = castle;
castle.player = p;
OutgoingMessage mes = networkService.CreateServerMessage();
mes.Write(ADD_CASTLE);
mes.Write(data.clientId);
mes.Write(entity.Name);
mes.Write(castle.GetSize());
for (int i = 0; i < castle.GetSize(); i++)
{
WorldObject part = castle.GetPart(i);
networkedScene.EntityManager.Add(part.Owner);
mes.Write(part.Owner.Name);
mes.Write(part.GetX());
mes.Write(part.GetY());
}
networkService.SendToClients(mes, WaveEngine.Networking.Messages.DeliveryMethod.ReliableOrdered);
}
}
}
}
/// <summary>
/// Writes the serialized entity.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="offlineEntity">The offline entity.</param>
private void WriteEntity(OutgoingMessage message, Entity offlineEntity)
{
using (var stream = new MemoryStream())
{
this.serializer.Serialize(stream, offlineEntity);
var data = new byte[stream.Length];
stream.Seek(0, SeekOrigin.Begin);
stream.Read(data, 0, data.Length);
message.Write(data);
}
}
private static IncomingMessage Receive(OutgoingMessage outgoingMessage)
{
var buffer = new StringBuilder();
using (var writer = XmlWriter.Create(buffer))
{
outgoingMessage.Write(writer);
writer.Flush();
}
var reader = XmlReader.Create(new StringReader(buffer.ToString()));
return new IncomingMessage(reader);
}
public void Send(GalaxyID peer, OutgoingMessage message)
{
using (MemoryStream stream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(stream))
{
message.Write(writer);
stream.Seek(0L, SeekOrigin.Begin);
Send(peer, stream.ToArray());
}
}
}
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());
}
}
private static void WriteResponse(HttpContext ctx, OutgoingMessage outgoingMessage)
{
using (var memoryStream = new MemoryStream())
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8
};
using (var writer = XmlWriter.Create(memoryStream, settings))
{
Log.Debug("Writing response to stream.");
outgoingMessage.Write(writer);
writer.Flush();
}
var buffer = memoryStream.GetBuffer();
ctx.Response.OutputStream.Write(buffer, 0, (int)memoryStream.Length);
}
}
private static void SerializeRequestBody(HttpWebRequest httpRequest, OutgoingMessage requestMessage)
{
using (var memoryStream = new MemoryStream())
{
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8
};
using (var writer = XmlWriter.Create(memoryStream, settings))
{
requestMessage.Write(writer);
writer.Flush();
}
var buffer = memoryStream.GetBuffer();
httpRequest.ContentLength = memoryStream.Length;
var bodyStream = httpRequest.GetRequestStream();
bodyStream.Write(buffer, 0, (int)memoryStream.Length);
bodyStream.Close();
}
}