// binary search for the command for given request ID
// invariant: lower <= target <= upper
public static int?GetResponseIndex <T>(this MessageList <T> list, CommandRequestId requestId)
where T : struct, IReceivedCommandResponse
{
var targetId = requestId;
var lower = 0;
var upper = list.Count - 1;
while (upper >= lower)
{
var current = (lower + upper) / 2;
var id = list[current].RequestId;
if (id > requestId)
{
upper = current - 1;
}
else if (id < targetId)
{
lower = current + 1;
}
else
{
return(current);
}
}
return(default);
public CommandRequestId SendCommand <T>(T request, Entity sendingEntity = default) where T : ICommandRequest
{
var requestId = new CommandRequestId(nextRequestId++);
Worker.MessagesToSend.AddCommandRequest(request, sendingEntity, requestId);
return(requestId);
}
public void RegisterCommandResponseCallback <T>(CommandRequestId requestId, Action <T> callback)
where T : struct, IReceivedCommandResponse
{
if (!responseCallbackManagers.TryGetManager(typeof(T), out var manager))
{
manager = new CommandResponseCallbackManager <T>(World);
responseCallbackManagers.AddCallbackManager(typeof(T), manager);
}
((CommandResponseCallbackManager <T>)manager).RegisterCallback(requestId, callback);
}
public ReceivedResponse(
Unity.Entities.Entity sendingEntity,
EntityId entityId,
string message,
StatusCode statusCode,
global::Improbable.Gdk.PlayerLifecycle.CreatePlayerResponse?response,
global::Improbable.Gdk.PlayerLifecycle.CreatePlayerRequest request,
global::System.Object context,
CommandRequestId requestId)
{
SendingEntity = sendingEntity;
EntityId = entityId;
Message = message;
StatusCode = statusCode;
ResponsePayload = response;
RequestPayload = request;
Context = context;
RequestId = requestId;
}
public void GenerateResponse <TRequest, TResponse>(CommandRequestId id, Func <CommandRequestId, TRequest, TResponse> creator)
where TRequest : ICommandRequest
where TResponse : struct, IReceivedCommandResponse
{
if (!outgoingRequests.TryGetValue(id.Raw, out var request))
{
throw new ArgumentException($"Could not find a request with request id {id}");
}
var commandClass = ComponentDatabase.GetCommandMetaclassFromRequest <TRequest>();
if (typeof(TResponse) != commandClass.ReceivedResponse)
{
throw new ArgumentException($"Invalid response type {typeof(TResponse)}, expected {commandClass.ReceivedResponse}");
}
CurrentDiff.AddCommandResponse(creator(id, (TRequest)request), commandClass.ComponentId, commandClass.CommandIndex);
requestIds[typeof(TRequest)].Remove(id.Raw);
outgoingRequests.Remove(id.Raw);
}
IDiffCommandResponseStorage <WorldCommands.ReserveEntityIds.ReceivedResponse> .GetResponse(CommandRequestId requestId)
{
if (!reserveEntityIdsSorted)
{
reserveEntityIdsResponses.Sort(comparer);
reserveEntityIdsSorted = true;
}
var responseIndex = reserveEntityIdsResponses.GetResponseIndex(requestId);
return(responseIndex.HasValue
? reserveEntityIdsResponses.Slice(responseIndex.Value, 1)
: MessagesSpan <WorldCommands.ReserveEntityIds.ReceivedResponse> .Empty());
}
WorldCommands.CreateEntity.ReceivedResponse?IDiffCommandResponseStorage <WorldCommands.CreateEntity.ReceivedResponse> .GetResponse(CommandRequestId requestId)
{
if (!createEntitySorted)
{
createEntityResponses.Sort(comparer);
createEntitySorted = true;
}
var responseIndex = createEntityResponses.GetResponseIndex(requestId);
return(responseIndex.HasValue
? createEntityResponses[responseIndex.Value]
: (WorldCommands.CreateEntity.ReceivedResponse?)null);
}
public T?GetResponse <T>(CommandRequestId requestId) where T : struct, IReceivedCommandResponse
{
var manager = (IDiffCommandResponseStorage <T>)worker.Diff.GetCommandDiffStorage(typeof(T));
return(manager.GetResponse(requestId));
}
IDiffCommandResponseStorage <WorldCommands.ReserveEntityIds.ReceivedResponse> .GetResponse(CommandRequestId requestId)
{
if (!reserveEntityIdsSorted)
{
reserveEntityIdsResponses.Sort(comparer);
reserveEntityIdsSorted = true;
}
var responseIndex = reserveEntityIdsResponses.GetResponseIndex(requestId);
return(responseIndex.HasValue
? reserveEntityIdsResponses[responseIndex.Value]
: (WorldCommands.ReserveEntityIds.ReceivedResponse?)null);
}
IDiffCommandResponseStorage <WorldCommands.EntityQuery.ReceivedResponse> .GetResponse(CommandRequestId requestId)
{
if (!entityQueriesSorted)
{
entityQueryResponses.Sort(comparer);
entityQueriesSorted = true;
}
var responseIndex = entityQueryResponses.GetResponseIndex(requestId);
return(responseIndex.HasValue
? entityQueryResponses[responseIndex.Value]
: (WorldCommands.EntityQuery.ReceivedResponse?)null);
}
IDiffCommandResponseStorage <WorldCommands.CreateEntity.ReceivedResponse> .GetResponse(CommandRequestId requestId)
{
if (!createEntitySorted)
{
createEntityResponses.Sort(comparer);
createEntitySorted = true;
}
var responseIndex = createEntityResponses.GetResponseIndex(requestId);
return(responseIndex.HasValue
? createEntityResponses.Slice(responseIndex.Value, 1)
: MessagesSpan <WorldCommands.CreateEntity.ReceivedResponse> .Empty());
}
private static Launcher.LaunchEntity.ReceivedResponse ResponseGenerator(CommandRequestId id, Launcher.LaunchEntity.Request request)
{
return(new Launcher.LaunchEntity.ReceivedResponse(
IDiffCommandResponseStorage <WorldCommands.EntityQuery.ReceivedResponse> .GetResponse(CommandRequestId requestId)
{
if (!entityQueriesSorted)
{
entityQueryResponses.Sort(comparer);
entityQueriesSorted = true;
}
var responseIndex = entityQueryResponses.GetResponseIndex(requestId);
return(responseIndex.HasValue
? entityQueryResponses.Slice(responseIndex.Value, 1)
: MessagesSpan <WorldCommands.EntityQuery.ReceivedResponse> .Empty());
}
private static TestCommands.Test.ReceivedResponse ResponseGenerator(CommandRequestId id, TestCommands.Test.Request request)
{
return(new TestCommands.Test.ReceivedResponse(
public void SetInternalRequestId(InternalCommandRequestId internalRequestId, CommandRequestId requestId)
{
internalRequestIdToRequestId.Add(internalRequestId, requestId);
}
public void AddRequest(WorldCommands.EntityQuery.Request request, Entity sendingEntity, CommandRequestId requestId)
{
entityQueryResponses.Add(
new CommandRequestWithMetaData <WorldCommands.EntityQuery.Request>(request, sendingEntity,
requestId));
}
public void AddRequest(WorldCommands.ReserveEntityIds.Request request, Entity sendingEntity, CommandRequestId requestId)
{
reserveEntityIdsResponses.Add(
new CommandRequestWithMetaData <WorldCommands.ReserveEntityIds.Request>(request, sendingEntity,
requestId));
}
