Apecs.Stores

Documentation

data Map c

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

Instances

MonadIO m => ExplMembers m (Map c)

Defined in Apecs.Stores

Methods

explMembers :: Map c -> m (Vector Int)

MonadIO m => ExplDestroy m (Map c)

Defined in Apecs.Stores

Methods

explDestroy :: Map c -> Int -> m ()

MonadIO m => ExplSet m (Map c)

Defined in Apecs.Stores

Methods

explSet :: Map c -> Int -> Elem (Map c) -> m ()

(MonadIO m, Typeable c) => ExplGet m (Map c)

Defined in Apecs.Stores

Methods

explGet :: Map c -> Int -> m (Elem (Map c))

explExists :: Map c -> Int -> m Bool

MonadIO m => ExplInit m (Map c)

Defined in Apecs.Stores

Methods

explInit :: m (Map c)

Cachable (Map s)

Defined in Apecs.Stores

type Elem (Map c)

Defined in Apecs.Stores

type Elem (Map c) = c

data Cache (n :: Nat) s

A cache around another store. Caches store their members in a fixed-size vector, so read/write operations become O(1). Caches can provide huge performance boosts, especially when working with 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 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 (-2) internally to represent missing entities. If you manually manipulate Entity values, be careful that you do not use (-2)

The actual cache is not necessarily the given argument, but the next biggest power of two. This is allows most operations to be expressed as bit masks, for a large potential performance boost.

Instances

(MonadIO m, ExplMembers m s) => ExplMembers m (Cache n s)

Defined in Apecs.Stores

Methods

explMembers :: Cache n s -> m (Vector Int)

(MonadIO m, ExplDestroy m s) => ExplDestroy m (Cache n s)

Defined in Apecs.Stores

Methods

explDestroy :: Cache n s -> Int -> m ()

(MonadIO m, ExplSet m s) => ExplSet m (Cache n s)

Defined in Apecs.Stores

Methods

explSet :: Cache n s -> Int -> Elem (Cache n s) -> m ()

(MonadIO m, ExplGet m s) => ExplGet m (Cache n s)

Defined in Apecs.Stores

Methods

explGet :: Cache n s -> Int -> m (Elem (Cache n s))

explExists :: Cache n s -> Int -> m Bool

(MonadIO m, ExplInit m s, KnownNat n, Cachable s) => ExplInit m (Cache n s)

Defined in Apecs.Stores

Methods

explInit :: m (Cache n s)

(KnownNat n, Cachable s) => Cachable (Cache n s)

Defined in Apecs.Stores

type Elem (Cache n s)

Defined in Apecs.Stores

type Elem (Cache n s) = Elem s

data Unique c

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.

Instances

MonadIO m => ExplMembers m (Unique c)

Defined in Apecs.Stores

Methods

explMembers :: Unique c -> m (Vector Int)

MonadIO m => ExplDestroy m (Unique c)

Defined in Apecs.Stores

Methods

explDestroy :: Unique c -> Int -> m ()

MonadIO m => ExplSet m (Unique c)

Defined in Apecs.Stores

Methods

explSet :: Unique c -> Int -> Elem (Unique c) -> m ()

(MonadIO m, Typeable c) => ExplGet m (Unique c)

Defined in Apecs.Stores

Methods

explGet :: Unique c -> Int -> m (Elem (Unique c))

explExists :: Unique c -> Int -> m Bool

MonadIO m => ExplInit m (Unique c)

Defined in Apecs.Stores

Methods

explInit :: m (Unique c)

type Elem (Unique c)

Defined in Apecs.Stores

type Elem (Unique c) = c

data Global c

A Global contains exactly one component. The initial value is mempty from the component's Monoid instance. Querying a Global at any Entity yields this one component, effectively sharing the component between all entities.

A Global component can be read with get 0 or get 1 or even get undefined. The convenience entity global is defined as -1, and can be used to make operations on a global more explicit, i.e. 'Time t <- get global'.

You also can read and write Globals during a cmap over other components.

Instances

MonadIO m => ExplSet m (Global c)

Defined in Apecs.Stores

Methods

explSet :: Global c -> Int -> Elem (Global c) -> m ()

MonadIO m => ExplGet m (Global c)

Defined in Apecs.Stores

Methods

explGet :: Global c -> Int -> m (Elem (Global c))

explExists :: Global c -> Int -> m Bool

(Monoid c, MonadIO m) => ExplInit m (Global c)

Defined in Apecs.Stores

Methods

explInit :: m (Global c)

type Elem (Global c)

Defined in Apecs.Stores

type Elem (Global c) = c

class Cachable s

Class of stores that behave like a regular map, and can therefore safely be cached. This prevents stores like Unique and Global, which do not behave like simple maps, from being cached.

Instances

Cachable (Map s)

Defined in Apecs.Stores

(KnownNat n, Cachable s) => Cachable (Cache n s)

Defined in Apecs.Stores

data ReadOnly s

Wrapper that makes a store read-only by hiding its ExplSet and ExplDestroy instances. This is primarily used to protect the EntityCounter from accidental overwrites. Use setReadOnly and destroyReadOnly to override.

Instances

ExplMembers m s => ExplMembers m (ReadOnly s)

Defined in Apecs.Stores

Methods

explMembers :: ReadOnly s -> m (Vector Int)

ExplGet m s => ExplGet m (ReadOnly s)

Defined in Apecs.Stores

Methods

explGet :: ReadOnly s -> Int -> m (Elem (ReadOnly s))

explExists :: ReadOnly s -> Int -> m Bool

(Functor m, ExplInit m s) => ExplInit m (ReadOnly s)

Defined in Apecs.Stores

Methods

explInit :: m (ReadOnly s)

type Elem (ReadOnly s)

Defined in Apecs.Stores

type Elem (ReadOnly s) = Elem s

setReadOnly :: forall w m s c. (Has w m c, Storage c ~ ReadOnly s, Elem s ~ c, ExplSet m s) => Entity -> c -> SystemT w m ()

destroyReadOnly :: forall w m s c. (Has w m c, Storage c ~ ReadOnly s, Elem s ~ c, ExplDestroy m s) => Entity -> Proxy c -> SystemT w m ()