Game.Antisplice.Rooms

A huge pile of utility functions for building our dungeon.

Room modification

modifyRoomState :: MonadRoom m => (RoomState -> RoomState) -> m ()

Modify the room state.

getRoomDesc :: (MonadRoom m, MonadAtoms m) => m String

Get the current room's description

getRoomTitle :: (MonadRoom m, IsText t) => m t

Get the current room's title

setRoomTitle :: (MonadRoom m, IsText t) => t -> m ()

Set the current room's description setRoomDesc :: (MonadRoom m,IsText t) => t -> m () setRoomDesc t = modifyRoomState $ s -> s{roomDescOf=toText t}

Set the current room's title

markRoom :: MonadDungeon m => m ()

Mark the current room as visited

Moving around

enterRoom :: NodeId -> ChattyDungeonM Bool

Enter the given room and trigger most events, but don't announce it. Result tells whether this room is visited the first time.

reenterCurrentRoom :: ChattyDungeonM ()

Reenter the current room and trigger all events (but don't announce it).

enterAndAnnounce :: NodeId -> ChattyDungeonM ()

Enter the given room, trigger all events and announce it. On the first visit, look around.

changeRoom :: Direction -> ChattyDungeonM ()

Enter a neighbouring room by its direction.

Room construction

constructRoom :: MonadDungeon m => RoomT m a -> m NodeId

Construct a new room using the room monad.

establishWay :: MonadDungeon m => NodeId -> NodeId -> Direction -> PathState -> m ()

Establish a path from one room to another one (one-way only).

addRoomObject :: (MonadCounter m, MonadRoom m) => ObjectT m a -> m ObjectId

Add a new object to the current room. It is contructed using the object monad.

removeRoomObject :: MonadRoom m => ObjectId -> m ObjectState

Remove an object from the current room and return its state.

insertRoomObject :: MonadRoom m => ObjectState -> m ()

Insert an already constructed object to the current room.

Object construction

constructObject :: Monad m => ObjectT m a -> Maybe ObjectId -> KindId -> m ObjectState

Construct a room object (but don't add it)

modifyObjectState :: MonadObject m => (ObjectState -> ObjectState) -> m ()

Modify the object state

setObjectDesc :: (MonadObject m, IsText t) => t -> m ()

Set the object's description

setObjectTitle :: (MonadObject m, IsText t) => t -> m ()

Set the object's title

addObjectName :: MonadObject m => String -> m ()

Add a name for the current object

addObjectAttr :: MonadObject m => String -> m ()

Add an attribute for the current object

setObjectIsMob :: MonadObject m => Bool -> m ()

Set whether the current object is a mob.

setObjectIsAcquirable :: MonadObject m => Bool -> m ()

Set whether the current object is acquirable.

addFeature :: MonadObject m => Feature -> m ()

Add an object feature to the current object

addDescSeg :: (MonadObject m, MonadAtoms m) => String -> m ()

Add a room description segment to the current object

addEquipSlot :: MonadObject m => EquipKey -> m ()

Add equippable slot

Object forms

registerForm :: MonadAtoms m => ObjectT m () -> m (Atom ObjectState)

Register an object form and return its atom

instanciateForm :: (MonadAtoms m, MonadRoom m, MonadCounter m) => Atom ObjectState -> m ObjectId

Instanciate a registered form

registerKind :: MonadCounter m => m KindId

Register an object kind.

setObjectKind :: MonadObject m => KindId -> m ()

Set object kind.

Object investigation

getObjectTitle :: (MonadObject m, IsText t) => m t

Get the object's title

getObjectDesc :: (MonadObject m, IsText t) => m t

Get the object's description

getObjectNames :: MonadObject m => m [String]

Get the object's names

matchObjectName :: MonadObject m => String -> m Bool

Check if the given name matches our current object

getObjectIsMob :: (MonadObject m, Functor m) => m Bool

Check if the current object is a mob.

getObjectIsAcquirable :: (MonadObject m, Functor m) => m Bool

Check if the current object is acquirable.

roomOfObject :: MonadDungeon m => ObjectId -> m [NodeId]

Determine which rooms contain the given object (won't be more than one, but we're careful)

Object actions

setMobRoute :: MonadObject m => [NodeId] -> m ()

Set the current mob's route

continueMobRoute :: ObjectId -> Handler

The given object may continue its route

Scheduling

schedule :: (MonadDungeon m, MonadClock m) => Integer -> Handler -> m ()

Schedule an event for a given time offset (in milliseconds).

Players

subscribePlayer :: (MonadDungeon m, MonadCounter m) => PlayerT m a -> m ()

Create a new player using the player monad

setPlayerRoom :: MonadPlayer m => NodeId -> m ()

Move the current player to the given room, but don't trigger anything.

acquireObject :: ObjectId -> ChattyDungeonM ()

Acquire the given object and put it in the player's inventory

dropObject :: ObjectId -> ChattyDungeonM ()

Drop the given object and remove it from the player's inventory

equipObject :: (MonadPlayer m, MonadError SplErr m) => ObjectState -> m (Maybe ObjectState)

Equip the given object somewhere

equipObjectAt :: (MonadPlayer m, MonadError SplErr m) => EquipKey -> ObjectState -> m (Maybe ObjectState)

Equip the given object at a given key

getEquipment :: MonadPlayer m => EquipKey -> m (Maybe ObjectState)

Get equipped object

getCooldown :: MonadPlayer m => CooldownId -> m Bool

Get cooldown state

setCooldown :: MonadPlayer m => CooldownId -> Bool -> m ()

Set/unset cooldown

Currencies

registerCurrency :: (MonadCounter m, MonadDungeon m) => String -> String -> m CurrencyId

Register a currency

getCurrency :: MonadPlayer m => CurrencyId -> m Int

Get currency state

modifyCurrency :: MonadPlayer m => CurrencyId -> (Int -> Int) -> m ()

Modify currency state

Fight

damage :: DamageTarget -> Int -> ChattyDungeonM ()

Damage a target (no matter whether player or mob) without setting focus

focusOpponent :: ObjectId -> ChattyDungeonM ()

Focus an opponent

dealDamage :: Int -> ChattyDungeonM ()

Deal damage to an opponent. Real damage is influenced by random.

Masquerades

withRoom :: MonadDungeon m => NodeId -> RoomT m a -> m a

Run a function in the context of the given room.

withPlayer :: MonadDungeon m => PlayerId -> PlayerT (RoomT m) a -> m a

Run a function in the context of a given player

withObject :: MonadDungeon m => ObjectId -> ObjectT (RoomT m) a -> m a

Run a function in the context of a given object

Guardians

guardRoom :: MonadDungeon m => NodeId -> m () -> m ()

Only run the given function if the player is inside the also given room.

guardObject :: MonadDungeon m => ObjectId -> m () -> m ()

Only run the given function if the given object exists

guardObjectInRoom :: MonadDungeon m => ObjectId -> NodeId -> m () -> m ()

Only run the given function if the given object is in the also given room

guardObjectNotInRoom :: MonadDungeon m => ObjectId -> NodeId -> m () -> m ()

Only run the given function if the given object is not in the also given room

guardKindInRoom :: MonadDungeon m => KindId -> NodeId -> m () -> m ()

Only run the given function if an object of the given kind is in the also given room

guardKindNotInRoom :: MonadDungeon m => KindId -> NodeId -> m () -> m ()

Only run the given function if no object of the given kind is in the also given room