1088 lines
23 KiB
C
1088 lines
23 KiB
C
// g_utils.c -- misc utility functions for game module
|
|
|
|
#include "g_local.h"
|
|
#include "FX.h"
|
|
#include "g_Skeletons.h"
|
|
#include "random.h"
|
|
#include "vector.h"
|
|
#include "g_BoundingForm.h"
|
|
#include "g_Physics.h"
|
|
|
|
void G_ProjectSource (vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
|
|
{
|
|
result[0] = point[0] + forward[0] * distance[0] + right[0] * distance[1];
|
|
result[1] = point[1] + forward[1] * distance[0] + right[1] * distance[1];
|
|
result[2] = point[2] + forward[2] * distance[0] + right[2] * distance[1] + distance[2];
|
|
}
|
|
|
|
|
|
void G_SetToFree(edict_t *self)
|
|
{
|
|
if(self->PersistantCFX)
|
|
{
|
|
gi.RemovePersistantEffect(self->PersistantCFX, REMOVE_ENTITY);
|
|
self->PersistantCFX = 0;
|
|
}
|
|
|
|
self->think = G_FreeEdict;
|
|
self->nextthink = level.time + FRAMETIME;
|
|
self->svflags &= ~SVF_NOCLIENT;
|
|
|
|
self->next_pre_think = -1;
|
|
self->next_post_think = -1;
|
|
|
|
self->takedamage = DAMAGE_NO;
|
|
self->movetype = PHYSICSTYPE_NONE;
|
|
self->solid = SOLID_NOT;
|
|
self->touch = NULL;
|
|
self->blocked = NULL;
|
|
self->isBlocked = NULL;
|
|
self->isBlocking = NULL;
|
|
self->bounced = NULL;
|
|
VectorClear(self->mins);
|
|
VectorClear(self->maxs);
|
|
|
|
gi.linkentity(self);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
G_Find
|
|
|
|
Searches all active entities for the next one that holds
|
|
the matching string at fieldofs (use the FOFS() macro) in the structure.
|
|
|
|
Searches beginning at the edict after from, or the beginning if NULL
|
|
NULL will be returned if the end of the list is reached.
|
|
|
|
=============
|
|
*/
|
|
edict_t *G_Find (edict_t *from, int fieldofs, char *match)
|
|
{
|
|
char *s;
|
|
|
|
// if we aren't trying to find anything, then exit.
|
|
if (match == NULL)
|
|
return NULL;
|
|
|
|
if (!from)
|
|
from = g_edicts;
|
|
else
|
|
from++;
|
|
|
|
for ( ; from < &g_edicts[globals.num_edicts] ; from++)
|
|
{
|
|
if (!from->inuse)
|
|
continue;
|
|
s = *(char **) ((byte *)from + fieldofs);
|
|
if (!s)
|
|
continue;
|
|
if (!Q_stricmp (s, match))
|
|
return from;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//
|
|
//=================
|
|
// FindOnPath
|
|
//
|
|
// Returns damageable entities that lie along a given pathway. This is NOT 100% guaranteed to return a given edict only once.
|
|
//
|
|
//=================
|
|
|
|
edict_t *findonpath(edict_t *startent, vec3_t startpos, vec3_t endpos, vec3_t mins, vec3_t maxs, vec3_t *resultpos)
|
|
{
|
|
vec3_t vect, curpos;
|
|
trace_t trace;
|
|
float skipamount;
|
|
edict_t *tracebuddy;
|
|
|
|
VectorCopy(startpos, curpos);
|
|
tracebuddy = startent;
|
|
while(1)
|
|
{
|
|
gi.trace(curpos, mins, maxs, endpos, tracebuddy, MASK_SHOT,&trace);
|
|
|
|
// If we started inside something.
|
|
if (trace.startsolid || trace.allsolid)
|
|
{
|
|
if (trace.ent && trace.ent->takedamage)
|
|
{ // Found an item. Skip forward a distance and return the ent.
|
|
skipamount = maxs[2];
|
|
if (skipamount < 4)
|
|
skipamount = 4;
|
|
VectorSubtract(endpos, curpos, vect);
|
|
if (VectorNormalize(vect) < skipamount) // skip to the end.
|
|
VectorCopy(endpos, *resultpos);
|
|
else
|
|
VectorMA(curpos, skipamount, vect, *resultpos);
|
|
|
|
return(trace.ent);
|
|
}
|
|
else
|
|
{ // Didn't stop on anything useful, continue to next trace.
|
|
skipamount = maxs[2]; // Skip forward a bit.
|
|
if (skipamount < 4)
|
|
skipamount = 4;
|
|
VectorSubtract(endpos, curpos, vect);
|
|
if (VectorNormalize(vect) < skipamount) // skip to the end.
|
|
return(NULL); // Didn't find anything.
|
|
else
|
|
VectorMA(curpos, skipamount, vect, curpos);
|
|
if (trace.ent)
|
|
tracebuddy = trace.ent;
|
|
continue; // Do another trace.
|
|
}
|
|
}
|
|
|
|
// If we did not start inside something, but stopped at something.
|
|
if (trace.fraction < .99)
|
|
{
|
|
if (trace.ent && trace.ent->takedamage)
|
|
{ // Found an item. Skip forward a distance and return the ent.
|
|
skipamount = maxs[2];
|
|
if (skipamount < 4)
|
|
skipamount = 4;
|
|
VectorSubtract(endpos, trace.endpos, vect);
|
|
if (VectorNormalize(vect) < skipamount) // skip to the end.
|
|
VectorCopy(endpos, *resultpos);
|
|
else
|
|
VectorMA(trace.endpos, skipamount, vect, *resultpos);
|
|
|
|
return(trace.ent);
|
|
}
|
|
else
|
|
{ // Didn't stop on anything useful, continue to next trace.
|
|
skipamount = maxs[2]; // Skip forward a bit.
|
|
if (skipamount < 4)
|
|
skipamount = 4;
|
|
VectorSubtract(endpos, trace.endpos, vect);
|
|
if (VectorNormalize(vect) < skipamount) // skip to the end.
|
|
return(NULL); // Didn't find anything.
|
|
else
|
|
VectorMA(trace.endpos, skipamount, vect, curpos);
|
|
if (trace.ent)
|
|
tracebuddy = trace.ent;
|
|
continue; // Do another trace.
|
|
}
|
|
}
|
|
|
|
// If we finished the whole move.
|
|
{
|
|
VectorCopy(endpos, *resultpos);
|
|
return(NULL);
|
|
}
|
|
};
|
|
|
|
return(NULL); // Never gets here.
|
|
}
|
|
|
|
#define NEW_FINDS (1)
|
|
|
|
#if !NEW_FINDS
|
|
/*
|
|
=================
|
|
findradius
|
|
|
|
Returns entities that have origins within a spherical area
|
|
|
|
findradius (origin, radius)
|
|
=================
|
|
*/
|
|
edict_t *findradius (edict_t *from, vec3_t org, float rad)
|
|
{
|
|
vec3_t eorg;
|
|
int j;
|
|
|
|
if (!from)
|
|
from = g_edicts;
|
|
else
|
|
from++;
|
|
for ( ; from < &g_edicts[globals.num_edicts]; from++)
|
|
{
|
|
if (!from->inuse)
|
|
continue;
|
|
if (from->solid == SOLID_NOT)
|
|
continue;
|
|
for (j=0 ; j<3 ; j++)
|
|
eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
|
|
if (VectorLength(eorg) > rad)
|
|
continue;
|
|
return from;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// THis works like findradius, except it uses the bbox of an ent to indicate the area to check.
|
|
edict_t *findinblocking(edict_t *from, edict_t *checkent)
|
|
{
|
|
vec3_t min, max;
|
|
int j;
|
|
qboolean ok;
|
|
|
|
if (!from)
|
|
from = g_edicts;
|
|
else
|
|
from++;
|
|
|
|
VectorAdd(checkent->s.origin, checkent->mins, min);
|
|
VectorAdd(checkent->s.origin, checkent->maxs, max);
|
|
for ( ; from < &g_edicts[globals.num_edicts]; from++)
|
|
{
|
|
if (!from->inuse)
|
|
continue;
|
|
if (from->solid == SOLID_NOT)
|
|
continue;
|
|
if (from == checkent)
|
|
continue;
|
|
ok=true;
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
if ( from->s.origin[j] + from->mins[j] > max[j] ||
|
|
from->s.origin[j] + from->maxs[j] < min[j])
|
|
{ // Automatic failure.
|
|
ok=false;
|
|
break;
|
|
}
|
|
}
|
|
if (ok)
|
|
return from;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
=================
|
|
finddistance
|
|
|
|
Returns entities that have origins within a spherical shell area
|
|
|
|
finddistance (origin, mindist, maxdist)
|
|
=================
|
|
*/
|
|
edict_t *finddistance (edict_t *from, vec3_t org, float mindist, float maxdist)
|
|
{
|
|
vec3_t eorg;
|
|
int j;
|
|
float elen;
|
|
|
|
if (!from)
|
|
from = g_edicts;
|
|
else
|
|
from++;
|
|
for ( ; from < &g_edicts[globals.num_edicts]; from++)
|
|
{
|
|
if (!from->inuse)
|
|
continue;
|
|
if (from->solid == SOLID_NOT)
|
|
continue;
|
|
for (j=0 ; j<3 ; j++)
|
|
eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
|
|
elen = VectorLength(eorg);
|
|
if (elen > maxdist)
|
|
continue;
|
|
if (elen < mindist)
|
|
continue;
|
|
return from;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// THis works like findradius, except it uses two absolute positions to define where to search.
|
|
edict_t *findinbounds(edict_t *from, vec3_t min, vec3_t max)
|
|
{
|
|
int j;
|
|
qboolean ok;
|
|
|
|
if (!from)
|
|
from = g_edicts;
|
|
else
|
|
from++;
|
|
|
|
for ( ; from < &g_edicts[globals.num_edicts]; from++)
|
|
{
|
|
if (!from->inuse)
|
|
continue;
|
|
if (from->solid == SOLID_NOT)
|
|
continue;
|
|
|
|
ok=true;
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
if ( from->s.origin[j] + from->mins[j] > max[j] ||
|
|
from->s.origin[j] + from->maxs[j] < min[j])
|
|
{ // Automatic failure.
|
|
ok=false;
|
|
break;
|
|
}
|
|
}
|
|
if (ok)
|
|
return from;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#else
|
|
|
|
// THis works like findradius, except it uses the bbox of an ent to indicate the area to check.
|
|
edict_t *findinblocking(edict_t *from, edict_t *checkent)
|
|
{
|
|
static vec3_t min, max;
|
|
|
|
if (!from)
|
|
{
|
|
VectorAdd(checkent->s.origin, checkent->mins, min);
|
|
VectorAdd(checkent->s.origin, checkent->maxs, max);
|
|
}
|
|
while (1)
|
|
{
|
|
from=findinbounds(from,min,max);
|
|
if (!from)
|
|
return 0;
|
|
if (!from->inuse)
|
|
continue;
|
|
if (from == checkent)
|
|
continue;
|
|
return from;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
findradius
|
|
|
|
Returns entities that have origins within a spherical area
|
|
|
|
findradius (origin, radius)
|
|
=================
|
|
*/
|
|
edict_t *findradius (edict_t *from, vec3_t org, float rad)
|
|
{
|
|
static float max2;
|
|
static vec3_t min;
|
|
static vec3_t max;
|
|
vec3_t eorg;
|
|
int j;
|
|
float elen;
|
|
|
|
if (!from)
|
|
{
|
|
max2=rad*rad;
|
|
VectorCopy(org,min);
|
|
VectorCopy(org,max);
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
min[j]-=rad;
|
|
max[j]+=rad;
|
|
}
|
|
}
|
|
while (1)
|
|
{
|
|
from=findinbounds(from,min,max);
|
|
if (!from)
|
|
return 0;
|
|
if (!from->inuse)
|
|
continue;
|
|
for (j=0 ; j<3 ; j++)
|
|
eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
|
|
elen = DotProduct(eorg,eorg);
|
|
if (elen > max2)
|
|
continue;
|
|
return from;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=================
|
|
finddistance
|
|
|
|
Returns entities that have origins within a spherical shell area
|
|
|
|
finddistance (origin, mindist, maxdist)
|
|
=================
|
|
*/
|
|
edict_t *finddistance (edict_t *from, vec3_t org, float mindist, float maxdist)
|
|
{
|
|
static float min2;
|
|
static float max2;
|
|
static vec3_t min;
|
|
static vec3_t max;
|
|
vec3_t eorg;
|
|
int j;
|
|
float elen;
|
|
|
|
if (!from)
|
|
{
|
|
min2=mindist*mindist;
|
|
max2=maxdist*maxdist;
|
|
VectorCopy(org,min);
|
|
VectorCopy(org,max);
|
|
for (j=0 ; j<3 ; j++)
|
|
{
|
|
min[j]-=maxdist;
|
|
max[j]+=maxdist;
|
|
}
|
|
}
|
|
while (1)
|
|
{
|
|
from=findinbounds(from,min,max);
|
|
if (!from)
|
|
return 0;
|
|
if (!from->inuse)
|
|
continue;
|
|
for (j=0 ; j<3 ; j++)
|
|
eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
|
|
elen = DotProduct(eorg,eorg);
|
|
if (elen > max2)
|
|
continue;
|
|
if (elen < min2)
|
|
continue;
|
|
return from;
|
|
}
|
|
}
|
|
|
|
edict_t *findinbounds(edict_t *from, vec3_t min, vec3_t max)
|
|
{
|
|
static edict_t *touchlist[MAX_EDICTS];
|
|
static int index=-1;
|
|
static int num;
|
|
|
|
if (!from)
|
|
{
|
|
num = gi.BoxEdicts(min,max, touchlist, MAX_EDICTS, AREA_SOLID);
|
|
index=0;
|
|
}
|
|
else
|
|
{
|
|
assert(touchlist[index]==from);
|
|
// you cannot adjust the pointers yourself...
|
|
// this means you did not call it with the previous edict
|
|
index++;
|
|
}
|
|
for (;index<num;index++)
|
|
{
|
|
if (!touchlist[index]->inuse)
|
|
continue;
|
|
return touchlist[index];
|
|
}
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
=============
|
|
G_PickTarget
|
|
|
|
Searches all active entities for the next one that holds
|
|
the matching string at fieldofs (use the FOFS() macro) in the structure.
|
|
|
|
Searches beginning at the edict after from, or the beginning if NULL
|
|
NULL will be returned if the end of the list is reached.
|
|
|
|
=============
|
|
*/
|
|
#define MAXCHOICES 8
|
|
|
|
edict_t *G_PickTarget (char *targetname)
|
|
{
|
|
edict_t *ent = NULL;
|
|
int num_choices = 0;
|
|
edict_t *choice[MAXCHOICES];
|
|
|
|
if (!targetname)
|
|
{
|
|
#ifdef _DEVEL
|
|
gi.dprintf("G_PickTarget called with NULL targetname\n");
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
while(1)
|
|
{
|
|
ent = G_Find (ent, FOFS(targetname), targetname);
|
|
if (!ent)
|
|
break;
|
|
choice[num_choices++] = ent;
|
|
if (num_choices == MAXCHOICES)
|
|
break;
|
|
}
|
|
|
|
if (!num_choices)
|
|
{
|
|
#ifdef _DEVEL
|
|
gi.dprintf("G_PickTarget: target %s not found\n", targetname);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
return choice[irand(0, num_choices - 1)];
|
|
}
|
|
|
|
|
|
|
|
void Think_Delay (edict_t *ent)
|
|
{
|
|
G_UseTargets (ent, ent->activator);
|
|
G_FreeEdict (ent);
|
|
}
|
|
|
|
/*
|
|
==============================
|
|
G_UseTargets
|
|
|
|
the global "activator" should be set to the entity that initiated the firing.
|
|
|
|
If self.delay is set, a DelayedUse entity will be created that will actually
|
|
do the SUB_UseTargets after that many seconds have passed.
|
|
|
|
Centerprints any self.message to the activator.
|
|
|
|
Search for (string)targetname in all entities that
|
|
match (string)self.target and call their .use function
|
|
|
|
==============================
|
|
*/
|
|
void G_UseTargets (edict_t *ent, edict_t *activator)
|
|
{
|
|
edict_t *t;
|
|
|
|
//
|
|
// check for a delay
|
|
//
|
|
if (ent->delay)
|
|
{
|
|
// create a temp object to fire at a later time
|
|
t = G_Spawn();
|
|
t->movetype = PHYSICSTYPE_NONE;
|
|
t->classname = "DelayedUse";
|
|
t->nextthink = level.time + ent->delay;
|
|
t->think = Think_Delay;
|
|
t->activator = activator;
|
|
#ifdef _DEVEL
|
|
if (!activator)
|
|
gi.dprintf ("Think_Delay with no activator\n");
|
|
#endif
|
|
t->message = ent->message;
|
|
t->text_msg = ent->text_msg;
|
|
t->target = ent->target;
|
|
t->killtarget = ent->killtarget;
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// print the message
|
|
//
|
|
if ((ent->message) && !(activator->svflags & SVF_MONSTER))
|
|
{
|
|
gi.levelmsg_centerprintf (activator, (short)atoi(ent->message));
|
|
if (ent->noise_index)
|
|
{
|
|
gi.sound (activator, CHAN_AUTO, ent->noise_index, 1, ATTN_NORM, 0);
|
|
}
|
|
}
|
|
|
|
if ((ent->text_msg) && !(activator->svflags & SVF_MONSTER))
|
|
{
|
|
gi.centerprintf (activator, "%s", ent->text_msg);
|
|
}
|
|
|
|
//
|
|
// kill killtargets
|
|
//
|
|
if (ent->killtarget)
|
|
{
|
|
t = NULL;
|
|
while ((t = G_Find (t, FOFS(targetname), ent->killtarget)))
|
|
{
|
|
QPostMessage(t,MSG_DEATH,PRI_DIRECTIVE,"eeei",t,ent,activator,100000);
|
|
|
|
if (!ent->inuse)
|
|
{
|
|
#ifdef _DEVEL
|
|
gi.dprintf("entity was removed while using killtargets\n");
|
|
#endif
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// fire targets
|
|
//
|
|
if (ent->target)
|
|
{
|
|
t = NULL;
|
|
while ((t = G_Find (t, FOFS(targetname), ent->target)))
|
|
{
|
|
// doors fire area portals in a specific way
|
|
if (!Q_stricmp(t->classname, "func_areaportal") &&
|
|
(!Q_stricmp(ent->classname, "func_door") || !Q_stricmp(ent->classname, "func_door_rotating")))
|
|
continue;
|
|
|
|
if (t == ent)
|
|
{
|
|
#ifdef _DEVEL
|
|
gi.dprintf ("WARNING: %s used itself.\n", t->classname);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
if (t->use)
|
|
t->use (t, ent, activator);
|
|
}
|
|
if (!ent->inuse)
|
|
{
|
|
#ifdef _DEVEL
|
|
gi.dprintf("entity was removed while using targets\n");
|
|
#endif
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
qboolean PossessCorrectItem(edict_t *ent, gitem_t *item)
|
|
{
|
|
edict_t *t;
|
|
|
|
if(!ent->target_ent)
|
|
{
|
|
return(false);
|
|
}
|
|
ent = ent->target_ent;
|
|
t = NULL;
|
|
while ((t = G_Find (t, FOFS(targetname), ent->target)))
|
|
{
|
|
// doors fire area portals in a specific way
|
|
if (!Q_stricmp(t->classname, "func_areaportal") &&
|
|
(!Q_stricmp(ent->classname, "func_door") || !Q_stricmp(ent->classname, "func_door_rotating")))
|
|
continue;
|
|
|
|
if(t->item == item)
|
|
{
|
|
return(true);
|
|
}
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
/*
|
|
=============
|
|
VectorToString
|
|
|
|
This is just a convenience function
|
|
for printing vectors
|
|
=============
|
|
*/
|
|
char *vtos (vec3_t v)
|
|
{
|
|
static int index;
|
|
static char str[8][32];
|
|
char *s;
|
|
|
|
// use an array so that multiple vtos won't collide
|
|
s = str[index];
|
|
index = (index + 1)&7;
|
|
|
|
Com_sprintf (s, 32, "(%i %i %i)", (int)v[0], (int)v[1], (int)v[2]);
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
vec3_t VEC_UP = {0.0, -1.0, 0.0};
|
|
vec3_t MOVEDIR_UP = {0.0, 0.0, 1.0};
|
|
vec3_t VEC_DOWN = {0.0, -2.0, 0.0};
|
|
vec3_t MOVEDIR_DOWN = {0.0, 0.0, -1.0};
|
|
|
|
void G_SetMovedir (vec3_t angles, vec3_t movedir)
|
|
{
|
|
if (VectorCompare (angles, VEC_UP))
|
|
{
|
|
VectorCopy (MOVEDIR_UP, movedir);
|
|
}
|
|
else if (VectorCompare (angles, VEC_DOWN))
|
|
{
|
|
VectorCopy (MOVEDIR_DOWN, movedir);
|
|
}
|
|
else
|
|
{
|
|
AngleVectors (angles, movedir, NULL, NULL);
|
|
}
|
|
|
|
VectorClear (angles);
|
|
}
|
|
|
|
|
|
float vectoyaw (vec3_t vec)
|
|
{
|
|
float yaw;
|
|
|
|
if (vec[YAW] == 0 && vec[PITCH] == 0)
|
|
yaw = 0;
|
|
else
|
|
{
|
|
yaw = (float) (atan2(vec[YAW], vec[PITCH]) * (180 / M_PI));
|
|
if (yaw < 0)
|
|
yaw += 360;
|
|
}
|
|
|
|
return yaw;
|
|
}
|
|
|
|
char *G_CopyString (char *in)
|
|
{
|
|
char *out;
|
|
|
|
out = gi.TagMalloc (strlen(in)+1, TAG_LEVEL);
|
|
strcpy (out, in);
|
|
return out;
|
|
}
|
|
|
|
|
|
void G_InitEdict (edict_t *self)
|
|
{
|
|
self->s.clientEffects.buf = NULL;
|
|
self->s.clientEffects.bufSize = 0;
|
|
self->s.clientEffects.freeBlock = 0;
|
|
self->s.clientEffects.numEffects = 0;
|
|
|
|
self->inuse = true;
|
|
self->movetype = PHYSICSTYPE_NONE;
|
|
self->classname = "noclass";
|
|
self->gravity = 1.0F;
|
|
self->friction = 1.0F;
|
|
self->elasticity = ELASTICITY_SLIDE;
|
|
self->s.number = self - g_edicts;
|
|
self->s.scale = 1.0F;
|
|
self->msgHandler = NULL;
|
|
self->svflags = 0;
|
|
self->client_sent = 0;
|
|
self->just_deleted = 0;
|
|
self->reflected_time = level.time;
|
|
|
|
}
|
|
|
|
/*
|
|
=================
|
|
G_Spawn
|
|
|
|
Either finds a free edict, or allocates a new one.
|
|
Try to avoid reusing an entity that was recently freed, because it
|
|
can cause the client to think the entity morphed into something else
|
|
instead of being removed and recreated, which can cause interpolated
|
|
angles and bad trails.
|
|
=================
|
|
*/
|
|
edict_t *G_Spawn (void)
|
|
{
|
|
int i;
|
|
edict_t *e;
|
|
//static unsigned int entID = 0;
|
|
|
|
e = &g_edicts[(int)maxclients->value+1];
|
|
for(i=maxclients->value + 1; i < globals.num_edicts; ++i, ++e)
|
|
{
|
|
// the first couple seconds of server time can involve a lot of
|
|
// freeing and allocating, so relax the replacement policy
|
|
if(!e->inuse && e->freetime <= level.time)
|
|
{
|
|
G_InitEdict (e);
|
|
|
|
++e->s.usageCount;
|
|
return e;
|
|
}
|
|
}
|
|
|
|
if (i == game.maxentities)
|
|
{
|
|
assert(0);
|
|
gi.error ("ED_Alloc: Spawning more than %d edicts", game.maxentities);
|
|
}
|
|
|
|
globals.num_edicts++;
|
|
G_InitEdict (e);
|
|
return e;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
G_FreeEdict
|
|
|
|
Marks the edict as free
|
|
=================
|
|
*/
|
|
void G_FreeEdict(edict_t *self)
|
|
{
|
|
SinglyLinkedList_t msgs;
|
|
char *temp;
|
|
unsigned int usageCount;
|
|
int server_seen;
|
|
int entnum;
|
|
|
|
gi.unlinkentity (self); // unlink from world
|
|
|
|
// From Quake2 3.17 code release.
|
|
|
|
if ((self - g_edicts) <= (maxclients->value + BODY_QUEUE_SIZE))
|
|
{
|
|
#ifdef _DEVEL
|
|
gi.dprintf("tried to free special edict\n");
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// Start non-quake2.
|
|
|
|
// Portals need to be marked as open even if they are freed in deathmatch, only when deliberately removed for netplay.
|
|
if (self->classname && level.time <= 0.2) // Just upon startup
|
|
{
|
|
if (Q_stricmp(self->classname, "func_areaportal") == 0)
|
|
gi.SetAreaPortalState (self->style, true);
|
|
}
|
|
|
|
if(self->s.effects & EF_JOINTED)
|
|
{
|
|
FreeSkeleton(self->s.rootJoint);
|
|
}
|
|
|
|
if(self->s.clientEffects.buf)
|
|
{
|
|
temp = self->s.clientEffects.buf; // buffer needs to be stored to be cleared by the engine
|
|
}
|
|
else
|
|
{
|
|
temp = NULL;
|
|
}
|
|
|
|
msgs = self->msgQ.msgs;
|
|
usageCount = self->s.usageCount;
|
|
server_seen = self->client_sent;
|
|
entnum = self->s.number;
|
|
|
|
// End non-quake2.
|
|
|
|
memset(self, 0, sizeof(*self));
|
|
|
|
// Start non-quake2.
|
|
|
|
self->s.usageCount = usageCount;
|
|
self->msgQ.msgs = msgs;
|
|
self->s.clientEffects.buf = temp;
|
|
self->just_deleted = SERVER_DELETED;
|
|
self->client_sent = server_seen;
|
|
self->s.number = entnum;
|
|
|
|
// End non-quake2.
|
|
|
|
self->classname = "freed";
|
|
self->freetime = level.time + 2.0;
|
|
self->inuse = false;
|
|
self->s.skeletalType = SKEL_NULL;
|
|
|
|
self->svflags = SVF_NOCLIENT; // so it will get removed from the client properly
|
|
}
|
|
|
|
|
|
/*
|
|
============
|
|
G_TouchTriggers
|
|
|
|
============
|
|
*/
|
|
void G_TouchTriggers (edict_t *ent)
|
|
{
|
|
int i, num;
|
|
edict_t *touch[MAX_EDICTS], *hit;
|
|
|
|
// dead things don't activate triggers!
|
|
if ((ent->client || (ent->svflags & SVF_MONSTER)) && (ent->health <= 0))
|
|
return;
|
|
|
|
num = gi.BoxEdicts (ent->absmin, ent->absmax, touch
|
|
, MAX_EDICTS, AREA_TRIGGERS);
|
|
|
|
// be careful, it is possible to have an entity in this
|
|
// list removed before we get to it (killtriggered)
|
|
for (i=0 ; i<num ; i++)
|
|
{
|
|
hit = touch[i];
|
|
if (!hit->inuse)
|
|
continue;
|
|
if (!hit->touch)
|
|
continue;
|
|
hit->touch (hit, ent, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
G_TouchSolids
|
|
|
|
Call after linking a new trigger in during gameplay
|
|
to force all entities it covers to immediately touch it
|
|
============
|
|
*/
|
|
void G_TouchSolids (edict_t *ent)
|
|
{
|
|
int i, num;
|
|
edict_t *touch[MAX_EDICTS], *hit;
|
|
|
|
num = gi.BoxEdicts (ent->absmin, ent->absmax, touch
|
|
, MAX_EDICTS, AREA_SOLID);
|
|
|
|
// be careful, it is possible to have an entity in this
|
|
// list removed before we get to it (killtriggered)
|
|
for (i=0 ; i<num ; i++)
|
|
{
|
|
hit = touch[i];
|
|
if (!hit->inuse)
|
|
continue;
|
|
if (ent->touch)
|
|
ent->touch (hit, ent, NULL, NULL);
|
|
if (!ent->inuse)
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
==============================================================================
|
|
|
|
Kill box
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
/*
|
|
=================
|
|
KillBox
|
|
|
|
Kills all entities that would touch the proposed new positioning
|
|
of ent. Ent should be unlinked before calling this!
|
|
=================
|
|
*/
|
|
qboolean KillBox (edict_t *ent)
|
|
{
|
|
edict_t *current=NULL;
|
|
vec3_t mins, maxs;
|
|
|
|
// since we can't trust the absmin and absmax to be set correctly on entry, I'll create my own versions
|
|
|
|
VectorAdd(ent->s.origin, ent->mins, mins);
|
|
VectorAdd(ent->s.origin, ent->maxs, maxs);
|
|
|
|
while (1)
|
|
{
|
|
current = findinbounds(current, mins, maxs);
|
|
|
|
// don't allow us to kill the player
|
|
if(current == ent)
|
|
continue;
|
|
|
|
// we've checked everything
|
|
if(!current)
|
|
break;
|
|
|
|
// nail it
|
|
if (current->takedamage)
|
|
T_Damage (current, ent, ent, vec3_origin, ent->s.origin, vec3_origin, 100000, 0,
|
|
DAMAGE_NO_PROTECTION|DAMAGE_AVOID_ARMOR|DAMAGE_HURT_FRIENDLY,MOD_TELEFRAG);
|
|
|
|
}
|
|
|
|
return true; // all clear
|
|
}
|
|
|
|
/*
|
|
ClearBBox
|
|
|
|
returns true if there is nothing in you BBOX
|
|
*/
|
|
|
|
qboolean ClearBBox (edict_t *self)
|
|
{
|
|
vec3_t top, bottom, mins, maxs;
|
|
trace_t trace;
|
|
VectorSet(mins, self->mins[0], self->mins[1], 0);
|
|
VectorSet(maxs, self->maxs[0], self->maxs[1], 1);
|
|
VectorSet(bottom, self->s.origin[0], self->s.origin[1], self->absmin[2]);
|
|
VectorSet(top, self->s.origin[0], self->s.origin[1], self->absmax[2] - 1);
|
|
|
|
gi.trace(top, mins, maxs, bottom, self, self->clipmask,&trace);
|
|
if(trace.startsolid || trace.allsolid)
|
|
return false;
|
|
|
|
if(trace.fraction == 1.0)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
=================
|
|
oldfindradius
|
|
|
|
Returns entities that have origins within a spherical area
|
|
|
|
oldfindradius (origin, radius)
|
|
=================
|
|
*/
|
|
edict_t *oldfindradius (edict_t *from, vec3_t org, float rad)
|
|
{
|
|
vec3_t eorg;
|
|
int j;
|
|
|
|
if (!from)
|
|
from = g_edicts;
|
|
else
|
|
from++;
|
|
for ( ; from < &g_edicts[globals.num_edicts]; from++)
|
|
{
|
|
if (!from->inuse)
|
|
continue;
|
|
if (from->solid == SOLID_NOT)
|
|
continue;
|
|
for (j=0 ; j<3 ; j++)
|
|
eorg[j] = org[j] - (from->s.origin[j] + (from->mins[j] + from->maxs[j])*0.5);
|
|
if (VectorLength(eorg) > rad)
|
|
continue;
|
|
return from;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
// ========================================
|
|
// LinkMissile(edict_t *self)
|
|
//
|
|
// This is a way to kinda "cheat" the system.
|
|
// We don't want missiles to be considered for collision,
|
|
// yet we want them to collide with other things.
|
|
// So when we link the entity (for rendering, etc) we set
|
|
// SOLID_NOT so certain things don't happen.
|
|
// ========================================
|
|
void G_LinkMissile(edict_t *self)
|
|
{
|
|
int oldsolid;
|
|
|
|
oldsolid=self->solid;
|
|
|
|
// self->solid=SOLID_NOT; // comment this line out for old behaviour
|
|
gi.linkentity(self);
|
|
self->solid=oldsolid;
|
|
}
|
|
|