ubergames/rpg-x2
0
0
Fork 0
mirror of https://github.com/UberGames/RPG-X2.git synced 2024-11-27 22:52:33 +00:00
Code Issues Projects Releases Packages Wiki Activity
rpg-x2/game/g_utils.c

1201 lines
26 KiB
C
Raw Normal View History

initial commit
2011-06-01 12:20:56 +00:00
// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_utils.c -- misc utility functions for game module
#include "g_local.h"
#ifdef XTRA
typedef struct {
char oldShader[MAX_QPATH];
char newShader[MAX_QPATH];
float timeOffset;
} shaderRemap_t;
#define MAX_SHADER_REMAPS 128
int remapCount = 0;
shaderRemap_t remappedShaders[MAX_SHADER_REMAPS];
void AddRemap(const char *oldShader, const char *newShader, float timeOffset) {
int i;
for (i = 0; i < remapCount; i++) {
if (Q_stricmp(oldShader, remappedShaders[i].oldShader) == 0) {
// found it, just update this one
strcpy(remappedShaders[i].newShader,newShader);
remappedShaders[i].timeOffset = timeOffset;
return;
}
}
if (remapCount < MAX_SHADER_REMAPS) {
strcpy(remappedShaders[remapCount].newShader,newShader);
strcpy(remappedShaders[remapCount].oldShader,oldShader);
remappedShaders[remapCount].timeOffset = timeOffset;
remapCount++;
}
}
const char *BuildShaderStateConfig(void) {
static char buff[MAX_STRING_CHARS*4];
char out[(MAX_QPATH * 2) + 5];
int i;
memset(buff, 0, MAX_STRING_CHARS);
for (i = 0; i < remapCount; i++) {
Com_sprintf(out, (MAX_QPATH * 2) + 5, "%s=%s:%5.2f@", remappedShaders[i].oldShader, remappedShaders[i].newShader, remappedShaders[i].timeOffset);
Q_strcat( buff, sizeof( buff ), out);
}
return buff;
}
#endif
/*
=========================================================================
model / sound configstring indexes
=========================================================================
*/
/*
================
G_FindConfigstringIndex
================
*/
int G_FindConfigstringIndex( char *name, int start, int max, qboolean create ) {
int i;
char s[MAX_STRING_CHARS];
if ( !name || !name[0] ) {
return 0;
}
for ( i=1 ; i<max ; i++ ) {
trap_GetConfigstring( start + i, s, sizeof( s ) );
if ( !s[0] ) {
break;
}
if ( !strcmp( s, name ) ) {
return i;
}
}
if ( !create ) {
return 0;
}
if ( i == max ) {
//G_Error( "G_FindConfigstringIndex: overflow" );
G_Printf( S_COLOR_RED "G_FindConfigstringIndex: Full!! Could not add value: %s\n", name );
}
trap_SetConfigstring( start + i, name );
return i;
}
//TiM - all the data is encoded in one string in the hopes that by doing this, less
//data is sent on map run time
//it is assumed 30 lots of 32 stringed entries are encoded in each one
/*int G_FindCompressedConfigstringIndex( char *name, int start, int max, qboolean create ) {
int i;
int j=1;
int lastJump=0;
char s[MAX_STRING_CHARS];
if ( !name || !name[0] ) {
return 0;
}
trap_GetConfigstring( start + j, s, sizeof( s ) );
for ( i=1 ; i<max*30; i++ )
{
if ( !s[0] )
{
break;
}
if ( !strcmp( Info_ValueForKey( s, va( "%i", i ) ), name ) ) {
return i;
}
if ( i >= lastJump + 30 )
{
lastJump += 30;
j++;
trap_GetConfigstring( start + j, s, sizeof( s ) );
}
}
if ( !create ) {
return 0;
}
if ( i == max ) {
G_Error( "G_FindCompressedConfigstringIndex: overflow" );
}
if ( strlen( name ) > 32 )
name[31] = '\0';
Info_SetValueForKey ( s, va( "%i", i ), name );
trap_SetConfigstring( start + j, name );
return i;
}*/
int G_ModelIndex( char *name ) {
return G_FindConfigstringIndex (name, CS_MODELS, MAX_MODELS, qtrue);
}
int G_SoundIndex( char *name ) {
return G_FindConfigstringIndex (name, CS_SOUNDS, MAX_SOUNDS, qtrue);
}
int G_TricStringIndex( char *name ) {
return G_FindConfigstringIndex (name, CS_TRIC_STRINGS, MAX_TRIC_STRINGS, qtrue);
}
//=====================================================================
/*
================
G_TeamCommand
Broadcasts a command to only a specific team
================
*/
void G_TeamCommand( team_t team, char *cmd ) {
int i;
for ( i = 0 ; i < level.maxclients ; i++ ) {
if ( level.clients[i].pers.connected == CON_CONNECTED ) {
if ( level.clients[i].sess.sessionTeam == team ) {
trap_SendServerCommand( i, va("%s", cmd ));
}
}
}
}
/*
=============
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 entity after from, or the beginning if NULL
NULL will be returned if the end of the list is reached.
=============
*/
gentity_t *G_Find (gentity_t *from, int fieldofs, const char *match)
{
char *s;
if (!from)
from = g_entities;
else
from++;
for ( ; from < &g_entities[level.num_entities] ; from++)
{
if (!from->inuse)
continue;
s = *(char **) ((byte *)from + fieldofs);
if (!s)
continue;
if (!Q_stricmp (s, match))
return from;
}
return NULL;
}
/*
=============
G_PickTarget
Selects a random entity from among the targets
=============
*/
#define MAXCHOICES 32
gentity_t *G_PickTarget (char *targetname)
{
gentity_t *ent = NULL;
int num_choices = 0;
gentity_t *choice[MAXCHOICES];
if (!targetname)
{
G_Printf("G_PickTarget called with NULL targetname\n");
return NULL;
}
//BOOKMARK
while(1)
{
ent = G_Find (ent, FOFS(targetname), targetname);
if (!ent)
break;
choice[num_choices++] = ent;
if (num_choices == MAXCHOICES)
break;
}
/*================
RPG-X Modification
Phenix
13/06/2004
================*/
if (!num_choices)
{
while(1)
{
ent = G_Find (ent, FOFS(swapname), targetname);
if (!ent)
break;
choice[num_choices++] = ent;
if (num_choices == MAXCHOICES)
break;
}
}
if (!num_choices)
{
while(1)
{
ent = G_Find (ent, FOFS(truename), targetname);
if (!ent)
break;
choice[num_choices++] = ent;
if (num_choices == MAXCHOICES)
break;
}
}
if (!num_choices)
{
while(1)
{
ent = G_Find (ent, FOFS(falsename), targetname);
if (!ent)
break;
choice[num_choices++] = ent;
if (num_choices == MAXCHOICES)
break;
}
}
/*================
End Modification
================*/
if (!num_choices)
{
G_Printf("G_PickTarget: target %s not found\n", targetname);
return NULL;
}
return choice[rand() % num_choices];
}
/*
==============================
G_PickEntity
Locates an entity
==============================
*/
//gentity_t *G_PickEntity ( char* className, int fieldofs, const char *match )
/*
==============================
G_UseTargets
"activator" should be set to the entity that initiated the firing.
Search for (string)targetname in all entities that
match (string)self.target and call their .use function
==============================
*/
void G_UseTargets2( gentity_t *ent, gentity_t *activator, char *target ) {
gentity_t *t;
if ( !ent ) {
return;
}
#ifdef XTRA
if (ent->targetShaderName && ent->targetShaderNewName) {
float f = level.time * 0.001;
AddRemap(ent->targetShaderName, ent->targetShaderNewName, f);
trap_SetConfigstring(CS_SHADERSTATE, BuildShaderStateConfig());
}
#endif
if ( !target ) {
return;
}
t = NULL;
while ( (t = G_Find (t, FOFS(targetname), target)) != NULL ) {
if ( t == ent ) {
G_Printf (va("WARNING: Entity %i used itself.\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
} else {
if ( t->use ) {
t->use (t, ent, activator);
#ifdef G_LUA
if(t->luaUse)
{
if(activator)
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, activator->s.number);
}
else
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, ENTITYNUM_WORLD);
}
}
#endif
}
}
if ( !ent->inuse ) {
G_Printf(va("Entity %i was removed while using targets\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
return;
}
}
/*================
RPG-X Modification
Phenix
13/06/2004
================*/
t = NULL;
while ( (t = G_Find (t, FOFS(swapname), target)) != NULL ) {
if ( t == ent ) {
G_Printf (va("WARNING: Entity %i used itself.\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
} else {
if ( t->use ) {
t->use (t, ent, activator);
#ifdef G_LUA
if(t->luaUse)
{
if(activator)
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, activator->s.number);
}
else
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, ENTITYNUM_WORLD);
}
}
#endif
}
}
if ( !ent->inuse ) {
G_Printf(va("Entity %i was removed while using targets\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
return;
}
}
t = NULL;
while ( (t = G_Find (t, FOFS(truename), target)) != NULL ) {
if ( t == ent ) {
G_Printf (va("WARNING: Entity %i used itself.\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
} else {
if ( t->use ) {
t->use (t, ent, activator);
#ifdef G_LUA
if(t->luaUse)
{
if(activator)
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, activator->s.number);
}
else
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, ENTITYNUM_WORLD);
}
}
#endif
}
}
if ( !ent->inuse ) {
G_Printf(va("Entity %i was removed while using targets\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
return;
}
}
t = NULL;
while ( (t = G_Find (t, FOFS(falsename), target)) != NULL ) {
if ( t == ent ) {
G_Printf (va("WARNING: Entity %i used itself.\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
} else {
if ( t->use ) {
t->use (t, ent, activator);
#ifdef G_LUA
if(t->luaUse)
{
if(activator)
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, activator->s.number);
}
else
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, ENTITYNUM_WORLD);
}
}
#endif
}
}
if ( !ent->inuse ) {
G_Printf(va("Entity %i was removed while using targets\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
return;
}
}
/*================
End Modification
================*/
//RPG-X | GSIO01 | 11/05/2009 | MOD START
// target_alert
t = NULL;
while( (t = G_Find(t, FOFS(bluename), target)) != NULL ) {
if ( t == ent ) {
G_Printf (va("WARNING: Entity %i used itself.\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
} else {
if ( t->use ) {
t->use (t, ent, ent);
#ifdef G_LUA
if(t->luaUse)
{
if(activator)
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, activator->s.number);
}
else
{
LuaHook_G_EntityUse(t->luaUse, t->s.number, ent->s.number, ENTITYNUM_WORLD);
}
}
#endif
}
}
if ( !ent->inuse ) {
G_Printf(va("Entity %i was removed while using targets\n", t->s.number)); //RPG-X | GSIO01 | 22.10.09: a little bit more information for the mapper
return;
}
}
}
/*
==============================
G_UseTargets
"activator" should be set to the entity that initiated the firing.
Search for (string)targetname in all entities that
match (string)self.target and call their .use function
==============================
*/
void G_UseTargets( gentity_t *ent, gentity_t *activator ) {
if ( !ent ) {
return;
}
G_UseTargets2( ent, activator, ent->target );
}
/*
=============
TempVector
This is just a convenience function
for making temporary vectors for function calls
=============
*/
float *tv( float x, float y, float z ) {
static int index;
static vec3_t vecs[8];
float *v;
// use an array so that multiple tempvectors won't collide
// for a while
v = vecs[index];
index = (index + 1)&7;
v[0] = x;
v[1] = y;
v[2] = z;
return v;
}
/*
=============
VectorToString
This is just a convenience function
for printing vectors
=============
*/
char *vtos( const 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;
}
/*
===============
G_SetMovedir
The editor only specifies a single value for angles (yaw),
but we have special constants to generate an up or down direction.
Angles will be cleared, because it is being used to represent a direction
instead of an orientation.
===============
*/
void G_SetMovedir( vec3_t angles, vec3_t movedir ) {
static vec3_t VEC_UP = {0, -1, 0};
static vec3_t MOVEDIR_UP = {0, 0, 1};
static vec3_t VEC_DOWN = {0, -2, 0};
static vec3_t MOVEDIR_DOWN = {0, 0, -1};
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( const vec3_t vec ) {
float yaw;
if (vec[YAW] == 0 && vec[PITCH] == 0) {
yaw = 0;
} else {
if (vec[PITCH]) {
yaw = ( atan2( vec[YAW], vec[PITCH]) * 180 / M_PI );
} else if (vec[YAW] > 0) {
yaw = 90;
} else {
yaw = 270;
}
if (yaw < 0) {
yaw += 360;
}
}
return yaw;
}
void G_InitGentity( gentity_t *e ) {
e->inuse = qtrue;
e->classname = "noclass";
e->s.number = e - g_entities;
e->r.ownerNum = ENTITYNUM_NONE;
}
/*
=================
G_Spawn
Either finds a free entity, or allocates a new one.
The slots from 0 to MAX_CLIENTS-1 are always reserved for clients, and will
never be used by anything else.
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.
=================
*/
gentity_t *G_Spawn( void ) {
int i, force;
gentity_t *e;
//RPG-X: RedTechie - Get rid of tripmines first
gentity_t *tripwire = NULL;
int foundTripWires[MAX_GENTITIES] = {ENTITYNUM_NONE};
int tripcount = 0;
e = NULL; // shut up warning
i = 0; // shut up warning
for ( force = 0 ; force < 2 ; force++ ) {
// if we go through all entities and can't find one to free,
// override the normal minimum times before use
e = &g_entities[MAX_CLIENTS];
for ( i = MAX_CLIENTS ; i<level.num_entities ; i++, e++) {
if ( e->inuse ) {
continue;
}
// the first couple seconds of server time can involve a lot of
// freeing and allocating, so relax the replacement policy
if ( !force && e->freetime > level.startTime + 2000 && level.time - e->freetime < 1000 ) {
continue;
}
// reuse this slot
G_InitGentity( e );
return e;
}
if ( i != ENTITYNUM_MAX_NORMAL ) {
break;
}
}
//RPG-X: RedTechie DEBUG: SHOW HOW MANY ENT's WE HAVE LEFT
//trap_SendServerCommand( -1, va("print \"^1DEBUG: current:%i total:%i\n\"", i, ENTITYNUM_MAX_NORMAL));
if ( i == ENTITYNUM_MAX_NORMAL ) {
//RPG-X: RedTechie - Do some rpg-x house cleaning before we decalre the server dead
while ( (tripwire = G_Find( tripwire, FOFS(classname), "tripwire" )) != NULL )
{
foundTripWires[tripcount++] = tripwire->s.number;
}
if(tripcount != 0){
for ( i = 0; i < tripcount; i++ )
{
//remove it... or blow it?
if ( &g_entities[foundTripWires[i]] != NULL )
{
G_FreeEntity( &g_entities[foundTripWires[i]] );
foundTripWires[i] = ENTITYNUM_NONE;
}
}
G_LogPrintf("RPG-X WARNING: Max entities hit! Removed all tripmines. Restart the server ASAP or suffer a server crash!\n");
trap_SendServerCommand( -1, va("print \"^1RPG-X WARNING: Max entities hit! Removed all tripmines. Restart the server ASAP or suffer a server crash!\n\"", i, ENTITYNUM_MAX_NORMAL));
if ( i == ENTITYNUM_MAX_NORMAL ) {
G_Error( "G_Spawn: no free entities" );
}
}else{
G_Error( "G_Spawn: no free entities" );
}
}
//RPG-X: RedTechie - Update global entity count
RPGEntityCount = i;
// open up a new slot
level.num_entities++;
// let the server system know that there are more entities
trap_LocateGameData( level.gentities, level.num_entities, sizeof( gentity_t ),
&level.clients[0].ps, sizeof( level.clients[0] ) );
G_InitGentity( e );
return e;
}
/*
=================
G_FreeEntity
Marks the entity as free
=================
*/
void G_FreeEntity( gentity_t *ed ) {
trap_UnlinkEntity (ed); // unlink from world
if ( ed->neverFree ) {
return;
}
#ifdef G_LUA
// Lua API callbacks
if(ed->luaFree && !ed->client)
{
LuaHook_G_EntityFree(ed->luaFree, ed->s.number);
}
#endif
memset (ed, 0, sizeof(*ed));
ed->classname = "freed";
ed->freetime = level.time;
ed->inuse = qfalse;
}
/*
=================
G_TempEntity
Spawns an event entity that will be auto-removed
The origin will be snapped to save net bandwidth, so care
must be taken if the origin is right on a surface (snap towards start vector first)
=================
*/
gentity_t *G_TempEntity( vec3_t origin, int event ) {
gentity_t *e;
vec3_t snapped;
e = G_Spawn();
e->s.eType = ET_EVENTS + event;
e->classname = "tempEntity";
e->eventTime = level.time;
e->freeAfterEvent = qtrue;
VectorCopy( origin, snapped );
SnapVector( snapped ); // save network bandwidth
G_SetOrigin( e, snapped );
// find cluster for PVS
trap_LinkEntity( e );
return e;
}
/*
==============================================================================
Kill box
==============================================================================
*/
/*
=================
G_KillBox
Kills all entities that would touch the proposed new positioning
of ent. Ent should be unlinked before calling this!
=================
*/
void G_KillBox (gentity_t *ent) {
int i, num;
int touch[MAX_GENTITIES];
gentity_t *hit;
vec3_t mins, maxs;
VectorAdd( ent->client->ps.origin, ent->r.mins, mins );
VectorAdd( ent->client->ps.origin, ent->r.maxs, maxs );
num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
for (i=0 ; i<num ; i++) {
hit = &g_entities[touch[i]];
if ( !hit->client ) {
continue;
}
// nail it
G_Damage ( hit, ent, ent, NULL, NULL,
100000, DAMAGE_NO_PROTECTION, MOD_TELEFRAG);
}
}
//RPG-X: J2J - Basically just copied above function excpt will accelerate players instead of killing them.
qboolean G_MoveBox (gentity_t *ent )
{
int i, num;
int touch[MAX_GENTITIES];
gentity_t *hit;
vec3_t mins, maxs;
vec3_t dir;
qboolean movedPlayer = qfalse;
VectorAdd( ent->client->ps.origin, ent->r.mins, mins );
VectorAdd( ent->client->ps.origin, ent->r.maxs, maxs );
num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
for (i=0 ; i<num ; i++)
{
hit = &g_entities[touch[i]];
if ( !hit->client || hit->client->ps.clientNum == ent->client->ps.clientNum )
{
continue;
}
VectorSet( dir, 0, hit->client->ps.viewangles[YAW], 0 );
AngleVectors( dir, hit->client->ps.velocity, NULL, NULL );
VectorScale( hit->client->ps.velocity, -150, hit->client->ps.velocity );
hit->client->ps.pm_time = 160; // hold time
hit->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
movedPlayer = qtrue;
}
return movedPlayer;
}
//==============================================================================
/*
===============
G_AddPredictableEvent
Use for non-pmove events that would also be predicted on the
client side: jumppads and item pickups
Adds an event+parm and twiddles the event counter
===============
*/
void G_AddPredictableEvent( gentity_t *ent, int event, int eventParm ) {
if ( !ent->client ) {
return;
}
BG_AddPredictableEventToPlayerstate( event, eventParm, &ent->client->ps );
}
/*
===============
G_AddEvent
Adds an event+parm and twiddles the event counter
===============
*/
void G_AddEvent( gentity_t *ent, int event, int eventParm ) {
int bits;
playerState_t *ps = &ent->client->ps;
if ( !event ) {
G_Printf( "G_AddEvent: zero event added for entity %i\n", ent->s.number );
return;
}
// clients need to add the event in playerState_t instead of entityState_t
if ( ent->client ) {
bits = ps->externalEvent & EV_EVENT_BITS;
bits = ( bits + EV_EVENT_BIT1 ) & EV_EVENT_BITS;
ps->externalEvent = event | bits;
ps->externalEventParm = eventParm;
ps->externalEventTime = level.time;
} else {
bits = ent->s.event & EV_EVENT_BITS;
bits = ( bits + EV_EVENT_BIT1 ) & EV_EVENT_BITS;
ent->s.event = event | bits;
ent->s.eventParm = eventParm;
}
ent->eventTime = level.time;
}
/*
=============
G_Sound
=============
*/
void G_Sound( gentity_t *ent, int soundIndex ) {
gentity_t *te;
te = G_TempEntity( ent->r.currentOrigin, EV_GENERAL_SOUND );
te->s.eventParm = soundIndex;
}
//==============================================================================
/*
================
G_SetOrigin
Sets the pos trajectory for a fixed position
================
*/
void G_SetOrigin( gentity_t *ent, vec3_t origin ) {
VectorCopy( origin, ent->s.pos.trBase );
ent->s.pos.trType = TR_STATIONARY;
ent->s.pos.trTime = 0;
ent->s.pos.trDuration = 0;
VectorClear( ent->s.pos.trDelta );
VectorCopy( origin, ent->r.currentOrigin );
VectorCopy( origin, ent->s.origin); // RPG-X | GSIO01 | 24.08.2009
}
/*
================
G_SetOrigin
Sets the pos trajectory for a fixed angular position
RPG-X | GSIO01 | 24.08.2009
================
*/
void G_SetAngles(gentity_t *ent, vec3_t angles) {
VectorCopy(angles, ent->s.apos.trBase);
ent->s.apos.trType = TR_STATIONARY;
ent->s.apos.trTime = 0;
ent->s.apos.trDuration = 0;
VectorClear(ent->s.apos.trDelta);
VectorCopy(angles, ent->r.currentAngles);
VectorCopy(angles, ent->s.angles);
}
/*
============
G_RadiusList - given an origin and a radius, return all entities that are in use that are within the list
============
*/
int G_RadiusList ( vec3_t origin, float radius, gentity_t *ignore, qboolean takeDamage, gentity_t *ent_list[MAX_GENTITIES])
{
float dist;
gentity_t *ent;
int entityList[MAX_GENTITIES];
int numListedEntities;
vec3_t mins, maxs;
vec3_t v;
int i, e;
int ent_count = 0;
if ( radius < 1 )
{
radius = 1;
}
for ( i = 0 ; i < 3 ; i++ )
{
mins[i] = origin[i] - radius;
maxs[i] = origin[i] + radius;
}
numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
for ( e = 0 ; e < numListedEntities ; e++ )
{
ent = &g_entities[entityList[e]];
if ((ent == ignore) || !(ent->inuse) || ent->takedamage != takeDamage)
continue;
// find the distance from the edge of the bounding box
for ( i = 0 ; i < 3 ; i++ )
{
if ( origin[i] < ent->r.absmin[i] )
{
v[i] = ent->r.absmin[i] - origin[i];
} else if ( origin[i] > ent->r.absmax[i] )
{
v[i] = origin[i] - ent->r.absmax[i];
} else
{
v[i] = 0;
}
}
dist = VectorLength( v );
if ( dist >= radius )
{
continue;
}
// ok, we are within the radius, add us to the incoming list
ent_list[ent_count] = ent;
ent_count++;
}
// we are done, return how many we found
return(ent_count);
}
/*
============
G_GetNearestEnt - Find the nearest entity
============
*/
gentity_t *G_GetNearestEnt(char *classname, vec3_t origin, float radius, gentity_t *ignore, qboolean takeDamage) {
gentity_t *entList[MAX_GENTITIES], *nearest = NULL;
int count, i;
float distance, minDist;
vec3_t dist;
if(!radius) // we don't care how far it is away
radius = 9999999;
minDist = radius;
count = G_RadiusList(origin, radius, ignore, takeDamage, entList);
for(i = 0; i < count; i++) {
if(entList[i] != ignore) {
if(entList[i]->s.origin[0] || entList[i]->s.origin[1] || entList[i]->s.origin[2])
VectorSubtract(origin, entList[i]->s.origin, dist);
else if(entList[i]->r.currentOrigin[0] || entList[i]->r.currentOrigin[1] || entList[i]->r.currentOrigin[2])
VectorSubtract(origin, entList[i]->r.currentOrigin, dist);
else if(entList[i]->s.pos.trBase[0] || entList[i]->s.pos.trBase[1] || entList[i]->s.pos.trBase[2])
VectorSubtract(origin, entList[i]->s.pos.trBase, dist);
else // wow none of above ... well then assume it's origin is 0 0 0
VectorCopy(origin, dist);
distance = VectorLength(dist);
if(distance < 0)
distance *= -1;
if(distance < minDist) {
if(classname && !Q_stricmp(classname, entList[i]->classname)) {
minDist = distance;
nearest = entList[i];
} else if(!classname) {
minDist = distance;
nearest = entList[i];
}
}
}
}
return nearest;
}
/*
============
G_GetNearestPlayer - Find the nearest player
============
*/
gentity_t *G_GetNearestPlayer(vec3_t origin, float radius, gentity_t *ignore ) {
gentity_t *entList[MAX_GENTITIES], *nearest = NULL;
int count, i;
float distance, minDist;
vec3_t dist;
if(!radius)
radius = 999999;
minDist = radius;
count = G_RadiusList(origin, radius, ignore, qtrue, entList);
for(i = 0; i < MAX_CLIENTS; i++) {
if(entList[i]->client) {
VectorSubtract(origin, entList[i]->r.currentOrigin, dist);
distance = VectorLength(dist);
if(distance < 0)
distance *= -1;
if(distance < minDist) {
minDist = distance;
nearest = entList[i];
}
}
}
return nearest;
}
/*
============
G_GetEntityByTargetname - get all entities with specified targetname
============
*/
int G_GetEntityByTargetname(const char *targetname, gentity_t *entities[MAX_GENTITIES]) {
int i;
int cnt = 0;
gentity_t *t;
for(i = MAX_GENTITIES - 1; i > -1; i--) {
if(!&g_entities[i]) continue;
t = &g_entities[i];
if(t->targetname && !Q_strncmp(t->targetname, targetname, strlen(targetname))) {
entities[cnt] = t;
cnt++;
}
}
return cnt;
}
/*
============
G_GetEntityByTarget - get all entities with specified target
============
*/
int G_GetEntityByTarget(const char *target, gentity_t *entities[MAX_GENTITIES]) {
int i;
int cnt = 0;
gentity_t *t;
for(i = MAX_GENTITIES - 1; i > -1; i--) {
if(!&g_entities[i]) continue;
t = &g_entities[i];
if(t->target && !Q_strncmp(t->target, target, strlen(target))) {
entities[cnt] = t;
cnt++;
}
}
return cnt;
}
/*
============
G_GetEntityByTarget - get all entities with specified target
============
*/
int G_GetEntityByBmodel(char *bmodel, gentity_t *entities[MAX_GENTITIES]) {
int i;
int cnt = 0;
gentity_t *t;
for(i = MAX_GENTITIES - 1; i > -1; i--) {
if(!&g_entities[i]) continue;
t = &g_entities[i];
if(t->model && !Q_strncmp(t->model, bmodel, strlen(bmodel))) {
entities[cnt] = t;
cnt++;
}
}
return cnt;
}
/*====================*\
|| RPG-X Modification ||
|| ||
|| Phenix - 2/8/2004 ||
\*====================*/
/**
* Checks if the line of sight between two entities is blocked.
*
* /author Ubergames - Phenix
* /date 2/8/2004
*/
qboolean LineOfSight( gentity_t *ent1, gentity_t *ent2 ) {
trace_t trace;
trap_Trace (&trace, ent1->s.pos.trBase, NULL, NULL, ent2->s.pos.trBase, ent1->s.number, MASK_SHOT );
if ( trace.contents & CONTENTS_SOLID ) {
return qfalse;
}
return qtrue;
}
/*=================*\
|| End Moficiation ||
\*=================*/
Reference in a new issue Copy permalink