Update whole Component.Set

Single component mapping, Same asList.map - only for Component.Set inside World

gravitySystem =
    Logic.System.step (Vec2.add gravity) accelerationSpec

Step over all entities that have both components.

Example:

system =
    Logic.System.step2
        (\( v, _ ) ( p, setP ) -> setP (Vec2.add v p))
        velocitySpec
        positionSpec

Same as step2 only with 3 components

Same as step2 only with 4 components

Same as step2 only with 5 components

Reduce a Component.Set from the left.

Example count how much enemies left in the world:

enemySet =
    enemySpec.get world


count =
    foldl (\_ -> (+) 1) enemySet 0

Step over all entities that have both components and reduce an Component.Sets from the left.

Same as foldl2 only with 3 components

Same as foldl2 only with 4 components

Same as foldl2 only with 5 components

Variant of foldl that passes the index of the current element to the step function.

indexedFoldl is to foldl as List.indexedMap is to List.map.

Same as indexedFoldl2 only with 3 components

Same as indexedFoldl2 only with 4 components

Same as indexedFoldl2 only with 5 components

Specify that a component to be used in an advanced fold operation is optional.

Specify that a component to be used in an advanced fold operation is required.

Specify that an entityId an advanced fold operation must not have this component

similar to indexFoldl2, but allows you to specify which components are required and which are optional.

The tests are a good example of how this works

let
    world =
        withEntities
            [ -- entity 1
              [ ( fooSpec, 1 ) ]


            -- entity 2
            , [ ( fooSpec, 2 ), ( barSpec, 3 ) ]


            -- entity 3
            , [ ( barSpec, 999 ) ]
            ]


    result =
        Logic.System.advancedFoldl2
            (\_ foo barMaybe acc -> acc + foo + Maybe.withDefault 0 barMaybe)
            (Logic.System.isRequired world.foos)
            (Logic.System.isOptional world.bars)
            0
in
Expect.equal result 6

a version of advancedFoldl2 that allows you to fold over 3 components

a version of advancedFoldl2 that allows you to fold over 4 components

a version of advancedFoldl2 that allows you to fold over 5 components

Just nice helper function to pipe into systems

update msg world =
    world
        |> system1
        |> applyIf (msg === KeyUp "a") systemMoveLeft
        |> system2

Same as applyIf, but works with Maybe

update msg world =
    world
        |> system1
        |> applyMaybe (decode saveDecoder msg) loadGame
        |> system2