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