/*
===============
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 );
}
/*
===============
Touch_Item
===============
*/
void Touch_Item( gentity_t *ent, gentity_t *other, trace_t *trace ) {
int respawn;
int makenoise = EV_ITEM_PICKUP;
// only activated items can be picked up
if( !ent->active ) {
return;
} else {
// need to set active to false if player is maxed out
ent->active = qfalse;
}
if( !other->client ) {
return;
}
if( other->health <= 0 ) {
return; // dead people can't pickup
}
// the same pickup rules are used for client side and server side
if ( !BG_CanItemBeGrabbed( &ent->s, &other->client->ps, other->client->sess.skill, other->client->sess.sessionTeam ) ) {
return;
}
if(g_gamestate.integer == GS_PLAYING) {
G_LogPrintf( "Item: %i %s\n", other->s.number, ent->item->classname );
} else {
// OSP - Don't let them pickup winning stuff in warmup
if(ent->item->giType != IT_WEAPON &&
ent->item->giType != IT_AMMO &&
ent->item->giType != IT_HEALTH)
return;
}
// G_LogPrintf( "Calling item pickup function for %s\n", ent->item->classname );
// call the item-specific pickup function
switch( ent->item->giType ) {
case IT_WEAPON:
respawn = Pickup_Weapon( ent, other );
break;
case IT_HEALTH:
respawn = Pickup_Health(ent, other);
break;
case IT_TEAM:
respawn = Pickup_Team(ent, other);
break;
default:
return;
}
// G_LogPrintf( "Finished pickup function\n" );
if ( !respawn ) {
return;
}
// play sounds
if( ent->noise_index ) {
// (SA) a sound was specified in the entity, so play that sound
// (this G_AddEvent) and send the pickup as "EV_ITEM_PICKUP_QUIET"
// so it doesn't make the default pickup sound when the pickup event is recieved
makenoise = EV_ITEM_PICKUP_QUIET;
G_AddEvent( other, EV_GENERAL_SOUND, ent->noise_index );
}
G_AddEvent( other, makenoise, ent->s.modelindex );
// powerup pickups are global broadcasts
if ( ent->item->giType == IT_TEAM ) {
gentity_t* te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
te->s.eventParm = ent->s.modelindex;
te->r.svFlags |= SVF_BROADCAST;
}
// G_LogPrintf( "Firing item targets\n" );
// fire item targets
G_UseTargets (ent, other);
// 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->flags |= FL_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 );
}
/*
===============
Touch_Item
===============
*/
void Touch_Item( gentity_t *ent, gentity_t *other, trace_t *trace ) {
int respawn;
int makenoise = EV_ITEM_PICKUP;
// only activated items can be picked up
if ( !ent->active ) {
return;
} else {
// need to set active to false if player is maxed out
ent->active = qfalse;
}
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( &ent->s, &other->client->ps ) ) {
return;
}
G_LogPrintf( "Item: %i %s\n", other->s.number, ent->item->classname );
// call the item-specific pickup function
switch ( ent->item->giType ) {
case IT_WEAPON:
respawn = Pickup_Weapon( ent, other );
break;
case IT_AMMO:
respawn = Pickup_Ammo( ent, other );
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 );
break;
case IT_TEAM:
respawn = Pickup_Team( ent, other );
break;
case IT_HOLDABLE:
respawn = Pickup_Holdable( ent, other );
break;
case IT_KEY:
respawn = Pickup_Key( ent, other );
break;
case IT_TREASURE:
respawn = Pickup_Treasure( ent, other );
break;
case IT_CLIPBOARD:
respawn = Pickup_Clipboard( ent, other );
// send the event to the client to request that the UI draw a popup
// (specified by the configstring in ent->s.density).
//G_AddEvent( other, EV_POPUP, ent->s.density);
//if(ent->key)
//G_AddEvent( other, EV_GIVEPAGE, ent->key );
break;
default:
return;
}
if ( !respawn ) {
return;
}
// play sounds
if ( ent->noise_index ) {
// (SA) a sound was specified in the entity, so play that sound
// (this G_AddEvent) and send the pickup as "EV_ITEM_PICKUP_QUIET"
// so it doesn't make the default pickup sound when the pickup event is recieved
makenoise = EV_ITEM_PICKUP_QUIET;
G_AddEvent( other, EV_GENERAL_SOUND, ent->noise_index );
}
// send the pickup event
if ( other->client->pers.predictItemPickup ) {
G_AddPredictableEvent( other, makenoise, ent->s.modelindex );
} else {
G_AddEvent( other, makenoise, ent->s.modelindex );
}
// powerup pickups are global broadcasts
if ( ent->item->giType == IT_POWERUP || ent->item->giType == IT_TEAM ) {
// (SA) probably need to check for IT_KEY here too... (coop?)
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;
// (SA) set if we want this to only go to the pickup 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->flags |= FL_NODRAW;
//ent->r.svFlags |= SVF_NOCLIENT;
ent->s.eFlags |= EF_NODRAW;
ent->r.contents = 0;
ent->unlinkAfterEvent = qtrue;
return;
}
// wait of -2 will respawn but not be available for pickup anymore
// (partial use things that leave a spent modle (ex. plate for turkey)
if ( respawn == RESPAWN_PARTIAL_DONE ) {
ent->s.density = ( 1 << 9 ); // (10 bits of data transmission for density)
ent->active = qtrue; // re-activate
trap_LinkEntity( ent );
return;
}
if ( respawn == RESPAWN_PARTIAL ) { // multi-stage health
ent->s.density--;
if ( ent->s.density ) { // still not completely used up ( (SA) this will change to == 0 and stage 1 will be a destroyable item (plate/etc.) )
ent->active = qtrue; // re-activate
trap_LinkEntity( ent );
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->flags |= FL_NODRAW;
//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 );
}
/*
===============
Touch_Item
===============
*/
void Touch_Item(gentity_t * ent, gentity_t * other, trace_t * trace)
{
int respawn;
qboolean predict;
int bandolierFactor;
//Makro - some checks
if (other == NULL || ent == NULL)
return;
if (!other->client)
return;
if (other->health < 1)
return; // dead people can't pickup
//Makro - even more bot hacks !
//this way, we can remove the item from the bot's library for a few seconds
//so bots won't get stuck in a loop between 2 items
if ((ent->r.svFlags & MASK_BOTHACK) == MASK_BOTHACK) {
if (ent->nextthink < level.time) {
ent->nextthink = level.time + 45 * 1000;
}
return;
}
// the same pickup rules are used for client side and server side
if (!BG_CanItemBeGrabbed(g_gametype.integer, &ent->s, &other->client->ps))
return;
predict = other->client->pers.predictItemPickup;
if (other->client->ps.stats[STAT_HOLDABLE_ITEM] & (1 << HI_BANDOLIER))
bandolierFactor = 2;
else
bandolierFactor = 1;
//Elder: should check if the item was recently thrown ... if it was, then
//don't allow it to be picked up ... or something like that
// call the item-specific pickup function
switch (ent->item->giType) {
case IT_WEAPON:
switch (ent->item->giTag) {
//Blaze: Check to see if we already have the weapon,
//If not so check and see if we have less then full ammo, if so pick up gun
//Elder's version:
//Accumulators (e.g. knife, grenade): if you have the weap AND the max limit, leave
//Pistols: if you have akimbos AND max clips, leave
//Akimbos: shouldn't pick them up b/c they shouldn't be dropped
//Specials: if you have more than/equal to limit (remember bando later), leave
case WP_KNIFE:
if (((other->client->ps.stats[STAT_WEAPONS] & (1 << WP_KNIFE)) == (1 << WP_KNIFE)) &&
(other->client->ps.ammo[ent->item->giTag] >= RQ3_KNIFE_MAXCLIP * bandolierFactor))
return;
break;
case WP_GRENADE:
if (((other->client->ps.stats[STAT_WEAPONS] & (1 << WP_GRENADE)) == (1 << WP_GRENADE)) &&
(other->client->ps.ammo[ent->item->giTag] >= RQ3_GRENADE_MAXCLIP * bandolierFactor))
return;
break;
case WP_PISTOL:
//Elder: always have pistol - but extra ones give akimbo or clips
if (((other->client->ps.stats[STAT_WEAPONS] & (1 << WP_AKIMBO)) == (1 << WP_AKIMBO)) &&
other->client->numClips[WP_PISTOL] >= RQ3_PISTOL_MAXCLIP * bandolierFactor) {
//leave if we have max clips and akimbos
return;
}
break;
case WP_M3:
case WP_HANDCANNON:
case WP_MP5:
case WP_M4:
case WP_SSG3000:
//Elder: check to see if it's in mid-air or over the limit
if (other->client->uniqueWeapons >= g_RQ3_maxWeapons.integer + (bandolierFactor - 1) ||
ent->s.pos.trDelta[2] != 0)
return;
// Paril: fix/workaround for 4085
// don't pick up dupe special weapons even if we could.
if ((other->client->ps.stats[STAT_WEAPONS] & (1 << ent->item->giTag)) == (1 << ent->item->giTag))
return;
break;
case WP_AKIMBO:
default:
//Elder: shouldn't be here
G_Printf("Touch_Item received invalid IT_WEAPON giTag: %d\n", ent->item->giTag);
return;
break;
}
respawn = Pickup_Weapon(ent, other, bandolierFactor);
//Elder: added pistol and knife condition
if (ent->item->giTag == WP_GRENADE || ent->item->giTag == WP_PISTOL || ent->item->giTag == WP_KNIFE) {
respawn = 30;
} else {
//Elder: moved here
respawn = -1; //Dont respawn weapons
}
// predict = qfalse;
break;
case IT_AMMO:
switch (ent->item->giTag) {
//Blaze: dont pick up the clip if we already have all the clips we can have
case WP_KNIFE:
if (other->client->numClips[ent->item->giTag] >= 0)
return; //No clips for knifes
break;
case WP_PISTOL:
if (other->client->numClips[ent->item->giTag] >= RQ3_PISTOL_MAXCLIP * bandolierFactor)
return;
break;
case WP_M3:
if (other->client->numClips[ent->item->giTag] >= RQ3_M3_MAXCLIP * bandolierFactor)
return;
break;
case WP_HANDCANNON:
if (other->client->numClips[ent->item->giTag] >= RQ3_HANDCANNON_MAXCLIP * bandolierFactor)
return;
break;
case WP_MP5:
if (other->client->numClips[ent->item->giTag] >= RQ3_MP5_MAXCLIP * bandolierFactor)
return;
break;
case WP_M4:
if (other->client->numClips[ent->item->giTag] >= RQ3_M4_MAXCLIP * bandolierFactor)
return;
break;
case WP_SSG3000:
if (other->client->numClips[ent->item->giTag] >= RQ3_SSG3000_MAXCLIP * bandolierFactor)
return;
break;
case WP_AKIMBO:
if (other->client->numClips[ent->item->giTag] >= RQ3_AKIMBO_MAXCLIP * bandolierFactor)
return;
break;
case WP_GRENADE:
if (other->client->numClips[ent->item->giTag] >= 0)
return; //no clips for grenades
break;
}
respawn = Pickup_Ammo(ent, other, bandolierFactor);
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;
case IT_TEAM:
// NiceAss: can't pick it up if it's in mid-flight (someone dropped it)
if (ent->s.pos.trDelta[2] != 0.0f)
return;
respawn = Pickup_Team(ent, other);
break;
case IT_HOLDABLE:
//Elder: check to see if it's in mid-air
if (other->client->uniqueItems >= g_RQ3_maxItems.integer || ent->s.pos.trDelta[2] != 0)
return;
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);
}
/*
===============
Touch_Item
===============
*/
void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace) {
int respawn;
qboolean predict;
//instant gib
if ((g_instantgib.integer || g_rockets.integer || g_gametype.integer == GT_CTF_ELIMINATION || g_elimination_allgametypes.integer)
&& ent->item->giType != IT_TEAM)
return;
//Cannot touch flag before round starts
if(g_gametype.integer == GT_CTF_ELIMINATION && level.roundNumber != level.roundNumberStarted)
return;
//Cannot take ctf elimination oneway
if(g_gametype.integer == GT_CTF_ELIMINATION && g_elimination_ctf_oneway.integer!=0 && (
(other->client->sess.sessionTeam==TEAM_BLUE && (level.eliminationSides+level.roundNumber)%2 == 0 ) ||
(other->client->sess.sessionTeam==TEAM_RED && (level.eliminationSides+level.roundNumber)%2 != 0 ) ))
return;
if (g_gametype.integer == GT_ELIMINATION || g_gametype.integer == GT_LMS)
return; //nothing to pick up in elimination
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;
}
//In double DD we cannot "pick up" a flag we already got
if(g_gametype.integer == GT_DOUBLE_D) {
if( strcmp(ent->classname, "team_CTF_redflag") == 0 )
if(other->client->sess.sessionTeam == level.pointStatusA)
return;
if( strcmp(ent->classname, "team_CTF_blueflag") == 0 )
if(other->client->sess.sessionTeam == level.pointStatusB)
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;
case IT_PERSISTANT_POWERUP:
respawn = Pickup_PersistantPowerup(ent, other);
break;
case IT_TEAM:
respawn = Pickup_Team(ent, other);
//If touching a team item remove spawnprotection
if(other->client->spawnprotected)
other->client->spawnprotected = qfalse;
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 );
}
virtual void execute( GameEntity *other, trace_t *trace )
{
int respawn;
bool predict;
GameEntity* self = self_; // Since we may delete our current think()
if( !other->client_ )
return;
if( other->health_ < 1 )
return; // dead people can't pickup
if( other->client_->ps_.pm_type == PM_SPECTATOR )
return;
// the same pickup rules are used for client side and server side
if ( !BG_CanItemBeGrabbed( g_gametype.integer, &self->s, &other->client_->ps_, other->client_->vehicle_ ) )
return;
G_LogPrintf( "Item: %i %s\n", other->s.number, self->item_->classname );
predict = other->client_->pers_.predictItemPickup_;
// call the item-specific pickup function
switch( self->item_->giType )
{
case IT_AMMO:
respawn = Pickup_Ammo(self, other);
break;
case IT_HEALTH:
respawn = Pickup_Health(self, other);
break;
case IT_FUEL:
respawn = Pickup_Fuel(self, other);
break;
case IT_TEAM:
respawn = Pickup_Team(self, other);
break;
default:
return;
}
if ( !respawn )
return;
// play the normal pickup sound
if( predict )
G_AddPredictableEvent( other, EV_ITEM_PICKUP, self->s.modelindex );
else
G_AddEvent( other, EV_ITEM_PICKUP, self->s.modelindex, true );
// powerup pickups are global broadcasts
if( self->item_->giType == IT_TEAM)
{
// if we want the global sound to play
if( !self->speed_ )
{
GameEntity *te;
te = G_TempEntity( self->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
te->s.eventParm = self->s.modelindex;
te->r.svFlags |= SVF_BROADCAST;
}
else
{
GameEntity *te;
te = G_TempEntity( self->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
te->s.eventParm = self->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 (self, other);
// wait of -1 will not respawn
if( self->wait_ == -1 )
{
self->r.svFlags |= SVF_NOCLIENT;
self->s.eFlags |= EF_NODRAW;
self->r.contents = 0;
self->unlinkAfterEvent_ = true;
return;
}
// non zero wait overrides respawn time
if( self->wait_ )
respawn = self->wait_;
// random can be used to vary the respawn time
if( self->random_ )
{
respawn += crandom() * self->random_;
if ( respawn < 1 )
respawn = 1;
}
// dropped items will not respawn
if( self->flags_ & FL_DROPPED_ITEM )
self->freeAfterEvent_ = true;
// picked up items still stay around, they just don't
// draw anything. This allows respawnable items
// to be placed on movers.
self->r.svFlags |= SVF_NOCLIENT;
self->s.eFlags |= EF_NODRAW;
self->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 )
{
self->nextthink_ = 0;
self->setThink(0);
}
else
{
self->nextthink_ = theLevel.time_ + respawn * 1000;
self->setThink(new Think_RespawnItem);
}
SV_LinkEntity( self );
}
/*
===============
Touch_Item
defcon-X: just keep this for bots!
===============
*/
void Pick_Item( gentity_t *ent, gentity_t *other, trace_t *trace ) {
int respawn;
if ( !other->client ) {
return;
}
if ( other->health < 1 ) {
return; // dead people can't pickup
}
if ( !BG_CanItemBeGrabbed( g_gametype.integer, &ent->s, &other->client->ps ) ) {
return;
}
// call the item-specific pickup function
switch ( ent->item->giType ) {
case IT_WEAPON:
respawn = Pickup_Weapon( ent, other );
break;
case IT_AMMO:
respawn = Pickup_Ammo( ent, other );
break;
case IT_ARMOR:
respawn = Pickup_Armor( ent, other );
break;
case IT_TEAM:
respawn = Pickup_Team( ent, other );
break;
default:
return;
}
if ( !respawn ) {
return;
}
// play the normal pickup sound
if ( ( ent->item->giTag != PW_BRIEFCASE_RETURN ) && ( ent->item->giTag != PW_BRIEFCASE ) ) {
if ( ent->item->giType != IT_BOTROAM ) {
G_AddEvent( other, EV_ITEM_PICKUP, ent->s.modelindex );
}
}
// Navy Seals ++
// 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 );
}
/*
===============
Touch_Item
===============
*/
void Touch_Item (gentity_t *ent, gentity_t *other, trace_t *trace) {
int respawn;
if (!other->client)
return;
if (other->health < 1)
return; // dead people can't pickup
// RPG-X: Marcin: Press USE to pick up items. - 03/12/2008
if ( !(other->client->pers.cmd.buttons & BUTTON_USE) || other->client->pressedUse == qtrue) {
return;
} else {
other->client->pressedUse = qtrue;
}
// If ghosted, then end the ghost-ness in favor of the pickup.
//RPG-X: RedTechie - Keep ghost all the time
/*if (other->client->ps.powerups[PW_GHOST] >= level.time)
{
other->client->ps.powerups[PW_GHOST] = 0; // Unghost the player. This
}*/
// the same pickup rules are used for client side and server side
if ( !BG_CanItemBeGrabbed( &ent->s, &other->client->ps, Max_Weapon(other->client->ps.weapon) )
&& IsAdmin( other ) == qfalse )
{
return;
}
numTotalDropped--;
G_LogPrintf( "Item: %i %s\n", other->s.number, ent->item->classname );
// call the item-specific pickup function
switch( ent->item->giType )
{
case IT_WEAPON:
respawn = Pickup_Weapon(ent, other);
break;
case IT_AMMO:
respawn = Pickup_Ammo(ent, other);
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);
break;
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 ( other->client->pers.predictItemPickup ) {
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) {
gentity_t *te;
te = G_TempEntity( ent->s.pos.trBase, EV_GLOBAL_ITEM_PICKUP );
te->s.eventParm = ent->s.modelindex;
// tell us which client fired off this global sound
te->s.otherEntityNum = other->s.number;
te->r.svFlags |= SVF_BROADCAST;
}
// fire item targets
G_UseTargets (ent, other);
if ( rpg_weaponsStay.integer == 1 && IsAdmin( ent->parent ) == qtrue && IsAdmin( other ) == qfalse ) {
return;
}
if ( ent->item->giTag == WP_3 ) {
Padd_Remove( ent );
}
// 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.
if (ent->item->giType==IT_WEAPON || ent->item->giType==IT_POWERUP)
{
ent->s.eFlags |= EF_ITEMPLACEHOLDER;
}
else
{
// this line used to prevent items that were picked up from being drawn, but we now want to draw the techy grid thing instead
ent->s.eFlags |= EF_NODRAW;
ent->r.svFlags |= SVF_NOCLIENT;
}
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 );
}
