1 files changed, 2601 insertions, 0 deletions

diff --git a/src/p_enemy.c b/src/p_enemy.c
new file mode 100644
index 0000000..937321e
--- /dev/null
+++ b/src/p_enemy.c
@@ -0,0 +1,2601 @@
+/* Emacs style mode select   -*- C++ -*-
+ *-----------------------------------------------------------------------------
+ *
+ *
+ *  PrBoom: a Doom port merged with LxDoom and LSDLDoom
+ *  based on BOOM, a modified and improved DOOM engine
+ *  Copyright (C) 1999 by
+ *  id Software, Chi Hoang, Lee Killough, Jim Flynn, Rand Phares, Ty Halderman
+ *  Copyright (C) 1999-2000,2002 by
+ *  Jess Haas, Nicolas Kalkhof, Colin Phipps, Florian Schulze
+ *  Copyright 2005, 2006 by
+ *  Florian Schulze, Colin Phipps, Neil Stevens, Andrey Budko
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version 2
+ *  of the License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ *  02111-1307, USA.
+ *
+ * DESCRIPTION:
+ *      Enemy thinking, AI.
+ *      Action Pointer Functions
+ *      that are associated with states/frames.
+ *
+ *-----------------------------------------------------------------------------*/
+
+#include "doomstat.h"
+#include "m_random.h"
+#include "r_main.h"
+#include "p_maputl.h"
+#include "p_map.h"
+#include "p_setup.h"
+#include "p_spec.h"
+#include "s_sound.h"
+#include "sounds.h"
+#include "p_inter.h"
+#include "g_game.h"
+#include "p_enemy.h"
+#include "p_tick.h"
+#include "m_bbox.h"
+#include "lprintf.h"
+
+static mobj_t *current_actor;
+
+typedef enum {
+  DI_EAST,
+  DI_NORTHEAST,
+  DI_NORTH,
+  DI_NORTHWEST,
+  DI_WEST,
+  DI_SOUTHWEST,
+  DI_SOUTH,
+  DI_SOUTHEAST,
+  DI_NODIR,
+  NUMDIRS
+} dirtype_t;
+
+static void P_NewChaseDir(mobj_t *actor);
+void P_ZBumpCheck(mobj_t *);                                        // phares
+
+//
+// ENEMY THINKING
+// Enemies are allways spawned
+// with targetplayer = -1, threshold = 0
+// Most monsters are spawned unaware of all players,
+// but some can be made preaware
+//
+
+//
+// Called by P_NoiseAlert.
+// Recursively traverse adjacent sectors,
+// sound blocking lines cut off traversal.
+//
+// killough 5/5/98: reformatted, cleaned up
+
+static void P_RecursiveSound(sector_t *sec, int soundblocks,
+           mobj_t *soundtarget)
+{
+  int i;
+
+  // wake up all monsters in this sector
+  if (sec->validcount == validcount && sec->soundtraversed <= soundblocks+1)
+    return;             // already flooded
+
+  sec->validcount = validcount;
+  sec->soundtraversed = soundblocks+1;
+  P_SetTarget(&sec->soundtarget, soundtarget);
+
+  for (i=0; i<sec->linecount; i++)
+    {
+      sector_t *other;
+      line_t *check = sec->lines[i];
+
+      if (!(check->flags & ML_TWOSIDED))
+        continue;
+
+      P_LineOpening(check);
+
+      if (openrange <= 0)
+        continue;       // closed door
+
+      other=sides[check->sidenum[sides[check->sidenum[0]].sector==sec]].sector;
+
+      if (!(check->flags & ML_SOUNDBLOCK))
+        P_RecursiveSound(other, soundblocks, soundtarget);
+      else
+        if (!soundblocks)
+          P_RecursiveSound(other, 1, soundtarget);
+    }
+}
+
+//
+// P_NoiseAlert
+// If a monster yells at a player,
+// it will alert other monsters to the player.
+//
+void P_NoiseAlert(mobj_t *target, mobj_t *emitter)
+{
+  validcount++;
+  P_RecursiveSound(emitter->subsector->sector, 0, target);
+}
+
+//
+// P_CheckMeleeRange
+//
+
+static boolean P_CheckMeleeRange(mobj_t *actor)
+{
+  mobj_t *pl = actor->target;
+
+  return  // killough 7/18/98: friendly monsters don't attack other friends
+    pl && !(actor->flags & pl->flags & MF_FRIEND) &&
+    (P_AproxDistance(pl->x-actor->x, pl->y-actor->y) <
+     MELEERANGE - 20*FRACUNIT + pl->info->radius) &&
+    P_CheckSight(actor, actor->target);
+}
+
+//
+// P_HitFriend()
+//
+// killough 12/98
+// This function tries to prevent shooting at friends
+
+static boolean P_HitFriend(mobj_t *actor)
+{
+  return actor->flags & MF_FRIEND && actor->target &&
+    (P_AimLineAttack(actor,
+         R_PointToAngle2(actor->x, actor->y,
+             actor->target->x, actor->target->y),
+         P_AproxDistance(actor->x-actor->target->x,
+             actor->y-actor->target->y), 0),
+     linetarget) && linetarget != actor->target &&
+    !((linetarget->flags ^ actor->flags) & MF_FRIEND);
+}
+
+//
+// P_CheckMissileRange
+//
+static boolean P_CheckMissileRange(mobj_t *actor)
+{
+  fixed_t dist;
+
+  if (!P_CheckSight(actor, actor->target))
+    return false;
+
+  if (actor->flags & MF_JUSTHIT)
+    {      // the target just hit the enemy, so fight back!
+      actor->flags &= ~MF_JUSTHIT;
+
+      /* killough 7/18/98: no friendly fire at corpses
+       * killough 11/98: prevent too much infighting among friends
+       * cph - yikes, talk about fitting everything on one line... */
+
+      return
+  !(actor->flags & MF_FRIEND) ||
+  (actor->target->health > 0 &&
+   (!(actor->target->flags & MF_FRIEND) ||
+    (actor->target->player ?
+     monster_infighting || P_Random(pr_defect) >128 :
+     !(actor->target->flags & MF_JUSTHIT) && P_Random(pr_defect) >128)));
+    }
+
+  /* killough 7/18/98: friendly monsters don't attack other friendly
+   * monsters or players (except when attacked, and then only once)
+   */
+  if (actor->flags & actor->target->flags & MF_FRIEND)
+    return false;
+
+  if (actor->reactiontime)
+    return false;       // do not attack yet
+
+  // OPTIMIZE: get this from a global checksight
+  dist = P_AproxDistance ( actor->x-actor->target->x,
+                           actor->y-actor->target->y) - 64*FRACUNIT;
+
+  if (!actor->info->meleestate)
+    dist -= 128*FRACUNIT;       // no melee attack, so fire more
+
+  dist >>= FRACBITS;
+
+  if (actor->type == MT_VILE)
+    if (dist > 14*64)
+      return false;     // too far away
+
+
+  if (actor->type == MT_UNDEAD)
+    {
+      if (dist < 196)
+        return false;   // close for fist attack
+      dist >>= 1;
+    }
+
+  if (actor->type == MT_CYBORG ||
+      actor->type == MT_SPIDER ||
+      actor->type == MT_SKULL)
+    dist >>= 1;
+
+  if (dist > 200)
+    dist = 200;
+
+  if (actor->type == MT_CYBORG && dist > 160)
+    dist = 160;
+
+  if (P_Random(pr_missrange) < dist)
+    return false;
+
+  if (P_HitFriend(actor))
+    return false;
+
+  return true;
+}
+
+/*
+ * P_IsOnLift
+ *
+ * killough 9/9/98:
+ *
+ * Returns true if the object is on a lift. Used for AI,
+ * since it may indicate the need for crowded conditions,
+ * or that a monster should stay on the lift for a while
+ * while it goes up or down.
+ */
+
+static boolean P_IsOnLift(const mobj_t *actor)
+{
+  const sector_t *sec = actor->subsector->sector;
+  line_t line;
+  int l;
+
+  // Short-circuit: it's on a lift which is active.
+  if (sec->floordata && ((thinker_t *) sec->floordata)->function==T_PlatRaise)
+    return true;
+
+  // Check to see if it's in a sector which can be activated as a lift.
+  if ((line.tag = sec->tag))
+    for (l = -1; (l = P_FindLineFromLineTag(&line, l)) >= 0;)
+      switch (lines[l].special)
+  {
+  case  10: case  14: case  15: case  20: case  21: case  22:
+  case  47: case  53: case  62: case  66: case  67: case  68:
+  case  87: case  88: case  95: case 120: case 121: case 122:
+  case 123: case 143: case 162: case 163: case 181: case 182:
+  case 144: case 148: case 149: case 211: case 227: case 228:
+  case 231: case 232: case 235: case 236:
+    return true;
+  }
+
+  return false;
+}
+
+/*
+ * P_IsUnderDamage
+ *
+ * killough 9/9/98:
+ *
+ * Returns nonzero if the object is under damage based on
+ * their current position. Returns 1 if the damage is moderate,
+ * -1 if it is serious. Used for AI.
+ */
+
+static int P_IsUnderDamage(mobj_t *actor)
+{
+  const struct msecnode_s *seclist;
+  const ceiling_t *cl;             // Crushing ceiling
+  int dir = 0;
+  for (seclist=actor->touching_sectorlist; seclist; seclist=seclist->m_tnext)
+    if ((cl = seclist->m_sector->ceilingdata) &&
+  cl->thinker.function == T_MoveCeiling)
+      dir |= cl->direction;
+  return dir;
+}
+
+//
+// P_Move
+// Move in the current direction,
+// returns false if the move is blocked.
+//
+
+static fixed_t xspeed[8] = {FRACUNIT,47000,0,-47000,-FRACUNIT,-47000,0,47000};
+static fixed_t yspeed[8] = {0,47000,FRACUNIT,47000,0,-47000,-FRACUNIT,-47000};
+
+// 1/11/98 killough: Limit removed on special lines crossed
+extern  line_t **spechit;          // New code -- killough
+extern  int    numspechit;
+
+static boolean P_Move(mobj_t *actor, boolean dropoff) /* killough 9/12/98 */
+{
+  fixed_t tryx, tryy, deltax, deltay, origx, origy;
+  boolean try_ok;
+  int movefactor = ORIG_FRICTION_FACTOR;    // killough 10/98
+  int friction = ORIG_FRICTION;
+  int speed;
+
+  if (actor->movedir == DI_NODIR)
+    return false;
+
+#ifdef RANGECHECK
+  if ((unsigned)actor->movedir >= 8)
+    I_Error ("P_Move: Weird actor->movedir!");
+#endif
+
+  // killough 10/98: make monsters get affected by ice and sludge too:
+
+  if (monster_friction)
+    movefactor = P_GetMoveFactor(actor, &friction);
+
+  speed = actor->info->speed;
+
+  if (friction < ORIG_FRICTION &&     // sludge
+      !(speed = ((ORIG_FRICTION_FACTOR - (ORIG_FRICTION_FACTOR-movefactor)/2)
+     * speed) / ORIG_FRICTION_FACTOR))
+    speed = 1;      // always give the monster a little bit of speed
+
+  tryx = (origx = actor->x) + (deltax = speed * xspeed[actor->movedir]);
+  tryy = (origy = actor->y) + (deltay = speed * yspeed[actor->movedir]);
+
+  try_ok = P_TryMove(actor, tryx, tryy, dropoff);
+
+  // killough 10/98:
+  // Let normal momentum carry them, instead of steptoeing them across ice.
+
+  if (try_ok && friction > ORIG_FRICTION)
+    {
+      actor->x = origx;
+      actor->y = origy;
+      movefactor *= FRACUNIT / ORIG_FRICTION_FACTOR / 4;
+      actor->momx += FixedMul(deltax, movefactor);
+      actor->momy += FixedMul(deltay, movefactor);
+    }
+
+  if (!try_ok)
+    {      // open any specials
+      int good;
+
+      if (actor->flags & MF_FLOAT && floatok)
+        {
+          if (actor->z < tmfloorz)          // must adjust height
+            actor->z += FLOATSPEED;
+          else
+            actor->z -= FLOATSPEED;
+
+          actor->flags |= MF_INFLOAT;
+
+    return true;
+        }
+
+      if (!numspechit)
+        return false;
+
+      actor->movedir = DI_NODIR;
+
+      /* if the special is not a door that can be opened, return false
+       *
+       * killough 8/9/98: this is what caused monsters to get stuck in
+       * doortracks, because it thought that the monster freed itself
+       * by opening a door, even if it was moving towards the doortrack,
+       * and not the door itself.
+       *
+       * killough 9/9/98: If a line blocking the monster is activated,
+       * return true 90% of the time. If a line blocking the monster is
+       * not activated, but some other line is, return false 90% of the
+       * time. A bit of randomness is needed to ensure it's free from
+       * lockups, but for most cases, it returns the correct result.
+       *
+       * Do NOT simply return false 1/4th of the time (causes monsters to
+       * back out when they shouldn't, and creates secondary stickiness).
+       */
+
+      for (good = false; numspechit--; )
+        if (P_UseSpecialLine(actor, spechit[numspechit], 0))
+    good |= spechit[numspechit] == blockline ? 1 : 2;
+
+      /* cph - compatibility maze here
+       * Boom v2.01 and orig. Doom return "good"
+       * Boom v2.02 and LxDoom return good && (P_Random(pr_trywalk)&3)
+       * MBF plays even more games
+       */
+      if (!good || comp[comp_doorstuck]) return good;
+      if (!mbf_features)
+  return (P_Random(pr_trywalk)&3); /* jff 8/13/98 */
+      else /* finally, MBF code */
+  return ((P_Random(pr_opendoor) >= 230) ^ (good & 1));
+    }
+  else
+    actor->flags &= ~MF_INFLOAT;
+
+  /* killough 11/98: fall more slowly, under gravity, if felldown==true */
+  if (!(actor->flags & MF_FLOAT) &&
+      (!felldown || !mbf_features))
+    actor->z = actor->floorz;
+
+  return true;
+}
+
+/*
+ * P_SmartMove
+ *
+ * killough 9/12/98: Same as P_Move, except smarter
+ */
+
+static boolean P_SmartMove(mobj_t *actor)
+{
+  mobj_t *target = actor->target;
+  int on_lift, dropoff = false, under_damage;
+
+  /* killough 9/12/98: Stay on a lift if target is on one */
+  on_lift = !comp[comp_staylift]
+    && target && target->health > 0
+    && target->subsector->sector->tag==actor->subsector->sector->tag &&
+    P_IsOnLift(actor);
+
+  under_damage = monster_avoid_hazards && P_IsUnderDamage(actor);
+
+  // killough 10/98: allow dogs to drop off of taller ledges sometimes.
+  // dropoff==1 means always allow it, dropoff==2 means only up to 128 high,
+  // and only if the target is immediately on the other side of the line.
+
+#ifdef DOGS
+  // haleyjd: allow all friends of HelperType to also jump down
+
+  if ((actor->type == MT_DOGS || (actor->type == (HelperThing-1) && actor->flags&MF_FRIEND))
+      && target && dog_jumping &&
+      !((target->flags ^ actor->flags) & MF_FRIEND) &&
+      P_AproxDistance(actor->x - target->x,
+          actor->y - target->y) < FRACUNIT*144 &&
+      P_Random(pr_dropoff) < 235)
+    dropoff = 2;
+#endif
+
+  if (!P_Move(actor, dropoff))
+    return false;
+
+  // killough 9/9/98: avoid crushing ceilings or other damaging areas
+  if (
+      (on_lift && P_Random(pr_stayonlift) < 230 &&      // Stay on lift
+       !P_IsOnLift(actor))
+      ||
+      (monster_avoid_hazards && !under_damage &&  // Get away from damage
+       (under_damage = P_IsUnderDamage(actor)) &&
+       (under_damage < 0 || P_Random(pr_avoidcrush) < 200))
+      )
+    actor->movedir = DI_NODIR;    // avoid the area (most of the time anyway)
+
+  return true;
+}
+
+//
+// TryWalk
+// Attempts to move actor on
+// in its current (ob->moveangle) direction.
+// If blocked by either a wall or an actor
+// returns FALSE
+// If move is either clear or blocked only by a door,
+// returns TRUE and sets...
+// If a door is in the way,
+// an OpenDoor call is made to start it opening.
+//
+
+static boolean P_TryWalk(mobj_t *actor)
+{
+  if (!P_SmartMove(actor))
+    return false;
+  actor->movecount = P_Random(pr_trywalk)&15;
+  return true;
+}
+
+//
+// P_DoNewChaseDir
+//
+// killough 9/8/98:
+//
+// Most of P_NewChaseDir(), except for what
+// determines the new direction to take
+//
+
+static void P_DoNewChaseDir(mobj_t *actor, fixed_t deltax, fixed_t deltay)
+{
+  dirtype_t xdir, ydir, tdir;
+  dirtype_t olddir = actor->movedir;
+  dirtype_t turnaround = olddir;
+
+  if (turnaround != DI_NODIR)         // find reverse direction
+    turnaround ^= 4;
+
+  xdir =
+    deltax >  10*FRACUNIT ? DI_EAST :
+    deltax < -10*FRACUNIT ? DI_WEST : DI_NODIR;
+
+  ydir =
+    deltay < -10*FRACUNIT ? DI_SOUTH :
+    deltay >  10*FRACUNIT ? DI_NORTH : DI_NODIR;
+
+  // try direct route
+  if (xdir != DI_NODIR && ydir != DI_NODIR && turnaround !=
+      (actor->movedir = deltay < 0 ? deltax > 0 ? DI_SOUTHEAST : DI_SOUTHWEST :
+       deltax > 0 ? DI_NORTHEAST : DI_NORTHWEST) && P_TryWalk(actor))
+    return;
+
+  // try other directions
+  if (P_Random(pr_newchase) > 200 || D_abs(deltay)>D_abs(deltax))
+    tdir = xdir, xdir = ydir, ydir = tdir;
+
+  if ((xdir == turnaround ? xdir = DI_NODIR : xdir) != DI_NODIR &&
+      (actor->movedir = xdir, P_TryWalk(actor)))
+    return;         // either moved forward or attacked
+
+  if ((ydir == turnaround ? ydir = DI_NODIR : ydir) != DI_NODIR &&
+      (actor->movedir = ydir, P_TryWalk(actor)))
+    return;
+
+  // there is no direct path to the player, so pick another direction.
+  if (olddir != DI_NODIR && (actor->movedir = olddir, P_TryWalk(actor)))
+    return;
+
+  // randomly determine direction of search
+  if (P_Random(pr_newchasedir) & 1)
+    {
+      for (tdir = DI_EAST; tdir <= DI_SOUTHEAST; tdir++)
+        if (tdir != turnaround && (actor->movedir = tdir, P_TryWalk(actor)))
+    return;
+    }
+  else
+    for (tdir = DI_SOUTHEAST; tdir != DI_EAST-1; tdir--)
+      if (tdir != turnaround && (actor->movedir = tdir, P_TryWalk(actor)))
+  return;
+
+  if ((actor->movedir = turnaround) != DI_NODIR && !P_TryWalk(actor))
+    actor->movedir = DI_NODIR;
+}
+
+//
+// killough 11/98:
+//
+// Monsters try to move away from tall dropoffs.
+//
+// In Doom, they were never allowed to hang over dropoffs,
+// and would remain stuck if involuntarily forced over one.
+// This logic, combined with p_map.c (P_TryMove), allows
+// monsters to free themselves without making them tend to
+// hang over dropoffs.
+
+static fixed_t dropoff_deltax, dropoff_deltay, floorz;
+
+static boolean PIT_AvoidDropoff(line_t *line)
+{
+  if (line->backsector                          && // Ignore one-sided linedefs
+      tmbbox[BOXRIGHT]  > line->bbox[BOXLEFT]   &&
+      tmbbox[BOXLEFT]   < line->bbox[BOXRIGHT]  &&
+      tmbbox[BOXTOP]    > line->bbox[BOXBOTTOM] && // Linedef must be contacted
+      tmbbox[BOXBOTTOM] < line->bbox[BOXTOP]    &&
+      P_BoxOnLineSide(tmbbox, line) == -1)
+    {
+      fixed_t front = line->frontsector->floorheight;
+      fixed_t back  = line->backsector->floorheight;
+      angle_t angle;
+
+      // The monster must contact one of the two floors,
+      // and the other must be a tall dropoff (more than 24).
+
+      if (back == floorz && front < floorz - FRACUNIT*24)
+  angle = R_PointToAngle2(0,0,line->dx,line->dy);   // front side dropoff
+      else
+  if (front == floorz && back < floorz - FRACUNIT*24)
+    angle = R_PointToAngle2(line->dx,line->dy,0,0); // back side dropoff
+  else
+    return true;
+
+      // Move away from dropoff at a standard speed.
+      // Multiple contacted linedefs are cumulative (e.g. hanging over corner)
+      dropoff_deltax -= finesine[angle >> ANGLETOFINESHIFT]*32;
+      dropoff_deltay += finecosine[angle >> ANGLETOFINESHIFT]*32;
+    }
+  return true;
+}
+
+//
+// Driver for above
+//
+
+static fixed_t P_AvoidDropoff(mobj_t *actor)
+{
+  int yh=((tmbbox[BOXTOP]   = actor->y+actor->radius)-bmaporgy)>>MAPBLOCKSHIFT;
+  int yl=((tmbbox[BOXBOTTOM]= actor->y-actor->radius)-bmaporgy)>>MAPBLOCKSHIFT;
+  int xh=((tmbbox[BOXRIGHT] = actor->x+actor->radius)-bmaporgx)>>MAPBLOCKSHIFT;
+  int xl=((tmbbox[BOXLEFT]  = actor->x-actor->radius)-bmaporgx)>>MAPBLOCKSHIFT;
+  int bx, by;
+
+  floorz = actor->z;            // remember floor height
+
+  dropoff_deltax = dropoff_deltay = 0;
+
+  // check lines
+
+  validcount++;
+  for (bx=xl ; bx<=xh ; bx++)
+    for (by=yl ; by<=yh ; by++)
+      P_BlockLinesIterator(bx, by, PIT_AvoidDropoff);  // all contacted lines
+
+  return dropoff_deltax | dropoff_deltay;   // Non-zero if movement prescribed
+}
+
+//
+// P_NewChaseDir
+//
+// killough 9/8/98: Split into two functions
+//
+
+static void P_NewChaseDir(mobj_t *actor)
+{
+  mobj_t *target = actor->target;
+  fixed_t deltax = target->x - actor->x;
+  fixed_t deltay = target->y - actor->y;
+
+  // killough 8/8/98: sometimes move away from target, keeping distance
+  //
+  // 1) Stay a certain distance away from a friend, to avoid being in their way
+  // 2) Take advantage over an enemy without missiles, by keeping distance
+
+  actor->strafecount = 0;
+
+  if (mbf_features) {
+    if (actor->floorz - actor->dropoffz > FRACUNIT*24 &&
+  actor->z <= actor->floorz &&
+  !(actor->flags & (MF_DROPOFF|MF_FLOAT)) &&
+  !comp[comp_dropoff] &&
+  P_AvoidDropoff(actor)) /* Move away from dropoff */
+      {
+  P_DoNewChaseDir(actor, dropoff_deltax, dropoff_deltay);
+
+  // If moving away from dropoff, set movecount to 1 so that
+  // small steps are taken to get monster away from dropoff.
+
+  actor->movecount = 1;
+  return;
+      }
+    else
+      {
+  fixed_t dist = P_AproxDistance(deltax, deltay);
+
+  // Move away from friends when too close, except
+  // in certain situations (e.g. a crowded lift)
+
+  if (actor->flags & target->flags & MF_FRIEND &&
+      distfriend << FRACBITS > dist &&
+      !P_IsOnLift(target) && !P_IsUnderDamage(actor))
+  {
+    deltax = -deltax, deltay = -deltay;
+  } else
+    if (target->health > 0 && (actor->flags ^ target->flags) & MF_FRIEND)
+      {   // Live enemy target
+        if (monster_backing &&
+      actor->info->missilestate && actor->type != MT_SKULL &&
+      ((!target->info->missilestate && dist < MELEERANGE*2) ||
+       (target->player && dist < MELEERANGE*3 &&
+        (target->player->readyweapon == wp_fist ||
+         target->player->readyweapon == wp_chainsaw))))
+    {       // Back away from melee attacker
+      actor->strafecount = P_Random(pr_enemystrafe) & 15;
+      deltax = -deltax, deltay = -deltay;
+    }
+      }
+      }
+  }
+
+  P_DoNewChaseDir(actor, deltax, deltay);
+
+  // If strafing, set movecount to strafecount so that old Doom
+  // logic still works the same, except in the strafing part
+
+  if (actor->strafecount)
+    actor->movecount = actor->strafecount;
+}
+
+//
+// P_IsVisible
+//
+// killough 9/9/98: whether a target is visible to a monster
+//
+
+static boolean P_IsVisible(mobj_t *actor, mobj_t *mo, boolean allaround)
+{
+  if (!allaround)
+    {
+      angle_t an = R_PointToAngle2(actor->x, actor->y,
+           mo->x, mo->y) - actor->angle;
+      if (an > ANG90 && an < ANG270 &&
+    P_AproxDistance(mo->x-actor->x, mo->y-actor->y) > MELEERANGE)
+  return false;
+    }
+  return P_CheckSight(actor, mo);
+}
+
+//
+// PIT_FindTarget
+//
+// killough 9/5/98
+//
+// Finds monster targets for other monsters
+//
+
+static int current_allaround;
+
+static boolean PIT_FindTarget(mobj_t *mo)
+{
+  mobj_t *actor = current_actor;
+
+  if (!((mo->flags ^ actor->flags) & MF_FRIEND &&        // Invalid target
+  mo->health > 0 && (mo->flags & MF_COUNTKILL || mo->type == MT_SKULL)))
+    return true;
+
+  // If the monster is already engaged in a one-on-one attack
+  // with a healthy friend, don't attack around 60% the time
+  {
+    const mobj_t *targ = mo->target;
+    if (targ && targ->target == mo &&
+  P_Random(pr_skiptarget) > 100 &&
+  (targ->flags ^ mo->flags) & MF_FRIEND &&
+  targ->health*2 >= targ->info->spawnhealth)
+      return true;
+  }
+
+  if (!P_IsVisible(actor, mo, current_allaround))
+    return true;
+
+  P_SetTarget(&actor->lastenemy, actor->target);  // Remember previous target
+  P_SetTarget(&actor->target, mo);                // Found target
+
+  // Move the selected monster to the end of its associated
+  // list, so that it gets searched last next time.
+
+  {
+    thinker_t *cap = &thinkerclasscap[mo->flags & MF_FRIEND ?
+             th_friends : th_enemies];
+    (mo->thinker.cprev->cnext = mo->thinker.cnext)->cprev = mo->thinker.cprev;
+    (mo->thinker.cprev = cap->cprev)->cnext = &mo->thinker;
+    (mo->thinker.cnext = cap)->cprev = &mo->thinker;
+  }
+
+  return false;
+}
+
+//
+// P_LookForPlayers
+// If allaround is false, only look 180 degrees in front.
+// Returns true if a player is targeted.
+//
+
+static boolean P_LookForPlayers(mobj_t *actor, boolean allaround)
+{
+  player_t *player;
+  int stop, stopc, c;
+
+  if (actor->flags & MF_FRIEND)
+    {  // killough 9/9/98: friendly monsters go about players differently
+      int anyone;
+
+#if 0
+      if (!allaround) // If you want friendly monsters not to awaken unprovoked
+  return false;
+#endif
+
+      // Go back to a player, no matter whether it's visible or not
+      for (anyone=0; anyone<=1; anyone++)
+  for (c=0; c<MAXPLAYERS; c++)
+    if (playeringame[c] && players[c].playerstate==PST_LIVE &&
+        (anyone || P_IsVisible(actor, players[c].mo, allaround)))
+      {
+        P_SetTarget(&actor->target, players[c].mo);
+
+        // killough 12/98:
+        // get out of refiring loop, to avoid hitting player accidentally
+
+        if (actor->info->missilestate)
+    {
+      P_SetMobjState(actor, actor->info->seestate);
+      actor->flags &= ~MF_JUSTHIT;
+    }
+
+        return true;
+      }
+
+      return false;
+    }
+
+  // Change mask of 3 to (MAXPLAYERS-1) -- killough 2/15/98:
+  stop = (actor->lastlook-1)&(MAXPLAYERS-1);
+
+  c = 0;
+
+  stopc = !mbf_features &&
+    !demo_compatibility && monsters_remember ?
+    MAXPLAYERS : 2;       // killough 9/9/98
+
+  for (;; actor->lastlook = (actor->lastlook+1)&(MAXPLAYERS-1))
+    {
+      if (!playeringame[actor->lastlook])
+  continue;
+
+      // killough 2/15/98, 9/9/98:
+      if (c++ == stopc || actor->lastlook == stop)  // done looking
+      {
+        // e6y
+        // Fixed Boom incompatibilities. The following code was missed.
+        // There are no more desyncs on Donce's demos on horror.wad
+
+        // Use last known enemy if no players sighted -- killough 2/15/98:
+        if (!mbf_features && !demo_compatibility && monsters_remember)
+        {
+          if (actor->lastenemy && actor->lastenemy->health > 0)
+          {
+            actor->target = actor->lastenemy;
+            actor->lastenemy = NULL;
+            return true;
+          }
+        }
+
+        return false;
+      }
+
+      player = &players[actor->lastlook];
+
+      if (player->health <= 0)
+  continue;               // dead
+
+      if (!P_IsVisible(actor, player->mo, allaround))
+  continue;
+
+      P_SetTarget(&actor->target, player->mo);
+
+      /* killough 9/9/98: give monsters a threshold towards getting players
+       * (we don't want it to be too easy for a player with dogs :)
+       */
+      if (!comp[comp_pursuit])
+  actor->threshold = 60;
+
+      return true;
+    }
+}
+
+//
+// Friendly monsters, by Lee Killough 7/18/98
+//
+// Friendly monsters go after other monsters first, but
+// also return to owner if they cannot find any targets.
+// A marine's best friend :)  killough 7/18/98, 9/98
+//
+
+static boolean P_LookForMonsters(mobj_t *actor, boolean allaround)
+{
+  thinker_t *cap, *th;
+
+  if (demo_compatibility)
+    return false;
+
+  if (actor->lastenemy && actor->lastenemy->health > 0 && monsters_remember &&
+      !(actor->lastenemy->flags & actor->flags & MF_FRIEND)) // not friends
+    {
+      P_SetTarget(&actor->target, actor->lastenemy);
+      P_SetTarget(&actor->lastenemy, NULL);
+      return true;
+    }
+
+  /* Old demos do not support monster-seeking bots */
+  if (!mbf_features)
+    return false;
+
+  // Search the threaded list corresponding to this object's potential targets
+  cap = &thinkerclasscap[actor->flags & MF_FRIEND ? th_enemies : th_friends];
+
+  // Search for new enemy
+
+  if (cap->cnext != cap)        // Empty list? bail out early
+    {
+      int x = (actor->x - bmaporgx)>>MAPBLOCKSHIFT;
+      int y = (actor->y - bmaporgy)>>MAPBLOCKSHIFT;
+      int d;
+
+      current_actor = actor;
+      current_allaround = allaround;
+
+      // Search first in the immediate vicinity.
+
+      if (!P_BlockThingsIterator(x, y, PIT_FindTarget))
+  return true;
+
+      for (d=1; d<5; d++)
+  {
+    int i = 1 - d;
+    do
+      if (!P_BlockThingsIterator(x+i, y-d, PIT_FindTarget) ||
+    !P_BlockThingsIterator(x+i, y+d, PIT_FindTarget))
+        return true;
+    while (++i < d);
+    do
+      if (!P_BlockThingsIterator(x-d, y+i, PIT_FindTarget) ||
+    !P_BlockThingsIterator(x+d, y+i, PIT_FindTarget))
+        return true;
+    while (--i + d >= 0);
+  }
+
+      {   // Random number of monsters, to prevent patterns from forming
+  int n = (P_Random(pr_friends) & 31) + 15;
+
+  for (th = cap->cnext; th != cap; th = th->cnext)
+    if (--n < 0)
+      {
+        // Only a subset of the monsters were searched. Move all of
+        // the ones which were searched so far, to the end of the list.
+
+        (cap->cnext->cprev = cap->cprev)->cnext = cap->cnext;
+        (cap->cprev = th->cprev)->cnext = cap;
+        (th->cprev = cap)->cnext = th;
+        break;
+     }
+    else
+      if (!PIT_FindTarget((mobj_t *) th))   // If target sighted
+        return true;
+      }
+    }
+
+  return false;  // No monster found
+}
+
+//
+// P_LookForTargets
+//
+// killough 9/5/98: look for targets to go after, depending on kind of monster
+//
+
+static boolean P_LookForTargets(mobj_t *actor, int allaround)
+{
+  return actor->flags & MF_FRIEND ?
+    P_LookForMonsters(actor, allaround) || P_LookForPlayers (actor, allaround):
+    P_LookForPlayers (actor, allaround) || P_LookForMonsters(actor, allaround);
+}
+
+//
+// P_HelpFriend
+//
+// killough 9/8/98: Help friends in danger of dying
+//
+
+static boolean P_HelpFriend(mobj_t *actor)
+{
+  thinker_t *cap, *th;
+
+  // If less than 33% health, self-preservation rules
+  if (actor->health*3 < actor->info->spawnhealth)
+    return false;
+
+  current_actor = actor;
+  current_allaround = true;
+
+  // Possibly help a friend under 50% health
+  cap = &thinkerclasscap[actor->flags & MF_FRIEND ? th_friends : th_enemies];
+
+  for (th = cap->cnext; th != cap; th = th->cnext)
+    if (((mobj_t *) th)->health*2 >= ((mobj_t *) th)->info->spawnhealth)
+      {
+  if (P_Random(pr_helpfriend) < 180)
+    break;
+      }
+    else
+      if (((mobj_t *) th)->flags & MF_JUSTHIT &&
+    ((mobj_t *) th)->target &&
+    ((mobj_t *) th)->target != actor->target &&
+    !PIT_FindTarget(((mobj_t *) th)->target))
+  {
+    // Ignore any attacking monsters, while searching for friend
+    actor->threshold = BASETHRESHOLD;
+    return true;
+  }
+
+  return false;
+}
+
+//
+// A_KeenDie
+// DOOM II special, map 32.
+// Uses special tag 666.
+//
+void A_KeenDie(mobj_t* mo)
+{
+  thinker_t *th;
+  line_t   junk;
+
+  A_Fall(mo);
+
+  // scan the remaining thinkers to see if all Keens are dead
+
+  for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
+    if (th->function == P_MobjThinker)
+      {
+        mobj_t *mo2 = (mobj_t *) th;
+        if (mo2 != mo && mo2->type == mo->type && mo2->health > 0)
+          return;                           // other Keen not dead
+      }
+
+  junk.tag = 666;
+  EV_DoDoor(&junk,open);
+}
+
+
+//
+// ACTION ROUTINES
+//
+
+//
+// A_Look
+// Stay in state until a player is sighted.
+//
+
+void A_Look(mobj_t *actor)
+{
+  mobj_t *targ = actor->subsector->sector->soundtarget;
+  actor->threshold = 0; // any shot will wake up
+
+  /* killough 7/18/98:
+   * Friendly monsters go after other monsters first, but
+   * also return to player, without attacking them, if they
+   * cannot find any targets. A marine's best friend :)
+   */
+  actor->pursuecount = 0;
+
+  if (!(actor->flags & MF_FRIEND && P_LookForTargets(actor, false)) &&
+      !((targ = actor->subsector->sector->soundtarget) &&
+  targ->flags & MF_SHOOTABLE &&
+  (P_SetTarget(&actor->target, targ),
+   !(actor->flags & MF_AMBUSH) || P_CheckSight(actor, targ))) &&
+      (actor->flags & MF_FRIEND || !P_LookForTargets(actor, false)))
+    return;
+
+  // go into chase state
+
+  if (actor->info->seesound)
+    {
+      int sound;
+      switch (actor->info->seesound)
+        {
+        case sfx_posit1:
+        case sfx_posit2:
+        case sfx_posit3:
+          sound = sfx_posit1+P_Random(pr_see)%3;
+          break;
+
+        case sfx_bgsit1:
+        case sfx_bgsit2:
+          sound = sfx_bgsit1+P_Random(pr_see)%2;
+          break;
+
+        default:
+          sound = actor->info->seesound;
+          break;
+        }
+      if (actor->type==MT_SPIDER || actor->type == MT_CYBORG)
+        S_StartSound(NULL, sound);          // full volume
+      else
+        S_StartSound(actor, sound);
+    }
+  P_SetMobjState(actor, actor->info->seestate);
+}
+
+//
+// A_KeepChasing
+//
+// killough 10/98:
+// Allows monsters to continue movement while attacking
+//
+
+static void A_KeepChasing(mobj_t *actor)
+{
+  if (actor->movecount)
+    {
+      actor->movecount--;
+      if (actor->strafecount)
+        actor->strafecount--;
+      P_SmartMove(actor);
+    }
+}
+
+//
+// A_Chase
+// Actor has a melee attack,
+// so it tries to close as fast as possible
+//
+
+void A_Chase(mobj_t *actor)
+{
+  if (actor->reactiontime)
+    actor->reactiontime--;
+
+  if (actor->threshold) { /* modify target threshold */
+    if (!actor->target || actor->target->health <= 0)
+      actor->threshold = 0;
+    else
+      actor->threshold--;
+  }
+
+  /* turn towards movement direction if not there yet
+   * killough 9/7/98: keep facing towards target if strafing or backing out
+   */
+
+  if (actor->strafecount)
+    A_FaceTarget(actor);
+  else if (actor->movedir < 8)
+    {
+      int delta = (actor->angle &= (7<<29)) - (actor->movedir << 29);
+      if (delta > 0)
+        actor->angle -= ANG90/2;
+      else
+        if (delta < 0)
+          actor->angle += ANG90/2;
+    }
+
+  if (!actor->target || !(actor->target->flags&MF_SHOOTABLE))
+    {
+      if (!P_LookForTargets(actor,true)) // look for a new target
+  P_SetMobjState(actor, actor->info->spawnstate); // no new target
+      return;
+    }
+
+  // do not attack twice in a row
+  if (actor->flags & MF_JUSTATTACKED)
+    {
+      actor->flags &= ~MF_JUSTATTACKED;
+      if (gameskill != sk_nightmare && !fastparm)
+        P_NewChaseDir(actor);
+      return;
+    }
+
+  // check for melee attack
+  if (actor->info->meleestate && P_CheckMeleeRange(actor))
+    {
+      if (actor->info->attacksound)
+        S_StartSound(actor, actor->info->attacksound);
+      P_SetMobjState(actor, actor->info->meleestate);
+      /* killough 8/98: remember an attack
+      * cph - DEMOSYNC? */
+      if (!actor->info->missilestate)
+  actor->flags |= MF_JUSTHIT;
+      return;
+    }
+
+  // check for missile attack
+  if (actor->info->missilestate)
+    if (!(gameskill < sk_nightmare && !fastparm && actor->movecount))
+      if (P_CheckMissileRange(actor))
+        {
+          P_SetMobjState(actor, actor->info->missilestate);
+          actor->flags |= MF_JUSTATTACKED;
+          return;
+        }
+
+  if (!actor->threshold) {
+    if (!mbf_features)
+      {   /* killough 9/9/98: for backward demo compatibility */
+  if (netgame && !P_CheckSight(actor, actor->target) &&
+      P_LookForPlayers(actor, true))
+    return;
+      }
+    /* killough 7/18/98, 9/9/98: new monster AI */
+    else if (help_friends && P_HelpFriend(actor))
+      return;      /* killough 9/8/98: Help friends in need */
+    /* Look for new targets if current one is bad or is out of view */
+    else if (actor->pursuecount)
+      actor->pursuecount--;
+    else {
+  /* Our pursuit time has expired. We're going to think about
+   * changing targets */
+  actor->pursuecount = BASETHRESHOLD;
+
+  /* Unless (we have a live target
+   *         and it's not friendly
+   *         and we can see it)
+   *  try to find a new one; return if sucessful */
+
+  if (!(actor->target && actor->target->health > 0 &&
+        ((comp[comp_pursuit] && !netgame) ||
+         (((actor->target->flags ^ actor->flags) & MF_FRIEND ||
+     (!(actor->flags & MF_FRIEND) && monster_infighting)) &&
+    P_CheckSight(actor, actor->target))))
+      && P_LookForTargets(actor, true))
+        return;
+
+  /* (Current target was good, or no new target was found.)
+   *
+   * If monster is a missile-less friend, give up pursuit and
+   * return to player, if no attacks have occurred recently.
+   */
+
+  if (!actor->info->missilestate && actor->flags & MF_FRIEND) {
+    if (actor->flags & MF_JUSTHIT)          /* if recent action, */
+      actor->flags &= ~MF_JUSTHIT;          /* keep fighting */
+    else if (P_LookForPlayers(actor, true)) /* else return to player */
+      return;
+  }
+    }
+  }
+
+  if (actor->strafecount)
+    actor->strafecount--;
+
+  // chase towards player
+  if (--actor->movecount<0 || !P_SmartMove(actor))
+    P_NewChaseDir(actor);
+
+  // make active sound
+  if (actor->info->activesound && P_Random(pr_see)<3)
+    S_StartSound(actor, actor->info->activesound);
+}
+
+//
+// A_FaceTarget
+//
+void A_FaceTarget(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  actor->flags &= ~MF_AMBUSH;
+  actor->angle = R_PointToAngle2(actor->x, actor->y,
+                                 actor->target->x, actor->target->y);
+  if (actor->target->flags & MF_SHADOW)
+    { // killough 5/5/98: remove dependence on order of evaluation:
+      int t = P_Random(pr_facetarget);
+      actor->angle += (t-P_Random(pr_facetarget))<<21;
+    }
+}
+
+//
+// A_PosAttack
+//
+
+void A_PosAttack(mobj_t *actor)
+{
+  int angle, damage, slope, t;
+
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  angle = actor->angle;
+  slope = P_AimLineAttack(actor, angle, MISSILERANGE, 0); /* killough 8/2/98 */
+  S_StartSound(actor, sfx_pistol);
+
+  // killough 5/5/98: remove dependence on order of evaluation:
+  t = P_Random(pr_posattack);
+  angle += (t - P_Random(pr_posattack))<<20;
+  damage = (P_Random(pr_posattack)%5 + 1)*3;
+  P_LineAttack(actor, angle, MISSILERANGE, slope, damage);
+}
+
+void A_SPosAttack(mobj_t* actor)
+{
+  int i, bangle, slope;
+
+  if (!actor->target)
+    return;
+  S_StartSound(actor, sfx_shotgn);
+  A_FaceTarget(actor);
+  bangle = actor->angle;
+  slope = P_AimLineAttack(actor, bangle, MISSILERANGE, 0); /* killough 8/2/98 */
+  for (i=0; i<3; i++)
+    {  // killough 5/5/98: remove dependence on order of evaluation:
+      int t = P_Random(pr_sposattack);
+      int angle = bangle + ((t - P_Random(pr_sposattack))<<20);
+      int damage = ((P_Random(pr_sposattack)%5)+1)*3;
+      P_LineAttack(actor, angle, MISSILERANGE, slope, damage);
+    }
+}
+
+void A_CPosAttack(mobj_t *actor)
+{
+  int angle, bangle, damage, slope, t;
+
+  if (!actor->target)
+    return;
+  S_StartSound(actor, sfx_shotgn);
+  A_FaceTarget(actor);
+  bangle = actor->angle;
+  slope = P_AimLineAttack(actor, bangle, MISSILERANGE, 0); /* killough 8/2/98 */
+
+  // killough 5/5/98: remove dependence on order of evaluation:
+  t = P_Random(pr_cposattack);
+  angle = bangle + ((t - P_Random(pr_cposattack))<<20);
+  damage = ((P_Random(pr_cposattack)%5)+1)*3;
+  P_LineAttack(actor, angle, MISSILERANGE, slope, damage);
+}
+
+void A_CPosRefire(mobj_t *actor)
+{
+  // keep firing unless target got out of sight
+  A_FaceTarget(actor);
+
+  /* killough 12/98: Stop firing if a friend has gotten in the way */
+  if (P_HitFriend(actor))
+    goto stop;
+
+  /* killough 11/98: prevent refiring on friends continuously */
+  if (P_Random(pr_cposrefire) < 40) {
+    if (actor->target && actor->flags & actor->target->flags & MF_FRIEND)
+      goto stop;
+    else
+      return;
+  }
+
+  if (!actor->target || actor->target->health <= 0
+      || !P_CheckSight(actor, actor->target))
+stop:  P_SetMobjState(actor, actor->info->seestate);
+}
+
+void A_SpidRefire(mobj_t* actor)
+{
+  // keep firing unless target got out of sight
+  A_FaceTarget(actor);
+
+  /* killough 12/98: Stop firing if a friend has gotten in the way */
+  if (P_HitFriend(actor))
+    goto stop;
+
+  if (P_Random(pr_spidrefire) < 10)
+    return;
+
+  // killough 11/98: prevent refiring on friends continuously
+  if (!actor->target || actor->target->health <= 0
+      || actor->flags & actor->target->flags & MF_FRIEND
+      || !P_CheckSight(actor, actor->target))
+    stop: P_SetMobjState(actor, actor->info->seestate);
+}
+
+void A_BspiAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  P_SpawnMissile(actor, actor->target, MT_ARACHPLAZ);  // launch a missile
+}
+
+//
+// A_TroopAttack
+//
+
+void A_TroopAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  if (P_CheckMeleeRange(actor))
+    {
+      int damage;
+      S_StartSound(actor, sfx_claw);
+      damage = (P_Random(pr_troopattack)%8+1)*3;
+      P_DamageMobj(actor->target, actor, actor, damage);
+      return;
+    }
+  P_SpawnMissile(actor, actor->target, MT_TROOPSHOT);  // launch a missile
+}
+
+void A_SargAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  if (P_CheckMeleeRange(actor))
+    {
+      int damage = ((P_Random(pr_sargattack)%10)+1)*4;
+      P_DamageMobj(actor->target, actor, actor, damage);
+    }
+}
+
+void A_HeadAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget (actor);
+  if (P_CheckMeleeRange(actor))
+    {
+      int damage = (P_Random(pr_headattack)%6+1)*10;
+      P_DamageMobj(actor->target, actor, actor, damage);
+      return;
+    }
+  P_SpawnMissile(actor, actor->target, MT_HEADSHOT);  // launch a missile
+}
+
+void A_CyberAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  P_SpawnMissile(actor, actor->target, MT_ROCKET);
+}
+
+void A_BruisAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  if (P_CheckMeleeRange(actor))
+    {
+      int damage;
+      S_StartSound(actor, sfx_claw);
+      damage = (P_Random(pr_bruisattack)%8+1)*10;
+      P_DamageMobj(actor->target, actor, actor, damage);
+      return;
+    }
+  P_SpawnMissile(actor, actor->target, MT_BRUISERSHOT);  // launch a missile
+}
+
+//
+// A_SkelMissile
+//
+
+void A_SkelMissile(mobj_t *actor)
+{
+  mobj_t *mo;
+
+  if (!actor->target)
+    return;
+
+  A_FaceTarget (actor);
+  actor->z += 16*FRACUNIT;      // so missile spawns higher
+  mo = P_SpawnMissile (actor, actor->target, MT_TRACER);
+  actor->z -= 16*FRACUNIT;      // back to normal
+
+  mo->x += mo->momx;
+  mo->y += mo->momy;
+  P_SetTarget(&mo->tracer, actor->target);
+}
+
+int     TRACEANGLE = 0xc000000;
+
+void A_Tracer(mobj_t *actor)
+{
+  angle_t       exact;
+  fixed_t       dist;
+  fixed_t       slope;
+  mobj_t        *dest;
+  mobj_t        *th;
+
+  /* killough 1/18/98: this is why some missiles do not have smoke
+   * and some do. Also, internal demos start at random gametics, thus
+   * the bug in which revenants cause internal demos to go out of sync.
+   *
+   * killough 3/6/98: fix revenant internal demo bug by subtracting
+   * levelstarttic from gametic.
+   *
+   * killough 9/29/98: use new "basetic" so that demos stay in sync
+   * during pauses and menu activations, while retaining old demo sync.
+   *
+   * leveltime would have been better to use to start with in Doom, but
+   * since old demos were recorded using gametic, we must stick with it,
+   * and improvise around it (using leveltime causes desync across levels).
+   */
+
+  if ((gametic-basetic) & 3)
+    return;
+
+  // spawn a puff of smoke behind the rocket
+  P_SpawnPuff(actor->x, actor->y, actor->z);
+
+  th = P_SpawnMobj (actor->x-actor->momx,
+                    actor->y-actor->momy,
+                    actor->z, MT_SMOKE);
+
+  th->momz = FRACUNIT;
+  th->tics -= P_Random(pr_tracer) & 3;
+  if (th->tics < 1)
+    th->tics = 1;
+
+  // adjust direction
+  dest = actor->tracer;
+
+  if (!dest || dest->health <= 0)
+    return;
+
+  // change angle
+  exact = R_PointToAngle2(actor->x, actor->y, dest->x, dest->y);
+
+  if (exact != actor->angle) {
+    if (exact - actor->angle > 0x80000000)
+      {
+        actor->angle -= TRACEANGLE;
+        if (exact - actor->angle < 0x80000000)
+          actor->angle = exact;
+      }
+    else
+      {
+        actor->angle += TRACEANGLE;
+        if (exact - actor->angle > 0x80000000)
+          actor->angle = exact;
+      }
+  }
+
+  exact = actor->angle>>ANGLETOFINESHIFT;
+  actor->momx = FixedMul(actor->info->speed, finecosine[exact]);
+  actor->momy = FixedMul(actor->info->speed, finesine[exact]);
+
+  // change slope
+  dist = P_AproxDistance(dest->x - actor->x, dest->y - actor->y);
+
+  dist = dist / actor->info->speed;
+
+  if (dist < 1)
+    dist = 1;
+
+  slope = (dest->z+40*FRACUNIT - actor->z) / dist;
+
+  if (slope < actor->momz)
+    actor->momz -= FRACUNIT/8;
+  else
+    actor->momz += FRACUNIT/8;
+}
+
+void A_SkelWhoosh(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  S_StartSound(actor,sfx_skeswg);
+}
+
+void A_SkelFist(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  if (P_CheckMeleeRange(actor))
+    {
+      int damage = ((P_Random(pr_skelfist)%10)+1)*6;
+      S_StartSound(actor, sfx_skepch);
+      P_DamageMobj(actor->target, actor, actor, damage);
+    }
+}
+
+//
+// PIT_VileCheck
+// Detect a corpse that could be raised.
+//
+
+mobj_t* corpsehit;
+mobj_t* vileobj;
+fixed_t viletryx;
+fixed_t viletryy;
+
+static boolean PIT_VileCheck(mobj_t *thing)
+{
+  int     maxdist;
+  boolean check;
+
+  if (!(thing->flags & MF_CORPSE) )
+    return true;        // not a monster
+
+  if (thing->tics != -1)
+    return true;        // not lying still yet
+
+  if (thing->info->raisestate == S_NULL)
+    return true;        // monster doesn't have a raise state
+
+  maxdist = thing->info->radius + mobjinfo[MT_VILE].radius;
+
+  if (D_abs(thing->x-viletryx) > maxdist || D_abs(thing->y-viletryy) > maxdist)
+    return true;                // not actually touching
+
+// Check to see if the radius and height are zero. If they are      // phares
+// then this is a crushed monster that has been turned into a       //   |
+// gib. One of the options may be to ignore this guy.               //   V
+
+// Option 1: the original, buggy method, -> ghost (compatibility)
+// Option 2: ressurect the monster, but not as a ghost
+// Option 3: ignore the gib
+
+//    if (Option3)                                                  //   ^
+//        if ((thing->height == 0) && (thing->radius == 0))         //   |
+//            return true;                                          // phares
+
+    corpsehit = thing;
+    corpsehit->momx = corpsehit->momy = 0;
+    if (comp[comp_vile])                                            // phares
+      {                                                             //   |
+        corpsehit->height <<= 2;                                    //   V
+        check = P_CheckPosition(corpsehit,corpsehit->x,corpsehit->y);
+        corpsehit->height >>= 2;
+      }
+    else
+      {
+        int height,radius;
+
+        height = corpsehit->height; // save temporarily
+        radius = corpsehit->radius; // save temporarily
+        corpsehit->height = corpsehit->info->height;
+        corpsehit->radius = corpsehit->info->radius;
+        corpsehit->flags |= MF_SOLID;
+        check = P_CheckPosition(corpsehit,corpsehit->x,corpsehit->y);
+        corpsehit->height = height; // restore
+        corpsehit->radius = radius; // restore                      //   ^
+        corpsehit->flags &= ~MF_SOLID;
+      }                                                             //   |
+                                                                    // phares
+    if (!check)
+      return true;              // doesn't fit here
+    return false;               // got one, so stop checking
+}
+
+//
+// A_VileChase
+// Check for ressurecting a body
+//
+
+void A_VileChase(mobj_t* actor)
+{
+  int xl, xh;
+  int yl, yh;
+  int bx, by;
+
+  if (actor->movedir != DI_NODIR)
+    {
+      // check for corpses to raise
+      viletryx =
+        actor->x + actor->info->speed*xspeed[actor->movedir];
+      viletryy =
+        actor->y + actor->info->speed*yspeed[actor->movedir];
+
+      xl = (viletryx - bmaporgx - MAXRADIUS*2)>>MAPBLOCKSHIFT;
+      xh = (viletryx - bmaporgx + MAXRADIUS*2)>>MAPBLOCKSHIFT;
+      yl = (viletryy - bmaporgy - MAXRADIUS*2)>>MAPBLOCKSHIFT;
+      yh = (viletryy - bmaporgy + MAXRADIUS*2)>>MAPBLOCKSHIFT;
+
+      vileobj = actor;
+      for (bx=xl ; bx<=xh ; bx++)
+        {
+          for (by=yl ; by<=yh ; by++)
+            {
+              // Call PIT_VileCheck to check
+              // whether object is a corpse
+              // that canbe raised.
+              if (!P_BlockThingsIterator(bx,by,PIT_VileCheck))
+                {
+      mobjinfo_t *info;
+
+                  // got one!
+                  mobj_t* temp = actor->target;
+                  actor->target = corpsehit;
+                  A_FaceTarget(actor);
+                  actor->target = temp;
+
+                  P_SetMobjState(actor, S_VILE_HEAL1);
+                  S_StartSound(corpsehit, sfx_slop);
+                  info = corpsehit->info;
+
+                  P_SetMobjState(corpsehit,info->raisestate);
+
+                  if (comp[comp_vile])                              // phares
+                    corpsehit->height <<= 2;                        //   |
+                  else                                              //   V
+                    {
+                      corpsehit->height = info->height; // fix Ghost bug
+                      corpsehit->radius = info->radius; // fix Ghost bug
+                    }                                               // phares
+
+      /* killough 7/18/98:
+       * friendliness is transferred from AV to raised corpse
+       */
+      corpsehit->flags =
+        (info->flags & ~MF_FRIEND) | (actor->flags & MF_FRIEND);
+
+                  if (!((corpsehit->flags ^ MF_COUNTKILL) & (MF_FRIEND | MF_COUNTKILL)))
+                    totallive++;
+                  
+                  corpsehit->health = info->spawnhealth;
+      P_SetTarget(&corpsehit->target, NULL);  // killough 11/98
+
+      if (mbf_features)
+        {         /* kilough 9/9/98 */
+          P_SetTarget(&corpsehit->lastenemy, NULL);
+          corpsehit->flags &= ~MF_JUSTHIT;
+        }
+
+      /* killough 8/29/98: add to appropriate thread */
+      P_UpdateThinker(&corpsehit->thinker);
+
+                  return;
+                }
+            }
+        }
+    }
+  A_Chase(actor);  // Return to normal attack.
+}
+
+//
+// A_VileStart
+//
+
+void A_VileStart(mobj_t *actor)
+{
+  S_StartSound(actor, sfx_vilatk);
+}
+
+//
+// A_Fire
+// Keep fire in front of player unless out of sight
+//
+
+void A_StartFire(mobj_t *actor)
+{
+  S_StartSound(actor,sfx_flamst);
+  A_Fire(actor);
+}
+
+void A_FireCrackle(mobj_t* actor)
+{
+  S_StartSound(actor,sfx_flame);
+  A_Fire(actor);
+}
+
+void A_Fire(mobj_t *actor)
+{
+  unsigned an;
+  mobj_t *dest = actor->tracer;
+
+  if (!dest)
+    return;
+
+  // don't move it if the vile lost sight
+  if (!P_CheckSight(actor->target, dest) )
+    return;
+
+  an = dest->angle >> ANGLETOFINESHIFT;
+
+  P_UnsetThingPosition(actor);
+  actor->x = dest->x + FixedMul(24*FRACUNIT, finecosine[an]);
+  actor->y = dest->y + FixedMul(24*FRACUNIT, finesine[an]);
+  actor->z = dest->z;
+  P_SetThingPosition(actor);
+}
+
+//
+// A_VileTarget
+// Spawn the hellfire
+//
+
+void A_VileTarget(mobj_t *actor)
+{
+  mobj_t *fog;
+
+  if (!actor->target)
+    return;
+
+  A_FaceTarget(actor);
+
+  // killough 12/98: fix Vile fog coordinates // CPhipps - compatibility optioned
+  fog = P_SpawnMobj(actor->target->x,
+    (compatibility_level < lxdoom_1_compatibility) ? actor->target->x : actor->target->y,
+                    actor->target->z,MT_FIRE);
+
+  P_SetTarget(&actor->tracer, fog);
+  P_SetTarget(&fog->target, actor);
+  P_SetTarget(&fog->tracer, actor->target);
+  A_Fire(fog);
+}
+
+//
+// A_VileAttack
+//
+
+void A_VileAttack(mobj_t *actor)
+{
+  mobj_t *fire;
+  int    an;
+
+  if (!actor->target)
+    return;
+
+  A_FaceTarget(actor);
+
+  if (!P_CheckSight(actor, actor->target))
+    return;
+
+  S_StartSound(actor, sfx_barexp);
+  P_DamageMobj(actor->target, actor, actor, 20);
+  actor->target->momz = 1000*FRACUNIT/actor->target->info->mass;
+
+  an = actor->angle >> ANGLETOFINESHIFT;
+
+  fire = actor->tracer;
+
+  if (!fire)
+    return;
+
+  // move the fire between the vile and the player
+  fire->x = actor->target->x - FixedMul (24*FRACUNIT, finecosine[an]);
+  fire->y = actor->target->y - FixedMul (24*FRACUNIT, finesine[an]);
+  P_RadiusAttack(fire, actor, 70);
+}
+
+//
+// Mancubus attack,
+// firing three missiles (bruisers)
+// in three different directions?
+// Doesn't look like it.
+//
+
+#define FATSPREAD       (ANG90/8)
+
+void A_FatRaise(mobj_t *actor)
+{
+  A_FaceTarget(actor);
+  S_StartSound(actor, sfx_manatk);
+}
+
+void A_FatAttack1(mobj_t *actor)
+{
+  mobj_t *mo;
+  int    an;
+
+  if (!actor->target)
+    return;
+
+  A_FaceTarget(actor);
+
+  // Change direction  to ...
+  actor->angle += FATSPREAD;
+
+  P_SpawnMissile(actor, actor->target, MT_FATSHOT);
+
+  mo = P_SpawnMissile (actor, actor->target, MT_FATSHOT);
+  mo->angle += FATSPREAD;
+  an = mo->angle >> ANGLETOFINESHIFT;
+  mo->momx = FixedMul(mo->info->speed, finecosine[an]);
+  mo->momy = FixedMul(mo->info->speed, finesine[an]);
+}
+
+void A_FatAttack2(mobj_t *actor)
+{
+  mobj_t *mo;
+  int    an;
+
+  if (!actor->target)
+    return;
+
+  A_FaceTarget(actor);
+  // Now here choose opposite deviation.
+  actor->angle -= FATSPREAD;
+  P_SpawnMissile(actor, actor->target, MT_FATSHOT);
+
+  mo = P_SpawnMissile(actor, actor->target, MT_FATSHOT);
+  mo->angle -= FATSPREAD*2;
+  an = mo->angle >> ANGLETOFINESHIFT;
+  mo->momx = FixedMul(mo->info->speed, finecosine[an]);
+  mo->momy = FixedMul(mo->info->speed, finesine[an]);
+}
+
+void A_FatAttack3(mobj_t *actor)
+{
+  mobj_t *mo;
+  int    an;
+
+  if (!actor->target)
+    return;
+
+  A_FaceTarget(actor);
+
+  mo = P_SpawnMissile(actor, actor->target, MT_FATSHOT);
+  mo->angle -= FATSPREAD/2;
+  an = mo->angle >> ANGLETOFINESHIFT;
+  mo->momx = FixedMul(mo->info->speed, finecosine[an]);
+  mo->momy = FixedMul(mo->info->speed, finesine[an]);
+
+  mo = P_SpawnMissile(actor, actor->target, MT_FATSHOT);
+  mo->angle += FATSPREAD/2;
+  an = mo->angle >> ANGLETOFINESHIFT;
+  mo->momx = FixedMul(mo->info->speed, finecosine[an]);
+  mo->momy = FixedMul(mo->info->speed, finesine[an]);
+}
+
+
+//
+// SkullAttack
+// Fly at the player like a missile.
+//
+#define SKULLSPEED              (20*FRACUNIT)
+
+void A_SkullAttack(mobj_t *actor)
+{
+  mobj_t  *dest;
+  angle_t an;
+  int     dist;
+
+  if (!actor->target)
+    return;
+
+  dest = actor->target;
+  actor->flags |= MF_SKULLFLY;
+
+  S_StartSound(actor, actor->info->attacksound);
+  A_FaceTarget(actor);
+  an = actor->angle >> ANGLETOFINESHIFT;
+  actor->momx = FixedMul(SKULLSPEED, finecosine[an]);
+  actor->momy = FixedMul(SKULLSPEED, finesine[an]);
+  dist = P_AproxDistance(dest->x - actor->x, dest->y - actor->y);
+  dist = dist / SKULLSPEED;
+
+  if (dist < 1)
+    dist = 1;
+  actor->momz = (dest->z+(dest->height>>1) - actor->z) / dist;
+}
+
+//
+// A_PainShootSkull
+// Spawn a lost soul and launch it at the target
+//
+
+static void A_PainShootSkull(mobj_t *actor, angle_t angle)
+{
+  fixed_t       x,y,z;
+  mobj_t        *newmobj;
+  angle_t       an;
+  int           prestep;
+
+// The original code checked for 20 skulls on the level,            // phares
+// and wouldn't spit another one if there were. If not in           // phares
+// compatibility mode, we remove the limit.                         // phares
+                                                                    // phares
+  if (comp[comp_pain]) /* killough 10/98: compatibility-optioned */
+    {
+      // count total number of skulls currently on the level
+      int count = 0;
+      thinker_t *currentthinker = NULL;
+      while ((currentthinker = P_NextThinker(currentthinker,th_all)) != NULL)
+        if ((currentthinker->function == P_MobjThinker)
+            && ((mobj_t *)currentthinker)->type == MT_SKULL)
+          count++;
+      if (count > 20)                                               // phares
+        return;                                                     // phares
+    }
+
+  // okay, there's room for another one
+
+  an = angle >> ANGLETOFINESHIFT;
+
+  prestep = 4*FRACUNIT + 3*(actor->info->radius + mobjinfo[MT_SKULL].radius)/2;
+
+  x = actor->x + FixedMul(prestep, finecosine[an]);
+  y = actor->y + FixedMul(prestep, finesine[an]);
+  z = actor->z + 8*FRACUNIT;
+
+  if (comp[comp_skull])   /* killough 10/98: compatibility-optioned */
+    newmobj = P_SpawnMobj(x, y, z, MT_SKULL);                     // phares
+  else                                                            //   V
+    {
+      // Check whether the Lost Soul is being fired through a 1-sided
+      // wall or an impassible line, or a "monsters can't cross" line.
+      // If it is, then we don't allow the spawn. This is a bug fix, but
+      // it should be considered an enhancement, since it may disturb
+      // existing demos, so don't do it in compatibility mode.
+
+      if (Check_Sides(actor,x,y))
+        return;
+
+      newmobj = P_SpawnMobj(x, y, z, MT_SKULL);
+
+      // Check to see if the new Lost Soul's z value is above the
+      // ceiling of its new sector, or below the floor. If so, kill it.
+
+      if ((newmobj->z >
+           (newmobj->subsector->sector->ceilingheight - newmobj->height)) ||
+          (newmobj->z < newmobj->subsector->sector->floorheight))
+        {
+          // kill it immediately
+          P_DamageMobj(newmobj,actor,actor,10000);
+          return;                                                 //   ^
+        }                                                         //   |
+     }                                                            // phares
+
+  /* killough 7/20/98: PEs shoot lost souls with the same friendliness */
+  newmobj->flags = (newmobj->flags & ~MF_FRIEND) | (actor->flags & MF_FRIEND);
+
+  /* killough 8/29/98: add to appropriate thread */
+  P_UpdateThinker(&newmobj->thinker);
+
+  // Check for movements.
+  // killough 3/15/98: don't jump over dropoffs:
+
+  if (!P_TryMove(newmobj, newmobj->x, newmobj->y, false))
+    {
+      // kill it immediately
+      P_DamageMobj(newmobj, actor, actor, 10000);
+      return;
+    }
+
+  P_SetTarget(&newmobj->target, actor->target);
+  A_SkullAttack(newmobj);
+}
+
+//
+// A_PainAttack
+// Spawn a lost soul and launch it at the target
+//
+
+void A_PainAttack(mobj_t *actor)
+{
+  if (!actor->target)
+    return;
+  A_FaceTarget(actor);
+  A_PainShootSkull(actor, actor->angle);
+}
+
+void A_PainDie(mobj_t *actor)
+{
+  A_Fall(actor);
+  A_PainShootSkull(actor, actor->angle+ANG90);
+  A_PainShootSkull(actor, actor->angle+ANG180);
+  A_PainShootSkull(actor, actor->angle+ANG270);
+}
+
+void A_Scream(mobj_t *actor)
+{
+  int sound;
+
+  switch (actor->info->deathsound)
+    {
+    case 0:
+      return;
+
+    case sfx_podth1:
+    case sfx_podth2:
+    case sfx_podth3:
+      sound = sfx_podth1 + P_Random(pr_scream)%3;
+      break;
+
+    case sfx_bgdth1:
+    case sfx_bgdth2:
+      sound = sfx_bgdth1 + P_Random(pr_scream)%2;
+      break;
+
+    default:
+      sound = actor->info->deathsound;
+      break;
+    }
+
+  // Check for bosses.
+  if (actor->type==MT_SPIDER || actor->type == MT_CYBORG)
+    S_StartSound(NULL, sound); // full volume
+  else
+    S_StartSound(actor, sound);
+}
+
+void A_XScream(mobj_t *actor)
+{
+  S_StartSound(actor, sfx_slop);
+}
+
+void A_Pain(mobj_t *actor)
+{
+  if (actor->info->painsound)
+    S_StartSound(actor, actor->info->painsound);
+}
+
+void A_Fall(mobj_t *actor)
+{
+  // actor is on ground, it can be walked over
+  actor->flags &= ~MF_SOLID;
+}
+
+//
+// A_Explode
+//
+void A_Explode(mobj_t *thingy)
+{
+  P_RadiusAttack( thingy, thingy->target, 128 );
+}
+
+//
+// A_BossDeath
+// Possibly trigger special effects
+// if on first boss level
+//
+
+void A_BossDeath(mobj_t *mo)
+{
+  thinker_t *th;
+  line_t    junk;
+  int       i;
+
+  if (gamemode == commercial)
+    {
+      if (gamemap != 7)
+        return;
+
+      if ((mo->type != MT_FATSO)
+          && (mo->type != MT_BABY))
+        return;
+    }
+  else
+    {
+      // e6y
+      // Additional check of gameepisode is necessary, because 
+      // there is no right or wrong solution for E4M6 in original EXEs,
+      // there's nothing to emulate.
+      if (comp[comp_666] && gameepisode < 4)
+      {
+        // e6y
+        // Only following checks are present in doom2.exe ver. 1.666 and 1.9
+        // instead of separate checks for each episode in doomult.exe, plutonia.exe and tnt.exe
+        // There is no more desync on doom.wad\episode3.lmp
+        // http://www.doomworld.com/idgames/index.php?id=6909
+        if (gamemap != 8)
+          return;
+        if (mo->type == MT_BRUISER && gameepisode != 1) 
+          return;
+      }
+      else
+      {
+      switch(gameepisode)
+        {
+        case 1:
+          if (gamemap != 8)
+            return;
+
+          if (mo->type != MT_BRUISER)
+            return;
+          break;
+
+        case 2:
+          if (gamemap != 8)
+            return;
+
+          if (mo->type != MT_CYBORG)
+            return;
+          break;
+
+        case 3:
+          if (gamemap != 8)
+            return;
+
+          if (mo->type != MT_SPIDER)
+            return;
+
+          break;
+
+        case 4:
+          switch(gamemap)
+            {
+            case 6:
+              if (mo->type != MT_CYBORG)
+                return;
+              break;
+
+            case 8:
+              if (mo->type != MT_SPIDER)
+                return;
+              break;
+
+            default:
+              return;
+              break;
+            }
+          break;
+
+        default:
+          if (gamemap != 8)
+            return;
+          break;
+        }
+      }
+
+    }
+
+  // make sure there is a player alive for victory
+  for (i=0; i<MAXPLAYERS; i++)
+    if (playeringame[i] && players[i].health > 0)
+      break;
+
+  if (i==MAXPLAYERS)
+    return;     // no one left alive, so do not end game
+
+    // scan the remaining thinkers to see
+    // if all bosses are dead
+  for (th = thinkercap.next ; th != &thinkercap ; th=th->next)
+    if (th->function == P_MobjThinker)
+      {
+        mobj_t *mo2 = (mobj_t *) th;
+        if (mo2 != mo && mo2->type == mo->type && mo2->health > 0)
+          return;         // other boss not dead
+      }
+
+  // victory!
+  if ( gamemode == commercial)
+    {
+      if (gamemap == 7)
+        {
+          if (mo->type == MT_FATSO)
+            {
+              junk.tag = 666;
+              EV_DoFloor(&junk,lowerFloorToLowest);
+              return;
+            }
+
+          if (mo->type == MT_BABY)
+            {
+              junk.tag = 667;
+              EV_DoFloor(&junk,raiseToTexture);
+              return;
+            }
+        }
+    }
+  else
+    {
+      switch(gameepisode)
+        {
+        case 1:
+          junk.tag = 666;
+          EV_DoFloor(&junk, lowerFloorToLowest);
+          return;
+          break;
+
+        case 4:
+          switch(gamemap)
+            {
+            case 6:
+              junk.tag = 666;
+              EV_DoDoor(&junk, blazeOpen);
+              return;
+              break;
+
+            case 8:
+              junk.tag = 666;
+              EV_DoFloor(&junk, lowerFloorToLowest);
+              return;
+              break;
+            }
+        }
+    }
+  G_ExitLevel();
+}
+
+
+void A_Hoof (mobj_t* mo)
+{
+    S_StartSound(mo, sfx_hoof);
+    A_Chase(mo);
+}
+
+void A_Metal(mobj_t *mo)
+{
+  S_StartSound(mo, sfx_metal);
+  A_Chase(mo);
+}
+
+void A_BabyMetal(mobj_t *mo)
+{
+  S_StartSound(mo, sfx_bspwlk);
+  A_Chase(mo);
+}
+
+void A_OpenShotgun2(player_t *player, pspdef_t *psp)
+{
+  S_StartSound(player->mo, sfx_dbopn);
+}
+
+void A_LoadShotgun2(player_t *player, pspdef_t *psp)
+{
+  S_StartSound(player->mo, sfx_dbload);
+}
+
+void A_CloseShotgun2(player_t *player, pspdef_t *psp)
+{
+  S_StartSound(player->mo, sfx_dbcls);
+  A_ReFire(player,psp);
+}
+
+// killough 2/7/98: Remove limit on icon landings:
+mobj_t **braintargets;
+int    numbraintargets_alloc;
+int    numbraintargets;
+
+struct brain_s brain;   // killough 3/26/98: global state of boss brain
+
+// killough 3/26/98: initialize icon landings at level startup,
+// rather than at boss wakeup, to prevent savegame-related crashes
+
+void P_SpawnBrainTargets(void)  // killough 3/26/98: renamed old function
+{
+  thinker_t *thinker;
+
+  // find all the target spots
+  numbraintargets = 0;
+  brain.targeton = 0;
+  brain.easy = 0;           // killough 3/26/98: always init easy to 0
+
+  for (thinker = thinkercap.next ;
+       thinker != &thinkercap ;
+       thinker = thinker->next)
+    if (thinker->function == P_MobjThinker)
+      {
+        mobj_t *m = (mobj_t *) thinker;
+
+        if (m->type == MT_BOSSTARGET )
+          {   // killough 2/7/98: remove limit on icon landings:
+            if (numbraintargets >= numbraintargets_alloc)
+              braintargets = realloc(braintargets,
+                      (numbraintargets_alloc = numbraintargets_alloc ?
+                       numbraintargets_alloc*2 : 32) *sizeof *braintargets);
+            braintargets[numbraintargets++] = m;
+          }
+      }
+}
+
+void A_BrainAwake(mobj_t *mo)
+{
+  S_StartSound(NULL,sfx_bossit); // killough 3/26/98: only generates sound now
+}
+
+void A_BrainPain(mobj_t *mo)
+{
+  S_StartSound(NULL,sfx_bospn);
+}
+
+void A_BrainScream(mobj_t *mo)
+{
+  int x;
+  for (x=mo->x - 196*FRACUNIT ; x< mo->x + 320*FRACUNIT ; x+= FRACUNIT*8)
+    {
+      int y = mo->y - 320*FRACUNIT;
+      int z = 128 + P_Random(pr_brainscream)*2*FRACUNIT;
+      mobj_t *th = P_SpawnMobj (x,y,z, MT_ROCKET);
+      th->momz = P_Random(pr_brainscream)*512;
+      P_SetMobjState(th, S_BRAINEXPLODE1);
+      th->tics -= P_Random(pr_brainscream)&7;
+      if (th->tics < 1)
+        th->tics = 1;
+    }
+  S_StartSound(NULL,sfx_bosdth);
+}
+
+void A_BrainExplode(mobj_t *mo)
+{  // killough 5/5/98: remove dependence on order of evaluation:
+  int t = P_Random(pr_brainexp);
+  int x = mo->x + (t - P_Random(pr_brainexp))*2048;
+  int y = mo->y;
+  int z = 128 + P_Random(pr_brainexp)*2*FRACUNIT;
+  mobj_t *th = P_SpawnMobj(x,y,z, MT_ROCKET);
+  th->momz = P_Random(pr_brainexp)*512;
+  P_SetMobjState(th, S_BRAINEXPLODE1);
+  th->tics -= P_Random(pr_brainexp)&7;
+  if (th->tics < 1)
+    th->tics = 1;
+}
+
+void A_BrainDie(mobj_t *mo)
+{
+  G_ExitLevel();
+}
+
+void A_BrainSpit(mobj_t *mo)
+{
+  mobj_t *targ, *newmobj;
+
+  if (!numbraintargets)     // killough 4/1/98: ignore if no targets
+    return;
+
+  brain.easy ^= 1;          // killough 3/26/98: use brain struct
+  if (gameskill <= sk_easy && !brain.easy)
+    return;
+
+  // shoot a cube at current target
+  targ = braintargets[brain.targeton++]; // killough 3/26/98:
+  brain.targeton %= numbraintargets;     // Use brain struct for targets
+
+  // spawn brain missile
+  newmobj = P_SpawnMissile(mo, targ, MT_SPAWNSHOT);
+  P_SetTarget(&newmobj->target, targ);
+  newmobj->reactiontime = (short)(((targ->y-mo->y)/newmobj->momy)/newmobj->state->tics);
+
+  // killough 7/18/98: brain friendliness is transferred
+  newmobj->flags = (newmobj->flags & ~MF_FRIEND) | (mo->flags & MF_FRIEND);
+
+  // killough 8/29/98: add to appropriate thread
+  P_UpdateThinker(&newmobj->thinker);
+
+  S_StartSound(NULL, sfx_bospit);
+}
+
+// travelling cube sound
+void A_SpawnSound(mobj_t *mo)
+{
+  S_StartSound(mo,sfx_boscub);
+  A_SpawnFly(mo);
+}
+
+void A_SpawnFly(mobj_t *mo)
+{
+  mobj_t *newmobj;
+  mobj_t *fog;
+  mobj_t *targ;
+  int    r;
+  mobjtype_t type;
+
+  if (--mo->reactiontime)
+    return;     // still flying
+
+  targ = mo->target;
+
+  // First spawn teleport fog.
+  fog = P_SpawnMobj(targ->x, targ->y, targ->z, MT_SPAWNFIRE);
+  S_StartSound(fog, sfx_telept);
+
+  // Randomly select monster to spawn.
+  r = P_Random(pr_spawnfly);
+
+  // Probability distribution (kind of :), decreasing likelihood.
+  if ( r<50 )
+    type = MT_TROOP;
+  else if (r<90)
+    type = MT_SERGEANT;
+  else if (r<120)
+    type = MT_SHADOWS;
+  else if (r<130)
+    type = MT_PAIN;
+  else if (r<160)
+    type = MT_HEAD;
+  else if (r<162)
+    type = MT_VILE;
+  else if (r<172)
+    type = MT_UNDEAD;
+  else if (r<192)
+    type = MT_BABY;
+  else if (r<222)
+    type = MT_FATSO;
+  else if (r<246)
+    type = MT_KNIGHT;
+  else
+    type = MT_BRUISER;
+
+  newmobj = P_SpawnMobj(targ->x, targ->y, targ->z, type);
+
+  /* killough 7/18/98: brain friendliness is transferred */
+  newmobj->flags = (newmobj->flags & ~MF_FRIEND) | (mo->flags & MF_FRIEND);
+
+  /* killough 8/29/98: add to appropriate thread */
+  P_UpdateThinker(&newmobj->thinker);
+
+  if (P_LookForTargets(newmobj,true))      /* killough 9/4/98 */
+    P_SetMobjState(newmobj, newmobj->info->seestate);
+
+    // telefrag anything in this spot
+  P_TeleportMove(newmobj, newmobj->x, newmobj->y, true); /* killough 8/9/98 */
+
+  // remove self (i.e., cube).
+  P_RemoveMobj(mo);
+}
+
+void A_PlayerScream(mobj_t *mo)
+{
+  int sound = sfx_pldeth;  // Default death sound.
+  if (gamemode != shareware && mo->health < -50)
+    sound = sfx_pdiehi;   // IF THE PLAYER DIES LESS THAN -50% WITHOUT GIBBING
+  S_StartSound(mo, sound);
+}
+
+/* cph - MBF-added codepointer functions */
+
+// killough 11/98: kill an object
+void A_Die(mobj_t *actor)
+{
+  P_DamageMobj(actor, NULL, NULL, actor->health);
+}
+
+//
+// A_Detonate
+// killough 8/9/98: same as A_Explode, except that the damage is variable
+//
+
+void A_Detonate(mobj_t *mo)
+{
+  P_RadiusAttack(mo, mo->target, mo->info->damage);
+}
+
+//
+// killough 9/98: a mushroom explosion effect, sorta :)
+// Original idea: Linguica
+//
+
+void A_Mushroom(mobj_t *actor)
+{
+  int i, j, n = actor->info->damage;
+
+  A_Explode(actor);  // First make normal explosion
+
+  // Now launch mushroom cloud
+  for (i = -n; i <= n; i += 8)
+    for (j = -n; j <= n; j += 8)
+      {
+  mobj_t target = *actor, *mo;
+  target.x += i << FRACBITS;    // Aim in many directions from source
+  target.y += j << FRACBITS;
+  target.z += P_AproxDistance(i,j) << (FRACBITS+2); // Aim up fairly high
+  mo = P_SpawnMissile(actor, &target, MT_FATSHOT);  // Launch fireball
+  mo->momx >>= 1;
+  mo->momy >>= 1;                                   // Slow it down a bit
+  mo->momz >>= 1;
+  mo->flags &= ~MF_NOGRAVITY;   // Make debris fall under gravity
+      }
+}
+
+//
+// killough 11/98
+//
+// The following were inspired by Len Pitre
+//
+// A small set of highly-sought-after code pointers
+//
+
+void A_Spawn(mobj_t *mo)
+{
+  if (mo->state->misc1)
+    {
+      /* mobj_t *newmobj = */
+      P_SpawnMobj(mo->x, mo->y, (mo->state->misc2 << FRACBITS) + mo->z,
+      mo->state->misc1 - 1);
+      /* CPhipps - no friendlyness (yet)
+   newmobj->flags = (newmobj->flags & ~MF_FRIEND) | (mo->flags & MF_FRIEND);
+      */
+    }
+}
+
+void A_Turn(mobj_t *mo)
+{
+  mo->angle += (unsigned int)(((uint_64_t) mo->state->misc1 << 32) / 360);
+}
+
+void A_Face(mobj_t *mo)
+{
+  mo->angle = (unsigned int)(((uint_64_t) mo->state->misc1 << 32) / 360);
+}
+
+void A_Scratch(mobj_t *mo)
+{
+  mo->target && (A_FaceTarget(mo), P_CheckMeleeRange(mo)) ?
+    mo->state->misc2 ? S_StartSound(mo, mo->state->misc2) : (void) 0,
+    P_DamageMobj(mo->target, mo, mo, mo->state->misc1) : (void) 0;
+}
+
+void A_PlaySound(mobj_t *mo)
+{
+  S_StartSound(mo->state->misc2 ? NULL : mo, mo->state->misc1);
+}
+
+void A_RandomJump(mobj_t *mo)
+{
+  if (P_Random(pr_randomjump) < mo->state->misc2)
+    P_SetMobjState(mo, mo->state->misc1);
+}
+
+//
+// This allows linedef effects to be activated inside deh frames.
+//
+
+void A_LineEffect(mobj_t *mo)
+{
+  static line_t junk;
+  player_t player;
+  player_t *oldplayer;
+  junk = *lines;
+  oldplayer = mo->player;
+  mo->player = &player;
+  player.health = 100;
+  junk.special = (short)mo->state->misc1;
+  if (!junk.special)
+    return;
+  junk.tag = (short)mo->state->misc2;
+  if (!P_UseSpecialLine(mo, &junk, 0))
+    P_CrossSpecialLine(&junk, 0, mo);
+  mo->state->misc1 = junk.special;
+  mo->player = oldplayer;
+}