A System is a newtype around `ReaderT w IO a`, where w is the game world variable. Systems mainly serve to

• Lift side effects into the IO Monad.
• Allow type-based lookup of a component's store through getStore.

A component is defined by specifying how it is stored. The constraint ensures that stores and components are mapped one-to-one.

An Entity is just an integer, used to index into a component store. In general, use newEntity, cmap, and component tags instead of manipulating these directly.

For performance reasons, negative values like (-1) are reserved for stores to represent special values, so avoid using these.

Has w c means that world w can produce a Storage c.

Psuedocomponent indicating the absence of a. Mainly used as e.g. cmap $ (a, Not b) -> c to iterate over entities with an a but no b. Can also be used to delete components, like cmap $ a -> (Not :: Not a) to delete every a component.

A map based on Data.Intmap.Strict. O(log(n)) for most operations.

A Unique contains zero or one component. Writing to it overwrites both the previous component and its owner. Its main purpose is to be a Map optimized for when only ever one component inhabits it.

A Global contains exactly one component. The initial value is mempty from the component's Monoid instance. When operating on a global, any entity arguments are ignored. For example, we can get a global component with get 0 or get 1 or even get undefined.

A cache around another store. Caches store their members in a fixed-size vector, so operations run in O(1). Caches can provide huge performance boosts, especially for large numbers of components. The cache size is given as a type-level argument.

Note that iterating over a cache is linear in cache size, so sparsely populated caches might actually decrease performance. In general, the exact size of the cache does not matter as long as it reasonably approximates the number of components present.

The cache uses entity (-1) to internally represent missing entities, so be wary when manually manipulating entities.

Initialize a new empty store.

Writes a component to a given entity. Will overwrite existing components. The type was originally 'Entity c -> c -> System w ()', but is relaxed to 'Entity e' so you don't always have to write 'set . cast'

Get all components c. Call as [(c,Entity)] to also read the entity index.

Maps a function over all entities with a cx, and writes their cy.

Monadically iterates over all entites with a cx, and writes their cy.

Monadically iterates over all entites with a cx

Fold over the game world; for example, cfold max (minBound :: Foo) will find the maximum value of Foo. Strict in the accumulator.

Monadically fold over the game world. Strict in the accumulator.

Monadically fold over the game world. Strict in the accumulator.

Applies a function, if possible.

Destroys component c for the given entity. Note that c is a phantom argument, used only to convey the type of the entity to be destroyed.

Returns whether the given entity has component c Note that c is a phantom argument, used only to convey the type of the entity to be queried.

Run a system with a game world

Run a system with a game world

Explicitly invoke the garbage collector

Component used by newEntity to track the number of issued entities. Automatically added to any world created with makeWorld

Writes the given components to a new entity, and yields that entity. The return value is often ignored.

Convenience entity, for use in places where the entity value does not matter, i.e. a global store. Its value is -2, to avoid potential conflicts with caches, which reserve -1.

makeWorld "WorldName" [''Component1, ''Component2, ...]

turns into

data WorldName = WorldName Component1 Component2 ... EntityCounter
instance WorldName `Has` Component1 where ...
instance WorldName `Has` Component2 where ...
...
instance WorldName `Has` EntityCounter where ...

initWorldName :: IO WorldName
initWorldName = WorldName <$> initStore <*> initStore <*> ... <*> initStore

|

Same as makeWorld, but also makes a component instance:

Retrieves a function of the current environment.

Retrieves the monad environment.

Lift a computation from the IO monad.

Lift a computation from the argument monad to the constructed monad.