/// <summary>
/// Reads the entity.
/// </summary>
/// <param name="message">The message.</param>
/// <returns>Return the serialized entity from message</returns>
private Entity ReadEntity(IncomingMessage message)
{
var data = message.ReadBytes();
using (var stream = new MemoryStream())
{
stream.Write(data, 0, data.Length);
stream.Seek(0, SeekOrigin.Begin);
var entity = this.serializer.Deserialize(stream);
return (Entity)entity;
}
}
public override void ReadSyncData(IncomingMessage reader)
{
var x = reader.ReadSingle();
var y = reader.ReadSingle();
this.transform.Position = new Vector2(x, y);
}
/// <summary>
/// Creates the new entity.
/// </summary>
/// <param name="fromNetworkId">From network identifier.</param>
/// <param name="fromNetworkBehaviorId">From network behavior identifier.</param>
/// <param name="reader">The reader.</param>
/// <param name="factoryId">The factory identifier.</param>
/// <returns>The network behavior os created entity</returns>
private NetworkBehavior CreateNewEntity(string fromNetworkId, string fromNetworkBehaviorId, IncomingMessage reader, string factoryId)
{
Entity entity;
if (factoryId == SerializationFactoryId)
{
entity = this.ReadEntity(reader);
}
else
{
entity = this.CreateEntity(factoryId, fromNetworkId, fromNetworkBehaviorId);
}
var behavior = this.RegisterEntityBehavior(entity, fromNetworkId, fromNetworkBehaviorId, this.SceneId, factoryId, true);
this.scene.EntityManager.Add(entity);
behavior.ReadSyncData(reader);
return behavior;
}
/// <summary>
/// Handles the message.
/// </summary>
/// <param name="receivedmessage">The receivedmessage.</param>
private void HandleMessage(IncomingMessage receivedmessage)
{
var fromNetworkId = receivedmessage.ReadString();
var type = (NetworkSyncType)receivedmessage.ReadInt32();
var fromNetworkBehaviorId = receivedmessage.ReadString();
var factoryId = receivedmessage.ReadString();
if (type == NetworkSyncType.Update)
{
NetworkBehavior behavior;
if (this.entityBehaviors.TryGetValue(fromNetworkBehaviorId, out behavior))
{
if (behavior.CreatedByBehavior)
{
behavior.ReadSyncData(receivedmessage);
}
}
}
else if (type == NetworkSyncType.Start)
{
foreach (var item in this.entityBehaviors.Where(x => !x.Value.CreatedByBehavior).ToList())
{
this.SendResponseToRecreateThisEntity(item.Value);
}
}
else if (type == NetworkSyncType.Create && !this.entityBehaviors.ContainsKey(fromNetworkBehaviorId))
{
var behavior = this.CreateNewEntity(fromNetworkId, fromNetworkBehaviorId, receivedmessage, factoryId);
}
else if (type == NetworkSyncType.Remove)
{
NetworkBehavior behavior;
if (this.entityBehaviors.TryGetValue(fromNetworkBehaviorId, out behavior))
{
if (behavior.CreatedByBehavior)
{
this.RemoveNetworkEntity(behavior);
}
}
}
}
/// <summary>
/// Handles the messages received from the clients. Only when this player is the host.
/// </summary>
private void HostMessageReceived(object sender, IncomingMessage receivedMessage)
{
var playerIdentifier = receivedMessage.ReadString();
var playerSpriteIndex = receivedMessage.ReadInt32();
var resultPlayerSpriteIndex = this.AssignPlayerSpriteIndex(playerIdentifier, playerSpriteIndex);
var responseMessage = this.networkService.CreateServerMessage();
responseMessage.Write(playerIdentifier);
responseMessage.Write(resultPlayerSpriteIndex);
this.networkService.SendToClients(responseMessage, DeliveryMethod.ReliableUnordered);
}
/// <summary>
/// Handles the menssage.
/// </summary>
/// <param name="receivedmessage">The receivedmessage.</param>
internal static void HandleMenssage(IncomingMessage receivedmessage)
{
var sceneId = receivedmessage.ReadString();
WeakReference<NetworkManager> managerReference;
if (registeredScenes.TryGetValue(sceneId, out managerReference))
{
NetworkManager registeredManager;
if (managerReference.TryGetTarget(out registeredManager))
{
registeredManager.HandleMessage(receivedmessage);
}
}
}
/// <summary>
/// Called when [client message received].
/// </summary>
/// <param name="receivedMessage">The received message.</param>
protected virtual void OnClientMessageReceived(IncomingMessage receivedMessage)
{
if (receivedMessage.Type == MessageType.Synchronization)
{
WaveServices.Dispatcher.RunOnWaveThread(() => NetworkManager.HandleMenssage(receivedMessage));
return;
}
var handler = this.ClientMessageReceived;
if (handler != null)
{
handler(this, receivedMessage);
}
}
/// <summary>
/// Reads a <see cref="ClientIncomingMessageTypes"/> type from an incoming message
/// </summary>
/// <param name="incomingMessage">The message</param>
/// <returns>A <see cref="ClientIncomingMessageTypes"/> type</returns>
internal static ClientIncomingMessageTypes ReadClientIncomingMessageType(this IncomingMessage incomingMessage)
{
return((ClientIncomingMessageTypes)incomingMessage.ReadByte());
}
/// <summary>
/// Res the send to clients.
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="deliveryMethod">The delivery method.</param>
public void ReSendToClients(IncomingMessage obj, DeliveryMethod deliveryMethod)
{
this.networkServer.Send(obj, deliveryMethod);
}
/// <summary>
/// Called when [host message received].
/// </summary>
/// <param name="receivedMessage">The received message.</param>
protected virtual void OnHostMessageReceived(IncomingMessage receivedMessage)
{
if (receivedMessage.Type == MessageType.Synchronization)
{
this.ReSendToClients(receivedMessage);
return;
}
var handler = this.HostMessageReceived;
if (handler != null)
{
handler(this, receivedMessage);
}
}
/// <summary>
/// Res the send to clients.
/// </summary>
/// <param name="obj">The object.</param>
public void ReSendToClients(IncomingMessage obj)
{
this.networkServer.Send(obj, (DeliveryMethod)obj.Message.DeliveryMethod);
}
/// <summary>
/// Reads a <see cref="EnterRoomResultCodes"/> type from an incoming message
/// </summary>
/// <param name="incomingMessage">The message</param>
/// <returns>A <see cref="EnterRoomResultCodes"/> type</returns>
internal static EnterRoomResultCodes ReadEnterRoomResultCode(this IncomingMessage incomingMessage)
{
return((EnterRoomResultCodes)incomingMessage.ReadByte());
}
/// <summary>
/// Reads a <see cref="ServerIncomingMessageTypes"/> type from an incoming message
/// </summary>
/// <param name="incomingMessage">The message</param>
/// <returns>A <see cref="ServerIncomingMessageTypes"/> type</returns>
internal static ServerIncomingMessageTypes ReadServerIncomingMessageType(this IncomingMessage incomingMessage)
{
return((ServerIncomingMessageTypes)incomingMessage.ReadByte());
}
/// <summary>
/// Called when [message received].
/// </summary>
/// <param name="receivedMessage">The received message.</param>
protected virtual void OnMessageReceived(IncomingMessage receivedMessage)
{
var handler = this.MessageReceived;
if (handler != null)
{
handler(this, receivedMessage);
}
}
/// <summary>
/// Handles the messages received from the host.
/// </summary>
private void ClientMessageReceived(object sender, IncomingMessage receivedMessage)
{
var playerIdentifier = receivedMessage.ReadString();
var playerSpriteIndex = receivedMessage.ReadInt32();
if (this.networkService.ClientIdentifier == playerIdentifier)
{
this.HandlePlayerSelectionResponse(playerSpriteIndex);
}
}
/// <summary>
/// Sends the specified incoming message.
/// </summary>
/// <param name="incomingMessage">The incoming message.</param>
/// <param name="deliveryMethod">The delivery method.</param>
public void Send(IncomingMessage incomingMessage, DeliveryMethod deliveryMethod)
{
for (int index = 0; index < this.server.Connections.Count; index++)
{
var netConnection = this.server.Connections[index];
if (netConnection != incomingMessage.Message.SenderConnection)
{
var message = this.server.CreateMessage(incomingMessage.Message.LengthBytes);
message.Write(incomingMessage.Message.Data);
this.server.SendMessage(message, netConnection, (NetDeliveryMethod)deliveryMethod);
}
}
}
/// <summary>
/// Reads a player id from the message
/// </summary>
/// <param name="incomingMessage">The message</param>
/// <returns>The player id</returns>
internal static int ReadPlayerId(this IncomingMessage incomingMessage)
{
return(incomingMessage.ReadInt32());
}
