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

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 Store s where

Holds components indexed by entities

Minimal complete definition

explGet, explSet, explDestroy, explExists, explMembers, explGetUnsafe, explSetMaybe, initStoreWith

Associated Types

type Stores s

The type of components stored by this Store

type SafeRW s

Return type for safe reads writes to the store

type InitArgs s

The initialization argument required by this store

Methods

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

Retrieves a component from the store

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

Writes a component

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

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

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

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

Either writes or deletes a component

initStoreWith :: InitArgs s -> IO s

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

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 (Global c)

Associated Types

type Stores (Global c) :: *

type SafeRW (Global c) :: *

type InitArgs (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 ()

initStoreWith :: InitArgs (Global c) -> 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]

Store (Unique c)

Associated Types

type Stores (Unique c) :: *

type SafeRW (Unique c) :: *

type InitArgs (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 ()

initStoreWith :: InitArgs (Unique c) -> 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]

Flag c => Store (Set c)

Associated Types

type Stores (Set c) :: *

type SafeRW (Set c) :: *

type InitArgs (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 ()

initStoreWith :: InitArgs (Set c) -> 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]

Store (Map c)

Associated Types

type Stores (Map c) :: *

type SafeRW (Map c) :: *

type InitArgs (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 ()

initStoreWith :: InitArgs (Map c) -> 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]

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

Associated Types

type Stores (a, b) :: *

type SafeRW (a, b) :: *

type InitArgs (a, b) :: *

Methods

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

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

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

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

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

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

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

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

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

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

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

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]

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

Associated Types

type Stores (Cache n s) :: *

type SafeRW (Cache n s) :: *

type InitArgs (Cache n s) :: *

Methods

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

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

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

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

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

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

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

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

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]

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 Stores (Logger l s) :: *

type SafeRW (Logger l s) :: *

type InitArgs (Logger l s) :: *

Methods

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

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

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

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

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

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

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

initStoreWith :: InitArgs (Logger l s) -> IO (Logger l s)

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]

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 Stores (a, b, c) :: *

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

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

Methods

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

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

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

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

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

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

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

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

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]

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]

class (SafeRW s ~ Stores s, Store s) => GlobalStore s

Class of storages for global values

Instances

GlobalStore (Global c)

(GlobalStore a, GlobalStore b) => GlobalStore (a, b)

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

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