Apecs

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 Initializable (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 Initializable.

Associated Types

type Storage c = s | s -> c

Instances

Component EntityCounter

Associated Types

type Storage EntityCounter = (s :: *)

(Component a, Component b) => Component (a, b)

Associated Types

type Storage (a, b) = (s :: *)

(Component a, Component b, Component c) => Component (a, b, c)

Associated Types

type Storage (a, b, c) = (s :: *)

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 a, Has w b) => Has w (a, b)

Methods

getStore :: System w (Storage (a, b))

(Has w a, Has w b, Has w c) => Has w (a, b, c)

Methods

getStore :: System w (Storage (a, b, c))

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(n log(n)) for most operations. Yields safe runtime representations of type Maybe c.

Instances

Store (Map c)

Associated Types

type SafeRW (Map c) :: *

type Stores (Map c) :: *

Methods

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

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

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

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

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]

HasMembers (Map c)

Methods

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

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

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

explReset :: Map c -> IO ()

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

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

Initializable (Map c)

Associated Types

type InitArgs (Map c) :: *

Methods

initStoreWith :: InitArgs (Map c) -> IO (Map c)

Cachable (Map s)

type SafeRW (Map c)

type SafeRW (Map c) = Maybe c

type Stores (Map c)

type Stores (Map c) = c

type InitArgs (Map c)

type InitArgs (Map 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 SafeRW (Set c) :: *

type Stores (Set c) :: *

Methods

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

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

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

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

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]

HasMembers (Set c)

Methods

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

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

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

explReset :: Set c -> IO ()

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

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

Initializable (Set c)

Associated Types

type InitArgs (Set c) :: *

Methods

initStoreWith :: InitArgs (Set c) -> IO (Set c)

type SafeRW (Set c)

type SafeRW (Set c) = Bool

type Stores (Set c)

type Stores (Set c) = c

type InitArgs (Set c)

type InitArgs (Set c) = ()

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

type Stores (Unique c) :: *

Methods

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

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

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

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

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]

HasMembers (Unique c)

Methods

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

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

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

explReset :: Unique c -> IO ()

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

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

Initializable (Unique c)

Associated Types

type InitArgs (Unique c) :: *

Methods

initStoreWith :: InitArgs (Unique c) -> IO (Unique c)

type SafeRW (Unique c)

type SafeRW (Unique c) = Maybe c

type Stores (Unique c)

type Stores (Unique c) = c

type InitArgs (Unique c)

type InitArgs (Unique c) = ()

data Global c

Global value. Must be given an initial value upon construction.

Instances

Initializable (Global c)

Associated Types

type InitArgs (Global c) :: *

Methods

initStoreWith :: InitArgs (Global c) -> IO (Global c)

GlobalRW (Global c) c

Methods

explGlobalRead :: Global c -> IO c

explGlobalWrite :: Global c -> c -> IO ()

explGlobalModify :: Global c -> (c -> c) -> IO ()

type InitArgs (Global c)

type InitArgs (Global c) = c

Initializable

initStoreWith :: Initializable s => InitArgs s -> IO s

HasMembers wrapper functions

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

Destroys the component c for the given entity

exists :: forall w c. (Has w c, HasMembers (Storage 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, HasMembers (Storage c)) => System w (Slice c)

A slice containing all entities with component c

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

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

Store wrapper functions

get :: forall w c. (Store (Storage 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. (IsRuntime c, Has w c) => Entity e -> c -> System w ()

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

set' :: forall w c. (IsRuntime 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. (IsRuntime 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. (IsRuntime c, Has world c) => (c -> c) -> System world ()

Maps a pure function over all components

cmapM :: forall w c a. (Has w c, IsRuntime 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, IsRuntime c) => (c -> System w ()) -> System w ()

mapM_ version of cmap

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

indexed cmapM, also gives the current entity.

cimapM_ :: forall w c. (Has w c, IsRuntime 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 w), IsRuntime r) => (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, IsRuntime w, IsRuntime 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, IsRuntime w, IsRuntime r) => (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 w), IsRuntime r) => (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, IsRuntime c) => (c -> Safe c) -> System world ()

Maps a function that might delete its components

GlobalRW wrapper functions

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

Reads a global value

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

Writes a global value

modifyGlobal :: forall w c. (Has w c, GlobalRW (Storage c) 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

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.