public Promise <MultiPlayerMessage> SendRequest(MultiPlayerMessage message, TimeSpan?timeout = null)
{
try
{
message.Sender = ClientId;
message.RequestId = Guid.NewGuid().ToString();
var pendingRequest = new PendingRequest()
{
Id = message.RequestId,
ResponseDeferred = Deferred <MultiPlayerMessage> .Create(),
};
if (timeout.HasValue)
{
pendingRequest.Timeout = timeout.Value;
}
lock (pendingRequests)
{
pendingRequests.Add(message.RequestId, pendingRequest);
}
SendMessage(message);
return(pendingRequest.ResponseDeferred.Promise);
}
catch (Exception ex)
{
var d = Deferred <MultiPlayerMessage> .Create();
d.Reject(ex);
return(d.Promise);
}
}
public void SendMessage(MultiPlayerMessage message)
{
message.Sender = message.Sender ?? ServerId;
lock (connectionsLock)
{
var client = GetClient(message.Recipient);
try
{
if (client == null)
{
throw new Exception($"The client {message.Recipient} is not connected at the moment");
}
else
{
serverNetworkProvider.SendMessageToClient(message.Serialize(), client);
}
}
catch (Exception ex)
{
Error.Fire(ex.ToString());
Undeliverable.Fire(new UndeliverableEvent()
{
Message = message,
Exception = ex
});
throw;
}
}
}
public Task <MultiPlayerMessage> SendRequest(MultiPlayerMessage message, TimeSpan?timeout = null)
{
try
{
message.Sender = ClientId;
message.RequestId = Guid.NewGuid().ToString();
var pendingRequest = new PendingRequest()
{
Id = message.RequestId,
ResponseDeferred = new TaskCompletionSource <MultiPlayerMessage>(),
};
if (timeout.HasValue)
{
pendingRequest.Timeout = timeout.Value;
}
lock (pendingRequests)
{
pendingRequests.Add(message.RequestId, pendingRequest);
}
SendMessage(message);
return(pendingRequest.ResponseDeferred.Task);
}
catch (Exception ex)
{
var d = new TaskCompletionSource <MultiPlayerMessage>();
d.SetException(ex);
return(d.Task);
}
}
public void Respond(MultiPlayerMessage response)
{
if (response.RequestId == null)
{
throw new ArgumentNullException("RequestId cannot be null");
}
SendMessage(response);
}
public bool TryRespond(MultiPlayerMessage response)
{
if (response.RequestId == null)
{
throw new ArgumentNullException("RequestId cannot be null");
}
return(TrySendMessage(response));
}
private void OnNotFound(MultiPlayerMessage message)
{
Warning.Fire($"Message not handled from {message.Sender}: {message.GetType().Name}");
if (message.RequestId != null)
{
Respond(new NotFoundMessage()
{
Recipient = message.Sender, RequestId = message.RequestId
});
}
}
public bool TrySendMessage(MultiPlayerMessage message)
{
try
{
SendMessage(message);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public bool TrySendMessage(MultiPlayerMessage message)
{
try
{
message.Sender = ClientId;
clientNetworkProvider.SendMessage(message.Serialize());
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public MultiPlayerClient(IClientNetworkProvider networkProvider)
{
this.clientNetworkProvider = networkProvider;
networkProvider.MessageReceived.SubscribeForLifetime((m) =>
{
var hydratedEvent = MultiPlayerMessage.Deserialize(m);
EventRouter.Route(hydratedEvent.GetType().Name, hydratedEvent);
}, this);
this.OnDisposed(() =>
{
if (isConnected)
{
TrySendMessage(new LeftMessage()
{
ClientWhoLeft = this.ClientId
});
}
this.clientNetworkProvider.Dispose();
});
EventRouter.Register <Ack>(OnAck, this);
}
public void RemoteFire(MultiPlayerMessage message)
{
var rpgMessage = message as RPGFireMessage;
FireDoubleInternal(rpgMessage.X, rpgMessage.Y, rpgMessage.Angle);
}
private void OnRawMessageReceived(string messageText)
{
var hydratedMessage = MultiPlayerMessage.Deserialize(messageText);
MessageRouter.Route(hydratedMessage.GetType().Name, hydratedMessage);
}
public void Route(string messageTypeName, MultiPlayerMessage message) => innerRouter.Route(messageTypeName, message);
public void Complete(MultiPlayerMessage response)
{
timer.Stop();
ResponseDeferred.Resolve(response);
}
public void SendMessage(MultiPlayerMessage message)
{
message.Sender = ClientId;
clientNetworkProvider.SendMessage(message.Serialize());
}
