Apecs

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

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

(*>) :: 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 (Stores (Storage c) ~ c, Store (Storage 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 in instance of Store.

Associated Types

type Storage c

Instances

Component EntityCounter

Associated Types

type Storage EntityCounter :: *

(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) :: *

newtype Entity c

An Entity is really just an Int. The type variable is used to keep track of reads and writes, but can be freely cast.

Constructors

Entity Int

Instances

Eq (Entity c)

Methods

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

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

Ord (Entity c)

Methods

compare :: Entity c -> Entity c -> Ordering

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

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

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

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

max :: Entity c -> Entity c -> Entity c

min :: Entity c -> Entity c -> Entity c

Show (Entity c)

Methods

showsPrec :: Int -> Entity c -> ShowS

show :: Entity c -> String

showList :: [Entity c] -> ShowS

Cast (Entity a) (Entity b)

Methods

cast :: Entity a -> Entity b

data Slice c

A slice is a list of entities, represented by a Data.Unbox.Vector of Ints.

Instances

Show (Slice c)

Methods

showsPrec :: Int -> Slice c -> ShowS

show :: Slice c -> String

showList :: [Slice c] -> ShowS

Monoid (Slice c)

Methods

mempty :: Slice c

mappend :: Slice c -> Slice c -> Slice c

mconcat :: [Slice c] -> Slice c

Cast (Slice a) (Slice b)

Methods

cast :: Slice a -> Slice b

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 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))

newtype Safe c

Represents a safe access to c. A safe access is either a read that might fail, or a write that might delete.

Constructors

Safe

Fields

• getSafe :: SafeRW (Storage c)

cast :: Cast a b => a -> b

data Map c

A map from Data.Intmap.Strict. O(log(n)) for most operations. Yields safe runtime representations of type Maybe c.

Instances

Store (Map c)

Associated Types

type Stores (Map c) :: *

type SafeRW (Map c) :: *

Methods

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

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

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

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

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

explGetUnsafe :: Map c -> Int -> IO (Stores (Map c))

explSetMaybe :: Map c -> Int -> SafeRW (Map c) -> IO ()

initStore :: IO (Map c)

explReset :: Map c -> IO ()

explImapM_ :: MonadIO m => Map c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Map c -> (Int -> m a) -> m [a]

explModify :: Map c -> Int -> (Stores (Map c) -> Stores (Map c)) -> IO ()

explCmap :: Map c -> (Stores (Map c) -> Stores (Map c)) -> IO ()

explCmapM_ :: MonadIO m => Map c -> (Stores (Map c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Map c -> ((Int, Stores (Map c)) -> m a) -> m ()

explCmapM :: MonadIO m => Map c -> (Stores (Map c) -> m a) -> m [a]

explCimapM :: MonadIO m => Map c -> ((Int, Stores (Map c)) -> m a) -> m [a]

Cachable (Map s)

type Stores (Map c)

type Stores (Map c) = c

type SafeRW (Map c)

type SafeRW (Map c) = Maybe c

data Set c

A store that keeps membership, but holds no values. Produces flag runtime values.

Instances

Flag c => Store (Set c)

Associated Types

type Stores (Set c) :: *

type SafeRW (Set c) :: *

Methods

explGet :: Set c -> Int -> IO (SafeRW (Set c))

explSet :: Set c -> Int -> Stores (Set c) -> IO ()

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

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

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

explGetUnsafe :: Set c -> Int -> IO (Stores (Set c))

explSetMaybe :: Set c -> Int -> SafeRW (Set c) -> IO ()

initStore :: IO (Set c)

explReset :: Set c -> IO ()

explImapM_ :: MonadIO m => Set c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Set c -> (Int -> m a) -> m [a]

explModify :: Set c -> Int -> (Stores (Set c) -> Stores (Set c)) -> IO ()

explCmap :: Set c -> (Stores (Set c) -> Stores (Set c)) -> IO ()

explCmapM_ :: MonadIO m => Set c -> (Stores (Set c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Set c -> ((Int, Stores (Set c)) -> m a) -> m ()

explCmapM :: MonadIO m => Set c -> (Stores (Set c) -> m a) -> m [a]

explCimapM :: MonadIO m => Set c -> ((Int, Stores (Set c)) -> m a) -> m [a]

type Stores (Set c)

type Stores (Set c) = c

type SafeRW (Set c)

type SafeRW (Set c) = Bool

data Unique c

A Unique contains exactly one component belonging to some entity. Writing to it overwrites both the previous component and its owner.

Instances

Store (Unique c)

Associated Types

type Stores (Unique c) :: *

type SafeRW (Unique c) :: *

Methods

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

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

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

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

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

explGetUnsafe :: Unique c -> Int -> IO (Stores (Unique c))

explSetMaybe :: Unique c -> Int -> SafeRW (Unique c) -> IO ()

initStore :: IO (Unique c)

explReset :: Unique c -> IO ()

explImapM_ :: MonadIO m => Unique c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Unique c -> (Int -> m a) -> m [a]

explModify :: Unique c -> Int -> (Stores (Unique c) -> Stores (Unique c)) -> IO ()

explCmap :: Unique c -> (Stores (Unique c) -> Stores (Unique c)) -> IO ()

explCmapM_ :: MonadIO m => Unique c -> (Stores (Unique c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Unique c -> ((Int, Stores (Unique c)) -> m a) -> m ()

explCmapM :: MonadIO m => Unique c -> (Stores (Unique c) -> m a) -> m [a]

explCimapM :: MonadIO m => Unique c -> ((Int, Stores (Unique c)) -> m a) -> m [a]

type Stores (Unique c)

type Stores (Unique c) = c

type SafeRW (Unique c)

type SafeRW (Unique c) = Maybe c

data Global c

Global value. Initialized with mempty

Instances

Monoid c => GlobalStore (Global c)

Monoid c => Store (Global c)

Associated Types

type Stores (Global c) :: *

type SafeRW (Global c) :: *

Methods

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

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

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

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

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

explGetUnsafe :: Global c -> Int -> IO (Stores (Global c))

explSetMaybe :: Global c -> Int -> SafeRW (Global c) -> IO ()

initStore :: IO (Global c)

explReset :: Global c -> IO ()

explImapM_ :: MonadIO m => Global c -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Global c -> (Int -> m a) -> m [a]

explModify :: Global c -> Int -> (Stores (Global c) -> Stores (Global c)) -> IO ()

explCmap :: Global c -> (Stores (Global c) -> Stores (Global c)) -> IO ()

explCmapM_ :: MonadIO m => Global c -> (Stores (Global c) -> m a) -> m ()

explCimapM_ :: MonadIO m => Global c -> ((Int, Stores (Global c)) -> m a) -> m ()

explCmapM :: MonadIO m => Global c -> (Stores (Global c) -> m a) -> m [a]

explCimapM :: MonadIO m => Global c -> ((Int, Stores (Global c)) -> m a) -> m [a]

type Stores (Global c)

type Stores (Global c) = c

type SafeRW (Global c)

type SafeRW (Global c) = c

class Flag c where

Class for flags, used by Set to yield runtime representations.

Minimal complete definition

flag

Methods

flag :: c

Store wrapper functions

initStore :: Store s => IO s

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

Destroys the component c for the given entity

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

Returns whether the given entity has component c For composite components, this indicates whether the component has all its constituents

owners :: forall w c. Has w c => System w (Slice c)

A slice containing all entities with component c

resetStore :: forall w c p. Has w c => p c -> System w ()

Removes all components. Equivalent to manually iterating and deleting, but usually optimized.

get :: forall w c. Has w c => Entity c -> System w (Safe c)

Gets the component for a given entity. This is a safe access, because the entity might not have the requested components.

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

Writes a component to a given entity. Will overwrite existing components.

set' :: forall w c. Has w c => Entity c -> Safe c -> System w ()

Same as set, but uses Safe to possibly delete a component

modify :: forall w c. Has w c => Entity c -> (c -> c) -> System w ()

Applies a function if possible. Equivalent to reading, mapping, and writing, but stores can provide optimized implementations.

cmap :: forall world c. Has world c => (c -> c) -> System world ()

Maps a pure function over all components

cmapM :: forall w c a. Has w c => (c -> System w a) -> System w [a]

mapM version of cmap. Can be used to get a list of entities

cmapM_ :: forall w c. Has w c => (c -> System w ()) -> System w ()

mapM_ version of cmap

cimapM :: forall w c a. Has w c => ((Entity c, c) -> System w a) -> System w [a]

indexed cmapM, also gives the current entity.

cimapM_ :: forall w c. Has w c => ((Entity c, c) -> System w ()) -> System w ()

indexed cmapM_, also gives the current entity.

rmap' :: forall world r w. (Has world w, Has world r, Store (Storage r), Store (Storage w)) => (r -> Safe w) -> System world ()

Maps a function over all entities with a r, and writes or deletes their w

rmap :: forall world r w. (Has world w, Has world r) => (r -> w) -> System world ()

Maps a function over all entities with a r, and writes their w

wmap :: forall world r w. (Has world w, Has world r, Store (Storage r), Store (Storage w)) => (Safe r -> w) -> System world ()

For all entities with a w, this map reads their r and writes their w

wmap' :: forall world r w. (Has world w, Has world r, Store (Storage r), Store (Storage w)) => (Safe r -> Safe w) -> System world ()

For all entities with a w, this map reads their r and writes or deletes their w

cmap' :: forall world c. Has world c => (c -> Safe c) -> System world ()

Maps a function that might delete its components

GlobalRW wrapper functions

readGlobal :: forall w c. (Has w c, GlobalStore (Storage c)) => System w c

Reads a global value

writeGlobal :: forall w c. (Has w c, GlobalStore (Storage c)) => c -> System w ()

Writes a global value

modifyGlobal :: forall w c. (Has w c, GlobalStore (Storage c)) => (c -> c) -> System w ()

Modifies a global value

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

Secretly just an int in a newtype

Instances

Eq EntityCounter

Methods

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

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

Num EntityCounter

Methods

(+) :: EntityCounter -> EntityCounter -> EntityCounter

(-) :: EntityCounter -> EntityCounter -> EntityCounter

(*) :: EntityCounter -> EntityCounter -> EntityCounter

negate :: EntityCounter -> EntityCounter

abs :: EntityCounter -> EntityCounter

signum :: EntityCounter -> EntityCounter

fromInteger :: Integer -> EntityCounter

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 :: (Store (Storage c), Has w c, Has w EntityCounter) => c -> System w (Entity c)

Writes the given components to a new entity, and yields that entity

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.