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

Initializable (Global c)

Associated Types

type InitArgs (Global c) :: *

Methods

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

Initializable (Unique c)

Associated Types

type InitArgs (Unique c) :: *

Methods

initStoreWith :: InitArgs (Unique c) -> IO (Unique 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, Cachable s) => Initializable (Cache n s)

Associated Types

type InitArgs (Cache n s) :: *

Methods

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

(Log l (Stores s), Cachable s) => Initializable (Logger l s)

Associated Types

type InitArgs (Logger l s) :: *

Methods

initStoreWith :: InitArgs (Logger l s) -> IO (Logger l 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. Equivalent to calling explDestroy on each member

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

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]

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]

Cachable 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]

(Log l (Stores s), Cachable s) => HasMembers (Logger l s)

Methods

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

explExists :: Logger l s -> Int -> IO Bool

explMembers :: Logger l s -> IO (Vector Int)

explReset :: Logger l s -> IO ()

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

explImapM :: MonadIO m => Logger l 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. Equivalent to reading a value, and then writing the result of the function application.

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

Maps over all elements of this store. Equivalent to getting a list of all entities with this component, and then explModifying each of them.

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

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]

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]

Cachable 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]

(Log l (Stores s), Cachable s) => Store (Logger l s)

Associated Types

type SafeRW (Logger l s) :: *

type Stores (Logger l s) :: *

Methods

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

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

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

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

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

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

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

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

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

explCimapM :: MonadIO m => Logger l s -> ((Int, Stores (Logger l 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 This will almost always be the case, but it _might_ not be so we need this constraint.

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