DelayedEntityProcessingSystem (artemis-odb 2.2.0 API)

java.lang.Object
- com.artemis.BaseSystem
- - com.artemis.BaseEntitySystem
  - - com.artemis.EntitySystem
    - - com.artemis.systems.DelayedEntityProcessingSystem

All Implemented Interfaces:

EntitySubscription.SubscriptionListener
```
public abstract class DelayedEntityProcessingSystem
extends EntitySystem
```
Tracks cooldown per entity, processing entity when its timer runs out.
An example system would be an ExpirationSystem, that deletes entities after a certain lifetime. Instead of running a system that decrements a timeLeft value for each entity, you can simply use this system to execute in a future at a time of the shortest lived entity, and then reset the system to run at a time in a future at a time of the shortest lived entity, etc.
Another example system would be an AnimationSystem. You know when you have to animate a certain entity, e.g. in 300 milliseconds. So you can set the system to run in 300 ms to perform the animation.
This will save CPU cycles in some scenarios.
Implementation notes:
Within processExpired(Entity e) you must call offerDelay(float delay) if the entity's delay time is renewed. That method is also called by inserted(int entityId) for each newly matched entity.

Author:

Arni Arent

Field Summary
- Fields inherited from class com.artemis.BaseEntitySystem
  subscription
- Fields inherited from class com.artemis.BaseSystem
  world

Constructor Summary

Constructors
Constructor and Description

DelayedEntityProcessingSystem()

DelayedEntityProcessingSystem(Aspect.Builder aspect)
Creates a new DelayedEntityProcessingSystem.

Constructors
Constructor and Description
`DelayedEntityProcessingSystem()`
`DelayedEntityProcessingSystem(Aspect.Builder aspect)` Creates a new DelayedEntityProcessingSystem.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected boolean`	`checkProcessing()` Does the system desire processing.
`float`	`getInitialTimeDelay()` Get the initial delay that the system was ordered to process entities after.
`protected abstract float`	`getRemainingDelay(Entity e)` Return the delay until this entity should be processed.
`float`	`getRemainingTimeUntilProcessing()` Get the time until the system is scheduled to run at.
`protected float`	`getTimeDelta()` Overridable method to provide custom time delta.
`void`	`inserted(Entity entity)` Called if entity has come into scope for this system, e.g created or a component was added to it.
`boolean`	`isRunning()` Check if the system is counting down towards processing.
`void`	`offerDelay(float offeredDelay)` Restarts the system only if the delay offered is shorter than the time that the system is currently scheduled to execute at.
`protected abstract void`	`processDelta(Entity e, float accumulatedDelta)` Process an entity this system is interested in.
`protected abstract void`	`processExpired(Entity e)`
`protected void`	`processSystem()` Process the system.
`void`	`stop()` Stops the system from running, aborts current countdown.

Methods inherited from class com.artemis.EntitySystem
getEntities, inserted, inserted, removed, removed, removed, setWorld

Methods inherited from class com.artemis.BaseEntitySystem
getEntityIds, getSubscription

Methods inherited from class com.artemis.BaseSystem
begin, dispose, end, getWorld, initialize, isEnabled, process, setEnabled

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DelayedEntityProcessingSystem
```
public DelayedEntityProcessingSystem(Aspect.Builder aspect)
```
    Creates a new DelayedEntityProcessingSystem.
    
    Parameters:
    
    aspect - the aspect to match against entities
  - DelayedEntityProcessingSystem
```
public DelayedEntityProcessingSystem()
```
- Method Detail
  - processSystem
```
protected final void processSystem()
```
    Description copied from class: BaseSystem
    
    Process the system.
    
    Specified by:
    
    processSystem in class BaseSystem
  - inserted
```
public void inserted(Entity entity)
```
    Description copied from class: EntitySystem
    
    Called if entity has come into scope for this system, e.g created or a component was added to it.
    
    Overrides:
    
    inserted in class EntitySystem
    
    Parameters:
    
    entity - the entity that was added to this system
  - getRemainingDelay
```
protected abstract float getRemainingDelay(Entity e)
```
    Return the delay until this entity should be processed.
    
    Parameters:
    
    e - entity
    
    Returns:
    
    delay
  - checkProcessing
```
protected final boolean checkProcessing()
```
    Description copied from class: BaseSystem
    
    Does the system desire processing. Useful when the system is enabled, but only occasionally needs to process. This only affects processing, and does not affect events or subscription lists.
    
    Overrides:
    
    checkProcessing in class BaseSystem
    
    Returns:
    
    true if the system should be processed, false if not.
    
    See Also:
    
    both must be true before the system will process.
  - getTimeDelta
```
protected float getTimeDelta()
```
    Overridable method to provide custom time delta.
  - processDelta
```
protected abstract void processDelta(Entity e,
                                     float accumulatedDelta)
```
    Process an entity this system is interested in.
    Substract the accumulatedDelta from the entities defined delay.
    
    Parameters:
    
    e - the entity to process
    
    accumulatedDelta - the delta time since this system was last executed
  - processExpired
```
protected abstract void processExpired(Entity e)
```
  - offerDelay
```
public void offerDelay(float offeredDelay)
```
    Restarts the system only if the delay offered is shorter than the time that the system is currently scheduled to execute at.
    If the system is already stopped (not running) then the offered delay will be used to restart the system with no matter its value.
    If the system is already counting down, and the offered delay is larger than the time remaining, the system will ignore it. If the offered delay is shorter than the time remaining, the system will restart itself to run at the offered delay.
    
    Parameters:
    
    offeredDelay - delay to offer
  - getInitialTimeDelay
```
public float getInitialTimeDelay()
```
    Get the initial delay that the system was ordered to process entities after.
    
    Returns:
    
    the originally set delay
  - getRemainingTimeUntilProcessing
```
public float getRemainingTimeUntilProcessing()
```
    Get the time until the system is scheduled to run at.
    Returns zero (0) if the system is not running. Use isRunning() before checking this value.
    
    Returns:
    
    time when system will run at
  - isRunning
```
public boolean isRunning()
```
    Check if the system is counting down towards processing.
    
    Returns:
    
    true if it's counting down, false if it's not running
  - stop
```
public void stop()
```
    Stops the system from running, aborts current countdown.
    Call offerDelay or restart to run it again.

Class DelayedEntityProcessingSystem

Field Summary

Fields inherited from class com.artemis.BaseEntitySystem

Fields inherited from class com.artemis.BaseSystem

Constructor Summary

Method Summary

Methods inherited from class com.artemis.EntitySystem

Methods inherited from class com.artemis.BaseEntitySystem

Methods inherited from class com.artemis.BaseSystem

Methods inherited from class java.lang.Object

Constructor Detail

DelayedEntityProcessingSystem

DelayedEntityProcessingSystem

Method Detail

processSystem

inserted

getRemainingDelay

checkProcessing

getTimeDelta

processDelta

processExpired

offerDelay

getInitialTimeDelay

getRemainingTimeUntilProcessing

isRunning

stop