Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

3384 lines (2945 sloc) 88.045 kb
// Emacs style mode select -*- C++ -*-
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
// Enemy thinking, AI.
// Action Pointer Functions
// that are associated with states/frames.
//
//-----------------------------------------------------------------------------
#include <stdlib.h>
#include "templates.h"
#include "m_random.h"
#include "i_system.h"
#include "doomdef.h"
#include "p_local.h"
#include "m_bbox.h"
#include "p_lnspec.h"
#include "s_sound.h"
#include "g_game.h"
#include "doomstat.h"
#include "r_state.h"
#include "c_cvars.h"
#include "p_enemy.h"
#include "a_sharedglobal.h"
#include "a_action.h"
#include "thingdef/thingdef.h"
#include "d_dehacked.h"
#include "g_level.h"
#include "teaminfo.h"
#include "gi.h"
static FRandom pr_checkmissilerange ("CheckMissileRange");
static FRandom pr_opendoor ("OpenDoor");
static FRandom pr_trywalk ("TryWalk");
static FRandom pr_newchasedir ("NewChaseDir");
static FRandom pr_lookformonsters ("LookForMonsters");
static FRandom pr_lookforplayers ("LookForPlayers");
static FRandom pr_scaredycat ("Anubis");
FRandom pr_chase ("Chase");
static FRandom pr_facetarget ("FaceTarget");
static FRandom pr_railface ("RailFace");
static FRandom pr_dropitem ("DropItem");
static FRandom pr_look2 ("LookyLooky");
static FRandom pr_look3 ("IGotHooky");
static FRandom pr_slook ("SlooK");
static FRandom pr_dropoff ("Dropoff");
static FRandom pr_defect ("Defect");
static FRandom pr_skiptarget("SkipTarget");
static FRandom pr_enemystrafe("EnemyStrafe");
// movement interpolation is fine for objects that are moved by their own
// velocity. But for monsters it is problematic.
// 1. They don't move every tic
// 2. Their animation is not designed for movement interpolation
// The result is that they tend to 'glide' across the floor
// so this CVAR allows to switch it off.
CVAR(Bool, nomonsterinterpolation, false, CVAR_GLOBALCONFIG|CVAR_ARCHIVE)
//
// P_NewChaseDir related LUT.
//
dirtype_t opposite[9] =
{
DI_WEST, DI_SOUTHWEST, DI_SOUTH, DI_SOUTHEAST,
DI_EAST, DI_NORTHEAST, DI_NORTH, DI_NORTHWEST, DI_NODIR
};
dirtype_t diags[4] =
{
DI_NORTHWEST, DI_NORTHEAST, DI_SOUTHWEST, DI_SOUTHEAST
};
fixed_t xspeed[8] = {FRACUNIT,46341,0,-46341,-FRACUNIT,-46341,0,46341};
fixed_t yspeed[8] = {0,46341,FRACUNIT,46341,0,-46341,-FRACUNIT,-46341};
void P_RandomChaseDir (AActor *actor);
//
// ENEMY THINKING
// Enemies are always spawned
// with targetplayer = -1, threshold = 0
// Most monsters are spawned unaware of all players,
// but some can be made preaware
//
//----------------------------------------------------------------------------
//
// PROC P_RecursiveSound
//
// Called by P_NoiseAlert.
// Recursively traverse adjacent sectors,
// sound blocking lines cut off traversal.
//----------------------------------------------------------------------------
void P_RecursiveSound (sector_t *sec, AActor *soundtarget, bool splash, int soundblocks, AActor *emitter, fixed_t maxdist)
{
int i;
line_t* check;
sector_t* other;
AActor* actor;
// 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;
sec->SoundTarget = soundtarget;
// [RH] Set this in the actors in the sector instead of the sector itself.
for (actor = sec->thinglist; actor != NULL; actor = actor->snext)
{
if (actor != soundtarget && (!splash || !(actor->flags4 & MF4_NOSPLASHALERT)) &&
(!maxdist || (P_AproxDistance(actor->x - emitter->x, actor->y - emitter->y) <= maxdist)))
{
actor->LastHeard = soundtarget;
}
}
for (i = 0; i < sec->linecount; i++)
{
check = sec->lines[i];
if (check->sidedef[1] == NULL ||
!(check->flags & ML_TWOSIDED))
{
continue;
}
// Early out for intra-sector lines
if (check->sidedef[0]->sector == check->sidedef[1]->sector) continue;
if ( check->sidedef[0]->sector == sec)
other = check->sidedef[1]->sector;
else
other = check->sidedef[0]->sector;
// check for closed door
if ((sec->floorplane.ZatPoint (check->v1->x, check->v1->y) >=
other->ceilingplane.ZatPoint (check->v1->x, check->v1->y) &&
sec->floorplane.ZatPoint (check->v2->x, check->v2->y) >=
other->ceilingplane.ZatPoint (check->v2->x, check->v2->y))
|| (other->floorplane.ZatPoint (check->v1->x, check->v1->y) >=
sec->ceilingplane.ZatPoint (check->v1->x, check->v1->y) &&
other->floorplane.ZatPoint (check->v2->x, check->v2->y) >=
sec->ceilingplane.ZatPoint (check->v2->x, check->v2->y))
|| (other->floorplane.ZatPoint (check->v1->x, check->v1->y) >=
other->ceilingplane.ZatPoint (check->v1->x, check->v1->y) &&
other->floorplane.ZatPoint (check->v2->x, check->v2->y) >=
other->ceilingplane.ZatPoint (check->v2->x, check->v2->y)))
{
continue;
}
if (check->flags & ML_SOUNDBLOCK)
{
if (!soundblocks)
P_RecursiveSound (other, soundtarget, splash, 1, emitter, maxdist);
}
else
{
P_RecursiveSound (other, soundtarget, splash, soundblocks, emitter, maxdist);
}
}
}
//----------------------------------------------------------------------------
//
// PROC P_NoiseAlert
//
// If a monster yells at a player, it will alert other monsters to the
// player.
//
//----------------------------------------------------------------------------
void P_NoiseAlert (AActor *target, AActor *emitter, bool splash, fixed_t maxdist)
{
if (emitter == NULL)
return;
if (target != NULL && target->player && (target->player->cheats & CF_NOTARGET))
return;
validcount++;
P_RecursiveSound (emitter->Sector, target, splash, 0, emitter, maxdist);
}
//----------------------------------------------------------------------------
//
// AActor :: CheckMeleeRange
//
//----------------------------------------------------------------------------
bool AActor::CheckMeleeRange ()
{
AActor *pl = target;
fixed_t dist;
if (!pl)
return false;
dist = P_AproxDistance (pl->x - x, pl->y - y);
if (dist >= meleerange + pl->radius)
return false;
// [RH] If moving toward goal, then we've reached it.
if (pl == goal)
return true;
// [RH] Don't melee things too far above or below actor.
if (!(flags5 & MF5_NOVERTICALMELEERANGE))
{
if (pl->z > z + height)
return false;
if (pl->z + pl->height < z)
return false;
}
// killough 7/18/98: friendly monsters don't attack other friends
if (IsFriend(pl))
return false;
if (!P_CheckSight (this, pl, 0))
return false;
return true;
}
//----------------------------------------------------------------------------
//
// FUNC P_CheckMeleeRange2
//
//----------------------------------------------------------------------------
bool P_CheckMeleeRange2 (AActor *actor)
{
AActor *mo;
fixed_t dist;
if (!actor->target)
{
return false;
}
mo = actor->target;
dist = P_AproxDistance (mo->x-actor->x, mo->y-actor->y);
if (dist >= MELEERANGE*2 || dist < MELEERANGE-20*FRACUNIT + mo->radius)
{
return false;
}
if (mo->z > actor->z+actor->height)
{ // Target is higher than the attacker
return false;
}
else if (actor->z > mo->z+mo->height)
{ // Attacker is higher
return false;
}
else if (actor->IsFriend(mo))
{
// killough 7/18/98: friendly monsters don't attack other friends
return false;
}
if (!P_CheckSight(actor, mo))
{
return false;
}
return true;
}
//=============================================================================
//
// P_CheckMissileRange
//
//=============================================================================
bool P_CheckMissileRange (AActor *actor)
{
fixed_t dist;
if (!P_CheckSight (actor, actor->target, SF_SEEPASTBLOCKEVERYTHING))
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
// Cleaned up and made readable
if (!(actor->flags & MF_FRIENDLY)) return true;
if (actor->target->health <= 0) return false;
if (!actor->IsFriend(actor->target)) return true;
if (actor->target->player != NULL)
{
return (pr_defect() >128);
}
else
{
return !(actor->target->flags & MF_JUSTHIT) && pr_defect() >128;
}
}
if (actor->reactiontime)
return false; // do not attack yet
// killough 7/18/98: friendly monsters don't attack other friendly
// monsters or players (except when attacked, and then only once)
if (actor->IsFriend(actor->target))
return false;
if (actor->flags & MF_FRIENDLY && P_HitFriend(actor))
return false;
// OPTIMIZE: get this from a global checksight
// [RH] What?
dist = P_AproxDistance (actor->x-actor->target->x,
actor->y-actor->target->y) - 64*FRACUNIT;
if (actor->MeleeState == NULL)
dist -= 128*FRACUNIT; // no melee attack, so fire more
return actor->SuggestMissileAttack (dist);
}
bool AActor::SuggestMissileAttack (fixed_t dist)
{
// new version encapsulates the different behavior in flags instead of virtual functions
// The advantage is that this allows inheriting the missile attack attributes from the
// various Doom monsters by custom monsters
if (maxtargetrange > 0 && dist > maxtargetrange)
return false; // The Arch Vile's special behavior turned into a property
if (MeleeState != NULL && dist < meleethreshold)
return false; // From the Revenant: close enough for fist attack
if (flags4 & MF4_MISSILEMORE) dist >>= 1;
if (flags4 & MF4_MISSILEEVENMORE) dist >>= 3;
int mmc = FixedMul(MinMissileChance, G_SkillProperty(SKILLP_Aggressiveness));
return pr_checkmissilerange() >= MIN<int> (dist >> FRACBITS, mmc);
}
//=============================================================================
//
// P_HitFriend()
//
// killough 12/98
// This function tries to prevent shooting at friends that get in the line of fire
//
// [GrafZahl] Taken from MBF but this has been cleaned up to make it readable.
//
//=============================================================================
bool P_HitFriend(AActor * self)
{
AActor *linetarget;
if (self->flags&MF_FRIENDLY && self->target != NULL)
{
angle_t angle = R_PointToAngle2 (self->x, self->y, self->target->x, self->target->y);
fixed_t dist = P_AproxDistance (self->x - self->target->x, self->y - self->target->y);
P_AimLineAttack (self, angle, dist, &linetarget, 0, true);
if (linetarget != NULL && linetarget != self->target)
{
return self->IsFriend (linetarget);
}
}
return false;
}
//
// P_Move
// Move in the current direction,
// returns false if the move is blocked.
//
bool P_Move (AActor *actor)
{
fixed_t tryx, tryy, deltax, deltay, origx, origy;
bool try_ok;
int speed = actor->Speed;
int movefactor = ORIG_FRICTION_FACTOR;
int friction = ORIG_FRICTION;
int dropoff = 0;
if (actor->flags2 & MF2_BLASTED)
{
return true;
}
if (actor->movedir == DI_NODIR)
{
return false;
}
// [RH] Walking actors that are not on the ground cannot walk. We don't
// want to yank them to the ground here as Doom did, since that makes
// it difficult to thrust them vertically in a reasonable manner.
// [GZ] Let jumping actors jump.
if (!((actor->flags & MF_NOGRAVITY) || (actor->flags6 & MF6_CANJUMP))
&& actor->z > actor->floorz && !(actor->flags2 & MF2_ONMOBJ))
{
return false;
}
if ((unsigned)actor->movedir >= 8)
I_Error ("Weird actor->movedir!");
// 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.
AActor *target = actor->target;
if ((actor->flags6 & MF6_JUMPDOWN) && target &&
!(target->IsFriend(actor)) &&
P_AproxDistance(actor->x - target->x, actor->y - target->y) < FRACUNIT*144 &&
pr_dropoff() < 235)
{
dropoff = 2;
}
// [RH] I'm not so sure this is such a good idea
// [GZ] That's why it's compat-optioned.
if (compatflags & COMPATF_MBFMONSTERMOVE)
{
// killough 10/98: make monsters get affected by ice and sludge too:
movefactor = P_GetMoveFactor (actor, &friction);
if (friction < ORIG_FRICTION)
{ // sludge
speed = ((ORIG_FRICTION_FACTOR - (ORIG_FRICTION_FACTOR-movefactor)/2)
* speed) / ORIG_FRICTION_FACTOR;
if (speed == 0)
{ // always give the monster a little bit of speed
speed = ksgn(actor->Speed);
}
}
}
tryx = (origx = actor->x) + (deltax = FixedMul (speed, xspeed[actor->movedir]));
tryy = (origy = actor->y) + (deltay = FixedMul (speed, yspeed[actor->movedir]));
// Like P_XYMovement this should do multiple moves if the step size is too large
fixed_t maxmove = actor->radius - FRACUNIT;
int steps = 1;
if (maxmove > 0)
{
const fixed_t xspeed = abs (deltax);
const fixed_t yspeed = abs (deltay);
if (xspeed > yspeed)
{
if (xspeed > maxmove)
{
steps = 1 + xspeed / maxmove;
}
}
else
{
if (yspeed > maxmove)
{
steps = 1 + yspeed / maxmove;
}
}
}
FCheckPosition tm;
tm.FromPMove = true;
try_ok = true;
for(int i=1; i < steps; i++)
{
try_ok = P_TryMove(actor, origx + Scale(deltax, i, steps), origy + Scale(deltay, i, steps), dropoff, NULL, tm);
if (!try_ok) break;
}
// killough 3/15/98: don't jump over dropoffs:
if (try_ok) try_ok = P_TryMove (actor, tryx, tryy, dropoff, NULL, tm);
// [GrafZahl] Interpolating monster movement as it is done here just looks bad
// so make it switchable
if (nomonsterinterpolation)
{
actor->PrevX = actor->x;
actor->PrevY = actor->y;
actor->PrevZ = actor->z;
}
if (try_ok && friction > ORIG_FRICTION)
{
actor->x = origx;
actor->y = origy;
movefactor *= FRACUNIT / ORIG_FRICTION_FACTOR / 4;
actor->velx += FixedMul (deltax, movefactor);
actor->vely += FixedMul (deltay, movefactor);
}
// [RH] If a walking monster is no longer on the floor, move it down
// to the floor if it is within MaxStepHeight, presuming that it is
// actually walking down a step.
if (try_ok &&
!((actor->flags & MF_NOGRAVITY) || (actor->flags6 & MF6_CANJUMP))
&& actor->z > actor->floorz && !(actor->flags2 & MF2_ONMOBJ))
{
if (actor->z <= actor->floorz + actor->MaxStepHeight)
{
fixed_t savedz = actor->z;
actor->z = actor->floorz;
// Make sure that there isn't some other actor between us and
// the floor we could get stuck in. The old code did not do this.
if (!P_TestMobjZ(actor))
{
actor->z = savedz;
}
}
}
if (!try_ok)
{
if (((actor->flags6 & MF6_CANJUMP)||(actor->flags & MF_FLOAT)) && tm.floatok)
{ // must adjust height
fixed_t savedz = actor->z;
if (actor->z < tm.floorz)
actor->z += actor->FloatSpeed;
else
actor->z -= actor->FloatSpeed;
// [RH] Check to make sure there's nothing in the way of the float
if (P_TestMobjZ (actor))
{
actor->flags |= MF_INFLOAT;
return true;
}
actor->z = savedz;
}
if (!spechit.Size ())
{
return false;
}
// open any specials
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).
line_t *ld;
int good = 0;
if (!(actor->flags6 & MF6_NOTRIGGER))
{
while (spechit.Pop (ld))
{
// [RH] let monsters push lines, as well as use them
if (((actor->flags4 & MF4_CANUSEWALLS) && P_ActivateLine (ld, actor, 0, SPAC_Use)) ||
((actor->flags2 & MF2_PUSHWALL) && P_ActivateLine (ld, actor, 0, SPAC_Push)))
{
good |= ld == actor->BlockingLine ? 1 : 2;
}
}
}
else spechit.Clear();
return good && ((pr_opendoor() >= 203) ^ (good & 1));
}
else
{
actor->flags &= ~MF_INFLOAT;
}
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.
//
//=============================================================================
bool P_TryWalk (AActor *actor)
{
if (!P_Move (actor))
{
return false;
}
actor->movecount = pr_trywalk() & 15;
return true;
}
//=============================================================================
//
// P_DoNewChaseDir
//
// killough 9/8/98:
//
// Most of P_NewChaseDir(), except for what
// determines the new direction to take
//
//=============================================================================
void P_DoNewChaseDir (AActor *actor, fixed_t deltax, fixed_t deltay)
{
dirtype_t d[3];
int tdir;
dirtype_t olddir, turnaround;
olddir = (dirtype_t)actor->movedir;
turnaround = opposite[olddir];
if (deltax>10*FRACUNIT)
d[1]= DI_EAST;
else if (deltax<-10*FRACUNIT)
d[1]= DI_WEST;
else
d[1]=DI_NODIR;
if (deltay<-10*FRACUNIT)
d[2]= DI_SOUTH;
else if (deltay>10*FRACUNIT)
d[2]= DI_NORTH;
else
d[2]=DI_NODIR;
// try direct route
if (d[1] != DI_NODIR && d[2] != DI_NODIR)
{
actor->movedir = diags[((deltay<0)<<1) + (deltax>0)];
if (actor->movedir != turnaround && P_TryWalk(actor))
return;
}
// try other directions
if (!(actor->flags5 & MF5_AVOIDINGDROPOFF))
{
if ((pr_newchasedir() > 200 || abs(deltay) > abs(deltax)))
{
swapvalues (d[1], d[2]);
}
if (d[1] == turnaround)
d[1] = DI_NODIR;
if (d[2] == turnaround)
d[2] = DI_NODIR;
}
if (d[1] != DI_NODIR)
{
actor->movedir = d[1];
if (P_TryWalk (actor))
{
// either moved forward or attacked
return;
}
}
if (d[2] != DI_NODIR)
{
actor->movedir = d[2];
if (P_TryWalk (actor))
return;
}
if (!(actor->flags5 & MF5_AVOIDINGDROPOFF))
{
// there is no direct path to the player, so pick another direction.
if (olddir != DI_NODIR)
{
actor->movedir = olddir;
if (P_TryWalk (actor))
return;
}
}
// randomly determine direction of search
if (pr_newchasedir() & 1)
{
for (tdir = DI_EAST; tdir <= DI_SOUTHEAST; tdir++)
{
if (tdir != turnaround)
{
actor->movedir = tdir;
if ( P_TryWalk(actor) )
return;
}
}
}
else
{
for (tdir = DI_SOUTHEAST; tdir != (DI_EAST-1); tdir--)
{
if (tdir != turnaround)
{
actor->movedir = tdir;
if ( P_TryWalk(actor) )
return;
}
}
}
if (turnaround != DI_NODIR)
{
actor->movedir =turnaround;
if ( P_TryWalk(actor) )
return;
}
actor->movedir = DI_NODIR; // cannot move
}
//=============================================================================
//
// 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.
//=============================================================================
//=============================================================================
//
// P_NewChaseDir
//
// killough 9/8/98: Split into two functions
//
//=============================================================================
void P_NewChaseDir(AActor * actor)
{
fixed_t deltax;
fixed_t deltay;
actor->strafecount = 0;
if ((actor->flags5&MF5_CHASEGOAL || actor->goal == actor->target) && actor->goal!=NULL)
{
deltax = actor->goal->x - actor->x;
deltay = actor->goal->y - actor->y;
}
else if (actor->target != NULL)
{
deltax = actor->target->x - actor->x;
deltay = actor->target->y - actor->y;
if (!(actor->flags6 & MF6_NOFEAR))
{
if ((actor->target->player != NULL && (actor->target->player->cheats & CF_FRIGHTENING)) ||
(actor->flags4 & MF4_FRIGHTENED))
{
deltax = -deltax;
deltay = -deltay;
}
}
}
else
{
// Don't abort if this happens.
Printf ("P_NewChaseDir: called with no target\n");
P_RandomChaseDir(actor);
return;
}
// Try to move away from a dropoff
if (actor->floorz - actor->dropoffz > actor->MaxDropOffHeight &&
actor->z <= actor->floorz && !(actor->flags & MF_DROPOFF) &&
!(actor->flags2 & MF2_ONMOBJ) &&
!(actor->flags & MF_FLOAT) && !(i_compatflags & COMPATF_DROPOFF))
{
FBoundingBox box(actor->x, actor->y, actor->radius);
FBlockLinesIterator it(box);
line_t *line;
fixed_t deltax = 0;
fixed_t deltay = 0;
while ((line = it.Next()))
{
if (line->backsector && // Ignore one-sided linedefs
box.Right() > line->bbox[BOXLEFT] &&
box.Left() < line->bbox[BOXRIGHT] &&
box.Top() > line->bbox[BOXBOTTOM] && // Linedef must be contacted
box.Bottom() < line->bbox[BOXTOP] &&
box.BoxOnLineSide(line) == -1)
{
fixed_t front = line->frontsector->floorplane.ZatPoint(actor->x,actor->y);
fixed_t back = line->backsector->floorplane.ZatPoint(actor->x,actor->y);
angle_t angle;
// The monster must contact one of the two floors,
// and the other must be a tall dropoff.
if (back == actor->z && front < actor->z - actor->MaxDropOffHeight)
{
angle = R_PointToAngle2(0,0,line->dx,line->dy); // front side dropoff
}
else if (front == actor->z && back < actor->z - actor->MaxDropOffHeight)
{
angle = R_PointToAngle2(line->dx,line->dy,0,0); // back side dropoff
}
else continue;
// Move away from dropoff at a standard speed.
// Multiple contacted linedefs are cumulative (e.g. hanging over corner)
deltax -= finesine[angle >> ANGLETOFINESHIFT]*32;
deltay += finecosine[angle >> ANGLETOFINESHIFT]*32;
}
}
if (deltax || deltay)
{
// [Graf Zahl] I have changed P_TryMove to only apply this logic when
// being called from here. AVOIDINGDROPOFF activates the code that
// allows monsters to move away from a dropoff. This is different from
// MBF which requires unconditional use of the altered logic and therefore
// forcing a massive change in the monster behavior to use this.
// use different dropoff movement logic in P_TryMove
actor->flags5|=MF5_AVOIDINGDROPOFF;
P_DoNewChaseDir(actor, deltax, deltay);
actor->flags5&=~MF5_AVOIDINGDROPOFF;
// 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;
}
}
#if 0
// Move away from friends when too close, except
// in certain situations (e.g. a crowded lift)
// MBF code for friends. Cannot be done in ZDoom but left here as a reminder for later implementation.
if (actor->flags & target->flags & MF_FRIEND &&
distfriend << FRACBITS > dist &&
!P_IsOnLift(target) && !P_IsUnderDamage(actor))
deltax = -deltax, deltay = -deltay;
else
#endif
// MBF's monster_backing option. Made an actor flag instead. Also cleaned the code up to make it readable.
// Todo: implement the movement logic
AActor *target = actor->target;
if (target->health > 0 && !actor->IsFriend(target))
{ // Live enemy target
if (actor->flags3 & MF3_AVOIDMELEE)
{
bool ismeleeattacker = false;
fixed_t dist = P_AproxDistance(actor->x-target->x, actor->y-target->y);
if (target->player == NULL)
{
ismeleeattacker = (target->MissileState == NULL && dist < (target->meleerange + target->radius)*2);
}
else if (target->player->ReadyWeapon != NULL)
{
// melee range of player weapon is a parameter of the action function and cannot be checked here.
// Add a new weapon property?
ismeleeattacker = (target->player->ReadyWeapon->WeaponFlags & WIF_MELEEWEAPON && dist < MELEERANGE*3);
}
if (ismeleeattacker)
{
actor->strafecount = 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_RandomChaseDir
//
//=============================================================================
void P_RandomChaseDir (AActor *actor)
{
dirtype_t olddir, turnaround;
int tdir, i;
olddir = (dirtype_t)actor->movedir;
turnaround = opposite[olddir];
int turndir;
// Friendly monsters like to head toward a player
if (actor->flags & MF_FRIENDLY)
{
AActor *player;
fixed_t deltax, deltay;
dirtype_t d[3];
if (actor->FriendPlayer != 0)
{
player = players[i = actor->FriendPlayer - 1].mo;
}
else
{
if (!multiplayer)
{
i = 0;
}
else for (i = pr_newchasedir() & (MAXPLAYERS-1); !playeringame[i]; i = (i+1) & (MAXPLAYERS-1))
{
}
player = players[i].mo;
}
if (player != NULL && playeringame[i])
{
if (pr_newchasedir() & 1 || !P_CheckSight (actor, player))
{
deltax = player->x - actor->x;
deltay = player->y - actor->y;
if (deltax>128*FRACUNIT)
d[1]= DI_EAST;
else if (deltax<-128*FRACUNIT)
d[1]= DI_WEST;
else
d[1]=DI_NODIR;
if (deltay<-128*FRACUNIT)
d[2]= DI_SOUTH;
else if (deltay>128*FRACUNIT)
d[2]= DI_NORTH;
else
d[2]=DI_NODIR;
// try direct route
if (d[1] != DI_NODIR && d[2] != DI_NODIR)
{
actor->movedir = diags[((deltay<0)<<1) + (deltax>0)];
if (actor->movedir != turnaround && P_TryWalk(actor))
return;
}
// try other directions
if (pr_newchasedir() > 200 || abs(deltay) > abs(deltax))
{
swapvalues (d[1], d[2]);
}
if (d[1] == turnaround)
d[1] = DI_NODIR;
if (d[2] == turnaround)
d[2] = DI_NODIR;
if (d[1] != DI_NODIR)
{
actor->movedir = d[1];
if (P_TryWalk (actor))
{
// either moved forward or attacked
return;
}
}
if (d[2] != DI_NODIR)
{
actor->movedir = d[2];
if (P_TryWalk (actor))
return;
}
}
}
}
// If the actor elects to continue in its current direction, let it do
// so unless the way is blocked. Then it must turn.
if (pr_newchasedir() < 150)
{
if (P_TryWalk (actor))
return;
}
turndir = (pr_newchasedir() & 1) ? -1 : 1;
if (olddir == DI_NODIR)
{
olddir = (dirtype_t)(pr_newchasedir() & 7);
}
for (tdir = (olddir + turndir) & 7; tdir != olddir; tdir = (tdir + turndir) & 7)
{
if (tdir != turnaround)
{
actor->movedir = tdir;
if (P_TryWalk (actor))
return;
}
}
/*
if (pr_newchasedir() & 1)
{
for (tdir = olddir; tdir <= DI_SOUTHEAST; ++tdir)
{
if (tdir != turnaround)
{
actor->movedir = tdir;
if (P_TryWalk (actor))
return;
}
}
}
else
{
for (tdir = DI_SOUTHEAST; tdir >= DI_EAST; --tdir)
{
if (tdir != turnaround)
{
actor->movedir = tdir;
if (P_TryWalk (actor))
return;
}
}
}
*/
if (turnaround != DI_NODIR)
{
actor->movedir = turnaround;
if (P_TryWalk (actor))
{
actor->movecount = pr_newchasedir() & 15;
return;
}
}
actor->movedir = DI_NODIR; // cannot move
}
//---------------------------------------------------------------------------
//
// P_IsVisible
//
// killough 9/9/98: whether a target is visible to a monster
// Extended to handle all A_LookEx related checking, too.
//
//---------------------------------------------------------------------------
bool P_IsVisible(AActor *lookee, AActor *other, INTBOOL allaround, FLookExParams *params)
{
fixed_t maxdist;
fixed_t mindist;
angle_t fov;
if (params != NULL)
{
maxdist = params->maxdist;
mindist = params->mindist;
fov = params->fov;
}
else
{
mindist = maxdist = 0;
fov = allaround ? 0 : ANGLE_180;
}
fixed_t dist = P_AproxDistance (other->x - lookee->x, other->y - lookee->y);
if (maxdist && dist > maxdist)
return false; // [KS] too far
if (mindist && dist < mindist)
return false; // [KS] too close
if (fov && fov < ANGLE_MAX)
{
angle_t an = R_PointToAngle2 (lookee->x, lookee->y, other->x, other->y) - lookee->angle;
if (an > (fov / 2) && an < (ANGLE_MAX - (fov / 2)))
{
// if real close, react anyway
// [KS] but respect minimum distance rules
if (mindist || dist > MELEERANGE)
return false; // outside of fov
}
}
// P_CheckSight is by far the most expensive operation in here so let's do it last.
return P_CheckSight(lookee, other, SF_SEEPASTSHOOTABLELINES);
}
//---------------------------------------------------------------------------
//
// FUNC P_LookForMonsters
//
//---------------------------------------------------------------------------
#define MONS_LOOK_RANGE (20*64*FRACUNIT)
#define MONS_LOOK_LIMIT 64
bool P_LookForMonsters (AActor *actor)
{
int count;
AActor *mo;
TThinkerIterator<AActor> iterator;
if (!P_CheckSight (players[0].mo, actor, SF_SEEPASTBLOCKEVERYTHING))
{ // Player can't see monster
return false;
}
count = 0;
while ( (mo = iterator.Next ()) )
{
if (!(mo->flags3 & MF3_ISMONSTER) || (mo == actor) || (mo->health <= 0))
{ // Not a valid monster
continue;
}
if (P_AproxDistance (actor->x-mo->x, actor->y-mo->y)
> MONS_LOOK_RANGE)
{ // Out of range
continue;
}
if (pr_lookformonsters() < 16)
{ // Skip
continue;
}
if (++count >= MONS_LOOK_LIMIT)
{ // Stop searching
return false;
}
if (mo->GetSpecies() == actor->GetSpecies())
{ // [RH] Don't go after same species
continue;
}
if (!P_CheckSight (actor, mo, SF_SEEPASTBLOCKEVERYTHING))
{ // Out of sight
continue;
}
// Found a target monster
actor->target = mo;
return true;
}
return false;
}
//============================================================================
//
// LookForTIDinBlock
//
// Finds a target with the specified TID in a mapblock. Alternatively, it
// can find a target with a specified TID if something in this mapblock is
// already targetting it.
//
//============================================================================
AActor *LookForTIDInBlock (AActor *lookee, int index, void *extparams)
{
FLookExParams *params = (FLookExParams *)extparams;
FBlockNode *block;
AActor *link;
AActor *other;
for (block = blocklinks[index]; block != NULL; block = block->NextActor)
{
link = block->Me;
if (!(link->flags & MF_SHOOTABLE))
continue; // not shootable (observer or dead)
if (link == lookee)
continue;
if (link->health <= 0)
continue; // dead
if (link->flags2 & MF2_DORMANT)
continue; // don't target dormant things
if (link->tid == lookee->TIDtoHate)
{
other = link;
}
else if (link->target != NULL && link->target->tid == lookee->TIDtoHate)
{
other = link->target;
if (!(other->flags & MF_SHOOTABLE) ||
other->health <= 0 ||
(other->flags2 & MF2_DORMANT))
{
continue;
}
}
else
{
continue;
}
if (!(lookee->flags3 & MF3_NOSIGHTCHECK))
{
if (!P_IsVisible(lookee, other, true, params))
continue; // out of sight
}
return other;
}
return NULL;
}
//============================================================================
//
// P_LookForTID
//
// Selects a live monster with the given TID
//
//============================================================================
bool P_LookForTID (AActor *actor, INTBOOL allaround, FLookExParams *params)
{
AActor *other;
bool reachedend = false;
bool chasegoal = params? (!(params->flags & LOF_DONTCHASEGOAL)) : true;
other = P_BlockmapSearch (actor, 0, LookForTIDInBlock, params);
if (other != NULL)
{
if (actor->goal && actor->target == actor->goal)
actor->reactiontime = 0;
actor->target = other;
actor->LastLookActor = other;
return true;
}
// The actor's TID could change because of death or because of
// Thing_ChangeTID. If it's not what we expect, then don't use
// it as a base for the iterator.
if (actor->LastLookActor != NULL &&
actor->LastLookActor->tid != actor->TIDtoHate)
{
actor->LastLookActor = NULL;
}
FActorIterator iterator (actor->TIDtoHate, actor->LastLookActor);
int c = (pr_look3() & 31) + 7; // Look for between 7 and 38 hatees at a time
while ((other = iterator.Next()) != actor->LastLookActor)
{
if (other == NULL)
{
if (reachedend)
{
// we have cycled through the entire list at least once
// so let's abort because even if we continue nothing can
// be found.
break;
}
reachedend = true;
continue;
}
if (!(other->flags & MF_SHOOTABLE))
continue; // not shootable (observer or dead)
if (other == actor)
continue; // don't hate self
if (other->health <= 0)
continue; // dead
if (other->flags2 & MF2_DORMANT)
continue; // don't target dormant things
if (--c == 0)
break;
if (!(actor->flags3 & MF3_NOSIGHTCHECK))
{
if (!P_IsVisible (actor, other, !!allaround, params))
continue; // out of sight
}
// [RH] Need to be sure the reactiontime is 0 if the monster is
// leaving its goal to go after something else.
if (actor->goal && actor->target == actor->goal)
actor->reactiontime = 0;
actor->target = other;
actor->LastLookActor = other;
return true;
}
actor->LastLookActor = other;
if (actor->target == NULL)
{
// [RH] use goal as target
if (actor->goal != NULL && chasegoal)
{
actor->target = actor->goal;
return true;
}
// Use last known enemy if no hatee sighted -- killough 2/15/98:
if (actor->lastenemy != NULL && actor->lastenemy->health > 0)
{
if (!actor->IsFriend(actor->lastenemy))
{
actor->target = actor->lastenemy;
actor->lastenemy = NULL;
return true;
}
else
{
actor->lastenemy = NULL;
}
}
}
return false;
}
//============================================================================
//
// LookForEnemiesinBlock
//
// Finds a non-friendly monster in a mapblock. It can also use targets of
// friendlies in this mapblock to find non-friendlies in other mapblocks.
//
//============================================================================
AActor *LookForEnemiesInBlock (AActor *lookee, int index, void *extparam)
{
FBlockNode *block;
AActor *link;
AActor *other;
FLookExParams *params = (FLookExParams *)extparam;
for (block = blocklinks[index]; block != NULL; block = block->NextActor)
{
link = block->Me;
if (!(link->flags & MF_SHOOTABLE))
continue; // not shootable (observer or dead)
if (link == lookee)
continue;
if (link->health <= 0)
continue; // dead
if (link->flags2 & MF2_DORMANT)
continue; // don't target dormant things
if (!(link->flags3 & MF3_ISMONSTER))
continue; // don't target it if it isn't a monster (could be a barrel)
other = NULL;
if (link->flags & MF_FRIENDLY)
{
if (!lookee->IsFriend(link))
{
// This is somebody else's friend, so go after it
other = link;
}
else if (link->target != NULL && !(link->target->flags & MF_FRIENDLY))
{
other = link->target;
if (!(other->flags & MF_SHOOTABLE) ||
other->health <= 0 ||
(other->flags2 & MF2_DORMANT))
{
other = NULL;;
}
}
}
else
{
other = link;
}
// [MBF] If the monster is already engaged in a one-on-one attack
// with a healthy friend, don't attack around 60% the time.
// [GrafZahl] This prevents friendlies from attacking all the same
// target.
if (other)
{
AActor *targ = other->target;
if (targ && targ->target == other && pr_skiptarget() > 100 && lookee->IsFriend (targ) &&
targ->health*2 >= targ->SpawnHealth())
{
continue;
}
}
// [KS] Hey, shouldn't there be a check for MF3_NOSIGHTCHECK here?
if (other == NULL || !P_IsVisible (lookee, other, true, params))
continue; // out of sight
return other;
}
return NULL;
}
//============================================================================
//
// P_LookForEnemies
//
// Selects a live enemy monster
//
//============================================================================
bool P_LookForEnemies (AActor *actor, INTBOOL allaround, FLookExParams *params)
{
AActor *other;
other = P_BlockmapSearch (actor, 10, LookForEnemiesInBlock, params);
if (other != NULL)
{
if (actor->goal && actor->target == actor->goal)
actor->reactiontime = 0;
actor->target = other;
// actor->LastLook.Actor = other;
return true;
}
if (actor->target == NULL)
{
// [RH] use goal as target
if (actor->goal != NULL)
{
actor->target = actor->goal;
return true;
}
// Use last known enemy if no hatee sighted -- killough 2/15/98:
if (actor->lastenemy != NULL && actor->lastenemy->health > 0)
{
if (!actor->IsFriend(actor->lastenemy))
{
actor->target = actor->lastenemy;
actor->lastenemy = NULL;
return true;
}
else
{
actor->lastenemy = NULL;
}
}
}
return false;
}
/*
================
=
= P_LookForPlayers
=
= If allaround is false, only look 180 degrees in front
= returns true if a player is targeted
================
*/
bool P_LookForPlayers (AActor *actor, INTBOOL allaround, FLookExParams *params)
{
int c;
int stop;
int pnum;
player_t* player;
bool chasegoal = params? (!(params->flags & LOF_DONTCHASEGOAL)) : true;
if (actor->TIDtoHate != 0)
{
if (P_LookForTID (actor, allaround, params))
{
return true;
}
if (!(actor->flags3 & MF3_HUNTPLAYERS))
{
return false;
}
}
else if (actor->flags & MF_FRIENDLY)
{
bool result = P_LookForEnemies (actor, allaround, params);
#ifdef MBF_FRIENDS
if (!result && (actor->flags & MF_FRIEND_MBF))
{ // killough 9/9/98: friendly monsters go about players differently
// Go back to a player, no matter whether it's visible or not
for (int anyone=0; anyone<=1; anyone++)
{
for (int c=0; c<MAXPLAYERS; c++)
{
if (playeringame[c] && players[c].playerstate==PST_LIVE &&
actor->IsFriend(players[c].mo) &&
(anyone || P_IsVisible(actor, players[c].mo, allaround)))
{
actor->target = players[c].mo;
// killough 12/98:
// get out of refiring loop, to avoid hitting player accidentally
if (actor->MissileState != NULL)
{
actor->SetState(actor->SeeState, true);
actor->flags &= ~MF_JUSTHIT;
}
return true;
}
}
}
}
#endif
// [SP] If you don't see any enemies in deathmatch, look for players (but only when friend to a specific player.)
if (actor->FriendPlayer == 0 && (!teamplay || actor->DesignatedTeam == TEAM_NONE)) return result;
if (result || !deathmatch) return true;
} // [SP] if false, and in deathmatch, intentional fall-through
if (!(gameinfo.gametype & (GAME_DoomStrifeChex)) &&
!multiplayer &&
players[0].health <= 0)
{ // Single player game and player is dead; look for monsters
return P_LookForMonsters (actor);
}
c = 0;
if (actor->TIDtoHate != 0)
{
pnum = pr_look2() & (MAXPLAYERS-1);
}
else
{
pnum = actor->LastLookPlayerNumber;
}
stop = (pnum - 1) & (MAXPLAYERS-1);
for (;;)
{
pnum = (pnum + 1) & (MAXPLAYERS-1);
if (!playeringame[pnum])
continue;
if (actor->TIDtoHate == 0)
{
actor->LastLookPlayerNumber = pnum;
}
if (++c == MAXPLAYERS-1 || pnum == stop)
{
// done looking
if (actor->target == NULL)
{
// [RH] use goal as target
// [KS] ...unless we're ignoring goals and we don't already have one
if (actor->goal != NULL && chasegoal)
{
actor->target = actor->goal;
return true;
}
// Use last known enemy if no players sighted -- killough 2/15/98:
if (actor->lastenemy != NULL && actor->lastenemy->health > 0)
{
if (!actor->IsFriend(actor->lastenemy))
{
actor->target = actor->lastenemy;
actor->lastenemy = NULL;
return true;
}
else
{
actor->lastenemy = NULL;
}
}
}
return actor->target == actor->goal && actor->goal != NULL;
}
player = &players[pnum];
if (!(player->mo->flags & MF_SHOOTABLE))
continue; // not shootable (observer or dead)
if (player->cheats & CF_NOTARGET)
continue; // no target
if (player->health <= 0)
continue; // dead
if (!P_IsVisible (actor, player->mo, allaround, params))
continue; // out of sight
// [SP] Deathmatch fixes - if we have MF_FRIENDLY we're definitely in deathmatch
// We're going to ignore our master, but go after his enemies.
if ( actor->flags & MF_FRIENDLY )
{
if ( actor->IsFriend(player->mo) )
continue;
}
// [RC] Well, let's let special monsters with this flag active be able to see
// the player then, eh?
if(!(actor->flags6 & MF6_SEEINVISIBLE))
{
if ((player->mo->flags & MF_SHADOW && !(i_compatflags & COMPATF_INVISIBILITY)) ||
player->mo->flags3 & MF3_GHOST)
{
if ((P_AproxDistance (player->mo->x - actor->x,
player->mo->y - actor->y) > 2*MELEERANGE)
&& P_AproxDistance (player->mo->velx, player->mo->vely)
< 5*FRACUNIT)
{ // Player is sneaking - can't detect
return false;
}
if (pr_lookforplayers() < 225)
{ // Player isn't sneaking, but still didn't detect
return false;
}
}
}
// [RH] Need to be sure the reactiontime is 0 if the monster is
// leaving its goal to go after a player.
if (actor->goal && actor->target == actor->goal)
actor->reactiontime = 0;
actor->target = player->mo;
return true;
}
}
//
// ACTION ROUTINES
//
//
// A_Look
// Stay in state until a player is sighted.
// [RH] Will also leave state to move to goal.
//
DEFINE_ACTION_FUNCTION(AActor, A_Look)
{
AActor *targ;
if (self->flags5 & MF5_INCONVERSATION)
return;
// [RH] Set goal now if appropriate
if (self->special == Thing_SetGoal && self->args[0] == 0)
{
NActorIterator iterator (NAME_PatrolPoint, self->args[1]);
self->special = 0;
self->goal = iterator.Next ();
self->reactiontime = self->args[2] * TICRATE + level.maptime;
if (self->args[3] == 0) self->flags5 &= ~MF5_CHASEGOAL;
else self->flags5 |= MF5_CHASEGOAL;
}
self->threshold = 0; // any shot will wake up
if (self->TIDtoHate != 0)
{
targ = self->target;
}
else
{
targ = (i_compatflags & COMPATF_SOUNDTARGET || self->flags & MF_NOSECTOR)?
self->Sector->SoundTarget : self->LastHeard;
// [RH] If the soundtarget is dead, don't chase it
if (targ != NULL && targ->health <= 0)
{
targ = NULL;
}
if (targ && targ->player && (targ->player->cheats & CF_NOTARGET))
{
return;
}
}
// [RH] Andy Baker's stealth monsters
if (self->flags & MF_STEALTH)
{
self->visdir = -1;
}
if (targ && (targ->flags & MF_SHOOTABLE))
{
if (self->IsFriend (targ)) // be a little more precise!
{
// If we find a valid target here, the wandering logic should *not*
// be activated! It would cause the seestate to be set twice.
if (P_LookForPlayers (self, self->flags4 & MF4_LOOKALLAROUND, NULL))
goto seeyou;
// Let the self wander around aimlessly looking for a fight
if (self->SeeState != NULL)
{
self->SetState (self->SeeState);
}
else
{
CALL_ACTION(A_Wander, self);
}
}
else
{
self->target = targ;
if (self->flags & MF_AMBUSH)
{
if (P_CheckSight (self, self->target, SF_SEEPASTBLOCKEVERYTHING))
goto seeyou;
}
else
goto seeyou;
}
}
if (!P_LookForPlayers (self, self->flags4 & MF4_LOOKALLAROUND, NULL))
return;
// go into chase state
seeyou:
// [RH] Don't start chasing after a goal if it isn't time yet.
if (self->target == self->goal)
{
if (self->reactiontime > level.maptime)
self->target = NULL;
}
else if (self->SeeSound)
{
if (self->flags2 & MF2_BOSS)
{ // full volume
S_Sound (self, CHAN_VOICE, self->SeeSound, 1, ATTN_NONE);
}
else
{
S_Sound (self, CHAN_VOICE, self->SeeSound, 1, ATTN_NORM);
}
}
if (self->target)
{
self->SetState (self->SeeState);
}
}
//==========================================================================
//
// A_LookEx (int flags, fixed minseedist, fixed maxseedist, fixed maxheardist, fixed fov, state wakestate)
// [KS] Borrowed the A_Look code to make a parameterized version.
//
//==========================================================================
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_LookEx)
{
ACTION_PARAM_START(6);
ACTION_PARAM_INT(flags, 0);
ACTION_PARAM_FIXED(minseedist, 1);
ACTION_PARAM_FIXED(maxseedist, 2);
ACTION_PARAM_FIXED(maxheardist, 3);
ACTION_PARAM_DOUBLE(fov_f, 4);
ACTION_PARAM_STATE(seestate, 5);
AActor *targ = NULL; // Shuts up gcc
fixed_t dist;
angle_t fov = (fov_f == 0) ? ANGLE_180 : angle_t(fov_f * ANGLE_90 / 90);
FLookExParams params = { fov, minseedist, maxseedist, maxheardist, flags, seestate };
if (self->flags5 & MF5_INCONVERSATION)
return;
// [RH] Set goal now if appropriate
if (self->special == Thing_SetGoal && self->args[0] == 0)
{
NActorIterator iterator (NAME_PatrolPoint, self->args[1]);
self->special = 0;
self->goal = iterator.Next ();
self->reactiontime = self->args[2] * TICRATE + level.maptime;
if (self->args[3] == 0) self->flags5 &=~ MF5_CHASEGOAL;
else self->flags5 |= MF5_CHASEGOAL;
}
self->threshold = 0; // any shot will wake up
if (self->TIDtoHate != 0)
{
targ = self->target;
}
else
{
if (!(flags & LOF_NOSOUNDCHECK))
{
targ = (self->flags & MF_NOSECTOR)? self->Sector->SoundTarget : self->LastHeard;
if (targ != NULL)
{
// [RH] If the soundtarget is dead, don't chase it
if (targ->health <= 0)
{
targ = NULL;
}
else
{
dist = P_AproxDistance (targ->x - self->x,
targ->y - self->y);
// [KS] If the target is too far away, don't respond to the sound.
if (maxheardist && dist > maxheardist)
{
targ = NULL;
self->LastHeard = NULL;
}
}
}
}
if (targ && targ->player && (targ->player->cheats & CF_NOTARGET))
{
return;
}
}
// [RH] Andy Baker's stealth monsters
if (self->flags & MF_STEALTH)
{
self->visdir = -1;
}
if (targ && (targ->flags & MF_SHOOTABLE))
{
if (self->IsFriend (targ)) // be a little more precise!
{
if (!(self->flags4 & MF4_STANDSTILL))
{
if (!(flags & LOF_NOSIGHTCHECK))
{
// If we find a valid target here, the wandering logic should *not*
// be activated! If would cause the seestate to be set twice.
if (P_LookForPlayers(self, true, &params))
goto seeyou;
}
// Let the self wander around aimlessly looking for a fight
if (!(self->flags & MF_INCHASE))
{
if (seestate)
{
self->SetState (seestate);
}
else
{
if (self->SeeState != NULL)
{
self->SetState (self->SeeState);
}
else
{
CALL_ACTION(A_Wander, self);
}
}
}
}
}
else
{
self->target = targ; //We already have a target?
// [KS] The target can become ourselves in rare circumstances (like
// if we committed suicide), so if that's the case, just ignore it.
if (self->target == self) self->target = NULL;
if (self->target != NULL)
{
if (self->flags & MF_AMBUSH)
{
dist = P_AproxDistance (self->target->x - self->x,
self->target->y - self->y);
if (P_CheckSight (self, self->target, SF_SEEPASTBLOCKEVERYTHING) &&
(!minseedist || dist > minseedist) &&
(!maxseedist || dist < maxseedist))
{
goto seeyou;
}
}
else
goto seeyou;
}
}
}
if (!(flags & LOF_NOSIGHTCHECK))
{
if (!P_LookForPlayers(self, true, &params))
return;
}
else
{
return;
}
// go into chase state
seeyou:
// [RH] Don't start chasing after a goal if it isn't time yet.
if (self->target == self->goal)
{
if (self->reactiontime > level.maptime)
self->target = NULL;
}
else if (self->SeeSound && !(flags & LOF_NOSEESOUND))
{
if (flags & LOF_FULLVOLSEESOUND)
{ // full volume
S_Sound (self, CHAN_VOICE, self->SeeSound, 1, ATTN_NONE);
}
else
{
S_Sound (self, CHAN_VOICE, self->SeeSound, 1, ATTN_NORM);
}
}
if (self->target && !(self->flags & MF_INCHASE))
{
if (!(flags & LOF_NOJUMP))
{
if (seestate)
{
self->SetState (seestate);
}
else
{
self->SetState (self->SeeState);
}
}
}
}
// [KS] *** End additions by me ***
//==========================================================================
//
// A_ClearLastHeard
//
//==========================================================================
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_ClearLastHeard)
{
self->LastHeard = NULL;
}
//==========================================================================
//
// A_Wander
//
//==========================================================================
DEFINE_ACTION_FUNCTION(AActor, A_Wander)
{
// [RH] Strife probably clears this flag somewhere, but I couldn't find where.
// This seems as good a place as any.
self->flags4 &= ~MF4_INCOMBAT;
if (self->flags5 & MF5_INCONVERSATION)
return;
if (self->flags4 & MF4_STANDSTILL)
return;
if (self->reactiontime != 0)
{
self->reactiontime--;
return;
}
// turn towards movement direction if not there yet
if (self->movedir < DI_NODIR)
{
self->angle &= (angle_t)(7<<29);
int delta = self->angle - (self->movedir << 29);
if (delta > 0)
{
self->angle -= ANG90/2;
}
else if (delta < 0)
{
self->angle += ANG90/2;
}
}
if (--self->movecount < 0 || !P_Move (self))
{
P_RandomChaseDir (self);
self->movecount += 5;
}
}
//==========================================================================
//
// A_Look2
//
//==========================================================================
DEFINE_ACTION_FUNCTION(AActor, A_Look2)
{
AActor *targ;
if (self->flags5 & MF5_INCONVERSATION)
return;
self->threshold = 0;
targ = self->LastHeard;
if (targ != NULL && targ->health <= 0)
{
targ = NULL;
}
if (targ && (targ->flags & MF_SHOOTABLE))
{
if ((level.flags & LEVEL_NOALLIES) ||
(self->flags & MF_FRIENDLY) != (targ->flags & MF_FRIENDLY))
{
if (self->flags & MF_AMBUSH)
{
if (!P_CheckSight (self, targ, SF_SEEPASTBLOCKEVERYTHING))
goto nosee;
}
self->target = targ;
self->threshold = 10;
self->SetState (self->SeeState);
return;
}
else
{
if (!P_LookForPlayers (self, self->flags4 & MF4_LOOKALLAROUND, NULL))
goto nosee;
self->SetState (self->SeeState);
self->flags4 |= MF4_INCOMBAT;
return;
}
}
nosee:
if (pr_look2() < 30)
{
self->SetState (self->SpawnState + (pr_look2() & 1) + 1);
}
if (!(self->flags4 & MF4_STANDSTILL) && pr_look2() < 40)
{
self->SetState (self->SpawnState + 3);
}
}
//=============================================================================
//
// A_Chase
//
// Actor has a melee attack, so it tries to close as fast as possible
//
// [GrafZahl] integrated A_FastChase, A_SerpentChase and A_SerpentWalk into this
// to allow the monsters using those functions to take advantage of the
// enhancements.
//
//=============================================================================
#define CLASS_BOSS_STRAFE_RANGE 64*10*FRACUNIT
void A_DoChase (AActor *actor, bool fastchase, FState *meleestate, FState *missilestate, bool playactive, bool nightmarefast, bool dontmove)
{
int delta;
if (actor->flags5 & MF5_INCONVERSATION)
return;
if (actor->flags & MF_INCHASE)
{
return;
}
actor->flags |= MF_INCHASE;
// [RH] Andy Baker's stealth monsters
if (actor->flags & MF_STEALTH)
{
actor->visdir = -1;
}
if (actor->reactiontime)
{
actor->reactiontime--;
}
// [RH] Don't chase invisible targets
if (actor->target != NULL &&
actor->target->renderflags & RF_INVISIBLE &&
actor->target != actor->goal)
{
actor->target = NULL;
}
// modify target threshold
if (actor->threshold)
{
if (actor->target == NULL || actor->target->health <= 0)
{
actor->threshold = 0;
}
else
{
actor->threshold--;
}
}
if (nightmarefast && G_SkillProperty(SKILLP_FastMonsters))
{ // Monsters move faster in nightmare mode
if (actor->tics > 3)
{
actor->tics -= actor->tics / 2;
if (actor->tics < 3)
{
actor->tics = 3;
}
}
}
// turn towards movement direction if not there yet
if (actor->strafecount)
{
A_FaceTarget(actor);
}
else if (actor->movedir < 8)
{
actor->angle &= (angle_t)(7<<29);
delta = actor->angle - (actor->movedir << 29);
if (delta > 0)
{
actor->angle -= ANG90/2;
}
else if (delta < 0)
{
actor->angle += ANG90/2;
}
}
// [RH] If the target is dead or a friend (and not a goal), stop chasing it.
if (actor->target && actor->target != actor->goal && (actor->target->health <= 0 || actor->IsFriend(actor->target)))
actor->target = NULL;
// [RH] Friendly monsters will consider chasing whoever hurts a player if they
// don't already have a target.
if (actor->flags & MF_FRIENDLY && actor->target == NULL)
{
player_t *player;
if (actor->FriendPlayer != 0)
{
player = &players[actor->FriendPlayer - 1];
}
else
{
int i;
if (!multiplayer)
{
i = 0;
}
else for (i = pr_newchasedir() & (MAXPLAYERS-1); !playeringame[i]; i = (i+1) & (MAXPLAYERS-1))
{
}
player = &players[i];
}
if (player->attacker && player->attacker->health > 0 && player->attacker->flags & MF_SHOOTABLE && pr_newchasedir() < 80)
{
if (!(player->attacker->flags & MF_FRIENDLY) ||
(deathmatch && actor->FriendPlayer != 0 && player->attacker->FriendPlayer != 0 &&
actor->FriendPlayer != player->attacker->FriendPlayer))
{
actor->target = player->attacker;
}
}
}
if (!actor->target || !(actor->target->flags & MF_SHOOTABLE))
{ // look for a new target
if (actor->target != NULL && (actor->target->flags2 & MF2_NONSHOOTABLE))
{
// Target is only temporarily unshootable, so remember it.
actor->lastenemy = actor->target;
// Switch targets faster, since we're only changing because we can't
// hurt our old one temporarily.
actor->threshold = 0;
}
if (P_LookForPlayers (actor, true, NULL) && actor->target != actor->goal)
{ // got a new target
actor->flags &= ~MF_INCHASE;
return;
}
if (actor->target == NULL)
{
if (actor->flags & MF_FRIENDLY)
{
//CALL_ACTION(A_Look, actor);
if (actor->target == NULL)
{
if (!dontmove) CALL_ACTION(A_Wander, actor);
actor->flags &= ~MF_INCHASE;
return;
}
}
else
{
actor->SetIdle();
actor->flags &= ~MF_INCHASE;
return;
}
}
}
// do not attack twice in a row
if (actor->flags & MF_JUSTATTACKED)
{
actor->flags &= ~MF_JUSTATTACKED;
if (!actor->isFast() && !dontmove)
{
P_NewChaseDir (actor);
}
actor->flags &= ~MF_INCHASE;
return;
}
// [RH] Don't attack if just moving toward goal
if (actor->target == actor->goal || (actor->flags5&MF5_CHASEGOAL && actor->goal != NULL))
{
AActor * savedtarget = actor->target;
actor->target = actor->goal;
bool result = actor->CheckMeleeRange();
actor->target = savedtarget;
if (result)
{
// reached the goal
NActorIterator iterator (NAME_PatrolPoint, actor->goal->args[0]);
NActorIterator specit (NAME_PatrolSpecial, actor->goal->tid);
AActor *spec;
// Execute the specials of any PatrolSpecials with the same TID
// as the goal.
while ( (spec = specit.Next()) )
{
P_ExecuteSpecial(spec->special, NULL, actor, false, spec->args[0],
spec->args[1], spec->args[2], spec->args[3], spec->args[4]);
}
angle_t lastgoalang = actor->goal->angle;
int delay;
AActor * newgoal = iterator.Next ();
if (newgoal != NULL && actor->goal == actor->target)
{
delay = newgoal->args[1];
actor->reactiontime = delay * TICRATE + level.maptime;
}
else
{
delay = 0;
actor->reactiontime = actor->GetDefault()->reactiontime;
actor->angle = lastgoalang; // Look in direction of last goal
}
if (actor->target == actor->goal) actor->target = NULL;
actor->flags |= MF_JUSTATTACKED;
if (newgoal != NULL && delay != 0)
{
actor->flags4 |= MF4_INCOMBAT;
actor->SetIdle();
}
actor->flags &= ~MF_INCHASE;
actor->goal = newgoal;
return;
}
if (actor->goal == actor->target) goto nomissile;
}
// Strafe (Hexen's class bosses)
// This was the sole reason for the separate A_FastChase function but
// it can be just as easily handled by a simple flag so the monsters
// can take advantage of all the other enhancements of A_Chase.
if (fastchase && !dontmove)
{
if (actor->FastChaseStrafeCount > 0)
{
actor->FastChaseStrafeCount--;
}
else
{
actor->FastChaseStrafeCount = 0;
actor->velx = 0;
actor->vely = 0;
fixed_t dist = P_AproxDistance (actor->x - actor->target->x, actor->y - actor->target->y);
if (dist < CLASS_BOSS_STRAFE_RANGE)
{
if (pr_chase() < 100)
{
angle_t ang = R_PointToAngle2(actor->x, actor->y, actor->target->x, actor->target->y);
if (pr_chase() < 128) ang += ANGLE_90;
else ang -= ANGLE_90;
actor->velx = 13 * finecosine[ang>>ANGLETOFINESHIFT];
actor->vely = 13 * finesine[ang>>ANGLETOFINESHIFT];
actor->FastChaseStrafeCount = 3; // strafe time
}
}
}
}
// [RH] Scared monsters attack less frequently
if (((actor->target->player == NULL ||
!(actor->target->player->cheats & CF_FRIGHTENING)) &&
!(actor->flags4 & MF4_FRIGHTENED)) ||
pr_scaredycat() < 43)
{
// check for melee attack
if (meleestate && actor->CheckMeleeRange ())
{
if (actor->AttackSound)
S_Sound (actor, CHAN_WEAPON, actor->AttackSound, 1, ATTN_NORM);
actor->SetState (meleestate);
actor->flags &= ~MF_INCHASE;
return;
}
// check for missile attack
if (missilestate)
{
if (!actor->isFast() && actor->movecount)
{
goto nomissile;
}
if (!P_CheckMissileRange (actor))
goto nomissile;
actor->SetState (missilestate);
actor->flags |= MF_JUSTATTACKED;
actor->flags4 |= MF4_INCOMBAT;
actor->flags &= ~MF_INCHASE;
return;
}
}
nomissile:
// possibly choose another target
if ((multiplayer || actor->TIDtoHate)
&& !actor->threshold
&& !P_CheckSight (actor, actor->target, 0) )
{
bool lookForBetter = false;
bool gotNew;
if (actor->flags3 & MF3_NOSIGHTCHECK)
{
actor->flags3 &= ~MF3_NOSIGHTCHECK;
lookForBetter = true;
}
AActor * oldtarget = actor->target;
gotNew = P_LookForPlayers (actor, true, NULL);
if (lookForBetter)
{
actor->flags3 |= MF3_NOSIGHTCHECK;
}
if (gotNew && actor->target != oldtarget)
{
actor->flags &= ~MF_INCHASE;
return; // got a new target
}
}
//
// chase towards player
//
if (actor->strafecount)
actor->strafecount--;
// class bosses don't do this when strafing
if ((!fastchase || !actor->FastChaseStrafeCount) && !dontmove)
{
// CANTLEAVEFLOORPIC handling was completely missing in the non-serpent functions.
fixed_t oldX = actor->x;
fixed_t oldY = actor->y;
FTextureID oldFloor = actor->floorpic;
// chase towards player
if (--actor->movecount < 0 || !P_Move (actor))
{
P_NewChaseDir (actor);
}
// if the move was illegal, reset it
// (copied from A_SerpentChase - it applies to everything with CANTLEAVEFLOORPIC!)
if (actor->flags2&MF2_CANTLEAVEFLOORPIC && actor->floorpic != oldFloor )
{
if (P_TryMove (actor, oldX, oldY, false))
{
if (nomonsterinterpolation)
{
actor->PrevX = oldX;
actor->PrevY = oldY;
}
}
P_NewChaseDir (actor);
}
}
else if (dontmove && actor->movecount > 0) actor->movecount--;
// make active sound
if (playactive && pr_chase() < 3)
{
actor->PlayActiveSound ();
}
actor->flags &= ~MF_INCHASE;
}
//==========================================================================
//
// P_CheckForResurrection (formerly part of A_VileChase)
// Check for ressurecting a body
//
//==========================================================================
static bool P_CheckForResurrection(AActor *self, bool usevilestates)
{
const AActor *info;
AActor *temp;
if (self->movedir != DI_NODIR)
{
const fixed_t absSpeed = abs (self->Speed);
fixed_t viletryx = self->x + FixedMul (absSpeed, xspeed[self->movedir]);
fixed_t viletryy = self->y + FixedMul (absSpeed, yspeed[self->movedir]);
AActor *corpsehit;
FState *raisestate;
FBlockThingsIterator it(FBoundingBox(viletryx, viletryy, 32*FRACUNIT));
while ((corpsehit = it.Next()))
{
if (!(corpsehit->flags & MF_CORPSE) )
continue; // not a monster
if (corpsehit->tics != -1)
continue; // not lying still yet
raisestate = corpsehit->FindState(NAME_Raise);
if (raisestate == NULL)
continue; // monster doesn't have a raise state
if (corpsehit->IsKindOf(RUNTIME_CLASS(APlayerPawn)))
continue; // do not resurrect players
// use the current actor's radius instead of the Arch Vile's default.
fixed_t maxdist = corpsehit->GetDefault()->radius + self->radius;
maxdist = corpsehit-> GetDefault()->radius + self->radius;
if ( abs(corpsehit-> x - viletryx) > maxdist ||
abs(corpsehit-> y - viletryy) > maxdist )
continue; // not actually touching
#ifdef _3DFLOORS
// Let's check if there are floors in between the archvile and its target
sector_t *vilesec = self->Sector;
sector_t *corpsec = corpsehit->Sector;
// We only need to test if at least one of the sectors has a 3D floor.
sector_t *testsec = vilesec->e->XFloor.ffloors.Size() ? vilesec :
(vilesec != corpsec && corpsec->e->XFloor.ffloors.Size()) ? corpsec : NULL;
if (testsec)
{
fixed_t zdist1, zdist2;
if (P_Find3DFloor(testsec, corpsehit->x, corpsehit->y, corpsehit->z, false, true, zdist1)
!= P_Find3DFloor(testsec, self->x, self->y, self->z, false, true, zdist2))
{
// Not on same floor
if (vilesec == corpsec || abs(zdist1 - self->z) > self->height)
continue;
}
}
#endif
corpsehit->velx = corpsehit->vely = 0;
// [RH] Check against real height and radius
fixed_t oldheight = corpsehit->height;
fixed_t oldradius = corpsehit->radius;
int oldflags = corpsehit->flags;
corpsehit->flags |= MF_SOLID;
corpsehit->height = corpsehit->GetDefault()->height;
bool check = P_CheckPosition (corpsehit, corpsehit->x, corpsehit->y);
corpsehit->flags = oldflags;
corpsehit->radius = oldradius;
corpsehit->height = oldheight;
if (!check) continue;
// got one!
temp = self->target;
self->target = corpsehit;
A_FaceTarget (self);
if (self->flags & MF_FRIENDLY)
{
// If this is a friendly Arch-Vile (which is turning the resurrected monster into its friend)
// and the Arch-Vile is currently targetting the resurrected monster the target must be cleared.
if (self->lastenemy == temp) self->lastenemy = NULL;
if (self->lastenemy == corpsehit) self->lastenemy = NULL;
if (temp == self->target) temp = NULL;
}
self->target = temp;
// Make the state the monster enters customizable.
FState * state = self->FindState(NAME_Heal);
if (state != NULL)
{
self->SetState (state);
}
else if (usevilestates)
{
// For Dehacked compatibility this has to use the Arch Vile's
// heal state as a default if the actor doesn't define one itself.
const PClass *archvile = PClass::FindClass("Archvile");
if (archvile != NULL)
{
self->SetState (archvile->ActorInfo->FindState(NAME_Heal));
}
}
S_Sound (corpsehit, CHAN_BODY, "vile/raise", 1, ATTN_IDLE);
info = corpsehit->GetDefault ();
if (corpsehit->state == corpsehit->FindState(NAME_GenericCrush))
{
corpsehit->Translation = info->Translation; // Clean up bloodcolor translation from crushed corpses
}
if (ib_compatflags & BCOMPATF_VILEGHOSTS)
{
corpsehit->height <<= 2;
// [GZ] This was a commented-out feature, so let's make use of it,
// but only for ghost monsters so that they are visibly different.
if (corpsehit->height == 0)
{
// Make raised corpses look ghostly
if (corpsehit->alpha > TRANSLUC50)
{
corpsehit->alpha /= 2;
}
// This will only work if the render style is changed as well.
if (corpsehit->RenderStyle == LegacyRenderStyles[STYLE_Normal])
{
corpsehit->RenderStyle = STYLE_Translucent;
}
}
}
else
{
corpsehit->height = info->height; // [RH] Use real mobj height
corpsehit->radius = info->radius; // [RH] Use real radius
}
corpsehit->flags = info->flags;
corpsehit->flags2 = info->flags2;
corpsehit->flags3 = info->flags3;
corpsehit->flags4 = info->flags4;
corpsehit->flags5 = info->flags5;
corpsehit->flags6 = info->flags6;
corpsehit->health = info->health;
corpsehit->target = NULL;
corpsehit->lastenemy = NULL;
// [RH] If it's a monster, it gets to count as another kill
if (corpsehit->CountsAsKill())
{
level.total_monsters++;
}
// You are the Archvile's minion now, so hate what it hates
corpsehit->CopyFriendliness (self, false);
corpsehit->SetState (raisestate);
return true;
}
}
return false;
}
//==========================================================================
//
// A_Chase and variations
//
//==========================================================================
enum ChaseFlags
{
CHF_FASTCHASE = 1,
CHF_NOPLAYACTIVE = 2,
CHF_NIGHTMAREFAST = 4,
CHF_RESURRECT = 8,
CHF_DONTMOVE = 16,
};
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Chase)
{
ACTION_PARAM_START(3);
ACTION_PARAM_STATE(melee, 0);
ACTION_PARAM_STATE(missile, 1);
ACTION_PARAM_INT(flags, 2);
if (melee != (FState*)-1)
{
if (flags & CHF_RESURRECT && P_CheckForResurrection(self, false)) return;
A_DoChase(self, !!(flags&CHF_FASTCHASE), melee, missile, !(flags&CHF_NOPLAYACTIVE),
!!(flags&CHF_NIGHTMAREFAST), !!(flags&CHF_DONTMOVE));
}
else // this is the old default A_Chase
{
A_DoChase (self, false, self->MeleeState, self->MissileState, true, gameinfo.nightmarefast, false);
}
}
DEFINE_ACTION_FUNCTION(AActor, A_FastChase)
{
A_DoChase (self, true, self->MeleeState, self->MissileState, true, true, false);
}
DEFINE_ACTION_FUNCTION(AActor, A_VileChase)
{
if (!P_CheckForResurrection(self, true))
A_DoChase (self, false, self->MeleeState, self->MissileState, true, gameinfo.nightmarefast, false);
}
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_ExtChase)
{
ACTION_PARAM_START(4);
ACTION_PARAM_BOOL(domelee, 0);
ACTION_PARAM_BOOL(domissile, 1);
ACTION_PARAM_BOOL(playactive, 2);
ACTION_PARAM_BOOL(nightmarefast, 3);
// Now that A_Chase can handle state label parameters, this function has become rather useless...
A_DoChase(self, false,
domelee ? self->MeleeState:NULL, domissile ? self->MissileState:NULL,
playactive, nightmarefast, false);
}
// for internal use
void A_Chase(AActor *self)
{
A_DoChase (self, false, self->MeleeState, self->MissileState, true, gameinfo.nightmarefast, false);
}
//=============================================================================
//
// A_FaceTarget
// A_FaceMaster
// A_FaceTracer
//
//=============================================================================
void A_Face (AActor *self, AActor *other, angle_t max_turn, angle_t max_pitch)
{
if (!other)
return;
// [RH] Andy Baker's stealth monsters
if (self->flags & MF_STEALTH)
{
self->visdir = 1;
}
self->flags &= ~MF_AMBUSH;
angle_t other_angle = R_PointToAngle2 (self->x, self->y, other->x, other->y);
// 0 means no limit. Also, if we turn in a single step anyways, no need to go through the algorithms.
// It also means that there is no need to check for going past the other.
if (max_turn && (max_turn < (angle_t)abs(self->angle - other_angle)))
{
if (self->angle > other_angle)
{
if (self->angle - other_angle < ANGLE_180)
{
self->angle -= max_turn;
}
else
{
self->angle += max_turn;
}
}
else
{
if (other_angle - self->angle < ANGLE_180)
{
self->angle += max_turn;
}
else
{
self->angle -= max_turn;
}
}
}
else
{
self->angle = other_angle;
}
// [DH] Now set pitch. In order to maintain compatibility, this can be
// disabled and is so by default.
if (max_pitch <= ANGLE_180)
{
// [DH] Don't need to do proper fixed->double conversion, since the
// result is only used in a ratio.
double dist_x = self->target->x - self->x;
double dist_y = self->target->y - self->y;
double dist_z = self->target->z - self->z;
double dist = sqrt(dist_x*dist_x + dist_y*dist_y + dist_z*dist_z);
int other_pitch = (int)rad2bam(asin(dist_z / dist));
if (max_pitch != 0)
{
if (self->pitch > other_pitch)
{
max_pitch = MIN(max_pitch, unsigned(self->pitch - other_pitch));
self->pitch -= max_pitch;
}
else
{
max_pitch = MIN(max_pitch, unsigned(other_pitch - self->pitch));
self->pitch += max_pitch;
}
}
else
{
self->pitch = other_pitch;
}
}
// This will never work well if the turn angle is limited.
if (max_turn == 0 && (self->angle == other_angle) && other->flags & MF_SHADOW && !(self->flags6 & MF6_SEEINVISIBLE) )
{
self->angle += pr_facetarget.Random2() << 21;
}
}
void A_FaceTarget (AActor *self, angle_t max_turn, angle_t max_pitch)
{
A_Face(self, self->target, max_turn, max_pitch);
}
void A_FaceMaster (AActor *self, angle_t max_turn, angle_t max_pitch)
{
A_Face(self, self->master, max_turn, max_pitch);
}
void A_FaceTracer (AActor *self, angle_t max_turn, angle_t max_pitch)
{
A_Face(self, self->tracer, max_turn, max_pitch);
}
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTarget)
{
ACTION_PARAM_START(2);
ACTION_PARAM_ANGLE(max_turn, 0);
ACTION_PARAM_ANGLE(max_pitch, 1);
A_FaceTarget(self, max_turn, max_pitch);
}
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceMaster)
{
ACTION_PARAM_START(2);
ACTION_PARAM_ANGLE(max_turn, 0);
ACTION_PARAM_ANGLE(max_pitch, 1);
A_FaceMaster(self, max_turn, max_pitch);
}
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_FaceTracer)
{
ACTION_PARAM_START(2);
ACTION_PARAM_ANGLE(max_turn, 0);
ACTION_PARAM_ANGLE(max_pitch, 1);
A_FaceTracer(self, max_turn, max_pitch);
}
//===========================================================================
//
// [RH] A_MonsterRail
//
// New function to let monsters shoot a railgun
//
//===========================================================================
DEFINE_ACTION_FUNCTION(AActor, A_MonsterRail)
{
if (!self->target)
return;
fixed_t saved_pitch = self->pitch;
AActor *linetarget;
// [RH] Andy Baker's stealth monsters
if (self->flags & MF_STEALTH)
{
self->visdir = 1;
}
self->flags &= ~MF_AMBUSH;
self->angle = R_PointToAngle2 (self->x,
self->y,
self->target->x,
self->target->y);
self->pitch = P_AimLineAttack (self, self->angle, MISSILERANGE, &linetarget, ANGLE_1*60, 0, self->target);
if (linetarget == NULL)
{
// We probably won't hit the target, but aim at it anyway so we don't look stupid.
FVector2 xydiff(self->target->x - self->x, self->target->y - self->y);
double zdiff = (self->target->z + (self->target->height>>1)) -
(self->z + (self->height>>1) - self->floorclip);
self->pitch = int(atan2(zdiff, xydiff.Length()) * ANGLE_180 / -M_PI);
}
// Let the aim trail behind the player
self->angle = R_PointToAngle2 (self->x,
self->y,
self->target->x - self->target->velx * 3,
self->target->y - self->target->vely * 3);
if (self->target->flags & MF_SHADOW && !(self->flags6 & MF6_SEEINVISIBLE))
{
self->angle += pr_railface.Random2() << 21;
}
P_RailAttack (self, self->GetMissileDamage (0, 1), 0);
self->pitch = saved_pitch;
}
DEFINE_ACTION_FUNCTION(AActor, A_Scream)
{
if (self->DeathSound)
{
// Check for bosses.
if (self->flags2 & MF2_BOSS)
{
// full volume
S_Sound (self, CHAN_VOICE, self->DeathSound, 1, ATTN_NONE);
}
else
{
S_Sound (self, CHAN_VOICE, self->DeathSound, 1, ATTN_NORM);
}
}
}
DEFINE_ACTION_FUNCTION(AActor, A_XScream)
{
if (self->player)
S_Sound (self, CHAN_VOICE, "*gibbed", 1, ATTN_NORM);
else
S_Sound (self, CHAN_VOICE, "misc/gibbed", 1, ATTN_NORM);
}
//===========================================================================
//
// A_ScreamAndUnblock
//
//===========================================================================
DEFINE_ACTION_FUNCTION(AActor, A_ScreamAndUnblock)
{
CALL_ACTION(A_Scream, self);
A_Unblock(self, true);
}
//===========================================================================
//
// A_ActiveSound
//
//===========================================================================
DEFINE_ACTION_FUNCTION(AActor, A_ActiveSound)
{
if (self->ActiveSound)
{
S_Sound (self, CHAN_VOICE, self->ActiveSound, 1, ATTN_NORM);
}
}
//===========================================================================
//
// A_ActiveAndUnblock
//
//===========================================================================
DEFINE_ACTION_FUNCTION(AActor, A_ActiveAndUnblock)
{
CALL_ACTION(A_ActiveSound, self);
A_Unblock(self, true);
}
//---------------------------------------------------------------------------
//
// Modifies the drop amount of this item according to the current skill's
// settings (also called by ADehackedPickup::TryPickup)
//
//---------------------------------------------------------------------------
void ModifyDropAmount(AInventory *inv, int dropamount)
{
int flagmask = IF_IGNORESKILL;
fixed_t dropammofactor = G_SkillProperty(SKILLP_DropAmmoFactor);
// Default drop amount is half of regular amount * regular ammo multiplication
if (dropammofactor == -1)
{
dropammofactor = FRACUNIT/2;
flagmask = 0;
}
if (dropamount > 0)
{
if (flagmask != 0 && inv->IsKindOf(RUNTIME_CLASS(AAmmo)))
{
inv->Amount = FixedMul(dropamount, dropammofactor);
inv->ItemFlags |= IF_IGNORESKILL;
}
else
{
inv->Amount = dropamount;
}
}
else if (inv->IsKindOf (RUNTIME_CLASS(AAmmo)))
{
// Half ammo when dropped by bad guys.
inv->Amount = inv->GetClass()->Meta.GetMetaInt (AIMETA_DropAmount, MAX(1, FixedMul(inv->Amount, dropammofactor)));
inv->ItemFlags|=flagmask;
}
else if (inv->IsKindOf (RUNTIME_CLASS(AWeapon)))
{
// The same goes for ammo from a weapon.
static_cast<AWeapon *>(inv)->AmmoGive1 = FixedMul(static_cast<AWeapon *>(inv)->AmmoGive1, dropammofactor);
static_cast<AWeapon *>(inv)->AmmoGive2 = FixedMul(static_cast<AWeapon *>(inv)->AmmoGive2, dropammofactor);
inv->ItemFlags|=flagmask;
}
else if (inv->IsKindOf (RUNTIME_CLASS(ADehackedPickup)))
{
// For weapons and ammo modified by Dehacked we need to flag the item.
static_cast<ADehackedPickup *>(inv)->droppedbymonster = true;
}
}
//---------------------------------------------------------------------------
//
// PROC P_DropItem
//
//---------------------------------------------------------------------------
CVAR(Int, sv_dropstyle, 0, CVAR_SERVERINFO | CVAR_ARCHIVE);
AInventory *P_DropItem (AActor *source, const PClass *type, int dropamount, int chance)
{
if (type != NULL && pr_dropitem() <= chance)
{
AActor *mo;
fixed_t spawnz;
spawnz = source->z;
if (!(i_compatflags & COMPATF_NOTOSSDROPS))
{
int style = sv_dropstyle;
if (style==0) style= (gameinfo.gametype == GAME_Strife)? 2:1;
if (style==2)
{
spawnz += 24*FRACUNIT;
}
else
{
spawnz += source->height / 2;
}
}
mo = Spawn (type, source->x, source->y, spawnz, ALLOW_REPLACE);
if (mo != NULL)
{
mo->flags |= MF_DROPPED;
mo->flags &= ~MF_NOGRAVITY; // [RH] Make sure it is affected by gravity
if (!(i_compatflags & COMPATF_NOTOSSDROPS))
{
P_TossItem (mo);
}
if (mo->IsKindOf (RUNTIME_CLASS(AInventory)))
{
AInventory * inv = static_cast<AInventory *>(mo);
ModifyDropAmount(inv, dropamount);
if (inv->SpecialDropAction (source))
{
return NULL;
}
return inv;
}
// we can't really return an AInventory pointer to a non-inventory item here, can we?
}
}
return NULL;
}
//============================================================================
//
// P_TossItem
//
//============================================================================
void P_TossItem (AActor *item)
{
int style = sv_dropstyle;
if (style==0) style= gameinfo.defaultdropstyle;
if (style==2)
{
item->velx += pr_dropitem.Random2(7) << FRACBITS;
item->vely += pr_dropitem.Random2(7) << FRACBITS;
}
else
{
item->velx = pr_dropitem.Random2() << 8;
item->vely = pr_dropitem.Random2() << 8;
item->velz = FRACUNIT*5 + (pr_dropitem() << 10);
}
}
DEFINE_ACTION_FUNCTION(AActor, A_Pain)
{
// [RH] Vary player pain sounds depending on health (ala Quake2)
if (self->player && self->player->morphTics == 0)
{
const char *pain_amount;
FSoundID sfx_id;
if (self->health < 25)
pain_amount = "*pain25";
else if (self->health < 50)
pain_amount = "*pain50";
else if (self->health < 75)
pain_amount = "*pain75";
else
pain_amount = "*pain100";
// Try for damage-specific sounds first.
if (self->player->LastDamageType != NAME_None)
{
FString pain_sound = pain_amount;
pain_sound += '-';
pain_sound += self->player->LastDamageType;
sfx_id = pain_sound;
if (sfx_id == 0)
{
// Try again without a specific pain amount.
pain_sound = "*pain-";
pain_sound += self->player->LastDamageType;
sfx_id = pain_sound;
}
}
if (sfx_id == 0)
{
sfx_id = pain_amount;
}
S_Sound (self, CHAN_VOICE, sfx_id, 1, ATTN_NORM);
}
else if (self->PainSound)
{
S_Sound (self, CHAN_VOICE, self->PainSound, 1, ATTN_NORM);
}
}
// killough 11/98: kill an object
DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Die)
{
ACTION_PARAM_START(1);
ACTION_PARAM_NAME(damagetype, 0);
P_DamageMobj (self, NULL, NULL, self->health, damagetype, DMG_FORCED);
}
//
// A_Detonate
// killough 8/9/98: same as A_Explode, except that the damage is variable
//
DEFINE_ACTION_FUNCTION(AActor, A_Detonate)
{
int damage = self->GetMissileDamage (0, 1);
P_RadiusAttack (self, self->target, damage, damage, self->DamageType, RADF_HURTSOURCE);
P_CheckSplash(self, damage<<FRACBITS);
}
bool CheckBossDeath (AActor *actor)
{
int i;
// 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 false; // no one left alive, so do not end game
// Make sure all bosses are dead
TThinkerIterator<AActor> iterator;
AActor *other;
while ( (other = iterator.Next ()) )
{
if (other != actor &&
(other->health > 0 || (other->flags & MF_ICECORPSE))
&& other->GetClass() == actor->GetClass())
{ // Found a living boss
// [RH] Frozen bosses don't count as dead until they shatter
return false;
}
}
// The boss death is good
return true;
}
//
// A_BossDeath
// Possibly trigger special effects if on a boss level
//
DEFINE_ACTION_FUNCTION(AActor, A_BossDeath)
{
FName mytype = self->GetClass()->TypeName;
// Ugh...
FName type = self->GetClass()->ActorInfo->GetReplacee()->Class->TypeName;
// Do generic special death actions first
bool checked = false;
for(unsigned i=0; i<level.info->specialactions.Size(); i++)
{
FSpecialAction *sa = &level.info->specialactions[i];
if (type == sa->Type || mytype == sa->Type)
{
if (!checked && !CheckBossDeath(self))
{
return;
}
checked = true;
P_ExecuteSpecial(sa->Action, NULL, self, false,
sa->Args[0], sa->Args[1], sa->Args[2], sa->Args[3], sa->Args[4]);
}
}
// [RH] These all depend on the presence of level flags now
// rather than being hard-coded to specific levels/episodes.
if ((level.flags & (LEVEL_MAP07SPECIAL|
LEVEL_BRUISERSPECIAL|
LEVEL_CYBORGSPECIAL|
LEVEL_SPIDERSPECIAL|
LEVEL_HEADSPECIAL|
LEVEL_MINOTAURSPECIAL|
LEVEL_SORCERER2SPECIAL)) == 0)
return;
if ((i_compatflags & COMPATF_ANYBOSSDEATH) || ( // [GZ] Added for UAC_DEAD
((level.flags & LEVEL_MAP07SPECIAL) && (type == NAME_Fatso || type == NAME_Arachnotron)) ||
((level.flags & LEVEL_BRUISERSPECIAL) && (type == NAME_BaronOfHell)) ||
((level.flags & LEVEL_CYBORGSPECIAL) && (type == NAME_Cyberdemon)) ||
((level.flags & LEVEL_SPIDERSPECIAL) && (type == NAME_SpiderMastermind)) ||
((level.flags & LEVEL_HEADSPECIAL) && (type == NAME_Ironlich)) ||
((level.flags & LEVEL_MINOTAURSPECIAL) && (type == NAME_Minotaur)) ||
((level.flags & LEVEL_SORCERER2SPECIAL) && (type == NAME_Sorcerer2))
))
;
else
return;
if (!CheckBossDeath (self))
{
return;
}
// victory!
if (level.flags & LEVEL_SPECKILLMONSTERS)
{ // Kill any remaining monsters
P_Massacre ();
}
if (level.flags & LEVEL_MAP07SPECIAL)
{
if (type == NAME_Fatso)
{
EV_DoFloor (DFloor::floorLowerToLowest, NULL, 666, FRACUNIT, 0, 0, 0, false);
return;
}
if (type == NAME_Arachnotron)
{
EV_DoFloor (DFloor::floorRaiseByTexture, NULL, 667, FRACUNIT, 0, 0, 0, false);
return;
}
}
else
{
switch (level.flags & LEVEL_SPECACTIONSMASK)
{
case LEVEL_SPECLOWERFLOOR:
EV_DoFloor (DFloor::floorLowerToLowest, NULL, 666, FRACUNIT, 0, 0, 0, false);
return;
case LEVEL_SPECLOWERFLOORTOHIGHEST:
EV_DoFloor (DFloor::floorLowerToHighest, NULL, 666, FRACUNIT, 0, 0, 0, false);
return;
case LEVEL_SPECOPENDOOR:
EV_DoDoor (DDoor::doorOpen, NULL, NULL, 666, 8*FRACUNIT, 0, 0, 0);
return;
}
}
// [RH] If noexit, then don't end the level.
if ((deathmatch || alwaysapplydmflags) && (dmflags & DF_NO_EXIT))
return;
G_ExitLevel (0, false);
}
//----------------------------------------------------------------------------
//
// PROC P_Massacre
//
// Kills all monsters.
//
//----------------------------------------------------------------------------
int P_Massacre ()
{
// jff 02/01/98 'em' cheat - kill all monsters
// partially taken from Chi's .46 port
//
// killough 2/7/98: cleaned up code and changed to use dprintf;
// fixed lost soul bug (LSs left behind when PEs are killed)
int killcount = 0;
AActor *actor;
TThinkerIterator<AActor> iterator;
while ( (actor = iterator.Next ()) )
{
if (!(actor->flags2 & MF2_DORMANT) && (actor->flags3 & MF3_ISMONSTER))
{
killcount += actor->Massacre();
}
}
return killcount;
}
//
// A_SinkMobj
// Sink a mobj incrementally into the floor
//
bool A_SinkMobj (AActor *actor, fixed_t speed)
{
if (actor->floorclip < actor->height)
{
actor->floorclip += speed;
return false;
}
return true;
}
//
// A_RaiseMobj
// Raise a mobj incrementally from the floor to
//
bool A_RaiseMobj (AActor *actor, fixed_t speed)
{
bool done = true;
// Raise a mobj from the ground
if (actor->floorclip > 0)
{
actor->floorclip -= speed;
if (actor->floorclip <= 0)
{
actor->floorclip = 0;
done = true;
}
else
{
done = false;
}
}
return done; // Reached target height
}
DEFINE_ACTION_FUNCTION(AActor, A_ClassBossHealth)
{
if (multiplayer && !deathmatch) // co-op only
{
if (!self->special1)
{
self->health *= 5;
self->special1 = true; // has been initialized
}
}
}
Jump to Line
Something went wrong with that request. Please try again.