Map Query m a to Query m b with side effects.

Example

[q|Name, Position|]
  & qtraverse (\e (name, pos) -> do
    [i|The name of entity #{e} is #{name}|]
    pure pos
  )
  & query

Apply a side effect over a query.

Example

[q|Name, Position|]
  & qtraverse (\e (name, pos) -> do
    [i|The name of entity #{e} is #{name}|]
  )
  & query

Maps Query m a to Query m b. Same as fmap.

Example

[q|Name, Position|]
  & qmap (\(name, _) -> name)
  & query

Same as qtraverse.

Possibly maps each element from Query m a to an element from Query m b. If Nothing, will filter this Entity out of the Query.

Example

f :: Name -> Maybe Name

[q|Name|]
  & qmapMaybe f
  & query

Filter the entities of a query with a dedicated query filter.

Example

[q|Position|]
  & qcheck [f|Changed Position, !Added Position|]
  & query

Filter the entities of a query.

Example

[q|Name|]
  & qfilter (== Name Florian)
  & query

Filter the entities of a query with possible side effects.

Example

[q|Position|]
  & qfilterM (\e _ -> changed @Position e)
  & query

Insert the values obtained from a mapping function.

Example

q[|Position, Velocity|]
  & qinsert (\(Position p, Velocity v) -> Position (p + v))
  & query

Same as qinsert but only inserts components that aren't already on the entity.

Same as qinsert but only inserts components that are new or different than the ones already on the entity. Avoids triggering false change detection.

Same as qinsert but will also propagate the mapped elements. Equivalent to qinsert id . qmap f.

Same as qinsertNew but will also propagate the mapped elements. Equivalent to qinsertNew id . qmap f.

Same as qinsertIfNeq but will also propagate the mapped elements. Equivalent to qinsertIfNeq id . qmap f.

Grab a specific entity from another query and map it into the current one. If the first function returns Nothing, will filter this entity out of the query.

Example

data Sprite = Sprite {image :: Entity} deriving (Component)

[q|Sprite|]
  qget (\sprite -> sprite.image) (,) [q|Image|]
  & query

qget :: (MonadSystem w m) => (a -> Maybe Entity) -> Query m b -> Query m a -> Join m a Maybe (From b) qget f b a = Join a ( _ x -> do let entity = f x case entity of Nothing -> pure Nothing Just entity -> do bs <- get entity b pure $ fmap (From entity) bs )

Grab specific entities from another query. If the first function returns an empty list, will filter this entity out of the query.

Example

data Images = Images {images :: [Entity]} deriving (Component)

[q|Images|]
  & qgetMany (.images) (,) [q|Image|]
  & query

qgetMany :: (MonadSystem w m) => (a -> [Entity]) -> Query m b -> Query m a -> Join m a List (From b) qgetMany f b a = Join a ( _ x -> do let entities = f x y catMaybes <$ mapM (e -> fmap (e,) $ single (mkGet e b)) entities pure $ map (uncurry From) y )

Like qgetMany but with side-effects in the function which provides the entities. qgetManyM :: (MonadSystem w m) => (a -> m [Entity]) -> Query m b -> Query m a -> Join m a List (From b) qgetManyM f b a = Join a ( _ x -> do entities <- f x y catMaybes <$ mapM (e -> fmap (e,) $ single (mkGet e b)) entities pure $ map (uncurry From) y )

Very similar to qappendOneM. This is a helper function mainly intended to make relationship traversals easier.

Example

import Mischief.ECS.Relationships.Graph

[q|Name|]
  & qrelateOne (Graph.outgoing @ChildOf) (,) [q|Name|]
  & qinfo (\(child, parent) -> [i|#{child} is child of #{parent}|])
  & query_

qrelate :: (MonadSystem w m) => (Entity -> m (Maybe Entity)) -> Query m b -> Query m a -> Join m a Maybe (From b) qrelate f b a = Join a ( e _ -> do entity <- f e case entity of Nothing -> pure Nothing Just entity -> do y <- single (mkGet entity b) pure $ fmap (From entity) y )

Very similar to qappendManyM. This is a helper function mainly intended to make relationship traversals easier.

Example

import Mischief.ECS.Relationships.Graph

[q|Name|]
  & qrelateOne (Graph.ingoing @ChildOf) (,) [q|Name|]
  & qinfo (\(parent, children) -> [i|#{parent} is parent of #{children}|])
  & query_

qrelateMany :: (MonadSystem w m) => (Entity -> m [Entity]) -> Query m b -> Query m a -> Join m a List (From b) qrelateMany f b a = Join a ( e _ -> do entities <- f e y catMaybes <$ mapM (e -> fmap (e,) $ single (mkGet e b)) (toList entities) pure $ map (uncurry From) y )

Grab the elements from another query that meet a certain condition in relation to this query. Map them together. The entities for which the list is empty will be filtered out.

Example

[q|Entity, Name|]
  & qjoin (\(e1, n1) (e2, n2) -> n1 == n2 && e1 /= e2) (,) [q|Entity, Name|]
  & qinfo (\((e1, name), (e2, _)) -> [i|#{e1} and #{e2} are both named #{name}|])
  & query_

qcross :: (MonadSystem w m) => (a -> b -> Bool) -> Query m b -> Query m a -> Join m a List (From b) qcross f b a = Join a ( _ a -> do y <- query (qentity b) let y' = filter ((_, b) -> f a b) y pure $ map (uncurry From) y' )

Same as qcross but with side effects in the function which matches the elements of the two queries. qcrossM :: (MonadSystem w m) => (Entity -> a -> Entity -> b -> m Bool) -> Query m b -> Query m a -> Join m a List (From b) qcrossM f b a = Join a ( e a -> do y <- query (qentity b) y' <- filterM (uncurry (f e a)) y pure $ map (uncurry From) y' )

Extends the query with new elements.

Example

[q|Name|]
  & qextend qd|Position|
  & query

Maps a resource into the query.

Example

[q|Name|]
  & qres @SomeResource (,)
  & query

qres :: forall r m a w. (MonadSystem w m, Component r) => Query m a -> Join m a Maybe (Res r) qres = qextend (mkQuery (Res @r))

Logs an INFO message.

Logs a WARNING message.

Logs an ERROR message.