Apecs

This module forms the apecs Prelude. It selectively re-exports the user-facing functions from the submodules.

Documentation

module Data.Proxy

Core types

newtype System w a

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

Constructors

System

Fields

• unSystem :: ReaderT w IO a

Instances

Monad (System w)

Methods

(>>=) :: System w a -> (a -> System w b) -> System w b

(>>) :: System w a -> System w b -> System w b

return :: a -> System w a

fail :: String -> System w a

Functor (System w)

Methods

fmap :: (a -> b) -> System w a -> System w b

(<$) :: a -> System w b -> System w a

Applicative (System w)

Methods

pure :: a -> System w a

(<*>) :: System w (a -> b) -> System w a -> System w b

liftA2 :: (a -> b -> c) -> System w a -> System w b -> System w c

(*>) :: System w a -> System w b -> System w b

(<*) :: System w a -> System w b -> System w a

MonadIO (System w)

Methods

liftIO :: IO a -> System w a

class Elem (Storage c) ~ c => Component c

A component is defined by the type of its storage The storage in turn supplies runtime types for the component. For the component to be valid, its Storage must be an instance of Store.

Associated Types

type Storage c

Instances

Component Entity

Associated Types

type Storage Entity :: *

Component EntityCounter

Associated Types

type Storage EntityCounter :: *

Component c => Component (Maybe c)

Associated Types

type Storage (Maybe c) :: *

Component c => Component (Identity c)

Associated Types

type Storage (Identity c) :: *

Component c => Component (Filter c)

Associated Types

type Storage (Filter c) :: *

Component c => Component (Not c)

Associated Types

type Storage (Not c) :: *

(Component t_0, Component t_1) => Component (t_0, t_1)

Associated Types

type Storage (t_0, t_1) :: *

(Component t_0, Component t_1, Component t_2) => Component (t_0, t_1, t_2)

Associated Types

type Storage (t_0, t_1, t_2) :: *

(Component t_0, Component t_1, Component t_2, Component t_3) => Component (t_0, t_1, t_2, t_3)

Associated Types

type Storage (t_0, t_1, t_2, t_3) :: *

(Component t_0, Component t_1, Component t_2, Component t_3, Component t_4) => Component (t_0, t_1, t_2, t_3, t_4)

Associated Types

type Storage (t_0, t_1, t_2, t_3, t_4) :: *

(Component t_0, Component t_1, Component t_2, Component t_3, Component t_4, Component t_5) => Component (t_0, t_1, t_2, t_3, t_4, t_5)

Associated Types

type Storage (t_0, t_1, t_2, t_3, t_4, t_5) :: *

(Component t_0, Component t_1, Component t_2, Component t_3, Component t_4, Component t_5, Component t_6) => Component (t_0, t_1, t_2, t_3, t_4, t_5, t_6)

Associated Types

type Storage (t_0, t_1, t_2, t_3, t_4, t_5, t_6) :: *

(Component t_0, Component t_1, Component t_2, Component t_3, Component t_4, Component t_5, Component t_6, Component t_7) => Component (t_0, t_1, t_2, t_3, t_4, t_5, t_6, t_7)

Associated Types

type Storage (t_0, t_1, t_2, t_3, t_4, t_5, t_6, t_7) :: *

newtype Entity

An Entity is just an integer, used to index into a component store.

Constructors

Entity

Fields

• unEntity :: Int

Instances

Eq Entity

Methods

(==) :: Entity -> Entity -> Bool

(/=) :: Entity -> Entity -> Bool

Num Entity

Methods

(+) :: Entity -> Entity -> Entity

(-) :: Entity -> Entity -> Entity

(*) :: Entity -> Entity -> Entity

negate :: Entity -> Entity

abs :: Entity -> Entity

signum :: Entity -> Entity

fromInteger :: Integer -> Entity

Ord Entity

Methods

compare :: Entity -> Entity -> Ordering

(<) :: Entity -> Entity -> Bool

(<=) :: Entity -> Entity -> Bool

(>) :: Entity -> Entity -> Bool

(>=) :: Entity -> Entity -> Bool

max :: Entity -> Entity -> Entity

min :: Entity -> Entity -> Entity

Show Entity

Methods

showsPrec :: Int -> Entity -> ShowS

show :: Entity -> String

showList :: [Entity] -> ShowS

Component Entity

Associated Types

type Storage Entity :: *

Has w Entity

Methods

getStore :: System w (Storage Entity)

type Storage Entity

type Storage Entity = EntityStore

class Component c => Has w c where

A world Has a component if it can produce its Storage

Minimal complete definition

getStore

Methods

getStore :: System w (Storage c)

Instances

Has w Entity

Methods

getStore :: System w (Storage Entity)

Has w c => Has w (Identity c)

Methods

getStore :: System w (Storage (Identity c))

Has w c => Has w (Filter c)

Methods

getStore :: System w (Storage (Filter c))

Has w c => Has w (Maybe c)

Methods

getStore :: System w (Storage (Maybe c))

Has w c => Has w (Not c)

Methods

getStore :: System w (Storage (Not c))

(Has w t_0, Has w t_1) => Has w (t_0, t_1)

Methods

getStore :: System w (Storage (t_0, t_1))

(Has w t_0, Has w t_1, Has w t_2) => Has w (t_0, t_1, t_2)

Methods

getStore :: System w (Storage (t_0, t_1, t_2))

(Has w t_0, Has w t_1, Has w t_2, Has w t_3) => Has w (t_0, t_1, t_2, t_3)

Methods

getStore :: System w (Storage (t_0, t_1, t_2, t_3))

(Has w t_0, Has w t_1, Has w t_2, Has w t_3, Has w t_4) => Has w (t_0, t_1, t_2, t_3, t_4)

Methods

getStore :: System w (Storage (t_0, t_1, t_2, t_3, t_4))

(Has w t_0, Has w t_1, Has w t_2, Has w t_3, Has w t_4, Has w t_5) => Has w (t_0, t_1, t_2, t_3, t_4, t_5)

Methods

getStore :: System w (Storage (t_0, t_1, t_2, t_3, t_4, t_5))

(Has w t_0, Has w t_1, Has w t_2, Has w t_3, Has w t_4, Has w t_5, Has w t_6) => Has w (t_0, t_1, t_2, t_3, t_4, t_5, t_6)

Methods

getStore :: System w (Storage (t_0, t_1, t_2, t_3, t_4, t_5, t_6))

(Has w t_0, Has w t_1, Has w t_2, Has w t_3, Has w t_4, Has w t_5, Has w t_6, Has w t_7) => Has w (t_0, t_1, t_2, t_3, t_4, t_5, t_6, t_7)

Methods

getStore :: System w (Storage (t_0, t_1, t_2, t_3, t_4, t_5, t_6, t_7))

data Not a

Psuedocomponent indicating the absence of a.

Constructors

Not

Instances

Has w c => Has w (Not c)

Methods

getStore :: System w (Storage (Not c))

Component c => Component (Not c)

Associated Types

type Storage (Not c) :: *

type Storage (Not c)

type Storage (Not c) = NotStore (Storage c)

Stores

data Map c

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

Instances

ExplMembers (Map c)

Methods

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

ExplDestroy (Map c)

Methods

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

ExplSet (Map c)

Methods

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

ExplGet (Map c)

Methods

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

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

ExplInit (Map c)

Methods

explInit :: IO (Map c)

Cachable (Map s)

type Elem (Map c)

type Elem (Map c) = c

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

ExplMembers (Unique c)

Methods

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

ExplDestroy (Unique c)

Methods

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

ExplSet (Unique c)

Methods

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

ExplGet (Unique c)

Methods

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

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

ExplInit (Unique c)

Methods

explInit :: IO (Unique c)

type Elem (Unique c)

type Elem (Unique c) = c

data Global c

A Global contains exactly one component. Initialized with mempty The store will return true for every existence check, but only ever gives (-1) as its inhabitant. The entity argument is ignored when setting/getting a global.

Instances

ExplSet (Global c)

Methods

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

ExplGet (Global c)

Methods

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

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

Monoid c => ExplInit (Global c)

Methods

explInit :: IO (Global c)

type Elem (Global c)

type Elem (Global c) = c

data Cache (n :: Nat) s

A cache around another store. Note that iterating over a cache is linear in cache size, so sparsely populated caches might actually decrease performance.

Instances

ExplMembers s => ExplMembers (Cache n s)

Methods

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

ExplDestroy s => ExplDestroy (Cache n s)

Methods

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

ExplSet s => ExplSet (Cache n s)

Methods

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

ExplGet s => ExplGet (Cache n s)

Methods

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

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

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

Methods

explInit :: IO (Cache n s)

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

type Elem (Cache n s)

type Elem (Cache n s) = Elem s

explInit :: ExplInit s => IO s

Initialize the store with its initialization arguments.

Systems

get :: forall w c. Get w c => Entity -> System w c

set :: forall w c. Set w c => Entity -> c -> System w ()

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'

getAll :: forall w c. (Get w c, Members w c) => System w [c]

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

cmap :: forall w cx cy. (Get w cx, Members w cx, Set w cy) => (cx -> cy) -> System w ()

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

cmapM :: forall w cx cy. (Get w cx, Set w cy, Members w cx) => (cx -> System w cy) -> System w ()

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

cmapM_ :: forall w c a. (Get w c, Members w c) => (c -> System w a) -> System w ()

Monadically iterates over all entites with a cx

modify :: forall w c. (Get w c, Set w c) => Entity -> (c -> c) -> System w ()

Applies a function, if possible.

destroy :: forall w c. Destroy w c => Entity -> Proxy c -> System w ()

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.

exists :: forall w c. Get w c => Entity -> Proxy c -> System w Bool

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.

Other

runSystem :: System w a -> w -> IO a

Run a system with a game world

runWith :: w -> System w a -> IO a

Run a system with a game world

runGC :: System w ()

Explicitly invoke the garbage collector

data EntityCounter

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

Instances

Eq EntityCounter

Methods

(==) :: EntityCounter -> EntityCounter -> Bool

(/=) :: EntityCounter -> EntityCounter -> Bool

Show EntityCounter

Methods

showsPrec :: Int -> EntityCounter -> ShowS

show :: EntityCounter -> String

showList :: [EntityCounter] -> ShowS

Monoid EntityCounter

Methods

mempty :: EntityCounter

mappend :: EntityCounter -> EntityCounter -> EntityCounter

mconcat :: [EntityCounter] -> EntityCounter

Component EntityCounter

Associated Types

type Storage EntityCounter :: *

type Storage EntityCounter

type Storage EntityCounter = Global EntityCounter

newEntity :: (Set w c, Get w EntityCounter, Set w EntityCounter) => c -> System w Entity

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

global :: Entity

Convenience entity (-1), used in places where the exact entity value does not matter, i.e. a global store.

makeWorld :: String -> [Name] -> Q [Dec]

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

|

makeWorldAndComponents :: String -> [Name] -> Q [Dec]

Same as makeWorld, but also makes a component instance:

Re-exports

asks

Arguments

:: MonadReader r m

=> (r -> a)

The selector function to apply to the environment.

-> m a

Retrieves a function of the current environment.

ask :: MonadReader r m => m r

Retrieves the monad environment.

liftIO :: MonadIO m => forall a. IO a -> m a

Lift a computation from the IO monad.

lift :: MonadTrans t => forall (m :: * -> *) a. Monad m => m a -> t m a

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