Game.LambdaHack.Server.HandleEffectM

Handle effects. They are most often caused by requests sent by clients but sometimes also caused by projectiles or periodically activated items.

Documentation

data UseResult

Constructors

UseDud

UseId

UseUp

Instances

Eq UseResult

Defined in Game.LambdaHack.Server.HandleEffectM

Methods

(==) :: UseResult -> UseResult -> Bool

(/=) :: UseResult -> UseResult -> Bool

Ord UseResult

Defined in Game.LambdaHack.Server.HandleEffectM

Methods

compare :: UseResult -> UseResult -> Ordering

(<) :: UseResult -> UseResult -> Bool

(<=) :: UseResult -> UseResult -> Bool

(>) :: UseResult -> UseResult -> Bool

(>=) :: UseResult -> UseResult -> Bool

max :: UseResult -> UseResult -> UseResult

min :: UseResult -> UseResult -> UseResult

data EffToUse

Constructors

EffBare

EffBareAndOnCombine

EffOnCombine

Instances

Eq EffToUse

Defined in Game.LambdaHack.Server.HandleEffectM

Methods

(==) :: EffToUse -> EffToUse -> Bool

(/=) :: EffToUse -> EffToUse -> Bool

data EffApplyFlags

Constructors

EffApplyFlags

Fields

• effToUse :: EffToUse
• effVoluntary :: Bool
• effUseAllCopies :: Bool
• effKineticPerformed :: Bool
• effActivation :: ActivationFlag
• effMayDestroy :: Bool

applyItem :: MonadServerAtomic m => ActorId -> ItemId -> CStore -> m ()

cutCalm :: MonadServerAtomic m => ActorId -> m ()

kineticEffectAndDestroy :: MonadServerAtomic m => EffApplyFlags -> ActorId -> ActorId -> ActorId -> ItemId -> Container -> m UseResult

effectAndDestroyAndAddKill :: MonadServerAtomic m => EffApplyFlags -> ActorId -> ActorId -> ActorId -> ItemId -> Container -> ItemFull -> m UseResult

itemEffectEmbedded :: MonadServerAtomic m => EffToUse -> Bool -> ActorId -> LevelId -> Point -> ItemId -> m UseResult

highestImpression :: MonadServerAtomic m => Actor -> m (Maybe (FactionId, Int))

dominateFidSfx :: MonadServerAtomic m => ActorId -> ActorId -> ItemId -> FactionId -> m Bool

dropAllEquippedItems :: MonadServerAtomic m => ActorId -> Actor -> m ()

Drop all actor's equipped items.

pickDroppable :: MonadStateRead m => Bool -> ActorId -> Actor -> m Container

consumeItems :: MonadServerAtomic m => ActorId -> EnumMap CStore ItemBag -> [(CStore, (ItemId, ItemFull))] -> m ()

dropCStoreItem :: MonadServerAtomic m => Bool -> Bool -> CStore -> ActorId -> Actor -> Int -> ItemId -> ItemQuant -> m UseResult

Drop a single actor's item (though possibly multiple copies). Note that if there are multiple copies, at most one explodes to avoid excessive carnage and UI clutter (let's say, the multiple explosions interfere with each other or perhaps larger quantities of explosives tend to be packaged more safely). Note also that OnSmash effects are activated even if item discharged.

Internal operations

applyKineticDamage :: MonadServerAtomic m => ActorId -> ActorId -> ItemId -> m Bool

refillHP :: MonadServerAtomic m => ActorId -> ActorId -> Int64 -> m ()

effectAndDestroy :: MonadServerAtomic m => EffApplyFlags -> ActorId -> ActorId -> ItemId -> Container -> ItemFull -> m UseResult

imperishableKit :: ActivationFlag -> ItemFull -> Bool

itemEffectDisco :: MonadServerAtomic m => EffApplyFlags -> ActorId -> ActorId -> ItemId -> ContentId ItemKind -> ItemKind -> Container -> [Effect] -> m UseResult

The source actor affects the target actor, with a given item. If any of the effects fires up, the item gets identified. Even using raw damage (beating the enemy with the magic wand, for example) identifies the item. This means a costly UpdDiscover is processed for each random timeout weapon hit and for most projectiles, but at least not for most explosion particles nor plain organs. And if not needed, the UpdDiscover are eventually not sent to clients. So, enemy missiles that hit us are no longer mysterious until picked up, which is for the better, because the client knows their charging status and so can generate accurate messages in the case when not recharged. This also means that thrown consumables in flasks sturdy enough to cause damage are always identified at hit, even if no effect activated. So throwing them at foes is a better identification method than applying.

Note that if we activate a durable non-passive item, e.g., a spiked shield, from the ground, it will get identified, which is perfectly fine, until we want to add sticky armor that can't be easily taken off (and, e.g., has some maluses).

effectSem :: MonadServerAtomic m => EffApplyFlags -> ActorId -> ActorId -> ItemId -> Container -> Effect -> m UseResult

Source actor affects target actor, with a given effect and it strength. Both actors are on the current level and can be the same actor. The item may or may not still be in the container.

effectBurn :: MonadServerAtomic m => Dice -> ActorId -> ActorId -> ItemId -> m UseResult

effectExplode :: MonadServerAtomic m => m () -> GroupName ItemKind -> ActorId -> ActorId -> Container -> m UseResult

effectRefillHP :: MonadServerAtomic m => Int -> ActorId -> ActorId -> ItemId -> m UseResult

effectRefillCalm :: MonadServerAtomic m => m () -> Int -> ActorId -> ActorId -> m UseResult

effectDominate :: MonadServerAtomic m => ActorId -> ActorId -> ItemId -> m UseResult

dominateFid :: MonadServerAtomic m => FactionId -> ActorId -> ActorId -> m ()

effectImpress :: MonadServerAtomic m => (Effect -> m UseResult) -> m () -> ActorId -> ActorId -> m UseResult

effectPutToSleep :: MonadServerAtomic m => m () -> ActorId -> m UseResult

effectYell :: MonadServerAtomic m => m () -> ActorId -> m UseResult

effectSummon :: MonadServerAtomic m => GroupName ItemKind -> Dice -> ItemId -> ActorId -> ActorId -> ActivationFlag -> m UseResult

effectAscend :: MonadServerAtomic m => (Effect -> m UseResult) -> m () -> Bool -> ActorId -> ActorId -> Container -> m UseResult

findStairExit :: MonadStateRead m => FactionId -> Bool -> LevelId -> Point -> m Point

switchLevels1 :: MonadServerAtomic m => (ActorId, Actor) -> m (Maybe ActorId)

switchLevels2 :: MonadServerAtomic m => LevelId -> Point -> (ActorId, Actor) -> Maybe Time -> Maybe Time -> Maybe ActorId -> m ()

effectEscape :: MonadServerAtomic m => m () -> ActorId -> ActorId -> m UseResult

The faction leaves the dungeon.

effectParalyze :: MonadServerAtomic m => m () -> Dice -> ActorId -> ActorId -> m UseResult

Advance target actor time by this many time clips. Not by actor moves, to hurt fast actors more.

paralyze :: MonadServerAtomic m => m () -> Dice -> ActorId -> ActorId -> m UseResult

effectParalyzeInWater :: MonadServerAtomic m => m () -> Dice -> ActorId -> ActorId -> m UseResult

Advance target actor time by this many time clips. Not by actor moves, to hurt fast actors more. Due to water, so resistable.

effectInsertMove :: MonadServerAtomic m => m () -> Dice -> ActorId -> ActorId -> m UseResult

Give target actor the given number of tenths of extra move. Don't give an absolute amount of time units, to benefit slow actors more.

effectTeleport :: MonadServerAtomic m => m () -> Dice -> ActorId -> ActorId -> m UseResult

Teleport the target actor. Note that projectiles can be teleported, too, for extra fun.

effectCreateItem :: MonadServerAtomic m => Maybe FactionId -> Maybe Int -> ActorId -> ActorId -> Maybe ItemId -> CStore -> GroupName ItemKind -> TimerDice -> m UseResult

effectDestroyItem :: MonadServerAtomic m => m () -> Int -> Int -> CStore -> ActorId -> GroupName ItemKind -> m UseResult

Make the target actor destroy items in a store from the given group. The item that caused the effect itself is *not* immune, because often the item needs to destroy itself, e.g., to model wear and tear. In such a case, the item may need to be identified, in a container, when it no longer exists, at least in the container. This is OK. Durable items are not immune, unlike the tools in ConsumeItems.

effectDropItem :: MonadServerAtomic m => m () -> ItemId -> Int -> Int -> CStore -> GroupName ItemKind -> ActorId -> m UseResult

Make the target actor drop items in a store from the given group. The item that caused the effect itself is immune (any copies).

effectConsumeItems :: MonadServerAtomic m => m () -> ItemId -> ActorId -> [(Int, GroupName ItemKind)] -> [(Int, GroupName ItemKind)] -> m UseResult

Make the target actor destroy the given items, if all present, or none at all, if any is missing. To be used in crafting. The item that caused the effect itself is not considered (any copies).

effectRecharge :: forall m. MonadServerAtomic m => Bool -> m () -> ItemId -> Int -> Dice -> ActorId -> m UseResult

effectPolyItem :: MonadServerAtomic m => m () -> ItemId -> ActorId -> m UseResult

effectRerollItem :: forall m. MonadServerAtomic m => m () -> ItemId -> ActorId -> m UseResult

effectDupItem :: MonadServerAtomic m => m () -> ItemId -> ActorId -> m UseResult

effectIdentify :: MonadServerAtomic m => m () -> ItemId -> ActorId -> m UseResult

identifyIid :: MonadServerAtomic m => ItemId -> Container -> ContentId ItemKind -> ItemKind -> m ()

effectDetect :: MonadServerAtomic m => m () -> DetectKind -> Int -> ActorId -> Container -> m UseResult

effectDetectX :: MonadServerAtomic m => DetectKind -> (Point -> Bool) -> ([Point] -> m Bool) -> m () -> Int -> ActorId -> m UseResult

effectSendFlying :: MonadServerAtomic m => m () -> ThrowMod -> ActorId -> ActorId -> Container -> Maybe Bool -> m UseResult

Send the target actor flying like a projectile. If the actors are adjacent, the vector is directed outwards, if no, inwards, if it's the same actor, boldpos is used, if it can't, a random outward vector of length 10 is picked.

sendFlyingVector :: MonadServerAtomic m => ActorId -> ActorId -> Container -> Maybe Bool -> m Vector

effectApplyPerfume :: MonadServerAtomic m => m () -> ActorId -> m UseResult

effectAtMostOneOf :: MonadServerAtomic m => (Effect -> m UseResult) -> [Effect] -> m UseResult

effectOneOf :: MonadServerAtomic m => (Effect -> m UseResult) -> [Effect] -> m UseResult

effectAndEffect :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> ActorId -> Effect -> Effect -> m UseResult

effectAndEffectSem :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> Effect -> Effect -> m UseResult

effectOrEffect :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> FactionId -> Effect -> Effect -> m UseResult

effectSeqEffect :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> [Effect] -> m UseResult

effectWhen :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> ActorId -> Condition -> Effect -> ActivationFlag -> m UseResult

effectUnless :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> ActorId -> Condition -> Effect -> ActivationFlag -> m UseResult

effectIfThenElse :: forall m. MonadServerAtomic m => (Effect -> m UseResult) -> ActorId -> Condition -> Effect -> Effect -> ActivationFlag -> m UseResult

effectVerbNoLonger :: MonadServerAtomic m => Bool -> m () -> ActorId -> m UseResult

effectVerbMsg :: MonadServerAtomic m => m () -> ActorId -> m UseResult

effectVerbMsgFail :: MonadServerAtomic m => m () -> ActorId -> m UseResult