/**
* @brief Finds the spawn function for the entity and calls it.
*/
static _Bool G_SpawnEntity(g_entity_t *ent) {
if (!ent->class_name) {
gi.Debug("NULL classname\n");
return false;
}
// check item spawn functions
for (int32_t i = 0; i < g_num_items; i++) {
const g_item_t *item = G_ItemByIndex(i);
if (!item->class_name) {
continue;
}
if (!g_strcmp0(item->class_name, ent->class_name)) { // found it
G_SpawnItem(ent, item);
return true;
}
}
// check normal spawn functions
for (g_entity_spawn_t *s = g_entity_spawns; s->name; s++) {
if (!g_strcmp0(s->name, ent->class_name)) { // found it
s->Spawn(ent);
return true;
}
}
gi.Warn("%s doesn't have a spawn function\n", ent->class_name);
return false;
}
void SP_gametype_item ( gentity_t* ent )
{
gitem_t *item = NULL;
char *value;
int team = -1;
G_SpawnString("teamfilter", "", &value);
G_SetOrigin( ent, ent->s.origin );
// If a team filter is set then override any team settings for the spawns
if ( level.mTeamFilter[0] )
{
if ( Q_stricmp ( level.mTeamFilter, "red") == 0 )
{
team = TEAM_RED;
}
else if ( Q_stricmp ( level.mTeamFilter, "blue") == 0 )
{
team = TEAM_BLUE;
}
}
if (ent->targetname && ent->targetname[0])
{
if (team != -1)
{
if (strstr(ent->targetname, "flag"))
{
if (team == TEAM_RED)
{
item = BG_FindItem("team_CTF_redflag");
}
else
{ //blue
item = BG_FindItem("team_CTF_blueflag");
}
}
}
else if (strstr(ent->targetname, "red_flag"))
{
item = BG_FindItem("team_CTF_redflag");
}
else if (strstr(ent->targetname, "blue_flag"))
{
item = BG_FindItem("team_CTF_blueflag");
}
else
{
item = NULL;
}
if (item)
{
ent->targetname = NULL;
ent->classname = item->classname;
G_SpawnItem( ent, item );
}
}
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// 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->classname) ) {
// found it
if (ent->healingsound && ent->healingsound[0])
{ //yeah...this can be used for anything, so.. precache it if it's there
G_SoundIndex(ent->healingsound);
}
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
/*
* @brief Finds the spawn function for the entity and calls it.
*/
static void G_SpawnEntity(g_edict_t *ent) {
spawn_t *s;
int32_t i;
if (!ent->class_name) {
gi.Debug("NULL classname\n");
return;
}
// check item spawn functions
const g_item_t *item = g_items;
for (i = 0; i < g_num_items; i++, item++) {
if (!item->class_name)
continue;
if (!g_strcmp0(item->class_name, ent->class_name)) { // found it
G_SpawnItem(ent, item);
return;
}
}
// check normal spawn functions
for (s = g_spawns; s->name; s++) {
if (!g_strcmp0(s->name, ent->class_name)) { // found it
s->spawn(ent);
return;
}
}
gi.Debug("%s doesn't have a spawn function\n", ent->class_name);
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn(gentity_t *ent)
{
spawn_t *s;
gitem_t *item;
if (!ent->classname)
{
G_Printf("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for (item = bg_itemlist + 1 ; item->classname ; item++)
{
if (!strcmp(item->classname, ent->classname))
{
// found it
if (g_gametype.integer != GT_WOLF_LMS) // lets not have items in last man standing for the moment
{
G_SpawnItem(ent, item);
G_Script_ScriptParse(ent);
G_Script_ScriptEvent(ent, "spawn", "");
}
else
{
return qfalse;
}
return qtrue;
}
}
// check normal spawn functions
for (s = spawns ; s->name ; s++)
{
if (!strcmp(s->name, ent->classname))
{
// found it
s->spawn(ent);
// entity scripting
if (/*ent->s.number >= MAX_CLIENTS &&*/ ent->scriptName)
{
G_Script_ScriptParse(ent);
G_Script_ScriptEvent(ent, "spawn", "");
}
return qtrue;
}
}
// hack: this avoids spammy prints on start, bsp uses obsolete classnames!
// bot_sniper_spot (railgun)
if (Q_stricmp(ent->classname, "bot_sniper_spot"))
{
G_Printf("%s doesn't have a spawn function\n", ent->classname);
}
return qfalse;
}
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf( "G_CallSpawn: NULL classname\n" );
return qfalse;
}
// check item spawn functions
//TODO: cant reorder items because compat so....?
for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
if ( !strcmp(item->classname, ent->classname) ) {
G_SpawnItem( ent, item );
return qtrue;
}
}
// check normal spawn functions
s = (spawn_t *)bsearch( ent->classname, spawns, ARRAY_LEN( spawns ), sizeof( spawn_t ), spawncmp );
if ( s )
{// found it
if ( VALIDSTRING( ent->healingsound ) )
G_SoundIndex( ent->healingsound );
s->spawn( ent );
return qtrue;
}
G_Printf( "%s doesn't have a spawn function\n", ent->classname );
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qbool G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for(item=&bg_itemlist[1]; ITEM_INDEX(item) < IT_NUM_ITEMS; item++){
if ( !strcmp(item->classname, ent->classname) ) {
if(g_gametype.integer != GT_BR && !Q_stricmp(item->classname, "item_money"))
return qfalse;
if(g_gametype.integer >= GT_RTP && !Q_stricmp(item->classname, "pickup_money"))
return qfalse;
G_SpawnItem( ent, item );
return qtrue;
}
}
// check normal spawn functions
for ( s=spawns ; s->name ; s++ ) {
if ( !strcmp(s->name, ent->classname) ) {
// found it
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// 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->classname) ) {
// found it
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
int i;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for ( i = 1; i < BG_NumItems(); i++ ) {
item = BG_ItemForItemNum( i );
if ( !item->classname || !*item->classname ) {
continue;
}
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->classname) ) {
// found it
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
static gentity_t* G_RealSpawnGametypeItem ( gentity_t* ent, bool dropped )
{
gentity_t* it_ent;
it_ent = G_Spawn();
it_ent->flags |= FL_DROPPED_ITEM;
it_ent->item = ent->item;
VectorCopy( ent->r.currentOrigin, it_ent->s.origin );
VectorCopy ( ent->s.angles, it_ent->s.apos.trBase );
it_ent->classname = ent->item->classname;
G_SpawnItem ( it_ent, it_ent->item );
FinishSpawningItem(it_ent);
VectorSet( it_ent->r.mins, -ITEM_RADIUS * 4 / 3, -ITEM_RADIUS * 4 / 3, -ITEM_RADIUS );
VectorSet( it_ent->r.maxs, ITEM_RADIUS * 4 / 3, ITEM_RADIUS * 4 / 3, ITEM_RADIUS );
// Red team only
if ( ent->s.eFlags & EF_REDTEAM )
{
it_ent->s.eFlags |= EF_REDTEAM;
}
if ( ent->s.eFlags & EF_BLUETEAM )
{
it_ent->s.eFlags |= EF_BLUETEAM;
}
return it_ent;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
int hash;
if ( !ent->classname ) {
G_Printf( "G_CallSpawn: NULL classname\n" );
return qfalse;
}
if ( g_deathmatch.integer ) {
if ( !strcmp( "func_explosive", ent->classname ) ) {
return qfalse;
}
if ( !strcmp( "trigger_hurt", ent->classname ) ) {
return qfalse;
}
// don't spawn the flags in cp
if ( g_gametype.integer == 7 && !strcmp( "team_WOLF_checkpoint", ent->classname ) ) {
return qfalse;
}
}
// check item spawn functions
for ( item = bg_itemlist + 1 ; item->classname ; item++ ) {
if ( !strcmp( item->classname, ent->classname ) ) {
// found it
// DHM - Nerve :: allow flags in GTWOLF
if ( item->giType == IT_TEAM && ( g_gametype.integer != GT_CTF && g_gametype.integer < GT_WOLF ) ) {
return qfalse;
}
G_SpawnItem( ent, item );
return qtrue;
}
}
// check normal spawn functions
hash = BG_StringHashValue( ent->classname );
for ( s = spawns ; s->name ; s++ ) {
if ( s->hash == hash ) {
// found it
s->spawn( ent );
// RF, entity scripting
if ( ent->s.number >= MAX_CLIENTS && ent->scriptName ) {
G_Script_ScriptParse( ent );
G_Script_ScriptEvent( ent, "spawn", "" );
}
return qtrue;
}
}
G_Printf( "%s doesn't have a spawn function\n", ent->classname );
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn(gentity_t * ent)
{
spawn_t *s;
gitem_t *item;
if(!ent->classname)
{
G_Printf("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for(item = bg_itemlist + 1; item->classname; item++)
{
if(!strcmp(item->classname, ent->classname))
{
// found it
if(g_gametype.integer != GT_WOLF_LMS)
{ // Gordon: lets not have items in last man standing for the moment
G_SpawnItem(ent, item);
G_Script_ScriptParse(ent);
G_Script_ScriptEvent(ent, "spawn", "");
}
else
{
return qfalse;
}
return qtrue;
}
}
// check normal spawn functions
for(s = spawns; s->name; s++)
{
if(!strcmp(s->name, ent->classname))
{
// found it
s->spawn(ent);
// RF, entity scripting
if( /*ent->s.number >= MAX_CLIENTS && */ ent->scriptName)
{
G_Script_ScriptParse(ent);
G_Script_ScriptEvent(ent, "spawn", "");
}
return qtrue;
}
}
G_Printf("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
/**
* @brief Actually does the magic
*/
static void G_weapon_chaingun_Think(g_entity_t *ent) {
g_entity_t *cg = NULL;
while ((cg = G_Find(cg, EOFS(class_name), "weapon_chaingun"))) {
// spawn a lightning gun where we are
g_entity_t *lg = G_AllocEntity_(g_media.items.weapons[WEAPON_LIGHTNING]->class_name);
VectorCopy(cg->s.origin, lg->s.origin);
VectorCopy(cg->s.angles, lg->s.angles);
lg->locals.spawn_flags = cg->locals.spawn_flags;
G_SpawnItem(lg, g_media.items.weapons[WEAPON_LIGHTNING]);
// replace nearby bullets with bolts
g_entity_t *ammo = NULL;
while ((ammo = G_FindRadius(ammo, lg->s.origin, 128.0))) {
if (ammo->locals.item && ammo->locals.item == g_media.items.ammo[AMMO_BULLETS]) {
// hello bolts
g_entity_t *bolts = G_AllocEntity_(g_media.items.ammo[AMMO_BOLTS]->class_name);
VectorCopy(ammo->s.origin, bolts->s.origin);
VectorCopy(ammo->s.angles, bolts->s.angles);
bolts->locals.spawn_flags = ammo->locals.spawn_flags;
G_SpawnItem(bolts, g_media.items.ammo[AMMO_BOLTS]);
// byebye bullets
G_FreeEntity(ammo);
}
}
// byebye chaingun
G_FreeEntity(cg);
}
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
int i;
qboolean normalSpawn = qtrue;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
if ( g_mutators.integer & MT_MACHINEGUNONLY ) {
if ( strstr(ent->classname, "weapon_") ) {
ent->classname = "weapon_machinegun";
} else if ( strstr(ent->classname, "ammo_") ) {
ent->classname = "ammo_bullets";
}
}
if ( g_mutators.integer & MT_INSTAGIB ) {
if ( strstr(ent->classname, "weapon_") ) {
ent->classname = "weapon_railgun";
} else if ( strstr(ent->classname, "ammo_") && (ent->target || ent->target2) ) {
ent->classname = "ammo_slugs";
} else if ( strstr(ent->classname, "ammo_") ) {
return qtrue; //ammo box has no target/target2 so it isn't spawned
}
}
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->classname) ) {
// found it
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname )
{
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for ( item=bg_itemlist+1 ; item->classname ; item++ )
{
if ( !strcmp(item->classname, ent->classname) )
{ // found it
if( item->giType == IT_TEAM && g_gametype.integer != GT_CTF )
{
return qfalse;
}
G_SpawnItem( ent, item );
#ifdef G_LUA
if(ent->luaSpawn)
{
LuaHook_G_EntitySpawn(ent->luaSpawn, ent->s.number);
}
#endif
return qtrue;
}
}
// check normal spawn functions
for ( s=spawns ; s->name ; s++ )
{
if ( !strcmp(s->name, ent->classname) )
{
// found it
s->spawn(ent);
return qtrue;
}
}
if ( Q_stricmp( "item_botroam", ent->classname ) != 0 )
{ //suppress error message about botroams as those are actually valid
DEVELOPER(G_Printf (S_COLOR_RED "%s doesn't have a spawn function\n", ent->classname););
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
char cvarname[128];
char itemname[128];
//Construct a replace cvar:
Com_sprintf(cvarname, sizeof(cvarname), "replace_%s", ent->classname);
//Look an alternative item up:
trap_Cvar_VariableStringBuffer(cvarname,itemname,sizeof(itemname));
if(itemname[0]==0) //If nothing found use original
Com_sprintf(itemname, sizeof(itemname), "%s", ent->classname);
else
G_Printf ("%s replaced by %s\n", ent->classname, itemname);
if ( itemname[0]==0) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
if ( !strcmp(item->classname, itemname) ) {
G_SpawnItem( ent, item );
return qtrue;
}
}
// check normal spawn functions
for ( s=spawns ; s->name ; s++ ) {
if ( !strcmp(s->name, itemname) ) {
// found it
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", itemname);
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf( "G_CallSpawn: NULL classname\n" );
return qfalse;
}
// check item spawn functions
for ( item = bg_itemlist + 1 ; item->classname ; item++ ) {
if ( !strcmp( item->classname, ent->classname ) ) {
// found it
// DHM - Nerve :: allow flags in GTWOLF
if ( item->giType == IT_TEAM && ( g_gametype.integer != GT_CTF && g_gametype.integer < GT_WOLF ) ) {
return qfalse;
}
G_SpawnItem( ent, item );
return qtrue;
}
}
// check normal spawn functions
for ( s = spawns ; s->name ; s++ ) {
if ( !strcmp( s->name, ent->classname ) ) {
// found it
s->spawn( ent );
// RF, entity scripting
if ( ent->s.number >= MAX_CLIENTS && ent->scriptName ) {
G_Script_ScriptParse( ent );
G_Script_ScriptEvent( ent, "spawn", "" );
}
return qtrue;
}
}
G_Printf( "%s doesn't have a spawn function\n", ent->classname );
return qfalse;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn(gentity_t *ent) {
spawn_t *s;
gitem_t *item;
if (!ent->classname) {
G_DPrintf("G_CallSpawn: NULL classname\n");
return qfalse;
}
// check item spawn functions
for (item = bg_itemlist + 1 ; item->classname ; ++item) {
if (!strcmp(item->classname, ent->classname)) {
// found it
G_SpawnItem(ent, item);
G_Script_ScriptParse(ent);
G_Script_ScriptEvent(ent, "spawn", "");
return qtrue;
}
}
// check normal spawn functions
for (s = spawns ; s->name ; ++s) {
if (!strcmp(s->name, ent->classname)) {
// found it
s->spawn(ent);
// RF, entity scripting
if (ent->scriptName) {
G_Script_ScriptParse(ent);
G_Script_ScriptEvent(ent, "spawn", "");
}
return qtrue;
}
}
G_DPrintf("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
/*
* G_SpawnEntity
*
* Finds the spawn function for the entity and calls it.
*/
static void G_SpawnEntity(g_edict_t *ent) {
spawn_t *s;
g_item_t *item;
g_override_t *over;
int i;
if (!ent->class_name) {
gi.Debug("G_SpawnEntity: NULL classname\n");
return;
}
// check overrides
for (i = 0; i < g_game.num_overrides; i++) {
over = &g_overrides[i];
if (!strcmp(ent->class_name, over->old)) { // found it
item = G_FindItemByClassname(over->new);
G_SpawnItem(ent, item);
return;
}
}
// Finds the spawn function for the entity and calls it, returning qfalse if not found
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
const gitem_t *item;
char buf[MAX_STRING_CHARS] = { 0 };
if ( !ent->classname ) {
trap->Print( "G_CallSpawn: NULL classname\n" );
return qfalse;
}
// swap this entity out for something else
trap->Cvar_VariableStringBuffer( va( "replace_%s", ent->classname ), buf, sizeof(buf) );
if ( buf[0] )
ent->classname = G_NewString( buf );
// check item spawn functions
//RAZTODO: cant reorder items because compat so....?
for ( item = bg_itemlist + 1; item->classname; item++ ) {
if ( !strcmp( item->classname, ent->classname ) ) {
G_SpawnItem( ent, item );
return qtrue;
}
}
// check normal spawn functions
s = (spawn_t *)bsearch( ent->classname, spawns, ARRAY_LEN( spawns ), sizeof(spawn_t), spawncmp );
if ( s ) {// found it
if ( VALIDSTRING( ent->healingsound ) )
G_SoundIndex( ent->healingsound );
s->spawn( ent );
return qtrue;
}
trap->Print( "%s doesn't have a spawn function\n", ent->classname );
return qfalse;
}
gentity_t *G_DropSaberItem( const char *saberType, saber_colors_t saberColor, vec3_t saberPos, vec3_t saberVel, vec3_t saberAngles, gentity_t *copySaber )
{//turn it into a pick-uppable item!
gentity_t *newItem = NULL;
if ( saberType
&& saberType[0] )
{//have a valid string to use for saberType
newItem = G_Spawn();
if ( newItem )
{
newItem->classname = G_NewString( "weapon_saber" );
VectorCopy( saberPos, newItem->s.origin );
G_SetOrigin( newItem, newItem->s.origin );
VectorCopy( saberAngles, newItem->s.angles );
G_SetAngles( newItem, newItem->s.angles );
newItem->spawnflags = 128;/*ITMSF_USEPICKUP*/
newItem->spawnflags |= 64;/*ITMSF_NOGLOW*/
newItem->NPC_type = G_NewString( saberType );//saberType
//FIXME: transfer per-blade color somehow?
newItem->NPC_targetname = (char *)saberColorStringForColor[saberColor];
newItem->count = 1;
newItem->flags = FL_DROPPED_ITEM;
G_SpawnItem( newItem, FindItemForWeapon( WP_SABER ) );
newItem->s.pos.trType = TR_GRAVITY;
newItem->s.pos.trTime = level.time;
VectorCopy( saberVel, newItem->s.pos.trDelta );
//newItem->s.eFlags |= EF_BOUNCE_HALF;
//copy some values from another saber, if provided:
G_CopySaberItemValues( copySaber, newItem );
//don't *think* about calling FinishSpawningItem, just do it!
newItem->e_ThinkFunc = thinkF_NULL;
newItem->nextthink = -1;
FinishSpawningItem( newItem );
newItem->delay = level.time + 500;//so you can't pick it back up right away
}
}
return newItem;
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning false if not found
===============
*/
bool G_CallSpawn( gentity_t *ent )
{
spawn_t *s;
gitem_t *item;
if ( !ent->classname )
{
Com_Printf ("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) )
{
// If this is a backpack then handle it specially
if ( item->giType == IT_BACKPACK )
{
if ( !level.gametypeData->backpack )
{
return false;
}
G_SpawnItem ( ent, item );
return true;
}
// Make sure pickups arent disabled
if ( !level.pickupsDisabled )
{
G_SpawnItem( ent, item );
return true;
}
else
{ // Pickups dont spawn when disabled - this avoids the "doesn't have a spawn function" message
return false;
}
}
}
// check normal spawn functions
for ( s=spawns ; s->name ; s++ )
{
char* wildcard = strchr ( s->name, '*' );
int result;
if ( wildcard )
{
result = strncmp ( s->name, ent->classname, wildcard - s->name );
}
else
{
result = strcmp(s->name, ent->classname);
}
if ( !result )
{
if (s->spawn)
{ // found it
s->spawn(ent);
return true;
}
else
{
return false;
}
}
}
Com_Printf ("%s doesn't have a spawn function\n", ent->classname);
return false;
}
/*
==================
Cmd_Give_f
Give items to a client
==================
*/
void Cmd_Give_f (gentity_t *ent)
{
char *name;
gitem_t *it;
int i;
qboolean give_all;
gentity_t *it_ent;
trace_t trace;
if ( !CheatsOk( ent ) ) {
return;
}
name = ConcatArgs( 1 );
if (Q_stricmp(name, "all") == 0)
give_all = qtrue;
else
give_all = qfalse;
if (give_all || Q_stricmp(name, "force") == 0)
{
if ( ent->client )
{
ent->client->ps.forcePower = FORCE_POWER_MAX;
}
if (!give_all)
return;
}
if (give_all || Q_stricmp(gi.argv(1), "health") == 0)
{
if (gi.argc() == 3) {
ent->health = atoi(gi.argv(2));
if (ent->health > ent->client->ps.stats[STAT_MAX_HEALTH]) {
ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
}
}
else {
ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
}
if (!give_all)
return;
}
if (give_all || Q_stricmp(name, "inventory") == 0)
{
// Huh? Was doing a INV_MAX+1 which was wrong because then you'd actually have every inventory item including INV_MAX
ent->client->ps.stats[STAT_ITEMS] = (1 << (INV_MAX)) - ( 1 << INV_ELECTROBINOCULARS );
ent->client->ps.inventory[INV_ELECTROBINOCULARS] = 1;
ent->client->ps.inventory[INV_BACTA_CANISTER] = 5;
ent->client->ps.inventory[INV_SEEKER] = 5;
ent->client->ps.inventory[INV_LIGHTAMP_GOGGLES] = 1;
ent->client->ps.inventory[INV_SENTRY] = 5;
ent->client->ps.inventory[INV_GOODIE_KEY] = 5;
ent->client->ps.inventory[INV_SECURITY_KEY] = 5;
if (!give_all)
{
return;
}
}
if (give_all || Q_stricmp(name, "weapons") == 0)
{
ent->client->ps.stats[STAT_WEAPONS] = (1 << (MAX_PLAYER_WEAPONS+1)) - ( 1 << WP_NONE );
// ent->client->ps.stats[STAT_WEAPONS] |= (1 << (WP_MELEE));
if (!give_all)
return;
}
if ( !give_all && Q_stricmp(gi.argv(1), "weaponnum") == 0 )
{
ent->client->ps.stats[STAT_WEAPONS] |= (1 << atoi(gi.argv(2)));
return;
}
if ( Q_stricmp(name, "eweaps") == 0) //for developing, gives you all the weapons, including enemy
{
ent->client->ps.stats[STAT_WEAPONS] = (unsigned)(1 << WP_NUM_WEAPONS) - ( 1 << WP_NONE ); // NOTE: this wasn't giving the last weapon in the list
if (!give_all)
return;
}
if (give_all || Q_stricmp(name, "ammo") == 0)
{
for ( i = 0 ; i < AMMO_MAX ; i++ ) {
ent->client->ps.ammo[i] = ammoData[i].max;
}
if (!give_all)
return;
}
if (give_all || Q_stricmp(gi.argv(1), "batteries") == 0)
{
if (gi.argc() == 3)
ent->client->ps.batteryCharge = atoi(gi.argv(2));
else
ent->client->ps.batteryCharge = MAX_BATTERIES;
if (!give_all)
return;
}
if (give_all || Q_stricmp(gi.argv(1), "armor") == 0)
{
if (gi.argc() == 3)
ent->client->ps.stats[STAT_ARMOR] = atoi(gi.argv(2));
else
ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
if ( ent->client->ps.stats[STAT_ARMOR] > 0 )
{
ent->client->ps.powerups[PW_BATTLESUIT] = Q3_INFINITE;
}
else
{
ent->client->ps.powerups[PW_BATTLESUIT] = 0;
}
if (!give_all)
return;
}
// spawn a specific item right on the player
if ( !give_all ) {
it = FindItem (name);
if (!it) {
name = gi.argv(1);
it = FindItem (name);
if (!it) {
gi.SendServerCommand( ent-g_entities, "print \"unknown item\n\"");
return;
}
}
it_ent = G_Spawn();
VectorCopy( ent->currentOrigin, it_ent->s.origin );
it_ent->classname = it->classname;
G_SpawnItem (it_ent, it);
FinishSpawningItem(it_ent );
memset( &trace, 0, sizeof( trace ) );
Touch_Item (it_ent, ent, &trace);
if (it_ent->inuse) {
G_FreeEntity( it_ent );
}
}
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
// oatmeal begin
// Ammo spawning
if(om_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_bfg")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_slugs")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_rockets")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_lightning")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_cells")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_grenades")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_bullets")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_shells")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_belt")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_nails")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "ammo_mines")==0){
return qfalse;
}
}
// Individual Weapon Ammo Spawning
if(om_rocket_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_rocket")==0){
return qfalse;
}
}
if(om_grenade_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_grenades")==0){
return qfalse;
}
}
if(om_plasma_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_cells")==0){
return qfalse;
}
}
if(om_shotgun_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_shells")==0){
return qfalse;
}
}
if(om_bfg_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_bfg")==0){
return qfalse;
}
}
if(om_railgun_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_slugs")==0){
return qfalse;
}
}
if(om_machinegun_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_bullets")==0){
return qfalse;
}
}
if(om_chaingun_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_belt")==0){
return qfalse;
}
}
if(om_lightning_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_lightning")==0){
return qfalse;
}
}
if(om_nailgun_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_nails")==0){
return qfalse;
}
}
if(om_proxmine_spawn_ammo.integer==0){
if(Q_stricmp(ent->classname, "ammo_mines")==0){
return qfalse;
}
}
// Health spawning
if(om_spawn_health.integer==0){
if(Q_stricmp(ent->classname, "item_health_small")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_health")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_health_large")==0){
return qfalse;
}
}
// Armor spawning
if(om_spawn_armor.integer==0){
if(Q_stricmp(ent->classname, "item_armor_shard")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_armor_combat")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_armor_body")==0){
return qfalse;
}
}
// Weapon spawning
if(om_spawn_weapons.integer==0){
if(Q_stricmp(ent->classname, "weapon_gauntlet")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_shotgun")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_machinegun")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_grenadelauncher")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_rocketlauncher")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_lightning")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_railgun")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_plasmagun")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "weapon_bfg")==0){
return qfalse;
}
}
// Individual Weapon Spawning
if(om_lightning_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_lightning")==0){
return qfalse;
}
}
if(om_chaingun_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_chaingun")==0){
return qfalse;
}
}
if(om_proxmine_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_prox_launcher")==0){
return qfalse;
}
}
if(om_rocket_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_rocketlauncher")==0){
return qfalse;
}
}
if(om_bfg_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_bfg")==0){
return qfalse;
}
}
if(om_plasma_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_plasmagun")==0){
return qfalse;
}
}
if(om_grenade_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_grenadelauncher")==0){
return qfalse;
}
}
if(om_machinegun_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_machinegun")==0){
return qfalse;
}
}
if(om_shotgun_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_shotgun")==0){
return qfalse;
}
}
if(om_railgun_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_railgun")==0){
return qfalse;
}
}
if(om_nailgun_spawn_weapon.integer==0){
if(Q_stricmp(ent->classname, "weapon_nailgun")==0){
return qfalse;
}
}
// Powerup spawning
if(om_spawn_powerups.integer==0){
if(Q_stricmp(ent->classname, "item_quad")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_enviro")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_haste")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_invis")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_regen")==0){
return qfalse;
}
if(Q_stricmp(ent->classname, "item_flight")==0){
return qfalse;
}
}
// oatmeal end
// 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->classname) ) {
// found it
s->spawn(ent);
return qtrue;
}
}
G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
static void Cmd_Spawn_f (gentity_t *ent)
{
gentity_t *s;
gitem_t *item;
vec3_t origin;
vec3_t forward;
char name[MAX_STRING_CHARS];
char valBuffer[128];
float f;
trace_t trace;
if (!g_cheats.integer) {
trap_SendServerCommand(ent-g_entities, va("print \"Cheats are not enabled on this server.\n\""));
return;
}
if (trap_Argc() < 2) {
trap_SendServerCommand(ent-g_entities, "print \"usage: spawn <item classname> [forward amount]\n\"");
return;
}
if (trap_Argc() > 2) {
trap_Argv(2, valBuffer, sizeof(valBuffer));
f = atof(valBuffer);
} else {
f = 100;
}
trap_Argv(1, name, sizeof(name));
s = G_Spawn();
AngleVectors(ent->s.apos.trBase, forward, NULL, NULL);
VectorNormalize(forward);
VectorCopy(ent->s.pos.trBase, origin);
VectorMA(origin, f, forward, origin);
memset(&trace, 0, sizeof(trace));
trap_Trace(&trace, ent->s.pos.trBase, NULL, NULL, origin, ent - g_entities, MASK_SOLID);
//VectorCopy(origin, s->s.pos.trBase);
//VectorCopy(origin, s->r.currentOrigin);
//VectorCopy(origin, s->s.origin);
VectorCopy(trace.endpos, s->s.origin);
item = BG_FindItem (name);
if (item) {
s->classname = item->classname;
G_SpawnItem(s, item);
FinishSpawningItem(s);
return;
}
#if 0
// check item spawn functions
for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
//if ( !strcmp(item->classname, name) ) {
s->classname = item->classname;
G_SpawnItem(s, item);
FinishSpawningItem(s);
//memset( &trace, 0, sizeof( trace ) );
//Touch_Item (it_ent, ent, &trace);
//if (it_ent->inuse) {
// G_FreeEntity( it_ent );
//}
return;
}
}
void G_Give( gentity_t *ent, const char *name, const char *args, int argc )
{
gitem_t *it;
int i;
qboolean give_all = qfalse;
if ( !Q_stricmp( name, "all" ) )
give_all = qtrue;
if ( give_all || !Q_stricmp( name, "health") )
{
if ( argc == 3 )
ent->health = Com_Clampi( 1, ent->client->ps.stats[STAT_MAX_HEALTH], atoi( args ) );
else
ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
if ( !give_all )
return;
}
if ( give_all || !Q_stricmp( name, "armor" ) || !Q_stricmp( name, "shield" ) )
{
if ( argc == 3 )
ent->client->ps.stats[STAT_ARMOR] = Com_Clampi( 0, ent->client->ps.stats[STAT_MAX_HEALTH], atoi( args ) );
else
ent->client->ps.stats[STAT_ARMOR] = ent->client->ps.stats[STAT_MAX_HEALTH];
if ( !give_all )
return;
}
if ( give_all || !Q_stricmp( name, "force" ) )
{
if ( argc == 3 )
ent->client->ps.forcePower = Com_Clampi( 0, FORCE_POWER_MAX, atoi( args ) );
else
ent->client->ps.forcePower = FORCE_POWER_MAX;
if ( !give_all )
return;
}
if ( give_all || !Q_stricmp( name, "weapons" ) )
{
ent->client->ps.stats[STAT_WEAPONS] = (1 << (WP_MELEE)) - ( 1 << WP_NONE );
if ( !give_all )
return;
}
if ( !give_all && !Q_stricmp( name, "weaponnum" ) )
{
ent->client->ps.stats[STAT_WEAPONS] |= (1 << atoi( args ));
return;
}
if ( !give_all && !Q_stricmp( name, "eweaps" ) ) //for developing, gives you all the weapons, including enemy
{
ent->client->ps.stats[STAT_WEAPONS] = (unsigned)(1 << WP_NUM_WEAPONS) - ( 1 << WP_NONE ); // NOTE: this wasn't giving the last weapon in the list
return;
}
if ( give_all || !Q_stricmp( name, "ammo" ) )
{
int num = 999;
if ( argc == 3 )
num = Com_Clampi( 0, 999, atoi( args ) );
for ( i=AMMO_FORCE; i<MAX_AMMO; i++ )
ent->client->ps.ammo[i] = num != -1 ? num : ammoData[i].max;
if ( !give_all )
return;
}
if ( give_all || !Q_stricmp( name, "batteries" ) )
{
if ( argc == 3 )
ent->client->ps.batteryCharge = Com_Clampi( 0, MAX_BATTERIES, atoi( args ) );
else
ent->client->ps.batteryCharge = MAX_BATTERIES;
if (!give_all)
return;
}
// spawn a specific item right on the player
if ( !give_all ) {
gentity_t *it_ent;
trace_t trace;
it = FindItem (args);
if (!it) {
it = FindItem (name);
if (!it) {
gi.SendServerCommand( ent-g_entities, "print \"unknown item\n\"");
return;
}
}
it_ent = G_Spawn();
VectorCopy( ent->currentOrigin, it_ent->s.origin );
it_ent->classname = G_NewString(it->classname);
G_SpawnItem (it_ent, it);
FinishSpawningItem(it_ent );
memset( &trace, 0, sizeof( trace ) );
Touch_Item (it_ent, ent, &trace);
if (it_ent->inuse) {
G_FreeEntity( it_ent );
}
}
}
/*
==================
Cmd_Give_f
Give items to a client
==================
*/
void Cmd_Give_f (gentity_t *ent)
{
char *name;
gitem_t *it;
int i;
qboolean give_all;
gentity_t *it_ent;
trace_t trace;
if ( !CheatsOk( ent ) ) {
return;
}
name = ConcatArgs( 1 );
if (Q_stricmp(name, "all") == 0)
give_all = qtrue;
else
give_all = qfalse;
if (give_all || Q_stricmp( name, "health") == 0)
{
ent->health = ent->client->ps.stats[STAT_MAX_HEALTH];
if (!give_all)
return;
}
if (give_all || Q_stricmp(name, "weapons") == 0)
{
ent->client->ps.stats[STAT_WEAPONS] = (1 << WP_NUM_WEAPONS) - 1 -
( 1 << WP_GRAPPLING_HOOK ) - ( 1 << WP_NONE );
if (!give_all)
return;
}
if (give_all || Q_stricmp(name, "ammo") == 0)
{
for ( i = 0 ; i < MAX_WEAPONS ; i++ ) {
ent->client->ps.ammo[i] = 999;
}
if (!give_all)
return;
}
if (give_all || Q_stricmp(name, "armor") == 0)
{
ent->client->ps.stats[STAT_ARMOR] = 200;
if (!give_all)
return;
}
if (Q_stricmp(name, "excellent") == 0) {
ent->client->ps.persistant[PERS_EXCELLENT_COUNT]++;
return;
}
if (Q_stricmp(name, "impressive") == 0) {
ent->client->ps.persistant[PERS_IMPRESSIVE_COUNT]++;
return;
}
if (Q_stricmp(name, "gauntletaward") == 0) {
ent->client->ps.persistant[PERS_GAUNTLET_FRAG_COUNT]++;
return;
}
if (Q_stricmp(name, "defend") == 0) {
ent->client->ps.persistant[PERS_DEFEND_COUNT]++;
return;
}
if (Q_stricmp(name, "assist") == 0) {
ent->client->ps.persistant[PERS_ASSIST_COUNT]++;
return;
}
// spawn a specific item right on the player
if ( !give_all ) {
it = BG_FindItem (name);
if (!it) {
return;
}
it_ent = G_Spawn();
VectorCopy( ent->r.currentOrigin, it_ent->s.origin );
it_ent->classname = it->classname;
G_SpawnItem (it_ent, it);
FinishSpawningItem(it_ent );
memset( &trace, 0, sizeof( trace ) );
Touch_Item (it_ent, ent, &trace);
if (it_ent->inuse) {
G_FreeEntity( it_ent );
}
}
}
/**
* @brief Creates team spawns if the map doesn't have one. Also creates flags, although
* chances are they will be in crap positions.
*/
static void G_CreateTeamSpawnPoints(GSList **dm_spawns, GSList **team_red_spawns, GSList **team_blue_spawns) {
// find our flags
g_entity_t *red_flag, *blue_flag;
g_entity_t *reused_spawns[2] = { NULL, NULL };
red_flag = g_team_red->flag_entity;
blue_flag = g_team_blue->flag_entity;
if (!!red_flag != !!blue_flag) {
gi.Error("Make sure you have both flags in your map!\n");
} else if (!red_flag) {
// no flag in map, so let's make one by repurposing the furthest spawn points
if (g_slist_length(*dm_spawns) < 4) {
return; // not enough points to make a flag
}
vec_t furthest_dist = 0;
for (GSList *pa = *dm_spawns; pa; pa = pa->next) {
for (GSList *pb = *dm_spawns; pb; pb = pb->next) {
if (pa == pb) {
continue;
}
g_entity_t *pae = (g_entity_t *) pa->data;
g_entity_t *pab = (g_entity_t *) pb->data;
if ((reused_spawns[0] == pae && reused_spawns[1] == pab) ||
(reused_spawns[0] == pab && reused_spawns[1] == pae)) {
continue;
}
vec3_t line;
VectorSubtract(pae->s.origin, pab->s.origin, line);
line[2] /= 10.0; // don't consider Z as heavily as X/Y
const vec_t dist = VectorLengthSquared(line);
if (dist > furthest_dist) {
reused_spawns[0] = pae;
reused_spawns[1] = pab;
furthest_dist = dist;
}
}
}
if (!reused_spawns[0] || !reused_spawns[1] || !furthest_dist) {
return; // error in finding furthest points
}
red_flag = G_AllocEntity_(g_team_red->flag);
blue_flag = G_AllocEntity_(g_team_blue->flag);
const uint8_t r = Randomr(0, 2);
VectorCopy(reused_spawns[r]->s.origin, red_flag->s.origin);
VectorCopy(reused_spawns[r ^ 1]->s.origin, blue_flag->s.origin);
G_SpawnItem(red_flag, g_media.items.flags[TEAM_RED]);
G_SpawnItem(blue_flag, g_media.items.flags[TEAM_BLUE]);
g_team_red->flag_entity = red_flag;
g_team_blue->flag_entity = blue_flag;
}
for (GSList *point = *dm_spawns; point; point = point->next) {
g_entity_t *p = (g_entity_t *) point->data;
if (p == reused_spawns[0] || p == reused_spawns[1]) {
continue;
}
const vec_t dist_to_red = VectorDistanceSquared(red_flag->s.origin, p->s.origin);
const vec_t dist_to_blue = VectorDistanceSquared(blue_flag->s.origin, p->s.origin);
if (dist_to_red < dist_to_blue) {
*team_red_spawns = g_slist_prepend(*team_red_spawns, p);
} else {
*team_blue_spawns = g_slist_prepend(*team_blue_spawns, p);
}
}
if (g_slist_length(*team_red_spawns) == g_slist_length(*team_blue_spawns)) {
return; // best case scenario
}
// unmatched spawns, we need to move some
*team_red_spawns = g_slist_sort_with_data(*team_red_spawns, G_CreateTeamSpawnPoints_CompareFunc, red_flag);
*team_blue_spawns = g_slist_sort_with_data(*team_blue_spawns, G_CreateTeamSpawnPoints_CompareFunc, blue_flag);
int32_t num_red_spawns = (int32_t) g_slist_length(*team_red_spawns);
int32_t num_blue_spawns = (int32_t) g_slist_length(*team_blue_spawns);
int32_t diff = abs(num_red_spawns - num_blue_spawns);
GSList **from, **to;
if (num_red_spawns > num_blue_spawns) {
from = team_red_spawns;
to = team_blue_spawns;
} else {
from = team_blue_spawns;
to = team_red_spawns;
}
// odd number of points, make one neutral
if (diff & 1) {
g_entity_t *point = (g_entity_t *) ((*from)->data);
*to = g_slist_prepend(*to, point);
}
int32_t num_move = diff - 1;
// move spawns to the other team
while (num_move) {
g_entity_t *point = (g_entity_t *) ((*from)->data);
*from = g_slist_remove(*from, point);
*to = g_slist_prepend(*to, point);
num_move--;
}
}
void GunRackAddItem( gitem_t *gun, vec3_t org, vec3_t angs, float ffwd, float fright, float fup )
{
vec3_t fwd, right;
gentity_t *it_ent = G_Spawn();
qboolean rotate = qtrue;
AngleVectors( angs, fwd, right, NULL );
if ( it_ent && gun )
{
// FIXME: scaling the ammo will probably need to be tweaked to a reasonable amount...adjust as needed
// Set base ammo per type
if ( gun->giType == IT_WEAPON )
{
it_ent->spawnflags |= 16;// VERTICAL
switch( gun->giTag )
{
case WP_BLASTER:
it_ent->count = 15;
break;
case WP_REPEATER:
it_ent->count = 100;
break;
case WP_ROCKET_LAUNCHER:
it_ent->count = 4;
break;
}
}
else
{
rotate = qfalse;
// must deliberately make it small, or else the objects will spawn inside of each other.
VectorSet( it_ent->maxs, 6.75f, 6.75f, 6.75f );
VectorScale( it_ent->maxs, -1, it_ent->mins );
}
it_ent->spawnflags |= 1;// ITMSF_SUSPEND
it_ent->classname = G_NewString(gun->classname); //copy it so it can be freed safely
G_SpawnItem( it_ent, gun );
// FinishSpawningItem handles everything, so clear the thinkFunc that was set in G_SpawnItem
FinishSpawningItem( it_ent );
if ( gun->giType == IT_AMMO )
{
if ( gun->giTag == AMMO_BLASTER ) // I guess this just has to use different logic??
{
if ( g_spskill->integer >= 2 )
{
it_ent->count += 10; // give more on higher difficulty because there will be more/harder enemies?
}
}
else
{
// scale ammo based on skill
switch ( g_spskill->integer )
{
case 0: // do default
break;
case 1:
it_ent->count *= 0.75f;
break;
case 2:
it_ent->count *= 0.5f;
break;
}
}
}
it_ent->nextthink = 0;
VectorCopy( org, it_ent->s.origin );
VectorMA( it_ent->s.origin, fright, right, it_ent->s.origin );
VectorMA( it_ent->s.origin, ffwd, fwd, it_ent->s.origin );
it_ent->s.origin[2] += fup;
VectorCopy( angs, it_ent->s.angles );
// by doing this, we can force the amount of ammo we desire onto the weapon for when it gets picked-up
it_ent->flags |= ( FL_DROPPED_ITEM | FL_FORCE_PULLABLE_ONLY );
it_ent->physicsBounce = 0.1f;
for ( int t = 0; t < 3; t++ )
{
if ( rotate )
{
if ( t == YAW )
{
it_ent->s.angles[t] = AngleNormalize180( it_ent->s.angles[t] + 180 + crandom() * 14 );
}
else
{
it_ent->s.angles[t] = AngleNormalize180( it_ent->s.angles[t] + crandom() * 4 );
}
}
else
{
if ( t == YAW )
{
it_ent->s.angles[t] = AngleNormalize180( it_ent->s.angles[t] + 90 + crandom() * 4 );
}
}
}
G_SetAngles( it_ent, it_ent->s.angles );
G_SetOrigin( it_ent, it_ent->s.origin );
gi.linkentity( it_ent );
}
}
/*
===============
G_CallSpawn
Finds the spawn function for the entity and calls it,
returning qfalse if not found
===============
*/
qboolean G_CallSpawn( gentity_t *ent ) {
spawn_t *s;
gitem_t *item;
if ( !ent->classname ) {
G_Printf ("G_CallSpawn: NULL classname\n");
return qfalse;
}
if ( ent->creator != 0 )
{
// This is a makermod ob that might have more than one class
int i;
char* oldname;
qboolean result;
result = qfalse;
oldname = ent->classname;
for ( i = 0 ; i < level.numSpawnVars ; i++ )
{
if ( Q_stricmp(level.spawnVars[i][0], "classname") == 0 )
{
ent->classname = level.spawnVars[i][1];
for ( item=bg_itemlist+1 ; item->classname ; item++ ) {
if ( !strcmp(item->classname, ent->classname) ) {
G_SpawnItem( ent, item );
result = qtrue;
continue;
}
}
// check normal spawn functions
for ( s=spawns ; s->name ; s++ ) {
if ( !strcmp(s->name, ent->classname) ) {
// found it
if (ent->healingsound && ent->healingsound[0])
{ //yeah...this can be used for anything, so.. precache it if it's there
G_SoundIndex(ent->healingsound);
}
s->spawn(ent);
result = qtrue;
continue;
}
}
}
}
ent->classname = oldname;
return result;
}
else
{
// 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->classname) ) {
// found it
if (ent->healingsound && ent->healingsound[0])
{ //yeah...this can be used for anything, so.. precache it if it's there
G_SoundIndex(ent->healingsound);
}
s->spawn(ent);
return qtrue;
}
}
}
//G_Printf ("%s doesn't have a spawn function\n", ent->classname);
return qfalse;
}
