World (artemis-odb 0.7.1 API)

java.lang.Object
- com.artemis.World

```
public class World
extends Object
```
The primary instance for the framework.
It contains all the managers. You must use this to create, delete and retrieve entities. It is also important to set the delta each game loop iteration, and initialize before game loop.

Author:

Arni Arent

Field Summary

Fields
Modifier and Type Field and Description

float delta
The time passed since the last update.

Fields
Modifier and Type	Field and Description
`float`	`delta` The time passed since the last update.

Constructor Summary

Constructors
Constructor and Description
`World()` Creates a new world.
`World(int expectedEntityCount)` Deprecated. `World(WorldConfiguration)` provides more fine-grained control.
`World(WorldConfiguration configuration)` Creates a new world.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addEntity(Entity e)` Deprecated. internally managed by artemis
`void`	`changedEntity(Entity e)` Deprecated. does nothing, internally tracked by artemis now.
`Entity`	`createEntity()` Create and return a new or reused entity instance.
`Entity`	`createEntity(ArchetypeBuilder.Archetype archetype)` Create and return an `EntityEdit` wrapping a new or reused entity instance.
`Entity`	`createEntity(UUID uuid)` Create and return a new or reused entity instance.
`void`	`deleteEntity(Entity e)` Deprecated. Better invoke `Entity.deleteFromWorld()` or `EntityEdit.deleteEntity()`
`void`	`deleteManager(Manager manager)` Deprecated. A world should be static once initialized
`void`	`deleteSystem(EntitySystem system)` Deprecated. A world should be static once initialized
`void`	`disable(Entity e)` Deprecated. create your own components to track state.
`void`	`dispose()` Disposes all managers and systems.
`void`	`enable(Entity e)` Deprecated. create your own components to track state.
`ComponentManager`	`getComponentManager()` Returns a manager that takes care of all the components in the world.
`float`	`getDelta()` Time since last game loop.
`Entity`	`getEntity(int entityId)` Get a entity having the specified id.
`EntityManager`	`getEntityManager()` Returns a manager that takes care of all the entities in the world.
`<T extends Manager> T`	`getManager(Class<T> managerType)` Returns a manager of the specified type.
`ImmutableBag<Manager>`	`getManagers()`
`<T extends Component> ComponentMapper<T>`	`getMapper(Class<T> type)` Retrieves a ComponentMapper instance for fast retrieval of components from entities.
`<T extends EntitySystem> T`	`getSystem(Class<T> type)` Retrieve a system for specified system type.
`ImmutableBag<EntitySystem>`	`getSystems()` Gives you all the systems in this world for possible iteration.
`void`	`initialize()` Makes sure all managers systems are initialized in the order they were added.
`void`	`inject(Object target)` Inject dependencies on object.
`void`	`process()` Process all non-passive systems.
`void`	`setDelta(float delta)` You must specify the delta for the game here.
`<T extends Manager> T`	`setManager(T manager)` Add a manager into this world.
`<T extends EntitySystem> T`	`setSystem(T system)` Adds a system to this world that will be processed by `process()`.
`<T extends EntitySystem> T`	`setSystem(T system, boolean passive)` Will add a system to this world.

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

- Field Detail
  - delta
```
public float delta
```
    The time passed since the last update.
- Constructor Detail
  - World
```
public World()
```
    Creates a new world.
    An EntityManager and ComponentManager are created and added upon creation.
  - World
```
@Deprecated
public World(int expectedEntityCount)
```
    Deprecated. World(WorldConfiguration) provides more fine-grained control.
  - World
```
public World(WorldConfiguration configuration)
```
    Creates a new world.
    An EntityManager and ComponentManager are created and added upon creation.
    
    Parameters:
    expectedEntityCount - To avoid resizing entity containers needlessly.
- Method Detail
  - initialize
```
public void initialize()
```
    Makes sure all managers systems are initialized in the order they were added.
  - inject
```
public void inject(Object target)
```
    Inject dependencies on object. Immediately perform dependency injection on the target. Wire annotation is required on the target or fields. If you want to specify nonstandard dependencies to inject, use WorldConfiguration.register(String, Object) instead.
    
    Parameters:
    target - Object to inject into.
    See Also:
    for more details about dependency injection.
  - dispose
```
public void dispose()
```
    Disposes all managers and systems. Only necessary if either need to free managed resources upon bringing the world to an end.
    
    Throws:
    
    ArtemisMultiException - if any managers or systems throws an exception.
  - getEntityManager
```
public EntityManager getEntityManager()
```
    Returns a manager that takes care of all the entities in the world.
    
    Returns:
    entity manager
  - getComponentManager
```
public ComponentManager getComponentManager()
```
    Returns a manager that takes care of all the components in the world.
    
    Returns:
    component manager
  - setManager
```
public final <T extends Manager> T setManager(T manager)
```
    Add a manager into this world.
    It can be retrieved later. World will notify this manager of changes to entity.
    
    Type Parameters:
    T - class type of the manager
    Parameters:
    manager - manager to be added
    
    Returns:
    the manager
  - getManager
```
public <T extends Manager> T getManager(Class<T> managerType)
```
    Returns a manager of the specified type.
    
    Type Parameters:
    T - class type of the manager
    Parameters:
    managerType - class type of the manager
    
    Returns:
    the manager
  - getManagers
```
public ImmutableBag<Manager> getManagers()
```
    Returns:
    all managers in this world
  - deleteManager
```
@Deprecated
public void deleteManager(Manager manager)
```
    Deprecated. A world should be static once initialized
    
    Deletes the manager from this world.
    
    Parameters:
    manager - manager to delete
  - getDelta
```
public float getDelta()
```
    Time since last game loop.
    
    Returns:
    delta time since last game loop
  - setDelta
```
public void setDelta(float delta)
```
    You must specify the delta for the game here.
    
    Parameters:
    delta - time since last game loop
  - addEntity
```
@Deprecated
public void addEntity(Entity e)
```
    Deprecated. internally managed by artemis
    
    Adds a entity to this world.
    
    Parameters:
    e - the entity to add
  - changedEntity
```
@Deprecated
public void changedEntity(Entity e)
```
    Deprecated. does nothing, internally tracked by artemis now.
  - deleteEntity
```
@Deprecated
public void deleteEntity(Entity e)
```
    Deprecated. Better invoke Entity.deleteFromWorld() or EntityEdit.deleteEntity()
    
    Delete the entity from the world.
    
    Parameters:
    e - the entity to delete
  - enable
```
@Deprecated
public void enable(Entity e)
```
    Deprecated. create your own components to track state.
    
    (Re)enable the entity in the world, after it having being disabled.
    Won't do anything unless it was already disabled.
    
    Parameters:
    e - the entity to enable
  - disable
```
@Deprecated
public void disable(Entity e)
```
    Deprecated. create your own components to track state.
    
    Disable the entity from being processed.
    Won't delete it, it will continue to exist but won't get processed.
    
    Parameters:
    e - the entity to disable
  - createEntity
```
public Entity createEntity()
```
    Create and return a new or reused entity instance. Entity is automatically added to the world.
    
    Returns:
    entity
  - createEntity
```
public Entity createEntity(ArchetypeBuilder.Archetype archetype)
```
    Create and return an EntityEdit wrapping a new or reused entity instance. Entity is automatically added to the world.
    
    Returns:
    entity
  - createEntity
```
public Entity createEntity(UUID uuid)
```
    Create and return a new or reused entity instance.
    The uuid parameter is ignored if UuidEntityManager hasn't been added to the world.
    
    Parameters:
    uuid - the UUID to give to the entity
    
    Returns:
    entity
  - getEntity
```
public Entity getEntity(int entityId)
```
    Get a entity having the specified id.
    
    Parameters:
    entityId - the entities id
    
    Returns:
    the specific entity
  - getSystems
```
public ImmutableBag<EntitySystem> getSystems()
```
    Gives you all the systems in this world for possible iteration.
    
    Returns:
    all entity systems in world
  - setSystem
```
public <T extends EntitySystem> T setSystem(T system)
```
    Adds a system to this world that will be processed by process().
    
    Type Parameters:
    T - the system class type
    Parameters:
    system - the system to add
    
    Returns:
    the added system
  - setSystem
```
public <T extends EntitySystem> T setSystem(T system,
                                   boolean passive)
```
    Will add a system to this world.
    
    Type Parameters:
    T - the system class type
    Parameters:
    system - the system to add
    passive - whether or not this system will be processed by process()
    
    Returns:
    the added system
  - deleteSystem
```
@Deprecated
public void deleteSystem(EntitySystem system)
```
    Deprecated. A world should be static once initialized
    
    Remove the specified system from the world.
    
    Parameters:
    system - the system to be deleted from world
  - getSystem
```
public <T extends EntitySystem> T getSystem(Class<T> type)
```
    Retrieve a system for specified system type.
    
    Type Parameters:
    T - the class type of system
    Parameters:
    type - type of system
    
    Returns:
    instance of the system in this world
  - process
```
public void process()
```
    Process all non-passive systems.
  - getMapper
```
public <T extends Component> ComponentMapper<T> getMapper(Class<T> type)
```
    Retrieves a ComponentMapper instance for fast retrieval of components from entities.
    
    Type Parameters:
    T - class type of the component
    Parameters:
    type - type of component to get mapper for
    
    Returns:
    mapper for specified component type

Class World

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

delta

Constructor Detail

World

World

World

Method Detail

initialize

inject

dispose

getEntityManager

getComponentManager

setManager

getManager

getManagers

deleteManager

getDelta

setDelta

addEntity

changedEntity

deleteEntity

enable

disable

createEntity

createEntity

createEntity

getEntity

getSystems

setSystem

setSystem

deleteSystem

getSystem

process

getMapper