/// <summary> /// Dispatches the <see cref="EventMessage"/> (this) to the supplied <see cref="INetworkMessageReceiver"/>. /// </summary> /// <param name="receiver">The target <see cref="INetworkMessageReceiver"/>.</param> /// <exception cref="ArgumentNullException">Throws if either parameters are null.</exception> /// <param name="parameters">The <see cref="IMessageParameters"/> of the <see cref="EventMessage"/>.</param> public override void Dispatch(INetworkMessageReceiver receiver, IMessageParameters parameters) { Throw<ArgumentNullException>.If.IsNull(receiver) ?.Now(nameof(receiver), $"{nameof(INetworkMessageReceiver)} parameter is null in {this.GetType().Name}"); Throw<ArgumentNullException>.If.IsNull(parameters) ?.Now(nameof(parameters), $"{nameof(IMessageParameters)} parameter is null in {this.GetType().Name}"); receiver.OnNetworkMessageReceive(this, parameters); }
public static bool Verify(this IStaticPayloadParameters actualParameters, IMessageParameters expectedParameters) { Throw<ArgumentNullException>.If.IsNull(actualParameters) ?.Now(nameof(actualParameters), $"{nameof(actualParameters)} cannot be null for {nameof(Verify)} extension method."); Throw<ArgumentNullException>.If.IsNull(expectedParameters) ?.Now(nameof(expectedParameters), $"{nameof(expectedParameters)} cannot be null for {nameof(Verify)} extension method."); return Verify(actualParameters, expectedParameters.Encrypted, expectedParameters.Channel, expectedParameters.DeliveryMethod); }
/// <summary> /// Called internally when a request is recieved. (setup using the subscription service) /// </summary> /// <param name="message">Incoming payload.</param> /// <param name="parameters">Parameters the message was sent with.</param> protected override void OnReceiveRequest(IRequestMessage message, IMessageParameters parameters) { Throw <ArgumentNullException> .If .IsNull(message)?.Now(nameof(message), $"This indicates a critical error. The GladNet API has provided a null {nameof(IRequestMessage)} to the {nameof(OnReceiveRequest)} method."); Throw <ArgumentNullException> .If .IsNull(parameters)?.Now(nameof(parameters), $"This indicates a critical error. The GladNet API has provided a null {nameof(IMessageParameters)} to the {nameof(OnReceiveRequest)} method."); //We're not interested in unencrypted messages on the ProxyLoadBalancing server if (!parameters.Encrypted) { Logger.WarnFormat("Client: {0} at IP {1} tried to send unencrypted payload Type: {2}", PeerDetails.ConnectionID, PeerDetails.RemoteIP, message.GetType()); return; } //Sends off the payload to the provided handlers. requestHandlerService.TryProcessMessage(message, parameters, this); }
/// <summary> /// Handles a <see cref="PacketPayload"/> sent as an event. /// </summary> /// <param name="payload">Event payload data from the network.</param> public abstract void OnReceiveEvent(IEventMessage message, IMessageParameters parameters);
/// <summary> /// Handles the <see cref="IResponseMessage"/> and specified <typeparamref name="TPayloadType"/>. /// </summary> /// <param name="payload">Packet payload to be handled.</param> /// <param name="parameters">Message parameters (null with Photon)</param> /// <param name="peer">The peer that recieved this <see cref="TPayloadType"/> payload.</param> protected abstract void OnIncomingHandlableMessage(IResponseMessage message, TPayloadType payload, IMessageParameters parameters, TPeerType peer);
protected override void OnIncomingHandlableMessage(IEventMessage message, PlayerEntitySpawnEventPayload payload, IMessageParameters parameters, InstanceClientPeer peer) { if (Logger.IsInfoEnabled) { Logger.Info($"Recieved spawn event for ID: {payload.EntityGuid.EntityId}."); } IEntitySpawnResults details = playerFactory.SpawnPlayerEntity(payload.Position.ToVector3(), payload.Rotation.ToQuaternion(), new NetworkPlayerSpawnContext(payload.EntityGuid, peer)); if (details.Result != SpawnResult.Success) { throw new InvalidOperationException($"Failed to spawn entity with Type: {payload.EntityGuid.EntityType} Id: {payload.EntityGuid.EntityId}."); } //TODO: Should we do this in the factory? //Add to collection entityCollection.Add(payload.EntityGuid, new EntityContainer(payload.EntityGuid, details.EntityGameObject)); OnCreatedEntity(details.EntityGameObject); }
//[Inject] //private readonly IGameObjectPrefabEntityFactory objectFactory; protected override void OnIncomingHandlableMessage(IEventMessage message, GameObjectEntitySpawnEventPayload payload, IMessageParameters parameters, InstanceClientPeer peer) { /*logger.Debug($"Recieved GameObject spawn event with Id: {payload.EntityGuid.EntityId} and Type: {payload.PrefabId}."); * * IEntitySpawnResults details = objectFactory.TrySpawnEntity(payload.Position.ToVector3(), payload.Rotation.ToQuaternion(), * payload.Scale.ToVector3(), new NetworkGameObjectPrefabSpawnContext(payload.EntityGuid, payload.PrefabId, peer)); * * if (details.Result != SpawnResult.Success) * { * Debug.LogError($"Failed to create GameObject for Entity Id: {payload.EntityGuid.EntityId} Type: {payload.PrefabId}."); * return; * } * * entityCollection.Add(payload.EntityGuid, new EntityContainer(payload.EntityGuid, details.EntityGameObject)); * * //TODO: Set default state. * IEntityStateContainer state = details.EntityGameObject.GetComponentInChildren<IEntityStateContainer>(); * * if (state == null) * return; * * state.State = payload.CurrentState;*/ }
public static bool MatchesMessageParameters(this IStaticPayloadParameters payload, IMessageParameters messageParameters) { return(payload.Channel == messageParameters.Channel && payload.DeliveryMethod == messageParameters.DeliveryMethod && messageParameters.Encrypted == payload.Encrypted); }
protected override void OnIncomingHandlableMessage(IResponseMessage message, ClaimSessionResponsePayload payload, IMessageParameters parameters, InstanceClientPeer peer) { //TODO: Implement spawning if (Logger.IsInfoEnabled) { Logger.Info($"Recieved player spawn response. {payload.ResponseCode} {payload.Position} {payload.Rotation}"); } GameObject entityGameObject = gameobjectFactory.CreateBuilder() .With(Service <INetPeer> .As(peer)) .With(Service <NetworkEntityGuid> .As(payload.EntityGuid)) .Create(playerPrefab, payload.Position.ToVector3(), payload.Rotation.ToQuaternion()); //TODO: Should we do this in the factory? //Add to collection entityCollection.Add(payload.EntityGuid, new EntityContainer(payload.EntityGuid, entityGameObject)); OnCreatedEntity(entityGameObject); }
protected override void OnIncomingHandlableMessage(IResponseMessage message, PlayerSpawnResponsePayload payload, IMessageParameters parameters, InstanceClientPeer peer) { //TODO: Implement spawning logger.Info($"Recieved player spawn response. {payload.ResponseCode} {payload.Position} {payload.Rotation}"); gameobjectFactory.CreateBuilder() .With(Service <INetPeer> .As(peer)) .With(Service <NetworkEntityGuid> .As(payload.EntityGuid)) .Create(playerPrefab, payload.Position.ToVector3(), payload.Rotation.ToQuaternion()); }
protected override void OnIncomingHandlableMessage(IRequestMessage message, PlayerSpawnRequestPayload payload, IMessageParameters parameters, InstanceClientSession peer) { //TODO: Right now we don't have a full handshake for entering an instance. So we need to make up a GUID for the entering player //Important to check if we've actually already created an entity for this connection //We don't have that implemenented though for the demo //rely on the factory implementation to handle placement details such as position and rotation NetworkEntityGuid guid = entityGuidFactory.Create(EntityType.Player); IEntitySpawnResults details = playerEntityFactory.SpawnPlayerEntity(new NetworkPlayerSpawnContext(guid, peer)); if (details.Result != SpawnResult.Success) { throw new InvalidOperationException($"Failed to create Entity for {peer.ToString()}. Failure: {details.Result.ToString()}"); } //TODO: This is temporary stuff for demo entityCollection.Add(guid, new EntityContainer(guid, details.EntityGameObject)); peerCollection.Add(peer); connectionRegistry.Register(peer.PeerDetails.ConnectionID, guid); //TODO: Clean this up Vector3Surrogate pos = details.EntityGameObject.transform.position.ToSurrogate(); QuaternionSurrogate rot = details.EntityGameObject.transform.rotation.ToSurrogate(); //Send the response to the player who requested to spawn peer.SendResponse(new PlayerSpawnResponsePayload(PlayerSpawnResponseCode.Success, pos, rot, guid), DeliveryMethod.ReliableUnordered, true, 0); //TODO: Remove this. This is demo code. foreach (var entity in entityCollection.Values.Where(e => e.NetworkGuid.EntityType == EntityType.GameObject)) { ITagProvider <GameObjectPrefab> prefabTag = entity.WorldObject.GetComponent <ITagProvider <GameObjectPrefab> >(); IEntityStateContainer state = entity.WorldObject.GetComponentInChildren <IEntityStateContainer>(); peer.SendEvent(new GameObjectEntitySpawnEventPayload(entity.NetworkGuid, entity.WorldObject.transform.position.ToSurrogate(), entity.WorldObject.transform.rotation.ToSurrogate(), entity.WorldObject.transform.localScale.ToSurrogate(), prefabTag.Tag, state.State), DeliveryMethod.ReliableOrdered, false, 0); } }
/// <summary> /// Called internally when an event is recieved. (setup using the subscription service) /// </summary> /// <param name="message">Incoming event message.</param> /// <param name="parameters">Parameters the message was sent with (Null right now in this implementation).</param> protected override void OnReceiveEvent(IEventMessage message, IMessageParameters parameters) { //Right now web clients should recieve events //There just isn't an implementation for it Logger.Error($"{nameof(AuthServiceClientPeer)} recieved an event in {nameof(OnReceiveEvent)} but should not recieve events."); }
/// <summary> /// Called internally when a request is recieved from the remote peer. /// </summary> /// <param name="requestMessage"><see cref="IRequestMessage"/> sent by the peer.</param> /// <param name="parameters">Parameters the message was sent with.</param> protected abstract override void OnReceiveRequest(IRequestMessage requestMessage, IMessageParameters parameters);
protected override void OnIncomingHandlableMessage(IEventMessage message, EntityPositionUpdateEvent payload, IMessageParameters parameters, InstanceClientPeer peer) { //logger.Info($"Recieved position event for ID: {payload.EntityGuid.EntityId}."); if (entityCollection.ContainsKey(payload.EntityGuid)) { entityCollection[payload.EntityGuid].WorldObject.transform.position = payload.Position.ToVector3(); } else { Debug.Log($"Recieved position update event from Type: {payload.EntityGuid.EntityType} Id: {payload.EntityGuid.EntityId} but we've not spawned an entity with that GUID."); } }
public void OnNetworkMessageReceive(IResponseMessage message, IMessageParameters parameters) { Throw <ArgumentNullException> .If.IsNull(message)?.Now(nameof(message), $"Cannot have a null {nameof(IResponseMessage)} in on recieve. This should never occur internally. Indicates major fault. Should never reach this point."); responseHandler.TryProcessMessage(message, null, this as TInheritingType); }
public void OnNetworkMessageReceive(IRequestMessage message, IMessageParameters parameters) { throw new NotImplementedException("Web peers cannot handle requests."); }
private static void Test(IResponseMessage message, IMessageParameters parameters) { AuthenticationResponse payload = message.Payload.Data as AuthenticationResponse; Console.WriteLine($"Authenticated: {payload.AuthenticationSuccessful} OptionalError: {payload.OptionalError} OptionalErrorMessage: {payload.OptionalErrorMessage}"); }
protected override void OnIncomingHandlableMessage(IResponseMessage message, GameServerListResponsePayload payload, IMessageParameters parameters, GameServerListWebClient peer) { Debug.Log($"Handling response game server list {payload.GameServerDetails.Count()}"); //TODO: Error handling if (payload.ResponseCode == GameServerListResponseCode.Success) { foreach (SimpleGameServerDetailsModel details in payload.GameServerDetails) { detailsFactory.Create(details.Name, details.Region); } } }
protected sealed override void OnIncomingHandlableMessage(IRequestMessage message, ClaimSessionRequestPayload payload, IMessageParameters parameters, InstanceClientSession peer) { TryClaimSession(payload.SessionClaimGuid, peer.PeerDetails.RemoteIP.ToString()) .UnityAsyncContinueWith(this, g => OnSessionClaimResponse(g, peer)); }
protected override void OnIncomingHandlableMessage(IRequestMessage message, PlayerMoveRequestPayload payload, IMessageParameters parameters, InstanceClientSession peer) { NetworkEntityGuid guid = guidLookupService.Lookup(peer.PeerDetails.ConnectionID); if (guid == null) { throw new InvalidOperationException($"Couldn't find GUID for Connection ID: {peer.PeerDetails.ConnectionID}."); } entityCollection[guid].WorldObject.transform.position = payload.Position.ToVector3(); }
protected override void OnIncomingHandlableMessage(IEventMessage message, EntityStateChangedEvent payload, IMessageParameters parameters, InstanceClientPeer peer) { logger.Debug($"Recieved state change from Entity Id: {payload.EntityGuid.EntityId} with new state Value: {payload.State}."); if (entityCollection.ContainsKey(payload.EntityGuid)) { var entityChunk = entityCollection[payload.EntityGuid]; IEntityStateContainer state = entityChunk.WorldObject.GetComponent <IEntityStateContainer>(); if (state == null) { throw new InvalidOperationException($"Failed to find {nameof(IEntityStateContainer)} component on GameObject: {entityChunk.WorldObject.name} with Entity Id: {payload.EntityGuid.EntityId}."); } //Just straight set the state from the payload. state.State = payload.State; } else { logger.Warn($"Recieved state change from UNKNOWN Entity Id: {payload.EntityGuid.EntityId} with new state Value: {payload.State}."); } }
/// <summary> /// Internally managed status receival method. /// Setup to be called internally using the <see cref="INetworkMessageSubscriptionService"/>. /// </summary> /// <param name="message">The new <see cref="IStatusMessage"/> message.</param> /// <param name="parameters"><see cref="IMessageParameters"/> the <see cref="IStatusMessage"/> was sent with.</param> private void OnReceiveStatus(IStatusMessage message, IMessageParameters parameters) { Throw<ArgumentNullException>.If.IsNull(message)?.Now(nameof(message)); //I know I cast here so let's only call this once for efficiency NetStatus s = message.Status; //Set the new status to the incoming status Status = s; if (s != Status) OnStatusChanged(s); }
protected override void OnIncomingHandlableMessage(IRequestMessage message, AuthenticationRequest payload, IMessageParameters parameters, TPeerType peer) { //TODO: Network the response Logger.Debug($"{peer?.GetType()} session is requesting elevation. ID {peer?.PeerDetails?.ConnectionID}"); //Check if we were sent the expected valid signed message for authentication/elevation if (elevationAuthService.TryAuthenticate(peer, payload.Message)) { Logger.Debug($"{peer?.GetType()} session is now elevated. ID {peer?.PeerDetails?.ConnectionID}"); } else { Logger.Warn($"{peer?.GetType()} session failed elevation. ID {peer?.PeerDetails?.ConnectionID}"); } }
public bool TryProcessMessage(IResponseMessage message, IMessageParameters parameters, INetPeer peer) { return(HandleDebug(message, parameters, peer)); }
public bool TryProcessMessage(IRequestMessage message, IMessageParameters parameters, GameServicePeerSession peer) { throw new NotImplementedException(); }
/// <summary> /// Interface method overload for receiving a <see cref="IRequestMessage"/>. /// </summary> /// <param name="message">The request recieved from the remote peer.</param> /// <param name="parameters">The message parameters the message was sent with.</param> public void OnNetworkMessageReceive(IRequestMessage message, IMessageParameters parameters) { Throw<ArgumentNullException>.If.IsNull(message)?.Now(nameof(message)); RequestPublisher?.Invoke(message, parameters); }
protected override void OnIncomingHandlableMessage(IRequestMessage message, AuthTokenRequest payload, IMessageParameters parameters, TPeerType peer) { Logger.Debug($"{peer?.GetType()} session is requesting an auth token. ID {peer?.PeerDetails?.ConnectionID}"); //Ask for a new token and associate it with the requesting session Guid token = elevationAuthService.RequestSingleUseToken(peer); //Send the token to the session peer.TrySendMessage(OperationType.Response, new AuthTokenResponse(token)); }
/// <summary> /// Dispatchable method that handles <see cref="IStatusMessage"/> changes. /// </summary> /// <param name="status">The status message recieved from the remote peer.</param> /// <param name="parameters">The message parameters the message was sent with.</param> public void OnNetworkMessageReceive(IStatusMessage status, IMessageParameters parameters) { Throw<ArgumentNullException>.If.IsNull(status)?.Now(nameof(status)); StatusPublisher?.Invoke(status, parameters); }
/// <summary> /// Handles a <see cref="PacketPayload"/> sent as a response. /// </summary> /// <param name="payload">Response payload data from the network.</param> public abstract void OnReceiveResponse(IResponseMessage message, IMessageParameters parameters);
protected override void OnIncomingHandlableMessage(IResponseMessage message, AuthenticationResponse payload, IMessageParameters parameters, AuthenticationWebClient peer) { if (payload.AuthenticationSuccessful) { OnSuccess?.Invoke(); } else { OnFailure?.Invoke(payload.OptionalError ?? ResponseErrorCode.Error, payload.OptionalErrorMessage); } }
protected override void OnIncomingHandlableMessage(IRequestMessage message, EntityInteractionRequestPayload payload, IMessageParameters parameters, InstanceClientSession peer) { if (Logger.IsDebugEnabled) { Logger.Debug($"Recieved interaction request for {payload.NetworkGuid.EntityId}."); } if (EntityCollection.ContainsKey(payload.NetworkGuid)) { IWorldInteractable interactable = EntityCollection[payload.NetworkGuid]?.WorldObject?.GetComponent <IWorldInteractable>(); if (interactable == null) { if (Logger.IsWarnEnabled) { Logger.Warn($"Recieved interaction request for entity that can't be interacted with ID: {payload.NetworkGuid.EntityId} Type: {payload.NetworkGuid.EntityType} from NetId: {peer.PeerDetails.ConnectionID}."); } } else { interactable.TryInteract(GuidLookupService.Lookup(peer.PeerDetails.ConnectionID)); } } else if (Logger.IsWarnEnabled) { Logger.Warn($"Recieved interaction request for unknown entity ID: {payload.NetworkGuid.EntityId} Type: {payload.NetworkGuid.EntityType} from NetId: {peer.PeerDetails.ConnectionID}."); } }
public void OnNetworkMessageReceive(IStatusMessage status, IMessageParameters parameters) { throw new NotImplementedException("Web peers cannot handle status updates."); }