/// <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()); }