void G_InstantExplode(vec3_t orig, gentity_t *attacker) {
gentity_t *dynamite;
//spawn a new entity
dynamite = G_Spawn();
dynamite->classname = "grenade";
//change its current position
VectorCopy(orig, dynamite->s.pos.trBase);
VectorCopy(orig, dynamite->r.currentOrigin);
//set its flags
dynamite->s.eType = ET_MISSILE;
dynamite->r.svFlags = SVF_USE_CURRENT_ORIGIN;
dynamite->r.svFlags |= SVF_BROADCAST;
dynamite->s.weapon = WP_DYNAMITE;
dynamite->s.eFlags = EF_BOUNCE_HALF;
//change the owner to the one who shot the dynamite
dynamite->r.ownerNum = attacker->s.number;
dynamite->parent = attacker;
//dynamite damage
dynamite->damage = 900 + rand()%200;
dynamite->splashDamage = 600 + rand()%200;
dynamite->splashRadius = 200 + rand()%50;
dynamite->methodOfDeath = MOD_DYNAMITE;
dynamite->splashMethodOfDeath = MOD_DYNAMITE;
dynamite->clipmask = MASK_SHOT;
G_ExplodeMissile(dynamite);
}
/*
================
ProximityMine_Explode
================
*/
static void ProximityMine_Explode( gentity_t *mine ) {
G_ExplodeMissile( mine );
// if the prox mine has a trigger free it
if (mine->activator) {
G_FreeEntity(mine->activator);
mine->activator = NULL;
}
}
void G_Suck( gentity_t *self ) {
int wait = self->wait;
// if in water disable burning
if (!Q_stricmp(self->classname, "grenadeend")){
gitem_t *item;
item = BG_FindItemForWeapon( WP_DYNAMITE );
self->s.apos.trDelta[0] = 0;
self->s.modelindex = item- bg_itemlist;
self->s.modelindex2 = 1;
self->item = item;
self->s.eType = ET_ITEM;
self->r.contents = CONTENTS_TRIGGER2;
self->wait = -1;
self->flags |= FL_THROWN_ITEM;
self->touch = Touch_Item;
self->classname = "grenadesit";
self->think = G_KnifeThink;
self->nextthink = level.time + 100;
self->wait = level.time + 60000;
self->r.currentAngles[1] = rand() % 360;
self->r.currentAngles[PITCH] = 90;
VectorCopy(self->r.currentAngles, self->s.apos.trBase);
return;
}
if(self->s.pos.trType == TR_STATIONARY){
// just to be sure KnifeThink doesn't delete the dynamite
self->wait = level.time + 999999;
// runs solid checks: is dynamite hovering in the air?
G_KnifeThink(self);
}
self->nextthink = level.time + 100;
self->think = G_Suck;
self->wait = wait;
if (level.time > self->wait && !Q_stricmp(self->classname, "grenade"))
G_ExplodeMissile( self );
}
/*
================
ProximityMine_ExplodeOnPlayer
================
*/
static void ProximityMine_ExplodeOnPlayer( gentity_t *mine ) {
gentity_t *player;
player = mine->enemy;
player->client->ps.eFlags &= ~EF_TICKING;
if ( player->client->invulnerabilityTime > level.time ) {
G_Damage( player, mine->parent, mine->parent, vec3_origin, mine->s.origin, 1000, DAMAGE_NO_KNOCKBACK, MOD_JUICED );
player->client->invulnerabilityTime = 0;
G_TempEntity( player->client->ps.origin, EV_JUICED );
}
else {
G_SetOrigin( mine, player->s.pos.trBase );
// make sure the explosion gets to the client
mine->r.svFlags &= ~SVF_NOCLIENT;
mine->splashMethodOfDeath = MOD_PROXIMITY_MINE;
G_ExplodeMissile( mine );
}
}
/*
================
G_ProcessProximityMine
If an enemy is close to the entity, go boom!
================
*/
void G_ProcessProximityMine(gentity_t *ent) {
int i, total_entities, entityList[MAX_GENTITIES];
vec3_t range, mins, maxs;
gentity_t *target;
// Set the next time to run this check (can be overwritten below)
ent->nextthink = level.time + PROXIMITY_CHECK_FREQUENCY;
// Grab all entities around us
VectorSet(range, PROXIMITY_RANGE, PROXIMITY_RANGE, PROXIMITY_RANGE);
VectorAdd(ent->s.origin, range, maxs);
VectorSubtract(ent->s.origin, range, mins);
total_entities = trap_EntitiesInBox(mins, maxs, entityList, MAX_GENTITIES);
// Loop entities looking for an enemy body
for(i=0; i<total_entities; i++) {
target = &g_entities[entityList[i]];
if(((target->client && target->client->ps.stats[ STAT_PTEAM ] == PTE_ALIENS) || !strcmp(target->classname, "slowblob")) && CanDamage(target, ent->s.origin)) {
// Found an enemy, boom time!
ent->nextthink = level.time + PROXIMITY_BOOM_TIME;
ent->think = G_ExplodeMissile;
return;
}
}
VectorAdd(ent->s.origin, ent->r.maxs, maxs);
VectorAdd(ent->s.origin, ent->r.maxs, mins);
total_entities = trap_EntitiesInBox(mins, maxs, entityList, MAX_GENTITIES);
for(i=0; i<total_entities; i++) {
target = &g_entities[entityList[i]];
if((target->client || !strcmp(target->classname, "bounceball")) && CanDamage(target, ent->s.origin)) {
// Found an enemy, boom time!
ent->nextthink = level.time + PROXIMITY_BOOM_TIME;
ent->think = G_ExplodeMissile;
return;
}
}
if( level.time > ent->s.time + 2*60*1000 ) {
G_ExplodeMissile( ent );
}
}
static void FirebombMissileThink( gentity_t *self )
{
gentity_t *neighbor, *m;
int subMissileNum;
vec3_t dir, upwards = { 0.0f, 0.0f, 1.0f };
// ignite alien buildables in range
neighbor = NULL;
while ( ( neighbor = G_IterateEntitiesWithinRadius( neighbor, self->s.origin, FIREBOMB_IGNITE_RANGE ) ) )
{
if ( neighbor->s.eType == ET_BUILDABLE && neighbor->buildableTeam == TEAM_ALIENS &&
G_LineOfSight( self, neighbor ) )
{
G_IgniteBuildable( neighbor, self->parent );
}
}
// set floor below on fire (assumes the firebomb lays on the floor!)
G_SpawnFire( self->s.origin, upwards, self->parent );
// spam fire
for ( subMissileNum = 0; subMissileNum < FIREBOMB_SUBMISSILE_COUNT; subMissileNum++ )
{
dir[ 0 ] = ( rand() / ( float )RAND_MAX ) - 0.5f;
dir[ 1 ] = ( rand() / ( float )RAND_MAX ) - 0.5f;
dir[ 2 ] = ( rand() / ( float )RAND_MAX ) * 0.5f;
VectorNormalize( dir );
// the submissile's parent is the attacker
m = G_SpawnMissile( MIS_FIREBOMB_SUB, self->parent, self->s.origin, dir, NULL, G_FreeEntity, level.time + 10000 );
// randomize missile speed
VectorScale( m->s.pos.trDelta, ( rand() / ( float )RAND_MAX ) + 0.5f, m->s.pos.trDelta );
}
// explode
G_ExplodeMissile( self );
}
/*
============
G_MoverPush
Objects need to be moved back on a failed push,
otherwise riders would continue to slide.
If qfalse is returned, *obstacle will be the blocking entity
============
*/
qboolean G_MoverPush( gentity_t *pusher, vec3_t move, vec3_t amove, gentity_t **obstacle ) {
int i, e;
gentity_t *check;
vec3_t mins, maxs;
pushed_t *p;
int entityList[MAX_GENTITIES];
int listedEntities;
vec3_t totalMins, totalMaxs;
*obstacle = NULL;
// mins/maxs are the bounds at the destination
// totalMins / totalMaxs are the bounds for the entire move
if ( pusher->r.currentAngles[0] || pusher->r.currentAngles[1] || pusher->r.currentAngles[2]
|| amove[0] || amove[1] || amove[2] ) {
float radius;
radius = RadiusFromBounds( pusher->r.mins, pusher->r.maxs );
for ( i = 0 ; i < 3 ; i++ ) {
mins[i] = pusher->r.currentOrigin[i] + move[i] - radius;
maxs[i] = pusher->r.currentOrigin[i] + move[i] + radius;
totalMins[i] = mins[i] - move[i];
totalMaxs[i] = maxs[i] - move[i];
}
} else {
for (i=0 ; i<3 ; i++) {
mins[i] = pusher->r.absmin[i] + move[i];
maxs[i] = pusher->r.absmax[i] + move[i];
}
VectorCopy( pusher->r.absmin, totalMins );
VectorCopy( pusher->r.absmax, totalMaxs );
for (i=0 ; i<3 ; i++) {
if ( move[i] > 0 ) {
totalMaxs[i] += move[i];
} else {
totalMins[i] += move[i];
}
}
}
// unlink the pusher so we don't get it in the entityList
trap_UnlinkEntity( pusher );
listedEntities = trap_EntitiesInBox( totalMins, totalMaxs, entityList, MAX_GENTITIES );
// move the pusher to it's final position
VectorAdd( pusher->r.currentOrigin, move, pusher->r.currentOrigin );
VectorAdd( pusher->r.currentAngles, amove, pusher->r.currentAngles );
trap_LinkEntity( pusher );
// see if any solid entities are inside the final position
for ( e = 0 ; e < listedEntities ; e++ ) {
check = &g_entities[ entityList[ e ] ];
#ifdef MISSIONPACK
if ( check->s.eType == ET_MISSILE ) {
// if it is a prox mine
if ( !strcmp(check->classname, "prox mine") ) {
// if this prox mine is attached to this mover try to move it with the pusher
if ( check->enemy == pusher ) {
if (!G_TryPushingProxMine( check, pusher, move, amove )) {
//explode
check->s.loopSound = 0;
G_AddEvent( check, EV_PROXIMITY_MINE_TRIGGER, 0 );
G_ExplodeMissile(check);
if (check->activator) {
G_FreeEntity(check->activator);
check->activator = NULL;
}
//G_Printf("prox mine explodes\n");
}
}
else {
//check if the prox mine is crushed by the mover
if (!G_CheckProxMinePosition( check )) {
//explode
check->s.loopSound = 0;
G_AddEvent( check, EV_PROXIMITY_MINE_TRIGGER, 0 );
G_ExplodeMissile(check);
if (check->activator) {
G_FreeEntity(check->activator);
check->activator = NULL;
}
//G_Printf("prox mine explodes\n");
}
}
continue;
}
}
#endif
// only push items and players
if ( check->s.eType != ET_ITEM && check->s.eType != ET_PLAYER && !check->physicsObject ) {
continue;
}
// if the entity is standing on the pusher, it will definitely be moved
if ( check->s.groundEntityNum != pusher->s.number ) {
// see if the ent needs to be tested
if ( check->r.absmin[0] >= maxs[0]
|| check->r.absmin[1] >= maxs[1]
|| check->r.absmin[2] >= maxs[2]
|| check->r.absmax[0] <= mins[0]
|| check->r.absmax[1] <= mins[1]
|| check->r.absmax[2] <= mins[2] ) {
continue;
}
// see if the ent's bbox is inside the pusher's final position
// this does allow a fast moving object to pass through a thin entity...
if (!G_TestEntityPosition (check)) {
continue;
}
}
// the entity needs to be pushed
if ( G_TryPushingEntity( check, pusher, move, amove ) ) {
continue;
}
// the move was blocked an entity
// bobbing entities are instant-kill and never get blocked
if ( pusher->s.pos.trType == TR_SINE || pusher->s.apos.trType == TR_SINE ) {
G_Damage( check, pusher, pusher, NULL, NULL, 99999, 0, MOD_CRUSH );
continue;
}
// save off the obstacle so we can call the block function (crush, etc)
*obstacle = check;
// move back any entities we already moved
// go backwards, so if the same entity was pushed
// twice, it goes back to the original position
for ( p=pushed_p-1 ; p>=pushed ; p-- ) {
VectorCopy (p->origin, p->ent->s.pos.trBase);
VectorCopy (p->angles, p->ent->s.apos.trBase);
if ( p->ent->client ) {
p->ent->client->ps.delta_angles[YAW] = p->deltayaw;
VectorCopy (p->origin, p->ent->client->ps.origin);
}
trap_LinkEntity (p->ent);
}
return qfalse;
}
return qtrue;
}
void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod ) {
gclient_t *client;
int take;
int save;
int knockback;
qboolean headShot;
qboolean wasAlive;
hitRegion_t hr = HR_NUM_HITREGIONS;
if (!targ->takedamage) {
return;
}
#ifdef SAVEGAME_SUPPORT
if( g_gametype.integer == GT_SINGLE_PLAYER && ( g_reloading.integer || saveGamePending ) )
return;
#endif // SAVEGAME_SUPPORT
// trap_SendServerCommand( -1, va("print \"%i\n\"\n", targ->health) );
// the intermission has allready been qualified for, so don't
// allow any extra scoring
if ( level.intermissionQueued || (g_gamestate.integer != GS_PLAYING && match_warmupDamage.integer == 0)) {
return;
}
if ( !inflictor ) {
inflictor = &g_entities[ENTITYNUM_WORLD];
}
if ( !attacker ) {
attacker = &g_entities[ENTITYNUM_WORLD];
}
// Arnout: invisible entities can't be damaged
if( targ->entstate == STATE_INVISIBLE ||
targ->entstate == STATE_UNDERCONSTRUCTION ) {
return;
}
// xkan, 12/23/2002 - was the bot alive before applying any damage?
wasAlive = (targ->health > 0);
// Arnout: combatstate
if( targ->client && attacker && attacker->client && attacker != targ ) {
/*vec_t dist = -1.f;
if( targ->client->combatState < COMBATSTATE_HOT ) {
vec3_t shotvec;
VectorSubtract( targ->r.currentOrigin, attacker->r.currentOrigin, shotvec );
dist = VectorLengthSquared( shotvec );
if( dist < Square(1500.f) && targ->client->combatState == COMBATSTATE_WARM )
targ->client->combatState = COMBATSTATE_HOT;
}
if( attacker->client->combatState < COMBATSTATE_HOT ) {
if( dist < 0.f ) {
vec3_t shotvec;
VectorSubtract( targ->r.currentOrigin, attacker->r.currentOrigin, shotvec );
dist = VectorLengthSquared( shotvec );
}
if( dist > Square(1500.f) )
attacker->client->combatState = COMBATSTATE_WARM;
else if( attacker->client->combatState == COMBATSTATE_WARM )
attacker->client->combatState = COMBATSTATE_HOT;
}*/
if( g_gamestate.integer == GS_PLAYING ) {
if( !OnSameTeam( attacker, targ ) ) {
targ->client->combatState |= (1<<COMBATSTATE_DAMAGERECEIVED);
attacker->client->combatState |= (1<<COMBATSTATE_DAMAGEDEALT);
}
}
}
// JPW NERVE
if ((targ->waterlevel >= 3) && (mod == MOD_FLAMETHROWER))
return;
// jpw
// shootable doors / buttons don't actually have any health
if ( targ->s.eType == ET_MOVER && !(targ->isProp) && !targ->scriptName) {
if ( targ->use && targ->moverState == MOVER_POS1 ) {
G_UseEntity( targ, inflictor, attacker );
}
return;
}
// TAT 11/22/2002
// In the old code, this check wasn't done for props, so I put that check back in to make props_statue properly work
// 4 means destructible
if ( targ->s.eType == ET_MOVER && (targ->spawnflags & 4) && !targ->isProp )
{
/*switch (mod) {
case MOD_GRENADE:
case MOD_GRENADE_LAUNCHER:
case MOD_ROCKET:
case MOD_AIRSTRIKE:
case MOD_ARTY:
case MOD_GRENADE_PINEAPPLE:
case MOD_MAPMORTAR:
case MOD_EXPLOSIVE:
case MOD_DYNAMITE:
case MOD_LANDMINE:
case MOD_GPG40:
case MOD_M7:
case MOD_TELEFRAG:
case MOD_PANZERFAUST:
case MOD_SATCHEL:
break;
default:
return; // no damage from other weapons
}*/
if( !G_WeaponIsExplosive( mod ) ) {
return;
}
// check for team
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
} else if ( targ->s.eType == ET_EXPLOSIVE ) {
/*// 32 Explosive
// 64 Dynamite only
// 256 Airstrike/artillery only
// 512 Satchel only
if ((targ->spawnflags & 32) || (targ->spawnflags & 64) || (targ->spawnflags & 256) || (targ->spawnflags & 512))
{
switch (mod) {
case MOD_GRENADE:
case MOD_GRENADE_LAUNCHER:
case MOD_ROCKET:
case MOD_GRENADE_PINEAPPLE:
case MOD_MAPMORTAR:
case MOD_EXPLOSIVE:
case MOD_LANDMINE:
case MOD_GPG40:
case MOD_M7:
if( !(targ->spawnflags & 32) )
return;
break;
case MOD_SATCHEL:
if( !(targ->spawnflags & 512) )
return;
break;
case MOD_ARTY:
case MOD_AIRSTRIKE:
if( !(targ->spawnflags & 256) )
return;
break;
case MOD_DYNAMITE:
if( !(targ->spawnflags & 64) )
return;
break;
default:
return;
}
// check for team
if( targ->s.teamNum == inflictor->s.teamNum ) {
return;
}
}*/
if( targ->parent && G_GetWeaponClassForMOD( mod ) == 2 ) {
return;
}
// check for team
// if( G_GetWeaponClassForMOD( mod ) != -1 && targ->s.teamNum == inflictor->s.teamNum ) {
// return;
// }
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
if( G_GetWeaponClassForMOD( mod ) < targ->constructibleStats.weaponclass ) {
return;
}
}
else if ( targ->s.eType == ET_MISSILE && targ->methodOfDeath == MOD_LANDMINE ) {
if( targ->s.modelindex2 ) {
if( G_WeaponIsExplosive( mod ) ) {
mapEntityData_t *mEnt;
if((mEnt = G_FindMapEntityData(&mapEntityData[0], targ-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[0], mEnt );
}
if((mEnt = G_FindMapEntityData(&mapEntityData[1], targ-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[1], mEnt );
}
if( attacker && attacker->client ) {
AddScore( attacker, 1 );
//G_AddExperience( attacker, 1.f );
}
G_ExplodeMissile(targ);
}
}
return;
} else if ( targ->s.eType == ET_CONSTRUCTIBLE ) {
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
if( G_GetWeaponClassForMOD( mod ) < targ->constructibleStats.weaponclass ) {
return;
}
}
client = targ->client;
if ( client ) {
if ( client->noclip || client->ps.powerups[PW_INVULNERABLE] ) {
return;
}
}
// check for godmode
if ( targ->flags & FL_GODMODE ) {
return;
}
if ( !dir ) {
dflags |= DAMAGE_NO_KNOCKBACK;
} else {
VectorNormalize(dir);
}
knockback = damage;
if ( knockback > 200 ) {
knockback = 200;
}
if ( targ->flags & FL_NO_KNOCKBACK ) {
knockback = 0;
}
if ( dflags & DAMAGE_NO_KNOCKBACK ) {
knockback = 0;
} else if( dflags & DAMAGE_HALF_KNOCKBACK ) {
knockback *= 0.5f;
}
// ydnar: set weapons means less knockback
if( client && (client->ps.weapon == WP_MORTAR_SET || client->ps.weapon == WP_MOBILE_MG42_SET) )
knockback *= 0.5;
if( targ->client && g_friendlyFire.integer && OnSameTeam(targ, attacker) ) {
knockback = 0;
}
// figure momentum add, even if the damage won't be taken
if ( knockback && targ->client ) {
vec3_t kvel;
float mass;
mass = 200;
VectorScale (dir, g_knockback.value * (float)knockback / mass, kvel);
VectorAdd (targ->client->ps.velocity, kvel, targ->client->ps.velocity);
/*if( mod == MOD_GRENADE ||
mod == MOD_GRENADE_LAUNCHER ||
mod == MOD_DYNAMITE ||
mod == MOD_GPG40 ||
mod == MOD_M7 ||
mod == MOD_LANDMINE ) {
targ->client->ps.velocity[2] *= 2.f; // gimme air baby!
targ->client->ps.groundEntityNum = ENTITYNUM_NONE; // flying high!
} else if( mod == MOD_ROCKET ) {
targ->client->ps.velocity[2] *= .75f; // but not to the moon please!
targ->client->ps.groundEntityNum = ENTITYNUM_NONE; // flying high!
}*/
if (targ == attacker && !( mod != MOD_ROCKET &&
mod != MOD_GRENADE &&
mod != MOD_GRENADE_LAUNCHER &&
mod != MOD_DYNAMITE
&& mod != MOD_GPG40
&& mod != MOD_M7
&& mod != MOD_LANDMINE
))
{
targ->client->ps.velocity[2] *= 0.25;
}
// set the timer so that the other client can't cancel
// out the movement immediately
if ( !targ->client->ps.pm_time ) {
int t;
t = knockback * 2;
if ( t < 50 ) {
t = 50;
}
if ( t > 200 ) {
t = 200;
}
targ->client->ps.pm_time = t;
targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
}
}
// check for completely getting out of the damage
if ( !(dflags & DAMAGE_NO_PROTECTION) ) {
// if TF_NO_FRIENDLY_FIRE is set, don't do damage to the target
// if the attacker was on the same team
if ( targ != attacker && OnSameTeam (targ, attacker) ) {
if ( (g_gamestate.integer != GS_PLAYING && match_warmupDamage.integer == 1)) {
return;
}
else if (!g_friendlyFire.integer)
{
return;
}
}
}
// add to the attacker's hit counter
if ( attacker->client && targ != attacker && targ->health > 0 ) {
if ( OnSameTeam( targ, attacker ) ) {
attacker->client->ps.persistant[PERS_HITS] -= damage;
} else {
attacker->client->ps.persistant[PERS_HITS] += damage;
}
}
if ( damage < 1 ) {
damage = 1;
}
take = damage;
save = 0;
// adrenaline junkie!
if( targ->client && targ->client->ps.powerups[PW_ADRENALINE] ) {
take *= .5f;
}
// save some from flak jacket
if( targ->client && targ->client->sess.skill[SK_EXPLOSIVES_AND_CONSTRUCTION] >= 4 && targ->client->sess.playerType == PC_ENGINEER ) {
if( mod == MOD_GRENADE ||
mod == MOD_GRENADE_LAUNCHER ||
mod == MOD_ROCKET ||
mod == MOD_GRENADE_PINEAPPLE ||
mod == MOD_MAPMORTAR ||
mod == MOD_MAPMORTAR_SPLASH ||
mod == MOD_EXPLOSIVE ||
mod == MOD_LANDMINE ||
mod == MOD_GPG40 ||
mod == MOD_M7 ||
mod == MOD_SATCHEL ||
mod == MOD_ARTY ||
mod == MOD_AIRSTRIKE ||
mod == MOD_DYNAMITE ||
mod == MOD_MORTAR ||
mod == MOD_PANZERFAUST ||
mod == MOD_MAPMORTAR ) {
take -= take * .5f;
}
}
headShot = IsHeadShot(targ, dir, point, mod);
if ( headShot ) {
if( take * 2 < 50 ) // head shots, all weapons, do minimum 50 points damage
take = 50;
else
take *= 2; // sniper rifles can do full-kill (and knock into limbo)
if( dflags & DAMAGE_DISTANCEFALLOFF ) {
vec_t dist;
vec3_t shotvec;
VectorSubtract( point, muzzleTrace, shotvec );
dist = VectorLength( shotvec );
if( dist > 1500.f ) {
if( dist > 2500.f ) {
take *= 0.2f;
} else {
float scale = 1.f - 0.2f * (1000.f / (dist - 1000.f));
take *= scale;
}
}
}
if( !(targ->client->ps.eFlags & EF_HEADSHOT) ) { // only toss hat on first headshot
G_AddEvent( targ, EV_LOSE_HAT, DirToByte(dir) );
if( mod != MOD_K43_SCOPE &&
mod != MOD_GARAND_SCOPE ) {
take *= .8f; // helmet gives us some protection
}
}
targ->client->ps.eFlags |= EF_HEADSHOT;
// OSP - Record the headshot
if(client && attacker && attacker->client
#ifndef DEBUG_STATS
&& attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam
#endif
) {
G_addStatsHeadShot(attacker, mod);
}
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Head Shot\n\"\n");
}
G_LogRegionHit( attacker, HR_HEAD );
hr = HR_HEAD;
} else if ( IsLegShot(targ, dir, point, mod) ) {
G_LogRegionHit( attacker, HR_LEGS );
hr = HR_LEGS;
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Leg Shot\n\"\n");
}
} else if ( IsArmShot(targ, attacker, point, mod) ) {
G_LogRegionHit( attacker, HR_ARMS );
hr = HR_ARMS;
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Arm Shot\n\"\n");
}
} else if (targ->client && targ->health > 0 && IsHeadShotWeapon( mod ) ) {
G_LogRegionHit( attacker, HR_BODY );
hr = HR_BODY;
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Body Shot\n\"\n");
}
}
#ifndef DEBUG_STATS
if ( g_debugDamage.integer )
#endif
{
G_Printf( "client:%i health:%i damage:%i mod:%s\n", targ->s.number, targ->health, take, modNames[mod] );
}
// add to the damage inflicted on a player this frame
// the total will be turned into screen blends and view angle kicks
// at the end of the frame
if ( client ) {
if ( attacker ) {
client->ps.persistant[PERS_ATTACKER] = attacker->s.number;
} else {
client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD;
}
client->damage_blood += take;
client->damage_knockback += knockback;
if ( dir ) {
VectorCopy ( dir, client->damage_from );
client->damage_fromWorld = qfalse;
} else {
VectorCopy ( targ->r.currentOrigin, client->damage_from );
client->damage_fromWorld = qtrue;
}
}
// See if it's the player hurting the emeny flag carrier
// Team_CheckHurtCarrier(targ, attacker);
if (targ->client) {
// set the last client who damaged the target
targ->client->lasthurt_client = attacker->s.number;
targ->client->lasthurt_mod = mod;
}
// do the damage
if( take ) {
targ->health -= take;
// Gordon: don't ever gib POWS
if( ( targ->health <= 0 ) && ( targ->r.svFlags & SVF_POW ) ) {
targ->health = -1;
}
// Ridah, can't gib with bullet weapons (except VENOM)
// Arnout: attacker == inflictor can happen in other cases as well! (movers trying to gib things)
//if ( attacker == inflictor && targ->health <= GIB_HEALTH) {
if( targ->health <= GIB_HEALTH ) {
if( !G_WeaponIsExplosive( mod ) ) {
targ->health = GIB_HEALTH + 1;
}
}
// JPW NERVE overcome previous chunk of code for making grenades work again
// if ((take > 190)) // 190 is greater than 2x mauser headshot, so headshots don't gib
// Arnout: only player entities! messes up ents like func_constructibles and func_explosives otherwise
if( ( (targ->s.number < MAX_CLIENTS) && (take > 190) ) && !(targ->r.svFlags & SVF_POW) ) {
targ->health = GIB_HEALTH - 1;
}
if( targ->s.eType == ET_MOVER && !Q_stricmp( targ->classname, "script_mover" ) ) {
targ->s.dl_intensity = 255.f * (targ->health / (float)targ->count); // send it to the client
}
//G_Printf("health at: %d\n", targ->health);
if( targ->health <= 0 ) {
if( client && !wasAlive ) {
targ->flags |= FL_NO_KNOCKBACK;
// OSP - special hack to not count attempts for body gibbage
if( targ->client->ps.pm_type == PM_DEAD ) {
G_addStats(targ, attacker, take, mod);
}
if( (targ->health < FORCE_LIMBO_HEALTH) && (targ->health > GIB_HEALTH) ) {
limbo(targ, qtrue);
}
// xkan, 1/13/2003 - record the time we died.
if (!client->deathTime)
client->deathTime = level.time;
} else {
targ->sound1to2 = hr;
targ->sound2to1 = mod;
targ->sound2to3 = (dflags & DAMAGE_RADIUS) ? 1 : 0;
if( client ) {
if( G_GetTeamFromEntity( inflictor ) != G_GetTeamFromEntity( targ ) ) {
G_AddKillSkillPoints( attacker, mod, hr, (dflags & DAMAGE_RADIUS) );
}
}
if( targ->health < -999 ) {
targ->health = -999;
}
targ->enemy = attacker;
targ->deathType = mod;
// Ridah, mg42 doesn't have die func (FIXME)
if( targ->die ) {
// Kill the entity. Note that this funtion can set ->die to another
// function pointer, so that next time die is applied to the dead body.
targ->die( targ, inflictor, attacker, take, mod );
// OSP - kill stats in player_die function
}
if( targ->s.eType == ET_MOVER && !Q_stricmp( targ->classname, "script_mover" ) && (targ->spawnflags & 8) ) {
return; // reseructable script mover doesn't unlink itself but we don't want a second death script to be called
}
// if we freed ourselves in death function
if (!targ->inuse)
return;
// RF, entity scripting
if (targ->health <= 0)
{ // might have revived itself in death function
if ((targ->s.eType != ET_CONSTRUCTIBLE && targ->s.eType != ET_EXPLOSIVE) || (targ->s.eType == ET_CONSTRUCTIBLE && !targ->desstages))
{ // call manually if using desstages
G_Script_ScriptEvent( targ, "death", "" );
}
}
}
}
else if ( targ->pain )
{
if (dir) { // Ridah, had to add this to fix NULL dir crash
VectorCopy (dir, targ->rotate);
VectorCopy (point, targ->pos3); // this will pass loc of hit
} else {
VectorClear( targ->rotate );
VectorClear( targ->pos3 );
}
targ->pain (targ, attacker, take, point);
} else {
// OSP - update weapon/dmg stats
G_addStats(targ, attacker, take, mod);
// OSP
}
// RF, entity scripting
G_Script_ScriptEvent( targ, "pain", va("%d %d", targ->health, targ->health+take) );
// Ridah, this needs to be done last, incase the health is altered in one of the event calls
if ( targ->client ) {
targ->client->ps.stats[STAT_HEALTH] = targ->health;
}
}
}
void G_HomingMissile(gentity_t * ent)
{
gentity_t *target = NULL;
gentity_t *blip = NULL;
vec3_t dir, blipdir;
vec_t angle;
qboolean chaff;
//qboolean ignorechaff = qfalse;
const int HOMING_THINK_TIME = 60;
// explode after 15 seconds without a hit
if(ent->spawnTime + 15000 <= level.time)
{
G_ExplodeMissile(ent);
return;
}
/*
if(ent->parent->health <= 0)
{
ent->nextthink = level.time + 15000;
ent->think = G_ExplodeMissile;
return;
}
*/
/*
if(ent->parent && ent->parent->client)
{
ignorechaff = (ent->parent->client->ps.powerups[PW_ACCURACY] > 0);
}
*/
while((blip = G_FindRadius(blip, ent->r.currentOrigin, 2000)) != NULL)
{
#if 0
if(blip->s.weapon == WP_CHAFF)
{
if(ignorechaff)
{
continue;
}
chaff = qtrue;
}
else
#endif
{
chaff = qfalse;
if(blip->client == NULL)
continue;
if(blip == ent->parent)
continue;
if(blip->health <= 0)
continue;
if(blip->client->sess.sessionTeam >= TEAM_SPECTATOR)
continue;
if((g_gametype.integer == GT_TEAM || g_gametype.integer == GT_CTF) && OnSameTeam(blip, ent->parent))
continue;
}
if(!G_IsVisible(ent, blip->r.currentOrigin))
continue;
VectorSubtract(blip->r.currentOrigin, ent->r.currentOrigin, blipdir);
if(chaff)
{
VectorScale(blipdir, 0.5, blipdir);
}
if((target == NULL) || (VectorLength(blipdir) < VectorLength(dir)))
{
if(chaff)
{
VectorScale(blipdir, 2, blipdir);
}
angle = AngleBetweenVectors(ent->r.currentAngles, blipdir);
if(angle < 120.0f)
{
// We add it as our target
target = blip;
VectorCopy(blipdir, dir);
}
}
}
if(target == NULL)
{
ent->nextthink = level.time + HOMING_THINK_TIME; // + 10000;
ent->think = G_HomingMissile;
}
else
{
// for exact trajectory calculation, set current point to base.
VectorCopy(ent->r.currentOrigin, ent->s.pos.trBase);
VectorNormalize(dir);
// 0.5 is swing rate.
VectorScale(dir, 0.5, dir);
VectorAdd(dir, ent->r.currentAngles, dir);
// turn nozzle to target angle
VectorNormalize(dir);
VectorCopy(dir, ent->r.currentAngles);
// scale direction, put into trDelta
if(g_rocketAcceleration.integer)
{
// use acceleration instead of linear velocity
ent->s.pos.trType = TR_ACCELERATION;
ent->s.pos.trAcceleration = g_rocketAcceleration.value;
VectorScale(dir, g_rocketVelocity.value, ent->s.pos.trDelta);
}
else
{
ent->s.pos.trType = TR_LINEAR;
VectorScale(dir, g_rocketVelocity.value * 0.25, ent->s.pos.trDelta);
}
ent->s.pos.trTime = level.time;
SnapVector(ent->s.pos.trDelta); // save net bandwidth
ent->nextthink = level.time + HOMING_THINK_TIME; // decrease this value also makes fast swing
ent->think = G_HomingMissile;
//G_Printf("targeting %s\n", target->classname);
}
}
/*
================
G_HomingMissile
From XREAL r3036
================
*/
void G_HomingMissile(gentity_t * ent)
{
gentity_t *target = NULL;
gentity_t *blip = NULL;
vec3_t dir, blipdir;
vec_t angle;
const int HOMING_THINK_TIME = 60;
#ifdef TA_WEAPSYS // XREAL: spawnTime
// explode after 15 seconds without a hit
if (bg_projectileinfo[ent->s.weapon].timetolive != -1
&& ent->spawnTime + bg_projectileinfo[ent->s.weapon].timetolive <= level.time)
{
G_ExplodeMissile(ent);
return;
}
#endif
/*
if(ent->parent->health <= 0)
{
ent->nextthink = level.time + 15000;
ent->think = G_ExplodeMissile;
return;
}
*/
while((blip = G_FindRadius(blip, ent->r.currentOrigin, 2000)) != NULL)
{
if(blip->player == NULL)
continue;
if(blip == ent->parent)
continue;
if(blip->health <= 0)
continue;
if(blip->flags & FL_NOTARGET)
continue;
if(blip->player->sess.sessionTeam >= TEAM_SPECTATOR)
continue;
if(OnSameTeam(blip, ent->parent))
continue;
if(!G_IsVisible(ent->s.number, ent->r.currentOrigin, blip->r.currentOrigin))
continue;
VectorSubtract(blip->r.currentOrigin, ent->r.currentOrigin, blipdir);
if((target == NULL) || (VectorLength(blipdir) < VectorLength(dir)))
{
angle = AngleBetweenVectors(ent->r.currentAngles, blipdir);
if(angle < 120.0f)
{
// We add it as our target
target = blip;
VectorCopy(blipdir, dir);
}
}
}
if (target == NULL)
{
ent->nextthink = level.time + HOMING_THINK_TIME; // + 10000;
ent->think = G_HomingMissile;
}
else
{
// for exact trajectory calculation, set current point to base.
VectorCopy(ent->r.currentOrigin, ent->s.pos.trBase);
VectorNormalize(dir);
// 0.5 is swing rate.
VectorScale(dir, 0.5, dir);
VectorAdd(dir, ent->r.currentAngles, dir);
// turn nozzle to target angle
VectorNormalize(dir);
VectorCopy(dir, ent->r.currentAngles);
ent->s.pos.trTime = level.time;
G_SetMissileVelocity(ent, dir, ent->s.weapon);
ent->nextthink = level.time + HOMING_THINK_TIME; // decrease this value also makes fast swing
ent->think = G_HomingMissile;
//G_Printf("targeting %s\n", target->classname);
}
}
/*
================
G_MissileImpact
================
*/
void G_MissileImpact( gentity_t *ent, trace_t *trace ) {
gentity_t *other;
qboolean hitPlayer = qfalse;
#if defined MISSIONPACK && !defined TURTLEARENA // POWERS
vec3_t forward, impactpoint, bouncedir;
int eFlags;
#endif
#ifdef TA_WEAPSYS
qboolean damagedOther = qfalse;
#endif
other = &g_entities[trace->entityNum];
#if defined MISSIONPACK && !defined TURTLEARENA // POWERS
if ( other->takedamage ) {
#ifdef TA_WEAPSYS
if ( !bg_projectileinfo[ent->s.weapon].stickOnImpact )
#else
if ( ent->s.weapon != WP_PROX_LAUNCHER )
#endif
{
if ( other->player && other->player->invulnerabilityTime > level.time ) {
//
VectorCopy( ent->s.pos.trDelta, forward );
VectorNormalize( forward );
if (G_InvulnerabilityEffect( other, forward, ent->s.pos.trBase, impactpoint, bouncedir )) {
VectorCopy( bouncedir, trace->plane.normal );
eFlags = ent->s.eFlags & EF_BOUNCE_HALF;
ent->s.eFlags &= ~EF_BOUNCE_HALF;
G_BounceMissile( ent, trace );
ent->s.eFlags |= eFlags;
}
ent->target_ent = other;
return;
}
}
}
#endif
// impact damage
if (other->takedamage
#ifdef TA_WEAPSYS // stickOnImpact only damages once
&& !(ent->count & 2)
#endif
)
{
// FIXME: wrong damage direction?
if ( ent->damage ) {
vec3_t velocity;
if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {
g_entities[ent->r.ownerNum].player->accuracy_hits++;
hitPlayer = qtrue;
}
BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );
if ( VectorLength( velocity ) == 0 ) {
#ifdef IOQ3ZTM
VectorCopy(trace->plane.normal, velocity);
#else
velocity[2] = 1; // stepped on a grenade
#endif
}
#ifdef TA_WEAPSYS
damagedOther = G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
ent->s.origin, ent->damage,
0, ent->methodOfDeath);
#else
G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
ent->s.origin, ent->damage,
0, ent->methodOfDeath);
#endif
}
}
// check for bounce
if (
#ifdef TA_WEAPSYS
!damagedOther &&
#else
!other->takedamage &&
#endif
( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
#ifdef TA_WEAPSYS // Bounce missiles
// Die on Nth bounce
if (ent->s.modelindex2 > 0)
{
ent->s.modelindex2--;
if (ent->s.modelindex2 == 0)
{
// Kill missile
G_ExplodeMissile( ent );
return;
}
}
G_AddEvent( ent, EV_PROJECTILE_BOUNCE, DirToByte( trace->plane.normal ) );
ent->s.time2 = trace->surfaceFlags; // surface
#else
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
#endif
return;
}
#ifdef TA_WEAPSYS
if (bg_projectileinfo[ent->s.weapon].stickOnImpact != PSOI_NONE) {
vec3_t dir;
#ifndef TURTLEARENA
// if it's a player, stick it on to them (flag them and remove this entity)
if( bg_projectileinfo[ent->s.weapon].explosionType == PE_PROX &&
other->s.eType == ET_PLAYER && other->health > 0 )
{
ProximityMine_Player( ent, other );
return;
}
#endif
if (ent->count & 2) {
// Already stuck to wall
return;
}
ent->count |= 2;
// Don't stick to players or obelisk
if (other->s.eType == ET_PLAYER
#ifdef MISSIONPACK
|| (other->pain == ObeliskPain)
#endif
)
{
goto missileExplode;
}
// Don't stick to the entity that this missile just killed or other missiles
if ((damagedOther && other->health <= 0) || other->s.eType == ET_MISSILE)
{
// Don't remove projectile if it doesn't explode.
if (bg_projectileinfo[ent->s.weapon].explosionType == PE_NONE)
{
ent->s.pos.trType = TR_GRAVITY;
ent->count &= ~2;
return;
}
else
{
goto missileExplode;
}
}
if (bg_projectileinfo[ent->s.weapon].shootable)
VectorMA(trace->endpos, -8, trace->plane.normal, trace->endpos);
SnapVectorTowards( trace->endpos, ent->s.pos.trBase );
G_SetOrigin( ent, trace->endpos );
if (bg_projectileinfo[ent->s.weapon].stickOnImpact == PSOI_KEEP_ANGLES) {
#if 0
// convert direction of travel into axis
if ( VectorNormalize2( ent->s.pos.trDelta, dir ) == 0 ) {
dir[2] = 1;
}
// Set the angles
vectoangles( dir, ent->s.angles );
#else
VectorCopy(trace->plane.normal, dir);
#endif
} else {
VectorCopy(trace->plane.normal, dir);
vectoangles( dir, ent->s.angles );
switch (bg_projectileinfo[ent->s.weapon].stickOnImpact)
{
case PSOI_ANGLE_270:
ent->s.angles[0] += 270;
break;
case PSOI_ANGLE_180:
ent->s.angles[0] += 180;
break;
case PSOI_ANGLE_90:
// Maybe this is good for prox mines, but doesn't look good on my
// rocket or shuirkens...
ent->s.angles[0] += 90;
break;
case PSOI_ANGLE_0:
break;
}
}
// Save direction
VectorCopy(dir, ent->s.angles2);
ent->s.pos.trType = TR_STATIONARY;
VectorClear( ent->s.pos.trDelta );
G_AddEvent( ent, EV_PROJECTILE_STICK, DirToByte(trace->plane.normal) );
ent->s.time2 = trace->surfaceFlags; // surface
if (bg_projectileinfo[ent->s.weapon].explosionType == PE_PROX)
{
// When a BREAKABLE ET_MOVER is killed it drops the projectiles stuck to it,
// so don't setup the prox mine when it impact a surface if it already hit been setup.
if (ent->die != ProximityMine_Die)
{
ent->think = ProximityMine_Activate;
ent->nextthink = level.time + 2000;
ent->die = ProximityMine_Die;
}
}
else
{
ent->die = G_Missile_Die;
}
// link the prox mine to the other entity
ent->enemy = other;
VectorCopy(dir, ent->movedir);
VectorSet(ent->s.mins, -4, -4, -4);
VectorSet(ent->s.maxs, 4, 4, 4);
trap_LinkEntity(ent);
return;
}
#elif defined MISSIONPACK
if( ent->s.weapon == WP_PROX_LAUNCHER ) {
if( ent->s.pos.trType != TR_GRAVITY ) {
return;
}
// if it's a player, stick it on to them (flag them and remove this entity)
if( other->s.eType == ET_PLAYER && other->health > 0 ) {
ProximityMine_Player( ent, other );
return;
}
SnapVectorTowards( trace->endpos, ent->s.pos.trBase );
G_SetOrigin( ent, trace->endpos );
ent->s.pos.trType = TR_STATIONARY;
VectorClear( ent->s.pos.trDelta );
G_AddEvent( ent, EV_PROXIMITY_MINE_STICK, trace->surfaceFlags );
ent->think = ProximityMine_Activate;
ent->nextthink = level.time + 2000;
vectoangles( trace->plane.normal, ent->s.angles );
ent->s.angles[0] += 90;
// link the prox mine to the other entity
ent->enemy = other;
ent->die = ProximityMine_Die;
VectorCopy(trace->plane.normal, ent->movedir);
VectorSet(ent->s.mins, -4, -4, -4);
VectorSet(ent->s.maxs, 4, 4, 4);
trap_LinkEntity(ent);
return;
}
#endif
#ifdef TA_WEAPSYS
if (bg_projectileinfo[ent->s.weapon].grappling)
#else
if (!strcmp(ent->classname, "hook"))
#endif
{
gentity_t *nent;
vec3_t v;
nent = G_Spawn();
if ( other->takedamage && other->player ) {
G_AddEvent( nent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
nent->s.otherEntityNum = other->s.number;
v[0] = other->r.currentOrigin[0] + (other->s.mins[0] + other->s.maxs[0]) * 0.5;
v[1] = other->r.currentOrigin[1] + (other->s.mins[1] + other->s.maxs[1]) * 0.5;
v[2] = other->r.currentOrigin[2] + (other->s.mins[2] + other->s.maxs[2]) * 0.5;
} else {
VectorCopy(trace->endpos, v);
G_AddEvent( nent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
}
#ifdef IOQ3ZTM // IOQ3BUGFIX: Fix grapple wallmark/death-effect/debris (only tested with TA_WEAPSYS...)
nent->s.weapon = ent->s.weapon;
#endif
#ifdef TA_WEAPSYS
if (ent->parent)
nent->s.playerNum = ent->parent->s.number;
else
nent->s.playerNum = ENTITYNUM_NONE;
#endif
nent->s.weapon = ent->s.weapon;
ent->enemy = other;
ent->s.groundEntityNum = other->s.number;
SnapVectorTowards( v, ent->s.pos.trBase ); // save net bandwidth
nent->freeAfterEvent = qtrue;
// change over to a normal entity right at the point of impact
nent->s.eType = ET_GENERAL;
ent->s.eType = ET_GRAPPLE;
G_SetOrigin( ent, v );
G_SetOrigin( nent, v );
ent->think = Weapon_HookThink;
ent->nextthink = level.time + FRAMETIME;
ent->parent->player->ps.pm_flags |= PMF_GRAPPLE_PULL;
VectorCopy( ent->r.currentOrigin, ent->parent->player->ps.grapplePoint);
trap_LinkEntity( ent );
trap_LinkEntity( nent );
#ifdef TA_WEAPSYS
// Don't grapple to the entity if you just killed it.
if (damagedOther && other->health <= 0)
{
Weapon_HookFree(ent);
}
#endif
return;
}
#ifdef TA_WEAPSYS
missileExplode:
#endif
// is it cheaper in bandwidth to just remove this ent and create a new
// one, rather than changing the missile into the explosion?
if ( other->takedamage && other->player ) {
G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
ent->s.otherEntityNum = other->s.number;
} else if( trace->surfaceFlags & SURF_METALSTEPS ) {
G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( trace->plane.normal ) );
} else {
G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
}
#ifdef TA_WEAPSYS
if (ent->parent)
ent->s.playerNum = ent->parent->s.number;
else
ent->s.playerNum = ENTITYNUM_NONE;
#endif
ent->freeAfterEvent = qtrue;
// change over to a normal entity right at the point of impact
#ifndef TA_WEAPSYS // Must be after G_RadiusDamage
ent->s.eType = ET_GENERAL;
#endif
SnapVectorTowards( trace->endpos, ent->s.pos.trBase ); // save net bandwidth
G_SetOrigin( ent, trace->endpos );
// splash damage (doesn't apply to person directly hit)
if ( ent->splashDamage ) {
#ifdef TA_WEAPSYS
if( G_RadiusDamage( trace->endpos, ent, ent->parent, ent->splashDamage, ent->splashRadius,
other, ent->splashMethodOfDeath ) )
#else
if( G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius,
other, ent->splashMethodOfDeath ) )
#endif
{
if( !hitPlayer ) {
g_entities[ent->r.ownerNum].player->accuracy_hits++;
}
}
}
#ifdef TA_WEAPSYS
ent->s.eType = ET_GENERAL;
#endif
trap_LinkEntity( ent );
}
void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, const vec3_t in_dir, vec3_t point, int damage, int dflags, int mod ) {
gclient_t *client;
int take;
int save;
int knockback;
qboolean wasAlive;
hitRegion_t hr = HR_NUM_HITREGIONS;
int limbo_health;
limbo_health = FORCE_LIMBO_HEALTH;
if (!targ->takedamage) {
return;
}
// the intermission has already been qualified for, so don't
// allow any extra scoring
// CHRUKER: b024 - Don't do damage if at warmup and warmupdamage is set to 'None' and the target is a client.
if ( level.intermissionQueued || (cvars::gameState.ivalue != GS_PLAYING && match_warmupDamage.integer == 0 && targ->client)) {
return;
}
if ( !inflictor ) {
inflictor = &g_entities[ENTITYNUM_WORLD];
}
if ( !attacker ) {
attacker = &g_entities[ENTITYNUM_WORLD];
}
// Arnout: invisible entities can't be damaged
if( targ->entstate == STATE_INVISIBLE ||
targ->entstate == STATE_UNDERCONSTRUCTION ) {
return;
}
// xkan, 12/23/2002 - was the bot alive before applying any damage?
wasAlive = (targ->health > 0) ? qtrue : qfalse;
// Arnout: combatstate
if( targ->client && attacker && attacker->client && attacker != targ ) {
if( cvars::gameState.ivalue == GS_PLAYING ) {
if( !OnSameTeam( attacker, targ ) ) {
targ->client->combatState = (combatstate_t)( targ->client->combatState | (1<<COMBATSTATE_DAMAGERECEIVED) );
attacker->client->combatState = (combatstate_t)( attacker->client->combatState | (1<<COMBATSTATE_DAMAGEDEALT) );
}
}
}
// JPW NERVE
if ((targ->waterlevel >= 3) && (mod == MOD_FLAMETHROWER))
return;
// jpw
// shootable doors / buttons don't actually have any health
if ( targ->s.eType == ET_MOVER && !(targ->isProp) && !targ->scriptName) {
if ( targ->use && targ->moverState == MOVER_POS1 ) {
G_UseEntity( targ, inflictor, attacker );
}
return;
}
// TAT 11/22/2002
// In the old code, this check wasn't done for props, so I put that check back in to make props_statue properly work
// 4 means destructible
if ( targ->s.eType == ET_MOVER && (targ->spawnflags & 4) && !targ->isProp )
{
if( !G_WeaponIsExplosive( (meansOfDeath_t)mod ) ) {
return;
}
// check for team
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
} else if ( targ->s.eType == ET_EXPLOSIVE ) {
if( targ->parent && G_GetWeaponClassForMOD( (meansOfDeath_t)mod ) == 2 ) {
return;
}
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
if( G_GetWeaponClassForMOD( (meansOfDeath_t)mod ) < targ->constructibleStats.weaponclass ) {
return;
}
}
else if ( targ->s.eType == ET_MISSILE && targ->methodOfDeath == MOD_LANDMINE ) {
if( targ->s.modelindex2 ) {
if( G_WeaponIsExplosive( (meansOfDeath_t)mod ) ) {
mapEntityData_t *mEnt;
if((mEnt = G_FindMapEntityData(&mapEntityData[0], targ-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[0], mEnt );
}
if((mEnt = G_FindMapEntityData(&mapEntityData[1], targ-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[1], mEnt );
}
if( attacker && attacker->client ) {
AddScore( attacker, 1 );
}
G_ExplodeMissile(targ);
}
}
return;
} else if ( targ->s.eType == ET_CONSTRUCTIBLE ) {
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
if( G_GetWeaponClassForMOD( (meansOfDeath_t)mod ) < targ->constructibleStats.weaponclass ) {
return;
}
//bani - fix #238
if ( mod == MOD_DYNAMITE ) {
if( !( inflictor->etpro_misc_1 & 1 ) )
return;
}
}
client = targ->client;
if ( client ) {
if ( client->noclip || ( client->ps.powerups[PW_INVULNERABLE] && !( dflags & DAMAGE_JAY_NO_PROTECTION ))) {
return;
}
}
// check for godmode
if ( targ->flags & FL_GODMODE ) {
return;
}
// ugly-ass code but we do this to make in_dir read-only
vec3_t dir;
if ( !in_dir ) {
dflags |= DAMAGE_NO_KNOCKBACK;
} else {
VectorCopy( in_dir, dir );
VectorNormalize( dir );
}
knockback = damage;
if ( knockback > 200 ) {
knockback = 200;
}
if ( targ->flags & FL_NO_KNOCKBACK ) {
knockback = 0;
}
if ( dflags & DAMAGE_NO_KNOCKBACK ) {
knockback = 0;
} else if( dflags & DAMAGE_HALF_KNOCKBACK ) {
knockback = int( knockback * 0.5f );
}
// ydnar: set weapons means less knockback
if( client && (client->ps.weapon == WP_MORTAR_SET || client->ps.weapon == WP_MOBILE_MG42_SET) )
knockback = int( knockback * 0.5f );
if( targ->client && g_friendlyFire.integer && OnSameTeam(targ, attacker) ) {
knockback = 0;
}
// figure momentum add, even if the damage won't be taken
if ( knockback && targ->client ) {
vec3_t kvel;
float mass;
mass = 200;
VectorScale (dir, g_knockback.value * (float)knockback / mass, kvel);
VectorAdd (targ->client->ps.velocity, kvel, targ->client->ps.velocity);
// From NoQuarter, I'm not sure I need this
if ( attacker && attacker->client && ( targ->client->ps.groundEntityNum != ENTITYNUM_NONE || G_WeaponIsExplosive((meansOfDeath_t)mod) )){
targ->client->pmext.wasShoved = qtrue;
targ->client->pmext.shover = attacker - g_entities;
}
if (targ == attacker && !( mod != MOD_ROCKET &&
mod != MOD_GRENADE &&
mod != MOD_GRENADE_LAUNCHER &&
mod != MOD_DYNAMITE
&& mod != MOD_GPG40
&& mod != MOD_M7
&& mod != MOD_LANDMINE
))
{
targ->client->ps.velocity[2] *= 0.25;
}
// set the timer so that the other client can't cancel
// out the movement immediately
if ( !targ->client->ps.pm_time ) {
int t;
t = knockback * 2;
if ( t < 50 ) {
t = 50;
}
if ( t > 200 ) {
t = 200;
}
targ->client->ps.pm_time = t;
targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
}
}
// skip damage if friendly fire is disabled
if (!(dflags & DAMAGE_NO_PROTECTION)
&& targ != attacker
&& OnSameTeam( targ, attacker )
&& !g_friendlyFire.integer)
{
return;
}
if (damage < 1)
damage = 1;
take = damage;
save = 0;
if ( attacker->client && targ->client && targ != attacker && targ->health > 0 ) {
// Jaybird - Hitsounds
// vsay "hold your fire" on the first hit of a teammate
// only applies if the player has been hurt before
// and the match is not in warmup.
if( OnSameTeam( targ, attacker )) {
if(( !client->lasthurt_mod || client->lasthurt_client != attacker->s.number ) && cvars::gameState.ivalue == GS_PLAYING && ( targ->health - take ) > limbo_health ) {
if( client->sess.sessionTeam == TEAM_AXIS )
G_ClientSound( attacker, "sound/chat/axis/26a.wav" );
else
G_ClientSound( attacker, "sound/chat/allies/26a.wav" );
}
if (mod != MOD_GOOMBA && mod != MOD_POISON_SYRINGE) {
g_clientObjects[attacker->s.number].recordHit( AbstractHitVolume::ZONE_BODY, true );
}
} else {
if (mod != MOD_GOOMBA && mod != MOD_POISON_SYRINGE) {
g_clientObjects[attacker->s.number].recordHit( AbstractHitVolume::ZONE_BODY, false );
}
}
}
// adrenaline junkie!
if( targ->client && targ->client->ps.powerups[PW_ADRENALINE] ) {
take = int( take * 0.5f );
}
// save some from flak jacket
// Jaybird - engineer class carryover
if( targ->client && targ->client->sess.skill[SK_EXPLOSIVES_AND_CONSTRUCTION] >= 4 && ( targ->client->sess.playerType == PC_ENGINEER || ( cvars::bg_skills.ivalue & SBS_ENGI ))) {
if( mod == MOD_GRENADE ||
mod == MOD_GRENADE_LAUNCHER ||
mod == MOD_ROCKET ||
mod == MOD_GRENADE_PINEAPPLE ||
mod == MOD_MAPMORTAR ||
mod == MOD_MAPMORTAR_SPLASH ||
mod == MOD_EXPLOSIVE ||
mod == MOD_LANDMINE ||
mod == MOD_GPG40 ||
mod == MOD_M7 ||
mod == MOD_SATCHEL ||
mod == MOD_ARTY ||
mod == MOD_AIRSTRIKE ||
mod == MOD_DYNAMITE ||
mod == MOD_MORTAR ||
mod == MOD_PANZERFAUST ||
mod == MOD_MAPMORTAR ) {
take -= int( take * 0.5f );
}
}
#ifndef DEBUG_STATS
if ( g_debugDamage.integer )
#endif
{
G_Printf( "client:%i health:%i damage:%i mod:%s\n", targ->s.number, targ->health, take, modNames[mod] );
}
if( targ && targ->client && attacker && attacker->client && targ != attacker && targ->health > 0 && OnSameTeam( targ, attacker ) && g_friendlyFire.integer == 2 && IsReflectable( mod )) {
int ffDamage;
// Percentage based reflect
ffDamage = int( take * g_reflectFriendlyFire.value / 100.f );
if( ffDamage <= 0 ) {
ffDamage = 0;
}
attacker->health -= ffDamage;
// Give them pain!
attacker->client->damage_blood += take;
attacker->client->damage_knockback += knockback;
// Set the lasthurt stuff so hitsounds do not replay
targ->client->lasthurt_mod = mod;
targ->client->lasthurt_client = attacker - g_entities;
// Kill the player if necessary
if( attacker->health <= 0 ) {
attacker->deathType = MOD_REFLECTED_FF;
attacker->enemy = attacker;
if( attacker->die ) {
attacker->die( attacker, attacker, attacker, ffDamage, MOD_REFLECTED_FF );
}
}
}
// add to the damage inflicted on a player this frame
// the total will be turned into screen blends and view angle kicks
// at the end of the frame
if ( client ) {
if ( attacker ) {
client->ps.persistant[PERS_ATTACKER] = attacker->s.number;
} else {
client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD;
}
client->damage_blood += take;
client->damage_knockback += knockback;
if ( dir ) {
VectorCopy ( dir, client->damage_from );
client->damage_fromWorld = qfalse;
} else {
VectorCopy ( targ->r.currentOrigin, client->damage_from );
client->damage_fromWorld = qtrue;
}
}
// See if it's the player hurting the emeny flag carrier
// Team_CheckHurtCarrier(targ, attacker);
if (targ->client) {
// set the last client who damaged the target
targ->client->lasthurt_client = attacker->s.number;
targ->client->lasthurt_mod = mod;
targ->client->lasthurt_time = level.time;
}
// do the damage
if( take ) {
targ->health -= take;
// Gordon: don't ever gib POWS
if( ( targ->health <= 0 ) && ( targ->r.svFlags & SVF_POW ) ) {
targ->health = -1;
}
// Ridah, can't gib with bullet weapons (except VENOM)
// Arnout: attacker == inflictor can happen in other cases as well! (movers trying to gib things)
//if ( attacker == inflictor && targ->health <= GIB_HEALTH) {
if( targ->health <= GIB_HEALTH ) {
if( !G_WeaponIsExplosive( (meansOfDeath_t)mod ) ) {
targ->health = GIB_HEALTH + 1;
}
}
if( g_damagexp.integer && client && G_GetTeamFromEntity( inflictor ) != G_GetTeamFromEntity( targ )) {
// Jaybird - give them some per hit
// They get 1 XP per 50 damage, so multiple .02 * take
int skill = G_SkillForMOD( mod );
if( skill >= 0 )
G_AddSkillPoints( attacker, (skillType_t)skill, take * .02 );
}
// JPW NERVE overcome previous chunk of code for making grenades work again
// if ((take > 190)) // 190 is greater than 2x mauser headshot, so headshots don't gib
// Arnout: only player entities! messes up ents like func_constructibles and func_explosives otherwise
if( ( (targ->s.number < MAX_CLIENTS) && (take > 190) ) && !(targ->r.svFlags & SVF_POW) ) {
targ->health = GIB_HEALTH - 1;
}
if( targ->s.eType == ET_MOVER && !Q_stricmp( targ->classname, "script_mover" ) ) {
targ->s.dl_intensity = int( 255.f * (targ->health / (float)targ->count) ); // send it to the client
}
//G_Printf("health at: %d\n", targ->health);
if( targ->health <= 0 ) {
if( client && !wasAlive ) {
targ->flags |= FL_NO_KNOCKBACK;
// OSP - special hack to not count attempts for body gibbage
if( targ->client->ps.pm_type == PM_DEAD ) {
G_addStats(targ, attacker, take, mod);
}
if( (targ->health < FORCE_LIMBO_HEALTH) && (targ->health > GIB_HEALTH) ) {
limbo(targ, qtrue);
}
// xkan, 1/13/2003 - record the time we died.
if (!client->deathTime)
client->deathTime = level.time;
//bani - #389
if( targ->health <= GIB_HEALTH ) {
GibEntity( targ, 0 );
}
} else {
targ->sound1to2 = hr;
targ->sound2to1 = mod;
targ->sound2to3 = (dflags & DAMAGE_RADIUS) ? 1 : 0;
if( client ) {
if( G_GetTeamFromEntity( inflictor ) != G_GetTeamFromEntity( targ ) ) {
G_AddKillSkillPoints( attacker, (meansOfDeath_t)mod, hr, (qboolean)(dflags & DAMAGE_RADIUS) );
}
}
if( targ->health < -999 ) {
targ->health = -999;
}
targ->enemy = attacker;
targ->deathType = (meansOfDeath_t)mod;
// Ridah, mg42 doesn't have die func (FIXME)
if( targ->die ) {
// Kill the entity. Note that this funtion can set ->die to another
// function pointer, so that next time die is applied to the dead body.
targ->die( targ, inflictor, attacker, take, mod );
// OSP - kill stats in player_die function
}
if( targ->s.eType == ET_MOVER && !Q_stricmp( targ->classname, "script_mover" ) && (targ->spawnflags & 8) ) {
return; // reseructable script mover doesn't unlink itself but we don't want a second death script to be called
}
// if we freed ourselves in death function
if (!targ->inuse)
return;
// RF, entity scripting
if ( targ->health <= 0) { // might have revived itself in death function
if( targ->r.svFlags & SVF_BOT ) {
// Removed
} else if( ( targ->s.eType != ET_CONSTRUCTIBLE && targ->s.eType != ET_EXPLOSIVE ) ||
( targ->s.eType == ET_CONSTRUCTIBLE && !targ->desstages ) ) { // call manually if using desstages
G_Script_ScriptEvent( targ, "death", "" );
}
}
}
} else if ( targ->pain ) {
if (dir) { // Ridah, had to add this to fix NULL dir crash
VectorCopy (dir, targ->rotate);
VectorCopy (point, targ->pos3); // this will pass loc of hit
} else {
VectorClear( targ->rotate );
VectorClear( targ->pos3 );
}
targ->pain (targ, attacker, take, point);
} else {
// OSP - update weapon/dmg stats
G_addStats(targ, attacker, take, mod);
// OSP
}
// RF, entity scripting
G_Script_ScriptEvent( targ, "pain", va("%d %d", targ->health, targ->health+take) );
// RF, record bot pain
if (targ->s.number < level.maxclients)
{
// notify omni-bot framework
Bot_Event_TakeDamage(targ-g_entities, attacker);
}
// Ridah, this needs to be done last, incase the health is altered in one of the event calls
// Jaybird - playdead check
if ( targ->client ) {
targ->client->ps.stats[STAT_HEALTH] = targ->health;
}
// Cheap way to ID inflictor entity as poison smoke.
if (inflictor->poisonGasAlarm && mod == MOD_POISON_GAS && targ->health >= 0)
G_AddEvent(targ, EV_COUGH, 0);
}
}
// Dini, Note, this is where damage etc is dealt out!
void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod ) {
gclient_t *client;
int take;
int save;
int knockback;
qboolean headShot;
qboolean wasAlive;
hitRegion_t hr = HR_NUM_HITREGIONS;
if (!targ->takedamage) {
return;
}
// the intermission has already been qualified for, so don't
// allow any extra scoring
// CHRUKER: b024 - Don't do damage if at warmup and warmupdamage is set to 'None' and the target is a client.
if ( level.intermissionQueued || (g_gamestate.integer != GS_PLAYING && targ->client)) {
return;
}
if ( !inflictor ) {
inflictor = &g_entities[ENTITYNUM_WORLD];
}
if ( !attacker ) {
attacker = &g_entities[ENTITYNUM_WORLD];
}
// Arnout: invisible entities can't be damaged
if( targ->entstate == STATE_INVISIBLE ||
targ->entstate == STATE_UNDERCONSTRUCTION ) {
return;
}
// xkan, 12/23/2002 - was the bot alive before applying any damage?
wasAlive = (targ->health > 0);
// Arnout: combatstate
if( targ->client && attacker && attacker->client && attacker != targ ) {
if( g_gamestate.integer == GS_PLAYING ) {
if( !OnSameTeam( attacker, targ ) ) {
targ->client->combatState |= (1<<COMBATSTATE_DAMAGERECEIVED);
attacker->client->combatState |= (1<<COMBATSTATE_DAMAGEDEALT);
}
}
}
// JPW NERVE
if ((targ->waterlevel >= 3) && (mod == MOD_FLAMETHROWER))
return;
// jpw
// shootable doors / buttons don't actually have any health
if ( targ->s.eType == ET_MOVER && !(targ->isProp) && !targ->scriptName) {
if ( targ->use && targ->moverState == MOVER_POS1 ) {
G_UseEntity( targ, inflictor, attacker );
}
return;
}
// 4 means destructible
if ( targ->s.eType == ET_MOVER && (targ->spawnflags & 4) && !targ->isProp )
{
if( !G_WeaponIsExplosive( mod ) ) {
return;
}
// check for team
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
} else if ( targ->s.eType == ET_EXPLOSIVE ) {
if( targ->parent && G_GetWeaponClassForMOD( mod ) == 2 ) {
return;
}
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
if( G_GetWeaponClassForMOD( mod ) < targ->constructibleStats.weaponclass ) {
return;
}
}
else if ( targ->s.eType == ET_MISSILE && targ->methodOfDeath == MOD_LANDMINE ) {
if( targ->s.modelindex2 ) {
if( G_WeaponIsExplosive( mod ) ) {
mapEntityData_t *mEnt;
if((mEnt = G_FindMapEntityData(&mapEntityData[0], targ-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[0], mEnt );
}
if((mEnt = G_FindMapEntityData(&mapEntityData[1], targ-g_entities)) != NULL) {
G_FreeMapEntityData( &mapEntityData[1], mEnt );
}
if( attacker && attacker->client ) {
AddScore( attacker, 1 );
}
G_ExplodeMissile(targ);
}
}
return;
} else if ( targ->s.eType == ET_CONSTRUCTIBLE ) {
if( G_GetTeamFromEntity( inflictor ) == G_GetTeamFromEntity( targ ) ) {
return;
}
if( G_GetWeaponClassForMOD( mod ) < targ->constructibleStats.weaponclass ) {
return;
}
//bani - fix #238
if ( mod == MOD_DYNAMITE ) {
if( !( inflictor->etpro_misc_1 & 1 ) )
return;
}
}
client = targ->client;
// Dini, Note, Noclip..
if ( client ) {
if ( client->noclip || client->ps.powerups[PW_INVULNERABLE] ) {
return;
}
}
// check for godmode
if ( targ->flags & FL_GODMODE ) {
return;
}
if ( !dir ) {
dflags |= DAMAGE_NO_KNOCKBACK;
} else {
VectorNormalize(dir);
}
// Only do knockback to yourself
if (attacker->client == targ->client)
knockback = 1;
else
knockback = 0;
// figure momentum add, even if the damage won't be taken
if ( knockback && targ->client ) {
vec3_t kvel;
int knock;
if (mod == MOD_PANZERFAUST)
knock = 500;
else
knock = 1000;
// Dini, Note, Fix this sometime..
VectorScale (dir, knock, kvel);
VectorAdd (targ->client->ps.velocity, kvel, targ->client->ps.velocity);
if (targ == attacker && !( mod != MOD_ROCKET &&
mod != MOD_GRENADE &&
mod != MOD_GRENADE_LAUNCHER &&
mod != MOD_DYNAMITE
&& mod != MOD_GPG40
&& mod != MOD_M7
&& mod != MOD_LANDMINE
))
{
targ->client->ps.velocity[2] *= 0.25;
}
// set the timer so that the other client can't cancel
// out the movement immediately
if ( !targ->client->ps.pm_time ) {
int t;
t = knockback * 2;
if ( t < 50 ) {
t = 50;
}
if ( t > 200 ) {
t = 200;
}
targ->client->ps.pm_time = t;
targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
}
}
// check for completely getting out of the damage
if ( !(dflags & DAMAGE_NO_PROTECTION) ) {
// Dini, disable damage taking for players, aka if they're on a team
if (OnAnyTeam (targ, attacker) && !tjg_damage.integer)
return;
// if TF_NO_FRIENDLY_FIRE is set, don't do damage to the target
// if the attacker was on the same team
if ( targ != attacker && OnSameTeam (targ, attacker) ) {
if ( (g_gamestate.integer != GS_PLAYING)) {
return;
}
else if (!g_friendlyFire.integer) {
return;
}
}
}
// add to the attacker's hit counter
if ( attacker->client && targ != attacker && targ->health > 0 ) {
if ( OnSameTeam( targ, attacker ) ) {
attacker->client->ps.persistant[PERS_HITS] -= damage;
} else {
attacker->client->ps.persistant[PERS_HITS] += damage;
}
}
if ( damage < 1 ) {
damage = 1;
}
take = damage;
save = 0;
headShot = IsHeadShot(targ, dir, point, mod);
if ( headShot ) {
if( take * 2 < 50 ) // head shots, all weapons, do minimum 50 points damage
take = 50;
else
take *= 2; // sniper rifles can do full-kill (and knock into limbo)
if( dflags & DAMAGE_DISTANCEFALLOFF ) {
vec_t dist;
vec3_t shotvec;
float scale;
VectorSubtract( point, muzzleTrace, shotvec );
dist = VectorLength( shotvec );
// zinx - start at 100% at 1500 units (and before),
// and go to 20% at 2500 units (and after)
// 1500 to 2500 -> 0.0 to 1.0
scale = (dist - 1500.f) / (2500.f - 1500.f);
// 0.0 to 1.0 -> 0.0 to 0.8
scale *= 0.8f;
// 0.0 to 0.8 -> 1.0 to 0.2
scale = 1.0f - scale;
// And, finally, cap it.
if (scale > 1.0f) scale = 1.0f;
else if (scale < 0.2f) scale = 0.2f;
take *= scale;
}
if( !(targ->client->ps.eFlags & EF_HEADSHOT) ) { // only toss hat on first headshot
G_AddEvent( targ, EV_LOSE_HAT, DirToByte(dir) );
if( mod != MOD_K43_SCOPE &&
mod != MOD_GARAND_SCOPE ) {
take *= .8f; // helmet gives us some protection
}
}
targ->client->ps.eFlags |= EF_HEADSHOT;
// OSP - Record the headshot
if(client && attacker && attacker->client
#ifndef DEBUG_STATS
&& attacker->client->sess.sessionTeam != targ->client->sess.sessionTeam
#endif
) {
G_addStatsHeadShot(attacker, mod);
}
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Head Shot\n\"\n");
}
G_LogRegionHit( attacker, HR_HEAD );
hr = HR_HEAD;
} else if ( IsLegShot(targ, dir, point, mod) ) {
G_LogRegionHit( attacker, HR_LEGS );
hr = HR_LEGS;
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Leg Shot\n\"\n");
}
} else if ( IsArmShot(targ, attacker, point, mod) ) {
G_LogRegionHit( attacker, HR_ARMS );
hr = HR_ARMS;
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Arm Shot\n\"\n");
}
} else if (targ->client && targ->health > 0 && IsHeadShotWeapon( mod ) ) {
G_LogRegionHit( attacker, HR_BODY );
hr = HR_BODY;
if( g_debugBullets.integer ) {
trap_SendServerCommand( attacker-g_entities, "print \"Body Shot\n\"\n");
}
}
#ifndef DEBUG_STATS
if ( g_debugDamage.integer )
#endif
{
G_Printf( "client:%i health:%i damage:%i mod:%s\n", targ->s.number, targ->health, take, modNames[mod] );
}
// add to the damage inflicted on a player this frame
// the total will be turned into screen blends and view angle kicks
// at the end of the frame
if ( client ) {
if ( attacker ) {
client->ps.persistant[PERS_ATTACKER] = attacker->s.number;
} else {
client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD;
}
client->damage_blood += take;
// Dini, removed for now.
//client->damage_knockback += knockback;
if ( dir ) {
VectorCopy ( dir, client->damage_from );
client->damage_fromWorld = qfalse;
} else {
VectorCopy ( targ->r.currentOrigin, client->damage_from );
client->damage_fromWorld = qtrue;
}
}
// See if it's the player hurting the emeny flag carrier
// Team_CheckHurtCarrier(targ, attacker);
if (targ->client) {
// set the last client who damaged the target
targ->client->lasthurt_client = attacker->s.number;
targ->client->lasthurt_mod = mod;
}
// do the damage
if( take ) {
targ->health -= take;
// Gordon: don't ever gib POWS
if( ( targ->health <= 0 ) && ( targ->r.svFlags & SVF_POW ) ) {
targ->health = -1;
}
// Ridah, can't gib with bullet weapons (except VENOM)
// Arnout: attacker == inflictor can happen in other cases as well! (movers trying to gib things)
//if ( attacker == inflictor && targ->health <= GIB_HEALTH) {
/*if( targ->health <= GIB_HEALTH ) {
if( !G_WeaponIsExplosive( mod ) ) {
targ->health = GIB_HEALTH + 1;
}
}*/
// JPW NERVE overcome previous chunk of code for making grenades work again
// if ((take > 190)) // 190 is greater than 2x mauser headshot, so headshots don't gib
// Arnout: only player entities! messes up ents like func_constructibles and func_explosives otherwise
if( ( (targ->s.number < MAX_CLIENTS) && (take > 190) ) && !(targ->r.svFlags & SVF_POW) ) {
targ->health = GIB_HEALTH - 1;
}
if( targ->s.eType == ET_MOVER && !Q_stricmp( targ->classname, "script_mover" ) ) {
targ->s.dl_intensity = 255.f * (targ->health / (float)targ->count); // send it to the client
}
//G_Printf("health at: %d\n", targ->health);
if( targ->health <= 0 ) {
if( client && !wasAlive ) {
targ->flags |= FL_NO_KNOCKBACK;
// OSP - special hack to not count attempts for body gibbage
if( targ->client->ps.pm_type == PM_DEAD ) {
G_addStats(targ, attacker, take, mod);
}
/*if( (targ->health < FORCE_LIMBO_HEALTH) && (targ->health > GIB_HEALTH) ) {
limbo(targ, qtrue);
}*/
if (targ->health <= 0 && targ->s.number < MAX_CLIENTS && !(targ->r.svFlags & SVF_POW))
{
targ->health = GIB_HEALTH - 1;
}
// xkan, 1/13/2003 - record the time we died.
if (!client->deathTime)
client->deathTime = level.time;
} else {
targ->sound1to2 = hr;
targ->sound2to1 = mod;
targ->sound2to3 = (dflags & DAMAGE_RADIUS) ? 1 : 0;
if( client ) {
if( G_GetTeamFromEntity( inflictor ) != G_GetTeamFromEntity( targ ) ) {
G_AddKillSkillPoints( attacker, mod, hr, (dflags & DAMAGE_RADIUS) );
}
}
if( targ->health < -999 ) {
targ->health = -999;
}
targ->enemy = attacker;
targ->deathType = mod;
// Ridah, mg42 doesn't have die func (FIXME)
if( targ->die ) {
// Kill the entity. Note that this funtion can set ->die to another
// function pointer, so that next time die is applied to the dead body.
targ->die( targ, inflictor, attacker, take, mod );
// OSP - kill stats in player_die function
}
if( targ->s.eType == ET_MOVER && !Q_stricmp( targ->classname, "script_mover" ) && (targ->spawnflags & 8) ) {
return; // reseructable script mover doesn't unlink itself but we don't want a second death script to be called
}
// if we freed ourselves in death function
if (!targ->inuse)
return;
// RF, entity scripting
if ( targ->health <= 0) { // might have revived itself in death function
if( ( targ->s.eType != ET_CONSTRUCTIBLE && targ->s.eType != ET_EXPLOSIVE ) ||
( targ->s.eType == ET_CONSTRUCTIBLE && !targ->desstages ) ) { // call manually if using desstages
G_Script_ScriptEvent( targ, "death", "" );
}
}
}
} else if ( targ->pain ) {
if (dir) { // Ridah, had to add this to fix NULL dir crash
VectorCopy (dir, targ->rotate);
VectorCopy (point, targ->pos3); // this will pass loc of hit
} else {
VectorClear( targ->rotate );
VectorClear( targ->pos3 );
}
targ->pain (targ, attacker, take, point);
} else {
// OSP - update weapon/dmg stats
G_addStats(targ, attacker, take, mod);
// OSP
}
// RF, entity scripting
G_Script_ScriptEvent( targ, "pain", va("%d %d", targ->health, targ->health+take) );
// Ridah, this needs to be done last, incase the health is altered in one of the event calls
if ( targ->client ) {
targ->client->ps.stats[STAT_HEALTH] = targ->health;
}
}
}
