1531 lines
36 KiB
C++
Executable File
1531 lines
36 KiB
C++
Executable File
// WL_STATE.C
|
|
|
|
#include "wl_def.h"
|
|
#pragma hdrstop
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
LOCAL CONSTANTS
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
GLOBAL VARIABLES
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
|
|
static const dirtype opposite[9] =
|
|
{west,southwest,south,southeast,east,northeast,north,northwest,nodir};
|
|
|
|
static const dirtype diagonal[9][9] =
|
|
{
|
|
/* east */ {nodir,nodir,northeast,nodir,nodir,nodir,southeast,nodir,nodir},
|
|
{nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir},
|
|
/* north */ {northeast,nodir,nodir,nodir,northwest,nodir,nodir,nodir,nodir},
|
|
{nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir},
|
|
/* west */ {nodir,nodir,northwest,nodir,nodir,nodir,southwest,nodir,nodir},
|
|
{nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir},
|
|
/* south */ {southeast,nodir,nodir,nodir,southwest,nodir,nodir,nodir,nodir},
|
|
{nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir},
|
|
{nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir,nodir}
|
|
};
|
|
|
|
|
|
|
|
void SpawnNewObj (unsigned tilex, unsigned tiley, statetype *state);
|
|
void NewState (objtype *ob, statetype *state);
|
|
|
|
boolean TryWalk (objtype *ob);
|
|
void MoveObj (objtype *ob, int32_t move);
|
|
|
|
void KillActor (objtype *ob);
|
|
void DamageActor (objtype *ob, unsigned damage);
|
|
|
|
boolean CheckLine (objtype *ob);
|
|
void FirstSighting (objtype *ob);
|
|
boolean CheckSight (objtype *ob);
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
LOCAL VARIABLES
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
|
|
/*
|
|
===================
|
|
=
|
|
= SpawnNewObj
|
|
=
|
|
= Spaws a new actor at the given TILE coordinates, with the given state, and
|
|
= the given size in GLOBAL units.
|
|
=
|
|
= newobj = a pointer to an initialized new actor
|
|
=
|
|
===================
|
|
*/
|
|
|
|
void SpawnNewObj (unsigned tilex, unsigned tiley, statetype *state)
|
|
{
|
|
GetNewActor ();
|
|
newobj->state = state;
|
|
if (state->tictime)
|
|
newobj->ticcount = DEMOCHOOSE_ORIG_SDL(
|
|
US_RndT () % state->tictime,
|
|
US_RndT () % state->tictime + 1); // Chris' moonwalk bugfix ;D
|
|
else
|
|
newobj->ticcount = 0;
|
|
|
|
newobj->tilex = (short) tilex;
|
|
newobj->tiley = (short) tiley;
|
|
newobj->x = ((int32_t)tilex<<TILESHIFT)+TILEGLOBAL/2;
|
|
newobj->y = ((int32_t)tiley<<TILESHIFT)+TILEGLOBAL/2;
|
|
newobj->dir = nodir;
|
|
|
|
actorat[tilex][tiley] = newobj;
|
|
newobj->areanumber =
|
|
*(mapsegs[0] + (newobj->tiley<<mapshift)+newobj->tilex) - AREATILE;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
=
|
|
= NewState
|
|
=
|
|
= Changes ob to a new state, setting ticcount to the max for that state
|
|
=
|
|
===================
|
|
*/
|
|
|
|
void NewState (objtype *ob, statetype *state)
|
|
{
|
|
ob->state = state;
|
|
ob->ticcount = state->tictime;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
ENEMY TILE WORLD MOVEMENT CODE
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
|
|
/*
|
|
==================================
|
|
=
|
|
= TryWalk
|
|
=
|
|
= Attempts to move ob in its current (ob->dir) 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
|
|
=
|
|
= ob->tilex = new destination
|
|
= ob->tiley
|
|
= ob->areanumber = the floor tile number (0-(NUMAREAS-1)) of destination
|
|
= ob->distance = TILEGLOBAl, or -doornumber if a door is blocking the way
|
|
=
|
|
= If a door is in the way, an OpenDoor call is made to start it opening.
|
|
= The actor code should wait until
|
|
= doorobjlist[-ob->distance].action = dr_open, meaning the door has been
|
|
= fully opened
|
|
=
|
|
==================================
|
|
*/
|
|
|
|
#define CHECKDIAG(x,y) \
|
|
{ \
|
|
temp=(uintptr_t)actorat[x][y]; \
|
|
if (temp) \
|
|
{ \
|
|
if (temp<256) \
|
|
return false; \
|
|
if (((objtype *)temp)->flags&FL_SHOOTABLE) \
|
|
return false; \
|
|
} \
|
|
}
|
|
|
|
#ifdef PLAYDEMOLIKEORIGINAL
|
|
#define DOORCHECK \
|
|
if(DEMOCOND_ORIG) \
|
|
doornum = temp&63; \
|
|
else \
|
|
{ \
|
|
doornum = (int) temp & 127; \
|
|
OpenDoor(doornum); \
|
|
ob->distance = -doornum - 1; \
|
|
return true; \
|
|
}
|
|
#else
|
|
#define DOORCHECK \
|
|
doornum = (int) temp & 127; \
|
|
OpenDoor(doornum); \
|
|
ob->distance = -doornum - 1; \
|
|
return true;
|
|
#endif
|
|
|
|
#define CHECKSIDE(x,y) \
|
|
{ \
|
|
temp=(uintptr_t)actorat[x][y]; \
|
|
if (temp) \
|
|
{ \
|
|
if (temp<128) \
|
|
return false; \
|
|
if (temp<256) \
|
|
{ \
|
|
DOORCHECK \
|
|
} \
|
|
else if (((objtype *)temp)->flags&FL_SHOOTABLE) \
|
|
return false; \
|
|
} \
|
|
}
|
|
|
|
|
|
boolean TryWalk (objtype *ob)
|
|
{
|
|
int doornum = -1;
|
|
uintptr_t temp;
|
|
|
|
if (ob->obclass == inertobj)
|
|
{
|
|
switch (ob->dir)
|
|
{
|
|
case north:
|
|
ob->tiley--;
|
|
break;
|
|
|
|
case northeast:
|
|
ob->tilex++;
|
|
ob->tiley--;
|
|
break;
|
|
|
|
case east:
|
|
ob->tilex++;
|
|
break;
|
|
|
|
case southeast:
|
|
ob->tilex++;
|
|
ob->tiley++;
|
|
break;
|
|
|
|
case south:
|
|
ob->tiley++;
|
|
break;
|
|
|
|
case southwest:
|
|
ob->tilex--;
|
|
ob->tiley++;
|
|
break;
|
|
|
|
case west:
|
|
ob->tilex--;
|
|
break;
|
|
|
|
case northwest:
|
|
ob->tilex--;
|
|
ob->tiley--;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (ob->dir)
|
|
{
|
|
case north:
|
|
if (ob->obclass == dogobj || ob->obclass == fakeobj
|
|
|| ob->obclass == ghostobj || ob->obclass == spectreobj)
|
|
{
|
|
CHECKDIAG(ob->tilex,ob->tiley-1);
|
|
}
|
|
else
|
|
{
|
|
CHECKSIDE(ob->tilex,ob->tiley-1);
|
|
}
|
|
ob->tiley--;
|
|
break;
|
|
|
|
case northeast:
|
|
CHECKDIAG(ob->tilex+1,ob->tiley-1);
|
|
CHECKDIAG(ob->tilex+1,ob->tiley);
|
|
CHECKDIAG(ob->tilex,ob->tiley-1);
|
|
ob->tilex++;
|
|
ob->tiley--;
|
|
break;
|
|
|
|
case east:
|
|
if (ob->obclass == dogobj || ob->obclass == fakeobj
|
|
|| ob->obclass == ghostobj || ob->obclass == spectreobj)
|
|
{
|
|
CHECKDIAG(ob->tilex+1,ob->tiley);
|
|
}
|
|
else
|
|
{
|
|
CHECKSIDE(ob->tilex+1,ob->tiley);
|
|
}
|
|
ob->tilex++;
|
|
break;
|
|
|
|
case southeast:
|
|
CHECKDIAG(ob->tilex+1,ob->tiley+1);
|
|
CHECKDIAG(ob->tilex+1,ob->tiley);
|
|
CHECKDIAG(ob->tilex,ob->tiley+1);
|
|
ob->tilex++;
|
|
ob->tiley++;
|
|
break;
|
|
|
|
case south:
|
|
if (ob->obclass == dogobj || ob->obclass == fakeobj
|
|
|| ob->obclass == ghostobj || ob->obclass == spectreobj)
|
|
{
|
|
CHECKDIAG(ob->tilex,ob->tiley+1);
|
|
}
|
|
else
|
|
{
|
|
CHECKSIDE(ob->tilex,ob->tiley+1);
|
|
}
|
|
ob->tiley++;
|
|
break;
|
|
|
|
case southwest:
|
|
CHECKDIAG(ob->tilex-1,ob->tiley+1);
|
|
CHECKDIAG(ob->tilex-1,ob->tiley);
|
|
CHECKDIAG(ob->tilex,ob->tiley+1);
|
|
ob->tilex--;
|
|
ob->tiley++;
|
|
break;
|
|
|
|
case west:
|
|
if (ob->obclass == dogobj || ob->obclass == fakeobj
|
|
|| ob->obclass == ghostobj || ob->obclass == spectreobj)
|
|
{
|
|
CHECKDIAG(ob->tilex-1,ob->tiley);
|
|
}
|
|
else
|
|
{
|
|
CHECKSIDE(ob->tilex-1,ob->tiley);
|
|
}
|
|
ob->tilex--;
|
|
break;
|
|
|
|
case northwest:
|
|
CHECKDIAG(ob->tilex-1,ob->tiley-1);
|
|
CHECKDIAG(ob->tilex-1,ob->tiley);
|
|
CHECKDIAG(ob->tilex,ob->tiley-1);
|
|
ob->tilex--;
|
|
ob->tiley--;
|
|
break;
|
|
|
|
case nodir:
|
|
return false;
|
|
|
|
default:
|
|
Quit ("Walk: Bad dir");
|
|
}
|
|
}
|
|
|
|
#ifdef PLAYDEMOLIKEORIGINAL
|
|
if (DEMOCOND_ORIG && doornum != -1)
|
|
{
|
|
OpenDoor(doornum);
|
|
ob->distance = -doornum-1;
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
ob->areanumber =
|
|
*(mapsegs[0] + (ob->tiley<<mapshift)+ob->tilex) - AREATILE;
|
|
|
|
ob->distance = TILEGLOBAL;
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
==================================
|
|
=
|
|
= SelectDodgeDir
|
|
=
|
|
= Attempts to choose and initiate a movement for ob that sends it towards
|
|
= the player while dodging
|
|
=
|
|
= If there is no possible move (ob is totally surrounded)
|
|
=
|
|
= ob->dir = nodir
|
|
=
|
|
= Otherwise
|
|
=
|
|
= ob->dir = new direction to follow
|
|
= ob->distance = TILEGLOBAL or -doornumber
|
|
= ob->tilex = new destination
|
|
= ob->tiley
|
|
= ob->areanumber = the floor tile number (0-(NUMAREAS-1)) of destination
|
|
=
|
|
==================================
|
|
*/
|
|
|
|
void SelectDodgeDir (objtype *ob)
|
|
{
|
|
int deltax,deltay,i;
|
|
unsigned absdx,absdy;
|
|
dirtype dirtry[5];
|
|
dirtype turnaround,tdir;
|
|
|
|
if (ob->flags & FL_FIRSTATTACK)
|
|
{
|
|
//
|
|
// turning around is only ok the very first time after noticing the
|
|
// player
|
|
//
|
|
turnaround = nodir;
|
|
ob->flags &= ~FL_FIRSTATTACK;
|
|
}
|
|
else
|
|
turnaround=opposite[ob->dir];
|
|
|
|
deltax = player->tilex - ob->tilex;
|
|
deltay = player->tiley - ob->tiley;
|
|
|
|
//
|
|
// arange 5 direction choices in order of preference
|
|
// the four cardinal directions plus the diagonal straight towards
|
|
// the player
|
|
//
|
|
|
|
if (deltax>0)
|
|
{
|
|
dirtry[1]= east;
|
|
dirtry[3]= west;
|
|
}
|
|
else
|
|
{
|
|
dirtry[1]= west;
|
|
dirtry[3]= east;
|
|
}
|
|
|
|
if (deltay>0)
|
|
{
|
|
dirtry[2]= south;
|
|
dirtry[4]= north;
|
|
}
|
|
else
|
|
{
|
|
dirtry[2]= north;
|
|
dirtry[4]= south;
|
|
}
|
|
|
|
//
|
|
// randomize a bit for dodging
|
|
//
|
|
absdx = abs(deltax);
|
|
absdy = abs(deltay);
|
|
|
|
if (absdx > absdy)
|
|
{
|
|
tdir = dirtry[1];
|
|
dirtry[1] = dirtry[2];
|
|
dirtry[2] = tdir;
|
|
tdir = dirtry[3];
|
|
dirtry[3] = dirtry[4];
|
|
dirtry[4] = tdir;
|
|
}
|
|
|
|
if (US_RndT() < 128)
|
|
{
|
|
tdir = dirtry[1];
|
|
dirtry[1] = dirtry[2];
|
|
dirtry[2] = tdir;
|
|
tdir = dirtry[3];
|
|
dirtry[3] = dirtry[4];
|
|
dirtry[4] = tdir;
|
|
}
|
|
|
|
dirtry[0] = diagonal [ dirtry[1] ] [ dirtry[2] ];
|
|
|
|
//
|
|
// try the directions util one works
|
|
//
|
|
for (i=0;i<5;i++)
|
|
{
|
|
if ( dirtry[i] == nodir || dirtry[i] == turnaround)
|
|
continue;
|
|
|
|
ob->dir = dirtry[i];
|
|
if (TryWalk(ob))
|
|
return;
|
|
}
|
|
|
|
//
|
|
// turn around only as a last resort
|
|
//
|
|
if (turnaround != nodir)
|
|
{
|
|
ob->dir = turnaround;
|
|
|
|
if (TryWalk(ob))
|
|
return;
|
|
}
|
|
|
|
ob->dir = nodir;
|
|
}
|
|
|
|
|
|
/*
|
|
============================
|
|
=
|
|
= SelectChaseDir
|
|
=
|
|
= As SelectDodgeDir, but doesn't try to dodge
|
|
=
|
|
============================
|
|
*/
|
|
|
|
void SelectChaseDir (objtype *ob)
|
|
{
|
|
int deltax,deltay;
|
|
dirtype d[3];
|
|
dirtype tdir, olddir, turnaround;
|
|
|
|
|
|
olddir=ob->dir;
|
|
turnaround=opposite[olddir];
|
|
|
|
deltax=player->tilex - ob->tilex;
|
|
deltay=player->tiley - ob->tiley;
|
|
|
|
d[1]=nodir;
|
|
d[2]=nodir;
|
|
|
|
if (deltax>0)
|
|
d[1]= east;
|
|
else if (deltax<0)
|
|
d[1]= west;
|
|
if (deltay>0)
|
|
d[2]=south;
|
|
else if (deltay<0)
|
|
d[2]=north;
|
|
|
|
if (abs(deltay)>abs(deltax))
|
|
{
|
|
tdir=d[1];
|
|
d[1]=d[2];
|
|
d[2]=tdir;
|
|
}
|
|
|
|
if (d[1]==turnaround)
|
|
d[1]=nodir;
|
|
if (d[2]==turnaround)
|
|
d[2]=nodir;
|
|
|
|
|
|
if (d[1]!=nodir)
|
|
{
|
|
ob->dir=d[1];
|
|
if (TryWalk(ob))
|
|
return; /*either moved forward or attacked*/
|
|
}
|
|
|
|
if (d[2]!=nodir)
|
|
{
|
|
ob->dir=d[2];
|
|
if (TryWalk(ob))
|
|
return;
|
|
}
|
|
|
|
/* there is no direct path to the player, so pick another direction */
|
|
|
|
if (olddir!=nodir)
|
|
{
|
|
ob->dir=olddir;
|
|
if (TryWalk(ob))
|
|
return;
|
|
}
|
|
|
|
if (US_RndT()>128) /*randomly determine direction of search*/
|
|
{
|
|
for (tdir=north; tdir<=west; tdir=(dirtype)(tdir+1))
|
|
{
|
|
if (tdir!=turnaround)
|
|
{
|
|
ob->dir=tdir;
|
|
if ( TryWalk(ob) )
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (tdir=west; tdir>=north; tdir=(dirtype)(tdir-1))
|
|
{
|
|
if (tdir!=turnaround)
|
|
{
|
|
ob->dir=tdir;
|
|
if ( TryWalk(ob) )
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (turnaround != nodir)
|
|
{
|
|
ob->dir=turnaround;
|
|
if (ob->dir != nodir)
|
|
{
|
|
if ( TryWalk(ob) )
|
|
return;
|
|
}
|
|
}
|
|
|
|
ob->dir = nodir; // can't move
|
|
}
|
|
|
|
|
|
/*
|
|
============================
|
|
=
|
|
= SelectRunDir
|
|
=
|
|
= Run Away from player
|
|
=
|
|
============================
|
|
*/
|
|
|
|
void SelectRunDir (objtype *ob)
|
|
{
|
|
int deltax,deltay;
|
|
dirtype d[3];
|
|
dirtype tdir;
|
|
|
|
|
|
deltax=player->tilex - ob->tilex;
|
|
deltay=player->tiley - ob->tiley;
|
|
|
|
if (deltax<0)
|
|
d[1]= east;
|
|
else
|
|
d[1]= west;
|
|
if (deltay<0)
|
|
d[2]=south;
|
|
else
|
|
d[2]=north;
|
|
|
|
if (abs(deltay)>abs(deltax))
|
|
{
|
|
tdir=d[1];
|
|
d[1]=d[2];
|
|
d[2]=tdir;
|
|
}
|
|
|
|
ob->dir=d[1];
|
|
if (TryWalk(ob))
|
|
return; /*either moved forward or attacked*/
|
|
|
|
ob->dir=d[2];
|
|
if (TryWalk(ob))
|
|
return;
|
|
|
|
/* there is no direct path to the player, so pick another direction */
|
|
|
|
if (US_RndT()>128) /*randomly determine direction of search*/
|
|
{
|
|
for (tdir=north; tdir<=west; tdir=(dirtype)(tdir+1))
|
|
{
|
|
ob->dir=tdir;
|
|
if ( TryWalk(ob) )
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (tdir=west; tdir>=north; tdir=(dirtype)(tdir-1))
|
|
{
|
|
ob->dir=tdir;
|
|
if ( TryWalk(ob) )
|
|
return;
|
|
}
|
|
}
|
|
|
|
ob->dir = nodir; // can't move
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
=
|
|
= MoveObj
|
|
=
|
|
= Moves ob be move global units in ob->dir direction
|
|
= Actors are not allowed to move inside the player
|
|
= Does NOT check to see if the move is tile map valid
|
|
=
|
|
= ob->x = adjusted for new position
|
|
= ob->y
|
|
=
|
|
=================
|
|
*/
|
|
|
|
void MoveObj (objtype *ob, int32_t move)
|
|
{
|
|
int32_t deltax,deltay;
|
|
|
|
switch (ob->dir)
|
|
{
|
|
case north:
|
|
ob->y -= move;
|
|
break;
|
|
case northeast:
|
|
ob->x += move;
|
|
ob->y -= move;
|
|
break;
|
|
case east:
|
|
ob->x += move;
|
|
break;
|
|
case southeast:
|
|
ob->x += move;
|
|
ob->y += move;
|
|
break;
|
|
case south:
|
|
ob->y += move;
|
|
break;
|
|
case southwest:
|
|
ob->x -= move;
|
|
ob->y += move;
|
|
break;
|
|
case west:
|
|
ob->x -= move;
|
|
break;
|
|
case northwest:
|
|
ob->x -= move;
|
|
ob->y -= move;
|
|
break;
|
|
|
|
case nodir:
|
|
return;
|
|
|
|
default:
|
|
Quit ("MoveObj: bad dir!");
|
|
}
|
|
|
|
//
|
|
// check to make sure it's not on top of player
|
|
//
|
|
if (areabyplayer[ob->areanumber])
|
|
{
|
|
deltax = ob->x - player->x;
|
|
if (deltax < -MINACTORDIST || deltax > MINACTORDIST)
|
|
goto moveok;
|
|
deltay = ob->y - player->y;
|
|
if (deltay < -MINACTORDIST || deltay > MINACTORDIST)
|
|
goto moveok;
|
|
|
|
if (ob->hidden) // move closer until he meets CheckLine
|
|
goto moveok;
|
|
|
|
if (ob->obclass == ghostobj || ob->obclass == spectreobj)
|
|
TakeDamage (tics*2,ob);
|
|
|
|
//
|
|
// back up
|
|
//
|
|
switch (ob->dir)
|
|
{
|
|
case north:
|
|
ob->y += move;
|
|
break;
|
|
case northeast:
|
|
ob->x -= move;
|
|
ob->y += move;
|
|
break;
|
|
case east:
|
|
ob->x -= move;
|
|
break;
|
|
case southeast:
|
|
ob->x -= move;
|
|
ob->y -= move;
|
|
break;
|
|
case south:
|
|
ob->y -= move;
|
|
break;
|
|
case southwest:
|
|
ob->x += move;
|
|
ob->y -= move;
|
|
break;
|
|
case west:
|
|
ob->x += move;
|
|
break;
|
|
case northwest:
|
|
ob->x += move;
|
|
ob->y += move;
|
|
break;
|
|
|
|
case nodir:
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
moveok:
|
|
ob->distance -=move;
|
|
}
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
STUFF
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
/*
|
|
===============
|
|
=
|
|
= DropItem
|
|
=
|
|
= Tries to drop a bonus item somewhere in the tiles surrounding the
|
|
= given tilex/tiley
|
|
=
|
|
===============
|
|
*/
|
|
|
|
void DropItem (wl_stat_t itemtype, int tilex, int tiley)
|
|
{
|
|
int x,y,xl,xh,yl,yh;
|
|
|
|
//
|
|
// find a free spot to put it in
|
|
//
|
|
if (!actorat[tilex][tiley])
|
|
{
|
|
PlaceItemType (itemtype, tilex,tiley);
|
|
return;
|
|
}
|
|
|
|
xl = tilex-1;
|
|
xh = tilex+1;
|
|
yl = tiley-1;
|
|
yh = tiley+1;
|
|
|
|
for (x=xl ; x<= xh ; x++)
|
|
{
|
|
for (y=yl ; y<= yh ; y++)
|
|
{
|
|
if (!actorat[x][y])
|
|
{
|
|
PlaceItemType (itemtype, x,y);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===============
|
|
=
|
|
= KillActor
|
|
=
|
|
===============
|
|
*/
|
|
|
|
void KillActor (objtype *ob)
|
|
{
|
|
int tilex,tiley;
|
|
|
|
tilex = ob->tilex = (word)(ob->x >> TILESHIFT); // drop item on center
|
|
tiley = ob->tiley = (word)(ob->y >> TILESHIFT);
|
|
|
|
switch (ob->obclass)
|
|
{
|
|
case guardobj:
|
|
GivePoints (100);
|
|
NewState (ob,&s_grddie1);
|
|
PlaceItemType (bo_clip2,tilex,tiley);
|
|
break;
|
|
|
|
case officerobj:
|
|
GivePoints (400);
|
|
NewState (ob,&s_ofcdie1);
|
|
PlaceItemType (bo_clip2,tilex,tiley);
|
|
break;
|
|
|
|
case mutantobj:
|
|
GivePoints (700);
|
|
NewState (ob,&s_mutdie1);
|
|
PlaceItemType (bo_clip2,tilex,tiley);
|
|
break;
|
|
|
|
case ssobj:
|
|
GivePoints (500);
|
|
NewState (ob,&s_ssdie1);
|
|
if (gamestate.bestweapon < wp_machinegun)
|
|
PlaceItemType (bo_machinegun,tilex,tiley);
|
|
else
|
|
PlaceItemType (bo_clip2,tilex,tiley);
|
|
break;
|
|
|
|
case dogobj:
|
|
GivePoints (200);
|
|
NewState (ob,&s_dogdie1);
|
|
break;
|
|
|
|
#ifndef SPEAR
|
|
case bossobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_bossdie1);
|
|
PlaceItemType (bo_key1,tilex,tiley);
|
|
break;
|
|
|
|
case gretelobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_greteldie1);
|
|
PlaceItemType (bo_key1,tilex,tiley);
|
|
break;
|
|
|
|
case giftobj:
|
|
GivePoints (5000);
|
|
gamestate.killx = player->x;
|
|
gamestate.killy = player->y;
|
|
NewState (ob,&s_giftdie1);
|
|
break;
|
|
|
|
case fatobj:
|
|
GivePoints (5000);
|
|
gamestate.killx = player->x;
|
|
gamestate.killy = player->y;
|
|
NewState (ob,&s_fatdie1);
|
|
break;
|
|
|
|
case schabbobj:
|
|
GivePoints (5000);
|
|
gamestate.killx = player->x;
|
|
gamestate.killy = player->y;
|
|
NewState (ob,&s_schabbdie1);
|
|
break;
|
|
case fakeobj:
|
|
GivePoints (2000);
|
|
NewState (ob,&s_fakedie1);
|
|
break;
|
|
|
|
case mechahitlerobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_mechadie1);
|
|
break;
|
|
case realhitlerobj:
|
|
GivePoints (5000);
|
|
gamestate.killx = player->x;
|
|
gamestate.killy = player->y;
|
|
NewState (ob,&s_hitlerdie1);
|
|
break;
|
|
#else
|
|
case spectreobj:
|
|
if (ob->flags&FL_BONUS)
|
|
{
|
|
GivePoints (200); // Get points once for each
|
|
ob->flags &= ~FL_BONUS;
|
|
}
|
|
NewState (ob,&s_spectredie1);
|
|
break;
|
|
|
|
case angelobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_angeldie1);
|
|
break;
|
|
|
|
case transobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_transdie0);
|
|
PlaceItemType (bo_key1,tilex,tiley);
|
|
break;
|
|
|
|
case uberobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_uberdie0);
|
|
PlaceItemType (bo_key1,tilex,tiley);
|
|
break;
|
|
|
|
case willobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_willdie1);
|
|
PlaceItemType (bo_key1,tilex,tiley);
|
|
break;
|
|
|
|
case deathobj:
|
|
GivePoints (5000);
|
|
NewState (ob,&s_deathdie1);
|
|
PlaceItemType (bo_key1,tilex,tiley);
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
gamestate.killcount++;
|
|
ob->flags &= ~FL_SHOOTABLE;
|
|
actorat[ob->tilex][ob->tiley] = NULL;
|
|
ob->flags |= FL_NONMARK;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===================
|
|
=
|
|
= DamageActor
|
|
=
|
|
= Called when the player succesfully hits an enemy.
|
|
=
|
|
= Does damage points to enemy ob, either putting it into a stun frame or
|
|
= killing it.
|
|
=
|
|
===================
|
|
*/
|
|
|
|
void DamageActor (objtype *ob, unsigned damage)
|
|
{
|
|
madenoise = true;
|
|
|
|
//
|
|
// do double damage if shooting a non attack mode actor
|
|
//
|
|
if ( !(ob->flags & FL_ATTACKMODE) )
|
|
damage <<= 1;
|
|
|
|
ob->hitpoints -= (short)damage;
|
|
|
|
if (ob->hitpoints<=0)
|
|
KillActor (ob);
|
|
else
|
|
{
|
|
if (! (ob->flags & FL_ATTACKMODE) )
|
|
FirstSighting (ob); // put into combat mode
|
|
|
|
switch (ob->obclass) // dogs only have one hit point
|
|
{
|
|
case guardobj:
|
|
if (ob->hitpoints&1)
|
|
NewState (ob,&s_grdpain);
|
|
else
|
|
NewState (ob,&s_grdpain1);
|
|
break;
|
|
|
|
case officerobj:
|
|
if (ob->hitpoints&1)
|
|
NewState (ob,&s_ofcpain);
|
|
else
|
|
NewState (ob,&s_ofcpain1);
|
|
break;
|
|
|
|
case mutantobj:
|
|
if (ob->hitpoints&1)
|
|
NewState (ob,&s_mutpain);
|
|
else
|
|
NewState (ob,&s_mutpain1);
|
|
break;
|
|
|
|
case ssobj:
|
|
if (ob->hitpoints&1)
|
|
NewState (ob,&s_sspain);
|
|
else
|
|
NewState (ob,&s_sspain1);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
CHECKSIGHT
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
|
|
/*
|
|
=====================
|
|
=
|
|
= CheckLine
|
|
=
|
|
= Returns true if a straight line between the player and ob is unobstructed
|
|
=
|
|
=====================
|
|
*/
|
|
|
|
boolean CheckLine (objtype *ob)
|
|
{
|
|
int x1,y1,xt1,yt1,x2,y2,xt2,yt2;
|
|
int x,y;
|
|
int xdist,ydist,xstep,ystep;
|
|
int partial,delta;
|
|
int32_t ltemp;
|
|
int xfrac,yfrac,deltafrac;
|
|
unsigned value,intercept;
|
|
|
|
x1 = ob->x >> UNSIGNEDSHIFT; // 1/256 tile precision
|
|
y1 = ob->y >> UNSIGNEDSHIFT;
|
|
xt1 = x1 >> 8;
|
|
yt1 = y1 >> 8;
|
|
|
|
x2 = plux;
|
|
y2 = pluy;
|
|
xt2 = player->tilex;
|
|
yt2 = player->tiley;
|
|
|
|
xdist = abs(xt2-xt1);
|
|
|
|
if (xdist > 0)
|
|
{
|
|
if (xt2 > xt1)
|
|
{
|
|
partial = 256-(x1&0xff);
|
|
xstep = 1;
|
|
}
|
|
else
|
|
{
|
|
partial = x1&0xff;
|
|
xstep = -1;
|
|
}
|
|
|
|
deltafrac = abs(x2-x1);
|
|
delta = y2-y1;
|
|
ltemp = ((int32_t)delta<<8)/deltafrac;
|
|
if (ltemp > 0x7fffl)
|
|
ystep = 0x7fff;
|
|
else if (ltemp < -0x7fffl)
|
|
ystep = -0x7fff;
|
|
else
|
|
ystep = ltemp;
|
|
yfrac = y1 + (((int32_t)ystep*partial) >>8);
|
|
|
|
x = xt1+xstep;
|
|
xt2 += xstep;
|
|
do
|
|
{
|
|
y = yfrac>>8;
|
|
yfrac += ystep;
|
|
|
|
value = (unsigned)tilemap[x][y];
|
|
x += xstep;
|
|
|
|
if (!value)
|
|
continue;
|
|
|
|
if (value<128 || value>256)
|
|
return false;
|
|
|
|
//
|
|
// see if the door is open enough
|
|
//
|
|
value &= ~0x80;
|
|
intercept = yfrac-ystep/2;
|
|
|
|
if (intercept>doorposition[value])
|
|
return false;
|
|
|
|
} while (x != xt2);
|
|
}
|
|
|
|
ydist = abs(yt2-yt1);
|
|
|
|
if (ydist > 0)
|
|
{
|
|
if (yt2 > yt1)
|
|
{
|
|
partial = 256-(y1&0xff);
|
|
ystep = 1;
|
|
}
|
|
else
|
|
{
|
|
partial = y1&0xff;
|
|
ystep = -1;
|
|
}
|
|
|
|
deltafrac = abs(y2-y1);
|
|
delta = x2-x1;
|
|
ltemp = ((int32_t)delta<<8)/deltafrac;
|
|
if (ltemp > 0x7fffl)
|
|
xstep = 0x7fff;
|
|
else if (ltemp < -0x7fffl)
|
|
xstep = -0x7fff;
|
|
else
|
|
xstep = ltemp;
|
|
xfrac = x1 + (((int32_t)xstep*partial) >>8);
|
|
|
|
y = yt1 + ystep;
|
|
yt2 += ystep;
|
|
do
|
|
{
|
|
x = xfrac>>8;
|
|
xfrac += xstep;
|
|
|
|
value = (unsigned)tilemap[x][y];
|
|
y += ystep;
|
|
|
|
if (!value)
|
|
continue;
|
|
|
|
if (value<128 || value>256)
|
|
return false;
|
|
|
|
//
|
|
// see if the door is open enough
|
|
//
|
|
value &= ~0x80;
|
|
intercept = xfrac-xstep/2;
|
|
|
|
if (intercept>doorposition[value])
|
|
return false;
|
|
} while (y != yt2);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
=
|
|
= CheckSight
|
|
=
|
|
= Checks a straight line between player and current object
|
|
=
|
|
= If the sight is ok, check alertness and angle to see if they notice
|
|
=
|
|
= returns true if the player has been spoted
|
|
=
|
|
================
|
|
*/
|
|
|
|
#define MINSIGHT 0x18000l
|
|
|
|
boolean CheckSight (objtype *ob)
|
|
{
|
|
int32_t deltax,deltay;
|
|
|
|
//
|
|
// don't bother tracing a line if the area isn't connected to the player's
|
|
//
|
|
if (!areabyplayer[ob->areanumber])
|
|
return false;
|
|
|
|
//
|
|
// if the player is real close, sight is automatic
|
|
//
|
|
deltax = player->x - ob->x;
|
|
deltay = player->y - ob->y;
|
|
|
|
if (deltax > -MINSIGHT && deltax < MINSIGHT
|
|
&& deltay > -MINSIGHT && deltay < MINSIGHT)
|
|
return true;
|
|
|
|
//
|
|
// see if they are looking in the right direction
|
|
//
|
|
switch (ob->dir)
|
|
{
|
|
case north:
|
|
if (deltay > 0)
|
|
return false;
|
|
break;
|
|
|
|
case east:
|
|
if (deltax < 0)
|
|
return false;
|
|
break;
|
|
|
|
case south:
|
|
if (deltay < 0)
|
|
return false;
|
|
break;
|
|
|
|
case west:
|
|
if (deltax > 0)
|
|
return false;
|
|
break;
|
|
|
|
// check diagonal moving guards fix
|
|
|
|
case northwest:
|
|
if (DEMOCOND_SDL && deltay > -deltax)
|
|
return false;
|
|
break;
|
|
|
|
case northeast:
|
|
if (DEMOCOND_SDL && deltay > deltax)
|
|
return false;
|
|
break;
|
|
|
|
case southwest:
|
|
if (DEMOCOND_SDL && deltax > deltay)
|
|
return false;
|
|
break;
|
|
|
|
case southeast:
|
|
if (DEMOCOND_SDL && -deltax > deltay)
|
|
return false;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// trace a line to check for blocking tiles (corners)
|
|
//
|
|
return CheckLine (ob);
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
=
|
|
= FirstSighting
|
|
=
|
|
= Puts an actor into attack mode and possibly reverses the direction
|
|
= if the player is behind it
|
|
=
|
|
===============
|
|
*/
|
|
|
|
void FirstSighting (objtype *ob)
|
|
{
|
|
//
|
|
// react to the player
|
|
//
|
|
switch (ob->obclass)
|
|
{
|
|
case guardobj:
|
|
PlaySoundLocActor(HALTSND,ob);
|
|
NewState (ob,&s_grdchase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case officerobj:
|
|
PlaySoundLocActor(SPIONSND,ob);
|
|
NewState (ob,&s_ofcchase1);
|
|
ob->speed *= 5; // go faster when chasing player
|
|
break;
|
|
|
|
case mutantobj:
|
|
NewState (ob,&s_mutchase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case ssobj:
|
|
PlaySoundLocActor(SCHUTZADSND,ob);
|
|
NewState (ob,&s_sschase1);
|
|
ob->speed *= 4; // go faster when chasing player
|
|
break;
|
|
|
|
case dogobj:
|
|
PlaySoundLocActor(DOGBARKSND,ob);
|
|
NewState (ob,&s_dogchase1);
|
|
ob->speed *= 2; // go faster when chasing player
|
|
break;
|
|
|
|
#ifndef SPEAR
|
|
case bossobj:
|
|
SD_PlaySound(GUTENTAGSND);
|
|
NewState (ob,&s_bosschase1);
|
|
ob->speed = SPDPATROL*3; // go faster when chasing player
|
|
break;
|
|
|
|
#ifndef APOGEE_1_0
|
|
case gretelobj:
|
|
SD_PlaySound(KEINSND);
|
|
NewState (ob,&s_gretelchase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case giftobj:
|
|
SD_PlaySound(EINESND);
|
|
NewState (ob,&s_giftchase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case fatobj:
|
|
SD_PlaySound(ERLAUBENSND);
|
|
NewState (ob,&s_fatchase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
#endif
|
|
|
|
case schabbobj:
|
|
SD_PlaySound(SCHABBSHASND);
|
|
NewState (ob,&s_schabbchase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case fakeobj:
|
|
SD_PlaySound(TOT_HUNDSND);
|
|
NewState (ob,&s_fakechase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case mechahitlerobj:
|
|
SD_PlaySound(DIESND);
|
|
NewState (ob,&s_mechachase1);
|
|
ob->speed *= 3; // go faster when chasing player
|
|
break;
|
|
|
|
case realhitlerobj:
|
|
SD_PlaySound(DIESND);
|
|
NewState (ob,&s_hitlerchase1);
|
|
ob->speed *= 5; // go faster when chasing player
|
|
break;
|
|
|
|
case ghostobj:
|
|
NewState (ob,&s_blinkychase1);
|
|
ob->speed *= 2; // go faster when chasing player
|
|
break;
|
|
#else
|
|
case spectreobj:
|
|
SD_PlaySound(GHOSTSIGHTSND);
|
|
NewState (ob,&s_spectrechase1);
|
|
ob->speed = 800; // go faster when chasing player
|
|
break;
|
|
|
|
case angelobj:
|
|
SD_PlaySound(ANGELSIGHTSND);
|
|
NewState (ob,&s_angelchase1);
|
|
ob->speed = 1536; // go faster when chasing player
|
|
break;
|
|
|
|
case transobj:
|
|
SD_PlaySound(TRANSSIGHTSND);
|
|
NewState (ob,&s_transchase1);
|
|
ob->speed = 1536; // go faster when chasing player
|
|
break;
|
|
|
|
case uberobj:
|
|
NewState (ob,&s_uberchase1);
|
|
ob->speed = 3000; // go faster when chasing player
|
|
break;
|
|
|
|
case willobj:
|
|
SD_PlaySound(WILHELMSIGHTSND);
|
|
NewState (ob,&s_willchase1);
|
|
ob->speed = 2048; // go faster when chasing player
|
|
break;
|
|
|
|
case deathobj:
|
|
SD_PlaySound(KNIGHTSIGHTSND);
|
|
NewState (ob,&s_deathchase1);
|
|
ob->speed = 2048; // go faster when chasing player
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
if (ob->distance < 0)
|
|
ob->distance = 0; // ignore the door opening command
|
|
|
|
ob->flags |= FL_ATTACKMODE|FL_FIRSTATTACK;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===============
|
|
=
|
|
= SightPlayer
|
|
=
|
|
= Called by actors that ARE NOT chasing the player. If the player
|
|
= is detected (by sight, noise, or proximity), the actor is put into
|
|
= it's combat frame and true is returned.
|
|
=
|
|
= Incorporates a random reaction delay
|
|
=
|
|
===============
|
|
*/
|
|
|
|
boolean SightPlayer (objtype *ob)
|
|
{
|
|
if (ob->flags & FL_ATTACKMODE)
|
|
Quit ("An actor in ATTACKMODE called SightPlayer!");
|
|
|
|
if (ob->temp2)
|
|
{
|
|
//
|
|
// count down reaction time
|
|
//
|
|
ob->temp2 -= (short) tics;
|
|
if (ob->temp2 > 0)
|
|
return false;
|
|
ob->temp2 = 0; // time to react
|
|
}
|
|
else
|
|
{
|
|
if (!areabyplayer[ob->areanumber])
|
|
return false;
|
|
|
|
if (ob->flags & FL_AMBUSH)
|
|
{
|
|
if (!CheckSight (ob))
|
|
return false;
|
|
ob->flags &= ~FL_AMBUSH;
|
|
}
|
|
else
|
|
{
|
|
if (!madenoise && !CheckSight (ob))
|
|
return false;
|
|
}
|
|
|
|
|
|
switch (ob->obclass)
|
|
{
|
|
case guardobj:
|
|
ob->temp2 = 1+US_RndT()/4;
|
|
break;
|
|
case officerobj:
|
|
ob->temp2 = 2;
|
|
break;
|
|
case mutantobj:
|
|
ob->temp2 = 1+US_RndT()/6;
|
|
break;
|
|
case ssobj:
|
|
ob->temp2 = 1+US_RndT()/6;
|
|
break;
|
|
case dogobj:
|
|
ob->temp2 = 1+US_RndT()/8;
|
|
break;
|
|
|
|
case bossobj:
|
|
case schabbobj:
|
|
case fakeobj:
|
|
case mechahitlerobj:
|
|
case realhitlerobj:
|
|
case gretelobj:
|
|
case giftobj:
|
|
case fatobj:
|
|
case spectreobj:
|
|
case angelobj:
|
|
case transobj:
|
|
case uberobj:
|
|
case willobj:
|
|
case deathobj:
|
|
ob->temp2 = 1;
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
FirstSighting (ob);
|
|
|
|
return true;
|
|
}
|