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
- 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, QueryType c) => Proxy c -> Entity -> m (Maybe c)
- getRAny :: forall c (m :: Type -> Type) w. (Component c, MonadSystem w m, RelExclusivity c ~ 'Inclusive) => 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, QueryType c) => Proxy c -> Entity -> m (Maybe c)
worldGetRAny :: forall c m w. (Component c, MonadSystem w m, RelExclusivity c ~ 'Inclusive) => 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
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
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, QueryType c) => Proxy c -> Entity -> m (Maybe c) getRAny :: forall c (m :: Type -> Type) w. (Component c, MonadSystem w m, RelExclusivity c ~ 'Inclusive) => 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, QueryType c) => Proxy c -> Entity -> m (Maybe c) Source #

worldGetRAny :: forall c m w. (Component c, MonadSystem w m, RelExclusivity c ~ 'Inclusive) => 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 set of instructions applied over a World. It can be added to the App to be ran on a certain Schedule.

A system is actually a wrapper around ReaderT World IO, meaning you can ask for the World, or do IO operations by using liftIO.

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 #

SystemConfig (System ()) Source #

Instance details

Defined in Mischief.ECS.App.SystemConfig

Methods

systemConfigData :: System () -> SystemConfigData Source #

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

Instance details

Defined in Mischief.ECS.World

Methods

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

SystemConfig s1 => SystemConfig (SystemConfigModifier s1 (System ())) Source #

Instance details

Defined in Mischief.ECS.App.SystemConfig

Methods

systemConfigData :: SystemConfigModifier s1 (System ()) -> SystemConfigData Source #

Event (e c) => EraseIntoStorage (e c -> System ()) (Hooks c) Source #

Instance details

Defined in Mischief.ECS.Hooks

Methods

erase :: (e c -> System ()) -> Hooks c 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 #

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 #