/*
=================
ED_Alloc
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 *ED_Alloc (void)
{
int i;
edict_t *e;
for ( i=MAX_CLIENTS+1 ; i<sv.num_edicts ; i++)
{
e = EDICT_NUM(i);
// the first couple seconds of server time can involve a lot of
// freeing and allocating, so relax the replacement policy
if (e->e->free && ( e->e->freetime < 2 || sv.time - e->e->freetime > 0.5 ) )
{
ED_ClearEdict (e);
return e;
}
}
if (i == MAX_EDICTS)
{
Con_Printf ("WARNING: ED_Alloc: no free edicts\n");
// step on whatever is the last edict
e = EDICT_NUM(--i);
SV_UnlinkEdict(e);
}
else
sv.num_edicts++;
e = EDICT_NUM(i);
ED_ClearEdict (e);
return e;
}
/*
=================
ED_Free
Marks the edict as free
FIXME: walk all entities and NULL out references to this entity
=================
*/
void ED_Free (edict_t *ed)
{
SV_UnlinkEdict (ed); // unlink from world bsp
ed->inuse = false;
ed->v.model = 0;
ed->v.takedamage = 0;
ed->v.modelindex = 0;
ed->v.colormap = 0;
ed->v.skin = 0;
ed->v.frame = 0;
VectorClear (ed->v.origin);
VectorClear (ed->v.angles);
ed->v.nextthink = -1;
ed->v.solid = 0;
ed->freetime = sv.time;
}
/*
* Marks the edict as free
*/
void G_FreeEdict(edict_t *ed)
{
SV_UnlinkEdict(ed); /* unlink from world */
if (deathmatch->value || coop->value) {
if ((ed - g_edicts) <= (maxclients->value + BODY_QUEUE_SIZE)) {
return;
}
} else {
if ((ed - g_edicts) <= maxclients->value) {
return;
}
}
memset(ed, 0, sizeof(*ed));
ed->classname = "freed";
ed->freetime = level.time;
ed->inuse = false;
}
/*
=================
ED_Free
Marks the edict as free
FIXME: walk all entities and NULL out references to this entity
=================
*/
void ED_Free (edict_t *ed)
{
SV_UnlinkEdict (ed); // unlink from world bsp
ed->free = true;
ed->v.model = 0;
ed->v.takedamage = 0;
ed->v.modelindex = 0;
ed->v.colormap = 0;
ed->v.skin = 0;
ed->v.frame = 0;
VectorCopy (vec3_origin, ed->v.origin);
VectorCopy (vec3_origin, ed->v.angles);
ed->v.nextthink = -1;
ed->v.solid = 0;
ed->alpha = ENTALPHA_DEFAULT; //johnfitz -- reset alpha for next entity
ed->freetime = sv.time;
}
/* DESCRIPTION: ED_Free
// LOCATION: pr_edict.c
// PATH: lots
//
// Zeros out the edict. I assume--but haven't yet found the init function--
// that edicts are on the hunk, and are reused. QW indicates the possible need
// to go through and remove all possible traces to the now gone edict,
// which would probably help out EntMod, but that's not happening just yet.
*/
void ED_Free(edict_t *ed) {
if(ed == NULL) {
Con_Printf("%s: Passed NULL edict.\n", __FUNCTION__);
return;
}
if(ed->free == 1) {
Con_Printf("%s: Passed entity already 'free'. Thought you should know.\n", __FUNCTION__);
}
SV_UnlinkEdict(ed);
FreeEntPrivateData(ed);
ed->free = 1;
ed->serialnumber++;
ed->v.flags = 0;
ed->v.model = 0;
ed->v.takedamage = 0;
ed->v.modelindex = 0;
ed->v.colormap = 0;
ed->v.skin = 0;
ed->v.frame = 0;
ed->v.scale = 0;
ed->v.gravity = 0;
ed->v.origin[0] = 0;
ed->v.origin[1] = 0;
ed->v.origin[2] = 0;
ed->v.angles[0] = 0;
ed->v.angles[1] = 0;
ed->v.angles[2] = 0;
ed->v.nextthink = -1;
ed->v.solid = SOLID_NOT;
ed->freetime = global_sv.time0c;
}
/* Marks the edict as free
FIXME: walk all entities and NULL out references to this entity
*/
void ED_Free(ServerEntity_t *ed)
{
SV_UnlinkEdict(ed); // unlink from world bsp
ed->free = true;
ed->v.model = 0;
ed->v.bTakeDamage = false;
ed->v.modelindex = 0;
ed->v.colormap = 0;
ed->Model.iSkin = 0;
ed->v.frame = 0;
ed->v.dNextThink = -1;
ed->Physics.iSolid = SOLID_NOT;
ed->Model.fScale = 1.0f;
ed->alpha = ENTALPHA_DEFAULT; //johnfitz -- reset alpha for next entity
Math_VectorCopy(g_mvOrigin3f,ed->v.origin);
Math_VectorCopy(g_mvOrigin3f,ed->v.angles);
ed->fFreeTime = sv.time;
}
void SV_LinkEdict (edict_t *ent)
{
areanode_t *node;
int leafs[MAX_TOTAL_ENT_LEAFS];
int clusters[MAX_TOTAL_ENT_LEAFS];
int num_leafs;
int i, j, k;
int area;
int topnode;
if (ent->area.prev)
SV_UnlinkEdict (ent); // unlink from old position
if (ent == ge->edicts)
return; // don't add the world
if (!ent->inuse)
return;
// set the size
VectorSubtract (ent->maxs, ent->mins, ent->size);
// encode the size into the entity_state for client prediction
if (ent->solid == SOLID_BBOX && !(ent->svflags & SVF_DEADMONSTER))
{ // assume that x/y are equal and symetric
i = ent->maxs[0]/8;
if (i<1)
i = 1;
if (i>31)
i = 31;
// z is not symetric
j = (-ent->mins[2])/8;
if (j<1)
j = 1;
if (j>31)
j = 31;
// and z maxs can be negative...
k = (ent->maxs[2]+32)/8;
if (k<1)
k = 1;
if (k>63)
k = 63;
ent->s.solid = (k<<10) | (j<<5) | i;
}
else if (ent->solid == SOLID_BSP)
{
ent->s.solid = 31; // a solid_bbox will never create this value
}
else
ent->s.solid = 0;
// set the abs box
if (ent->solid == SOLID_BSP &&
(ent->s.angles[0] || ent->s.angles[1] || ent->s.angles[2]) )
{ // expand for rotation
float max, v;
int i;
max = 0;
for (i=0 ; i<3 ; i++)
{
v =fabs( ent->mins[i]);
if (v > max)
max = v;
v =fabs( ent->maxs[i]);
if (v > max)
max = v;
}
for (i=0 ; i<3 ; i++)
{
ent->absmin[i] = ent->s.origin[i] - max;
ent->absmax[i] = ent->s.origin[i] + max;
}
}
else
{ // normal
VectorAdd (ent->s.origin, ent->mins, ent->absmin);
VectorAdd (ent->s.origin, ent->maxs, ent->absmax);
}
// because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
ent->absmin[0] -= 1;
ent->absmin[1] -= 1;
ent->absmin[2] -= 1;
ent->absmax[0] += 1;
ent->absmax[1] += 1;
ent->absmax[2] += 1;
// link to PVS leafs
ent->num_clusters = 0;
ent->areanum = 0;
ent->areanum2 = 0;
//get all leafs, including solids
num_leafs = CM_BoxLeafnums (ent->absmin, ent->absmax,
leafs, MAX_TOTAL_ENT_LEAFS, &topnode);
// set areas
for (i=0 ; i<num_leafs ; i++)
{
clusters[i] = CM_LeafCluster (leafs[i]);
area = CM_LeafArea (leafs[i]);
if (area)
{ // doors may legally straggle two areas,
// but nothing should evern need more than that
if (ent->areanum && ent->areanum != area)
{
if (ent->areanum2 && ent->areanum2 != area && sv.state == ss_loading)
Com_DPrintf ("Object touching 3 areas at %f %f %f\n",
ent->absmin[0], ent->absmin[1], ent->absmin[2]);
ent->areanum2 = area;
}
else
ent->areanum = area;
}
}
if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
}
else
{
ent->num_clusters = 0;
for (i=0 ; i<num_leafs ; i++)
{
if (clusters[i] == -1)
continue; // not a visible leaf
for (j=0 ; j<i ; j++)
if (clusters[j] == clusters[i])
break;
if (j == i)
{
if (ent->num_clusters == MAX_ENT_CLUSTERS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
break;
}
ent->clusternums[ent->num_clusters++] = clusters[i];
}
}
}
// if first time, make sure old_origin is valid
if (!ent->linkcount)
{
VectorCopy (ent->s.origin, ent->s.old_origin);
}
ent->linkcount++;
if (ent->solid == SOLID_NOT)
return;
// find the first node that the ent's box crosses
node = sv_areanodes;
while (1)
{
if (node->axis == -1)
break;
if (ent->absmin[node->axis] > node->dist)
node = node->children[0];
else if (ent->absmax[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
}
// link it in
if (ent->solid == SOLID_TRIGGER)
InsertLinkBefore (&ent->area, &node->trigger_edicts);
else
InsertLinkBefore (&ent->area, &node->solid_edicts);
}
void SV_LinkEdict(edict_t *ent)
{
guard(SV_LinkEdict);
int i, j, k;
//!! HOOK - move outside ?
if (bspfile.type != map_q2)
{
if (ent->s.modelindex >= 0 && ent->s.modelindex < MAX_MODELS)
{
// link model hook
const char *modelName = sv.configstrings[CS_MODELS + ent->s.modelindex];
if (!strcmp(modelName, "models/objects/dmspot/tris.md2"))
{
// teleporter (source+target) was found
// appPrintf(S_CYAN"teleport: %g %g %g\n", VECTOR_ARG(ent->s.origin));
return; // simply do not link model; trigger entity will be added anyway
}
}
}
if (ent->area.prev)
SV_UnlinkEdict(ent); // unlink from old position (i.e. relink edict)
if (ent == ge->edicts)
return; // don't add the world
if (!ent->inuse)
return;
entityHull_t &ex = ents[NUM_FOR_EDICT(ent)];
memset(&ex, 0, sizeof(entityHull_t));
ex.owner = ent;
ex.axis.FromEuler(ent->s.angles);
// set the size
VectorSubtract(ent->bounds.maxs, ent->bounds.mins, ent->size);
// encode the size into the entity_state for client prediction
if (ent->solid == SOLID_BBOX)
{
// assume that x/y are equal and symetric
i = appRound(ent->bounds.maxs[0] / 8);
// z is not symetric
j = appRound(-ent->bounds.mins[2] / 8);
// and z maxs can be negative...
k = appRound((ent->bounds.maxs[2] + 32) / 8);
// original Q2 have bounded i/j/k/ with lower margin==1 (for client prediction only); this will
// produce incorrect collision test when bbox mins/maxs is (0,0,0)
i = bound(i, 0, 31); // mins/maxs[0,1] range is -248..0/0..248
j = bound(j, 0, 31); // mins[2] range is [-248..0]
k = bound(k, 0, 63); // maxs[2] range is [-32..472]
// if SVF_DEADMONSTER, s.solid should be 0
ent->s.solid = (ent->svflags & SVF_DEADMONSTER) ? 0 : (k<<10) | (j<<5) | i;
i *= 8;
j *= 8;
k *= 8;
ex.bounds.mins.Set(-i, -i, -j);
ex.bounds.maxs.Set(i, i, k - 32);
ex.bounds.GetCenter(ex.center);
ex.center.Add(ent->s.origin);
ex.model = NULL;
ex.radius = VectorDistance(ex.bounds.maxs, ex.bounds.mins) / 2;
}
else if (ent->solid == SOLID_BSP)
{
ex.model = sv.models[ent->s.modelindex];
if (!ex.model) Com_DropError("MOVETYPE_PUSH with a non bsp model");
CVec3 v;
ex.model->bounds.GetCenter(v);
UnTransformPoint(ent->s.origin, ex.axis, v, ex.center);
ex.radius = ex.model->radius;
ent->s.solid = 31; // a SOLID_BBOX will never create this value (mins=(-248,-248,0) maxs=(248,248,-32))
}
else if (ent->solid == SOLID_TRIGGER)
{
ent->s.solid = 0;
// check for model link
ex.model = sv.models[ent->s.modelindex];
if (!ex.model)
{
// model not attached by game, check entstring
//?? can optimize: add 'bool spawningEnts', set to 'true' before SpawnEntities()
//?? and 'false' after; skip code below when 'false'
for (triggerModelLink_t *link = bspfile.modelLinks; link; link = link->next)
#define CMP(n) (fabs(ent->s.origin[n] - link->origin[n]) < 0.5f)
if (CMP(0) && CMP(1) && CMP(2))
{
CBspModel *model = CM_InlineModel(link->modelIdx);
VectorSubtract(model->bounds.maxs, ent->s.origin, ent->bounds.maxs);
VectorSubtract(model->bounds.mins, ent->s.origin, ent->bounds.mins);
break;
}
#undef CMP
}
}
else
ent->s.solid = 0;
// set the abs box
if (ent->solid == SOLID_BSP && (ent->s.angles[0] || ent->s.angles[1] || ent->s.angles[2]))
{
// expand for rotation
for (i = 0; i < 3 ; i++)
{
ent->absBounds.mins[i] = ex.center[i] - ex.radius;
ent->absBounds.maxs[i] = ex.center[i] + ex.radius;
}
}
else
{ // normal
VectorAdd(ent->s.origin, ent->bounds.mins, ent->absBounds.mins);
VectorAdd(ent->s.origin, ent->bounds.maxs, ent->absBounds.maxs);
}
// because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
for (i = 0; i < 3; i++)
{
ent->absBounds.mins[i] -= 1;
ent->absBounds.maxs[i] += 1;
}
// link to PVS leafs
ent->num_clusters = 0;
ent->zonenum = 0;
ent->zonenum2 = 0;
// get all leafs, including solids
CBspLeaf *leafs[MAX_TOTAL_ENT_LEAFS];
int topnode;
int num_leafs = CM_BoxLeafs(ent->absBounds, ARRAY_ARG(leafs), &topnode);
// set zones
int clusters[MAX_TOTAL_ENT_LEAFS];
for (i = 0; i < num_leafs; i++)
{
clusters[i] = leafs[i]->cluster;
int zone = leafs[i]->zone;
if (zone)
{ // doors may legally straggle two zones,
// but nothing should evern need more than that
if (ent->zonenum && ent->zonenum != zone)
{
if (ent->zonenum2 && ent->zonenum2 != zone && sv.state == ss_loading)
Com_DPrintf("Object touching 3 zones at %g %g %g\n", VECTOR_ARG(ent->absBounds.mins));
ent->zonenum2 = zone;
}
else
ent->zonenum = zone;
}
}
if (num_leafs >= MAX_TOTAL_ENT_LEAFS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
}
else
{
ent->num_clusters = 0;
for (i = 0; i < num_leafs; i++)
{
if (clusters[i] == -1)
continue; // not a visible leaf
for (j = 0; j < i; j++)
if (clusters[j] == clusters[i])
break;
if (j == i)
{
if (ent->num_clusters == MAX_ENT_CLUSTERS)
{ // assume we missed some leafs, and mark by headnode
ent->num_clusters = -1;
ent->headnode = topnode;
break;
}
ent->clusternums[ent->num_clusters++] = clusters[i];
}
}
}
// if first time, make sure old_origin is valid
if (!ent->linkcount)
ent->s.old_origin = ent->s.origin;
ent->linkcount++;
if (ent->solid == SOLID_NOT)
return;
// find the first node that the ent's box crosses
areanode_t *node = areaNodes;
while (node->axis != -1)
{
if (ent->absBounds.mins[node->axis] > node->dist)
node = node->children[0];
else if (ent->absBounds.maxs[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
}
// link it in
areanode_t *node2 = node;
if (ent->solid == SOLID_TRIGGER)
{
InsertLinkBefore(ent->area, node->trigEdicts);
for ( ; node2; node2 = node2->parent)
node2->numTrigEdicts++;
}
else
{
InsertLinkBefore(ent->area, node->solidEdicts);
for ( ; node2; node2 = node2->parent)
node2->numSolidEdicts++;
}
ex.area = node;
unguard;
}
/*
===============
SV_LinkEdict
===============
*/
void SV_LinkEdict (edict_t *ent, qbool touch_triggers)
{
areanode_t *node;
if (ent->area.prev)
SV_UnlinkEdict (ent); // unlink from old position
if (ent == sv.edicts)
return; // don't add the world
if (!ent->inuse)
return;
// set the abs box
VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
//
// to make items easier to pick up and allow them to be grabbed off
// of shelves, the abs sizes are expanded
//
if ((int)ent->v.flags & FL_ITEM)
{
ent->v.absmin[0] -= 15;
ent->v.absmin[1] -= 15;
ent->v.absmax[0] += 15;
ent->v.absmax[1] += 15;
}
else
{ // because movement is clipped an epsilon away from an actual edge,
// we must fully check even when bounding boxes don't quite touch
ent->v.absmin[0] -= 1;
ent->v.absmin[1] -= 1;
ent->v.absmin[2] -= 1;
ent->v.absmax[0] += 1;
ent->v.absmax[1] += 1;
ent->v.absmax[2] += 1;
}
// link to PVS leafs
if (ent->v.modelindex)
SV_LinkToLeafs (ent);
else
ent->num_leafs = 0;
if (ent->v.solid == SOLID_NOT)
return;
// find the first node that the ent's box crosses
node = sv_areanodes;
while (1)
{
if (node->axis == -1)
break;
if (ent->v.absmin[node->axis] > node->dist)
node = node->children[0];
else if (ent->v.absmax[node->axis] < node->dist)
node = node->children[1];
else
break; // crosses the node
}
// link it in
if (ent->v.solid == SOLID_TRIGGER)
InsertLinkBefore (&ent->area, &node->trigger_edicts);
else
InsertLinkBefore (&ent->area, &node->solid_edicts);
// if touch_triggers, touch all entities at this node and decend for more
if (touch_triggers)
SV_TouchLinks ( ent, sv_areanodes );
}