Ashley ECS

https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4
Admin
A lightweight and high-performance Entity Component System (ECS) framework for Java game...
Tokens:9,723
Snippets:173
Trust Score:9.5
Update:1 month ago
Show doc for...
Tokens:
Raw
### Family Usage Example

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Demonstrates how to retrieve a family that requires specific components.

```java
Family.all(PositionComponent.class, VelocityComponent.class).get()
```

--------------------------------

### get()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Finalizes the configuration and returns the constructed Family instance.

```APIDOC
## Family.Builder.get

### Description
Returns a Family instance based on the component criteria configured in the builder.
```

--------------------------------

### Get All EntitySystems

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Returns an immutable array of all systems managed by the engine.

```java
public ImmutableArray<EntitySystem> getSystems()
```

--------------------------------

### Get Component Index by Class

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

A helper method to retrieve the index for a given Component class directly.

```java
public static int getIndexFor(java.lang.Class<? extends Component> componentType)
```

--------------------------------

### Get Entities for Family

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Returns an immutable collection of entities matching the specified family.

```java
public ImmutableArray<Entity> getEntitiesFor(Family family)
```

--------------------------------

### Get Bits for Components

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Generates a Bits object representing a collection of component types for efficient matching.

```java
public static com.badlogic.gdx.utils.Bits getBitsFor(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### Get Component from Entity

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

Retrieves the component of the mapper's type from the specified entity.

```java
public T get(Entity entity)
```

--------------------------------

### Get ComponentType Instance

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Retrieves the ComponentType instance corresponding to a specific Component class.

```java
public static ComponentType getFor(java.lang.Class<? extends Component> componentType)
```

--------------------------------

### all Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Creates a builder for a family requiring all specified component types.

```java
@SafeVarargs
public static final Family.Builder all(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### getSystem

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Retrieves a system of the specified type.

```APIDOC
## getSystem(Class<T> systemType)

### Description
Quick EntitySystem retrieval.
```

--------------------------------

### PooledEngine()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Creates a new PooledEngine instance with default pool sizes (100 entities and 100 components of each type).

```APIDOC
### Constructor
`public PooledEngine()`

Creates a new PooledEngine with a maximum of 100 entities and 100 components of each type.
```

--------------------------------

### getSystems

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Returns an immutable array of all systems managed by the engine.

```APIDOC
## getSystems()

### Description
Returns an immutable array of all entity systems managed by the Engine.
```

--------------------------------

### Retrieve system family

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Returns the Family configuration used during system initialization.

```java
public Family getFamily()
```

--------------------------------

### IntervalSystem(float interval, int priority)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

Constructs a new IntervalSystem with a specified interval and priority.

```APIDOC
### Constructor
`IntervalSystem(float interval, int priority)`

#### Parameters
- **interval** (float) - Time in seconds between calls to `updateInterval()`.
- **priority** (int) - The priority level of the system.
```

--------------------------------

### System Lifecycle and Processing Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

Methods for managing system lifecycle, retrieving entities, and defining processing logic.

```java
public void addedToEngine(Engine engine)
```

```java
protected void updateInterval()
```

```java
public ImmutableArray<Entity> getEntities()
```

```java
public Family getFamily()
```

```java
protected abstract void processEntity(Entity entity)
```

--------------------------------

### Constructor Definitions

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

Constructors for initializing the system with a target family and processing interval.

```java
public IntervalIteratingSystem(Family family,
                               float interval)
```

```java
public IntervalIteratingSystem(Family family,
                               float interval,
                               int priority)
```

--------------------------------

### Lifecycle and Update Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntitySystem.html

Methods for handling system lifecycle events and the main update loop.

```java
public void addedToEngine(Engine engine)
```

```java
public void removedFromEngine(Engine engine)
```

```java
public void update(float deltaTime)
```

--------------------------------

### IteratingSystem(Family family, int priority)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IteratingSystem.html

Instantiates a system that will iterate over the entities described by the Family, with a specific priority.

```APIDOC
## IteratingSystem(Family family, int priority)

### Description
Instantiates a system that will iterate over the entities described by the Family, with a specific priority.

### Parameters
- **family** (Family) - Required - The family of entities iterated over in this System.
- **priority** (int) - Required - The priority to execute this system with (lower means higher priority).
```

--------------------------------

### IntervalSystem Constructors

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

Constructors for initializing an IntervalSystem with a specific interval and optional priority.

```java
public IntervalSystem(float interval)
```

```java
public IntervalSystem(float interval,
                      int priority)
```

--------------------------------

### PooledEngine Constructors

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Constructors for initializing the PooledEngine with specific pool size configurations.

```java
public PooledEngine()
```

```java
public PooledEngine(int entityPoolInitialSize,
                    int entityPoolMaxSize,
                    int componentPoolInitialSize,
                    int componentPoolMaxSize)
```

--------------------------------

### PooledEngine(int, int, int, int)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Creates a new PooledEngine instance with custom configuration for entity and component pool sizes.

```APIDOC
### Constructor
`public PooledEngine(int entityPoolInitialSize, int entityPoolMaxSize, int componentPoolInitialSize, int componentPoolMaxSize)`

Creates new PooledEngine with the specified pools size configurations.

#### Parameters
- **entityPoolInitialSize** (int) - Initial number of pre-allocated entities.
- **entityPoolMaxSize** (int) - Maximum number of pooled entities.
- **componentPoolInitialSize** (int) - Initial size for each component type pool.
- **componentPoolMaxSize** (int) - Maximum size for each component type pool.
```

--------------------------------

### Constructors

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Constructors for initializing the system with a family and comparator, optionally specifying priority.

```java
public SortedIteratingSystem(Family family,
                             java.util.Comparator<Entity> comparator)
```

```java
public SortedIteratingSystem(Family family,
                             java.util.Comparator<Entity> comparator,
                             int priority)
```

--------------------------------

### Signal Constructor

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Initializes a new instance of the Signal class.

```java
public Signal()
```

--------------------------------

### IntervalSystem(float interval)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

Constructs a new IntervalSystem with a specified interval in seconds.

```APIDOC
### Constructor
`IntervalSystem(float interval)`

#### Parameters
- **interval** (float) - Time in seconds between calls to `updateInterval()`.
```

--------------------------------

### addSystem

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Adds an EntitySystem to the engine. If a system of the same class exists, it is replaced.

```APIDOC
## addSystem(EntitySystem system)

### Description
Adds the EntitySystem to this Engine. If the Engine already had a system of the same class, the new one will replace the old one.
```

--------------------------------

### one Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Creates a builder for a family requiring at least one of the specified component types.

```java
@SafeVarargs
public static final Family.Builder one(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### EntitySystem Constructors

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntitySystem.html

Constructors for initializing an EntitySystem with optional priority.

```java
public EntitySystem()
```

```java
public EntitySystem(int priority)
```

--------------------------------

### PooledEngine Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Core methods for managing pooled entities and components within the engine.

```java
public Entity createEntity()
```

```java
public <T extends Component> T createComponent(java.lang.Class<T> componentType)
```

```java
public void clearPools()
```

```java
protected void removeEntityInternal(Entity entity)
```

--------------------------------

### Entity Constructor

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Constructor for creating a new empty Entity.

```java
public Entity()
```

--------------------------------

### IteratingSystem(Family family)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IteratingSystem.html

Instantiates a system that will iterate over the entities described by the provided Family.

```APIDOC
## IteratingSystem(Family family)

### Description
Instantiates a system that will iterate over the entities described by the Family.

### Parameters
- **family** (Family) - Required - The family of entities iterated over in this System.
```

--------------------------------

### Family.all(Class<? extends Component>... componentTypes)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Creates a builder to define a family where entities must contain all of the specified components.

```APIDOC
### Method
`public static final Family.Builder all(java.lang.Class<? extends Component>... componentTypes)`

### Description
Creates a builder for a family that requires entities to contain all of the specified component types.

### Parameters
- **componentTypes** (java.lang.Class<? extends Component>...) - Required - The component types that must be present in the entity.
```

--------------------------------

### IteratingSystem Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IteratingSystem.html

Core methods for managing the system lifecycle and entity processing.

```java
public void addedToEngine(Engine engine)
```

```java
public void removedFromEngine(Engine engine)
```

```java
public void update(float deltaTime)
```

```java
public ImmutableArray<Entity> getEntities()
```

```java
public Family getFamily()
```

```java
protected abstract void processEntity(Entity entity,
                                      float deltaTime)
```

--------------------------------

### Component Management Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Methods for adding, removing, and retrieving components from an entity.

```java
public Entity add(Component component)
```

```java
public <T extends Component> T addAndReturn(T component)
```

```java
public <T extends Component> T remove(java.lang.Class<T> componentClass)
```

```java
public void removeAll()
```

```java
public ImmutableArray<Component> getComponents()
```

```java
public <T extends Component> T getComponent(java.lang.Class<T> componentClass)
```

--------------------------------

### Engine

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/index-all.html

Core engine methods for managing entities and components.

```APIDOC
## Engine Methods

### Methods
- **createComponent(Class<T> componentType)**: Creates a new Component.
- **createEntity()**: Creates a new Entity object.
```

--------------------------------

### Retrieve Family Instance

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Finalizes the configuration and returns the resulting Family instance.

```java
public Family get()
```

--------------------------------

### matches Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Checks if a given entity satisfies the family's component requirements.

```java
public boolean matches(Entity entity)
```

--------------------------------

### IntervalSystem Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

Methods available in the IntervalSystem class for managing intervals and updates.

```java
public float getInterval()
```

```java
public void update(float deltaTime)
```

```java
protected abstract void updateInterval()
```

--------------------------------

### Processing and Engine Access Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntitySystem.html

Methods to control system processing state and retrieve the associated engine.

```java
public boolean checkProcessing()
```

```java
public void setProcessing(boolean processing)
```

```java
public Engine getEngine()
```

--------------------------------

### Entity()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Creates a new, empty Entity instance.

```APIDOC
### Constructor
`Entity()`

Creates an empty Entity.
```

--------------------------------

### all(Class<? extends Component>... componentTypes)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Specifies that entities must contain all of the provided component types.

```APIDOC
## Family.Builder.all

### Description
Configures the builder to require that entities contain all of the specified component types.

### Parameters
- **componentTypes** (Class<? extends Component>...) - Required - The component classes that must be present in the entity.
```

--------------------------------

### PooledEngine

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/index-all.html

Engine implementation that utilizes object pooling for entities and components.

```APIDOC
## PooledEngine Methods

### Methods
- **clearPools()**: Removes all free entities and components from their pools.
- **createComponent(Class<T> componentType)**: Retrieves a new Component from the Engine pool.
- **createEntity()**: Creates a new Entity object from the pool.
```

--------------------------------

### update

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Updates all systems in the engine.

```APIDOC
## update(float deltaTime)

### Description
Updates all the systems in this Engine.

### Parameters
- **deltaTime** (float) - The time passed since the last frame.
```

--------------------------------

### Configure Required Components

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Specifies that entities must contain all of the provided component types.

```java
@SafeVarargs
public final Family.Builder all(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### EntitySystem Lifecycle and Control Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntitySystem.html

Methods for managing the lifecycle of an EntitySystem within an Engine and controlling its execution state.

```APIDOC
## void addedToEngine(Engine engine)

### Description
Called when this EntitySystem is added to an Engine.

### Parameters
- **engine** (Engine) - The Engine this system was added to.

## void removedFromEngine(Engine engine)

### Description
Called when this EntitySystem is removed from an Engine.

### Parameters
- **engine** (Engine) - The Engine the system was removed from.

## void update(float deltaTime)

### Description
The update method called every tick.

### Parameters
- **deltaTime** (float) - The time passed since last frame in seconds.

## boolean checkProcessing()

### Description
Checks whether or not the system should be processed.

### Returns
- **boolean** - True if the system should be processed, false otherwise.

## void setProcessing(boolean processing)

### Description
Sets whether or not the system should be processed by the Engine.

### Parameters
- **processing** (boolean) - The processing state to set.

## Engine getEngine()

### Description
Retrieves the engine instance the system is registered to.

### Returns
- **Engine** - The engine instance, or null if not associated with any engine.
```

--------------------------------

### Retrieve EntitySystem

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Retrieves a system by its class type.

```java
public <T extends EntitySystem> T getSystem(java.lang.Class<T> systemType)
```

--------------------------------

### SortedIteratingSystem(Family family, Comparator<Entity> comparator, int priority)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Instantiates a new SortedIteratingSystem with a specific execution priority.

```APIDOC
### Constructor
SortedIteratingSystem(Family family, java.util.Comparator<Entity> comparator, int priority)

### Parameters
- **family** (Family) - The family of entities to iterate over.
- **comparator** (java.util.Comparator<Entity>) - The comparator used to sort the entities.
- **priority** (int) - The priority to execute this system with (lower values indicate higher priority).
```

--------------------------------

### createComponent(Class<T>)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Retrieves a new Component from the engine pool.

```APIDOC
### Method
`public <T extends Component> T createComponent(java.lang.Class<T> componentType)`

Retrieves a new Component from the Engine pool. It will be placed back in the pool whenever it's removed from an Entity or the Entity itself is removed.
```

--------------------------------

### IteratingSystem Constructors

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IteratingSystem.html

Constructors for initializing an IteratingSystem with a specific entity Family and optional priority.

```java
public IteratingSystem(Family family)
```

```java
public IteratingSystem(Family family,
                       int priority)
```

--------------------------------

### getFamily()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

Retrieves the family configuration used by the system.

```APIDOC
## Method: getFamily()

### Description
Returns the Family object used to filter entities for this system.

### Returns
- **Family** - The Family used when the system was created.
```

--------------------------------

### SortedIteratingSystem(Family family, Comparator<Entity> comparator)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Instantiates a new SortedIteratingSystem that iterates over entities in the specified family, sorted by the provided comparator.

```APIDOC
### Constructor
SortedIteratingSystem(Family family, java.util.Comparator<Entity> comparator)

### Parameters
- **family** (Family) - The family of entities to iterate over.
- **comparator** (java.util.Comparator<Entity>) - The comparator used to sort the entities.
```

--------------------------------

### Handle system removal from engine

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Lifecycle method invoked when the system is removed from an engine instance.

```java
public void removedFromEngine(Engine engine)
```

--------------------------------

### IntervalIteratingSystem(Family family, float interval)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

Constructs a new IntervalIteratingSystem with the specified family and interval.

```APIDOC
## Constructor: IntervalIteratingSystem(Family family, float interval)

### Description
Initializes a system that processes a specific family of entities at a given time interval.

### Parameters
- **family** (Family) - The collection of entities the system should process.
- **interval** (float) - Time in seconds between calls to updateInterval().
```

--------------------------------

### removedFromEngine(Engine engine)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Called when the system is removed from an Engine instance.

```APIDOC
## void removedFromEngine(Engine engine)

### Description
Called when this EntitySystem is removed from an Engine.

### Parameters
- **engine** (Engine) - The Engine the system was removed from.
```

--------------------------------

### Bag Constructors

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/Bag.html

Constructors for initializing a new Bag instance with optional capacity.

```java
public
Bag()
```

```java
public
Bag(int
capacity)
```

--------------------------------

### Class Declaration

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

The class definition for SortedIteratingSystem, extending EntitySystem and implementing EntityListener.

```java
public abstract class SortedIteratingSystem
extends EntitySystem
implements EntityListener
```

--------------------------------

### Configure Optional Components

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Specifies that entities must contain at least one of the provided component types.

```java
@SafeVarargs
public final Family.Builder one(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### Add EntitySystem to Engine

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Registers an EntitySystem. If a system of the same class exists, it is replaced.

```java
public void addSystem(EntitySystem system)
```

--------------------------------

### getBitsFor(Class<? extends Component>...)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Generates a Bits representation for a collection of Component classes.

```APIDOC
### Method
public static com.badlogic.gdx.utils.Bits getBitsFor(Class<? extends Component>... componentTypes)

### Description
Creates a Bits object representing the provided collection of component classes, useful for fast comparison and matching.

### Parameters
- **componentTypes** (Class<? extends Component>...) - A variable list of Component classes.

### Returns
- **com.badlogic.gdx.utils.Bits** - A Bits object representing the collection of components.
```

--------------------------------

### createEntity()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Creates a new Entity object from the engine pool.

```APIDOC
### Method
`public Entity createEntity()`

Creates a new Entity object. Returns a clean Entity from the Engine pool.
```

--------------------------------

### reset()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Resets the builder instance to its initial state.

```APIDOC
## Family.Builder.reset

### Description
Resets the builder instance, clearing all previously configured component requirements.
```

--------------------------------

### getInterval()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

Retrieves the current interval setting for the system.

```APIDOC
### Method
`float getInterval()`

#### Returns
- **float** - The time interval in seconds.
```

--------------------------------

### Added to Engine Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Lifecycle method called when the system is added to an engine.

```java
public void addedToEngine(Engine engine)
```

--------------------------------

### add(Listener<T> listener)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Registers a listener to receive events from this signal.

```APIDOC
## void add(Listener<T> listener)

### Description
Adds a Listener to this Signal.

### Parameters
- **listener** (Listener<T>) - Required - The Listener to be added.
```

--------------------------------

### Class Declaration

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

The class definition for IntervalIteratingSystem, which extends IntervalSystem.

```java
public abstract class IntervalIteratingSystem
extends IntervalSystem
```

--------------------------------

### removeAllSystems

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Removes all systems currently managed by the engine.

```APIDOC
## removeAllSystems()

### Description
Removes all systems from this Engine.
```

--------------------------------

### Bag Accessor and Utility Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/Bag.html

Methods for querying the state and contents of the Bag.

```java
public
boolean
contains(E
e)
```

```java
public
E
get(int
index)
```

```java
public
int
size()
```

```java
public
int
getCapacity()
```

```java
public
boolean
isIndexWithinBounds(int
index)
```

```java
public
boolean
isEmpty()
```

--------------------------------

### IntervalSystem Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

The base class definition for IntervalSystem extending EntitySystem.

```java
public abstract class IntervalSystem
extends EntitySystem
```

--------------------------------

### Bag<E>

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/index-all.html

A fast collection similar to Array that grows on demand as elements are accessed.

```APIDOC
## Bag<E>

### Description
Fast collection similar to Array that grows on demand as elements are accessed.

### Constructors
- **Bag()**: Creates an empty Bag with an initial capacity of 64.
- **Bag(int capacity)**: Creates an empty Bag with the specified initial capacity.

### Methods
- **clear()**: Removes all of the elements from this bag.
- **contains(E element)**: Check if bag contains this element.
```

--------------------------------

### Family.one(Class<? extends Component>... componentTypes)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Creates a builder to define a family where entities must contain at least one of the specified components.

```APIDOC
### Method
`public static final Family.Builder one(java.lang.Class<? extends Component>... componentTypes)`

### Description
Creates a builder for a family that requires entities to contain at least one of the specified component types.

### Parameters
- **componentTypes** (java.lang.Class<? extends Component>...) - Required - The component types, at least one of which must be present in the entity.
```

--------------------------------

### Implement receive Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Listener.html

The method invoked when a signal is dispatched.

```java
void receive(Signal<T> signal,
             T object)
```

--------------------------------

### EntitySystem Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntitySystem.html

The base class definition for all systems in the Ashley framework.

```java
public abstract class EntitySystem
extends java.lang.Object
```

--------------------------------

### void receive(Signal<T> signal, T object)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Listener.html

This method is invoked when a signal is dispatched. It receives the triggering signal and the associated data object.

```APIDOC
## void receive(Signal<T> signal, T object)

### Description
Invoked when a Signal is triggered. Implement this method to define the logic that should execute in response to a signal event.

### Parameters
- **signal** (Signal<T>) - The Signal instance that triggered the event.
- **object** (T) - The data object passed during the signal dispatch.
```

--------------------------------

### Update Engine

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Updates all systems in the engine using the provided delta time.

```java
public void update(float deltaTime)
```

--------------------------------

### Add Listener

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Registers a listener to receive events from the signal.

```java
public void add(Listener<T> listener)
```

--------------------------------

### Entity Lifecycle Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Methods to check the removal status of an entity.

```java
public boolean isScheduledForRemoval()
```

```java
public boolean isRemoving()
```

--------------------------------

### Add EntityListener

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Registers listeners to be notified of entity additions or removals. Priority determines execution order, with lower values executing first.

```java
public void addEntityListener(EntityListener listener)
```

```java
public void addEntityListener(int priority,
                              EntityListener listener)
```

```java
public void addEntityListener(Family family,
                              EntityListener listener)
```

```java
public void addEntityListener(Family family,
                              int priority,
                              EntityListener listener)
```

--------------------------------

### Handle entity addition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Callback triggered when an entity is added to the engine or a specific family.

```java
public void entityAdded(Entity entity)
```

--------------------------------

### Retrieve a ComponentMapper Instance

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

Use this static method to obtain a mapper instance for a specific component class.

```java
public static <T extends Component> ComponentMapper<T> getFor(java.lang.Class<T> componentClass)
```

--------------------------------

### one(Class<? extends Component>... componentTypes)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Specifies that entities must contain at least one of the provided component types.

```APIDOC
## Family.Builder.one

### Description
Configures the builder to require that entities contain at least one of the specified component types.

### Parameters
- **componentTypes** (Class<? extends Component>...) - Required - The component classes, at least one of which must be present in the entity.
```

--------------------------------

### Define a Component interface

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Component.html

The base interface for all components used to store data for EntitySystems.

```java
public interface Component
```

--------------------------------

### Entity Field Definitions

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Public fields available on an Entity instance.

```java
public int flags
```

```java
public final Signal<Entity> componentAdded
```

```java
public final Signal<Entity> componentRemoved
```

--------------------------------

### Dispatch Event

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Sends an event object to all registered listeners.

```java
public void dispatch(T object)
```

--------------------------------

### PooledEngine Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

The class definition for PooledEngine, which extends the base Engine class.

```java
public class PooledEngine
extends Engine
```

--------------------------------

### Remove All EntitySystems

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Clears all systems currently managed by the engine.

```java
public void removeAllSystems()
```

--------------------------------

### add(Component component)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Adds a component to the entity. If a component of the same type exists, it is replaced.

```APIDOC
### Method
`Entity add(Component component)`

Adds a `Component` to this Entity. If a `Component` of the same type already exists, it'll be replaced.

**Returns:** The Entity for easy chaining.
```

--------------------------------

### addEntityListener

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Adds an entity listener to the engine, optionally filtered by family and priority.

```APIDOC
## addEntityListener(EntityListener listener)
## addEntityListener(int priority, EntityListener listener)
## addEntityListener(Family family, EntityListener listener)
## addEntityListener(Family family, int priority, EntityListener listener)

### Description
Adds an EntityListener to be notified when entities are added or removed. Priority determines execution order (lower value executes first).
```

--------------------------------

### Entity Class Declaration

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

The base definition of the Entity class.

```java
public class Entity
extends java.lang.Object
```

--------------------------------

### ComponentMapper.getFor(Class<T> componentClass)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

Creates a new ComponentMapper instance for the specified component class to enable fast access.

```APIDOC
### Method
public static <T extends Component> ComponentMapper<T> getFor(java.lang.Class<T> componentClass)

### Parameters
- **componentClass** (java.lang.Class<T>) - The Component class to be retrieved by the mapper.

### Returns
- **ComponentMapper<T>** - A new instance that provides fast access to the Component of the specified class.
```

--------------------------------

### Family.Builder Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

The standard class declaration for the Family.Builder utility.

```java
public static class Family.Builder
extends java.lang.Object
```

--------------------------------

### removeSystem

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Removes a specific EntitySystem from the engine.

```APIDOC
## removeSystem(EntitySystem system)

### Description
Removes the EntitySystem from this Engine.
```

--------------------------------

### getEntities()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

Retrieves the set of entities currently processed by the system.

```APIDOC
## Method: getEntities()

### Description
Returns the collection of entities that match the system's family.

### Returns
- **ImmutableArray<Entity>** - The set of entities processed by the system.
```

--------------------------------

### Process individual entity

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Abstract method to be implemented for custom entity processing logic during each update cycle.

```java
protected abstract void processEntity(Entity entity,
                                      float deltaTime)
```

--------------------------------

### ImmutableArray Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/ImmutableArray.html

Methods available for interacting with an ImmutableArray instance.

```java
public int size()
```

```java
public T get(int index)
```

```java
public boolean contains(T value,
                        boolean identity)
```

```java
public int indexOf(T value,
                   boolean identity)
```

```java
public int lastIndexOf(T value,
                       boolean identity)
```

```java
public T peek()
```

```java
public T first()
```

```java
public T random()
```

```java
public T[] toArray()
```

```java
public <V> V[] toArray(java.lang.Class<V> type)
```

```java
public int hashCode()
```

```java
public boolean equals(java.lang.Object object)
```

```java
public java.lang.String toString()
```

```java
public java.lang.String toString(java.lang.String separator)
```

```java
public java.util.Iterator<T> iterator()
```

--------------------------------

### Internal Entity Management

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Protected methods for internal entity addition and removal.

```java
protected void addEntityInternal(Entity entity)
```

```java
protected void removeEntityInternal(Entity entity)
```

--------------------------------

### clearPools()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/PooledEngine.html

Removes all free entities and components from their pools to free up memory.

```APIDOC
### Method
`public void clearPools()`

Removes all free entities and components from their pools. Although this will likely result in garbage collection, it will free up memory.
```

--------------------------------

### Family.exclude(Class<? extends Component>... componentTypes)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Creates a builder to define a family where entities must not contain any of the specified components.

```APIDOC
### Method
`public static final Family.Builder exclude(java.lang.Class<? extends Component>... componentTypes)`

### Description
Creates a builder for a family that requires entities to exclude all of the specified component types.

### Parameters
- **componentTypes** (java.lang.Class<? extends Component>...) - Required - The component types that must not be present in the entity.
```

--------------------------------

### getFor(Class<? extends Component>)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Retrieves the ComponentType instance corresponding to a specific Component class.

```APIDOC
### Method
public static ComponentType getFor(Class<? extends Component> componentType)

### Description
Returns the ComponentType instance that matches the provided Component class.

### Parameters
- **componentType** (Class<? extends Component>) - The Component class to retrieve the type for.

### Returns
- **ComponentType** - The matching ComponentType instance.
```

--------------------------------

### ImmutableArray Constructor

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/ImmutableArray.html

Constructor for creating an ImmutableArray from an existing Array.

```java
public ImmutableArray(com.badlogic.gdx.utils.Array<T> array)
```

--------------------------------

### Signal Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

The base class definition for the Signal event system.

```java
public class Signal<T>
extends java.lang.Object
```

--------------------------------

### dispatch(T object)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Dispatches an event object to all registered listeners.

```APIDOC
## void dispatch(T object)

### Description
Dispatches an event to all Listeners registered to this Signal.

### Parameters
- **object** (T) - Required - The object to send off.
```

--------------------------------

### IteratingSystem Class Declaration

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IteratingSystem.html

The base class definition for systems that iterate over entities.

```java
public abstract class IteratingSystem
extends EntitySystem
```

--------------------------------

### Family.matches(Entity entity)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Checks if a given entity satisfies the requirements of this family.

```APIDOC
### Method
`public boolean matches(Entity entity)`

### Description
Determines whether the provided entity matches the requirements defined by this family.

### Parameters
- **entity** (Entity) - Required - The entity to check against the family requirements.

### Returns
- **boolean** - True if the entity matches, false otherwise.
```

--------------------------------

### entityAdded Method Signature

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntityListener.html

Callback triggered when an entity is added to the engine or a family.

```java
void entityAdded(Entity entity)
```

--------------------------------

### processEntity(Entity entity)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalIteratingSystem.html

Abstract method to be implemented by the user to define entity processing logic.

```APIDOC
## Method: processEntity(Entity entity)

### Description
This method contains the logic to be applied to each entity in the family. Users must override this method.

### Parameters
- **entity** (Entity) - The entity to process.
```

--------------------------------

### Bag Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/Bag.html

The base class definition for the generic Bag collection.

```java
public class Bag<E>
extends java.lang.Object
```

--------------------------------

### Configure Excluded Components

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Specifies that entities must not contain any of the provided component types.

```java
@SafeVarargs
public final Family.Builder exclude(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### EntityListener Interface Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntityListener.html

The base interface for receiving notifications about entity lifecycle events.

```java
public interface EntityListener
```

--------------------------------

### Define Listener Interface

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Listener.html

The generic interface for receiving events from a Signal.

```java
public interface Listener<T>
```

--------------------------------

### Reset Builder Instance

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Resets the builder instance to its initial state.

```java
public Family.Builder reset()
```

--------------------------------

### getIndex()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Retrieves the unique index assigned to this ComponentType instance.

```APIDOC
### Method
public int getIndex()

### Description
Returns the unique index associated with this specific ComponentType instance.

### Returns
- **int** - The unique index of the component type.
```

--------------------------------

### removeAll()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Removes all components currently attached to the entity.

```APIDOC
### Method
`void removeAll()`

Removes all the `Component`'s from the Entity.
```

--------------------------------

### Family Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

The class declaration for Family.

```java
public class Family
extends java.lang.Object
```

--------------------------------

### processEntity(Entity entity, float deltaTime)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IteratingSystem.html

An abstract method that must be overridden to implement specific processing logic for each entity during the update cycle.

```APIDOC
## processEntity(Entity entity, float deltaTime)

### Description
This method is called on every entity on every update call of the EntitySystem. Override this to implement your system's specific processing.

### Parameters
- **entity** (Entity) - Required - The current Entity being processed.
- **deltaTime** (float) - Required - The delta time between the last and current frame.
```

--------------------------------

### Bag Removal Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/Bag.html

Methods for removing elements from the Bag by index or by object reference.

```java
public
E
remove(int
index)
```

```java
public
E
removeLast()
```

```java
public
boolean
remove(E
e)
```

--------------------------------

### Handle entity removal

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Callback triggered when an entity is removed from the engine or a specific family.

```java
public void entityRemoved(Entity entity)
```

--------------------------------

### exclude(Class<? extends Component>... componentTypes)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.Builder.html

Specifies that entities must not contain any of the provided component types.

```APIDOC
## Family.Builder.exclude

### Description
Configures the builder to exclude entities that contain any of the specified component types.

### Parameters
- **componentTypes** (Class<? extends Component>...) - Required - The component classes that must not be present in the entity.
```

--------------------------------

### getIndexFor(Class<? extends Component>)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

A helper method to retrieve the unique index for a given Component class.

```APIDOC
### Method
public static int getIndexFor(Class<? extends Component> componentType)

### Description
Quickly retrieves the unique index for the specified Component class.

### Parameters
- **componentType** (Class<? extends Component>) - The Component class.

### Returns
- **int** - The index for the specified Component class.
```

--------------------------------

### updateInterval()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

An abstract method where the actual processing logic should be implemented. This is called automatically when the interval time has elapsed.

```APIDOC
### Method
`protected abstract void updateInterval()`
```

--------------------------------

### getEntitiesFor

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Returns an immutable collection of entities matching a specific family.

```APIDOC
## getEntitiesFor(Family family)

### Description
Returns immutable collection of entities for the specified Family. Returns the same instance every time for the same Family.
```

--------------------------------

### Retrieve Component Index

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Returns the unique index associated with the ComponentType instance.

```java
public int getIndex()
```

--------------------------------

### Bag Modification Methods

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/Bag.html

Methods for adding, setting, or clearing elements in the Bag.

```java
public
void
add(E
e)
```

```java
public
void
set(int
index,
                E
e)
```

```java
public
void
clear()
```

--------------------------------

### exclude Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Creates a builder for a family that excludes entities containing any of the specified component types.

```java
@SafeVarargs
public static final Family.Builder exclude(java.lang.Class<? extends Component>... componentTypes)
```

--------------------------------

### Priority Field Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntitySystem.html

The priority field used to determine the execution order of systems.

```java
public int priority
```

--------------------------------

### ComponentMapper.get(Entity entity)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

Retrieves the component of the mapper's specified class from the given entity.

```APIDOC
### Method
public T get(Entity entity)

### Parameters
- **entity** (Entity) - The entity from which to retrieve the component.

### Returns
- **T** - The Component of the specified class belonging to the entity.
```

--------------------------------

### forceSort()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Forces the system to re-sort the entity list. This should be called if the sorting criteria have changed.

```APIDOC
### Method
void forceSort()

### Description
Call this if the sorting criteria have changed. The actual sorting will be delayed until the entities are processed.
```

--------------------------------

### Family.getIndex()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Family.html

Retrieves the unique index assigned to this family.

```APIDOC
### Method
`public int getIndex()`

### Description
Returns the unique index associated with this specific family instance.

### Returns
- **int** - The unique index of the family.
```

--------------------------------

### update(float deltaTime)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/IntervalSystem.html

The update method called every tick, which manages the interval timing logic.

```APIDOC
### Method
`void update(float deltaTime)`

#### Parameters
- **deltaTime** (float) - The time passed since the last frame in seconds.
```

--------------------------------

### getComponent(Class<T> componentClass)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Retrieves a component from the entity by its class type.

```APIDOC
### Method
`<T extends Component> T getComponent(java.lang.Class<T> componentClass)`

Retrieve a component from this `Entity` by class.

**Parameters:**
- `componentClass` - the class of the component to be retrieved.

**Returns:** The instance of the specified `Component` attached to this `Entity`, or null if no such `Component` exists.
```

--------------------------------

### Retrieve processed entities

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Returns the collection of entities currently being processed by this system.

```java
public ImmutableArray<Entity> getEntities()
```

--------------------------------

### ComponentType Equality Check

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Overrides the default equals method to compare ComponentType instances.

```java
public boolean equals(java.lang.Object obj)
```

--------------------------------

### ComponentType HashCode

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

Overrides the default hashCode method.

```java
public int hashCode()
```

--------------------------------

### Force Sort Method

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/systems/SortedIteratingSystem.html

Method to trigger a re-sort of the entities if the sorting criteria have changed.

```java
public void forceSort()
```

--------------------------------

### ComponentMapper Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

The class definition for ComponentMapper, which is generic over a Component type.

```java
public final class ComponentMapper<T extends Component>
extends java.lang.Object
```

--------------------------------

### entityAdded(Entity entity)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntityListener.html

Called whenever an Entity is added to the Engine or a specific Family.

```APIDOC
## void entityAdded(Entity entity)

### Description
Called whenever an Entity is added to Engine or a specific Family.

### Parameters
- **entity** (Entity) - The entity that was added.
```

--------------------------------

### Remove EntitySystem from Engine

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Removes a specific EntitySystem from the engine.

```java
public void removeSystem(EntitySystem system)
```

--------------------------------

### ComponentType Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentType.html

The class definition for ComponentType, which is final and extends Object.

```java
public final class ComponentType
extends java.lang.Object
```

--------------------------------

### ComponentMapper.has(Entity entity)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

Checks if the specified entity contains the component associated with this mapper.

```APIDOC
### Method
public boolean has(Entity entity)

### Parameters
- **entity** (Entity) - The entity to check.

### Returns
- **boolean** - True if the entity has the component, false otherwise.
```

--------------------------------

### removeAllListeners()

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Removes all listeners currently attached to the signal.

```APIDOC
## void removeAllListeners()

### Description
Removes all listeners attached to this Signal.
```

--------------------------------

### Check for Component Existence

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/ComponentMapper.html

Checks if the specified entity contains the component type associated with this mapper.

```java
public boolean has(Entity entity)
```

--------------------------------

### entityRemoved Method Signature

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntityListener.html

Callback triggered when an entity is removed from the engine or a family.

```java
void entityRemoved(Entity entity)
```

--------------------------------

### Remove All Listeners

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Clears all registered listeners from the signal.

```java
public void removeAllListeners()
```

--------------------------------

### Remove EntityListener

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Unregisters an existing entity listener.

```java
public void removeEntityListener(EntityListener listener)
```

--------------------------------

### remove(Listener<T> listener)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Unregisters a listener from this signal.

```APIDOC
## void remove(Listener<T> listener)

### Description
Removes a listener from this Signal.

### Parameters
- **listener** (Listener<T>) - Required - The Listener to remove.
```

--------------------------------

### Remove Listener

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/signals/Signal.html

Unregisters a specific listener from the signal.

```java
public void remove(Listener<T> listener)
```

--------------------------------

### remove(Class<T> componentClass)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Entity.html

Removes the component of the specified type from the entity.

```APIDOC
### Method
`<T extends Component> T remove(java.lang.Class<T> componentClass)`

Removes the `Component` of the specified type.

**Returns:** The removed `Component`, or null if the Entity did not contain such a component.
```

--------------------------------

### ImmutableArray Class Definition

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/utils/ImmutableArray.html

The class definition for ImmutableArray, which implements the Iterable interface.

```java
public class ImmutableArray<T>
extends java.lang.Object
implements java.lang.Iterable<T>
```

--------------------------------

### removeEntityListener

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/Engine.html

Removes a previously added entity listener.

```APIDOC
## removeEntityListener(EntityListener listener)

### Description
Removes an EntityListener.
```

--------------------------------

### entityRemoved(Entity entity)

Source: https://javadoc.io/doc/com.badlogicgames.ashley/ashley/1.7.4/com/badlogic/ashley/core/EntityListener.html

Called whenever an Entity is removed from the Engine or a specific Family.

```APIDOC
## void entityRemoved(Entity entity)

### Description
Called whenever an Entity is removed from Engine or a specific Family.

### Parameters
- **entity** (Entity) - The entity that was removed.
```
Tokens:
Raw