{-# LANGUAGE TupleSections #-}
-- | Let AI pick the best target for an actor.
module Game.LambdaHack.Client.AI.PickTargetM
  ( refreshTarget
#ifdef EXPOSE_INTERNAL
    -- * Internal operations
  , computeTarget
#endif
  ) where

import Prelude ()

import Game.LambdaHack.Core.Prelude

import qualified Data.EnumMap.Strict as EM
import qualified Data.EnumSet as ES

import           Game.LambdaHack.Client.AI.ConditionM
import           Game.LambdaHack.Client.Bfs
import           Game.LambdaHack.Client.BfsM
import           Game.LambdaHack.Client.CommonM
import           Game.LambdaHack.Client.MonadClient
import           Game.LambdaHack.Client.State
import           Game.LambdaHack.Common.Actor
import           Game.LambdaHack.Common.ActorState
import           Game.LambdaHack.Common.Faction
import           Game.LambdaHack.Common.Item
import           Game.LambdaHack.Common.Kind
import           Game.LambdaHack.Common.Level
import           Game.LambdaHack.Common.MonadStateRead
import           Game.LambdaHack.Common.Point
import qualified Game.LambdaHack.Common.PointArray as PointArray
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.CaveKind as CK
import           Game.LambdaHack.Content.FactionKind
import           Game.LambdaHack.Content.RuleKind
import           Game.LambdaHack.Content.TileKind (isUknownSpace)
import           Game.LambdaHack.Core.Frequency
import           Game.LambdaHack.Core.Random
import qualified Game.LambdaHack.Definition.Ability as Ability

-- | Verify and possibly change the target of an actor. This function both
-- updates the target in the client state and returns the new target explicitly.
refreshTarget :: MonadClient m
              => [(ActorId, Actor)] -> [(ActorId, Actor)] -> (ActorId, Actor)
              -> m (Maybe TgtAndPath)
refreshTarget foeAssocs friendAssocs (aid, body) = do
  side <- getsClient sside
  let !_A = assert (bfid body == side
                    `blame` "AI tries to move an enemy actor"
                    `swith` (aid, body, side)) ()
  let !_A = assert (not (bproj body)
                    `blame` "AI gets to manually move its projectiles"
                    `swith` (aid, body, side)) ()
  mtarget <- computeTarget foeAssocs friendAssocs aid
  case mtarget of
    Nothing -> do
      -- Melee in progress and the actor can't contribute
      -- and would slow down others if he acted.
      -- Or he's just asleep.
      modifyClient $ \cli -> cli {stargetD = EM.delete aid (stargetD cli)}
      return Nothing
    Just tgtMPath -> do
      -- _debugoldTgt <- getsClient $ EM.lookup aid . stargetD
      modifyClient $ \cli ->
        cli {stargetD = EM.insert aid tgtMPath (stargetD cli)}
      return mtarget
      -- let _debug = T.unpack
      --       $ "\nHandleAI symbol:"    <+> tshow (bsymbol body)
      --       <> ", aid:"               <+> tshow aid
      --       <> ", pos:"               <+> tshow (bpos body)
      --       <> "\nHandleAI oldTgt:"   <+> tshow _debugoldTgt
      --       <> "\nHandleAI strTgt:"   <+> tshow stratTarget
      --       <> "\nHandleAI target:"   <+> tshow tgtMPath
      -- trace _debug $ return $ Just tgtMPath

computeTarget :: forall m. MonadClient m
              => [(ActorId, Actor)] -> [(ActorId, Actor)] -> ActorId
              -> m (Maybe TgtAndPath)
computeTarget foeAssocs friendAssocs aid = do
  cops@COps{cocave, corule=RuleContent{rWidthMax, rHeightMax, rnearby}, coTileSpeedup}
    <- getsState scops
  b <- getsState $ getActorBody aid
  mleader <- getsClient sleader
  salter <- getsClient salter
  -- We assume the actor eventually becomes a leader (or has the same
  -- set of skills as the leader, anyway) and set his target accordingly.
  actorMaxSkills <- getsState sactorMaxSkills
  condInMelee <- condInMeleeM $ blid b
  let lalter = salter EM.! blid b
      actorMaxSk = actorMaxSkills EM.! aid
      alterSkill = Ability.getSk Ability.SkAlter actorMaxSk
  lvl <- getLevel $ blid b
  localTime <- getsState $ getLocalTime (blid b)
  let stepAccesible :: [Point] -> Bool
      stepAccesible (q : _) =
        -- Effectively, only @alterMinWalk@ is checked, because real altering
        -- is not done via target path, but action after end of path.
        alterSkill >= fromEnum (lalter PointArray.! q)
      stepAccesible [] = False
  mtgtMPath <- getsClient $ EM.lookup aid . stargetD
  oldTgtUpdatedPath <- case mtgtMPath of
    Just TgtAndPath{tapTgt,tapPath=Nothing} ->
      -- This case is especially for TEnemyPos that would be lost otherwise.
      -- This is also triggered by @UpdLeadFaction@.
      Just <$> createPath aid tapTgt
    Just tap@TgtAndPath{tapTgt,tapPath=Just AndPath{..}} -> do
      mvalidPos <- getsState $ aidTgtToPos (Just aid) (blid b) (Just tapTgt)
      return $!
        if | isNothing mvalidPos -> Nothing  -- wrong level
           | bpos b == pathGoal ->
               mtgtMPath  -- goal reached; stay there picking up items
                          -- or hiding in ambush or in panic
           | pathSource == bpos b ->  -- no move
               -- If next step not accessible, something serious happened,
               -- so reconsider the target, not only path.
               if stepAccesible pathList then mtgtMPath else Nothing
           | otherwise -> case break (== bpos b) pathList of
               (crossed, _ : rest) ->  -- step or many steps along path
                 if null rest
                 then Nothing  -- path to the goal was partial, so tiles
                               -- discovered or altered, so reconsider target
                 else let newPath =
                            AndPath{ pathSource = bpos b
                                   , pathList = rest
                                   , pathGoal
                                   , pathLen = pathLen - length crossed - 1 }
                      in if stepAccesible rest
                         then Just tap{tapPath=Just newPath}
                         else Nothing
               (_, []) -> Nothing  -- veered off the path, e.g., due to push
                                   -- by enemy or congestion, so serious,
                                   -- so reconsider target, not only path
    Nothing -> return Nothing  -- no target assigned yet
  factionD <- getsState sfactionD
  seps <- getsClient seps
  let fact = factionD EM.! bfid b
      slackDoctrine = gdoctrine fact
                      `elem` [ Ability.TMeleeAndRanged, Ability.TMeleeAdjacent
                             , Ability.TBlock, Ability.TRoam, Ability.TPatrol ]
      canMove = Ability.getSk Ability.SkMove actorMaxSk > 0
      canReach = canMove
                 || Ability.getSk Ability.SkDisplace actorMaxSk > 0
                 -- Needed for now, because AI targets and shoots enemies
                 -- based on the path to them, not LOS to them:
                 || Ability.getSk Ability.SkProject actorMaxSk > 0
      canAlter = Ability.getSk Ability.SkAlter actorMaxSk
                 >= if slackDoctrine then 2 else 4
      canMoveItem = Ability.getSk Ability.SkMoveItem actorMaxSk > 0
      calmE = calmEnough b actorMaxSk
      heavilyDistressed =  -- actor hit by a proj or similarly distressed
        deltasSerious (bcalmDelta b)
  -- Speedup compared to @currentSkillsClient@.
  actorMinSk <- getsState $ actorCurrentSkills Nothing aid
  condCanProject <-
    condCanProjectM (Ability.getSk Ability.SkProject actorMaxSk) aid
  fleeD <- getsClient sfleeD
  let condCanMelee = actorCanMelee actorMaxSkills aid b
      condHpTooLow = hpTooLow b actorMaxSk
      mfled = aid `EM.lookup` fleeD
      recentlyFled =
        maybe False (\(_, time) -> timeRecent5 localTime time) mfled
      recentlyFled20 =
        maybe False (\(_, time) -> timeRecent5 localTime time) mfled
      actorTurn = ticksPerMeter $ gearSpeed actorMaxSk
  let canEscape = fcanEscape (gkind fact)
      canSmell = Ability.getSk Ability.SkSmell actorMaxSk > 0
      meleeNearby | canEscape = rnearby `div` 2
                  | otherwise = rnearby
      rangedNearby = 2 * meleeNearby
      -- We do target foes that already attack ours or have benign weapons.
      -- We assume benign weapons run out if they are the sole cause
      -- of targeting, to avoid stalemate.
      worthTargeting aidE body =
        let attacksFriends =
              any (adjacent (bpos body) . bpos . snd) friendAssocs
              && actorCanMeleeToHarm actorMaxSkills aidE body
        in attacksFriends
           || bweapBenign body > 0
           || actorWorthChasing actorMaxSkills aidE body
      targetableMelee body =
        let attacksFriends =
              any (adjacent (bpos body) . bpos . snd) friendAssocs
            -- 3 is
            -- 1 from condSupport1
            -- + 2 from foe being 2 away from friend before he closed in
            -- + 1 for as a margin for ambush, given than actors exploring
            -- can't physically keep adjacent all the time
            n | Ability.getSk Ability.SkAggression actorMaxSk >= 2
              = rangedNearby
                  -- boss never waits
              | condInMelee = if attacksFriends then 8 else 4
                  -- attack even if foe not in melee, to create another
                  -- skirmish and perhaps overwhelm them in this one;
                  -- also, this looks more natural; also sometimes the foe
                  -- would attack our friend in a couple of turns anyway,
                  -- but we may be too far from him at that time
              | otherwise = meleeNearby
        in canMove
           && condCanMelee
           && chessDist (bpos body) (bpos b) <= n
      -- Even when missiles run out, the non-moving foe will still be
      -- targeted, which is fine, since he is weakened by ranged, so should be
      -- meleed ASAP, even if without friends.
      targetableRanged body =
        (not condInMelee || Ability.getSk Ability.SkAggression actorMaxSk >= 2)
          -- boss fires at will
        && chessDist (bpos body) (bpos b) < rangedNearby
        && condCanProject
        && (canMove || targetableLine body)
              -- prevent the exploit of using cover against non-moving shooters
              -- causing them to ignore any other distant foes
      targetableLine body = isJust $ makeLine False b (bpos body) seps cops lvl
      targetableEnemy (aidE, body) = worthTargeting aidE body
                                     && (adjacent (bpos body) (bpos b)
                                            -- target regardless of anything,
                                            -- e.g., to flee if helpless
                                         || targetableMelee body
                                         || targetableRanged body)
      targetableFoes = filter targetableEnemy foeAssocs
      canMeleeEnemy (aidE, body) = actorCanMeleeToHarm actorMaxSkills aidE body
      nearbyFoes = if recentlyFled && not condInMelee
                   then filter (not . canMeleeEnemy) targetableFoes
                   else targetableFoes
  discoBenefit <- getsClient sdiscoBenefit
  getKind <- getsState $ flip getIidKind
  getArItem <- getsState $ flip aspectRecordFromIid
  cstashes <- if canMove
                 && (calmE || null nearbyFoes) -- danger or risk of defecting
                 && not heavilyDistressed
                 && gunderAI fact  -- humans target any stashes explicitly
              then closestStashes aid
              else return []
  let desirableIid (iid, (k, _)) =
        let Benefit{benPickup} = discoBenefit EM.! iid
        in desirableItem cops canEscape benPickup
                         (getArItem iid) (getKind iid) k
      desirableBagFloor bag = any desirableIid $ EM.assocs bag
      desirableFloor (_, (_, bag)) = desirableBagFloor bag
      focused = gearSpeed actorMaxSk < speedWalk || condHpTooLow
      couldMoveLastTurn =  -- approximated; could have changed
        let actorSk = if mleader == Just aid then actorMaxSk else actorMinSk
        in Ability.getSk Ability.SkMove actorSk > 0
      isStuck = actorWaits b && couldMoveLastTurn
      setPath :: Target -> m (Maybe TgtAndPath)
      setPath tgt = do
        let take6 tap@TgtAndPath{tapTgt=TEnemy{}} = tap
              -- @TEnemy@ needed for projecting, even by roaming actors;
              -- however, CStash not as binding, so excursions possible
            take6 TgtAndPath{tapPath=Just AndPath{..}} =
              -- Path followed for up to 6 moves regardless if the target valid
              -- and then target forgot and a new one picked.
              let path6 = take 6 pathList
                  vOld = if bpos b /= pathGoal
                         then towards (bpos b) pathGoal
                         else Vector 0 0
                  tapTgt = TVector vOld
                  tapPath = Just AndPath{pathList=path6, ..}
              in TgtAndPath{..}
            take6 tap = tap
        tgtpath <- createPath aid tgt
        return $ Just $ if slackDoctrine then take6 tgtpath else tgtpath
      pickNewTarget = pickNewTargetIgnore Nothing
      pickNewTargetIgnore :: Maybe ActorId -> m (Maybe TgtAndPath)
      pickNewTargetIgnore maidToIgnore =
        case cstashes of
          (_, (fid2, pos2)) : _ -> setPath $ TPoint (TStash fid2) (blid b) pos2
          [] -> do
            let f aidToIgnore = filter ((/= aidToIgnore) . fst) nearbyFoes
                notIgnoredFoes = maybe nearbyFoes f maidToIgnore
            cfoes <- closestFoes notIgnoredFoes aid
            case cfoes of
             (_, (aid2, _)) : _ -> setPath $ TEnemy aid2
             [] | condInMelee -> return Nothing  -- don't slow down fighters
               -- this looks a bit strange, because teammates stop
               -- in their tracks all around the map (unless very close
               -- to the combatant), but the intuition is, not being able
               -- to help immediately, and not being too friendly
               -- to each other, they just wait and see and also shout
               -- to the teammate to flee and lure foes into ambush
             [] -> do
              mhideout <- if recentlyFled20
                          then closestHideout aid
                          else return Nothing
              case (mhideout, mfled) of
               (Just (p, dist), Just (_, time))
                 | timeDeltaToFrom localTime time
                   <= timeDeltaScale actorTurn (20 - dist) ->
                -- Only target if can reach the hideout 20 turns from fleeing
                -- start, given the actor speed as a leader.
                setPath $ TPoint THideout (blid b) p
               _ -> do
                citemsRaw <- if canMoveItem && canMove
                             then closestItems aid
                             else return []
                let citems = toFreq "closestItems"
                             $ filter desirableFloor citemsRaw
                if nullFreq citems then do
                  -- Tracking enemies is more important than exploring,
                  -- but smell is unreliable and may lead to allies,
                  -- not foes, so avoid it. However, let's keep smell
                  -- more imporant than getting to stairs, to let smelling
                  -- monsters follow cues even on explored levels.
                  smpos <- if canSmell
                           then closestSmell aid
                           else return []
                  case smpos of
                    [] -> do
                      ctriggersRaw <- closestTriggers ViaAnything aid
                      let ctriggers = toFreq "ctriggers" ctriggersRaw
                      if nullFreq ctriggers then do
                        let oldpos = fromMaybe (bpos b) (boldpos b)
                            vOld = bpos b `vectorToFrom` oldpos
                            pNew = shiftBounded rWidthMax rHeightMax (bpos b) vOld
                        if slackDoctrine && not isStuck && calmE && not focused
                           && isUnit vOld && bpos b /= pNew
                                -- both are needed, e.g., when just teleported
                                -- or when the shift bounded by level borders
                        then do
                          let vFreq = toFreq "vFreq"
                                      $ (20, vOld) : map (1,) moves
                          v <- rndToAction $ frequency vFreq
                          -- Once the most pressing targets exhaused,
                          -- wander around for 7 steps and only then,
                          -- or if blocked or derailed, consider again
                          -- the old and new targets.
                          --
                          -- Together with depending on heroes or aliens
                          -- to keep arean, sleepiness, inability to displace
                          -- and chasing random smells, this makes it very hard
                          -- to fully explore and change levels for, e.g.,
                          -- animals. Heroes idling on the level help a lot.
                          let pathSource = bpos b
                              traSlack7 = trajectoryToPathBounded
                                            rWidthMax rHeightMax pathSource
                                            (replicate 7 v)  -- > 6 from take6
                              pathList = map head $ group traSlack7
                              pathGoal = last pathList
                              pathLen = length pathList
                              tapTgt = TVector v
                              tapPath = Just AndPath{..}
                          return $ Just TgtAndPath {..}
                        else do
                          upos <- if canMove
                                  then closestUnknown aid
                                  else return Nothing
                          case upos of
                            Nothing -> do
                              -- If can't move (and so no BFS data),
                              -- no info gained. Or if can't open doors.
                              -- If stuck among ice pillars, we can't help it.
                              when (canMove && canAlter) $
                                modifyClient $ \cli -> cli {sexplored =
                                  ES.insert (blid b) (sexplored cli)}
                              ctriggersRaw2 <- closestTriggers ViaExit aid
                              let ctriggers2 = toFreq "ctriggers2" ctriggersRaw2
                              if nullFreq ctriggers2 then do
                                let toKill = actorWorthKilling actorMaxSkills
                                    worthyFoes = filter (uncurry toKill)
                                                        foeAssocs
                                afoes <- closestFoes worthyFoes aid
                                case afoes of
                                  (_, (aid2, _)) : _ ->
                                    -- All stones turned, time to win or die.
                                    setPath $ TEnemy aid2
                                  [] -> do
                                    furthest <- furthestKnown aid
                                    setPath $ TPoint TKnown (blid b) furthest
                              else do
                                (p, (p0, bag)) <-
                                  rndToAction $ frequency ctriggers2
                                setPath $ TPoint (TEmbed bag p0) (blid b) p
                            Just p -> setPath $ TPoint TUnknown (blid b) p
                      else do
                        (p, (p0, bag)) <- rndToAction $ frequency ctriggers
                        setPath $ TPoint (TEmbed bag p0) (blid b) p
                    (_, (p, _)) : _ -> setPath $ TPoint TSmell (blid b) p
                else do
                  (p, bag) <- rndToAction $ frequency citems
                  setPath $ TPoint (TItem bag) (blid b) p
      tellOthersNothingHere = do
        let f TgtAndPath{tapTgt} = case tapTgt of
              TPoint _ lid p -> p /= bpos b || lid /= blid b
              _ -> True
        modifyClient $ \cli -> cli {stargetD = EM.filter f (stargetD cli)}
        pickNewTarget
      updateTgt :: TgtAndPath -> m (Maybe TgtAndPath)
      updateTgt TgtAndPath{tapPath=Nothing} = pickNewTarget
      updateTgt tap@TgtAndPath{tapPath=Just AndPath{..},tapTgt} = case tapTgt of
        TEnemy a -> do
          body <- getsState $ getActorBody a
          if   (condInMelee  -- fight close foes or nobody at all
                || bweapon body <= 0  -- not dangerous
                || not focused && not (null nearbyFoes))  -- prefers closer foes
               && a `notElem` map fst nearbyFoes  -- old one not close enough
               || blid body /= blid b  -- wrong level
               || actorDying body  -- foe already dying
               || not (worthTargeting a body)
               || recentlyFled
          then
                    -- forget enemy positions to prevent attacking them
                    -- again soon after flight
               pickNewTarget
          else do
               -- If there are no unwalkable tiles on the path to enemy,
               -- he gets target @TEnemy@ and then, even if such tiles emerge,
               -- the target updated by his moves remains @TEnemy@.
               -- Conversely, he is stuck with @TBlock@ if initial target had
               -- unwalkable tiles, for as long as they remain. Harmless quirk.
               mpath <- getCachePath aid $ bpos body
               case mpath of
                 Nothing -> pickNewTargetIgnore (Just a)
                   -- enemy became unreachable
                 Just AndPath{pathList=[]} -> pickNewTarget
                   -- he is his own enemy
                 Just AndPath{pathList= q : _} ->
                   -- If in melee and path blocked by actors (even proj.)
                   -- change target for this turn due to urgency.
                   -- Because of @condInMelee@ new target will be stash
                   -- or enemy if any other is left, or empty target.
                   -- If not in melee, keep target and consider your options
                   -- (wait until blocking actors move or displace or melee
                   -- or sidestep). We don't want to wander away
                   -- in search of loot, only to turn around next turn
                   -- when the enemy is again considered.
                   if not condInMelee
                      || q == bpos body  -- blocked by the enemy, great!
                      || not (occupiedBigLvl q lvl)
                         && not (occupiedProjLvl q lvl)
                   then return $ Just tap{tapPath=mpath}
                   else pickNewTargetIgnore (Just a)
        TPoint _ lid _ | lid /= blid b -> pickNewTarget  -- wrong level
        TPoint tgoal lid pos -> case tgoal of
          TStash fid2 -> do
            oursExploring <- getsState $ oursExploringAssocs (bfid b)
            let oursExploringLid =
                  filter (\(_, body) -> blid body == lid) oursExploring
                spawnFreqs = CK.cactorFreq $ okind cocave $ lkind lvl
                hasGroup grp = fromMaybe 0 (lookup grp spawnFreqs) > 0
                lvlSpawnsUs = any (hasGroup . fst) $ filter ((> 0) . snd)
                                                   $ fgroups (gkind fact)
           -- Even if made peace with the faction, loot stash one last time.
            if (calmE || null nearbyFoes)  -- no risk or can't defend anyway
               && not heavilyDistressed  -- not under heavy fire
               && gstash (factionD EM.! fid2) == Just (lid, pos)
               -- The condition below is more lenient than in @closestStashes@
               -- to avoid wasting time on guard's movement.
               && (fid2 == bfid b
                   && (pos == bpos b  -- guarded by me, so keep guarding
                       && (null nearbyFoes  -- if no foes nearby
                           || length oursExploringLid > 1) -- or buddies nearby
                       || isNothing (posToBigLvl pos lvl))  -- or unguarded
                   && (length oursExploring > 1  -- other actors able to explore
                       || lvlSpawnsUs)  -- or future spawned will be able
                   || isFoe (bfid b) fact fid2)
            then return $ Just tap
            else pickNewTarget
          -- In this case, need to retarget, to focus on foes that melee ours
          -- and not, e.g., on remembered foes or items.
          _ | condInMelee || not (null cstashes) -> pickNewTarget
          TEnemyPos _  -- chase last position even if foe hides
            | bpos b == pos -> tellOthersNothingHere
            | recentlyFled -> pickNewTarget
                -- forget enemy positions to prevent attacking them again soon
            | not (couldMoveLastTurn || null nearbyFoes) -> pickNewTarget
                -- if only, possibly, shooting, forget hotspots, target foes;
                -- this results in only pointman humans chasing old foes
                -- in preference of new visible ones, but it's fine
            | otherwise -> do
              -- Here pick the closer enemy, the remembered or seen, to avoid
              -- loops when approaching new enemy obscures him behind obstacle
              -- but reveals the previously remembered one, etc.
              let remainingDist = chessDist (bpos b) pos
              if any (\(_, b3) -> chessDist (bpos b) (bpos b3) < remainingDist)
                     nearbyFoes
              then pickNewTarget
              else return $ Just tap
          -- Don't stop fleeing into hideout after 5 turns even if foes appear.
          THideout ->
            -- Approach or stay in the hideout until 20 turns pass.
            if not recentlyFled20
            then pickNewTarget
            else return $ Just tap
          -- Prefer close foes to anything else below.
          _ | not (null nearbyFoes) -> pickNewTarget
          -- Below we check the target could not be picked again in
          -- pickNewTarget (e.g., an item got picked up by our teammate)
          -- and only in this case it is invalidated.
          -- This ensures targets are eventually reached (unless a foe
          -- shows up) and not changed all the time mid-route
          -- to equally interesting, but perhaps a bit closer targets,
          -- most probably already targeted by other actors.
          TEmbed bag p -> assert (adjacent pos p) $ do
            -- First, stairs and embedded items from @closestTriggers@.
            -- We don't check skills, because they normally don't change
            -- or we can put some equipment back and recover them.
            -- We don't determine if the stairs or embed are interesting
            -- (this changes with time), but allow the actor
            -- to reach them and then retarget. The two things we check
            -- is whether the embedded bag is still there, or used up
            -- and whether we happen to be already adjacent to @p@,
            -- even though not necessarily at @pos@.
            bag2 <- getsState $ getEmbedBag lid p  -- not @pos@
            if | bag /= bag2 -> pickNewTarget  -- others will notice soon enough
               | adjacent (bpos b) p ->  -- regardless if at @pos@ or not
                   setPath $ TPoint TKnown lid (bpos b)
                     -- stay there one turn (high chance to become leader)
                     -- to enable triggering; if trigger fails
                     -- (e.g, changed skills), will retarget next turn (@TAny@)
               | otherwise -> return $ Just tap
          TItem bag -> do
            bag2 <- getsState $ getFloorBag lid pos
            if | bag /= bag2 -> pickNewTarget  -- others will notice soon enough
               | bpos b == pos ->
                   setPath $ TPoint TKnown lid (bpos b)
                     -- stay there one turn (high chance to become leader)
                     -- to enable pickup; if pickup fails, will retarget
               | otherwise -> return $ Just tap
          TSmell ->
            if not canSmell
               || let sml = EM.findWithDefault timeZero pos (lsmell lvl)
                  in sml <= ltime lvl
            then pickNewTarget  -- others will notice soon enough
            else return $ Just tap
          TBlock -> do  -- e.g., door or first unknown tile of an area
            let t = lvl `at` pos
            if isStuck  -- not a very important target, because blocked
               || alterSkill < fromEnum (lalter PointArray.! pos)
                    -- tile was searched or altered or skill lowered
               || Tile.isWalkable coTileSpeedup t
                    -- tile is no longer unwalkable, so was explored
                    -- so time to recalculate target
            then pickNewTarget  -- others will notice soon enough
            else return $ Just tap
          TUnknown ->
            let t = lvl `at` pos
            in if lexpl lvl <= lseen lvl
                  || not (isUknownSpace t)
               then pickNewTarget  -- others will notice soon enough
               else return $ Just tap
          TKnown ->
            if bpos b == pos
               || isStuck
               || alterSkill < fromEnum (lalter PointArray.! pos)
                    -- tile was searched or altered or skill lowered
            then pickNewTarget  -- others unconcerned
            else return $ Just tap
        _ | condInMelee || not (null nearbyFoes && null cstashes) ->
            pickNewTarget
        TNonEnemy _ | mleader == Just aid ->  -- a leader, never follow
          pickNewTarget
        TNonEnemy a -> do
          body <- getsState $ getActorBody a
          if blid body /= blid b  -- wrong level
          then pickNewTarget
          else do
            -- Update path. If impossible, pick another target.
            mpath <- getCachePath aid $ bpos body
            case mpath of
              Nothing -> pickNewTarget
              Just AndPath{pathList=[]} -> pickNewTarget
              _ -> return $ Just tap{tapPath=mpath}
        TVector{} -> if bpos b /= pathGoal
                     then return $ Just tap
                     else pickNewTarget
  if canReach
  then maybe pickNewTarget updateTgt oldTgtUpdatedPath
  else return Nothing