/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gedict_t * ent )
{
const spawn_t *s;
// gitem_t *item;
if ( !ent->s.v.classname )
{
G_dprintf( "G_CallSpawn: NULL classname\n" );
return false;
}
/* // check item spawn functions
for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
if ( !strcmp(item->classname, ent->classname) ) {
G_SpawnItem( ent, item );
return qtrue;
}
}*/
// check normal spawn functions
for ( s = spawns; s->name; s++ )
{
if ( !strcmp( s->name, ent->s.v.classname ) )
{
// found it
self = ent;
//G_Printf("%8i %s\n",ent->s.v.classname,ent->s.v.classname);
s->spawn();
return true;
}
}
G_dprintf( "%s doesn't have a spawn function\n", ent->s.v.classname );
return false;
}
void SP_misc_explobox2( )
{
float oldz;
if ( !CheckExistence( ) )
{
dremove( self );
return;
}
self->s.v.solid = SOLID_BBOX;
self->s.v.movetype = MOVETYPE_NONE;
trap_precache_model( "maps/b_exbox2.bsp" );
setmodel( self, "maps/b_exbox2.bsp" );
setsize( self, 0, 0, 0, 32, 32, 32 );
trap_precache_sound( "weapons/r_exp3.wav" );
self->s.v.health = 20;
self->th_die = barrel_explode;
self->s.v.takedamage = DAMAGE_AIM;
self->s.v.origin[2] += 2;
oldz = self->s.v.origin[2];
droptofloor( self );
if ( oldz - self->s.v.origin[2] > 250 )
{
G_dprintf( "item fell out of level at '%f %f %f'\n", PASSVEC3( self->s.v.origin ) );
ent_remove( self );
}
}
void G_InitGame( int levelTime, int randomSeed )
{
int i;
/* int num;
char dirlist[1024];
char* dirptr;
int dirlen;*/
//Common Initialization
srand( randomSeed );
framecount = 0;
starttime = levelTime * 0.001;
G_dprintf( "Init Game\n" );
//G_InitMemory();
memset( g_edicts, 0, sizeof( gedict_t ) * MAX_EDICTS );
world->s.v.model = worldmodel;
g_globalvars.mapname = mapname;
for ( i = 0; i < MAX_CLIENTS; i++ )
{
g_edicts[i + 1].s.v.netname = netnames[i]; //Init client names
}
//TF Intialization
memset( &tf_data, 0, sizeof(tf_data));
memset( &tg_data, 0, sizeof(tg_data));
localcmd("serverinfo status Standby\n");
//test
/* num = trap_FS_GetFileList( "SKINS" , ".pcx" , dirlist, sizeof(dirlist));
dirptr=dirlist;
for (i = 0; i < num; i++, dirptr += dirlen+1) {
dirlen = strlen(dirptr);
G_Printf("%s\n",dirptr);
}*/
}
void *alloca( size_t size )
{
static void *alloca_strips[_ALLOCA_RINGSIZE] = { 0, };
static int snum = 0;
void *p;
if ( size < 0 )
{
/* Hack: reset alloca allocations */
//printf("alloca: reset hack\n");
for ( snum = 0; snum < _ALLOCA_RINGSIZE; snum++ )
{
free( alloca_strips[snum] );
alloca_strips[snum] = 0;
}
snum = 0;
return 0;
}
if ( alloca_strips[snum] )
{
free( alloca_strips[snum] );
alloca_strips[snum] = 0;
}
p = malloc( size );
if ( p == 0 )
{
G_dprintf( "FATAL: malloc out of memory\n" );
}
alloca_strips[snum] = p;
snum = ( snum + 1 ) % _ALLOCA_RINGSIZE;
return p;
}
void Engineer_RemoveBuildings( gedict_t * eng )
{
DestroyBuilding( eng, "building_dispenser" );
DestroyBuilding( eng, "building_sentrygun" );
#ifdef HAS_SENTRY_CHECK
if( eng->has_sentry)
{
G_dprintf("Warning Engineer_RemoveBuildings: eng->has_sentry == %d\n",eng->has_sentry);
eng->has_sentry = 0;
}
#endif
}
////////////////
// GlobalParams:
// time
// self
// other=world
///////////////
void G_EdictThink()
{
self = PROG_TO_EDICT( g_globalvars.self );
other = PROG_TO_EDICT( g_globalvars.other );
if ( self->s.v.think )
{
( ( void ( * )() ) ( self->s.v.think ) ) ();
} else
{
G_dprintf( "Null think func" );
}
}
//=========================================================================
// Ammo/Weapon exploded by the EMP grenade
void EMPExplode( )
{
float expsize;
expsize = 10;
if ( self->s.v.touch == ( func_t ) weapon_touch )
expsize = 60;
else
{
if ( streq( self->s.v.classname, "item_shells" ) )
expsize = 50 + self->aflag;
else
{
if ( streq( self->s.v.classname, "item_spikes" ) )
expsize = 40;
else
{
if ( streq( self->s.v.classname, "item_rockets" ) )
expsize = 100 + self->aflag * 4;
else
{
if ( streq( self->s.v.classname, "item_cells" ) )
expsize = 100 + self->aflag * 3;
else
{
if ( streq( self->s.v.classname, "item_weapon" ) )
expsize = 60;
else
{
G_dprintf( "EMPExplode: Attempting to explode a %s\n", self->s.v.classname );
return;
}
}
}
}
}
}
tf_data.deathmsg = DMSG_GREN_EMP_AMMO;
T_RadiusDamage( self, PROG_TO_EDICT( self->s.v.enemy ), expsize, world );
trap_WriteByte( MSG_MULTICAST, SVC_TEMPENTITY );
trap_WriteByte( MSG_MULTICAST, TE_EXPLOSION );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[0] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[1] );
trap_WriteCoord( MSG_MULTICAST, self->s.v.origin[2] );
trap_multicast( PASSVEC3( self->s.v.origin ), 1 );
// Respawn
Respawn_Item( self, PROG_TO_EDICT( self->s.v.enemy ) );
}
////////////////
// GlobalParams:
// time
// self=pusher
// other=check
// if the pusher has a "blocked" function, call it
// otherwise, just stay in place until the obstacle is gone
///////////////
void G_EdictBlocked()
{
self = PROG_TO_EDICT( g_globalvars.self );
other = PROG_TO_EDICT( g_globalvars.other );
if ( self->s.v.blocked )
{
( ( void ( * )() ) ( self->s.v.blocked ) ) ();
} else
{
#ifdef PARANOID
G_dprintf("Null blocked func");
#endif
}
}
//===========================================================================
// Physics
//
//===========================================================================
////////////////
// GlobalParams:
// time
// self
// other
///////////////
void G_EdictTouch()
{
self = PROG_TO_EDICT( g_globalvars.self );
other = PROG_TO_EDICT( g_globalvars.other );
if ( self->s.v.touch )
{
/*#ifdef DEBUG
if(self->s.v.classname && other->s.v.classname)
if(!strcmp(self->s.v.classname,"player")||!strcmp(other->s.v.classname,"player"))
G_dprintf( "touch %s <-> %s\n", self->s.v.classname,other->s.v.classname);
#endif*/
( ( void ( * )() ) ( self->s.v.touch ) ) ();
} else
{
G_dprintf( "Null touch func" );
}
}
/*
===============
G_ParseField
Takes a key/value pair and sets the binary values
in a gentity
===============
*/
void G_ParseField( const char *key, const char *value, gedict_t * ent )
{
const field_t *f;
byte *b;
float v;
vec3_t vec;
for ( f = fields; f->name; f++ )
{
if ( !Q_stricmp( f->name, key ) )
{
// found it
b = ( byte * ) ent;
switch ( f->type )
{
case F_LSTRING:
*( char ** ) ( b + f->ofs ) = G_NewString( value );
break;
case F_VECTOR:
sscanf( value, "%f %f %f", &vec[0], &vec[1], &vec[2] );
( ( float * ) ( b + f->ofs ) )[0] = vec[0];
( ( float * ) ( b + f->ofs ) )[1] = vec[1];
( ( float * ) ( b + f->ofs ) )[2] = vec[2];
break;
case F_INT:
*( int * ) ( b + f->ofs ) = atoi( value );
break;
case F_FLOAT:
*( float * ) ( b + f->ofs ) = atof( value );
break;
case F_ANGLEHACK:
v = atof( value );
( ( float * ) ( b + f->ofs ) )[0] = 0;
( ( float * ) ( b + f->ofs ) )[1] = v;
( ( float * ) ( b + f->ofs ) )[2] = 0;
break;
default:
case F_IGNORE:
break;
}
return;
}
}
G_dprintf( "unknown field: %s\n", key );
}
static void malloc_init( )
{
if ( ( ( int * ) arena )[0] == MALLOC_MAGIC )
return; /* Already initialized. */
{
int divider;
memset( arena, 0, sizeof(arena) );
divider = PAGESIZE + sizeof( *_arena_metadata );
_arena_pages = MALLOC_ARENA / divider;
_arena_metadata = ( int * ) arena;
_arena_data = ( unsigned char * ) ( _arena_metadata + _arena_pages );
( ( int * ) arena )[0] = MALLOC_MAGIC;
}
G_dprintf( "malloc_init: %d pages of %d bytes. Metadata @ %08X, heap @ %08X\n",
_arena_pages, PAGESIZE, _arena_metadata, _arena_data );
}
void free( void *ptr )
{
int n;
malloc_init( );
// n = 0;
n = ( ( unsigned char * ) ptr - _arena_data ) / PAGESIZE;
if ( ( n < 0 ) || ( n > _arena_pages ) )
{
/* Outside heap. Bad. */
G_dprintf("free: ptr Outside heap.\n");
return;
}
_arena_freestart = n; /* Next allocation tries here, to see if it fits. */
while ( _arena_metadata[n] == ( int ) ptr )
{
_arena_metadata[n] = 0;
n++;
}
return;
}
static int findspot( int pages )
{
int i, j;
malloc_init( );
//printf("findspot: for %d pages\n", pages);
// for (i = 1; i < (_arena_pages - pages); i++)
if ( _arena_freestart >= ( _arena_pages - pages ) )
_arena_freestart = 1;
//printf("findspot: for %d pages starting @ %d\n", pages, _arena_freestart);
for ( i = _arena_freestart; i < ( _arena_pages - pages ); i++ )
{
if ( _arena_metadata[i] == 0 )
{
for ( j = 0; j < pages; j++ )
{
if ( _arena_metadata[i + j] != 0 )
break;
}
if ( j < pages ) /* loop ended because of insufficient free pages. */
{
i += j; /* Skip the blocks we know we can't use. */
continue; /* with for i = ... */
}
for ( j = 0; j < pages; j++ )
{
_arena_metadata[i + j] =
( int ) ( _arena_data + ( i * PAGESIZE ) );
}
//printf("findspot: returning page %d (x %d) @ %08X\n", i, pages, (_arena_data + (i * PAGESIZE)));
_arena_freestart = i;
return i;
}
}
G_dprintf( "FATAL: findspot: Heap exhausted\n" );
return 0;
}
void Sentry_Die( )
{
G_sprint( self->real_owner, 2, "Your sentry gun was destroyed.\n" );
if ( self->has_sentry && tfset(tg_enabled) )
{
self->s.v.health = 0;
setmodel( self, "" );
setmodel( self->trigger_field, "" );
self->s.v.think = ( func_t ) SG_Static;
self->s.v.nextthink = g_globalvars.time + 0.5;
self->s.v.effects = self->s.v.effects - ( (int)self->s.v.effects & 8 );
self->s.v.movetype = MOVETYPE_NONE;
self->s.v.solid = SOLID_NOT;
self->trigger_field->s.v.movetype = MOVETYPE_NONE;
self->trigger_field->s.v.solid = SOLID_NOT;
ThrowGib( "progs/tgib1.mdl", -70 );
ThrowGib( "progs/tgib2.mdl", -70 );
ThrowGib( "progs/tgib3.mdl", -70 );
tf_data.deathmsg = DMSG_SG_EXPLODION;
T_RadiusDamage( self, self->real_owner, 75 + self->s.v.ammo_rockets * 8, self );
TempEffectCoord( self->s.v.origin , TE_EXPLOSION );
} else
{
self->real_owner->has_sentry -= 1;
#ifdef HAS_SENTRY_CHECK
if(!tfset(tg_enabled) && self->real_owner->has_sentry)
{
G_dprintf("Error SentryDie owner->has_sentry !=0 %d\n",self->real_owner->has_sentry);
G_sprint(self->real_owner,2,"Error SentryDie owner->has_sentry !=0 %d\n",self->real_owner->has_sentry);
self->real_owner->has_sentry = 0;
}
#endif
self->s.v.think = ( func_t ) Sentry_Explode;
self->s.v.nextthink = g_globalvars.time + 0.1;
}
}
