Apecs.Types

Documentation

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

Fields

• unEntity :: 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

newtype Slice c

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

Constructors

Slice

Fields

• unSlice :: Vector Int

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

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

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

class Initializable s where

Common for every storage. Represents a container that can be initialized.

Minimal complete definition

initStoreWith

Associated Types

type InitArgs s

The initialization argument required by this store

Methods

initStoreWith :: InitArgs s -> IO s

Instances

(ToIndex (Stores s), Initializable s) => Initializable (IndexTable s)

Associated Types

type InitArgs (IndexTable s) :: *

Methods

initStoreWith :: InitArgs (IndexTable s) -> IO (IndexTable s)

Initializable (Global c)

Associated Types

type InitArgs (Global c) :: *

Methods

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

Initializable (Set c)

Associated Types

type InitArgs (Set c) :: *

Methods

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

Initializable (Map c)

Associated Types

type InitArgs (Map c) :: *

Methods

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

(Initializable a, Initializable b) => Initializable (a, b)

Associated Types

type InitArgs (a, b) :: *

Methods

initStoreWith :: InitArgs (a, b) -> IO (a, b)

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

Associated Types

type InitArgs (Cache n s) :: *

Methods

initStoreWith :: InitArgs (Cache n s) -> IO (Cache n s)

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

Associated Types

type InitArgs (a, b, c) :: *

Methods

initStoreWith :: InitArgs (a, b, c) -> IO (a, b, c)

class HasMembers s where

A store that is indexed by entities.

Minimal complete definition

explDestroy, explExists, explMembers

Methods

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

Destroys the component for the given index.

explExists :: s -> Int -> IO Bool

Returns whether there is a component for the given index

explMembers :: s -> IO (Vector Int)

Returns an unboxed vector of member indices

explReset :: s -> IO ()

Removes all components. Default implementation iterates over members and calls explDestroy.

explImapM_ :: MonadIO m => s -> (Int -> m a) -> m ()

Monadically iterates over member indices

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

Monadically iterates over member indices

Instances

((~) * (SafeRW s) (Maybe (Stores s)), ToIndex (Stores s), Store s) => HasMembers (IndexTable s)

Methods

explDestroy :: IndexTable s -> Int -> IO ()

explExists :: IndexTable s -> Int -> IO Bool

explMembers :: IndexTable s -> IO (Vector Int)

explReset :: IndexTable s -> IO ()

explImapM_ :: MonadIO m => IndexTable s -> (Int -> m a) -> m ()

explImapM :: MonadIO m => IndexTable s -> (Int -> 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]

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]

(HasMembers a, HasMembers b) => HasMembers (a, b)

Methods

explDestroy :: (a, b) -> Int -> IO ()

explExists :: (a, b) -> Int -> IO Bool

explMembers :: (a, b) -> IO (Vector Int)

explReset :: (a, b) -> IO ()

explImapM_ :: MonadIO m => (a, b) -> (Int -> m a) -> m ()

explImapM :: MonadIO m => (a, b) -> (Int -> m a) -> m [a]

HasMembers s => HasMembers (Cache n s)

Methods

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

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

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

explReset :: Cache n s -> IO ()

explImapM_ :: MonadIO m => Cache n s -> (Int -> m a) -> m ()

explImapM :: MonadIO m => Cache n s -> (Int -> m a) -> m [a]

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

Methods

explDestroy :: (a, b, c) -> Int -> IO ()

explExists :: (a, b, c) -> Int -> IO Bool

explMembers :: (a, b, c) -> IO (Vector Int)

explReset :: (a, b, c) -> IO ()

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

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

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)

class HasMembers s => Store s where

Class of storages that associates components with entities.

Minimal complete definition

explGetUnsafe, explGet, explSet, explSetMaybe

Associated Types

type SafeRW s

Return type for safe reads writes to the store

type Stores s

The type of components stored by this Store

Methods

explGetUnsafe :: s -> Int -> IO (Stores s)

Unsafe index to the store. Undefined if the component does not exist

explGet :: s -> Int -> IO (SafeRW s)

Retrieves a component from the store

explSet :: s -> Int -> Stores s -> IO ()

Writes a component

explSetMaybe :: s -> Int -> SafeRW s -> IO ()

Either writes or deletes a component

explModify :: s -> Int -> (Stores s -> Stores s) -> IO ()

Modifies an element in the store.

explCmap :: s -> (Stores s -> Stores s) -> IO ()

Maps over all elements of this store. The default implementation can be replaced by an optimized one

explCmapM_ :: MonadIO m => s -> (Stores s -> m a) -> m ()

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

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

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

Instances

((~) * (SafeRW s) (Maybe (Stores s)), ToIndex (Stores s), Store s) => Store (IndexTable s)

Associated Types

type SafeRW (IndexTable s) :: *

type Stores (IndexTable s) :: *

Methods

explGetUnsafe :: IndexTable s -> Int -> IO (Stores (IndexTable s))

explGet :: IndexTable s -> Int -> IO (SafeRW (IndexTable s))

explSet :: IndexTable s -> Int -> Stores (IndexTable s) -> IO ()

explSetMaybe :: IndexTable s -> Int -> SafeRW (IndexTable s) -> IO ()

explModify :: IndexTable s -> Int -> (Stores (IndexTable s) -> Stores (IndexTable s)) -> IO ()

explCmap :: IndexTable s -> (Stores (IndexTable s) -> Stores (IndexTable s)) -> IO ()

explCmapM_ :: MonadIO m => IndexTable s -> (Stores (IndexTable s) -> m a) -> m ()

explCimapM_ :: MonadIO m => IndexTable s -> ((Int, Stores (IndexTable s)) -> m a) -> m ()

explCmapM :: MonadIO m => IndexTable s -> (Stores (IndexTable s) -> m a) -> m [a]

explCimapM :: MonadIO m => IndexTable s -> ((Int, Stores (IndexTable s)) -> m a) -> m [a]

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]

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]

(Store a, Store b) => Store (a, b)

Associated Types

type SafeRW (a, b) :: *

type Stores (a, b) :: *

Methods

explGetUnsafe :: (a, b) -> Int -> IO (Stores (a, b))

explGet :: (a, b) -> Int -> IO (SafeRW (a, b))

explSet :: (a, b) -> Int -> Stores (a, b) -> IO ()

explSetMaybe :: (a, b) -> Int -> SafeRW (a, b) -> IO ()

explModify :: (a, b) -> Int -> (Stores (a, b) -> Stores (a, b)) -> IO ()

explCmap :: (a, b) -> (Stores (a, b) -> Stores (a, b)) -> IO ()

explCmapM_ :: MonadIO m => (a, b) -> (Stores (a, b) -> m a) -> m ()

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

explCmapM :: MonadIO m => (a, b) -> (Stores (a, b) -> m a) -> m [a]

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

((~) * (SafeRW s) (Maybe (Stores s)), Store s) => Store (Cache n s)

Associated Types

type SafeRW (Cache n s) :: *

type Stores (Cache n s) :: *

Methods

explGetUnsafe :: Cache n s -> Int -> IO (Stores (Cache n s))

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

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

explSetMaybe :: Cache n s -> Int -> SafeRW (Cache n s) -> IO ()

explModify :: Cache n s -> Int -> (Stores (Cache n s) -> Stores (Cache n s)) -> IO ()

explCmap :: Cache n s -> (Stores (Cache n s) -> Stores (Cache n s)) -> IO ()

explCmapM_ :: MonadIO m => Cache n s -> (Stores (Cache n s) -> m a) -> m ()

explCimapM_ :: MonadIO m => Cache n s -> ((Int, Stores (Cache n s)) -> m a) -> m ()

explCmapM :: MonadIO m => Cache n s -> (Stores (Cache n s) -> m a) -> m [a]

explCimapM :: MonadIO m => Cache n s -> ((Int, Stores (Cache n s)) -> m a) -> m [a]

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

Associated Types

type SafeRW (a, b, c) :: *

type Stores (a, b, c) :: *

Methods

explGetUnsafe :: (a, b, c) -> Int -> IO (Stores (a, b, c))

explGet :: (a, b, c) -> Int -> IO (SafeRW (a, b, c))

explSet :: (a, b, c) -> Int -> Stores (a, b, c) -> IO ()

explSetMaybe :: (a, b, c) -> Int -> SafeRW (a, b, c) -> IO ()

explModify :: (a, b, c) -> Int -> (Stores (a, b, c) -> Stores (a, b, c)) -> IO ()

explCmap :: (a, b, c) -> (Stores (a, b, c) -> Stores (a, b, c)) -> IO ()

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

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

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

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

type IsRuntime c = (Store (Storage c), Stores (Storage c) ~ c)

A constraint that indicates that the runtime representation of c is c

class GlobalRW s c where

Class of storages for global values

Minimal complete definition

explGlobalRead, explGlobalWrite

Methods

explGlobalRead :: s -> IO c

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

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

Instances

GlobalRW (Global c) c

Methods

explGlobalRead :: Global c -> IO c

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

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

(GlobalRW a ca, GlobalRW b cb) => GlobalRW (a, b) (ca, cb)

Methods

explGlobalRead :: (a, b) -> IO (ca, cb)

explGlobalWrite :: (a, b) -> (ca, cb) -> IO ()

explGlobalModify :: (a, b) -> ((ca, cb) -> (ca, cb)) -> IO ()

(GlobalRW a ca, GlobalRW b cb, GlobalRW c cc) => GlobalRW (a, b, c) (ca, cb, cc)

Methods

explGlobalRead :: (a, b, c) -> IO (ca, cb, cc)

explGlobalWrite :: (a, b, c) -> (ca, cb, cc) -> IO ()

explGlobalModify :: (a, b, c) -> ((ca, cb, cc) -> (ca, cb, cc)) -> IO ()

class Query q s where

Classes of queries q that can be performed on a store s.

Minimal complete definition

explSlice

Methods

explSlice :: s -> q -> IO (Vector Int)

Returns a slice of the results of the query

Instances

HasMembers s => Query All s

Methods

explSlice :: s -> All -> IO (Vector Int)

Query q s => Query (ConcatQueries q) s

Methods

explSlice :: s -> ConcatQueries q -> IO (Vector Int)

((~) * (Stores s) c, ToIndex (Stores s)) => Query (ByComponent c) (IndexTable s)

Methods

explSlice :: IndexTable s -> ByComponent c -> IO (Vector Int)

((~) * (Stores s) c, ToIndex (Stores s)) => Query (ByIndex c) (IndexTable s)

Methods

explSlice :: IndexTable s -> ByIndex c -> IO (Vector Int)

data All

Query that returns all members, equivalent to members

Constructors

All

Instances

HasMembers s => Query All s

Methods

explSlice :: s -> All -> IO (Vector Int)

class Cast a b where

Casts for entities and slices

Minimal complete definition

cast

Methods

cast :: a -> b

Instances

Cast (Slice a) (Slice b)

Methods

cast :: Slice a -> Slice b

Cast (Entity a) (Entity b)

Methods

cast :: Entity a -> Entity b