Learned teleport away now follows the wand of teleportation AI rules.

Monsters that learn teleport away from a spellbook cast it with none
of the tactical rules muse.c applies to the wand of teleportation:
they handed a free controlled teleport to players with teleport
control, wasted casts on noteleport levels with no way to learn
better, fired it as a random attack instead of using it to dislodge
the hero from a protected spot, and never used it to escape. Review
of the new code surfaced four pre-existing bugs in the same beam and
kill-attribution paths, fixed here as well.

* mcastu.c: add teleport away to target_resists_learned_spell(), the
  shared filter behind both the learned-spell meta selection and the
  spell picker. Against the hero the spell now requires the hero to
  be on a scary square or the branch stairs and is skipped outright
  under teleport control; against monster targets it skips sure
  no-ops (noteleport level, temple priest). A caster that has seen
  teleportation fail on the level (the same mtrapseen knowledge bit
  the wand checks) skips it entirely.

* muse.c:
  - badly hurt spellcasters that know the spell now cast it to
    escape. New defensive action MUSE_SPE_TELEPORT_AWAY_SELF reuses
    the wand's mon_tele restriction and relocation code; Amulet
    carriers select MUSE_SPE_TELEPORT_AWAY and cast at the hero
    instead, since the Amulet blocks their own teleport. Shopkeepers
    in their shops, guards and priests never self-teleport, and
    casting charges the standard spell cooldown.
  - the defensive wand of teleportation zap (an Amulet carrier
    sending the hero away) fired in a stale direction: mbhit() aims
    via the tbx/tby globals and this path never set them. With the
    common 0,0 leftover the beam never advanced and teleported the
    Amulet carrier itself - exactly what the case exists to prevent.
    Aim at the hero's tracked position before the zap, restoring the
    pre-tbx/tby behavior.
  - mcast_immediate_spell() never set buzzer around its beam, unlike
    mcast_ray_spell() and the wand mbhit() sites, so a pet's learned
    force bolt, turn undead, drain life, dispel evil or cancellation
    kill through resist() earned no livelog credit. The polymorph
    system-shock death in mbhitm() likewise called mondied() with no
    attribution; both now credit the caster the way the adjacent
    drain life and dispel evil cases do.
  - the scroll-of-fire bystander kill (dead code upstream, enabled
    in EvilHack) called mondied() bare; set_pet_killer() first so a
    pet reading the scroll gets credit.

* trap.c: the magic beam trap fires dobuzz() with a negative zap
  type, so its kills read the buzzer attribution global; triggered
  nested inside another monster's beam (knockback or teleport landing
  a victim on the trigger), it inherited the outer zapper for pet
  credit and the hero's death reason. Save, zero and restore buzzer
  around both MAGIC_BEAM_TRAP_SET dobuzz() calls, the same discipline
  exploder uses for chained explosions.

Author: k21971

doc/evilhack-changelog.md

@@ -5547,4 +5547,5 @@ The following changes to date are:
 - Fix: pets never re-equipped gear after uncursing their own items
 - Farlook reports whether the selected spot is lit or dark, for all
   things
+- Learned teleport away now follows the wand of teleportation AI rules
 

src/mcastu.c

@@ -2404,6 +2404,19 @@ short spell_otyp;
         if (youdefend)
             return (u.ualign.type != A_NONE);
         return !is_evil(target);
+    case SPE_TELEPORT_AWAY:
+        /* mirror the wand of teleportation tactics from muse.c */
+        if (level.flags.noteleport
+            && (caster->mtrapseen & (1 << (TELEP_TRAP_SET - 1))))
+            return TRUE; /* knows teleporting fails on this level */
+        if (youdefend)
+            return (Teleport_control
+                    || !(onscary(u.ux, u.uy, caster)
+                         || (u.ux == sstairs.sx && u.uy == sstairs.sy)));
+        /* monster target: filter sure-thing no-ops */
+        return (level.flags.noteleport
+                || (target->ispriest
+                    && *in_rooms(target->mx, target->my, TEMPLE)));
     default:
         return FALSE;
     }

src/muse.c

@@ -121,6 +121,8 @@ STATIC_DCL boolean FDECL(mcan_learn_spell, (struct monst *, struct obj *));
 #define MUSE_WAN_UNDEAD_TURNING 24 /* also an offensive item */
 #define MUSE_POT_RESTORE_ABILITY 25
 #define MUSE_POT_VAMPIRE_BLOOD 26
+#define MUSE_SPE_TELEPORT_AWAY_SELF 27 /* learned spell, no item */
+#define MUSE_SPE_TELEPORT_AWAY 28      /* learned spell, no item */
 /* MUSE_* constants for offensive items */
 #define MUSE_WAN_DEATH 1
 #define MUSE_WAN_SLEEP 2
@@ -811,6 +813,22 @@ struct monst *mtmp;
               || t->ttyp == BEAR_TRAP))
         t = 0; /* ok for monster to dig here */
 
+    /* spellcasters that have learned teleport away can cast it to
+       escape without needing a wand or scroll; same noteleport
+       knowledge check as the wand, same minimum-level rule as
+       mchoose_learned_spell() */
+    if (!mtmp->mcan && !mtmp->mspec_used && !mtmp->mconf
+        && mknows_spell(mtmp, SPE_TELEPORT_AWAY)
+        && mtmp->m_lev >= objects[SPE_TELEPORT_AWAY].oc_level * 3
+        && (!level.flags.noteleport
+            || !(mtmp->mtrapseen & (1 << (TELEP_TRAP_SET - 1))))) {
+        if (mon_has_amulet(mtmp))
+            m.has_defense = MUSE_SPE_TELEPORT_AWAY;
+        else if (!(mtmp->isshk && inhishop(mtmp)) && !mtmp->isgd
+                 && !mtmp->ispriest)
+            m.has_defense = MUSE_SPE_TELEPORT_AWAY_SELF;
+    }
+
 #define nomore(x)       if (m.has_defense == x) continue;
     /* selection could be improved by collecting all possibilities
        into an array and then picking one at random */
@@ -1560,13 +1578,53 @@ struct monst *mtmp;
         mzapwand(mtmp, otmp, FALSE);
         m_using = TRUE;
         buzzer = mtmp; /* for kill attribution (pet livelog credit) */
-        mbhit(mtmp, rn1(8, 6), mbhitm, bhito, otmp);
+        /* mbhit() aims via the tbx/tby globals; nothing on the
+           defensive path sets them, so aim at the hero's tracked
+           position (skip the beam if that is somehow the caster's
+           own spot) */
+        tbx = mtmp->mux - mtmp->mx;
+        tby = mtmp->muy - mtmp->my;
+        if (tbx || tby)
+            mbhit(mtmp, rn1(8, 6), mbhitm, bhito, otmp);
         buzzer = 0;
         /* monster learns that teleportation isn't useful here */
         if (level.flags.noteleport)
             mtmp->mtrapseen |= (1 << (TELEP_TRAP_SET - 1));
         m_using = FALSE;
         return (DEADMONSTER(mtmp)) ? 1 : 2;
+    case MUSE_SPE_TELEPORT_AWAY_SELF:
+        if ((mtmp->isshk && inhishop(mtmp)) || mtmp->isgd || mtmp->ispriest)
+            return 2;
+        m_flee(mtmp);
+        /* casting-act messages use the wider castmu() visibility test */
+        if (canseemon(mtmp) || tp_sensemon(mtmp) || Detect_monsters)
+            pline("%s casts a spell!", Monnam(mtmp));
+        else if (!Deaf)
+            You_hear("something cast a spell!");
+        /* castmu()'s casting cost formula floors at 2 for any monster
+           of high enough level to cast this spell */
+        mtmp->mspec_used = 2;
+        goto mon_tele;
+    case MUSE_SPE_TELEPORT_AWAY:
+        /* carrying the Amulet, so it can't teleport itself; cast at
+           the hero to send them away instead, as with the wand */
+        pline("%s casts a spell%s!",
+              (canseemon(mtmp) || tp_sensemon(mtmp) || Detect_monsters)
+                  ? Monnam(mtmp)
+                  : "Something",
+              (Invis && !mon_prop(mtmp, SEE_INVIS)
+               && (mtmp->mux != u.ux || mtmp->muy != u.uy))
+                  ? " at a spot near you"
+                  : (Displaced && (mtmp->mux != u.ux || mtmp->muy != u.uy))
+                        ? " at your displaced image"
+                        : " at you");
+        mtmp->mspec_used = 2;
+        (void) mcast_immediate_spell(mtmp, mtmp->mux, mtmp->muy,
+                                     SPE_TELEPORT_AWAY);
+        /* monster learns that teleportation isn't useful here */
+        if (level.flags.noteleport)
+            mtmp->mtrapseen |= (1 << (TELEP_TRAP_SET - 1));
+        return (DEADMONSTER(mtmp)) ? 1 : 2;
     case MUSE_SCR_TELEPORTATION: {
         int obj_is_cursed = otmp->cursed;
 
@@ -2506,8 +2564,11 @@ struct obj *otmp;
                 if (canseemon(mtmp))
                     pline("%s is killed!", Monnam(mtmp));
                 mtmp->mhp = 0;
-                if (DEADMONSTER(mtmp))
+                if (DEADMONSTER(mtmp)) {
+                    if (mcarried(otmp) && otmp->ocarry->mtame)
+                        set_pet_killer(otmp->ocarry);
                     mondied(mtmp);
+                }
             } else if (newcham(mtmp, (struct permonst *) 0, TRUE, FALSE)) {
                 if (!Hallucination && zap_oseen && otmp->otyp == WAN_POLYMORPH)
                     makeknown(otmp->otyp);
@@ -3087,6 +3148,8 @@ struct monst *mtmp;
                     if (resists_cold(mtmp2))
                         damage_mon(mtmp2, 3 * num, AD_FIRE, FALSE);
                     if (DEADMONSTER(mtmp2)) {
+                        if (mtmp->mtame)
+                            set_pet_killer(mtmp);
                         mondied(mtmp2);
                         break;
                     }
@@ -5425,7 +5488,9 @@ int spell_otyp;
 
     /* Trace the ray and affect targets along the path */
     m_using = TRUE;
+    buzzer = caster; /* for kill attribution (pet livelog credit) */
     mbhit(caster, rn1(8, 6), mbhitm, bhito, pseudo);
+    buzzer = 0;
     m_using = FALSE;
 
     /* Capture caster mortality before cleaning up pseudo (cleanup must

src/trap.c

@@ -1293,10 +1293,17 @@ unsigned trflags;
         seetrap(trap);
         if (isok(trap->launch.x, trap->launch.y)
             && IS_STWALL(levl[trap->launch.x][trap->launch.y].typ)) {
+            /* nested firing (knockback or teleport during a monster's
+               beam can trigger this trap) must not inherit the outer
+               actor; a trap kill is unattributed */
+            struct monst *save_buzzer = buzzer;
+
+            buzzer = (struct monst *) 0;
             dobuzz(trap->launch_otyp, 8,
                    trap->launch.x, trap->launch.y,
                    sgn(trap->tx - trap->launch.x),
                    sgn(trap->ty - trap->launch.y), FALSE);
+            buzzer = save_buzzer;
         } else {
             deltrap(trap);
             newsym(u.ux, u.uy);
@@ -3431,12 +3438,20 @@ struct monst *mtmp;
                 seetrap(trap);
             if (isok(trap->launch.x, trap->launch.y)
                 && IS_STWALL(levl[trap->launch.x][trap->launch.y].typ)) {
+                /* nested firing (knockback or teleport during a
+                   monster's beam can trigger this trap) must not
+                   inherit the outer actor; a trap kill is
+                   unattributed */
+                struct monst *save_buzzer = buzzer;
+
                 trap->once = 1; /* set before dobuzz; it may free
                                    trap via melt_ice -> deltrap */
+                buzzer = (struct monst *) 0;
                 dobuzz(trap->launch_otyp, 8,
                        trap->launch.x, trap->launch.y,
                        sgn(trap->tx - trap->launch.x),
                        sgn(trap->ty - trap->launch.y), FALSE);
+                buzzer = save_buzzer;
                 /* trap may be freed; don't dereference */
                 if (DEADMONSTER(mtmp))
                     trapkilled = TRUE;