public override void CleanComponents(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system,
EntityCommandBuffer buffer)
{
var entityType = system.GetArchetypeChunkEntityType();
var componentAddedType = system.GetArchetypeChunkComponentType <ComponentAdded <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component> >();
var componentRemovedType = system.GetArchetypeChunkComponentType <ComponentRemoved <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component> >();
var receivedUpdateType = system.GetArchetypeChunkComponentType <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.ReceivedUpdates>();
var authorityChangeType = system.GetArchetypeChunkComponentType <AuthorityChanges <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component> >();
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
// Updates
if (chunk.Has(receivedUpdateType))
{
var updateArray = chunk.GetNativeArray(receivedUpdateType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.ReceivedUpdates>(entities[i]);
var updateList = updateArray[i].Updates;
// Pool update lists to avoid excessive allocation
updateList.Clear();
global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Update.Pool.Push(updateList);
ReferenceTypeProviders.UpdatesProvider.Free(updateArray[i].handle);
}
}
// Component Added
if (chunk.Has(componentAddedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentAdded <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component> >(entities[i]);
}
}
// Component Removed
if (chunk.Has(componentRemovedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentRemoved <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component> >(entities[i]);
}
}
// Authority
if (chunk.Has(authorityChangeType))
{
var authorityChangeArray = chunk.GetNativeArray(authorityChangeType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <AuthorityChanges <global::Improbable.Gdk.PlayerLifecycle.OwningWorker.Component> >(entities[i]);
AuthorityChangesProvider.Free(authorityChangeArray[i].Handle);
}
}
}
}
public static JobHandle DestroyTransformHierarchy <T>(this ComponentSystemBase system, EntityQuery query, EntityCommandBuffer cmdBuffer, JobHandle inputDeps)
where T : struct, IComponentData
{
return(new DestroyTransformHierarchy <T> {
ChunkEntityType = system.GetArchetypeChunkEntityType(),
ChildrenFromEntity = system.GetBufferFromEntity <Child>(true),
CmdBuffer = cmdBuffer.ToConcurrent()
}.Schedule(query, inputDeps));
}
public static JobHandle DestroyEntityOnly(
this EntityQuery query,
ComponentSystemBase system,
EntityCommandBuffer entityCommandBuffer,
JobHandle inputDeps)
{
return(new DestroyEntitiesOnly {
CmdBuffer = entityCommandBuffer.ToConcurrent(),
EntityOnlyArchetype = system.EntityManager.CreateArchetype(),
EntityType = system.GetArchetypeChunkEntityType()
}.Schedule(query, inputDeps));
}
public static JobHandle CopyFromChangedComponentData <T>(
this EntityQuery query,
ComponentSystemBase system,
ref NativeHashMap <Entity, T> resultChangedComponentData,
JobHandle inputDeps)
where T : struct, IComponentData
{
inputDeps = new CopyFromChangedComponentData <T> {
EntityType = system.GetArchetypeChunkEntityType(),
ChunkType = system.GetArchetypeChunkComponentType <T>(false),
ChangedComponentData = resultChangedComponentData
}.Schedule(query, inputDeps);
return(inputDeps);
}
public static LayerChunkTypeGroup BuildLayerChunkTypeGroup(ComponentSystemBase system)
{
LayerChunkTypeGroup result = new LayerChunkTypeGroup
{
collider = system.GetArchetypeChunkComponentType <Collider>(true),
translation = system.GetArchetypeChunkComponentType <Translation>(true),
rotation = system.GetArchetypeChunkComponentType <Rotation>(true),
scale = system.GetArchetypeChunkComponentType <PhysicsScale>(true),
parent = system.GetArchetypeChunkComponentType <Parent>(true),
localToWorld = system.GetArchetypeChunkComponentType <LocalToWorld>(true),
entity = system.GetArchetypeChunkEntityType()
};
return(result);
}
public static JobHandle ToDataWithEntity <TData>(
this EntityQuery entityQuery,
ComponentSystemBase system,
NativeArray <TData> sourceData,
ref NativeArray <DataWithEntity <TData> > resultDataWithEntity,
JobHandle inputDeps)
where TData : struct, IComparable <TData>
{
inputDeps = new ConvertToDataWithEntity <TData> {
ChunkEntityType = system.GetArchetypeChunkEntityType(),
Source = sourceData,
Target = resultDataWithEntity
}.Schedule(entityQuery, inputDeps);
return(inputDeps);
}
public static JobHandle GetChangedComponentDataFromEntity <T>(
this EntityQuery query,
ComponentSystemBase system,
ref NativeHashMap <Entity, T> resultHashMap,
JobHandle inputDeps)
where T : struct, IComponentData
{
inputDeps = resultHashMap.Clear(inputDeps, query.CalculateEntityCount());
inputDeps = new ChangedComponentToEntity <T> {
EntityType = system.GetArchetypeChunkEntityType(),
ChunkType = system.GetArchetypeChunkComponentType <T>(true),
ChangedComponents = resultHashMap.AsParallelWriter(),
LastSystemVersion = system.LastSystemVersion
}.Schedule(query, inputDeps);
return(inputDeps);
}
public void SendCommands(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system, CommandSystem commandSystem)
{
Profiler.BeginSample("ComponentWithNoFieldsWithCommands");
var entityType = system.GetArchetypeChunkEntityType();
var senderTypeCmd = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithCommands.CommandSenders.Cmd>(true);
var responderTypeCmd = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithCommands.CommandResponders.Cmd>(true);
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
if (chunk.Has(senderTypeCmd))
{
var senders = chunk.GetNativeArray(senderTypeCmd);
for (var i = 0; i < senders.Length; i++)
{
var requests = senders[i].RequestsToSend;
if (requests.Count > 0)
{
foreach (var request in requests)
{
commandSystem.SendCommand(request, entities[i]);
}
requests.Clear();
}
}
var responders = chunk.GetNativeArray(responderTypeCmd);
for (var i = 0; i < responders.Length; i++)
{
var responses = responders[i].ResponsesToSend;
if (responses.Count > 0)
{
foreach (var response in responses)
{
commandSystem.SendResponse(response);
}
responses.Clear();
}
}
}
}
Profiler.EndSample();
}
public void SendCommands(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system, CommandSystem commandSystem)
{
Profiler.BeginSample("PlayerHeartbeatClient");
var entityType = system.GetArchetypeChunkEntityType();
var senderTypePlayerHeartbeat = system.GetArchetypeChunkComponentType <Improbable.PlayerLifecycle.PlayerHeartbeatClient.CommandSenders.PlayerHeartbeat>(true);
var responderTypePlayerHeartbeat = system.GetArchetypeChunkComponentType <Improbable.PlayerLifecycle.PlayerHeartbeatClient.CommandResponders.PlayerHeartbeat>(true);
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
if (chunk.Has(senderTypePlayerHeartbeat))
{
var senders = chunk.GetNativeArray(senderTypePlayerHeartbeat);
for (var i = 0; i < senders.Length; i++)
{
var requests = senders[i].RequestsToSend;
if (requests.Count > 0)
{
foreach (var request in requests)
{
commandSystem.SendCommand(request, entities[i]);
}
requests.Clear();
}
}
var responders = chunk.GetNativeArray(responderTypePlayerHeartbeat);
for (var i = 0; i < responders.Length; i++)
{
var responses = responders[i].ResponsesToSend;
if (responses.Count > 0)
{
foreach (var response in responses)
{
commandSystem.SendResponse(response);
}
responses.Clear();
}
}
}
}
Profiler.EndSample();
}
public void SendCommands(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system, CommandSystem commandSystem)
{
Profiler.BeginSample("Worker");
var entityType = system.GetArchetypeChunkEntityType();
var senderTypeDisconnect = system.GetArchetypeChunkComponentType <global::Improbable.Restricted.Worker.CommandSenders.Disconnect>(true);
var responderTypeDisconnect = system.GetArchetypeChunkComponentType <global::Improbable.Restricted.Worker.CommandResponders.Disconnect>(true);
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
if (chunk.Has(senderTypeDisconnect))
{
var senders = chunk.GetNativeArray(senderTypeDisconnect);
for (var i = 0; i < senders.Length; i++)
{
var requests = senders[i].RequestsToSend;
if (requests.Count > 0)
{
foreach (var request in requests)
{
commandSystem.SendCommand(request, entities[i]);
}
requests.Clear();
}
}
var responders = chunk.GetNativeArray(responderTypeDisconnect);
for (var i = 0; i < responders.Length; i++)
{
var responses = responders[i].ResponsesToSend;
if (responses.Count > 0)
{
foreach (var response in responses)
{
commandSystem.SendResponse(response);
}
responses.Clear();
}
}
}
}
Profiler.EndSample();
}
public void ScheduleTimeInitialize(ComponentSystemBase jobComponentSystem, bool isReadOnly)
{
_type = jobComponentSystem.GetArchetypeChunkEntityType();
}
public override void CleanComponents(ComponentGroup group, ComponentSystemBase system,
EntityCommandBuffer buffer)
{
var entityType = system.GetArchetypeChunkEntityType();
var componentAddedType = system.GetArchetypeChunkComponentType <ComponentAdded <Improbable.Gdk.Tests.NestedComponent.Component> >();
var componentRemovedType = system.GetArchetypeChunkComponentType <ComponentRemoved <Improbable.Gdk.Tests.NestedComponent.Component> >();
var receivedUpdateType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.NestedComponent.ReceivedUpdates>();
var authorityChangeType = system.GetArchetypeChunkComponentType <AuthorityChanges <Improbable.Gdk.Tests.NestedComponent.Component> >();
var chunkArray = group.CreateArchetypeChunkArray(Allocator.TempJob);
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
// Updates
if (chunk.Has(receivedUpdateType))
{
var updateArray = chunk.GetNativeArray(receivedUpdateType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <Improbable.Gdk.Tests.NestedComponent.ReceivedUpdates>(entities[i]);
var updateList = updateArray[i].Updates;
// Pool update lists to avoid excessive allocation
updateList.Clear();
Improbable.Gdk.Tests.NestedComponent.Update.Pool.Push(updateList);
ReferenceTypeProviders.UpdatesProvider.Free(updateArray[i].handle);
}
}
// Component Added
if (chunk.Has(componentAddedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentAdded <Improbable.Gdk.Tests.NestedComponent.Component> >(entities[i]);
}
}
// Component Removed
if (chunk.Has(componentRemovedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentRemoved <Improbable.Gdk.Tests.NestedComponent.Component> >(entities[i]);
}
}
// Authority
if (chunk.Has(authorityChangeType))
{
var authorityChangeArray = chunk.GetNativeArray(authorityChangeType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <AuthorityChanges <Improbable.Gdk.Tests.NestedComponent.Component> >(entities[i]);
AuthorityChangesProvider.Free(authorityChangeArray[i].Handle);
}
}
}
chunkArray.Dispose();
}
public override void CleanComponents(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system,
EntityCommandBuffer buffer)
{
var entityType = system.GetArchetypeChunkEntityType();
var componentAddedType = system.GetArchetypeChunkComponentType <ComponentAdded <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> >();
var componentRemovedType = system.GetArchetypeChunkComponentType <ComponentRemoved <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> >();
var receivedUpdateType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.ReceivedUpdates>();
var authorityChangeType = system.GetArchetypeChunkComponentType <AuthorityChanges <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> >();
var myEventEventType = system.GetArchetypeChunkComponentType <ReceivedEvents.MyEvent>();
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
// Updates
if (chunk.Has(receivedUpdateType))
{
var updateArray = chunk.GetNativeArray(receivedUpdateType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.ReceivedUpdates>(entities[i]);
var updateList = updateArray[i].Updates;
// Pool update lists to avoid excessive allocation
updateList.Clear();
Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Update.Pool.Push(updateList);
ReferenceTypeProviders.UpdatesProvider.Free(updateArray[i].handle);
}
}
// Component Added
if (chunk.Has(componentAddedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentAdded <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> >(entities[i]);
}
}
// Component Removed
if (chunk.Has(componentRemovedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentRemoved <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> >(entities[i]);
}
}
// Authority
if (chunk.Has(authorityChangeType))
{
var authorityChangeArray = chunk.GetNativeArray(authorityChangeType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <AuthorityChanges <Improbable.Gdk.Tests.AlternateSchemaSyntax.Connection.Component> >(entities[i]);
AuthorityChangesProvider.Free(authorityChangeArray[i].Handle);
}
}
// MyEvent Event
if (chunk.Has(myEventEventType))
{
var myEventEventArray = chunk.GetNativeArray(myEventEventType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ReceivedEvents.MyEvent>(entities[i]);
ReferenceTypeProviders.MyEventProvider.Free(myEventEventArray[i].handle);
}
}
}
}
public override void CleanComponents(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system,
EntityCommandBuffer buffer)
{
var entityType = system.GetArchetypeChunkEntityType();
var componentAddedType = system.GetArchetypeChunkComponentType <ComponentAdded <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component> >();
var componentRemovedType = system.GetArchetypeChunkComponentType <ComponentRemoved <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component> >();
var receivedUpdateType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReceivedUpdates>();
var authorityChangeType = system.GetArchetypeChunkComponentType <AuthorityChanges <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component> >();
var firstEventEventType = system.GetArchetypeChunkComponentType <ReceivedEvents.FirstEvent>();
var secondEventEventType = system.GetArchetypeChunkComponentType <ReceivedEvents.SecondEvent>();
var firstCommandRequestType = system.GetArchetypeChunkComponentType <CommandRequests.FirstCommand>();
var firstCommandResponseType = system.GetArchetypeChunkComponentType <CommandResponses.FirstCommand>();
var secondCommandRequestType = system.GetArchetypeChunkComponentType <CommandRequests.SecondCommand>();
var secondCommandResponseType = system.GetArchetypeChunkComponentType <CommandResponses.SecondCommand>();
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
// Updates
if (chunk.Has(receivedUpdateType))
{
var updateArray = chunk.GetNativeArray(receivedUpdateType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.ReceivedUpdates>(entities[i]);
var updateList = updateArray[i].Updates;
// Pool update lists to avoid excessive allocation
updateList.Clear();
Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Update.Pool.Push(updateList);
ReferenceTypeProviders.UpdatesProvider.Free(updateArray[i].handle);
}
}
// Component Added
if (chunk.Has(componentAddedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentAdded <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component> >(entities[i]);
}
}
// Component Removed
if (chunk.Has(componentRemovedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentRemoved <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component> >(entities[i]);
}
}
// Authority
if (chunk.Has(authorityChangeType))
{
var authorityChangeArray = chunk.GetNativeArray(authorityChangeType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <AuthorityChanges <Improbable.Gdk.Tests.NonblittableTypes.NonBlittableComponent.Component> >(entities[i]);
AuthorityChangesProvider.Free(authorityChangeArray[i].Handle);
}
}
// FirstEvent Event
if (chunk.Has(firstEventEventType))
{
var firstEventEventArray = chunk.GetNativeArray(firstEventEventType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ReceivedEvents.FirstEvent>(entities[i]);
ReferenceTypeProviders.FirstEventProvider.Free(firstEventEventArray[i].handle);
}
}
// SecondEvent Event
if (chunk.Has(secondEventEventType))
{
var secondEventEventArray = chunk.GetNativeArray(secondEventEventType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ReceivedEvents.SecondEvent>(entities[i]);
ReferenceTypeProviders.SecondEventProvider.Free(secondEventEventArray[i].handle);
}
}
// FirstCommand Command
if (chunk.Has(firstCommandRequestType))
{
var firstCommandRequestArray = chunk.GetNativeArray(firstCommandRequestType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandRequests.FirstCommand>(entities[i]);
ReferenceTypeProviders.FirstCommandRequestsProvider.Free(firstCommandRequestArray[i].CommandListHandle);
}
}
if (chunk.Has(firstCommandResponseType))
{
var firstCommandResponseArray = chunk.GetNativeArray(firstCommandResponseType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandResponses.FirstCommand>(entities[i]);
ReferenceTypeProviders.FirstCommandResponsesProvider.Free(firstCommandResponseArray[i].CommandListHandle);
}
}
// SecondCommand Command
if (chunk.Has(secondCommandRequestType))
{
var secondCommandRequestArray = chunk.GetNativeArray(secondCommandRequestType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandRequests.SecondCommand>(entities[i]);
ReferenceTypeProviders.SecondCommandRequestsProvider.Free(secondCommandRequestArray[i].CommandListHandle);
}
}
if (chunk.Has(secondCommandResponseType))
{
var secondCommandResponseArray = chunk.GetNativeArray(secondCommandResponseType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandResponses.SecondCommand>(entities[i]);
ReferenceTypeProviders.SecondCommandResponsesProvider.Free(secondCommandResponseArray[i].CommandListHandle);
}
}
}
}
public override void SendCommands(ComponentGroup commandGroup, ComponentSystemBase system, global::Improbable.Worker.CInterop.Connection connection)
{
Profiler.BeginSample("ComponentWithNoFieldsWithCommands");
var entityType = system.GetArchetypeChunkEntityType();
{
var senderType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithCommands.CommandSenders.Cmd>(true);
var responderType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Tests.ComponentsWithNoFields.ComponentWithNoFieldsWithCommands.CommandResponders.Cmd>(true);
var chunks = commandGroup.CreateArchetypeChunkArray(Allocator.TempJob);
foreach (var chunk in chunks)
{
var entities = chunk.GetNativeArray(entityType);
var senders = chunk.GetNativeArray(senderType);
var responders = chunk.GetNativeArray(responderType);
for (var i = 0; i < senders.Length; i++)
{
var requests = senders[i].RequestsToSend;
var responses = responders[i].ResponsesToSend;
if (requests.Count > 0)
{
foreach (var request in requests)
{
var schemaCommandRequest = new global::Improbable.Worker.CInterop.SchemaCommandRequest(ComponentId, 1);
global::Improbable.Gdk.Tests.ComponentsWithNoFields.Empty.Serialization.Serialize(request.Payload, schemaCommandRequest.GetObject());
var requestId = connection.SendCommandRequest(request.TargetEntityId.Id,
new global::Improbable.Worker.CInterop.CommandRequest(schemaCommandRequest),
request.TimeoutMillis,
request.AllowShortCircuiting ? ShortCircuitParameters : null);
cmdStorage.CommandRequestsInFlight[requestId] =
new CommandRequestStore <global::Improbable.Gdk.Tests.ComponentsWithNoFields.Empty>(entities[i], request.Payload, request.Context, request.RequestId);
}
requests.Clear();
}
if (responses.Count > 0)
{
foreach (var response in responses)
{
var requestId = response.RequestId;
if (response.FailureMessage != null)
{
// Send a command failure if the string is non-null.
connection.SendCommandFailure((uint)requestId, response.FailureMessage);
continue;
}
var schemaCommandResponse = new global::Improbable.Worker.CInterop.SchemaCommandResponse(ComponentId, 1);
global::Improbable.Gdk.Tests.ComponentsWithNoFields.Empty.Serialization.Serialize(response.Payload.Value, schemaCommandResponse.GetObject());
connection.SendCommandResponse((uint)requestId, new global::Improbable.Worker.CInterop.CommandResponse(schemaCommandResponse));
}
responses.Clear();
}
}
}
chunks.Dispose();
}
Profiler.EndSample();
}
public override void CleanComponents(NativeArray <ArchetypeChunk> chunkArray, ComponentSystemBase system,
EntityCommandBuffer buffer)
{
var entityType = system.GetArchetypeChunkEntityType();
var componentAddedType = system.GetArchetypeChunkComponentType <ComponentAdded <Improbable.Gdk.Health.HealthComponent.Component> >();
var componentRemovedType = system.GetArchetypeChunkComponentType <ComponentRemoved <Improbable.Gdk.Health.HealthComponent.Component> >();
var receivedUpdateType = system.GetArchetypeChunkComponentType <Improbable.Gdk.Health.HealthComponent.ReceivedUpdates>();
var authorityChangeType = system.GetArchetypeChunkComponentType <AuthorityChanges <Improbable.Gdk.Health.HealthComponent.Component> >();
var healthModifiedEventType = system.GetArchetypeChunkComponentType <ReceivedEvents.HealthModified>();
var respawnEventType = system.GetArchetypeChunkComponentType <ReceivedEvents.Respawn>();
var modifyHealthRequestType = system.GetArchetypeChunkComponentType <CommandRequests.ModifyHealth>();
var modifyHealthResponseType = system.GetArchetypeChunkComponentType <CommandResponses.ModifyHealth>();
var requestRespawnRequestType = system.GetArchetypeChunkComponentType <CommandRequests.RequestRespawn>();
var requestRespawnResponseType = system.GetArchetypeChunkComponentType <CommandResponses.RequestRespawn>();
foreach (var chunk in chunkArray)
{
var entities = chunk.GetNativeArray(entityType);
// Updates
if (chunk.Has(receivedUpdateType))
{
var updateArray = chunk.GetNativeArray(receivedUpdateType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <Improbable.Gdk.Health.HealthComponent.ReceivedUpdates>(entities[i]);
var updateList = updateArray[i].Updates;
// Pool update lists to avoid excessive allocation
updateList.Clear();
Improbable.Gdk.Health.HealthComponent.Update.Pool.Push(updateList);
ReferenceTypeProviders.UpdatesProvider.Free(updateArray[i].handle);
}
}
// Component Added
if (chunk.Has(componentAddedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentAdded <Improbable.Gdk.Health.HealthComponent.Component> >(entities[i]);
}
}
// Component Removed
if (chunk.Has(componentRemovedType))
{
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ComponentRemoved <Improbable.Gdk.Health.HealthComponent.Component> >(entities[i]);
}
}
// Authority
if (chunk.Has(authorityChangeType))
{
var authorityChangeArray = chunk.GetNativeArray(authorityChangeType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <AuthorityChanges <Improbable.Gdk.Health.HealthComponent.Component> >(entities[i]);
AuthorityChangesProvider.Free(authorityChangeArray[i].Handle);
}
}
// HealthModified Event
if (chunk.Has(healthModifiedEventType))
{
var healthModifiedEventArray = chunk.GetNativeArray(healthModifiedEventType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ReceivedEvents.HealthModified>(entities[i]);
ReferenceTypeProviders.HealthModifiedProvider.Free(healthModifiedEventArray[i].handle);
}
}
// Respawn Event
if (chunk.Has(respawnEventType))
{
var respawnEventArray = chunk.GetNativeArray(respawnEventType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <ReceivedEvents.Respawn>(entities[i]);
ReferenceTypeProviders.RespawnProvider.Free(respawnEventArray[i].handle);
}
}
// ModifyHealth Command
if (chunk.Has(modifyHealthRequestType))
{
var modifyHealthRequestArray = chunk.GetNativeArray(modifyHealthRequestType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandRequests.ModifyHealth>(entities[i]);
ReferenceTypeProviders.ModifyHealthRequestsProvider.Free(modifyHealthRequestArray[i].CommandListHandle);
}
}
if (chunk.Has(modifyHealthResponseType))
{
var modifyHealthResponseArray = chunk.GetNativeArray(modifyHealthResponseType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandResponses.ModifyHealth>(entities[i]);
ReferenceTypeProviders.ModifyHealthResponsesProvider.Free(modifyHealthResponseArray[i].CommandListHandle);
}
}
// RequestRespawn Command
if (chunk.Has(requestRespawnRequestType))
{
var requestRespawnRequestArray = chunk.GetNativeArray(requestRespawnRequestType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandRequests.RequestRespawn>(entities[i]);
ReferenceTypeProviders.RequestRespawnRequestsProvider.Free(requestRespawnRequestArray[i].CommandListHandle);
}
}
if (chunk.Has(requestRespawnResponseType))
{
var requestRespawnResponseArray = chunk.GetNativeArray(requestRespawnResponseType);
for (int i = 0; i < entities.Length; ++i)
{
buffer.RemoveComponent <CommandResponses.RequestRespawn>(entities[i]);
ReferenceTypeProviders.RequestRespawnResponsesProvider.Free(requestRespawnResponseArray[i].CommandListHandle);
}
}
}
}
