mirror of
https://github.com/blendogames/thirtyflightsofloving.git
synced 2024-11-14 00:21:18 +00:00
9481c7c513
Changed Zaero and 3ZB2 game DLLs to use WORLD_SIZE for various calculations instead of 8192. Cleaned up string handling in 3ZB2 game DLL. Added func_plat2, func_door_secret2, and func_force_wall from Rogue to 3ZB2 game DLL. Added alternate attack contact explode for grenade launcher in 3ZB2 game DLL. Added awakening2 game DLL source.
426 lines
8.4 KiB
C
426 lines
8.4 KiB
C
// g_monster.c
|
|
|
|
#include "g_local.h"
|
|
|
|
#define STEPSIZE 18 //CW
|
|
|
|
/*
|
|
===============
|
|
M_CheckGround
|
|
===============
|
|
*/
|
|
void M_CheckGround(edict_t *ent)
|
|
{
|
|
vec3_t point;
|
|
trace_t trace;
|
|
|
|
if (ent->flags & (FL_SWIM|FL_FLY))
|
|
return;
|
|
|
|
//Maj++
|
|
ResetGroundSlope(ent);
|
|
//Maj--
|
|
|
|
if (ent->velocity[2] > 100.0)
|
|
{
|
|
ent->groundentity = NULL;
|
|
return;
|
|
}
|
|
|
|
// if the hull point one-quarter unit down is solid the entity is on ground
|
|
point[0] = ent->s.origin[0];
|
|
point[1] = ent->s.origin[1];
|
|
point[2] = ent->s.origin[2] - 0.25;
|
|
|
|
trace = gi.trace(ent->s.origin, ent->mins, ent->maxs, point, ent, MASK_MONSTERSOLID);
|
|
|
|
// check steepness
|
|
if ((trace.plane.normal[2] < 0.7) && !trace.startsolid)
|
|
{
|
|
ent->groundentity = NULL;
|
|
return;
|
|
}
|
|
|
|
/* //Maj - code superseded
|
|
if (!trace.startsolid && !trace.allsolid)
|
|
{
|
|
VectorCopy(trace.endpos, ent->s.origin);
|
|
ent->groundentity = trace.ent;
|
|
ent->groundentity_linkcount = trace.ent->linkcount;
|
|
ent->velocity[2] = 0.0;
|
|
}
|
|
*/
|
|
|
|
//Maj++
|
|
TraceAllSolid(ent, point, trace);
|
|
//Maj--
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
M_CatagorizePosition
|
|
===============
|
|
*/
|
|
void M_CatagorizePosition(edict_t *ent)
|
|
{
|
|
vec3_t point;
|
|
int cont;
|
|
|
|
// Get the current waterlevel.
|
|
|
|
point[0] = ent->s.origin[0];
|
|
point[1] = ent->s.origin[1];
|
|
point[2] = ent->s.origin[2] + ent->mins[2] + 1.0;
|
|
cont = gi.pointcontents(point);
|
|
|
|
if (!(cont & MASK_WATER))
|
|
{
|
|
ent->waterlevel = 0;
|
|
ent->watertype = 0;
|
|
return;
|
|
}
|
|
|
|
ent->watertype = cont;
|
|
ent->waterlevel = 1;
|
|
point[2] += 26.0;
|
|
cont = gi.pointcontents(point);
|
|
if (!(cont & MASK_WATER))
|
|
return;
|
|
|
|
ent->waterlevel = 2;
|
|
point[2] += 22.0;
|
|
cont = gi.pointcontents(point);
|
|
if (cont & MASK_WATER)
|
|
ent->waterlevel = 3;
|
|
}
|
|
|
|
|
|
/*
|
|
===============
|
|
M_DropToFloor
|
|
===============
|
|
*/
|
|
void M_DropToFloor(edict_t *ent)
|
|
{
|
|
vec3_t end;
|
|
trace_t trace;
|
|
|
|
ent->s.origin[2] += 1.0;
|
|
VectorCopy(ent->s.origin, end);
|
|
end[2] -= 256.0;
|
|
|
|
trace = gi.trace(ent->s.origin, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID);
|
|
|
|
if ((trace.fraction == 1.0) || trace.allsolid)
|
|
return;
|
|
|
|
VectorCopy(trace.endpos, ent->s.origin);
|
|
gi.linkentity(ent);
|
|
|
|
M_CheckGround(ent);
|
|
M_CatagorizePosition(ent);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
M_CheckBottom
|
|
|
|
Returns false if any part of the bottom of the entity is off an edge that
|
|
is not a staircase.
|
|
=============
|
|
*/
|
|
qboolean M_CheckBottom(edict_t *ent) //CW
|
|
{
|
|
vec3_t mins;
|
|
vec3_t maxs;
|
|
vec3_t start;
|
|
vec3_t stop;
|
|
trace_t trace;
|
|
float mid;
|
|
float bottom;
|
|
int x;
|
|
int y;
|
|
|
|
VectorAdd(ent->s.origin, ent->mins, mins);
|
|
VectorAdd(ent->s.origin, ent->maxs, maxs);
|
|
|
|
// If all of the points under the corners are solid world, don't bother
|
|
// with the tougher checks; the corners must be within 16 units of the midpoint.
|
|
|
|
start[2] = mins[2] - 1;
|
|
for (x = 0; x <= 1; x++)
|
|
{
|
|
for (y = 0; y <= 1; y++)
|
|
{
|
|
start[0] = (x) ? maxs[0] : mins[0];
|
|
start[1] = (y) ? maxs[1] : mins[1];
|
|
if (gi.pointcontents(start) != CONTENTS_SOLID)
|
|
goto realcheck;
|
|
}
|
|
}
|
|
|
|
return true; // we got out easy
|
|
|
|
realcheck:
|
|
// Check it for real...
|
|
|
|
start[2] = mins[2];
|
|
|
|
// The midpoint must be within 16 units of the bottom.
|
|
|
|
start[0] = stop[0] = (mins[0] + maxs[0]) * 0.5;
|
|
start[1] = stop[1] = (mins[1] + maxs[1]) * 0.5;
|
|
stop[2] = start[2] - 2 * STEPSIZE;
|
|
trace = gi.trace(start, vec3_origin, vec3_origin, stop, ent, MASK_MONSTERSOLID);
|
|
|
|
if (trace.fraction == 1.0)
|
|
return false;
|
|
|
|
mid = bottom = trace.endpos[2];
|
|
|
|
// The corners must be within 16 units of the midpoint.
|
|
|
|
for (x = 0; x <= 1; x++)
|
|
{
|
|
for (y = 0; y <= 1; y++)
|
|
{
|
|
start[0] = stop[0] = x ? maxs[0] : mins[0];
|
|
start[1] = stop[1] = y ? maxs[1] : mins[1];
|
|
trace = gi.trace(start, vec3_origin, vec3_origin, stop, ent, MASK_MONSTERSOLID);
|
|
if ((trace.fraction != 1.0) && (trace.endpos[2] > bottom))
|
|
bottom = trace.endpos[2];
|
|
|
|
if ((trace.fraction == 1.0) || (mid - trace.endpos[2] > STEPSIZE))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
SV_MoveStep
|
|
|
|
Called by monster program code.
|
|
The move will be adjusted for slopes and stairs, but if the move isn't
|
|
possible, no move is done, false is returned, and
|
|
pr_global_struct->trace_normal is set to the normal of the blocking wall
|
|
=============
|
|
*/
|
|
//FIXME since we need to test end position contents here, can we avoid doing
|
|
//it again later in catagorize position?
|
|
|
|
qboolean SV_MoveStep(edict_t *ent, vec3_t move, qboolean relink) //CW
|
|
{
|
|
trace_t trace;
|
|
vec3_t oldorg;
|
|
vec3_t neworg;
|
|
vec3_t end;
|
|
vec3_t test;
|
|
float dz;
|
|
float stepsize;
|
|
int contents;
|
|
int i;
|
|
|
|
// Try the move.
|
|
|
|
VectorCopy(ent->s.origin, oldorg);
|
|
VectorAdd(ent->s.origin, move, neworg);
|
|
|
|
// Flying monsters don't step up.
|
|
|
|
if (ent->flags & (FL_SWIM | FL_FLY))
|
|
{
|
|
|
|
// try one move with vertical motion, then one without
|
|
for (i = 0; i < 2; i++)
|
|
{
|
|
VectorAdd(ent->s.origin, move, neworg);
|
|
if ((i == 0) && ent->enemy)
|
|
{
|
|
if (!ent->goalentity)
|
|
ent->goalentity = ent->enemy;
|
|
dz = ent->s.origin[2] - ent->goalentity->s.origin[2];
|
|
if (ent->goalentity->client)
|
|
{
|
|
if (dz > 40.0)
|
|
neworg[2] -= 8.0;
|
|
|
|
if (!((ent->flags & FL_SWIM) && (ent->waterlevel < 2)))
|
|
if (dz < 30.0)
|
|
neworg[2] += 8.0;
|
|
}
|
|
else
|
|
{
|
|
if (dz > 8.0)
|
|
neworg[2] -= 8.0;
|
|
else if (dz > 0.0)
|
|
neworg[2] -= dz;
|
|
else if (dz < -8.0)
|
|
neworg[2] += 8.0;
|
|
else
|
|
neworg[2] += dz;
|
|
}
|
|
}
|
|
trace = gi.trace(ent->s.origin, ent->mins, ent->maxs, neworg, ent, MASK_MONSTERSOLID);
|
|
|
|
// fly monsters don't enter water voluntarily
|
|
if (ent->flags & FL_FLY)
|
|
{
|
|
if (!ent->waterlevel)
|
|
{
|
|
test[0] = trace.endpos[0];
|
|
test[1] = trace.endpos[1];
|
|
test[2] = trace.endpos[2] + ent->mins[2] + 1.0;
|
|
contents = gi.pointcontents(test);
|
|
if (contents & MASK_WATER)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// swim monsters don't exit water voluntarily
|
|
if (ent->flags & FL_SWIM)
|
|
{
|
|
if (ent->waterlevel < 2)
|
|
{
|
|
test[0] = trace.endpos[0];
|
|
test[1] = trace.endpos[1];
|
|
test[2] = trace.endpos[2] + ent->mins[2] + 1.0;
|
|
contents = gi.pointcontents(test);
|
|
if (!(contents & MASK_WATER))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (trace.fraction == 1.0)
|
|
{
|
|
VectorCopy(trace.endpos, ent->s.origin);
|
|
if (relink)
|
|
{
|
|
gi.linkentity(ent);
|
|
G_TouchTriggers(ent);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!ent->enemy)
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Push down from a step height above the wished position.
|
|
|
|
if (!(ent->monsterinfo.aiflags & AI_NOSTEP))
|
|
stepsize = STEPSIZE;
|
|
else
|
|
stepsize = 1;
|
|
|
|
neworg[2] += stepsize;
|
|
VectorCopy(neworg, end);
|
|
end[2] -= stepsize * 2.0;
|
|
|
|
trace = gi.trace(neworg, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID);
|
|
|
|
if (trace.allsolid)
|
|
return false;
|
|
|
|
if (trace.startsolid)
|
|
{
|
|
neworg[2] -= stepsize;
|
|
trace = gi.trace(neworg, ent->mins, ent->maxs, end, ent, MASK_MONSTERSOLID);
|
|
if (trace.allsolid || trace.startsolid)
|
|
return false;
|
|
}
|
|
|
|
|
|
// Don't go into water.
|
|
|
|
if (ent->waterlevel == 0)
|
|
{
|
|
test[0] = trace.endpos[0];
|
|
test[1] = trace.endpos[1];
|
|
test[2] = trace.endpos[2] + ent->mins[2] + 1.0;
|
|
contents = gi.pointcontents(test);
|
|
|
|
if (contents & MASK_WATER)
|
|
return false;
|
|
}
|
|
|
|
if (trace.fraction == 1.0)
|
|
{
|
|
// if monster had the ground pulled out, go ahead and fall
|
|
if (ent->flags & FL_PARTIALGROUND)
|
|
{
|
|
VectorAdd(ent->s.origin, move, ent->s.origin);
|
|
if (relink)
|
|
{
|
|
gi.linkentity(ent);
|
|
G_TouchTriggers(ent);
|
|
}
|
|
ent->groundentity = NULL;
|
|
return true;
|
|
}
|
|
|
|
return false; // walked off an edge
|
|
}
|
|
|
|
// Check point traces down for dangling corners.
|
|
|
|
VectorCopy(trace.endpos, ent->s.origin);
|
|
|
|
if (!M_CheckBottom(ent))
|
|
{
|
|
if (ent->flags & FL_PARTIALGROUND)
|
|
{ // entity had floor mostly pulled out from underneath it and is trying to correct
|
|
if (relink)
|
|
{
|
|
gi.linkentity(ent);
|
|
G_TouchTriggers(ent);
|
|
}
|
|
return true;
|
|
}
|
|
VectorCopy(oldorg, ent->s.origin);
|
|
return false;
|
|
}
|
|
|
|
if (ent->flags & FL_PARTIALGROUND)
|
|
ent->flags &= ~FL_PARTIALGROUND;
|
|
|
|
ent->groundentity = trace.ent;
|
|
ent->groundentity_linkcount = trace.ent->linkcount;
|
|
|
|
// The move is OK.
|
|
|
|
if (relink)
|
|
{
|
|
gi.linkentity(ent);
|
|
G_TouchTriggers(ent);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===============
|
|
M_WalkMove
|
|
===============
|
|
*/
|
|
qboolean M_WalkMove(edict_t *ent, float yaw, float dist) //CW
|
|
{
|
|
vec3_t move;
|
|
|
|
if (!ent->groundentity && !(ent->flags & (FL_FLY|FL_SWIM)))
|
|
return false;
|
|
|
|
yaw = DEG2RAD(yaw); //CW
|
|
move[0] = cos(yaw) * dist;
|
|
move[1] = sin(yaw) * dist;
|
|
move[2] = 0.0;
|
|
|
|
return SV_MoveStep(ent, move, true);
|
|
}
|