Class Store<ECS_TYPE>

java.lang.Object

com.hypixel.hytale.component.Store<ECS_TYPE>

Type Parameters:

ECS_TYPE - The ECS entity data type.

All Implemented Interfaces:

ComponentAccessor<ECS_TYPE>

public class Store<ECS_TYPE>
extends Object
implements ComponentAccessor<ECS_TYPE>

A store of components and entities for a specific ComponentRegistry.

Field Summary

Fields

Modifier and Type	Field	Description
static final Store[]	EMPTY_ARRAY	An array of stores that represents an empty set.
static final MetricsRegistry<Store<?>>	METRICS_REGISTRY	The metrics registry for stores.
static final int	OWNER_ROOT_ID	The parent id of an entity that no other entity owns and that owns children.
static final int	ROOT_PARENT_ID	The parent id of an entity that no other entity owns and that owns no children.

Method Summary

Modifier and Type	Method	Description
<T extends Component<ECS_TYPE>> T	addComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Adds and returns the given component to the given entity reference.
<T extends Component<ECS_TYPE>> void	addComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType, T component)	Adds the given component to the given entity reference.
Ref<ECS_TYPE>[]	addEntities(Holder<ECS_TYPE>[] holders, int start, int length, AddReason reason)
void	addEntities(Holder<ECS_TYPE>[] holders, int holderStart, Ref<ECS_TYPE>[] refs, int refStart, int length, AddReason reason)	The refs parameter places the invalid ref's at the end of the sub-array (refStart to refStart + length).
void	addEntities(Holder<ECS_TYPE>[] holders, int holderStart, Ref<ECS_TYPE>[] refs, int refStart, int length, AddReason reason, Ref<ECS_TYPE> parent)
Ref<ECS_TYPE>[]	addEntities(Holder<ECS_TYPE>[] holders, AddReason reason)	Adds the given entities to the store of this component accessor.
void	addEntities(Holder<ECS_TYPE>[] holders, Ref<ECS_TYPE>[] refs, AddReason reason)
Ref<ECS_TYPE>	addEntity(Archetype<ECS_TYPE> archetype, AddReason reason)
Ref<ECS_TYPE>	addEntity(Archetype<ECS_TYPE> archetype, AddReason reason, Ref<ECS_TYPE> parent)
Ref<ECS_TYPE>	addEntity(Holder<ECS_TYPE> holder, AddReason reason)	Adds the given entity to the store of this component accessor.
Ref<ECS_TYPE>	addEntity(Holder<ECS_TYPE> holder, AddReason reason, Ref<ECS_TYPE> parent)
Ref<ECS_TYPE>	addEntity(Holder<ECS_TYPE> holder, Ref<ECS_TYPE> ref, AddReason reason)
Ref<ECS_TYPE>	addEntity(Holder<ECS_TYPE> holder, Ref<ECS_TYPE> ref, AddReason reason, Ref<ECS_TYPE> parent)
void	assertThread()
void	assertWriteProcessing()
ArchetypeChunkData[]	collectArchetypeChunkData()	Collects diagnostic data about all archetype chunks in the store.
Holder<ECS_TYPE>	copyEntity(Ref<ECS_TYPE> ref)
Holder<ECS_TYPE>	copyEntity(Ref<ECS_TYPE> ref, Holder<ECS_TYPE> holder)
Holder<ECS_TYPE>	copySerializableEntity(Ref<ECS_TYPE> ref)
Holder<ECS_TYPE>	copySerializableEntity(Ref<ECS_TYPE> ref, Holder<ECS_TYPE> holder, Predicate<ComponentType<ECS_TYPE,?>> filter)
<T extends Component<ECS_TYPE>> T	ensureAndGetComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Ensures and fetches the component instance of the given type for the given entity reference.
<T extends Component<ECS_TYPE>> void	ensureComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)
<T extends ArchetypeDataSystem<ECS_TYPE,Q,R>, Q, R> void	fetch(SystemType<ECS_TYPE,T> systemType, Q query, List<R> results)	Runs a SystemType for a subset of ArchetypeDataSystem's for all ArchetypeChunk with an Archetype that fulfills the Query provided by QuerySystem.getQuery()}.
<T extends EntityDataSystem<ECS_TYPE,Q,R>, Q, R> void	fetch(Collection<Ref<ECS_TYPE>> refs, SystemType<ECS_TYPE,T> systemType, Q query, List<R> results)	Runs a SystemType for a subset of EntityDataSystem's for a specific Ref with an Archetype that fulfills the Query provided by QuerySystem.getQuery()}
void	forEachChunk(int systemIndex, BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every ArchetypeChunk in the component store that contains a matching Query, this includes non-ticking archetypes.
boolean	forEachChunk(int systemIndex, BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> predicate)	Iterates every ArchetypeChunk in the component store that contains a matching Query until the predicate returns true, this includes non-ticking archetypes.
void	forEachChunk(Query<ECS_TYPE> query, BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every ArchetypeChunk in the component store that contains a matching Query, this includes non-ticking archetypes.
boolean	forEachChunk(Query<ECS_TYPE> query, BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> predicate)	Iterates every ArchetypeChunk in the component store that contains a matching Query until the predicate returns true, this includes non-ticking archetypes.
void	forEachChunk(Ref<ECS_TYPE> parent, Query<ECS_TYPE> query, BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every ArchetypeChunk owned by parent that contains a matching Query.
void	forEachChunk(BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every ArchetypeChunk in the component store, this includes non-ticking archetypes.
boolean	forEachChunk(BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> predicate)	Iterates every ArchetypeChunk in the component store until the predicate returns true, this includes non-ticking archetypes.
void	forEachEntityParallel(Query<ECS_TYPE> query, IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every entity in the component store that contains a matching Query, this includes non-ticking entities.
void	forEachEntityParallel(Ref<ECS_TYPE> parent, Query<ECS_TYPE> query, IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every entity owned by parent that contains a matching Query.
void	forEachEntityParallel(IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)	Iterates every entity in the component store, this includes non-ticking entities.
Archetype<ECS_TYPE>	getArchetype(Ref<ECS_TYPE> ref)	Fetches the archetype for the given entity reference.
int	getArchetypeChunkCount()
int	getArchetypeChunkCountFor(int systemIndex)
<T extends Component<ECS_TYPE>> T	getComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Fetches the component instance of the given type for the given entity reference.
<T extends Component<ECS_TYPE>> T	getComponentConcurrent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Reads a component from any thread, without holding the world lock.
int	getEntityCount()
int	getEntityCountFor(int systemIndex)
int	getEntityCountFor(Query<ECS_TYPE> query)
ECS_TYPE	getExternalData()
ParallelTask<EntityDataSystem.SystemTaskData<ECS_TYPE,?,?>>	getFetchTask()
ParallelTask<EntityTickingSystem.SystemTaskData<ECS_TYPE>>	getParallelTask()
Ref<ECS_TYPE>	getParent(Ref<ECS_TYPE> ref)
ComponentRegistry<ECS_TYPE>	getRegistry()
<T extends Resource<ECS_TYPE>> T	getResource(ResourceType<ECS_TYPE,T> resourceType)	Fetches a resource from the given resource type.
IResourceStorage	getResourceStorage()
int	getStoreIndex()
HistoricMetric[]	getSystemMetrics()
<Event extends EcsEvent> void	invoke(EntityEventType<ECS_TYPE,Event> systemType, Ref<ECS_TYPE> ref, Event param)
<Event extends EcsEvent> void	invoke(EntityHolderEventType<ECS_TYPE,Event> systemType, Holder<ECS_TYPE> holder, Event param)
<Event extends EcsEvent> void	invoke(WorldEventType<ECS_TYPE,Event> systemType, Event param)
<Event extends EcsEvent> void	invoke(Holder<ECS_TYPE> holder, Event param)
<Event extends EcsEvent> void	invoke(Ref<ECS_TYPE> ref, Event param)
<Event extends EcsEvent> void	invoke(Event param)
boolean	isAliveInDifferentThread()
boolean	isInThread()
boolean	isProcessing()	Deprecated. this method should only be used to bridge legacy code all new code should work in such a way that this isn't needed
boolean	isShutdown()
void	pausedTick(float dt)
<T extends Component<ECS_TYPE>> void	putComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType, T component)	Called to put the given component onto the given entity.
<T extends Component<ECS_TYPE>> void	removeComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Called to remove the component of the given type from the given entity.
<T extends Component<ECS_TYPE>> boolean	removeComponentIfExists(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Called to remove the component from an entity if it exists.
Holder<ECS_TYPE>[]	removeEntities(Ref<ECS_TYPE>[] refs, int start, int length, RemoveReason reason)
Holder<ECS_TYPE>[]	removeEntities(Ref<ECS_TYPE>[] refArr, int refStart, Holder<ECS_TYPE>[] holders, int holderStart, int length, RemoveReason reason)	Removes a batch of entities, and every entity they own.
Holder<ECS_TYPE>[]	removeEntities(Ref<ECS_TYPE>[] refs, Holder<ECS_TYPE>[] holders, RemoveReason reason)
Holder<ECS_TYPE>[]	removeEntities(Ref<ECS_TYPE>[] refs, RemoveReason reason)
Holder<ECS_TYPE>	removeEntity(Ref<ECS_TYPE> ref, Holder<ECS_TYPE> holder, RemoveReason reason)	Called to remove the given entity from the store of this component accessor.
Holder<ECS_TYPE>	removeEntity(Ref<ECS_TYPE> ref, RemoveReason reason)	Removes an entity, and every entity it owns.
<T extends Component<ECS_TYPE>> void	replaceComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType, T component)
<T extends Resource<ECS_TYPE>> void	replaceResource(ResourceType<ECS_TYPE,T> resourceType, T resource)
CompletableFuture<Void>	saveAllResources()
void	setParent(Ref<ECS_TYPE> ref, Ref<ECS_TYPE> parent)	Moves an entity to a different owner, keeping all of its components.
void	shutdown()
void	tick(float dt)
void	tick(ArchetypeTickingSystem<ECS_TYPE> system, float dt, int systemIndex)	Required reading: CommandBuffer
String	toString()
<T extends Component<ECS_TYPE>> void	tryRemoveComponent(Ref<ECS_TYPE> ref, ComponentType<ECS_TYPE,T> componentType)	Called to try to remove the component og the given type from the given entity.

Methods inherited from class Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Details

EMPTY_ARRAY

public static final Store[] EMPTY_ARRAY

An array of stores that represents an empty set.

ROOT_PARENT_ID

public static final int ROOT_PARENT_ID

The parent id of an entity that no other entity owns and that owns no children. Never allocated to a real entity.

See Also:

• Constant Field Values

OWNER_ROOT_ID

public static final int OWNER_ROOT_ID

The parent id of an entity that no other entity owns and that owns children. Never allocated to a real entity.

See Also:

• Constant Field Values

METRICS_REGISTRY

@Nonnull
public static final MetricsRegistry<Store<?>> METRICS_REGISTRY

The metrics registry for stores.

Method Details

getStoreIndex

public int getStoreIndex()

Returns:

the index of the store in the registry.

getRegistry

@Nonnull
public ComponentRegistry<ECS_TYPE> getRegistry()

Returns:

the component registry associated with the store.

getExternalData

@Nonnull
public ECS_TYPE getExternalData()

Specified by:

getExternalData in interface ComponentAccessor<ECS_TYPE>

Returns:

the external data of this component accessor.

getResourceStorage

@Nonnull
public IResourceStorage getResourceStorage()

Returns:

the resource storage for this store.

getParallelTask

@Nonnull
public ParallelTask<EntityTickingSystem.SystemTaskData<ECS_TYPE>> getParallelTask()

getFetchTask

@Nonnull
public ParallelTask<EntityDataSystem.SystemTaskData<ECS_TYPE,?,?>> getFetchTask()

getSystemMetrics

@Nonnull
public HistoricMetric[] getSystemMetrics()

Returns:

the system metrics for tickable systems in the store.

isShutdown

public boolean isShutdown()

Returns:

true if this store is shutdown, false otherwise.

shutdown

public void shutdown()

saveAllResources

@Nonnull
public CompletableFuture<Void> saveAllResources()

getEntityCount

public int getEntityCount()

getEntityCountFor

public int getEntityCountFor(@Nonnull
 Query<ECS_TYPE> query)

getEntityCountFor

public int getEntityCountFor(int systemIndex)

Parameters:

systemIndex - The index for a registered system.

Returns:

The number of entities that match a system.

getArchetypeChunkCount

public int getArchetypeChunkCount()

collectArchetypeChunkData

@Nonnull
public ArchetypeChunkData[] collectArchetypeChunkData()

Collects diagnostic data about all archetype chunks in the store.

Returns:

an array of archetype chunk data for diagnostics

getArchetypeChunkCountFor

public int getArchetypeChunkCountFor(int systemIndex)

Parameters:

systemIndex - The index for a registered system.

Returns:

The number of archetype chunks that match a system.

addEntity

@Nullable
public Ref<ECS_TYPE> addEntity(@Nonnull
 Archetype<ECS_TYPE> archetype,
 @Nonnull
 AddReason reason)

addEntity

@Nullable
public Ref<ECS_TYPE> addEntity(@Nonnull
 Archetype<ECS_TYPE> archetype,
 @Nonnull
 AddReason reason,
 @Nullable
 Ref<ECS_TYPE> parent)

Parameters:

parent - The entity that owns the new entity, or null for the store root.

See Also:

• addEntity(Archetype, AddReason)

addEntity

@Nullable
public Ref<ECS_TYPE> addEntity(@Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 AddReason reason)

Description copied from interface: ComponentAccessor

Adds the given entity to the store of this component accessor.

Specified by:

addEntity in interface ComponentAccessor<ECS_TYPE>

Parameters:

holder - The holder of the entity to add.

reason - The reason that we are adding this entity.

Returns:

the entity Ref of the added entity.

addEntity

@Nullable
public Ref<ECS_TYPE> addEntity(@Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 AddReason reason,
 @Nullable
 Ref<ECS_TYPE> parent)

Parameters:

parent - The entity that owns the new entity, or null for the store root.

See Also:

• addEntity(Holder, AddReason)

addEntity

@Nullable
public Ref<ECS_TYPE> addEntity(@Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 AddReason reason)

addEntity

@Nullable
public Ref<ECS_TYPE> addEntity(@Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 AddReason reason,
 @Nullable
 Ref<ECS_TYPE> parent)

Parameters:

parent - The entity that owns the new entity, or null for the store root. When it is no longer valid the entity is not added and null is returned, which is the same signal as a system removing the entity during the add.

See Also:

• addEntity(Holder, Ref, AddReason)

addEntities

@Nonnull
public Ref<ECS_TYPE>[] addEntities(@Nonnull
 Holder<ECS_TYPE>[] holders,
 @Nonnull
 AddReason reason)

Description copied from interface: ComponentAccessor

Adds the given entities to the store of this component accessor.

Specified by:

addEntities in interface ComponentAccessor<ECS_TYPE>

Parameters:

holders - The holders of the entities to add.

reason - The reason that we are adding these entities.

Returns:

an array of entity Ref instances, representing the added entities.

See Also:

• addEntities(Holder[], int, Ref[], int, int, AddReason)

addEntities

@Nonnull
public Ref<ECS_TYPE>[] addEntities(@Nonnull
 Holder<ECS_TYPE>[] holders,
 int start,
 int length,
 @Nonnull
 AddReason reason)

Returns:

See Also:

• addEntities(Holder[], int, Ref[], int, int, AddReason)

addEntities

public void addEntities(@Nonnull
 Holder<ECS_TYPE>[] holders,
 @Nonnull
 Ref<ECS_TYPE>[] refs,
 @Nonnull
 AddReason reason)

See Also:

• addEntities(Holder[], int, Ref[], int, int, AddReason)

addEntities

public void addEntities(@Nonnull
 Holder<ECS_TYPE>[] holders,
 int holderStart,
 @Nonnull
 Ref<ECS_TYPE>[] refs,
 int refStart,
 int length,
 @Nonnull
 AddReason reason)

The refs parameter places the invalid ref's at the end of the sub-array (refStart to refStart + length). TODO: Since the ref's are shifted the index of the input holder isn't the same as the output refs. What do we care about more? Array sparsity or holder -> ref mapping? Should we provide an alternative method that doesn't shift the refs?

addEntities

public void addEntities(@Nonnull
 Holder<ECS_TYPE>[] holders,
 int holderStart,
 @Nonnull
 Ref<ECS_TYPE>[] refs,
 int refStart,
 int length,
 @Nonnull
 AddReason reason,
 @Nullable
 Ref<ECS_TYPE> parent)

Parameters:

parent - The entity that owns every new entity, or null for the store root. When it is no longer valid nothing is added.

See Also:

• addEntities(Holder[], int, Ref[], int, int, AddReason)

copyEntity

@Nonnull
public Holder<ECS_TYPE> copyEntity(@Nonnull
 Ref<ECS_TYPE> ref)

copyEntity

@Nonnull
public Holder<ECS_TYPE> copyEntity(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 Holder<ECS_TYPE> holder)

copySerializableEntity

@Nonnull
public Holder<ECS_TYPE> copySerializableEntity(@Nonnull
 Ref<ECS_TYPE> ref)

copySerializableEntity

@Nonnull
public Holder<ECS_TYPE> copySerializableEntity(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 Holder<ECS_TYPE> holder,
 @Nullable
 Predicate<ComponentType<ECS_TYPE,?>> filter)

getArchetype

@Nonnull
public Archetype<ECS_TYPE> getArchetype(@Nonnull
 Ref<ECS_TYPE> ref)

Description copied from interface: ComponentAccessor

Fetches the archetype for the given entity reference.

Specified by:

getArchetype in interface ComponentAccessor<ECS_TYPE>

Parameters:

ref - The entity Ref to fetch the archetype for.

Returns:

the Archetype of the given reference.

removeEntity

@Nonnull
public Holder<ECS_TYPE> removeEntity(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 RemoveReason reason)

Removes an entity, and every entity it owns. Only the named entity's data reaches holder; a child's data is discarded with it.

Parameters:

ref - The entity reference of the entity to remove.

reason - The removal reason.

Returns:

a holder containing the removed entity's components.

removeEntity

@Nonnull
public Holder<ECS_TYPE> removeEntity(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 RemoveReason reason)

Description copied from interface: ComponentAccessor

Called to remove the given entity from the store of this component accessor.

Specified by:

removeEntity in interface ComponentAccessor<ECS_TYPE>

Parameters:

ref - The entity reference of the entity being removed.

holder - The holder of the entity being removed.

reason - The reason that we are removing this entity.

Returns:

the holder of the removed entity.

removeEntities

@Nonnull
public Holder<ECS_TYPE>[] removeEntities(@Nonnull
 Ref<ECS_TYPE>[] refs,
 @Nonnull
 RemoveReason reason)

removeEntities

@Nonnull
public Holder<ECS_TYPE>[] removeEntities(@Nonnull
 Ref<ECS_TYPE>[] refs,
 int start,
 int length,
 @Nonnull
 RemoveReason reason)

removeEntities

@Nonnull
public Holder<ECS_TYPE>[] removeEntities(@Nonnull
 Ref<ECS_TYPE>[] refs,
 @Nonnull
 Holder<ECS_TYPE>[] holders,
 @Nonnull
 RemoveReason reason)

removeEntities

@Nonnull
public Holder<ECS_TYPE>[] removeEntities(@Nonnull
 Ref<ECS_TYPE>[] refArr,
 int refStart,
 @Nonnull
 Holder<ECS_TYPE>[] holders,
 int holderStart,
 int length,
 @Nonnull
 RemoveReason reason)

Removes a batch of entities, and every entity they own.

getParent

@Nullable
public Ref<ECS_TYPE> getParent(@Nonnull
 Ref<ECS_TYPE> ref)

Parameters:

ref - The entity reference of the entity.

Returns:

the entity that owns ref, or null when the store owns it directly.

setParent

public void setParent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nullable
 Ref<ECS_TYPE> parent)

Moves an entity to a different owner, keeping all of its components.

Hierarchy is two layers deep. An entity that owns children cannot be given a parent, and an entity that has a parent cannot be given children.

Parameters:

ref - The entity reference of the entity to move.

parent - The new owner, or null to give the entity back to the store root.

ensureComponent

public <T extends Component<ECS_TYPE>> void ensureComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

ensureAndGetComponent

@Nonnull
public <T extends Component<ECS_TYPE>> T ensureAndGetComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Description copied from interface: ComponentAccessor

Ensures and fetches the component instance of the given type for the given entity reference.

Specified by:

ensureAndGetComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component class type.

Parameters:

ref - The entity reference that we are fetching the component for.

componentType - The component type of the component.

Returns:

the component of the reference.

addComponent

@Nonnull
public <T extends Component<ECS_TYPE>> T addComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Description copied from interface: ComponentAccessor

Adds and returns the given component to the given entity reference.

Specified by:

addComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component class type.

Parameters:

ref - The entity Ref that we are adding this component to.

componentType - The type of the component.

Returns:

the newly instantiated instance of the component.

addComponent

public <T extends Component<ECS_TYPE>> void addComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType,
 @Nonnull
 T component)

Description copied from interface: ComponentAccessor

Adds the given component to the given entity reference.

Specified by:

addComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component class type.

Parameters:

ref - The entity Ref that we are adding this component to.

componentType - The type of the component.

component - The component instance to be added.

replaceComponent

public <T extends Component<ECS_TYPE>> void replaceComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType,
 @Nonnull
 T component)

putComponent

public <T extends Component<ECS_TYPE>> void putComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType,
 @Nonnull
 T component)

Description copied from interface: ComponentAccessor

Called to put the given component onto the given entity.

Specified by:

putComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component class type.

Parameters:

ref - The entity reference of the entity.

componentType - The component type of the component being put.

component - The component instance that is being put.

getComponent

public <T extends Component<ECS_TYPE>> T getComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Description copied from interface: ComponentAccessor

Fetches the component instance of the given type for the given entity reference.

Specified by:

getComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component class type.

Parameters:

ref - The entity reference that we are fetching the component for.

componentType - The component type of the component.

Returns:

the component of the reference, or null if one doesn't exist.

getComponentConcurrent

@Nullable
public <T extends Component<ECS_TYPE>> T getComponentConcurrent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Reads a component from any thread, without holding the world lock. The returned object belongs to ref and is never one from a different entity that has reused the same chunk slot.

Returns null when the entity does not have componentType, or when ref is invalidated during the read.

This protects against slot reuse, not against field mutation. The world thread can write fields on the returned component while the reader is using it, so individual field reads can be torn. Copy out the fields you need on the world thread if you require a consistent snapshot.

Each call takes its own seqlock pass. Two calls for the same entity can resolve in different ticks, so this is not a way to read several components and expect them to agree with each other.

removeComponent

public <T extends Component<ECS_TYPE>> void removeComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Description copied from interface: ComponentAccessor

Called to remove the component of the given type from the given entity.

Specified by:

removeComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component type based on the store type.

Parameters:

ref - The entity reference of the entity that we are removing the component from.

componentType - The component type of the component that we are removing.

tryRemoveComponent

public <T extends Component<ECS_TYPE>> void tryRemoveComponent(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Description copied from interface: ComponentAccessor

Called to try to remove the component og the given type from the given entity.

Specified by:

tryRemoveComponent in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The component type based on the store type.

Parameters:

ref - The entity reference of the entity that we are removing the component from.

componentType - The component type of the component that we are removing.

removeComponentIfExists

public <T extends Component<ECS_TYPE>> boolean removeComponentIfExists(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 ComponentType<ECS_TYPE,T> componentType)

Called to remove the component from an entity if it exists.

Type Parameters:

T - The component type.

Parameters:

ref - The entity reference of the entity.

componentType - The component type of the component to remove.

Returns:

true if the component was removed, false if the entity didn't have the component.

replaceResource

public <T extends Resource<ECS_TYPE>> void replaceResource(@Nonnull
 ResourceType<ECS_TYPE,T> resourceType,
 @Nonnull
 T resource)

getResource

@Nonnull
public <T extends Resource<ECS_TYPE>> T getResource(@Nonnull
 ResourceType<ECS_TYPE,T> resourceType)

Description copied from interface: ComponentAccessor

Fetches a resource from the given resource type.

Specified by:

getResource in interface ComponentAccessor<ECS_TYPE>

Type Parameters:

T - The resource type.

Parameters:

resourceType - The resource type to fetch.

Returns:

the Resource of the given class type.

forEachChunk

public void forEachChunk(@Nonnull
 BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every ArchetypeChunk in the component store, this includes non-ticking archetypes.

Parameters:

consumer - the task to run for each ArchetypeChunk.

forEachChunk

public boolean forEachChunk(@Nonnull
 BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> predicate)

Iterates every ArchetypeChunk in the component store until the predicate returns true, this includes non-ticking archetypes.

Parameters:

predicate - The task to run for each ArchetypeChunk. If the predicate returns true then iteration is stopped.

Returns:

true if the predicate returns true for any chunk.

forEachChunk

public void forEachChunk(Query<ECS_TYPE> query,
 @Nonnull
 BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every ArchetypeChunk in the component store that contains a matching Query, this includes non-ticking archetypes.

Parameters:

query - The Query that is used to filter the iterated ArchetypeChunk's.

consumer - The task to run for each ArchetypeChunk.

forEachChunk

public void forEachChunk(@Nullable
 Ref<ECS_TYPE> parent,
 @Nonnull
 Query<ECS_TYPE> query,
 @Nonnull
 BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every ArchetypeChunk owned by parent that contains a matching Query.

Parent scoping is a runtime argument and never part of a Query, because Query.test(Archetype) is what builds the cached system bitsets and those describe an archetype, not a parent.

Parameters:

parent - The owning entity, or null for the entities the store owns directly.

query - The Query that is used to filter the iterated ArchetypeChunk's.

consumer - The task to run for each ArchetypeChunk.

forEachChunk

public boolean forEachChunk(Query<ECS_TYPE> query,
 @Nonnull
 BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> predicate)

Iterates every ArchetypeChunk in the component store that contains a matching Query until the predicate returns true, this includes non-ticking archetypes.

Parameters:

query - The Query that is used to filter the iterated ArchetypeChunk's.

predicate - The task to run for each ArchetypeChunk. If the predicate returns true then iteration is stopped.

Returns:

true if the predicate returns true for any chunk

forEachChunk

public void forEachChunk(int systemIndex,
 @Nonnull
 BiConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every ArchetypeChunk in the component store that contains a matching Query, this includes non-ticking archetypes.

Parameters:

systemIndex - The systemIndex of a QuerySystem that is used to filter the iterated ArchetypeChunk's.

consumer - The task to run for each ArchetypeChunk.

forEachChunk

public boolean forEachChunk(int systemIndex,
 @Nonnull
 BiPredicate<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> predicate)

Iterates every ArchetypeChunk in the component store that contains a matching Query until the predicate returns true, this includes non-ticking archetypes.

Parameters:

systemIndex - The systemIndex of a QuerySystem that is used to filter the iterated ArchetypeChunk's.

predicate - The task to run for each ArchetypeChunk. If the predicate returns true then iteration is stopped.

Returns:

true if the predicate returns true for any chunk

forEachEntityParallel

public void forEachEntityParallel(IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every entity in the component store, this includes non-ticking entities.

Parameters:

consumer - the task to run for each entity.

forEachEntityParallel

public void forEachEntityParallel(Query<ECS_TYPE> query,
 IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every entity in the component store that contains a matching Query, this includes non-ticking entities.

Parameters:

query - The Query that is used to filter the iterated entities.

consumer - The task to run for each ArchetypeChunk.

forEachEntityParallel

public void forEachEntityParallel(@Nullable
 Ref<ECS_TYPE> parent,
 @Nonnull
 Query<ECS_TYPE> query,
 @Nonnull
 IntBiObjectConsumer<ArchetypeChunk<ECS_TYPE>, CommandBuffer<ECS_TYPE>> consumer)

Iterates every entity owned by parent that contains a matching Query.

Parameters:

parent - The owning entity, or null for the entities the store owns directly.

query - The Query that is used to filter the iterated entities.

consumer - The task to run for each entity.

fetch

public <T extends ArchetypeDataSystem<ECS_TYPE,Q,R>, Q, R>
void fetch(@Nonnull
 SystemType<ECS_TYPE,T> systemType,
 Q query,
 @Nonnull
 List<R> results)

Runs a SystemType for a subset of ArchetypeDataSystem's for all ArchetypeChunk with an Archetype that fulfills the Query provided by QuerySystem.getQuery()}.

Type Parameters:

T -

Q -

R -

fetch

public <T extends EntityDataSystem<ECS_TYPE,Q,R>, Q, R>
void fetch(@Nonnull
 Collection<Ref<ECS_TYPE>> refs,
 @Nonnull
 SystemType<ECS_TYPE,T> systemType,
 @Nonnull
 Q query,
 @Nonnull
 List<R> results)

Runs a SystemType for a subset of EntityDataSystem's for a specific Ref with an Archetype that fulfills the Query provided by QuerySystem.getQuery()}

Type Parameters:

T - The system type.

Q - The query type.

R - The result type.

invoke

public <Event extends EcsEvent> void invoke(@Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 Event param)

Specified by:

invoke in interface ComponentAccessor<ECS_TYPE>

invoke

public <Event extends EcsEvent> void invoke(@Nonnull
 EntityEventType<ECS_TYPE,Event> systemType,
 @Nonnull
 Ref<ECS_TYPE> ref,
 @Nonnull
 Event param)

Specified by:

invoke in interface ComponentAccessor<ECS_TYPE>

invoke

public <Event extends EcsEvent> void invoke(@Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 Event param)

Specified by:

invoke in interface ComponentAccessor<ECS_TYPE>

invoke

public <Event extends EcsEvent> void invoke(@Nonnull
 EntityHolderEventType<ECS_TYPE,Event> systemType,
 @Nonnull
 Holder<ECS_TYPE> holder,
 @Nonnull
 Event param)

Specified by:

invoke in interface ComponentAccessor<ECS_TYPE>

invoke

public <Event extends EcsEvent> void invoke(@Nonnull
 Event param)

Specified by:

invoke in interface ComponentAccessor<ECS_TYPE>

invoke

public <Event extends EcsEvent> void invoke(@Nonnull
 WorldEventType<ECS_TYPE,Event> systemType,
 @Nonnull
 Event param)

Specified by:

invoke in interface ComponentAccessor<ECS_TYPE>

tick

public void tick(float dt)

pausedTick

public void pausedTick(float dt)

tick

public void tick(ArchetypeTickingSystem<ECS_TYPE> system,
 float dt,
 int systemIndex)

Required reading: CommandBuffer

This is a utility method that contains the underlying ticking functionality for ArchetypeTickingSystem. This allows systems to provide functionality before the ticking of an ArchetypeChunk by overriding TickingSystem.tick(float, int, Store) and then calling to this method when ticking of ArchetypeChunk's is wanted.

For example, to only tick the ArchetypeChunk's when a condition is met:

public void tick(float dt, int systemIndex, Store<ECS_TYPE> store, CommandBuffer<ECS_TYPE> commandBuffer) {
    if (someCondition) {
        store.tick(this, dt, systemIndex);
    }
}

This allows for greatly improved performance by only checking the condition once per tick instead of for each ArchetypeChunk.

assertWriteProcessing

public void assertWriteProcessing()

isProcessing

@Deprecated
public boolean isProcessing()

Deprecated.

this method should only be used to bridge legacy code all new code should work in such a way that this isn't needed

Returns:

assertThread

public void assertThread()

isInThread

public boolean isInThread()

isAliveInDifferentThread

public boolean isAliveInDifferentThread()

toString

@Nonnull
public String toString()

Overrides:

toString in class Object