{-# LANGUAGE TupleSections #-}
module Game.LambdaHack.Common.ActorState
( fidActorNotProjGlobalAssocs, actorAssocs, fidActorRegularAssocs
, fidActorRegularIds, foeRegularAssocs, foeRegularList
, friendRegularAssocs, friendRegularList, bagAssocs, bagAssocsK
, posToBig, posToBigAssoc, posToProjs, posToProjAssocs
, posToAids, posToAidAssocs
, calculateTotal, itemPrice, mergeItemQuant, findIid
, combinedGround, combinedOrgan, combinedEqp, combinedInv
, combinedItems, combinedFromLore
, getActorBody, getActorMaxSkills, actorCurrentSkills, canTraverse
, getCarriedAssocsAndTrunk, getCarriedIidCStore, getContainerBag
, getFloorBag, getEmbedBag, getBodyStoreBag
, mapActorItems_, getActorAssocs, getActorAssocsK
, memActor, getLocalTime, regenCalmDelta, actorInAmbient, canDeAmbientList
, dispEnemy, itemToFull, fullAssocs, kitAssocs
, getItemKindId, getIidKindId, getItemKind, getIidKind
, getItemKindIdServer, getIidKindIdServer, getItemKindServer, getIidKindServer
, lidFromC, posFromC, anyFoeAdj, adjacentBigAssocs, adjacentProjAssocs
, armorHurtBonus, inMelee
) where
import Prelude ()
import Game.LambdaHack.Core.Prelude
import qualified Data.EnumMap.Strict as EM
import qualified Data.EnumSet as ES
import Data.Int (Int64)
import GHC.Exts (inline)
import Game.LambdaHack.Common.Actor
import Game.LambdaHack.Common.Faction
import Game.LambdaHack.Common.Item
import Game.LambdaHack.Common.Kind
import Game.LambdaHack.Common.Level
import Game.LambdaHack.Common.Misc
import Game.LambdaHack.Common.State
import qualified Game.LambdaHack.Common.Tile as Tile
import Game.LambdaHack.Common.Time
import Game.LambdaHack.Common.Types
import Game.LambdaHack.Common.Vector
import qualified Game.LambdaHack.Content.ItemKind as IK
import Game.LambdaHack.Content.ModeKind
import qualified Game.LambdaHack.Content.TileKind as TK
import Game.LambdaHack.Common.Point
import qualified Game.LambdaHack.Definition.Ability as Ability
import Game.LambdaHack.Definition.Defs
fidActorNotProjGlobalAssocs :: FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs :: FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs fid :: FactionId
fid s :: State
s =
let f :: (ActorId, Actor) -> Bool
f (_, b :: Actor
b) = Bool -> Bool
not (Actor -> Bool
bproj Actor
b) Bool -> Bool -> Bool
&& Actor -> FactionId
bfid Actor
b FactionId -> FactionId -> Bool
forall a. Eq a => a -> a -> Bool
== FactionId
fid
in ((ActorId, Actor) -> Bool)
-> [(ActorId, Actor)] -> [(ActorId, Actor)]
forall a. (a -> Bool) -> [a] -> [a]
filter (ActorId, Actor) -> Bool
f ([(ActorId, Actor)] -> [(ActorId, Actor)])
-> [(ActorId, Actor)] -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ EnumMap ActorId Actor -> [(ActorId, Actor)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs (EnumMap ActorId Actor -> [(ActorId, Actor)])
-> EnumMap ActorId Actor -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ State -> EnumMap ActorId Actor
sactorD State
s
actorAssocs :: (FactionId -> Bool) -> LevelId -> State
-> [(ActorId, Actor)]
actorAssocs :: (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorAssocs p :: FactionId -> Bool
p lid :: LevelId
lid s :: State
s =
let f :: (ActorId, Actor) -> Bool
f (_, b :: Actor
b) = Actor -> LevelId
blid Actor
b LevelId -> LevelId -> Bool
forall a. Eq a => a -> a -> Bool
== LevelId
lid Bool -> Bool -> Bool
&& FactionId -> Bool
p (Actor -> FactionId
bfid Actor
b)
in ((ActorId, Actor) -> Bool)
-> [(ActorId, Actor)] -> [(ActorId, Actor)]
forall a. (a -> Bool) -> [a] -> [a]
filter (ActorId, Actor) -> Bool
f ([(ActorId, Actor)] -> [(ActorId, Actor)])
-> [(ActorId, Actor)] -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ EnumMap ActorId Actor -> [(ActorId, Actor)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs (EnumMap ActorId Actor -> [(ActorId, Actor)])
-> EnumMap ActorId Actor -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ State -> EnumMap ActorId Actor
sactorD State
s
actorRegularAssocs :: (FactionId -> Bool) -> LevelId -> State
-> [(ActorId, Actor)]
{-# INLINE actorRegularAssocs #-}
actorRegularAssocs :: (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs p :: FactionId -> Bool
p lid :: LevelId
lid s :: State
s =
let f :: (ActorId, Actor) -> Bool
f (_, b :: Actor
b) = Bool -> Bool
not (Actor -> Bool
bproj Actor
b) Bool -> Bool -> Bool
&& Actor -> LevelId
blid Actor
b LevelId -> LevelId -> Bool
forall a. Eq a => a -> a -> Bool
== LevelId
lid Bool -> Bool -> Bool
&& FactionId -> Bool
p (Actor -> FactionId
bfid Actor
b) Bool -> Bool -> Bool
&& Actor -> Int64
bhp Actor
b Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> 0
in ((ActorId, Actor) -> Bool)
-> [(ActorId, Actor)] -> [(ActorId, Actor)]
forall a. (a -> Bool) -> [a] -> [a]
filter (ActorId, Actor) -> Bool
f ([(ActorId, Actor)] -> [(ActorId, Actor)])
-> [(ActorId, Actor)] -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ EnumMap ActorId Actor -> [(ActorId, Actor)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs (EnumMap ActorId Actor -> [(ActorId, Actor)])
-> EnumMap ActorId Actor -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ State -> EnumMap ActorId Actor
sactorD State
s
fidActorRegularAssocs :: FactionId -> LevelId -> State -> [(ActorId, Actor)]
fidActorRegularAssocs :: FactionId -> LevelId -> State -> [(ActorId, Actor)]
fidActorRegularAssocs fid :: FactionId
fid = (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs (FactionId -> FactionId -> Bool
forall a. Eq a => a -> a -> Bool
== FactionId
fid)
fidActorRegularIds :: FactionId -> LevelId -> State -> [ActorId]
fidActorRegularIds :: FactionId -> LevelId -> State -> [ActorId]
fidActorRegularIds fid :: FactionId
fid lid :: LevelId
lid s :: State
s =
((ActorId, Actor) -> ActorId) -> [(ActorId, Actor)] -> [ActorId]
forall a b. (a -> b) -> [a] -> [b]
map (ActorId, Actor) -> ActorId
forall a b. (a, b) -> a
fst ([(ActorId, Actor)] -> [ActorId])
-> [(ActorId, Actor)] -> [ActorId]
forall a b. (a -> b) -> a -> b
$ (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs (FactionId -> FactionId -> Bool
forall a. Eq a => a -> a -> Bool
== FactionId
fid) LevelId
lid State
s
foeRegularAssocs :: FactionId -> LevelId -> State -> [(ActorId, Actor)]
foeRegularAssocs :: FactionId -> LevelId -> State -> [(ActorId, Actor)]
foeRegularAssocs fid :: FactionId
fid lid :: LevelId
lid s :: State
s =
let fact :: Faction
fact = (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! FactionId
fid) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Faction) -> State -> Faction
forall a b. (a -> b) -> a -> b
$ State
s
in (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs ((FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFoe FactionId
fid Faction
fact) LevelId
lid State
s
foeRegularList :: FactionId -> LevelId -> State -> [Actor]
foeRegularList :: FactionId -> LevelId -> State -> [Actor]
foeRegularList fid :: FactionId
fid lid :: LevelId
lid s :: State
s =
let fact :: Faction
fact = (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! FactionId
fid) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Faction) -> State -> Faction
forall a b. (a -> b) -> a -> b
$ State
s
in ((ActorId, Actor) -> Actor) -> [(ActorId, Actor)] -> [Actor]
forall a b. (a -> b) -> [a] -> [b]
map (ActorId, Actor) -> Actor
forall a b. (a, b) -> b
snd ([(ActorId, Actor)] -> [Actor]) -> [(ActorId, Actor)] -> [Actor]
forall a b. (a -> b) -> a -> b
$ (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs ((FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFoe FactionId
fid Faction
fact) LevelId
lid State
s
friendRegularAssocs :: FactionId -> LevelId -> State -> [(ActorId, Actor)]
friendRegularAssocs :: FactionId -> LevelId -> State -> [(ActorId, Actor)]
friendRegularAssocs fid :: FactionId
fid lid :: LevelId
lid s :: State
s =
let fact :: Faction
fact = (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! FactionId
fid) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Faction) -> State -> Faction
forall a b. (a -> b) -> a -> b
$ State
s
in (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs ((FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFriend FactionId
fid Faction
fact) LevelId
lid State
s
friendRegularList :: FactionId -> LevelId -> State -> [Actor]
friendRegularList :: FactionId -> LevelId -> State -> [Actor]
friendRegularList fid :: FactionId
fid lid :: LevelId
lid s :: State
s =
let fact :: Faction
fact = (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! FactionId
fid) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Faction) -> State -> Faction
forall a b. (a -> b) -> a -> b
$ State
s
in ((ActorId, Actor) -> Actor) -> [(ActorId, Actor)] -> [Actor]
forall a b. (a -> b) -> [a] -> [b]
map (ActorId, Actor) -> Actor
forall a b. (a, b) -> b
snd ([(ActorId, Actor)] -> [Actor]) -> [(ActorId, Actor)] -> [Actor]
forall a b. (a -> b) -> a -> b
$ (FactionId -> Bool) -> LevelId -> State -> [(ActorId, Actor)]
actorRegularAssocs ((FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFriend FactionId
fid Faction
fact) LevelId
lid State
s
bagAssocs :: State -> ItemBag -> [(ItemId, Item)]
bagAssocs :: State -> ItemBag -> [(ItemId, Item)]
bagAssocs s :: State
s bag :: ItemBag
bag =
let iidItem :: ItemId -> (ItemId, Item)
iidItem iid :: ItemId
iid = (ItemId
iid, ItemId -> State -> Item
getItemBody ItemId
iid State
s)
in (ItemId -> (ItemId, Item)) -> [ItemId] -> [(ItemId, Item)]
forall a b. (a -> b) -> [a] -> [b]
map ItemId -> (ItemId, Item)
iidItem ([ItemId] -> [(ItemId, Item)]) -> [ItemId] -> [(ItemId, Item)]
forall a b. (a -> b) -> a -> b
$ ItemBag -> [ItemId]
forall k a. Enum k => EnumMap k a -> [k]
EM.keys ItemBag
bag
bagAssocsK :: State -> ItemBag -> [(ItemId, (Item, ItemQuant))]
bagAssocsK :: State -> ItemBag -> [(ItemId, (Item, ItemQuant))]
bagAssocsK s :: State
s bag :: ItemBag
bag =
let iidItem :: (ItemId, ItemQuant) -> (ItemId, (Item, ItemQuant))
iidItem (iid :: ItemId
iid, kit :: ItemQuant
kit) = (ItemId
iid, (ItemId -> State -> Item
getItemBody ItemId
iid State
s, ItemQuant
kit))
in ((ItemId, ItemQuant) -> (ItemId, (Item, ItemQuant)))
-> [(ItemId, ItemQuant)] -> [(ItemId, (Item, ItemQuant))]
forall a b. (a -> b) -> [a] -> [b]
map (ItemId, ItemQuant) -> (ItemId, (Item, ItemQuant))
iidItem ([(ItemId, ItemQuant)] -> [(ItemId, (Item, ItemQuant))])
-> [(ItemId, ItemQuant)] -> [(ItemId, (Item, ItemQuant))]
forall a b. (a -> b) -> a -> b
$ ItemBag -> [(ItemId, ItemQuant)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs ItemBag
bag
posToBig :: Point -> LevelId -> State -> Maybe ActorId
posToBig :: Point -> LevelId -> State -> Maybe ActorId
posToBig pos :: Point
pos lid :: LevelId
lid s :: State
s = Point -> Level -> Maybe ActorId
posToBigLvl Point
pos (Level -> Maybe ActorId) -> Level -> Maybe ActorId
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
posToBigAssoc :: Point -> LevelId -> State -> Maybe (ActorId, Actor)
posToBigAssoc :: Point -> LevelId -> State -> Maybe (ActorId, Actor)
posToBigAssoc pos :: Point
pos lid :: LevelId
lid s :: State
s =
let maid :: Maybe ActorId
maid = Point -> Level -> Maybe ActorId
posToBigLvl Point
pos (Level -> Maybe ActorId) -> Level -> Maybe ActorId
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
in (ActorId -> (ActorId, Actor))
-> Maybe ActorId -> Maybe (ActorId, Actor)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\aid :: ActorId
aid -> (ActorId
aid, ActorId -> State -> Actor
getActorBody ActorId
aid State
s)) Maybe ActorId
maid
posToProjs :: Point -> LevelId -> State -> [ActorId]
posToProjs :: Point -> LevelId -> State -> [ActorId]
posToProjs pos :: Point
pos lid :: LevelId
lid s :: State
s = Point -> Level -> [ActorId]
posToProjsLvl Point
pos (Level -> [ActorId]) -> Level -> [ActorId]
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
posToProjAssocs :: Point -> LevelId -> State -> [(ActorId, Actor)]
posToProjAssocs :: Point -> LevelId -> State -> [(ActorId, Actor)]
posToProjAssocs pos :: Point
pos lid :: LevelId
lid s :: State
s =
let l :: [ActorId]
l = Point -> Level -> [ActorId]
posToProjsLvl Point
pos (Level -> [ActorId]) -> Level -> [ActorId]
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
in (ActorId -> (ActorId, Actor)) -> [ActorId] -> [(ActorId, Actor)]
forall a b. (a -> b) -> [a] -> [b]
map (\aid :: ActorId
aid -> (ActorId
aid, ActorId -> State -> Actor
getActorBody ActorId
aid State
s)) [ActorId]
l
posToAids :: Point -> LevelId -> State -> [ActorId]
posToAids :: Point -> LevelId -> State -> [ActorId]
posToAids pos :: Point
pos lid :: LevelId
lid s :: State
s = Point -> Level -> [ActorId]
posToAidsLvl Point
pos (Level -> [ActorId]) -> Level -> [ActorId]
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
posToAidAssocs :: Point -> LevelId -> State -> [(ActorId, Actor)]
posToAidAssocs :: Point -> LevelId -> State -> [(ActorId, Actor)]
posToAidAssocs pos :: Point
pos lid :: LevelId
lid s :: State
s =
let l :: [ActorId]
l = Point -> Level -> [ActorId]
posToAidsLvl Point
pos (Level -> [ActorId]) -> Level -> [ActorId]
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
in (ActorId -> (ActorId, Actor)) -> [ActorId] -> [(ActorId, Actor)]
forall a b. (a -> b) -> [a] -> [b]
map (\aid :: ActorId
aid -> (ActorId
aid, ActorId -> State -> Actor
getActorBody ActorId
aid State
s)) [ActorId]
l
calculateTotal :: FactionId -> State -> (ItemBag, Int)
calculateTotal :: FactionId -> State -> (ItemBag, Int)
calculateTotal fid :: FactionId
fid s :: State
s =
let bag :: ItemBag
bag = FactionId -> State -> ItemBag
combinedItems FactionId
fid State
s
items :: [(Item, Int)]
items = ((ItemId, ItemQuant) -> (Item, Int))
-> [(ItemId, ItemQuant)] -> [(Item, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (\(iid :: ItemId
iid, (k :: Int
k, _)) -> (ItemId -> State -> Item
getItemBody ItemId
iid State
s, Int
k)) ([(ItemId, ItemQuant)] -> [(Item, Int)])
-> [(ItemId, ItemQuant)] -> [(Item, Int)]
forall a b. (a -> b) -> a -> b
$ ItemBag -> [(ItemId, ItemQuant)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs ItemBag
bag
price :: (Item, Int) -> Int
price (item :: Item
item, k :: Int
k) = Int -> ItemKind -> Int
itemPrice Int
k (ItemKind -> Int) -> ItemKind -> Int
forall a b. (a -> b) -> a -> b
$ Item -> State -> ItemKind
getItemKind Item
item State
s
in (ItemBag
bag, [Int] -> Int
forall a. Num a => [a] -> a
sum ([Int] -> Int) -> [Int] -> Int
forall a b. (a -> b) -> a -> b
$ ((Item, Int) -> Int) -> [(Item, Int)] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Item, Int) -> Int
price [(Item, Int)]
items)
itemPrice :: Int -> IK.ItemKind -> Int
itemPrice :: Int -> ItemKind -> Int
itemPrice jcount :: Int
jcount itemKind :: ItemKind
itemKind = case GroupName ItemKind -> [(GroupName ItemKind, Int)] -> Maybe Int
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup "valuable" ([(GroupName ItemKind, Int)] -> Maybe Int)
-> [(GroupName ItemKind, Int)] -> Maybe Int
forall a b. (a -> b) -> a -> b
$ ItemKind -> [(GroupName ItemKind, Int)]
IK.ifreq ItemKind
itemKind of
Just k :: Int
k -> Int
jcount Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
k
Nothing -> 0
mergeItemQuant :: ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant :: ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant (k2 :: Int
k2, it2 :: ItemTimer
it2) (k1 :: Int
k1, it1 :: ItemTimer
it1) = (Int
k1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
k2, ItemTimer
it1 ItemTimer -> ItemTimer -> ItemTimer
forall a. [a] -> [a] -> [a]
++ ItemTimer
it2)
findIid :: ActorId -> FactionId -> ItemId -> State
-> [(ActorId, (Actor, CStore))]
findIid :: ActorId
-> FactionId -> ItemId -> State -> [(ActorId, (Actor, CStore))]
findIid leader :: ActorId
leader fid :: FactionId
fid iid :: ItemId
iid s :: State
s =
let actors :: [(ActorId, Actor)]
actors = FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs FactionId
fid State
s
itemsOfActor :: (ActorId, Actor) -> [(ItemId, (ActorId, (Actor, CStore)))]
itemsOfActor (aid :: ActorId
aid, b :: Actor
b) =
let itemsOfCStore :: CStore -> [(ItemId, (ActorId, (Actor, CStore)))]
itemsOfCStore store :: CStore
store =
let bag :: ItemBag
bag = Actor -> CStore -> State -> ItemBag
getBodyStoreBag Actor
b CStore
store State
s
in (ItemId -> (ItemId, (ActorId, (Actor, CStore))))
-> [ItemId] -> [(ItemId, (ActorId, (Actor, CStore)))]
forall a b. (a -> b) -> [a] -> [b]
map (\iid2 :: ItemId
iid2 -> (ItemId
iid2, (ActorId
aid, (Actor
b, CStore
store)))) (ItemBag -> [ItemId]
forall k a. Enum k => EnumMap k a -> [k]
EM.keys ItemBag
bag)
stores :: [CStore]
stores = [CStore
CInv, CStore
CEqp, CStore
COrgan] [CStore] -> [CStore] -> [CStore]
forall a. [a] -> [a] -> [a]
++ [CStore
CSha | ActorId
aid ActorId -> ActorId -> Bool
forall a. Eq a => a -> a -> Bool
== ActorId
leader]
in (CStore -> [(ItemId, (ActorId, (Actor, CStore)))])
-> [CStore] -> [(ItemId, (ActorId, (Actor, CStore)))]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap CStore -> [(ItemId, (ActorId, (Actor, CStore)))]
itemsOfCStore [CStore]
stores
items :: [(ItemId, (ActorId, (Actor, CStore)))]
items = ((ActorId, Actor) -> [(ItemId, (ActorId, (Actor, CStore)))])
-> [(ActorId, Actor)] -> [(ItemId, (ActorId, (Actor, CStore)))]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (ActorId, Actor) -> [(ItemId, (ActorId, (Actor, CStore)))]
itemsOfActor [(ActorId, Actor)]
actors
in ((ItemId, (ActorId, (Actor, CStore)))
-> (ActorId, (Actor, CStore)))
-> [(ItemId, (ActorId, (Actor, CStore)))]
-> [(ActorId, (Actor, CStore))]
forall a b. (a -> b) -> [a] -> [b]
map (ItemId, (ActorId, (Actor, CStore))) -> (ActorId, (Actor, CStore))
forall a b. (a, b) -> b
snd ([(ItemId, (ActorId, (Actor, CStore)))]
-> [(ActorId, (Actor, CStore))])
-> [(ItemId, (ActorId, (Actor, CStore)))]
-> [(ActorId, (Actor, CStore))]
forall a b. (a -> b) -> a -> b
$ ((ItemId, (ActorId, (Actor, CStore))) -> Bool)
-> [(ItemId, (ActorId, (Actor, CStore)))]
-> [(ItemId, (ActorId, (Actor, CStore)))]
forall a. (a -> Bool) -> [a] -> [a]
filter ((ItemId -> ItemId -> Bool
forall a. Eq a => a -> a -> Bool
== ItemId
iid) (ItemId -> Bool)
-> ((ItemId, (ActorId, (Actor, CStore))) -> ItemId)
-> (ItemId, (ActorId, (Actor, CStore)))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ItemId, (ActorId, (Actor, CStore))) -> ItemId
forall a b. (a, b) -> a
fst) [(ItemId, (ActorId, (Actor, CStore)))]
items
combinedGround :: FactionId -> State -> ItemBag
combinedGround :: FactionId -> State -> ItemBag
combinedGround fid :: FactionId
fid s :: State
s =
let bs :: [(ActorId, Actor)]
bs = (FactionId -> State -> [(ActorId, Actor)])
-> FactionId -> State -> [(ActorId, Actor)]
forall a. a -> a
inline FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs FactionId
fid State
s
in (ItemQuant -> ItemQuant -> ItemQuant) -> [ItemBag] -> ItemBag
forall a k. (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
EM.unionsWith ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant
([ItemBag] -> ItemBag) -> [ItemBag] -> ItemBag
forall a b. (a -> b) -> a -> b
$ ((ActorId, Actor) -> ItemBag) -> [(ActorId, Actor)] -> [ItemBag]
forall a b. (a -> b) -> [a] -> [b]
map (\(_, b :: Actor
b) -> LevelId -> Point -> State -> ItemBag
getFloorBag (Actor -> LevelId
blid Actor
b) (Actor -> Point
bpos Actor
b) State
s) [(ActorId, Actor)]
bs
combinedOrgan :: FactionId -> State -> ItemBag
combinedOrgan :: FactionId -> State -> ItemBag
combinedOrgan fid :: FactionId
fid s :: State
s =
let bs :: [(ActorId, Actor)]
bs = (FactionId -> State -> [(ActorId, Actor)])
-> FactionId -> State -> [(ActorId, Actor)]
forall a. a -> a
inline FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs FactionId
fid State
s
in (ItemQuant -> ItemQuant -> ItemQuant) -> [ItemBag] -> ItemBag
forall a k. (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
EM.unionsWith ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant ([ItemBag] -> ItemBag) -> [ItemBag] -> ItemBag
forall a b. (a -> b) -> a -> b
$ ((ActorId, Actor) -> ItemBag) -> [(ActorId, Actor)] -> [ItemBag]
forall a b. (a -> b) -> [a] -> [b]
map (Actor -> ItemBag
borgan (Actor -> ItemBag)
-> ((ActorId, Actor) -> Actor) -> (ActorId, Actor) -> ItemBag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ActorId, Actor) -> Actor
forall a b. (a, b) -> b
snd) [(ActorId, Actor)]
bs
combinedEqp :: FactionId -> State -> ItemBag
combinedEqp :: FactionId -> State -> ItemBag
combinedEqp fid :: FactionId
fid s :: State
s =
let bs :: [(ActorId, Actor)]
bs = (FactionId -> State -> [(ActorId, Actor)])
-> FactionId -> State -> [(ActorId, Actor)]
forall a. a -> a
inline FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs FactionId
fid State
s
in (ItemQuant -> ItemQuant -> ItemQuant) -> [ItemBag] -> ItemBag
forall a k. (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
EM.unionsWith ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant ([ItemBag] -> ItemBag) -> [ItemBag] -> ItemBag
forall a b. (a -> b) -> a -> b
$ ((ActorId, Actor) -> ItemBag) -> [(ActorId, Actor)] -> [ItemBag]
forall a b. (a -> b) -> [a] -> [b]
map (Actor -> ItemBag
beqp (Actor -> ItemBag)
-> ((ActorId, Actor) -> Actor) -> (ActorId, Actor) -> ItemBag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ActorId, Actor) -> Actor
forall a b. (a, b) -> b
snd) [(ActorId, Actor)]
bs
combinedInv :: FactionId -> State -> ItemBag
combinedInv :: FactionId -> State -> ItemBag
combinedInv fid :: FactionId
fid s :: State
s =
let bs :: [(ActorId, Actor)]
bs = (FactionId -> State -> [(ActorId, Actor)])
-> FactionId -> State -> [(ActorId, Actor)]
forall a. a -> a
inline FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs FactionId
fid State
s
in (ItemQuant -> ItemQuant -> ItemQuant) -> [ItemBag] -> ItemBag
forall a k. (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
EM.unionsWith ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant ([ItemBag] -> ItemBag) -> [ItemBag] -> ItemBag
forall a b. (a -> b) -> a -> b
$ ((ActorId, Actor) -> ItemBag) -> [(ActorId, Actor)] -> [ItemBag]
forall a b. (a -> b) -> [a] -> [b]
map (Actor -> ItemBag
binv (Actor -> ItemBag)
-> ((ActorId, Actor) -> Actor) -> (ActorId, Actor) -> ItemBag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ActorId, Actor) -> Actor
forall a b. (a, b) -> b
snd) [(ActorId, Actor)]
bs
combinedItems :: FactionId -> State -> ItemBag
combinedItems :: FactionId -> State -> ItemBag
combinedItems fid :: FactionId
fid s :: State
s =
let shaBag :: ItemBag
shaBag = Faction -> ItemBag
gsha (Faction -> ItemBag) -> Faction -> ItemBag
forall a b. (a -> b) -> a -> b
$ State -> EnumMap FactionId Faction
sfactionD State
s EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! FactionId
fid
bs :: [Actor]
bs = ((ActorId, Actor) -> Actor) -> [(ActorId, Actor)] -> [Actor]
forall a b. (a -> b) -> [a] -> [b]
map (ActorId, Actor) -> Actor
forall a b. (a, b) -> b
snd ([(ActorId, Actor)] -> [Actor]) -> [(ActorId, Actor)] -> [Actor]
forall a b. (a -> b) -> a -> b
$ (FactionId -> State -> [(ActorId, Actor)])
-> FactionId -> State -> [(ActorId, Actor)]
forall a. a -> a
inline FactionId -> State -> [(ActorId, Actor)]
fidActorNotProjGlobalAssocs FactionId
fid State
s
in (ItemQuant -> ItemQuant -> ItemQuant) -> [ItemBag] -> ItemBag
forall a k. (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
EM.unionsWith ItemQuant -> ItemQuant -> ItemQuant
mergeItemQuant ([ItemBag] -> ItemBag) -> [ItemBag] -> ItemBag
forall a b. (a -> b) -> a -> b
$ (Actor -> ItemBag) -> [Actor] -> [ItemBag]
forall a b. (a -> b) -> [a] -> [b]
map Actor -> ItemBag
binv [Actor]
bs [ItemBag] -> [ItemBag] -> [ItemBag]
forall a. [a] -> [a] -> [a]
++ (Actor -> ItemBag) -> [Actor] -> [ItemBag]
forall a b. (a -> b) -> [a] -> [b]
map Actor -> ItemBag
beqp [Actor]
bs [ItemBag] -> [ItemBag] -> [ItemBag]
forall a. [a] -> [a] -> [a]
++ [ItemBag
shaBag]
combinedFromLore :: SLore -> FactionId -> State -> ItemBag
combinedFromLore :: SLore -> FactionId -> State -> ItemBag
combinedFromLore slore :: SLore
slore fid :: FactionId
fid s :: State
s = case SLore
slore of
SItem -> FactionId -> State -> ItemBag
combinedItems FactionId
fid State
s
SOrgan -> FactionId -> State -> ItemBag
combinedOrgan FactionId
fid State
s
STrunk -> FactionId -> State -> ItemBag
combinedOrgan FactionId
fid State
s
SCondition -> FactionId -> State -> ItemBag
combinedOrgan FactionId
fid State
s
SBlast -> ItemBag
forall k a. EnumMap k a
EM.empty
SEmbed -> ItemBag
forall k a. EnumMap k a
EM.empty
getActorBody :: ActorId -> State -> Actor
{-# INLINE getActorBody #-}
getActorBody :: ActorId -> State -> Actor
getActorBody aid :: ActorId
aid s :: State
s = State -> EnumMap ActorId Actor
sactorD State
s EnumMap ActorId Actor -> ActorId -> Actor
forall k a. Enum k => EnumMap k a -> k -> a
EM.! ActorId
aid
getActorMaxSkills :: ActorId -> State -> Ability.Skills
{-# INLINE getActorMaxSkills #-}
getActorMaxSkills :: ActorId -> State -> Skills
getActorMaxSkills aid :: ActorId
aid s :: State
s = State -> ActorMaxSkills
sactorMaxSkills State
s ActorMaxSkills -> ActorId -> Skills
forall k a. Enum k => EnumMap k a -> k -> a
EM.! ActorId
aid
actorCurrentSkills :: Maybe ActorId -> ActorId -> State -> Ability.Skills
actorCurrentSkills :: Maybe ActorId -> ActorId -> State -> Skills
actorCurrentSkills mleader :: Maybe ActorId
mleader aid :: ActorId
aid s :: State
s =
let body :: Actor
body = ActorId -> State -> Actor
getActorBody ActorId
aid State
s
actorMaxSk :: Skills
actorMaxSk = ActorId -> State -> Skills
getActorMaxSkills ActorId
aid State
s
player :: Player
player = Faction -> Player
gplayer (Faction -> Player) -> (State -> Faction) -> State -> Player
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> FactionId
bfid Actor
body) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Player) -> State -> Player
forall a b. (a -> b) -> a -> b
$ State
s
skillsFromTactic :: Skills
skillsFromTactic = Tactic -> Skills
Ability.tacticSkills (Tactic -> Skills) -> Tactic -> Skills
forall a b. (a -> b) -> a -> b
$ Player -> Tactic
ftactic Player
player
factionSkills :: Skills
factionSkills
| ActorId -> Maybe ActorId
forall a. a -> Maybe a
Just ActorId
aid Maybe ActorId -> Maybe ActorId -> Bool
forall a. Eq a => a -> a -> Bool
== Maybe ActorId
mleader = Skills
Ability.zeroSkills
| Bool
otherwise = Player -> Skills
fskillsOther Player
player Skills -> Skills -> Skills
`Ability.addSkills` Skills
skillsFromTactic
in Skills
actorMaxSk Skills -> Skills -> Skills
`Ability.addSkills` Skills
factionSkills
canTraverse :: ActorId -> State -> Bool
canTraverse :: ActorId -> State -> Bool
canTraverse aid :: ActorId
aid s :: State
s =
let actorMaxSk :: Skills
actorMaxSk = ActorId -> State -> Skills
getActorMaxSkills ActorId
aid State
s
in Skill -> Skills -> Int
Ability.getSk Skill
Ability.SkMove Skills
actorMaxSk Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0
Bool -> Bool -> Bool
&& Skill -> Skills -> Int
Ability.getSk Skill
Ability.SkAlter Skills
actorMaxSk Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Word8 -> Int
forall a. Enum a => a -> Int
fromEnum Word8
TK.talterForStairs
getCarriedAssocsAndTrunk :: Actor -> State -> [(ItemId, Item)]
getCarriedAssocsAndTrunk :: Actor -> State -> [(ItemId, Item)]
getCarriedAssocsAndTrunk b :: Actor
b s :: State
s =
let trunk :: ItemBag
trunk = ItemId -> ItemQuant -> ItemBag
forall k a. Enum k => k -> a -> EnumMap k a
EM.singleton (Actor -> ItemId
btrunk Actor
b) (1, [])
in State -> ItemBag -> [(ItemId, Item)]
bagAssocs State
s (ItemBag -> [(ItemId, Item)]) -> ItemBag -> [(ItemId, Item)]
forall a b. (a -> b) -> a -> b
$ (ItemQuant -> ItemQuant -> ItemQuant) -> [ItemBag] -> ItemBag
forall a k. (a -> a -> a) -> [EnumMap k a] -> EnumMap k a
EM.unionsWith ItemQuant -> ItemQuant -> ItemQuant
forall a b. a -> b -> a
const [Actor -> ItemBag
binv Actor
b, Actor -> ItemBag
beqp Actor
b, Actor -> ItemBag
borgan Actor
b, ItemBag
trunk]
getCarriedIidCStore :: Actor -> [(ItemId, CStore)]
getCarriedIidCStore :: Actor -> [(ItemId, CStore)]
getCarriedIidCStore b :: Actor
b =
let bagCarried :: (t, EnumMap t a) -> [(t, t)]
bagCarried (cstore :: t
cstore, bag :: EnumMap t a
bag) = (t -> (t, t)) -> [t] -> [(t, t)]
forall a b. (a -> b) -> [a] -> [b]
map (,t
cstore) ([t] -> [(t, t)]) -> [t] -> [(t, t)]
forall a b. (a -> b) -> a -> b
$ EnumMap t a -> [t]
forall k a. Enum k => EnumMap k a -> [k]
EM.keys EnumMap t a
bag
in ((CStore, ItemBag) -> [(ItemId, CStore)])
-> [(CStore, ItemBag)] -> [(ItemId, CStore)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (CStore, ItemBag) -> [(ItemId, CStore)]
forall t t a. Enum t => (t, EnumMap t a) -> [(t, t)]
bagCarried [(CStore
CInv, Actor -> ItemBag
binv Actor
b), (CStore
CEqp, Actor -> ItemBag
beqp Actor
b), (CStore
COrgan, Actor -> ItemBag
borgan Actor
b)]
getContainerBag :: Container -> State -> ItemBag
getContainerBag :: Container -> State -> ItemBag
getContainerBag c :: Container
c s :: State
s = case Container
c of
CFloor lid :: LevelId
lid p :: Point
p -> LevelId -> Point -> State -> ItemBag
getFloorBag LevelId
lid Point
p State
s
CEmbed lid :: LevelId
lid p :: Point
p -> LevelId -> Point -> State -> ItemBag
getEmbedBag LevelId
lid Point
p State
s
CActor aid :: ActorId
aid cstore :: CStore
cstore -> let b :: Actor
b = ActorId -> State -> Actor
getActorBody ActorId
aid State
s
in Actor -> CStore -> State -> ItemBag
getBodyStoreBag Actor
b CStore
cstore State
s
CTrunk{} -> ItemBag
forall k a. EnumMap k a
EM.empty
getFloorBag :: LevelId -> Point -> State -> ItemBag
getFloorBag :: LevelId -> Point -> State -> ItemBag
getFloorBag lid :: LevelId
lid p :: Point
p s :: State
s = ItemBag -> Point -> EnumMap Point ItemBag -> ItemBag
forall k a. Enum k => a -> k -> EnumMap k a -> a
EM.findWithDefault ItemBag
forall k a. EnumMap k a
EM.empty Point
p
(EnumMap Point ItemBag -> ItemBag)
-> EnumMap Point ItemBag -> ItemBag
forall a b. (a -> b) -> a -> b
$ Level -> EnumMap Point ItemBag
lfloor (State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid)
getEmbedBag :: LevelId -> Point -> State -> ItemBag
getEmbedBag :: LevelId -> Point -> State -> ItemBag
getEmbedBag lid :: LevelId
lid p :: Point
p s :: State
s = ItemBag -> Point -> EnumMap Point ItemBag -> ItemBag
forall k a. Enum k => a -> k -> EnumMap k a -> a
EM.findWithDefault ItemBag
forall k a. EnumMap k a
EM.empty Point
p
(EnumMap Point ItemBag -> ItemBag)
-> EnumMap Point ItemBag -> ItemBag
forall a b. (a -> b) -> a -> b
$ Level -> EnumMap Point ItemBag
lembed (State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid)
getBodyStoreBag :: Actor -> CStore -> State -> ItemBag
getBodyStoreBag :: Actor -> CStore -> State -> ItemBag
getBodyStoreBag b :: Actor
b cstore :: CStore
cstore s :: State
s =
case CStore
cstore of
CGround -> LevelId -> Point -> State -> ItemBag
getFloorBag (Actor -> LevelId
blid Actor
b) (Actor -> Point
bpos Actor
b) State
s
COrgan -> Actor -> ItemBag
borgan Actor
b
CEqp -> Actor -> ItemBag
beqp Actor
b
CInv -> Actor -> ItemBag
binv Actor
b
CSha -> Faction -> ItemBag
gsha (Faction -> ItemBag) -> Faction -> ItemBag
forall a b. (a -> b) -> a -> b
$ State -> EnumMap FactionId Faction
sfactionD State
s EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> FactionId
bfid Actor
b
mapActorItems_ :: Monad m
=> (CStore -> ItemId -> ItemQuant -> m a) -> Actor -> State
-> m ()
mapActorItems_ :: (CStore -> ItemId -> ItemQuant -> m a) -> Actor -> State -> m ()
mapActorItems_ f :: CStore -> ItemId -> ItemQuant -> m a
f b :: Actor
b s :: State
s = do
let notProcessed :: [CStore]
notProcessed = [CStore
CGround]
sts :: [CStore]
sts = [CStore
forall a. Bounded a => a
minBound..CStore
forall a. Bounded a => a
maxBound] [CStore] -> [CStore] -> [CStore]
forall a. Eq a => [a] -> [a] -> [a]
\\ [CStore]
notProcessed
g :: CStore -> m ()
g cstore :: CStore
cstore = do
let bag :: ItemBag
bag = Actor -> CStore -> State -> ItemBag
getBodyStoreBag Actor
b CStore
cstore State
s
((ItemId, ItemQuant) -> m a) -> [(ItemId, ItemQuant)] -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((ItemId -> ItemQuant -> m a) -> (ItemId, ItemQuant) -> m a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((ItemId -> ItemQuant -> m a) -> (ItemId, ItemQuant) -> m a)
-> (ItemId -> ItemQuant -> m a) -> (ItemId, ItemQuant) -> m a
forall a b. (a -> b) -> a -> b
$ CStore -> ItemId -> ItemQuant -> m a
f CStore
cstore) ([(ItemId, ItemQuant)] -> m ()) -> [(ItemId, ItemQuant)] -> m ()
forall a b. (a -> b) -> a -> b
$ ItemBag -> [(ItemId, ItemQuant)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs ItemBag
bag
(CStore -> m ()) -> [CStore] -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ CStore -> m ()
g [CStore]
sts
getActorAssocs :: ActorId -> CStore -> State -> [(ItemId, Item)]
getActorAssocs :: ActorId -> CStore -> State -> [(ItemId, Item)]
getActorAssocs aid :: ActorId
aid cstore :: CStore
cstore s :: State
s =
let b :: Actor
b = ActorId -> State -> Actor
getActorBody ActorId
aid State
s
in State -> ItemBag -> [(ItemId, Item)]
bagAssocs State
s (ItemBag -> [(ItemId, Item)]) -> ItemBag -> [(ItemId, Item)]
forall a b. (a -> b) -> a -> b
$ Actor -> CStore -> State -> ItemBag
getBodyStoreBag Actor
b CStore
cstore State
s
getActorAssocsK :: ActorId -> CStore -> State -> [(ItemId, (Item, ItemQuant))]
getActorAssocsK :: ActorId -> CStore -> State -> [(ItemId, (Item, ItemQuant))]
getActorAssocsK aid :: ActorId
aid cstore :: CStore
cstore s :: State
s =
let b :: Actor
b = ActorId -> State -> Actor
getActorBody ActorId
aid State
s
in State -> ItemBag -> [(ItemId, (Item, ItemQuant))]
bagAssocsK State
s (ItemBag -> [(ItemId, (Item, ItemQuant))])
-> ItemBag -> [(ItemId, (Item, ItemQuant))]
forall a b. (a -> b) -> a -> b
$ Actor -> CStore -> State -> ItemBag
getBodyStoreBag Actor
b CStore
cstore State
s
memActor :: ActorId -> LevelId -> State -> Bool
memActor :: ActorId -> LevelId -> State -> Bool
memActor aid :: ActorId
aid lid :: LevelId
lid s :: State
s =
Bool -> (Actor -> Bool) -> Maybe Actor -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False ((LevelId -> LevelId -> Bool
forall a. Eq a => a -> a -> Bool
== LevelId
lid) (LevelId -> Bool) -> (Actor -> LevelId) -> Actor -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Actor -> LevelId
blid) (Maybe Actor -> Bool) -> Maybe Actor -> Bool
forall a b. (a -> b) -> a -> b
$ ActorId -> EnumMap ActorId Actor -> Maybe Actor
forall k a. Enum k => k -> EnumMap k a -> Maybe a
EM.lookup ActorId
aid (EnumMap ActorId Actor -> Maybe Actor)
-> EnumMap ActorId Actor -> Maybe Actor
forall a b. (a -> b) -> a -> b
$ State -> EnumMap ActorId Actor
sactorD State
s
getLocalTime :: LevelId -> State -> Time
getLocalTime :: LevelId -> State -> Time
getLocalTime lid :: LevelId
lid s :: State
s = Level -> Time
ltime (Level -> Time) -> Level -> Time
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! LevelId
lid
regenCalmDelta :: ActorId -> Actor -> State -> Int64
regenCalmDelta :: ActorId -> Actor -> State -> Int64
regenCalmDelta aid :: ActorId
aid body :: Actor
body s :: State
s =
let calmIncr :: Int64
calmIncr = Int64
oneM
actorMaxSk :: Skills
actorMaxSk = ActorId -> State -> Skills
getActorMaxSkills ActorId
aid State
s
maxDeltaCalm :: Int64
maxDeltaCalm = Int -> Int64
xM (Skill -> Skills -> Int
Ability.getSk Skill
Ability.SkMaxCalm Skills
actorMaxSk)
Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Actor -> Int64
bcalm Actor
body
fact :: Faction
fact = (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> FactionId
bfid Actor
body) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Faction) -> State -> Faction
forall a b. (a -> b) -> a -> b
$ State
s
isHeardFoe :: (Point, ActorId) -> Bool
isHeardFoe (!Point
p, aid2 :: ActorId
aid2) =
let b :: Actor
b = ActorId -> State -> Actor
getActorBody ActorId
aid2 State
s
in (Point -> Point -> Int) -> Point -> Point -> Int
forall a. a -> a
inline Point -> Point -> Int
chessDist Point
p (Actor -> Point
bpos Actor
body) Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= 3
Bool -> Bool -> Bool
&& Bool -> Bool
not (Actor -> Bool
actorWaitsOrSleeps Actor
b)
Bool -> Bool -> Bool
&& (FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFoe (Actor -> FactionId
bfid Actor
body) Faction
fact (Actor -> FactionId
bfid Actor
b)
actorRelaxed :: Bool
actorRelaxed = ResDelta -> Bool
deltaBenign (ResDelta -> Bool) -> ResDelta -> Bool
forall a b. (a -> b) -> a -> b
$ Actor -> ResDelta
bcalmDelta Actor
body
actorWasRelaxed :: Bool
actorWasRelaxed = ResDelta -> Bool
deltaWasBenign (ResDelta -> Bool) -> ResDelta -> Bool
forall a b. (a -> b) -> a -> b
$ Actor -> ResDelta
bcalmDelta Actor
body
in if | Bool -> Bool
not Bool
actorRelaxed -> 0
| ((Point, ActorId) -> Bool) -> [(Point, ActorId)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (Point, ActorId) -> Bool
isHeardFoe ([(Point, ActorId)] -> Bool) -> [(Point, ActorId)] -> Bool
forall a b. (a -> b) -> a -> b
$ EnumMap Point ActorId -> [(Point, ActorId)]
forall k a. Enum k => EnumMap k a -> [(k, a)]
EM.assocs (EnumMap Point ActorId -> [(Point, ActorId)])
-> EnumMap Point ActorId -> [(Point, ActorId)]
forall a b. (a -> b) -> a -> b
$ Level -> EnumMap Point ActorId
lbig (Level -> EnumMap Point ActorId) -> Level -> EnumMap Point ActorId
forall a b. (a -> b) -> a -> b
$ State -> Dungeon
sdungeon State
s Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> LevelId
blid Actor
body ->
Int64
minusM1
| Bool
actorWasRelaxed -> Int64 -> Int64 -> Int64
forall a. Ord a => a -> a -> a
min Int64
calmIncr (Int64 -> Int64 -> Int64
forall a. Ord a => a -> a -> a
max 0 Int64
maxDeltaCalm)
| Bool
otherwise -> 0
actorInAmbient :: Actor -> State -> Bool
actorInAmbient :: Actor -> State -> Bool
actorInAmbient b :: Actor
b s :: State
s =
let lvl :: Level
lvl = (Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> LevelId
blid Actor
b) (Dungeon -> Level) -> (State -> Dungeon) -> State -> Level
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Dungeon
sdungeon (State -> Level) -> State -> Level
forall a b. (a -> b) -> a -> b
$ State
s
in TileSpeedup -> ContentId TileKind -> Bool
Tile.isLit (COps -> TileSpeedup
coTileSpeedup (COps -> TileSpeedup) -> COps -> TileSpeedup
forall a b. (a -> b) -> a -> b
$ State -> COps
scops State
s) (Level
lvl Level -> Point -> ContentId TileKind
`at` Actor -> Point
bpos Actor
b)
canDeAmbientList :: Actor -> State -> [Point]
canDeAmbientList :: Actor -> State -> [Point]
canDeAmbientList b :: Actor
b s :: State
s =
let COps{TileSpeedup
coTileSpeedup :: TileSpeedup
coTileSpeedup :: COps -> TileSpeedup
coTileSpeedup} = State -> COps
scops State
s
lvl :: Level
lvl = (Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> LevelId
blid Actor
b) (Dungeon -> Level) -> (State -> Dungeon) -> State -> Level
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Dungeon
sdungeon (State -> Level) -> State -> Level
forall a b. (a -> b) -> a -> b
$ State
s
posDeAmbient :: Point -> Bool
posDeAmbient p :: Point
p =
let t :: ContentId TileKind
t = Level
lvl Level -> Point -> ContentId TileKind
`at` Point
p
in TileSpeedup -> ContentId TileKind -> Bool
Tile.isWalkable TileSpeedup
coTileSpeedup ContentId TileKind
t
Bool -> Bool -> Bool
&& Bool -> Bool
not (TileSpeedup -> ContentId TileKind -> Bool
Tile.isLit TileSpeedup
coTileSpeedup ContentId TileKind
t)
in if TileSpeedup -> ContentId TileKind -> Bool
Tile.isLit TileSpeedup
coTileSpeedup (Level
lvl Level -> Point -> ContentId TileKind
`at` Actor -> Point
bpos Actor
b)
then (Point -> Bool) -> [Point] -> [Point]
forall a. (a -> Bool) -> [a] -> [a]
filter Point -> Bool
posDeAmbient (Point -> [Point]
vicinityUnsafe (Point -> [Point]) -> Point -> [Point]
forall a b. (a -> b) -> a -> b
$ Actor -> Point
bpos Actor
b)
else []
dispEnemy :: ActorId -> ActorId -> Ability.Skills -> State -> Bool
dispEnemy :: ActorId -> ActorId -> Skills -> State -> Bool
dispEnemy source :: ActorId
source target :: ActorId
target actorMaxSk :: Skills
actorMaxSk s :: State
s =
let hasBackup :: Actor -> Bool
hasBackup b :: Actor
b =
let adjAssocs :: [(ActorId, Actor)]
adjAssocs = Actor -> State -> [(ActorId, Actor)]
adjacentBigAssocs Actor
b State
s
fact :: Faction
fact = State -> EnumMap FactionId Faction
sfactionD State
s EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> FactionId
bfid Actor
b
friend :: (ActorId, Actor) -> Bool
friend (_, b2 :: Actor
b2) = FactionId -> Faction -> FactionId -> Bool
isFriend (Actor -> FactionId
bfid Actor
b) Faction
fact (Actor -> FactionId
bfid Actor
b2) Bool -> Bool -> Bool
&& Actor -> Int64
bhp Actor
b2 Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> 0
in ((ActorId, Actor) -> Bool) -> [(ActorId, Actor)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (ActorId, Actor) -> Bool
friend [(ActorId, Actor)]
adjAssocs
sb :: Actor
sb = ActorId -> State -> Actor
getActorBody ActorId
source State
s
tb :: Actor
tb = ActorId -> State -> Actor
getActorBody ActorId
target State
s
dozes :: Bool
dozes = Actor -> Watchfulness
bwatch Actor
tb Watchfulness -> [Watchfulness] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Watchfulness
WSleep, Watchfulness
WWake]
in Actor -> Bool
bproj Actor
tb
Bool -> Bool -> Bool
|| Bool -> Bool
not (Actor -> Bool
actorDying Actor
tb
Bool -> Bool -> Bool
|| Actor -> Bool
actorWaits Actor
tb
Bool -> Bool -> Bool
|| Skill -> Skills -> Int
Ability.getSk Skill
Ability.SkMove Skills
actorMaxSk Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= 0
Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
dozes
Bool -> Bool -> Bool
|| Actor -> Bool
hasBackup Actor
sb Bool -> Bool -> Bool
&& Actor -> Bool
hasBackup Actor
tb)
itemToFull :: ItemId -> State -> ItemFull
itemToFull :: ItemId -> State -> ItemFull
itemToFull iid :: ItemId
iid s :: State
s =
COps
-> DiscoveryKind -> DiscoveryAspect -> ItemId -> Item -> ItemFull
itemToFull6 (State -> COps
scops State
s) (State -> DiscoveryKind
sdiscoKind State
s) (State -> DiscoveryAspect
sdiscoAspect State
s) ItemId
iid (ItemId -> State -> Item
getItemBody ItemId
iid State
s)
fullAssocs :: ActorId -> [CStore] -> State -> [(ItemId, ItemFull)]
fullAssocs :: ActorId -> [CStore] -> State -> [(ItemId, ItemFull)]
fullAssocs aid :: ActorId
aid cstores :: [CStore]
cstores s :: State
s =
let allAssocs :: [(ItemId, (Item, ItemQuant))]
allAssocs = (CStore -> [(ItemId, (Item, ItemQuant))])
-> [CStore] -> [(ItemId, (Item, ItemQuant))]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\cstore :: CStore
cstore -> ActorId -> CStore -> State -> [(ItemId, (Item, ItemQuant))]
getActorAssocsK ActorId
aid CStore
cstore State
s) [CStore]
cstores
iToFull :: (ItemId, (Item, ItemQuant)) -> (ItemId, ItemFull)
iToFull (iid :: ItemId
iid, (item :: Item
item, _kit :: ItemQuant
_kit)) =
(ItemId
iid, COps
-> DiscoveryKind -> DiscoveryAspect -> ItemId -> Item -> ItemFull
itemToFull6 (State -> COps
scops State
s) (State -> DiscoveryKind
sdiscoKind State
s) (State -> DiscoveryAspect
sdiscoAspect State
s) ItemId
iid Item
item)
in ((ItemId, (Item, ItemQuant)) -> (ItemId, ItemFull))
-> [(ItemId, (Item, ItemQuant))] -> [(ItemId, ItemFull)]
forall a b. (a -> b) -> [a] -> [b]
map (ItemId, (Item, ItemQuant)) -> (ItemId, ItemFull)
iToFull [(ItemId, (Item, ItemQuant))]
allAssocs
kitAssocs :: ActorId -> [CStore] -> State -> [(ItemId, ItemFullKit)]
kitAssocs :: ActorId -> [CStore] -> State -> [(ItemId, ItemFullKit)]
kitAssocs aid :: ActorId
aid cstores :: [CStore]
cstores s :: State
s =
let allAssocs :: [(ItemId, (Item, ItemQuant))]
allAssocs = (CStore -> [(ItemId, (Item, ItemQuant))])
-> [CStore] -> [(ItemId, (Item, ItemQuant))]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\cstore :: CStore
cstore -> ActorId -> CStore -> State -> [(ItemId, (Item, ItemQuant))]
getActorAssocsK ActorId
aid CStore
cstore State
s) [CStore]
cstores
iToFull :: (ItemId, (Item, ItemQuant)) -> (ItemId, ItemFullKit)
iToFull (iid :: ItemId
iid, (item :: Item
item, kit :: ItemQuant
kit)) =
(ItemId
iid, ( COps
-> DiscoveryKind -> DiscoveryAspect -> ItemId -> Item -> ItemFull
itemToFull6 (State -> COps
scops State
s) (State -> DiscoveryKind
sdiscoKind State
s) (State -> DiscoveryAspect
sdiscoAspect State
s) ItemId
iid Item
item
, ItemQuant
kit ))
in ((ItemId, (Item, ItemQuant)) -> (ItemId, ItemFullKit))
-> [(ItemId, (Item, ItemQuant))] -> [(ItemId, ItemFullKit)]
forall a b. (a -> b) -> [a] -> [b]
map (ItemId, (Item, ItemQuant)) -> (ItemId, ItemFullKit)
iToFull [(ItemId, (Item, ItemQuant))]
allAssocs
getItemKindId :: Item -> State -> ContentId IK.ItemKind
getItemKindId :: Item -> State -> ContentId ItemKind
getItemKindId item :: Item
item s :: State
s = case Item -> ItemIdentity
jkind Item
item of
IdentityObvious ik :: ContentId ItemKind
ik -> ContentId ItemKind
ik
IdentityCovered ix :: ItemKindIx
ix ik :: ContentId ItemKind
ik -> ContentId ItemKind
-> Maybe (ContentId ItemKind) -> ContentId ItemKind
forall a. a -> Maybe a -> a
fromMaybe ContentId ItemKind
ik (Maybe (ContentId ItemKind) -> ContentId ItemKind)
-> Maybe (ContentId ItemKind) -> ContentId ItemKind
forall a b. (a -> b) -> a -> b
$ ItemKindIx -> DiscoveryKind -> Maybe (ContentId ItemKind)
forall k a. Enum k => k -> EnumMap k a -> Maybe a
EM.lookup ItemKindIx
ix (DiscoveryKind -> Maybe (ContentId ItemKind))
-> DiscoveryKind -> Maybe (ContentId ItemKind)
forall a b. (a -> b) -> a -> b
$ State -> DiscoveryKind
sdiscoKind State
s
getIidKindId :: ItemId -> State -> ContentId IK.ItemKind
getIidKindId :: ItemId -> State -> ContentId ItemKind
getIidKindId iid :: ItemId
iid s :: State
s = Item -> State -> ContentId ItemKind
getItemKindId (ItemId -> State -> Item
getItemBody ItemId
iid State
s) State
s
getItemKind :: Item -> State -> IK.ItemKind
getItemKind :: Item -> State -> ItemKind
getItemKind item :: Item
item s :: State
s = ContentData ItemKind -> ContentId ItemKind -> ItemKind
forall a. ContentData a -> ContentId a -> a
okind (COps -> ContentData ItemKind
coitem (COps -> ContentData ItemKind) -> COps -> ContentData ItemKind
forall a b. (a -> b) -> a -> b
$ State -> COps
scops State
s) (ContentId ItemKind -> ItemKind) -> ContentId ItemKind -> ItemKind
forall a b. (a -> b) -> a -> b
$ Item -> State -> ContentId ItemKind
getItemKindId Item
item State
s
getIidKind :: ItemId -> State -> IK.ItemKind
getIidKind :: ItemId -> State -> ItemKind
getIidKind iid :: ItemId
iid s :: State
s = Item -> State -> ItemKind
getItemKind (ItemId -> State -> Item
getItemBody ItemId
iid State
s) State
s
getItemKindIdServer :: Item -> State -> ContentId IK.ItemKind
getItemKindIdServer :: Item -> State -> ContentId ItemKind
getItemKindIdServer item :: Item
item s :: State
s = case Item -> ItemIdentity
jkind Item
item of
IdentityObvious ik :: ContentId ItemKind
ik -> ContentId ItemKind
ik
IdentityCovered ix :: ItemKindIx
ix _ik :: ContentId ItemKind
_ik -> ContentId ItemKind
-> Maybe (ContentId ItemKind) -> ContentId ItemKind
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> ContentId ItemKind
forall a. HasCallStack => [Char] -> a
error ([Char] -> ContentId ItemKind) -> [Char] -> ContentId ItemKind
forall a b. (a -> b) -> a -> b
$ ItemIdentity -> [Char]
forall a. Show a => a -> [Char]
show (ItemIdentity -> [Char]) -> ItemIdentity -> [Char]
forall a b. (a -> b) -> a -> b
$ Item -> ItemIdentity
jkind Item
item)
(ItemKindIx -> DiscoveryKind -> Maybe (ContentId ItemKind)
forall k a. Enum k => k -> EnumMap k a -> Maybe a
EM.lookup ItemKindIx
ix (DiscoveryKind -> Maybe (ContentId ItemKind))
-> DiscoveryKind -> Maybe (ContentId ItemKind)
forall a b. (a -> b) -> a -> b
$ State -> DiscoveryKind
sdiscoKind State
s)
getIidKindIdServer :: ItemId -> State -> ContentId IK.ItemKind
getIidKindIdServer :: ItemId -> State -> ContentId ItemKind
getIidKindIdServer iid :: ItemId
iid s :: State
s = Item -> State -> ContentId ItemKind
getItemKindIdServer (ItemId -> State -> Item
getItemBody ItemId
iid State
s) State
s
getItemKindServer :: Item -> State -> IK.ItemKind
getItemKindServer :: Item -> State -> ItemKind
getItemKindServer item :: Item
item s :: State
s = ContentData ItemKind -> ContentId ItemKind -> ItemKind
forall a. ContentData a -> ContentId a -> a
okind (COps -> ContentData ItemKind
coitem (COps -> ContentData ItemKind) -> COps -> ContentData ItemKind
forall a b. (a -> b) -> a -> b
$ State -> COps
scops State
s) (ContentId ItemKind -> ItemKind) -> ContentId ItemKind -> ItemKind
forall a b. (a -> b) -> a -> b
$ Item -> State -> ContentId ItemKind
getItemKindIdServer Item
item State
s
getIidKindServer :: ItemId -> State -> IK.ItemKind
getIidKindServer :: ItemId -> State -> ItemKind
getIidKindServer iid :: ItemId
iid s :: State
s = Item -> State -> ItemKind
getItemKindServer (ItemId -> State -> Item
getItemBody ItemId
iid State
s) State
s
lidFromC :: Container -> State -> LevelId
lidFromC :: Container -> State -> LevelId
lidFromC (CFloor lid :: LevelId
lid _) _ = LevelId
lid
lidFromC (CEmbed lid :: LevelId
lid _) _ = LevelId
lid
lidFromC (CActor aid :: ActorId
aid _) s :: State
s = Actor -> LevelId
blid (Actor -> LevelId) -> Actor -> LevelId
forall a b. (a -> b) -> a -> b
$ ActorId -> State -> Actor
getActorBody ActorId
aid State
s
lidFromC (CTrunk _ lid :: LevelId
lid _) _ = LevelId
lid
posFromC :: Container -> State -> Point
posFromC :: Container -> State -> Point
posFromC (CFloor _ pos :: Point
pos) _ = Point
pos
posFromC (CEmbed _ pos :: Point
pos) _ = Point
pos
posFromC (CActor aid :: ActorId
aid _) s :: State
s = Actor -> Point
bpos (Actor -> Point) -> Actor -> Point
forall a b. (a -> b) -> a -> b
$ ActorId -> State -> Actor
getActorBody ActorId
aid State
s
posFromC c :: Container
c@CTrunk{} _ = [Char] -> Point
forall a. HasCallStack => [Char] -> a
error ([Char] -> Point) -> [Char] -> Point
forall a b. (a -> b) -> a -> b
$ "" [Char] -> Container -> [Char]
forall v. Show v => [Char] -> v -> [Char]
`showFailure` Container
c
anyFoeAdj :: ActorId -> State -> Bool
anyFoeAdj :: ActorId -> State -> Bool
anyFoeAdj aid :: ActorId
aid s :: State
s =
let body :: Actor
body = ActorId -> State -> Actor
getActorBody ActorId
aid State
s
lvl :: Level
lvl = (Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> LevelId
blid Actor
body) (Dungeon -> Level) -> (State -> Dungeon) -> State -> Level
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Dungeon
sdungeon (State -> Level) -> State -> Level
forall a b. (a -> b) -> a -> b
$ State
s
fact :: Faction
fact = (EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> FactionId
bfid Actor
body) (EnumMap FactionId Faction -> Faction)
-> (State -> EnumMap FactionId Faction) -> State -> Faction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> EnumMap FactionId Faction
sfactionD (State -> Faction) -> State -> Faction
forall a b. (a -> b) -> a -> b
$ State
s
f :: Point -> Bool
f !Point
p = case Point -> Level -> Maybe ActorId
posToBigLvl Point
p Level
lvl of
Nothing -> Bool
False
Just aid2 :: ActorId
aid2 -> Actor -> Bool
g (Actor -> Bool) -> Actor -> Bool
forall a b. (a -> b) -> a -> b
$ ActorId -> State -> Actor
getActorBody ActorId
aid2 State
s
g :: Actor -> Bool
g !Actor
b = (FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFoe (Actor -> FactionId
bfid Actor
body) Faction
fact (Actor -> FactionId
bfid Actor
b)
Bool -> Bool -> Bool
&& Actor -> Int64
bhp Actor
b Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> 0
h :: Point -> Bool
h !Point
p = case Point -> Level -> [ActorId]
posToProjsLvl Point
p Level
lvl of
[] -> Bool
False
aid2 :: ActorId
aid2 : _ -> Actor -> Bool
g (Actor -> Bool) -> Actor -> Bool
forall a b. (a -> b) -> a -> b
$ ActorId -> State -> Actor
getActorBody ActorId
aid2 State
s
in (Point -> Bool) -> [Point] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\ p :: Point
p -> Point -> Bool
f Point
p Bool -> Bool -> Bool
|| Point -> Bool
h Point
p) ([Point] -> Bool) -> [Point] -> Bool
forall a b. (a -> b) -> a -> b
$ Point -> [Point]
vicinityUnsafe (Point -> [Point]) -> Point -> [Point]
forall a b. (a -> b) -> a -> b
$ Actor -> Point
bpos Actor
body
adjacentBigAssocs :: Actor -> State -> [(ActorId, Actor)]
{-# INLINE adjacentBigAssocs #-}
adjacentBigAssocs :: Actor -> State -> [(ActorId, Actor)]
adjacentBigAssocs body :: Actor
body s :: State
s =
let lvl :: Level
lvl = (Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> LevelId
blid Actor
body) (Dungeon -> Level) -> (State -> Dungeon) -> State -> Level
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Dungeon
sdungeon (State -> Level) -> State -> Level
forall a b. (a -> b) -> a -> b
$ State
s
f :: Point -> Maybe ActorId
f !Point
p = Point -> Level -> Maybe ActorId
posToBigLvl Point
p Level
lvl
g :: ActorId -> (ActorId, Actor)
g !ActorId
aid = (ActorId
aid, ActorId -> State -> Actor
getActorBody ActorId
aid State
s)
in (ActorId -> (ActorId, Actor)) -> [ActorId] -> [(ActorId, Actor)]
forall a b. (a -> b) -> [a] -> [b]
map ActorId -> (ActorId, Actor)
g ([ActorId] -> [(ActorId, Actor)])
-> [ActorId] -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ (Point -> Maybe ActorId) -> [Point] -> [ActorId]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Point -> Maybe ActorId
f ([Point] -> [ActorId]) -> [Point] -> [ActorId]
forall a b. (a -> b) -> a -> b
$ Point -> [Point]
vicinityUnsafe (Point -> [Point]) -> Point -> [Point]
forall a b. (a -> b) -> a -> b
$ Actor -> Point
bpos Actor
body
adjacentProjAssocs :: Actor -> State -> [(ActorId, Actor)]
{-# INLINE adjacentProjAssocs #-}
adjacentProjAssocs :: Actor -> State -> [(ActorId, Actor)]
adjacentProjAssocs body :: Actor
body s :: State
s =
let lvl :: Level
lvl = (Dungeon -> LevelId -> Level
forall k a. Enum k => EnumMap k a -> k -> a
EM.! Actor -> LevelId
blid Actor
body) (Dungeon -> Level) -> (State -> Dungeon) -> State -> Level
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State -> Dungeon
sdungeon (State -> Level) -> State -> Level
forall a b. (a -> b) -> a -> b
$ State
s
f :: Point -> [ActorId]
f !Point
p = Point -> Level -> [ActorId]
posToProjsLvl Point
p Level
lvl
g :: ActorId -> (ActorId, Actor)
g !ActorId
aid = (ActorId
aid, ActorId -> State -> Actor
getActorBody ActorId
aid State
s)
in (ActorId -> (ActorId, Actor)) -> [ActorId] -> [(ActorId, Actor)]
forall a b. (a -> b) -> [a] -> [b]
map ActorId -> (ActorId, Actor)
g ([ActorId] -> [(ActorId, Actor)])
-> [ActorId] -> [(ActorId, Actor)]
forall a b. (a -> b) -> a -> b
$ (Point -> [ActorId]) -> [Point] -> [ActorId]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Point -> [ActorId]
f ([Point] -> [ActorId]) -> [Point] -> [ActorId]
forall a b. (a -> b) -> a -> b
$ Point -> [Point]
vicinityUnsafe (Point -> [Point]) -> Point -> [Point]
forall a b. (a -> b) -> a -> b
$ Actor -> Point
bpos Actor
body
armorHurtBonus :: ActorId -> ActorId -> State -> Int
armorHurtBonus :: ActorId -> ActorId -> State -> Int
armorHurtBonus source :: ActorId
source target :: ActorId
target s :: State
s =
let sb :: Actor
sb = ActorId -> State -> Actor
getActorBody ActorId
source State
s
sMaxSk :: Skills
sMaxSk = ActorId -> State -> Skills
getActorMaxSkills ActorId
source State
s
tMaxSk :: Skills
tMaxSk = ActorId -> State -> Skills
getActorMaxSkills ActorId
target State
s
in Bool -> Skills -> Skills -> Int
armorHurtCalculation (Actor -> Bool
bproj Actor
sb) Skills
sMaxSk Skills
tMaxSk
inMelee :: FactionId -> LevelId -> State -> Bool
inMelee :: FactionId -> LevelId -> State -> Bool
inMelee !FactionId
fid !LevelId
lid s :: State
s =
let fact :: Faction
fact = State -> EnumMap FactionId Faction
sfactionD State
s EnumMap FactionId Faction -> FactionId -> Faction
forall k a. Enum k => EnumMap k a -> k -> a
EM.! FactionId
fid
f :: Actor -> Bool
f !Actor
b = Actor -> LevelId
blid Actor
b LevelId -> LevelId -> Bool
forall a. Eq a => a -> a -> Bool
== LevelId
lid
Bool -> Bool -> Bool
&& (FactionId -> Faction -> FactionId -> Bool)
-> FactionId -> Faction -> FactionId -> Bool
forall a. a -> a
inline FactionId -> Faction -> FactionId -> Bool
isFoe FactionId
fid Faction
fact (Actor -> FactionId
bfid Actor
b)
Bool -> Bool -> Bool
&& Actor -> Int64
bhp Actor
b Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> 0
allFoes :: [Actor]
allFoes = (Actor -> Bool) -> [Actor] -> [Actor]
forall a. (a -> Bool) -> [a] -> [a]
filter Actor -> Bool
f ([Actor] -> [Actor]) -> [Actor] -> [Actor]
forall a b. (a -> b) -> a -> b
$ EnumMap ActorId Actor -> [Actor]
forall k a. EnumMap k a -> [a]
EM.elems (EnumMap ActorId Actor -> [Actor])
-> EnumMap ActorId Actor -> [Actor]
forall a b. (a -> b) -> a -> b
$ State -> EnumMap ActorId Actor
sactorD State
s
g :: Actor -> Bool
g !Actor
b = Actor -> FactionId
bfid Actor
b FactionId -> FactionId -> Bool
forall a. Eq a => a -> a -> Bool
== FactionId
fid
Bool -> Bool -> Bool
&& Actor -> LevelId
blid Actor
b LevelId -> LevelId -> Bool
forall a. Eq a => a -> a -> Bool
== LevelId
lid
Bool -> Bool -> Bool
&& Bool -> Bool
not (Actor -> Bool
bproj Actor
b)
Bool -> Bool -> Bool
&& Actor -> Int64
bhp Actor
b Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
> 0
allOurs :: [Actor]
allOurs = (Actor -> Bool) -> [Actor] -> [Actor]
forall a. (a -> Bool) -> [a] -> [a]
filter Actor -> Bool
g ([Actor] -> [Actor]) -> [Actor] -> [Actor]
forall a b. (a -> b) -> a -> b
$ EnumMap ActorId Actor -> [Actor]
forall k a. EnumMap k a -> [a]
EM.elems (EnumMap ActorId Actor -> [Actor])
-> EnumMap ActorId Actor -> [Actor]
forall a b. (a -> b) -> a -> b
$ State -> EnumMap ActorId Actor
sactorD State
s
setFoeVicinity :: EnumSet Point
setFoeVicinity = [Point] -> EnumSet Point
forall k. Enum k => [k] -> EnumSet k
ES.fromList ([Point] -> EnumSet Point) -> [Point] -> EnumSet Point
forall a b. (a -> b) -> a -> b
$ (Actor -> [Point]) -> [Actor] -> [Point]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Point -> [Point]
vicinityUnsafe (Point -> [Point]) -> (Actor -> Point) -> Actor -> [Point]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Actor -> Point
bpos) [Actor]
allFoes
in Bool -> Bool
not (EnumSet Point -> Bool
forall k. EnumSet k -> Bool
ES.null EnumSet Point
setFoeVicinity)
Bool -> Bool -> Bool
&& (Actor -> Bool) -> [Actor] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\b :: Actor
b -> Actor -> Point
bpos Actor
b Point -> EnumSet Point -> Bool
forall k. Enum k => k -> EnumSet k -> Bool
`ES.member` EnumSet Point
setFoeVicinity) [Actor]
allOurs