mischief-ecs
Safe HaskellNone
LanguageGHC2024

Mischief.ECS.Tables

Synopsis

Documentation

newtype Tables Source #

Constructors

Tables 

Fields

data Table Source #

Constructors

Table 

Fields

newtype Column Source #

Constructors

Column (IOVec ComponentData) 

baseline_entities_cap :: Int Source #

emptyTables :: IO Tables Source #

newTable :: [ComponentId] -> IO Table Source #

tableIsEmpty :: Table -> IO Bool Source #

tapMap :: (Monad m, Ord k) => Map k a -> k -> (a -> m ()) -> m () Source #

runs the specified monadic action with the value of the given map key as input, if the key exists. if it doesn't, do nothing

insertComponentsIntoMap :: ProcessedBundleData -> Map ComponentId Column -> IO () Source #

insertComponentsIntoTable :: ProcessedBundleData -> Table -> IO () Source #

replaceComponentsIntoMap Source #

Arguments

:: ProcessedBundleData 
-> Maybe Tick

The current tick that will be as the components' change tick.

-> EntityPointer 
-> Map ComponentId Column 
-> IO () 

replaceComponentsIntoTable Source #

Arguments

:: ProcessedBundleData 
-> Maybe Tick

The current tick that will be as the components' change tick.

-> EntityPointer 
-> Table 
-> IO () 

takeFromColumn :: EntityPointer -> Column -> IO ComponentData Source #

takeComponentsFromTable :: EntityPointer -> Table -> IO ProcessedBundleData Source #

collectComponentIdsFromTable :: Table -> IO [ComponentId] Source #

removeComponentFromColumn :: EntityPointer -> Column -> IO () Source #

removeComponentsFromMap :: EntityPointer -> Map ComponentId Column -> IO () Source #

removeComponentsFromTable :: EntityPointer -> Table -> IO () Source #

removeRow :: Int -> IOVec (Entity, IORef EntityPointer) -> IO () Source #

removeEntityFromTable :: Int -> Table -> IO () Source #

insertEntityIntoTables :: ProcessedBundleData -> Tables -> ArchetypeId -> (Entity, IORef EntityPointer) -> IO () Source #

tryGetComponentFromColumn :: Component c => Column -> EntityPointer -> IO (Maybe c) Source #

tryGetRelCollectionFromTable :: Component c => Table -> Entity -> EntityPointer -> ComponentId -> IO (Maybe [Result (Rel c)]) Source #

tryGetComponentFromTable :: Component c => Table -> EntityPointer -> ComponentId -> IO (Maybe c) Source #

tryGetRelCollectionFromTables :: Component c => Tables -> Entity -> EntityPointer -> ComponentId -> IO (Maybe [Result (Rel c)]) Source #

tryGetComponentFromTables :: Component c => Tables -> EntityPointer -> ComponentId -> IO (Maybe c) Source #

tryGetTicksFromColumn :: Column -> IO [ComponentTicks] Source #

tryGetEntityTicksFromColumn :: Column -> EntityPointer -> IO ComponentTicks Source #

tryGetTicksFromTable :: Table -> ComponentId -> IO [Maybe ComponentTicks] Source #

tryGetEntityTicksFromTable :: Table -> EntityPointer -> ComponentId -> IO (Maybe ComponentTicks) Source #

tryGetTicksFromArchetype :: ArchetypeId -> IOVec Table -> ComponentId -> IO [Maybe ComponentTicks] Source #

tryGetEntityTicksFromArchetype :: ArchetypeId -> IOVec Table -> EntityPointer -> ComponentId -> IO (Maybe ComponentTicks) Source #

tryGetTicksFromTables :: Tables -> [ArchetypeId] -> ComponentId -> IO [Maybe ComponentTicks] Source #

tryGetEntityTicksFromTables :: Tables -> EntityPointer -> ComponentId -> IO (Maybe ComponentTicks) Source #

tryGetComponentsFromColumn :: Component c => Column -> IO [c] Source #

tryGetRelCollectionsFromTable :: Component c => Table -> ComponentId -> IO [(Entity, [Result (Rel c)])] Source #

tryGetComponentsFromTable :: Component c => Table -> ComponentId -> IO [(Entity, Result c)] Source #

tryGetEntitiesFromTable :: Table -> IO [Entity] Source #

tryGetComponentsFromTableMaybe :: Component c => Table -> ComponentId -> IO [(Entity, Maybe (Result c))] Source #

tryGetRelCollectionsFromArchetype :: Component c => ArchetypeId -> IOVec Table -> ComponentId -> IO [(Entity, [Result (Rel c)])] Source #

tryGetComponentsFromArchetype :: Component c => ArchetypeId -> IOVec Table -> ComponentId -> IO [(Entity, Result c)] Source #

tryGetEntitiesFromArchetype :: ArchetypeId -> IOVec Table -> IO [Entity] Source #

tryGetComponentsFromArchetypeMaybe :: Component c => ArchetypeId -> IOVec Table -> ComponentId -> IO [(Entity, Maybe (Result c))] Source #

tryGetRelCollectionsFromTables :: Component c => Tables -> [ArchetypeId] -> ComponentId -> IO [(Entity, [Result (Rel c)])] Source #

tryGetComponentsFromTables :: Component c => Tables -> [ArchetypeId] -> ComponentId -> IO [(Entity, Result c)] Source #

tryGetEntitiesFromTables :: Tables -> [ArchetypeId] -> IO [Entity] Source #

tryGetComponentsFromTablesMaybe :: Component c => Tables -> [ArchetypeId] -> ComponentId -> IO [(Entity, Maybe (Result c))] Source #

newtype Result c Source #

Constructors

Result (c, Entity) 

Instances

Instances details
HasField a b c => HasField (a :: k) (Result b :: Type) (c :: Type) Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

getField :: Result b -> c #

TryMapId 'False MapQueryVal (Result a) a Source # 
Instance details

Defined in Mischief.ECS.Mappable

Methods

tryMapId :: Result a -> a Source #

TryMapId 'False MapQueryValidity (Result a) (Result a) Source # 
Instance details

Defined in Mischief.ECS.Mappable

Methods

tryMapId :: Result a -> Result a Source #

Component c => Updateable' 'False (Result (Rel c)) Source # 
Instance details

Defined in Mischief.ECS.World.Insert

Methods

updateInner' :: Result (Rel c) -> System (Maybe (Result (Rel c))) Source #

(Component c, IsComponentC c ~ HTrue) => Updateable' 'True (Result c) Source # 
Instance details

Defined in Mischief.ECS.World.Insert

Methods

updateInner' :: Result c -> System (Maybe (Result c)) Source #

Component c => GetResultComponentId' 'False (Result (Rel c)) Source # 
Instance details

Defined in Mischief.ECS.World.Query

Methods

getResultComponentId' :: MonadSystem w m => Result (Rel c) -> m (Maybe ComponentId) Source #

Component c => GetResultComponentId' 'True (Result c) Source # 
Instance details

Defined in Mischief.ECS.World.Query

Methods

getResultComponentId' :: MonadSystem w m => Result c -> m (Maybe ComponentId) Source #

DeepValue' 'False (Result (Rel c)) c Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

deepValue' :: Result (Rel c) -> c Source #

DeepValue' 'True (Result c) c Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

deepValue' :: Result c -> c Source #

Component c => Settable' 'False (Result (Rel c)) c Source # 
Instance details

Defined in Mischief.ECS.World.Insert

Methods

setInner' :: Result (Rel c) -> c -> System () Source #

setIfNeqInner' :: Result (Rel c) -> c -> System () Source #

(Component c, IsComponentC c ~ HTrue) => Settable' 'True (Result c) c Source # 
Instance details

Defined in Mischief.ECS.World.Insert

Methods

setInner' :: Result c -> c -> System () Source #

setIfNeqInner' :: Result c -> c -> System () Source #

Component c => RelQuery 'Exclusive (MR c Any) (Maybe (Result (Rel c))) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

relRunQueryEntity :: MR c Any -> World -> Entity -> IO (Maybe (Maybe (Result (Rel c)))) Source #

relRunQueryInternal :: MR c Any -> [ArchetypeId] -> World -> IO [(Entity, Bool, Maybe (Result (Rel c)))] Source #

relQueryTypes :: MR c Any -> Set (TypeRep, TypeQuery) Source #

Component c => RelQuery 'Exclusive (R c Any) (Result (Rel c)) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

relRunQueryEntity :: R c Any -> World -> Entity -> IO (Maybe (Result (Rel c))) Source #

relRunQueryInternal :: R c Any -> [ArchetypeId] -> World -> IO [(Entity, Bool, Result (Rel c))] Source #

relQueryTypes :: R c Any -> Set (TypeRep, TypeQuery) Source #

Component c => RelQuery 'Inclusive (MR c Any) (Maybe [Result (Rel c)]) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

relRunQueryEntity :: MR c Any -> World -> Entity -> IO (Maybe (Maybe [Result (Rel c)])) Source #

relRunQueryInternal :: MR c Any -> [ArchetypeId] -> World -> IO [(Entity, Bool, Maybe [Result (Rel c)])] Source #

relQueryTypes :: MR c Any -> Set (TypeRep, TypeQuery) Source #

Component c => RelQuery 'Inclusive (R c Any) [Result (Rel c)] Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

relRunQueryEntity :: R c Any -> World -> Entity -> IO (Maybe [Result (Rel c)]) Source #

relRunQueryInternal :: R c Any -> [ArchetypeId] -> World -> IO [(Entity, Bool, [Result (Rel c)])] Source #

relQueryTypes :: R c Any -> Set (TypeRep, TypeQuery) Source #

Show c => Show (Result c) Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

showsPrec :: Int -> Result c -> ShowS #

show :: Result c -> String #

showList :: [Result c] -> ShowS #

Eq c => Eq (Result c) Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

(==) :: Result c -> Result c -> Bool #

(/=) :: Result c -> Result c -> Bool #

Ord c => Ord (Result c) Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

compare :: Result c -> Result c -> Ordering #

(<) :: Result c -> Result c -> Bool #

(<=) :: Result c -> Result c -> Bool #

(>) :: Result c -> Result c -> Bool #

(>=) :: Result c -> Result c -> Bool #

max :: Result c -> Result c -> Result c #

min :: Result c -> Result c -> Result c #

Updateable' (IsComp c) (Result c) => Updateable (Result c) Source # 
Instance details

Defined in Mischief.ECS.World.Insert

Methods

updateInner :: Result c -> System (Maybe (Result c)) Source #

GetResultComponentId' (IsComp c) (Result c) => GetResultComponentId (Result c) Source # 
Instance details

Defined in Mischief.ECS.World.Query

Methods

getResultComponentId :: MonadSystem w m => Result c -> m (Maybe ComponentId) Source #

DeepValue' (IsComp c) (Result c) i => DeepValue (Result c) i Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

deepValue :: Result c -> i Source #

Settable' (IsComp c) (Result c) i => Settable (Result c) i Source # 
Instance details

Defined in Mischief.ECS.World.Insert

Methods

setInner :: Result c -> i -> System () Source #

setIfNeqInner :: Result c -> i -> System () Source #

Component c => Queryable (C c) (Result c) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

runQueryEntity :: C c -> World -> Entity -> IO (Maybe (Result c)) Source #

runQueryInternal :: C c -> [ArchetypeId] -> World -> IO [(Entity, Bool, Result c)] Source #

queryTypes :: C c -> Set (TypeRep, TypeQuery) Source #

Component c => Queryable (M c) (Maybe (Result c)) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

runQueryEntity :: M c -> World -> Entity -> IO (Maybe (Maybe (Result c))) Source #

runQueryInternal :: M c -> [ArchetypeId] -> World -> IO [(Entity, Bool, Maybe (Result c))] Source #

queryTypes :: M c -> Set (TypeRep, TypeQuery) Source #

Component c => Queryable (MR c Entity) (Maybe (Result (Rel c))) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

runQueryEntity :: MR c Entity -> World -> Entity -> IO (Maybe (Maybe (Result (Rel c)))) Source #

runQueryInternal :: MR c Entity -> [ArchetypeId] -> World -> IO [(Entity, Bool, Maybe (Result (Rel c)))] Source #

queryTypes :: MR c Entity -> Set (TypeRep, TypeQuery) Source #

Component c => Queryable (R c Entity) (Result (Rel c)) Source # 
Instance details

Defined in Mischief.ECS.World.Query.Queryable

Methods

runQueryEntity :: R c Entity -> World -> Entity -> IO (Maybe (Result (Rel c))) Source #

runQueryInternal :: R c Entity -> [ArchetypeId] -> World -> IO [(Entity, Bool, Result (Rel c))] Source #

queryTypes :: R c Entity -> Set (TypeRep, TypeQuery) Source #

data ErasedResult where Source #

Constructors

ErasedResult :: forall c. Result c -> ErasedResult 

value :: Result c -> c Source #

type family IsComp a :: Bool where ... Source #

Equations

IsComp (Rel a) = 'False 
IsComp a = 'True 

entityOf :: Result c -> Entity Source #

class DeepValue' (flag :: k) c i | flag c -> i where Source #

Methods

deepValue' :: c -> i Source #

Instances

Instances details
DeepValue' 'False (Result (Rel c)) c Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

deepValue' :: Result (Rel c) -> c Source #

DeepValue' 'True (Result c) c Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

deepValue' :: Result c -> c Source #

class DeepValue c i | c -> i where Source #

Methods

deepValue :: c -> i Source #

Instances

Instances details
DeepValue' (IsComp c) (Result c) i => DeepValue (Result c) i Source # 
Instance details

Defined in Mischief.ECS.Tables

Methods

deepValue :: Result c -> i Source #