Game.Antisplice.Skills

Provides utility functions for composing skills

Utility types

newtype Condition

A wrapper type for skill execution preconditions.

Constructors

Condition

Fields

runCondition' :: InvokableP

Instances

Monoid Condition

None Condition

IsAction Condition

ToConsumer Condition

data Consumer

A single consumer. Build it using bareAction, bareCondition and monoid concatenation.

Constructors

Consumer !Condition !Invokable

Instances

Monoid Consumer

None Consumer

IsAction Consumer

Extensible Consumer

ToConsumer Consumer

data Skill

A skill. Build it using the !+ compositor and the skill function.

Constructors

Skill

Fields

skillConditionOf :: !Condition

skillActionOf :: !Invokable

skillNameOf :: !String

Instances

Extensible Skill

ToConsumer Skill

data Recipe

A recipe. Build it using the !+ compositor and the recipe function.

Constructors

Recipe

Fields

recipeConditionOf :: !Condition

recipeActionOf :: !Invokable

recipeMethodOf :: !RecipeMethod

recipeNameOf :: !String

Instances

Extensible Recipe

ToConsumer Recipe

class ToConsumer c where

Typeclass for everything that may act as a consumer.

Methods

toConsumer :: c -> Consumer

Instances

ToConsumer PredicateBox

ToConsumer HandlerBox

ToConsumer Action

ToConsumer Consumer

ToConsumer Recipe

ToConsumer Skill

ToConsumer Condition

Compositors

class Extensible e where

Typeclass for everything that may be extended by consumers using !+

Methods

(!+) :: ToConsumer c => e -> c -> e

Add a consumer to the skill.

Instances

Extensible Consumer

Extensible Recipe

Extensible Skill

(>!+) :: (ToConsumer c, Monad m, Extensible e) => m e -> c -> m e

Add a consumer to the monadic extensible

(!+>) :: (ToConsumer c, Monad m, Extensible e) => e -> m c -> m e

Add a monadic consumer to the extensible

(>!+>) :: (ToConsumer c, Monad m, Extensible e) => m e -> m c -> m e

Add a monadic consumer to the monadic extensible

Builders

skill :: String -> Skill

Build a bogus skill that does nothing but has a name. Use this with !+ to build powerful skills.

recipe :: RecipeMethod -> String -> Recipe

Build a bogus recipe that does nothing has a name and a usage method. Use this with !+ to build powerful recipes.

validConsumer :: (Append m (Cons EnsureLineEnd Nil) s, Append r Nil r, CallMask s r, Tuplify r t) => m -> (t -> Handler) -> Consumer

Build a consumer using new-style input validation

validCondition :: (Append m (Cons EnsureLineEnd Nil) s, Append r Nil r, CallMask s r, Tuplify r t) => m -> (t -> Predicate) -> Condition

Build a condition using new-style input validation

(#-) :: (Append m (Cons EnsureLineEnd Nil) s, Append r Nil r, CallMask s r) => m -> MaskedConsumer r -> Consumer

Map a masked consumer to a call mask

(#->) :: (Append m (Cons EnsureLineEnd Nil) s, Append r Nil r, CallMask s r, Tuplify r t) => m -> (t -> Handler) -> Consumer

Infix version of validConsumer

(#->>) :: (Append m (Cons EnsureLineEnd Nil) s, CallMask s Nil) => m -> Handler -> Consumer

Infix version of validConsumer, swallowing the empty handler parameter

Sample consumers

focusDirectC :: Consumer

Focus direct object

optionallyFocusDirectC :: Consumer

Optionally ocus direct object (obligatory if none is focused yet)

callRecipe :: RecipeMethod -> Consumer

Dispatch the remaining part of the line as a recipe call

Final wrappers

runConsumer :: ToConsumer c => c -> Invokable

Run the given consumer

wrapSkills :: [Skill] -> String -> Maybe Invokable

Wrap the skills into a form that is accepted by stereotypes.

wrapRecipes :: [Recipe] -> String -> Maybe (RecipeMethod -> Invokable)

Wrap the recipes into a form that is accepted by stereotypes.