ref: b8c0e4deccffcd668f7d08ffc1fe16147e9e894a
dir: /code/game/g_items.c/
/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
//
#include "g_local.h"
/*
Items are any object that a player can touch to gain some effect.
Pickup will return the number of seconds until they should respawn.
all items should pop when dropped in lava or slime
Respawnable items don't actually go away when picked up, they are
just made invisible and untouchable. This allows them to ride
movers and respawn apropriately.
*/
#define RESPAWN_ARMOR 25
#define RESPAWN_HEALTH 35
#define RESPAWN_AMMO 40
#define RESPAWN_HOLDABLE 60
#define RESPAWN_MEGAHEALTH 35//120
#define RESPAWN_POWERUP 120
//======================================================================
int Pickup_Powerup( gentity_t *ent, gentity_t *other ) {
int quantity;
int i;
gclient_t *client;
if ( !other->client->ps.powerups[ent->item->giTag] ) {
// round timing to seconds to make multiple powerup timers
// count in sync
other->client->ps.powerups[ent->item->giTag] =
level.time - ( level.time % 1000 );
}
if ( ent->count ) {
quantity = ent->count;
} else {
quantity = ent->item->quantity;
}
other->client->ps.powerups[ent->item->giTag] += quantity * 1000;
// give any nearby players a "denied" anti-reward
for ( i = 0 ; i < level.maxclients ; i++ ) {
vec3_t delta;
float len;
vec3_t forward;
trace_t tr;
client = &level.clients[i];
if ( client == other->client ) {
continue;
}
if ( client->pers.connected == CON_DISCONNECTED ) {
continue;
}
if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
continue;
}
// if same team in team game, no sound
// cannot use OnSameTeam as it expects to g_entities, not clients
if ( g_gametype.integer >= GT_TEAM && other->client->sess.sessionTeam == client->sess.sessionTeam ) {
continue;
}
// if too far away, no sound
VectorSubtract( ent->s.pos.trBase, client->ps.origin, delta );
len = VectorNormalize( delta );
if ( len > 192 ) {
continue;
}
// if not facing, no sound
AngleVectors( client->ps.viewangles, forward, NULL, NULL );
if ( DotProduct( delta, forward ) < 0.4 ) {
continue;
}
// if not line of sight, no sound
trap_Trace( &tr, client->ps.origin, NULL, NULL, ent->s.pos.trBase, ENTITYNUM_NONE, CONTENTS_SOLID );
if ( tr.fraction != 1.0 ) {
continue;
}
// anti-reward
client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_DENIEDREWARD;
}
return RESPAWN_POWERUP;
}
//======================================================================
#ifdef MISSIONPACK
int Pickup_PersistantPowerup( gentity_t *ent, gentity_t *other ) {
int clientNum;
char userinfo[MAX_INFO_STRING];
float handicap;
int max;
other->client->ps.stats[STAT_PERSISTANT_POWERUP] = ent->item - bg_itemlist;
other->client->persistantPowerup = ent;
switch( ent->item->giTag ) {
case PW_GUARD:
clientNum = other->client->ps.clientNum;
trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
handicap = atof( Info_ValueForKey( userinfo, "handicap" ) );
if( handicap<=0.0f || handicap>100.0f) {
handicap = 100.0f;
}
max = (int)(2 * handicap);
other->health = max;
other->client->ps.stats[STAT_HEALTH] = max;
other->client->ps.stats[STAT_MAX_HEALTH] = max;
other->client->ps.stats[STAT_ARMOR] = max;
other->client->pers.maxHealth = max;
break;
case PW_SCOUT:
clientNum = other->client->ps.clientNum;
trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
handicap = atof( Info_ValueForKey( userinfo, "handicap" ) );
if( handicap<=0.0f || handicap>100.0f) {
handicap = 100.0f;
}
other->client->pers.maxHealth = handicap;
other->client->ps.stats[STAT_ARMOR] = 0;
break;
case PW_DOUBLER:
clientNum = other->client->ps.clientNum;
trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
handicap = atof( Info_ValueForKey( userinfo, "handicap" ) );
if( handicap<=0.0f || handicap>100.0f) {
handicap = 100.0f;
}
other->client->pers.maxHealth = handicap;
break;
case PW_AMMOREGEN:
clientNum = other->client->ps.clientNum;
trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
handicap = atof( Info_ValueForKey( userinfo, "handicap" ) );
if( handicap<=0.0f || handicap>100.0f) {
handicap = 100.0f;
}
other->client->pers.maxHealth = handicap;
memset(other->client->ammoTimes, 0, sizeof(other->client->ammoTimes));
break;
default:
clientNum = other->client->ps.clientNum;
trap_GetUserinfo( clientNum, userinfo, sizeof(userinfo) );
handicap = atof( Info_ValueForKey( userinfo, "handicap" ) );
if( handicap<=0.0f || handicap>100.0f) {
handicap = 100.0f;
}
other->client->pers.maxHealth = handicap;
break;
}
return -1;
}
//======================================================================
#endif
int Pickup_Holdable( gentity_t *ent, gentity_t *other ) {
other->client->ps.stats[STAT_HOLDABLE_ITEM] = ent->item - bg_itemlist;
if( ent->item->giTag == HI_KAMIKAZE ) {
other->client->ps.eFlags |= EF_KAMIKAZE;
}
return RESPAWN_HOLDABLE;
}
//======================================================================
void Add_Ammo (gentity_t *ent, int weapon, int count)
{
ent->client->ps.ammo[weapon] += count;
if ( ent->client->ps.ammo[weapon] > 200 ) {
ent->client->ps.ammo[weapon] = 200;
}
}
int Pickup_Ammo (gentity_t *ent, gentity_t *other)
{
int quantity;
if ( ent->count ) {
quantity = ent->count;
} else {
quantity = ent->item->quantity;
}
Add_Ammo (other, ent->item->giTag, quantity);
return RESPAWN_AMMO;
}
//======================================================================
int Pickup_Weapon (gentity_t *ent, gentity_t *other) {
int quantity;
if ( ent->count < 0 ) {
quantity = 0; // None for you, sir!
} else {
if ( ent->count ) {
quantity = ent->count;
} else {
quantity = ent->item->quantity;
}
// dropped items and teamplay weapons always have full ammo
if ( ! (ent->flags & FL_DROPPED_ITEM) && g_gametype.integer != GT_TEAM ) {
// respawning rules
// drop the quantity if the already have over the minimum
if ( other->client->ps.ammo[ ent->item->giTag ] < quantity ) {
quantity = quantity - other->client->ps.ammo[ ent->item->giTag ];
} else {
quantity = 1; // only add a single shot
}
}
}
// add the weapon
other->client->ps.stats[STAT_WEAPONS] |= ( 1 << ent->item->giTag );
Add_Ammo( other, ent->item->giTag, quantity );
if (ent->item->giTag == WP_GRAPPLING_HOOK)
other->client->ps.ammo[ent->item->giTag] = -1; // unlimited ammo
// team deathmatch has slow weapon respawns
if ( g_gametype.integer == GT_TEAM ) {
return g_weaponTeamRespawn.integer;
}
return g_weaponRespawn.integer;
}
//======================================================================
int Pickup_Health (gentity_t *ent, gentity_t *other) {
int max;
int quantity;
// small and mega healths will go over the max
#ifdef MISSIONPACK
if( other->client && bg_itemlist[other->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
max = other->client->ps.stats[STAT_MAX_HEALTH];
}
else
#endif
if ( ent->item->quantity != 5 && ent->item->quantity != 100 ) {
max = other->client->ps.stats[STAT_MAX_HEALTH];
} else {
max = other->client->ps.stats[STAT_MAX_HEALTH] * 2;
}
if ( ent->count ) {
quantity = ent->count;
} else {
quantity = ent->item->quantity;
}
other->health += quantity;
if (other->health > max ) {
other->health = max;
}
other->client->ps.stats[STAT_HEALTH] = other->health;
if ( ent->item->quantity == 100 ) { // mega health respawns slow
return RESPAWN_MEGAHEALTH;
}
return RESPAWN_HEALTH;
}
//======================================================================
int Pickup_Armor( gentity_t *ent, gentity_t *other ) {
#ifdef MISSIONPACK
int upperBound;
other->client->ps.stats[STAT_ARMOR] += ent->item->quantity;
if( other->client && bg_itemlist[other->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
upperBound = other->client->ps.stats[STAT_MAX_HEALTH];
}
else {
upperBound = other->client->ps.stats[STAT_MAX_HEALTH] * 2;
}
if ( other->client->ps.stats[STAT_ARMOR] > upperBound ) {
other->client->ps.stats[STAT_ARMOR] = upperBound;
}
#else
other->client->ps.stats[STAT_ARMOR] += ent->item->quantity;
if ( other->client->ps.stats[STAT_ARMOR] > other->client->ps.stats[STAT_MAX_HEALTH] * 2 ) {
other->client->ps.stats[STAT_ARMOR] = other->client->ps.stats[STAT_MAX_HEALTH] * 2;
}
#endif
return RESPAWN_ARMOR;
}
//======================================================================
/*
===============
RespawnItem
===============
*/
void RespawnItem( gentity_t *ent ) {
// randomly select from teamed entities
if (ent->team) {
gentity_t *master;
int count;
int choice;
if ( !ent->teammaster ) {
G_Error( "RespawnItem: bad teammaster");
}
master = ent->teammaster;
for (count = 0, ent = master; ent; ent = ent->teamchain, count++)
;
choice = rand() % count;
for (count = 0, ent = master; count < choice; ent = ent->teamchain, count++)
;
}
ent->r.contents = CONTENTS_TRIGGER;
ent->s.eFlags &= ~EF_NODRAW;
ent->r.svFlags &= ~SVF_NOCLIENT;
trap_LinkEntity (ent);
if ( ent->item->giType == IT_POWERUP ) {
// play powerup spawn sound to all clients
gentity_t *te;
// if the powerup respawn sound should Not be global
if (ent->speed) {
te = G_TempEntity( ent->s.pos.trBase, EV_GENERAL_SOUND );
}
else {
te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_SOUND );
}
te->s.eventParm = G_SoundIndex( "sound/items/poweruprespawn.wav" );
te->r.svFlags |= SVF_BROADCAST;
}
if ( ent->item->giType == IT_HOLDABLE && ent->item->giTag == HI_KAMIKAZE ) {
// play powerup spawn sound to all clients
gentity_t *te;
// if the powerup respawn sound should Not be global
if (ent->speed) {
te = G_TempEntity( ent->s.pos.trBase, EV_GENERAL_SOUND );
}
else {
te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_SOUND );
}
te->s.eventParm = G_SoundIndex( "sound/items/kamikazerespawn.wav" );
te->r.svFlags |= SVF_BROADCAST;
}
// play the normal respawn sound only to nearby clients
G_AddEvent( ent, EV_ITEM_RESPAWN, 0 );
ent->nextthink = 0;
}
/*
===============
Touch_Item
===============
*/
void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace) {
int respawn;
qboolean predict;
if (!other->client)
return;
if (other->health < 1)
return; // dead people can't pickup
// the same pickup rules are used for client side and server side
if ( !BG_CanItemBeGrabbed( g_gametype.integer, &ent->s, &other->client->ps ) ) {
return;
}
G_LogPrintf( "Item: %i %s\n", other->s.number, ent->item->classname );
predict = other->client->pers.predictItemPickup;
// call the item-specific pickup function
switch( ent->item->giType ) {
case IT_WEAPON:
respawn = Pickup_Weapon(ent, other);
// predict = qfalse;
break;
case IT_AMMO:
respawn = Pickup_Ammo(ent, other);
// predict = qfalse;
break;
case IT_ARMOR:
respawn = Pickup_Armor(ent, other);
break;
case IT_HEALTH:
respawn = Pickup_Health(ent, other);
break;
case IT_POWERUP:
respawn = Pickup_Powerup(ent, other);
predict = qfalse;
break;
#ifdef MISSIONPACK
case IT_PERSISTANT_POWERUP:
respawn = Pickup_PersistantPowerup(ent, other);
break;
#endif
case IT_TEAM:
respawn = Pickup_Team(ent, other);
break;
case IT_HOLDABLE:
respawn = Pickup_Holdable(ent, other);
break;
default:
return;
}
if ( !respawn ) {
return;
}
// play the normal pickup sound
if (predict) {
G_AddPredictableEvent( other, EV_ITEM_PICKUP, ent->s.modelindex );
} else {
G_AddEvent( other, EV_ITEM_PICKUP, ent->s.modelindex );
}
// powerup pickups are global broadcasts
if ( ent->item->giType == IT_POWERUP || ent->item->giType == IT_TEAM) {
// if we want the global sound to play
if (!ent->speed) {
gentity_t *te;
te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
te->s.eventParm = ent->s.modelindex;
te->r.svFlags |= SVF_BROADCAST;
} else {
gentity_t *te;
te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
te->s.eventParm = ent->s.modelindex;
// only send this temp entity to a single client
te->r.svFlags |= SVF_SINGLECLIENT;
te->r.singleClient = other->s.number;
}
}
// fire item targets
G_UseTargets (ent, other);
// wait of -1 will not respawn
if ( ent->wait == -1 ) {
ent->r.svFlags |= SVF_NOCLIENT;
ent->s.eFlags |= EF_NODRAW;
ent->r.contents = 0;
ent->unlinkAfterEvent = qtrue;
return;
}
// non zero wait overrides respawn time
if ( ent->wait ) {
respawn = ent->wait;
}
// random can be used to vary the respawn time
if ( ent->random ) {
respawn += crandom() * ent->random;
if ( respawn < 1 ) {
respawn = 1;
}
}
// dropped items will not respawn
if ( ent->flags & FL_DROPPED_ITEM ) {
ent->freeAfterEvent = qtrue;
}
// picked up items still stay around, they just don't
// draw anything. This allows respawnable items
// to be placed on movers.
ent->r.svFlags |= SVF_NOCLIENT;
ent->s.eFlags |= EF_NODRAW;
ent->r.contents = 0;
// ZOID
// A negative respawn times means to never respawn this item (but don't
// delete it). This is used by items that are respawned by third party
// events such as ctf flags
if ( respawn <= 0 ) {
ent->nextthink = 0;
ent->think = 0;
} else {
ent->nextthink = level.time + respawn * 1000;
ent->think = RespawnItem;
}
trap_LinkEntity( ent );
}
//======================================================================
/*
================
LaunchItem
Spawns an item and tosses it forward
================
*/
gentity_t *LaunchItem( gitem_t *item, vec3_t origin, vec3_t velocity ) {
gentity_t *dropped;
dropped = G_Spawn();
dropped->s.eType = ET_ITEM;
dropped->s.modelindex = item - bg_itemlist; // store item number in modelindex
dropped->s.modelindex2 = 1; // This is non-zero is it's a dropped item
dropped->classname = item->classname;
dropped->item = item;
VectorSet (dropped->r.mins, -ITEM_RADIUS, -ITEM_RADIUS, -ITEM_RADIUS);
VectorSet (dropped->r.maxs, ITEM_RADIUS, ITEM_RADIUS, ITEM_RADIUS);
dropped->r.contents = CONTENTS_TRIGGER;
dropped->touch = Touch_Item;
G_SetOrigin( dropped, origin );
dropped->s.pos.trType = TR_GRAVITY;
dropped->s.pos.trTime = level.time;
VectorCopy( velocity, dropped->s.pos.trDelta );
dropped->s.eFlags |= EF_BOUNCE_HALF;
#ifdef MISSIONPACK
if ((g_gametype.integer == GT_CTF || g_gametype.integer == GT_1FCTF) && item->giType == IT_TEAM) { // Special case for CTF flags
#else
if (g_gametype.integer == GT_CTF && item->giType == IT_TEAM) { // Special case for CTF flags
#endif
dropped->think = Team_DroppedFlagThink;
dropped->nextthink = level.time + 30000;
Team_CheckDroppedItem( dropped );
} else { // auto-remove after 30 seconds
dropped->think = G_FreeEntity;
dropped->nextthink = level.time + 30000;
}
dropped->flags = FL_DROPPED_ITEM;
trap_LinkEntity (dropped);
return dropped;
}
/*
================
Drop_Item
Spawns an item and tosses it forward
================
*/
gentity_t *Drop_Item( gentity_t *ent, gitem_t *item, float angle ) {
vec3_t velocity;
vec3_t angles;
VectorCopy( ent->s.apos.trBase, angles );
angles[YAW] += angle;
angles[PITCH] = 0; // always forward
AngleVectors( angles, velocity, NULL, NULL );
VectorScale( velocity, 150, velocity );
velocity[2] += 200 + crandom() * 50;
return LaunchItem( item, ent->s.pos.trBase, velocity );
}
/*
================
Use_Item
Respawn the item
================
*/
void Use_Item( gentity_t *ent, gentity_t *other, gentity_t *activator ) {
RespawnItem( ent );
}
//======================================================================
/*
================
FinishSpawningItem
Traces down to find where an item should rest, instead of letting them
free fall from their spawn points
================
*/
void FinishSpawningItem( gentity_t *ent ) {
trace_t tr;
vec3_t dest;
VectorSet( ent->r.mins, -ITEM_RADIUS, -ITEM_RADIUS, -ITEM_RADIUS );
VectorSet( ent->r.maxs, ITEM_RADIUS, ITEM_RADIUS, ITEM_RADIUS );
ent->s.eType = ET_ITEM;
ent->s.modelindex = ent->item - bg_itemlist; // store item number in modelindex
ent->s.modelindex2 = 0; // zero indicates this isn't a dropped item
ent->r.contents = CONTENTS_TRIGGER;
ent->touch = Touch_Item;
// useing an item causes it to respawn
ent->use = Use_Item;
if ( ent->spawnflags & 1 ) {
// suspended
G_SetOrigin( ent, ent->s.origin );
} else {
// drop to floor
VectorSet( dest, ent->s.origin[0], ent->s.origin[1], ent->s.origin[2] - 4096 );
trap_Trace( &tr, ent->s.origin, ent->r.mins, ent->r.maxs, dest, ent->s.number, MASK_SOLID );
if ( tr.startsolid ) {
G_Printf ("FinishSpawningItem: %s startsolid at %s\n", ent->classname, vtos(ent->s.origin));
G_FreeEntity( ent );
return;
}
// allow to ride movers
ent->s.groundEntityNum = tr.entityNum;
G_SetOrigin( ent, tr.endpos );
}
// team slaves and targeted items aren't present at start
if ( ( ent->flags & FL_TEAMSLAVE ) || ent->targetname ) {
ent->s.eFlags |= EF_NODRAW;
ent->r.contents = 0;
return;
}
// powerups don't spawn in for a while
if ( ent->item->giType == IT_POWERUP ) {
float respawn;
respawn = 45 + crandom() * 15;
ent->s.eFlags |= EF_NODRAW;
ent->r.contents = 0;
ent->nextthink = level.time + respawn * 1000;
ent->think = RespawnItem;
return;
}
trap_LinkEntity (ent);
}
qboolean itemRegistered[MAX_ITEMS];
/*
==================
G_CheckTeamItems
==================
*/
void G_CheckTeamItems( void ) {
// Set up team stuff
Team_InitGame();
if( g_gametype.integer == GT_CTF ) {
gitem_t *item;
// check for the two flags
item = BG_FindItem( "Red Flag" );
if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_redflag in map" );
}
item = BG_FindItem( "Blue Flag" );
if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_blueflag in map" );
}
}
#ifdef MISSIONPACK
if( g_gametype.integer == GT_1FCTF ) {
gitem_t *item;
// check for all three flags
item = BG_FindItem( "Red Flag" );
if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_redflag in map" );
}
item = BG_FindItem( "Blue Flag" );
if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_blueflag in map" );
}
item = BG_FindItem( "Neutral Flag" );
if ( !item || !itemRegistered[ item - bg_itemlist ] ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_CTF_neutralflag in map" );
}
}
if( g_gametype.integer == GT_OBELISK ) {
gentity_t *ent;
// check for the two obelisks
ent = NULL;
ent = G_Find( ent, FOFS(classname), "team_redobelisk" );
if( !ent ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_redobelisk in map" );
}
ent = NULL;
ent = G_Find( ent, FOFS(classname), "team_blueobelisk" );
if( !ent ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_blueobelisk in map" );
}
}
if( g_gametype.integer == GT_HARVESTER ) {
gentity_t *ent;
// check for all three obelisks
ent = NULL;
ent = G_Find( ent, FOFS(classname), "team_redobelisk" );
if( !ent ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_redobelisk in map" );
}
ent = NULL;
ent = G_Find( ent, FOFS(classname), "team_blueobelisk" );
if( !ent ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_blueobelisk in map" );
}
ent = NULL;
ent = G_Find( ent, FOFS(classname), "team_neutralobelisk" );
if( !ent ) {
G_Printf( S_COLOR_YELLOW "WARNING: No team_neutralobelisk in map" );
}
}
#endif
}
/*
==============
ClearRegisteredItems
==============
*/
void ClearRegisteredItems( void ) {
memset( itemRegistered, 0, sizeof( itemRegistered ) );
// players always start with the base weapon
RegisterItem( BG_FindItemForWeapon( WP_MACHINEGUN ) );
RegisterItem( BG_FindItemForWeapon( WP_GAUNTLET ) );
#ifdef MISSIONPACK
if( g_gametype.integer == GT_HARVESTER ) {
RegisterItem( BG_FindItem( "Red Cube" ) );
RegisterItem( BG_FindItem( "Blue Cube" ) );
}
#endif
}
/*
===============
RegisterItem
The item will be added to the precache list
===============
*/
void RegisterItem( gitem_t *item ) {
if ( !item ) {
G_Error( "RegisterItem: NULL" );
}
itemRegistered[ item - bg_itemlist ] = qtrue;
}
/*
===============
SaveRegisteredItems
Write the needed items to a config string
so the client will know which ones to precache
===============
*/
void SaveRegisteredItems( void ) {
char string[MAX_ITEMS+1];
int i;
int count;
count = 0;
for ( i = 0 ; i < bg_numItems ; i++ ) {
if ( itemRegistered[i] ) {
count++;
string[i] = '1';
} else {
string[i] = '0';
}
}
string[ bg_numItems ] = 0;
G_Printf( "%i items registered\n", count );
trap_SetConfigstring(CS_ITEMS, string);
}
/*
============
G_ItemDisabled
============
*/
int G_ItemDisabled( gitem_t *item ) {
char name[128];
Com_sprintf(name, sizeof(name), "disable_%s", item->classname);
return trap_Cvar_VariableIntegerValue( name );
}
/*
============
G_SpawnItem
Sets the clipping size and plants the object on the floor.
Items can't be immediately dropped to floor, because they might
be on an entity that hasn't spawned yet.
============
*/
void G_SpawnItem (gentity_t *ent, gitem_t *item) {
G_SpawnFloat( "random", "0", &ent->random );
G_SpawnFloat( "wait", "0", &ent->wait );
RegisterItem( item );
if ( G_ItemDisabled(item) )
return;
ent->item = item;
// some movers spawn on the second frame, so delay item
// spawns until the third frame so they can ride trains
ent->nextthink = level.time + FRAMETIME * 2;
ent->think = FinishSpawningItem;
ent->physicsBounce = 0.50; // items are bouncy
if ( item->giType == IT_POWERUP ) {
G_SoundIndex( "sound/items/poweruprespawn.wav" );
G_SpawnFloat( "noglobalsound", "0", &ent->speed);
}
#ifdef MISSIONPACK
if ( item->giType == IT_PERSISTANT_POWERUP ) {
ent->s.generic1 = ent->spawnflags;
}
#endif
}
/*
================
G_BounceItem
================
*/
void G_BounceItem( gentity_t *ent, trace_t *trace ) {
vec3_t velocity;
float dot;
int hitTime;
// reflect the velocity on the trace plane
hitTime = level.previousTime + ( level.time - level.previousTime ) * trace->fraction;
BG_EvaluateTrajectoryDelta( &ent->s.pos, hitTime, velocity );
dot = DotProduct( velocity, trace->plane.normal );
VectorMA( velocity, -2*dot, trace->plane.normal, ent->s.pos.trDelta );
// cut the velocity to keep from bouncing forever
VectorScale( ent->s.pos.trDelta, ent->physicsBounce, ent->s.pos.trDelta );
// check for stop
if ( trace->plane.normal[2] > 0 && ent->s.pos.trDelta[2] < 40 ) {
trace->endpos[2] += 1.0; // make sure it is off ground
SnapVector( trace->endpos );
G_SetOrigin( ent, trace->endpos );
ent->s.groundEntityNum = trace->entityNum;
return;
}
VectorAdd( ent->r.currentOrigin, trace->plane.normal, ent->r.currentOrigin);
VectorCopy( ent->r.currentOrigin, ent->s.pos.trBase );
ent->s.pos.trTime = level.time;
}
/*
================
G_RunItem
================
*/
void G_RunItem( gentity_t *ent ) {
vec3_t origin;
trace_t tr;
int contents;
int mask;
// if groundentity has been set to -1, it may have been pushed off an edge
if ( ent->s.groundEntityNum == -1 ) {
if ( ent->s.pos.trType != TR_GRAVITY ) {
ent->s.pos.trType = TR_GRAVITY;
ent->s.pos.trTime = level.time;
}
}
if ( ent->s.pos.trType == TR_STATIONARY ) {
// check think function
G_RunThink( ent );
return;
}
// get current position
BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
// trace a line from the previous position to the current position
if ( ent->clipmask ) {
mask = ent->clipmask;
} else {
mask = MASK_PLAYERSOLID & ~CONTENTS_BODY;//MASK_SOLID;
}
trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin,
ent->r.ownerNum, mask );
VectorCopy( tr.endpos, ent->r.currentOrigin );
if ( tr.startsolid ) {
tr.fraction = 0;
}
trap_LinkEntity( ent ); // FIXME: avoid this for stationary?
// check think function
G_RunThink( ent );
if ( tr.fraction == 1 ) {
return;
}
// if it is in a nodrop volume, remove it
contents = trap_PointContents( ent->r.currentOrigin, -1 );
if ( contents & CONTENTS_NODROP ) {
if (ent->item && ent->item->giType == IT_TEAM) {
Team_FreeEntity(ent);
} else {
G_FreeEntity( ent );
}
return;
}
G_BounceItem( ent, &tr );
}