Reactor.Reaction

type Dimensions = { height :: Int, tileSize :: Int, width :: Int }

type Reaction world = ReactionM world Unit

data ReactionF world a

A DSL for constructing reactions. For internal use only. You should construct a Reaction by calling the different helper functions in this module, like modifyW, instead of building it manually.

Constructors

• Lift (Effect a)
• Modify (world -> world) (world -> a)
• Dimensions (Dimensions -> a)
• Widget String Ordering Widget (a)
• RemoveWidget String (a)
• ExecuteDefaultBehavior (a)

Instances

• (Functor m) => Functor (ReactionF world)

newtype ReactionM world a

ReactionM world a describes a general reaction in a reactor with the world world, that returns a. In the handleEvent function we use reactions which don't return anything (or more precisely, return Unit), ReactionM world Unit. To simplify things, the following type synonym is set up.

type Reaction world = ReactionM world Unit

Constructors

• ReactionM (Free (ReactionF world) a)

Instances

• Functor (ReactionM world)
• Apply (ReactionM world)
• Applicative (ReactionM world)
• Bind (ReactionM world)
• Monad (ReactionM world)
• (Semigroup a) => Semigroup (ReactionM world a)
• (Monoid a) => Monoid (ReactionM world a)
• MonadEffect (ReactionM world)
• MonadRec (ReactionM world)

widget :: forall world. String -> Widget -> Reaction world

Add a Widget with a given identifier to the reactor. If a widget with the same identifier already exists, it is replaced by the new one. Otherwise, the new widget is added to the end of the Widget array, i.e. to the bottom-most position.

widget' :: forall world. String -> Widget -> Reaction world

Add a Widget with a given identifier to the reactor. If a widget with the same identifier already exists, it is replaced by the new one. Otherwise, the new widget is inserted the beginning of the Widget array, i.e. to the top-most position.

dimensions :: forall world. ReactionM world Dimensions

Get a record of the following:

• height :: Int, the height of the grid, in tiles
• width :: Int, the width of the grid, in tiles
• tileSize :: Int the size of one grid tile, in points. The size is set internally, and this is the only way to get its value.

executeDefaultBehavior :: forall world. Reaction world

After handling the event, execute the default behavior as well. You can read more in the documentation of Reactor.Events.

Usually you'll call this in the handleEvent function, for events that you don't want to handle, e.g. when pressing 'J' doesn't do anything in your game.

getW :: forall world. ReactionM world world

Obtain the current value of the world.

type World = { player :: { x :: Int, y :: Int } }

handleEvent event = case event of
  KeyPress { key : "Space" } -> do
    w <- getW
    log $ "The player is at position: "
      <> show w.player.x
      <> ", "
      <> show w.player.y

modifyW :: forall world. (world -> world) -> ReactionM world world

Modify the current world by passing in a (world -> world) updating function. The function will receive the current value of the world, and should return the new updated value.

Returns the value of the new world.

type World = { player :: { x :: Int, y :: Int } }

handleEvent event = case event of
  KeyPress { key : "ArrowUp" } ->
    newWorld <- modifyW \oldWorld ->
      { player: { x : oldWorld.player.x, y: oldWorld.player.y + 1 } }
    log $ "New world is: " <> show newWorld

modifyW_ :: forall world. (world -> world) -> Reaction world

Similar to modifyW, but doesn't return the value of the new world.

removeWidget' :: forall world. String -> Reaction world

Remove a Widget with a given identifier from the reactor. If there is no widget with the given identifier, do nothing.

updateW :: forall changes t c world. Union changes t world => Nub changes c => Record changes -> ReactionM (Record world) (Record world)

Modify certain fields of the world by passing new values for them.

Returns the value of the new world.

type World = { player :: { x :: Int, y :: Int } }

handleEvent event = case event of
  KeyPress { key : "ArrowUp" } ->
    oldWorld <- getW
    newWorld <-
      updateW
        { player: { x : oldWorld.player.x, y: oldWorld.player.y + 1 } }
    log $ "New world is: " <> show newWorld

updateW_ :: forall changes t c world. Union changes t world => Nub changes c => Record changes -> Reaction (Record world)

Modify certain fields of the world by passing new values for them. Behaves the same as the updateW function, but returns unit instead of the new value of the world.

type World = { player :: { x :: Int, y :: Int } }

handleEvent event = case event of
  KeyPress { key : "ArrowUp" } -> do
    oldWorld <- getW
    updateW_
      { player: { x : oldWorld.player.x, y: oldWorld.player.y + 1 } }
    newWorld <- getW
    log $ "New world is: " <> show newWorld