/*
==================
BotImport_PointContents
==================
*/
int BotImport_PointContents(bvec3_t point) {
return SV_PointContents(point, -1);
}
/*
=============
SV_CheckWater
=============
*/
qboolean SV_CheckWater( edict_t *ent )
{
int cont, truecont;
vec3_t point;
point[0] = (ent->v.absmax[0] + ent->v.absmin[0]) * 0.5f;
point[1] = (ent->v.absmax[1] + ent->v.absmin[1]) * 0.5f;
point[2] = (ent->v.absmin[2] + 1.0f);
ent->v.watertype = CONTENTS_EMPTY;
svs.groupmask = ent->v.groupinfo;
ent->v.waterlevel = 0;
cont = SV_PointContents( point );
if( cont <= CONTENTS_WATER && cont > CONTENTS_TRANSLUCENT )
{
svs.groupmask = ent->v.groupinfo;
truecont = SV_TruePointContents( point );
ent->v.watertype = cont;
ent->v.waterlevel = 1;
if( ent->v.absmin[2] == ent->v.absmax[2] )
{
// a point entity
ent->v.waterlevel = 3;
}
else
{
point[2] = (ent->v.absmin[2] + ent->v.absmax[2]) * 0.5f;
svs.groupmask = ent->v.groupinfo;
cont = SV_PointContents( point );
if( cont <= CONTENTS_WATER && cont > CONTENTS_TRANSLUCENT )
{
ent->v.waterlevel = 2;
VectorAdd( point, ent->v.view_ofs, point );
svs.groupmask = ent->v.groupinfo;
cont = SV_PointContents( point );
if( cont <= CONTENTS_WATER && cont > CONTENTS_TRANSLUCENT )
ent->v.waterlevel = 3;
}
}
// Quake2 feature. Probably never was used in Half-Life...
if( truecont <= CONTENTS_CURRENT_0 && truecont >= CONTENTS_CURRENT_DOWN )
{
float speed = 50.0f * ent->v.waterlevel;
const float *dir = current_table[CONTENTS_CURRENT_0 - truecont];
VectorMA( ent->v.basevelocity, speed, dir, ent->v.basevelocity );
}
}
return (ent->v.waterlevel > 1);
}
qboolean SV_CheckBottom (edict_t *ent)
{
vec3_t mins, maxs, start, stop;
trace_t trace;
int x, y;
float mid, bottom;
VectorAdd (ent->v.origin, ent->v.mins, mins);
VectorAdd (ent->v.origin, ent->v.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 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 (SV_PointContents (start) != CONTENTS_SOLID)
goto realcheck;
}
c_yes++;
return true; // we got out easy
realcheck:
c_no++;
//
// check it for real...
//
start[2] = mins[2];
// the midpoint must be within 16 of the bottom
start[0] = stop[0] = (mins[0] + maxs[0])*0.5f;
start[1] = stop[1] = (mins[1] + maxs[1])*0.5f;
stop[2] = start[2] - 2*STEPSIZE;
trace = SV_Move (start, vec3_origin, vec3_origin, stop, true, ent);
if (trace.fraction == 1.0f)
return false;
mid = bottom = trace.endpos[2];
// the corners must be within 16 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 = SV_Move (start, vec3_origin, vec3_origin, stop, true, ent);
if (trace.fraction != 1.0f && trace.endpos[2] > bottom)
bottom = trace.endpos[2];
if (trace.fraction == 1.0f || mid - trace.endpos[2] > STEPSIZE)
return false;
}
c_yes++;
return true;
}
/*
=============
SV_CheckWaterTransition
=============
*/
void SV_CheckWaterTransition( edict_t *ent )
{
int cont;
vec3_t halfmax;
halfmax[0] = (ent->v.absmax[0] + ent->v.absmin[0]) * 0.5f;
halfmax[1] = (ent->v.absmax[1] + ent->v.absmin[1]) * 0.5f;
halfmax[2] = (ent->v.absmin[2] + 1.0f);
svs.groupmask = ent->v.groupinfo;
cont = SV_PointContents( halfmax );
if( !ent->v.watertype )
{
// just spawned here
ent->v.watertype = cont;
ent->v.waterlevel = 1;
return;
}
if( cont > CONTENTS_WATER || cont <= CONTENTS_TRANSLUCENT )
{
if( ent->v.watertype != CONTENTS_EMPTY )
{
SV_StartSound( ent, CHAN_AUTO, "player/pl_wade2.wav", 1.0f, ATTN_NORM, 0, 100 );
}
ent->v.watertype = CONTENTS_EMPTY;
ent->v.waterlevel = 0;
return;
}
if( ent->v.watertype == CONTENTS_EMPTY )
{
SV_StartSound( ent, CHAN_AUTO, "player/pl_wade1.wav", 1.0f, ATTN_NORM, 0, 100 );
ent->v.velocity[2] *= 0.5f;
}
ent->v.watertype = cont;
ent->v.waterlevel = 1;
if( ent->v.absmin[2] == ent->v.absmax[2] )
{
// a point entity
ent->v.waterlevel = 3;
}
halfmax[2] = (ent->v.absmin[2] + ent->v.absmax[2]) * 0.5f;
svs.groupmask = ent->v.groupinfo;
cont = SV_PointContents( halfmax );
if( cont > CONTENTS_WATER || cont <= CONTENTS_TRANSLUCENT )
return;
ent->v.waterlevel = 2;
VectorAdd( halfmax, ent->v.view_ofs, halfmax );
svs.groupmask = ent->v.groupinfo;
cont = SV_PointContents( halfmax );
if( cont > CONTENTS_WATER || cont <= CONTENTS_TRANSLUCENT )
return;
ent->v.waterlevel = 3;
}
/*
=============
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
=============
*/
qboolean SV_movestep (edict_t *ent, vec3_t move, qboolean relink)
{
float dz;
vec3_t oldorg, neworg, end;
trace_t trace;
int i;
edict_t *enemy;
// try the move
VectorCopy (ent->v.origin, oldorg);
VectorAdd (ent->v.origin, move, neworg);
// flying monsters don't step up
if ( (int)ent->v.flags & (FL_SWIM | FL_FLY) )
{
// try one move with vertical motion, then one without
for (i=0 ; i<2 ; i++)
{
VectorAdd (ent->v.origin, move, neworg);
enemy = PROG_TO_EDICT(ent->v.enemy);
if (i == 0 && enemy != sv.edicts)
{
dz = ent->v.origin[2] - PROG_TO_EDICT(ent->v.enemy)->v.origin[2];
if (dz > 40)
neworg[2] -= 8;
if (dz < 30)
neworg[2] += 8;
}
trace = SV_Move (ent->v.origin, ent->v.mins, ent->v.maxs, neworg, false, ent);
if (trace.fraction == 1)
{
if ( ((int)ent->v.flags & FL_SWIM) && SV_PointContents(trace.endpos) == CONTENTS_EMPTY )
return false; // swim monster left water
VectorCopy (trace.endpos, ent->v.origin);
if (relink)
SV_LinkEdict (ent, true);
return true;
}
if (enemy == sv.edicts)
break;
}
return false;
}
// push down from a step height above the wished position
neworg[2] += STEPSIZE;
VectorCopy (neworg, end);
end[2] -= STEPSIZE*2;
trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, false, ent);
if (trace.allsolid)
return false;
if (trace.startsolid)
{
neworg[2] -= STEPSIZE;
trace = SV_Move (neworg, ent->v.mins, ent->v.maxs, end, false, ent);
if (trace.allsolid || trace.startsolid)
return false;
}
if (trace.fraction == 1)
{
// if monster had the ground pulled out, go ahead and fall
if ( (int)ent->v.flags & FL_PARTIALGROUND )
{
VectorAdd (ent->v.origin, move, ent->v.origin);
if (relink)
SV_LinkEdict (ent, true);
ent->v.flags = (int)ent->v.flags & ~FL_ONGROUND;
// Con_Printf ("fall down\n");
return true;
}
return false; // walked off an edge
}
// check point traces down for dangling corners
VectorCopy (trace.endpos, ent->v.origin);
if (!SV_CheckBottom (ent))
{
if ( (int)ent->v.flags & FL_PARTIALGROUND )
{ // entity had floor mostly pulled out from underneath it
// and is trying to correct
if (relink)
SV_LinkEdict (ent, true);
return true;
}
VectorCopy (oldorg, ent->v.origin);
return false;
}
if ( (int)ent->v.flags & FL_PARTIALGROUND )
{
// Con_Printf ("back on ground\n");
ent->v.flags = (int)ent->v.flags & ~FL_PARTIALGROUND;
}
ent->v.groundentity = EDICT_TO_PROG(trace.ent);
// the move is ok
if (relink)
SV_LinkEdict (ent, true);
return true;
}