Safe Haskell	None
Language	GHC2024

Mischief.ECS.World

Contents

World
Systems
Parallel

Synopsis

data World = World {
- archetypes :: Archetypes
- components :: Components
- entities :: Entities
- tables :: Tables
- events :: IORef [ErasedEvent]
- deferred :: IORef [System ()]
- deferredAsync :: TVar [System ()]
- tick :: IORef Tick
- systemId :: SystemId
- frame :: IORef Frame
- prefs :: WorldPrefs
- logger :: LogAction IO Message
- loggerErr :: LogAction IO Message
- tools :: SystemTools
}
newWorld :: SystemTools -> IO World
setSystemId :: SystemId -> World -> World
setDeferred :: IORef [System ()] -> World -> World
setPrefs :: WorldPrefs -> World -> World
forkPrefs :: (WorldPrefs -> WorldPrefs) -> System a -> System a
newtype Frame = Frame Int
data SystemTools = SystemTools {
- get :: forall c (m :: Type -> Type) w. (MonadSystem w m, Component c) => Proxy c -> Entity -> m (Maybe c)
- getRAny :: forall c (m :: Type -> Type) w. (Component c, MonadSystem w m, IsExclusiveRel c ~ 'False) => Proxy c -> Entity -> m (Maybe [Rel c])
- set :: forall c. Bundle c => c -> Entity -> System ()
- spawnByInsert :: forall b. Bundle b => Entity -> b -> System ()
}
worldGet :: forall c m w. (MonadSystem w m, Component c) => Proxy c -> Entity -> m (Maybe c)
worldGetRAny :: forall c m w. (Component c, MonadSystem w m, IsExclusiveRel c ~ 'False) => Proxy c -> Entity -> m (Maybe [Rel c])
worldSet :: Bundle c => c -> Entity -> System ()
worldSpawnByInsert :: Bundle b => Entity -> b -> System ()
newtype System a = System (ReaderT (Hidden World) IO a)
newtype SystemId = SystemId {
- id :: Entity
}
runSystem :: System a -> World -> IO a
class (GetWorld w, MonadReader w a, Applicative a, MonadFail a, Functor a, Monad a, MonadIO a, PrimMonad a, PrimState a ~ RealWorld) => MonadSystem w (a :: Type -> Type)
unsafeGetWorld :: MonadSystem w m => m World
sysUnliftIO :: System (System a -> IO a)
newtype ParSystem a = ParSystem (ReaderT ParWorld IO a)
data ParWorld = ParWorld {
- world :: Hidden World
- parDeferred :: IORef [System ()]
}

World

data World Source #

The World is the main data structure storing the entities, components, archetypes, and everything else that lives in our app.

Constructors

World

Fields

archetypes :: Archetypes
Archetype storage.
components :: Components
Components storage.
entities :: Entities
Entities storage.
tables :: Tables
Archetype tables. Storage for the actual data of components.
events :: IORef [ErasedEvent]
List of events to be ran at the next sync point.
deferred :: IORef [System ()]
List of deferred system to be ran at the next sync point. They can also be flushed manually using flush.
deferredAsync :: TVar [System ()]
Secondary list of deferred systems stored in a TVar, meant to be used when running systems asynchronously. They are ran at the first available sync point, and can also be flushed manually with flushAsync.
tick :: IORef Tick
The current tick, incremented each time a system is ran, used for change detection.
systemId :: SystemId
Id of the current system.
frame :: IORef Frame
The current frame.
prefs :: WorldPrefs
Certain toggleable settings.
logger :: LogAction IO Message
loggerErr :: LogAction IO Message
tools :: SystemTools

newWorld :: SystemTools -> IO World Source #

Create a new World in IO.

setSystemId :: SystemId -> World -> World Source #

Change the current SystemId of the World.

setDeferred :: IORef [System ()] -> World -> World Source #

Set the list of deferred systems of the World.

setPrefs :: WorldPrefs -> World -> World Source #

Set new WorldPrefs for the World.

forkPrefs :: (WorldPrefs -> WorldPrefs) -> System a -> System a Source #

Run a System with changed WorldPrefs.

newtype Frame Source #

Constructors

Frame Int

Instances

Instances details

Show Frame Source #
Instance details Defined in Mischief.ECS.World Methods showsPrec :: Int -> Frame -> ShowS # show :: Frame -> String # showList :: [Frame] -> ShowS #
Eq Frame Source #
Instance details Defined in Mischief.ECS.World Methods (==) :: Frame -> Frame -> Bool # (/=) :: Frame -> Frame -> Bool #
Ord Frame Source #
Instance details Defined in Mischief.ECS.World Methods compare :: Frame -> Frame -> Ordering # (<) :: Frame -> Frame -> Bool # (<=) :: Frame -> Frame -> Bool # (>) :: Frame -> Frame -> Bool # (>=) :: Frame -> Frame -> Bool # max :: Frame -> Frame -> Frame # min :: Frame -> Frame -> Frame #

data SystemTools Source #

Constructors

SystemTools
Fields get :: forall c (m :: Type -> Type) w. (MonadSystem w m, Component c) => Proxy c -> Entity -> m (Maybe c) getRAny :: forall c (m :: Type -> Type) w. (Component c, MonadSystem w m, IsExclusiveRel c ~ 'False) => Proxy c -> Entity -> m (Maybe [Rel c]) set :: forall c. Bundle c => c -> Entity -> System () spawnByInsert :: forall b. Bundle b => Entity -> b -> System ()

worldGet :: forall c m w. (MonadSystem w m, Component c) => Proxy c -> Entity -> m (Maybe c) Source #

worldGetRAny :: forall c m w. (Component c, MonadSystem w m, IsExclusiveRel c ~ 'False) => Proxy c -> Entity -> m (Maybe [Rel c]) Source #

worldSet :: Bundle c => c -> Entity -> System () Source #

worldSpawnByInsert :: Bundle b => Entity -> b -> System () Source #

Systems

newtype System a Source #

A System is a monad that mutates the World.

It can be added to a certain schedule and ordered with other systems. It also offers IO access via liftIO.

Read the tutorial on systems for more details.

Constructors

System (ReaderT (Hidden World) IO a)

Instances

Instances details

Applicative System Source #

Instance details

Defined in Mischief.ECS.World

Methods

pure :: a -> System a #

(<*>) :: System (a -> b) -> System a -> System b #

liftA2 :: (a -> b -> c) -> System a -> System b -> System c #

(*>) :: System a -> System b -> System b #

(<*) :: System a -> System b -> System a #

Functor System Source #

Instance details

Defined in Mischief.ECS.World

Methods

fmap :: (a -> b) -> System a -> System b #

(<$) :: a -> System b -> System a #

Monad System Source #

Instance details

Defined in Mischief.ECS.World

Methods

(>>=) :: System a -> (a -> System b) -> System b #

(>>) :: System a -> System b -> System b #

return :: a -> System a #

MonadFail System Source #

Instance details

Defined in Mischief.ECS.World

Methods

fail :: String -> System a #

MonadIO System Source #

Instance details

Defined in Mischief.ECS.World

Methods

liftIO :: IO a -> System a #

Defer System Source #

Instance details

Defined in Mischief.ECS.World.Defer

Methods

defer :: System a -> System () Source #

PrimMonad System Source #

Instance details

Defined in Mischief.ECS.World

Associated Types

type PrimState System
Instance details Defined in Mischief.ECS.World type PrimState System = PrimState IO

Methods

primitive :: (State# (PrimState System) -> (# State# (PrimState System), a #)) -> System a #

EraseIntoStorage (System ()) Systems Source #

Instance details

Defined in Mischief.ECS.Systems

Methods

erase :: System () -> Systems Source #

EraseIntoStorage (System ()) [System ()] Source #

Instance details

Defined in Mischief.ECS.World

Methods

erase :: System () -> [System ()] Source #

type PrimState System Source #

Instance details

Defined in Mischief.ECS.World

type PrimState System = PrimState IO

newtype SystemId Source #

Unique id assigned to each system that's added to a schedule. Just a wrapper around Entity.

Constructors

SystemId
Fields id :: Entity

Instances

Instances details

Show SystemId Source #
Instance details Defined in Mischief.ECS.World Methods showsPrec :: Int -> SystemId -> ShowS # show :: SystemId -> String # showList :: [SystemId] -> ShowS #
Eq SystemId Source #
Instance details Defined in Mischief.ECS.World Methods (==) :: SystemId -> SystemId -> Bool # (/=) :: SystemId -> SystemId -> Bool #
Ord SystemId Source #
Instance details Defined in Mischief.ECS.World Methods compare :: SystemId -> SystemId -> Ordering # (<) :: SystemId -> SystemId -> Bool # (<=) :: SystemId -> SystemId -> Bool # (>) :: SystemId -> SystemId -> Bool # (>=) :: SystemId -> SystemId -> Bool # max :: SystemId -> SystemId -> SystemId # min :: SystemId -> SystemId -> SystemId #

runSystem :: System a -> World -> IO a Source #

Run a System with the given World inside IO

class (GetWorld w, MonadReader w a, Applicative a, MonadFail a, Functor a, Monad a, MonadIO a, PrimMonad a, PrimState a ~ RealWorld) => MonadSystem w (a :: Type -> Type) Source #

Typeclass that can be used to generalize systems to both System and ParSystem.

Used mainly by queries and other operations which don't mutate the World.

Instances

Instances details

MonadSystem ParWorld ParSystem Source #
Instance details Defined in Mischief.ECS.World

unsafeGetWorld :: MonadSystem w m => m World Source #

sysUnliftIO :: System (System a -> IO a) Source #

Parallel

newtype ParSystem a Source #

A variant of System that contains a ParWorld instead of World.

Parallel systems will only be able to run systems that are either specifically intended for them or are made to work with any MonadSystem (such as queries).

To run a normal System (), you need to defer!

Constructors

ParSystem (ReaderT ParWorld IO a)

Instances

Instances details

Applicative ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Methods

pure :: a -> ParSystem a #

(<*>) :: ParSystem (a -> b) -> ParSystem a -> ParSystem b #

liftA2 :: (a -> b -> c) -> ParSystem a -> ParSystem b -> ParSystem c #

(*>) :: ParSystem a -> ParSystem b -> ParSystem b #

(<*) :: ParSystem a -> ParSystem b -> ParSystem a #

Functor ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Methods

fmap :: (a -> b) -> ParSystem a -> ParSystem b #

(<$) :: a -> ParSystem b -> ParSystem a #

Monad ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Methods

(>>=) :: ParSystem a -> (a -> ParSystem b) -> ParSystem b #

(>>) :: ParSystem a -> ParSystem b -> ParSystem b #

return :: a -> ParSystem a #

MonadFail ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Methods

fail :: String -> ParSystem a #

MonadIO ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Methods

liftIO :: IO a -> ParSystem a #

Defer ParSystem Source #

Instance details

Defined in Mischief.ECS.World.Defer

Methods

defer :: System a -> ParSystem () Source #

PrimMonad ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Associated Types

type PrimState ParSystem
Instance details Defined in Mischief.ECS.World type PrimState ParSystem = PrimState (ReaderT ParWorld IO)

Methods

primitive :: (State# (PrimState ParSystem) -> (# State# (PrimState ParSystem), a #)) -> ParSystem a #

MonadSystem ParWorld ParSystem Source #

Instance details

Defined in Mischief.ECS.World

MonadReader ParWorld ParSystem Source #

Instance details

Defined in Mischief.ECS.World

Methods

ask :: ParSystem ParWorld #

local :: (ParWorld -> ParWorld) -> ParSystem a -> ParSystem a #

reader :: (ParWorld -> a) -> ParSystem a #

type PrimState ParSystem Source #

Instance details

Defined in Mischief.ECS.World

type PrimState ParSystem = PrimState (ReaderT ParWorld IO)

data ParWorld Source #

Special wrapper around World given to ParSystems.

Constructors

ParWorld
Fields world :: Hidden World `Hidden` ensures users cannot access and mutate the World. parDeferred :: IORef [System ()] Deferred systems will be collected in this dedicated list and then merged back into the main deferred list once the parallel systems are joined.

Instances

Instances details

MonadSystem ParWorld ParSystem Source #
Instance details Defined in Mischief.ECS.World
MonadReader ParWorld ParSystem Source #
Instance details Defined in Mischief.ECS.World Methods ask :: ParSystem ParWorld # local :: (ParWorld -> ParWorld) -> ParSystem a -> ParSystem a # reader :: (ParWorld -> a) -> ParSystem a #