qboolean ShotgunPellet( vec3_t start, vec3_t end, gentity_t *ent ) {
trace_t tr;
int damage, i, passent;
gentity_t *traceEnt;
#ifdef MISSIONPACK
vec3_t impactpoint, bouncedir;
#endif
vec3_t tr_start, tr_end;
passent = ent->s.number;
VectorCopy( start, tr_start );
VectorCopy( end, tr_end );
for (i = 0; i < 10; i++) {
trap_Trace (&tr, tr_start, NULL, NULL, tr_end, passent, MASK_SHOT);
traceEnt = &g_entities[ tr.entityNum ];
// send bullet impact
if ( tr.surfaceFlags & SURF_NOIMPACT ) {
return qfalse;
}
if ( traceEnt->takedamage) {
damage = DEFAULT_SHOTGUN_DAMAGE * s_quadFactor;
#ifdef MISSIONPACK
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
G_BounceProjectile( tr_start, impactpoint, bouncedir, tr_end );
VectorCopy( impactpoint, tr_start );
// the player can hit him/herself with the bounced rail
passent = ENTITYNUM_NONE;
}
else {
VectorCopy( tr.endpos, tr_start );
passent = traceEnt->s.number;
}
continue;
}
else {
G_Damage( traceEnt, ent, ent, forward, tr.endpos,
damage, 0, MOD_SHOTGUN);
if( LogAccuracyHit( traceEnt, ent ) ) {
return qtrue;
}
}
#else
G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, 0, MOD_SHOTGUN);
if( LogAccuracyHit( traceEnt, ent ) ) {
return qtrue;
}
#endif
}
return qfalse;
}
return qfalse;
}
void Weapon_LightningFire( gentity_t *ent ) {
trace_t tr;
vec3_t end;
#if 1
vec3_t impactpoint, bouncedir;
#endif
gentity_t *traceEnt, *tent;
int damage, i, passent;
damage = 8 * s_quadFactor;
passent = ent->s.number;
for (i = 0; i < 10; i++) {
VectorMA( muzzle, LIGHTNING_RANGE, forward, end );
trap_Trace( &tr, muzzle, NULL, NULL, end, passent, MASK_SHOT );
#if 1
// if not the first trace (the lightning bounced of an invulnerability sphere)
if (i) {
// add bounced off lightning bolt temp entity
// the first lightning bolt is a cgame only visual
//
tent = G_TempEntity( muzzle, EV_LIGHTNINGBOLT );
VectorCopy( tr.endpos, end );
SnapVector( end );
VectorCopy( end, tent->s.origin2 );
}
#endif
if ( tr.entityNum == ENTITYNUM_NONE ) {
return;
}
traceEnt = &g_entities[ tr.entityNum ];
if ( traceEnt->takedamage) {
#if 1
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
VectorCopy( impactpoint, muzzle );
VectorSubtract( end, impactpoint, forward );
VectorNormalize(forward);
// the player can hit him/herself with the bounced lightning
passent = ENTITYNUM_NONE;
}
else {
VectorCopy( tr.endpos, muzzle );
passent = traceEnt->s.number;
}
continue;
}
else {
G_Damage( traceEnt, ent, ent, forward, tr.endpos,
damage, 0, MOD_LIGHTNING);
}
#else
G_Damage( traceEnt, ent, ent, forward, tr.endpos,
damage, 0, MOD_LIGHTNING);
#endif
}
if ( traceEnt->takedamage && traceEnt->client ) {
tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );
tent->s.otherEntityNum = traceEnt->s.number;
tent->s.eventParm = DirToByte( tr.plane.normal );
tent->s.weapon = ent->s.weapon;
if( LogAccuracyHit( traceEnt, ent ) ) {
ent->client->accuracy_hits++;
}
} else if ( !( tr.surfaceFlags & SURF_NOIMPACT ) ) {
tent = G_TempEntity( tr.endpos, EV_MISSILE_MISS );
tent->s.eventParm = DirToByte( tr.plane.normal );
}
break;
}
}
void Bullet_Fire (gentity_t *ent, float spread, int damage ) {
trace_t tr;
vec3_t end;
#if 1
vec3_t impactpoint, bouncedir;
#endif
float r, f, d;
float u;
gentity_t *tent;
gentity_t *traceEnt;
int i, passent;
vec3_t forward, right, up;
AngleVectors (ent->client->ps.viewangles, forward, right, up);
CalcMuzzlePoint ( ent, forward, right, up, muzzle );
ent->client->accuracy_shots++;
f = ((float)(ent->client->accuracy_shots % SPIRAL_SIZE)) / SPIRAL_SIZE; // 0 >= f >= 1
d = (f+(1/SPIRAL_SIZE)) * 2.0 * M_PI;
damage *= s_quadFactor;
//Com_Printf("f: %f, d: %f\n, a: %i", f, d, ent->client->accuracy_shots);
u = sin(d) * (f * spread);
r = cos(d) * (f * spread);
//Com_Printf("end1 : [%f, %f, %f]\n", end[0], end[1], end[2]);
VectorMA (muzzle, 8192, forward, end);
//Com_Printf("end2 : [%f, %f, %f]\n", end[0], end[1], end[2]);
//Com_Printf("right : [%f, %f, %f]\n", right[0], right[1], right[2]);
VectorMA (end, r, right, end);
//Com_Printf("end3 : [%f, %f, %f]\n", end[0], end[1], end[2]);
//Com_Printf("up : [%f, %f, %f]\n", up[0], up[1], up[2]);
VectorMA (end, u, up, end);
//Com_Printf("end4 : [%f, %f, %f]\n", end[0], end[1], end[2]);
passent = ent->s.number;
for (i = 0; i < 10; i++) {
trap_Trace (&tr, muzzle, NULL, NULL, end, passent, MASK_SHOT);
if ( tr.surfaceFlags & SURF_NOIMPACT ) {
return;
}
traceEnt = &g_entities[ tr.entityNum ];
// snap the endpos to integers, but nudged towards the line
SnapVectorTowards( tr.endpos, muzzle );
// send bullet impact
if ( traceEnt->takedamage && traceEnt->client ) {
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );
tent->s.eventParm = traceEnt->s.number;
if( LogAccuracyHit( traceEnt, ent ) ) {
ent->client->accuracy_hits++;
}
} else {
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_WALL );
tent->s.eventParm = DirToByte( tr.plane.normal );
}
tent->s.otherEntityNum = ent->s.number;
if ( traceEnt->takedamage) {
#if 1
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
VectorCopy( impactpoint, muzzle );
// the player can hit him/herself with the bounced rail
passent = ENTITYNUM_NONE;
}
else {
VectorCopy( tr.endpos, muzzle );
passent = traceEnt->s.number;
}
continue;
}
else {
#endif
G_Damage( traceEnt, ent, ent, forward, tr.endpos,
damage, 0, MOD_MACHINEGUN);
#if 1
}
#endif
}
break;
}
}
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 asave;
int knockback;
int max;
#ifdef MISSIONPACK
vec3_t bouncedir, impactpoint;
#endif
if (!targ->takedamage) {
return;
}
// the intermission has allready been qualified for, so don't
// allow any extra scoring
if ( level.intermissionQueued ) {
return;
}
#ifdef MISSIONPACK
if ( targ->client && mod != MOD_JUICED) {
if ( targ->client->invulnerabilityTime > level.time) {
if ( dir && point ) {
G_InvulnerabilityEffect( targ, dir, point, impactpoint, bouncedir );
}
return;
}
}
#endif
if ( !inflictor ) {
inflictor = &g_entities[ENTITYNUM_WORLD];
}
if ( !attacker ) {
attacker = &g_entities[ENTITYNUM_WORLD];
}
// shootable doors / buttons don't actually have any health
if ( targ->s.eType == ET_MOVER ) {
if ( targ->use && targ->moverState == MOVER_POS1 ) {
targ->use( targ, inflictor, attacker );
}
return;
}
#ifdef MISSIONPACK
if( g_gametype.integer == GT_OBELISK && CheckObeliskAttack( targ, attacker ) ) {
return;
}
#endif
// reduce damage by the attacker's handicap value
// unless they are rocket jumping
if ( attacker->client && attacker != targ ) {
max = attacker->client->ps.stats[STAT_MAX_HEALTH];
#ifdef MISSIONPACK
if( bg_itemlist[attacker->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
max /= 2;
}
#endif
damage = damage * max / 100;
}
client = targ->client;
if ( client ) {
if ( client->noclip ) {
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;
}
// 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);
// 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
#ifdef MISSIONPACK
if ( mod != MOD_JUICED && targ != attacker && !(dflags & DAMAGE_NO_TEAM_PROTECTION) && OnSameTeam (targ, attacker) ) {
#else
if ( targ != attacker && OnSameTeam (targ, attacker) ) {
#endif
if ( !g_friendlyFire.integer ) {
return;
}
}
#ifdef MISSIONPACK
if (mod == MOD_PROXIMITY_MINE) {
if (inflictor && inflictor->parent && OnSameTeam(targ, inflictor->parent)) {
return;
}
if (targ == attacker) {
return;
}
}
#endif
// check for godmode
if ( targ->flags & FL_GODMODE ) {
return;
}
}
// battlesuit protects from all radius damage (but takes knockback)
// and protects 50% against all damage
if ( client && client->ps.powerups[PW_BATTLESUIT] ) {
G_AddEvent( targ, EV_POWERUP_BATTLESUIT, 0 );
if ( ( dflags & DAMAGE_RADIUS ) || ( mod == MOD_FALLING ) ) {
return;
}
damage *= 0.5;
}
// add to the attacker's hit counter (if the target isn't a general entity like a prox mine)
if ( attacker->client && client
&& targ != attacker && targ->health > 0
&& targ->s.eType != ET_MISSILE
&& targ->s.eType != ET_GENERAL) {
if ( OnSameTeam( targ, attacker ) ) {
attacker->client->ps.persistant[PERS_HITS]--;
} else {
attacker->client->ps.persistant[PERS_HITS]++;
}
attacker->client->ps.persistant[PERS_ATTACKEE_ARMOR] = (targ->health<<8)|(client->ps.stats[STAT_ARMOR]);
}
// always give half damage if hurting self
// calculated after knockback, so rocket jumping works
if ( targ == attacker) {
damage *= 0.5;
}
if ( damage < 1 ) {
damage = 1;
}
take = damage;
save = 0;
// save some from armor
asave = CheckArmor (targ, take, dflags);
take -= asave;
if ( g_debugDamage.integer ) {
G_Printf( "%i: client:%i health:%i damage:%i armor:%i\n", level.time, targ->s.number,
targ->health, take, asave );
}
// 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_armor += asave;
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
#ifdef MISSIONPACK
if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_1FCTF ) {
#else
if( g_gametype.integer == GT_CTF) {
#endif
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 = targ->health - take;
if ( targ->client ) {
targ->client->ps.stats[STAT_HEALTH] = targ->health;
}
if ( targ->health <= 0 ) {
if ( client )
targ->flags |= FL_NO_KNOCKBACK;
if (targ->health < -999)
targ->health = -999;
targ->enemy = attacker;
targ->die (targ, inflictor, attacker, take, mod);
return;
} else if ( targ->pain ) {
targ->pain (targ, attacker, take);
}
}
}
/*
============
CanDamage
Returns qtrue if the inflictor can directly damage the target. Used for
explosions and melee attacks.
============
*/
qboolean CanDamage (gentity_t *targ, vec3_t origin) {
vec3_t dest;
trace_t tr;
vec3_t midpoint;
// use the midpoint of the bounds instead of the origin, because
// bmodels may have their origin is 0,0,0
VectorAdd (targ->r.absmin, targ->r.absmax, midpoint);
VectorScale (midpoint, 0.5, midpoint);
VectorCopy (midpoint, dest);
trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (tr.fraction == 1.0 || tr.entityNum == targ->s.number)
return qtrue;
// this should probably check in the plane of projection,
// rather than in world coordinate, and also include Z
VectorCopy (midpoint, dest);
dest[0] += 15.0;
dest[1] += 15.0;
trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (tr.fraction == 1.0)
return qtrue;
VectorCopy (midpoint, dest);
dest[0] += 15.0;
dest[1] -= 15.0;
trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (tr.fraction == 1.0)
return qtrue;
VectorCopy (midpoint, dest);
dest[0] -= 15.0;
dest[1] += 15.0;
trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (tr.fraction == 1.0)
return qtrue;
VectorCopy (midpoint, dest);
dest[0] -= 15.0;
dest[1] -= 15.0;
trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (tr.fraction == 1.0)
return qtrue;
return qfalse;
}
/*
============
G_RadiusDamage
============
*/
qboolean G_RadiusDamage ( vec3_t origin, gentity_t *attacker, float damage, float radius,
gentity_t *ignore, int mod) {
float points, dist;
gentity_t *ent;
int entityList[MAX_GENTITIES];
int numListedEntities;
vec3_t mins, maxs;
vec3_t v;
vec3_t dir;
int i, e;
qboolean hitClient = qfalse;
if ( radius < 1 ) {
radius = 1;
}
for ( i = 0 ; i < 3 ; i++ ) {
mins[i] = origin[i] - radius;
maxs[i] = origin[i] + radius;
}
numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
for ( e = 0 ; e < numListedEntities ; e++ ) {
ent = &g_entities[entityList[ e ]];
if (ent == ignore)
continue;
if (!ent->takedamage)
continue;
// find the distance from the edge of the bounding box
for ( i = 0 ; i < 3 ; i++ ) {
if ( origin[i] < ent->r.absmin[i] ) {
v[i] = ent->r.absmin[i] - origin[i];
} else if ( origin[i] > ent->r.absmax[i] ) {
v[i] = origin[i] - ent->r.absmax[i];
} else {
v[i] = 0;
}
}
dist = VectorLength( v );
if ( dist >= radius ) {
continue;
}
points = damage * ( 1.0 - dist / radius );
if( CanDamage (ent, origin) ) {
if( LogAccuracyHit( ent, attacker ) ) {
hitClient = qtrue;
}
VectorSubtract (ent->r.currentOrigin, origin, dir);
// push the center of mass higher than the origin so players
// get knocked into the air more
dir[2] += 24;
G_Damage (ent, NULL, attacker, dir, origin, (int)points, DAMAGE_RADIUS, mod);
}
}
return hitClient;
}
void weapon_railgun_fire (gentity_t *ent) {
vec3_t end;
#ifdef MISSIONPACK
vec3_t impactpoint, bouncedir;
#endif
trace_t trace;
gentity_t *tent;
gentity_t *traceEnt;
int damage;
int i;
int hits;
int unlinked;
int passent;
gentity_t *unlinkedEntities[MAX_RAIL_HITS];
LS_Weapon_Fire_Start(WF_RAIL, ent);
damage = 100 * s_quadFactor;
VectorMA (muzzle, 8192, forward, end);
// trace only against the solids, so the railgun will go through people
unlinked = 0;
hits = 0;
passent = ent->s.number;
do {
trap_Trace (&trace, muzzle, NULL, NULL, end, passent, MASK_SHOT );
if ( trace.entityNum >= ENTITYNUM_MAX_NORMAL ) {
break;
}
traceEnt = &g_entities[ trace.entityNum ];
if ( traceEnt->takedamage ) {
#ifdef MISSIONPACK
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if ( G_InvulnerabilityEffect( traceEnt, forward, trace.endpos, impactpoint, bouncedir ) ) {
G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
// snap the endpos to integers to save net bandwidth, but nudged towards the line
SnapVectorTowards( trace.endpos, muzzle );
// send railgun beam effect
tent = G_TempEntity( trace.endpos, EV_RAILTRAIL );
// set player number for custom colors on the railtrail
tent->s.clientNum = ent->s.clientNum;
VectorCopy( muzzle, tent->s.origin2 );
// move origin a bit to come closer to the drawn gun muzzle
VectorMA( tent->s.origin2, 4, right, tent->s.origin2 );
VectorMA( tent->s.origin2, -1, up, tent->s.origin2 );
tent->s.eventParm = 255; // don't make the explosion at the end
//
VectorCopy( impactpoint, muzzle );
// the player can hit him/herself with the bounced rail
passent = ENTITYNUM_NONE;
}
}
else {
if( LogAccuracyHit( traceEnt, ent ) ) {
hits++;
}
G_Damage (traceEnt, ent, ent, forward, trace.endpos, damage, 0, MOD_RAILGUN);
}
#else
if( LogAccuracyHit( traceEnt, ent ) ) {
hits++;
}
G_Damage (traceEnt, ent, ent, forward, trace.endpos, damage, 0, MOD_RAILGUN);
#endif
}
if ( trace.contents & CONTENTS_SOLID ) {
break; // we hit something solid enough to stop the beam
}
// unlink this entity, so the next trace will go past it
trap_UnlinkEntity( traceEnt );
unlinkedEntities[unlinked] = traceEnt;
unlinked++;
} while ( unlinked < MAX_RAIL_HITS );
// link back in any entities we unlinked
for ( i = 0 ; i < unlinked ; i++ ) {
trap_LinkEntity( unlinkedEntities[i] );
}
// the final trace endpos will be the terminal point of the rail trail
// snap the endpos to integers to save net bandwidth, but nudged towards the line
SnapVectorTowards( trace.endpos, muzzle );
// send railgun beam effect
tent = G_TempEntity( trace.endpos, EV_RAILTRAIL );
// set player number for custom colors on the railtrail
tent->s.clientNum = ent->s.clientNum;
VectorCopy( muzzle, tent->s.origin2 );
// move origin a bit to come closer to the drawn gun muzzle
VectorMA( tent->s.origin2, 4, right, tent->s.origin2 );
VectorMA( tent->s.origin2, -1, up, tent->s.origin2 );
// no explosion at end if SURF_NOIMPACT, but still make the trail
if ( trace.surfaceFlags & SURF_NOIMPACT ) {
tent->s.eventParm = 255; // don't make the explosion at the end
} else {
tent->s.eventParm = DirToByte( trace.plane.normal );
}
tent->s.clientNum = ent->s.clientNum;
// give the shooter a reward sound if they have made two railgun hits in a row
if ( hits == 0 ) {
// complete miss
ent->client->accurateCount = 0;
} else {
// check for "impressive" reward sound
ent->client->accurateCount += hits;
if ( ent->client->accurateCount >= 2 ) {
ent->client->accurateCount -= 2;
ent->client->ps.persistant[PERS_IMPRESSIVE_COUNT]++;
// add the sprite over the player's head
ent->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
ent->client->ps.eFlags |= EF_AWARD_IMPRESSIVE;
ent->client->rewardTime = level.time + REWARD_SPRITE_TIME;
}
ent->client->accuracy_hits++;
}
LS_Weapon_Fire_End(WF_RAIL, ent);
}
void Bullet_Fire (gentity_t *ent, float spread, int damage ) {
trace_t tr;
vec3_t end;
#ifdef MISSIONPACK
vec3_t impactpoint, bouncedir;
#endif
float r;
float u;
gentity_t *tent;
gentity_t *traceEnt;
int i, passent;
damage *= s_quadFactor;
r = random() * M_PI * 2.0f;
u = sin(r) * crandom() * spread * 16;
r = cos(r) * crandom() * spread * 16;
VectorMA (muzzle, 8192*16, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
passent = ent->s.number;
for (i = 0; i < 10; i++) {
trap_Trace (&tr, muzzle, NULL, NULL, end, passent, MASK_SHOT);
if ( tr.surfaceFlags & SURF_NOIMPACT ) {
return;
}
traceEnt = &g_entities[ tr.entityNum ];
// snap the endpos to integers, but nudged towards the line
SnapVectorTowards( tr.endpos, muzzle );
// send bullet impact
if ( traceEnt->takedamage && traceEnt->client ) {
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );
tent->s.eventParm = traceEnt->s.number;
if( LogAccuracyHit( traceEnt, ent ) ) {
ent->client->accuracy_hits++;
}
} else {
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_WALL );
tent->s.eventParm = DirToByte( tr.plane.normal );
}
tent->s.otherEntityNum = ent->s.number;
if ( traceEnt->takedamage) {
#ifdef MISSIONPACK
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
VectorCopy( impactpoint, muzzle );
// the player can hit him/herself with the bounced rail
passent = ENTITYNUM_NONE;
}
else {
VectorCopy( tr.endpos, muzzle );
passent = traceEnt->s.number;
}
continue;
}
else {
#endif
G_Damage( traceEnt, ent, ent, forward, tr.endpos,
damage, 0, MOD_MACHINEGUN);
#ifdef MISSIONPACK
}
#endif
}
break;
}
}
void G_MissileImpact( gentity_t *ent, trace_t *trace ) {
#else
void G_MissileImpact( gentity_t *ent, trace_t *trace, int shaderNum ) {
#endif
gentity_t *other;
qboolean hitClient = qfalse;
#ifndef SMOKINGUNS
#ifdef MISSIONPACK
vec3_t forward, impactpoint, bouncedir;
int eFlags;
#endif
#else
qboolean hitKnife = qfalse;
vec3_t bottledirs[ALC_COUNT];
#endif
other = &g_entities[trace->entityNum];
#ifndef SMOKINGUNS
// check for bounce
if ( !other->takedamage &&
( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
return;
}
#ifdef MISSIONPACK
if ( other->takedamage ) {
if ( ent->s.weapon != WP_PROX_LAUNCHER ) {
if ( other->client && other->client->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) {
#else
if(other->takedamage)
hitKnife = qtrue;
// check for bounce
if ( ( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
return;
}
if (other->takedamage && ent->s.weapon != WP_DYNAMITE) {
#endif
// FIXME: wrong damage direction?
if ( ent->damage ) {
vec3_t velocity;
if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {
g_entities[ent->r.ownerNum].client->accuracy_hits++;
hitClient = qtrue;
}
BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );
if ( VectorLength( velocity ) == 0 ) {
velocity[2] = 1; // stepped on a grenade
}
#ifndef SMOKINGUNS
G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
ent->s.origin, ent->damage,
0, ent->methodOfDeath);
#else
// you can't make dynamite exploding by using a knife
if(!(ent->s.weapon == WP_KNIFE && other->s.weapon == WP_DYNAMITE &&
other->s.eType == ET_ITEM)){
// prepare breakable, if not already initialized
if(!(other->flags & FL_BREAKABLE_INIT))
G_BreakablePrepare(other, shaderNum);
G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
ent->s.origin, ent->damage,
0, ent->methodOfDeath);
}
#endif
}
}
#ifndef SMOKINGUNS
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->r.mins, -4, -4, -4);
VectorSet(ent->r.maxs, 4, 4, 4);
trap_LinkEntity(ent);
return;
}
if (!strcmp(ent->classname, "hook")) {
gentity_t *nent;
vec3_t v;
nent = G_Spawn();
if ( other->takedamage && other->client ) {
G_AddEvent( nent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
nent->s.otherEntityNum = other->s.number;
ent->enemy = other;
v[0] = other->r.currentOrigin[0] + (other->r.mins[0] + other->r.maxs[0]) * 0.5;
v[1] = other->r.currentOrigin[1] + (other->r.mins[1] + other->r.maxs[1]) * 0.5;
v[2] = other->r.currentOrigin[2] + (other->r.mins[2] + other->r.maxs[2]) * 0.5;
SnapVectorTowards( v, ent->s.pos.trBase ); // save net bandwidth
} else {
VectorCopy(trace->endpos, v);
G_AddEvent( nent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
ent->enemy = NULL;
}
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->client->ps.pm_flags |= PMF_GRAPPLE_PULL;
VectorCopy( ent->r.currentOrigin, ent->parent->client->ps.grapplePoint);
trap_LinkEntity( ent );
trap_LinkEntity( nent );
return;
}
#endif
// is it cheaper in bandwidth to just remove this ent and create a new
// one, rather than changing the missile into the explosion?
#ifndef SMOKINGUNS
if ( other->takedamage && other->client ) {
#else
// alcoohol impact
if( !Q_stricmp(ent->classname, "alcohol")){
// no event
//G_AddEvent( ent, EV_MISSILE_ALCOHOL, DirToByte( trace->plane.normal));
} else if( !Q_stricmp(ent->classname, "molotov")){
// we have to launch the whiskey drops
int i;
// set the directions
for(i = 0; i < ALC_COUNT; i++){
int temp;
VectorSet(bottledirs[i], (rand()%10)-5, (rand()%10)-5, (rand()%10)-3);
// direction has to be exactly the same (client and server)
temp = DirToByte(bottledirs[i]);
ByteToDir(temp, bottledirs[i]);
}
// dirs
BG_DirsToEntityState(&ent->s, bottledirs);
// burning
if(ent->s.apos.trDelta[0])
G_AddEvent( ent, EV_MISSILE_FIRE, DirToByte( trace->plane.normal));
// not burning
else
G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal));
} else if ( other->takedamage && other->client ) {
#endif
G_AddEvent( ent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
ent->s.otherEntityNum = other->s.number;
#ifndef SMOKINGUNS
} else if( trace->surfaceFlags & SURF_METALSTEPS ) {
#else
} else if( trace->surfaceFlags & SURF_METAL ) {
#endif
G_AddEvent( ent, EV_MISSILE_MISS_METAL, DirToByte( trace->plane.normal ) );
} else {
G_AddEvent( ent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
}
#ifndef SMOKINGUNS
ent->freeAfterEvent = qtrue;
// change over to a normal entity right at the point of impact
ent->s.eType = ET_GENERAL;
#else
if(Q_stricmp(ent->classname, "knife")){
ent->freeAfterEvent = qtrue;
// change over to a normal entity right at the point of impact
ent->s.eType = ET_GENERAL;
} else {
vec3_t dir;
gitem_t *item;
item = BG_FindItemForWeapon(WP_KNIFE);
ent->s.modelindex = item-bg_itemlist;
ent->s.modelindex2 = 1;
ent->item = item;
ent->s.eType = ET_ITEM;
ent->s.pos.trType = TR_GRAVITY;
ent->physicsBounce = 0.01f;
ent->r.contents = CONTENTS_TRIGGER;
ent->touch = Touch_Item;
ent->nextthink = level.time + 100;
ent->think = G_KnifeThink;
ent->wait = level.time + 30000;
ent->flags |= FL_THROWN_ITEM;
vectoangles(ent->s.pos.trDelta, dir);
VectorCopy(dir, ent->s.apos.trBase);
VectorCopy(dir, ent->r.currentAngles);
}
//modified by Spoon END
#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 ) {
if( G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius,
other, ent->splashMethodOfDeath ) ) {
if( !hitClient ) {
g_entities[ent->r.ownerNum].client->accuracy_hits++;
}
}
}
// spawn alcohol missiles
#ifdef SMOKINGUNS
if(!Q_stricmp(ent->classname, "molotov")){
BottleBreak( ent, trace->endpos, trace->plane.normal, bottledirs);
}
#endif
trap_LinkEntity( ent );
}
/*
================
G_RunMissile
================
*/
void G_RunMissile( gentity_t *ent ) {
vec3_t origin;
trace_t tr;
int passent;
#ifdef SMOKINGUNS
int shaderNum;
gentity_t *traceEnt;
#endif
// get current position
BG_EvaluateTrajectory( &ent->s.pos, level.time, origin );
// if this missile bounced off an invulnerability sphere
if ( ent->target_ent ) {
passent = ent->target_ent->s.number;
}
#ifndef SMOKINGUNS
// prox mines that left the owner bbox will attach to anything, even the owner
else if (ent->s.weapon == WP_PROX_LAUNCHER && ent->count) {
passent = ENTITYNUM_NONE;
}
#endif
else {
// ignore interactions with the missile owner
passent = ent->r.ownerNum;
}
// trace a line from the previous position to the current position
#ifndef SMOKINGUNS
trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, passent, ent->clipmask );
#else
shaderNum = trap_Trace_New2( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, origin, passent, ent->clipmask );
traceEnt = &g_entities[tr.entityNum];
#endif
if ( tr.startsolid || tr.allsolid ) {
// make sure the tr.entityNum is set to the entity we're stuck in
#ifndef SMOKINGUNS
trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, passent, ent->clipmask );
#else
trap_Trace_New( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, passent, ent->clipmask );
#endif
tr.fraction = 0;
}
else {
VectorCopy( tr.endpos, ent->r.currentOrigin );
}
trap_LinkEntity( ent );
if ( tr.fraction != 1 ) {
#ifdef SMOKINGUNS
VectorCopy(origin, ent->s.origin2);
#endif
// never explode or bounce on sky
if ( tr.surfaceFlags & SURF_NOIMPACT ) {
// If grapple, reset owner
if (ent->parent && ent->parent->client && ent->parent->client->hook == ent) {
ent->parent->client->hook = NULL;
}
// if its a dynamite or molotov let it move 10 seconds before deleting it
#ifdef SMOKINGUNS
if(ent->s.weapon == WP_DYNAMITE || ent->s.weapon == WP_MOLOTOV
|| ent->s.weapon == WP_KNIFE){
if(ent->mappart >= level.time && ent->mappart){
goto think;
} else if(ent->mappart){
ent->mappart = 0;
} else {
ent->mappart = level.time + 5000;
goto think;
}
}
#endif
G_FreeEntity( ent );
return;
}
#ifndef SMOKINGUNS
G_MissileImpact( ent, &tr );
if ( ent->s.eType != ET_MISSILE ) {
#else
G_MissileImpact( ent, &tr, shaderNum );
if ( ent->s.eType != ET_MISSILE && ent->s.eType != ET_ITEM) {
#endif
return; // exploded
}
}
#ifndef SMOKINGUNS
// if the prox mine wasn't yet outside the player body
if (ent->s.weapon == WP_PROX_LAUNCHER && !ent->count) {
// check if the prox mine is outside the owner bbox
trap_Trace( &tr, ent->r.currentOrigin, ent->r.mins, ent->r.maxs, ent->r.currentOrigin, ENTITYNUM_NONE, ent->clipmask );
if (!tr.startsolid || tr.entityNum != ent->r.ownerNum) {
ent->count = 1;
}
}
#endif
think:
// check think function after bouncing
G_RunThink( ent );
}
//=============================================================================
#ifndef SMOKINGUNS
/*
=================
fire_plasma
=================
*/
gentity_t *fire_plasma (gentity_t *self, vec3_t start, vec3_t dir) {
gentity_t *bolt;
VectorNormalize (dir);
bolt = G_Spawn();
bolt->classname = "plasma";
bolt->nextthink = level.time + 10000;
bolt->think = G_ExplodeMissile;
bolt->s.eType = ET_MISSILE;
bolt->r.svFlags = SVF_USE_CURRENT_ORIGIN;
bolt->s.weapon = WP_PLASMAGUN;
bolt->r.ownerNum = self->s.number;
bolt->parent = self;
bolt->damage = 20;
bolt->splashDamage = 15;
bolt->splashRadius = 20;
bolt->methodOfDeath = MOD_PLASMA;
bolt->splashMethodOfDeath = MOD_PLASMA_SPLASH;
bolt->clipmask = MASK_SHOT;
bolt->target_ent = NULL;
bolt->s.pos.trType = TR_LINEAR;
bolt->s.pos.trTime = level.time - MISSILE_PRESTEP_TIME; // move a bit on the very first frame
VectorCopy( start, bolt->s.pos.trBase );
VectorScale( dir, 2000, bolt->s.pos.trDelta );
SnapVector( bolt->s.pos.trDelta ); // save net bandwidth
VectorCopy (start, bolt->r.currentOrigin);
return bolt;
}
//=============================================================================
/*
=================
fire_grenade
=================
*/
gentity_t *fire_grenade (gentity_t *self, vec3_t start, vec3_t dir) {
gentity_t *bolt;
VectorNormalize (dir);
bolt = G_Spawn();
bolt->classname = "grenade";
bolt->nextthink = level.time + 2500;
bolt->think = G_ExplodeMissile;
bolt->s.eType = ET_MISSILE;
bolt->r.svFlags = SVF_USE_CURRENT_ORIGIN;
bolt->s.weapon = WP_GRENADE_LAUNCHER;
bolt->s.eFlags = EF_BOUNCE_HALF;
bolt->r.ownerNum = self->s.number;
bolt->parent = self;
bolt->damage = 100;
bolt->splashDamage = 100;
bolt->splashRadius = 150;
bolt->methodOfDeath = MOD_GRENADE;
bolt->splashMethodOfDeath = MOD_GRENADE_SPLASH;
bolt->clipmask = MASK_SHOT;
bolt->target_ent = NULL;
bolt->s.pos.trType = TR_GRAVITY;
bolt->s.pos.trTime = level.time - MISSILE_PRESTEP_TIME; // move a bit on the very first frame
VectorCopy( start, bolt->s.pos.trBase );
VectorScale( dir, 700, bolt->s.pos.trDelta );
SnapVector( bolt->s.pos.trDelta ); // save net bandwidth
VectorCopy (start, bolt->r.currentOrigin);
return bolt;
}
/*
================
G_MissileImpact
================
*/
void G_MissileImpact( gentity_t *ent, trace_t *trace ) {
gentity_t *other;
qboolean hitClient = qfalse;
#ifdef MISSIONPACK
vec3_t forward, impactpoint, bouncedir;
int eFlags;
#endif
other = &g_entities[trace->entityNum];
// check for bounce
if ( !other->takedamage &&
( ent->s.eFlags & ( EF_BOUNCE | EF_BOUNCE_HALF ) ) ) {
G_BounceMissile( ent, trace );
G_AddEvent( ent, EV_GRENADE_BOUNCE, 0 );
return;
}
#ifdef MISSIONPACK
if ( other->takedamage ) {
if ( ent->s.weapon != WP_PROX_LAUNCHER ) {
if ( other->client && other->client->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) {
// FIXME: wrong damage direction?
if ( ent->damage ) {
vec3_t velocity;
if( LogAccuracyHit( other, &g_entities[ent->r.ownerNum] ) ) {
g_entities[ent->r.ownerNum].client->accuracy_hits++;
hitClient = qtrue;
}
BG_EvaluateTrajectoryDelta( &ent->s.pos, level.time, velocity );
if ( VectorLength( velocity ) == 0 ) {
velocity[2] = 1; // stepped on a grenade
}
G_Damage (other, ent, &g_entities[ent->r.ownerNum], velocity,
ent->s.origin, ent->damage,
0, ent->methodOfDeath);
}
}
#ifdef 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->r.mins, -4, -4, -4);
VectorSet(ent->r.maxs, 4, 4, 4);
trap_LinkEntity(ent);
return;
}
#endif
if (!strcmp(ent->classname, "hook")) {
gentity_t *nent;
vec3_t v;
nent = G_Spawn();
if ( other->takedamage && other->client ) {
G_AddEvent( nent, EV_MISSILE_HIT, DirToByte( trace->plane.normal ) );
nent->s.otherEntityNum = other->s.number;
ent->enemy = other;
v[0] = other->r.currentOrigin[0] + (other->r.mins[0] + other->r.maxs[0]) * 0.5;
v[1] = other->r.currentOrigin[1] + (other->r.mins[1] + other->r.maxs[1]) * 0.5;
v[2] = other->r.currentOrigin[2] + (other->r.mins[2] + other->r.maxs[2]) * 0.5;
SnapVectorTowards( v, ent->s.pos.trBase ); // save net bandwidth
} else {
VectorCopy(trace->endpos, v);
G_AddEvent( nent, EV_MISSILE_MISS, DirToByte( trace->plane.normal ) );
ent->enemy = NULL;
}
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->client->ps.pm_flags |= PMF_GRAPPLE_PULL;
VectorCopy( ent->r.currentOrigin, ent->parent->client->ps.grapplePoint);
trap_LinkEntity( ent );
trap_LinkEntity( nent );
return;
}
// 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->client ) {
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 ) );
}
ent->freeAfterEvent = qtrue;
// change over to a normal entity right at the point of impact
ent->s.eType = ET_GENERAL;
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 ) {
if( G_RadiusDamage( trace->endpos, ent->parent, ent->splashDamage, ent->splashRadius,
other, ent->splashMethodOfDeath ) ) {
if( !hitClient ) {
g_entities[ent->r.ownerNum].client->accuracy_hits++;
}
}
}
trap_LinkEntity( ent );
}
// self is the "parent", the entity that owns the missile (like a player or shooter_*)
qboolean fire_projectile(gentity_t *self, vec3_t start, vec3_t forward,
vec3_t right, vec3_t up, int projnum, float quadFactor,
int mod, int splashMod, int handSide)
{
vec3_t mins = { -8, -8, -8 };
vec3_t maxs = { 8, 8, 8 };
gentity_t *bolt;
vec3_t dir;
vec3_t end;
int count;
int spread;
int damage;
int splashDamage;
float splashRadius;
int range;
qboolean hitClient;
if (projnum < 0 || projnum >= BG_NumProjectiles())
{
return qfalse;
}
// Check if can fire grappling projectile
if (self && self->player && bg_projectileinfo[projnum].grappling)
{
#ifdef IOQ3ZTM
#ifdef TURTLEARENA // HOLD_SHURIKEN
if (handSide == HS_CENTER) // Shuriken holdable item
{
if ((self->player->ps.pm_flags & PMF_USE_ITEM_HELD) || self->player->hook) {
return qfalse;
}
self->player->ps.pm_flags |= PMF_USE_ITEM_HELD;
}
else
#endif
{
if ((self->player->ps.pm_flags & PMF_FIRE_HELD) || self->player->hook) {
return qfalse;
}
self->player->ps.pm_flags |= PMF_FIRE_HELD;
}
#else
if (self->player->fireHeld || self->player->hook) {
return qfalse;
}
self->player->fireHeld = qtrue;
#endif
}
spread = bg_projectileinfo[projnum].spread;
#if 0 // ZTM: WONTFIX: Only for machinegun
if (g_gametype.integer == GT_TEAM)
{
damage = bg_projectileinfo[projnum].damage * 0.7;
splashDamage = bg_projectileinfo[projnum].splashDamage * 0.7;
}
else
#endif
{
damage = bg_projectileinfo[projnum].damage;
splashDamage = bg_projectileinfo[projnum].splashDamage;
}
splashRadius = bg_projectileinfo[projnum].splashRadius;
if (quadFactor > 1) {
damage *= quadFactor;
splashDamage *= quadFactor;
}
// Use default kill messages
// Missile is spawned
if (mod == MOD_UNKNOWN) {
mod = MOD_PROJECTILE;
}
if (splashMod == MOD_UNKNOWN) {
splashMod = MOD_PROJECTILE_EXPLOSION;
}
range = 0;
if (bg_projectileinfo[projnum].instantDamage)
{
range = bg_projectileinfo[projnum].speed;
}
if (!range) {
// 8192 is used by bullets, railgun, and nails
// Lightning uses 768
range = 8192;
}
for (count = 0; count < bg_projectileinfo[projnum].numProjectiles; count++ )
{
if (spread) // if spread make your own dir.
{
float r, u;
r = random() * M_PI * 2.0f;
u = sin(r) * crandom() * spread * 16;
r = cos(r) * crandom() * spread * 16;
VectorMA(start, (range * 16), forward, end);
VectorMA(end, r, right, end);
VectorMA(end, u, up, end);
VectorSubtract(end, start, dir);
}
else
{
VectorMA(start, range, forward, end);
VectorCopy(forward, dir);
}
if (bg_projectileinfo[projnum].flags & PF_USE_GRAVITY)
{
// extra vertical velocity
dir[2] += 0.2f;
}
VectorNormalize (dir);
if (bg_projectileinfo[projnum].instantDamage)
{
// Based on Q3's Bullet_Fire
// (with extra code from Weapon_LightningFire and weapon_railgun_fire)
trace_t tr;
#if defined MISSIONPACK && !defined TURTLEARENA // POWERS
vec3_t impactpoint, bouncedir;
#endif
gentity_t *tent;
gentity_t *traceEnt;
int i, passent;
int unlinked;
gentity_t *unlinkedEntities[10];
int hits;
unlinked = hits = 0;
// Do a bullet trace instead of spawning a missile.
passent = self->s.number;
for (i = 0; i < 10; i++) // 10 for lightning
{
trap_Trace (&tr, start, NULL, NULL, end, passent, MASK_SHOT);
#if defined MISSIONPACK && !defined TURTLEARENA // POWERS
// if not the first trace (the lightning bounced off an invulnerability sphere)
if (i && bg_projectileinfo[projnum].trailType == PT_LIGHTNING) {
// add bounced off lightning bolt temp entity
// the first lightning bolt is a cgame only visual
//
tent = G_TempEntity( start, EV_LIGHTNINGBOLT );
tent->s.weapon = projnum;
VectorCopy( tr.endpos, end );
SnapVector( end );
VectorCopy( end, tent->s.origin2 );
}
#endif
#if 0 // RAIL
if ( tr.entityNum >= ENTITYNUM_MAX_NORMAL ) {
break;
}
#else // LIGHTNING
if ( tr.entityNum == ENTITYNUM_NONE ) {
break;
}
#endif
traceEnt = &g_entities[ tr.entityNum ];
// snap the endpos to integers, but nudged towards the line
SnapVectorTowards( tr.endpos, start );
if ( !(tr.surfaceFlags & SURF_NOIMPACT) )
{
// send bullet impact
if ( traceEnt->takedamage && traceEnt->player )
{
#if 1 // lightning
tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );
tent->s.otherEntityNum = traceEnt->s.number;
tent->s.eventParm = DirToByte( tr.plane.normal );
tent->s.playerNum = self->s.number;
#else
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );
tent->s.eventParm = traceEnt->s.number;
tent->s.otherEntityNum = self->s.number;
#endif
tent->s.weapon = projnum;
} else if (tr.surfaceFlags & SURF_METALSTEPS) {
tent = G_TempEntity( tr.endpos, EV_MISSILE_MISS_METAL );
tent->s.playerNum = self->s.number;
tent->s.weapon = projnum;
tent->s.eventParm = DirToByte( tr.plane.normal );
} else {
#if 1 // lightning
tent = G_TempEntity( tr.endpos, EV_MISSILE_MISS );
tent->s.playerNum = self->s.number;
#else
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_WALL );
tent->s.otherEntityNum = self->s.number;
#endif
tent->s.weapon = projnum;
tent->s.eventParm = DirToByte( tr.plane.normal );
}
}
if ( traceEnt->takedamage)
{
#if defined MISSIONPACK && !defined TURTLEARENA // POWERS
if ( traceEnt->player && traceEnt->player->invulnerabilityTime > level.time )
{
if (G_InvulnerabilityEffect( traceEnt, dir, tr.endpos, impactpoint, bouncedir ))
{
G_BounceProjectile( start, impactpoint, bouncedir, end );
if (bg_projectileinfo[projnum].trailType == PT_RAIL)
{
// snap the endpos to integers to save net bandwidth, but nudged towards the line
SnapVectorTowards( tr.endpos, start );
// send railgun beam effect
tent = G_TempEntity( tr.endpos, EV_RAILTRAIL );
// set player number for custom colors on the railtrail
tent->s.playerNum = self->s.playerNum;
tent->s.weapon = projnum;
tent->s.weaponHands = MAX_HANDS; // Don't attach to player's gun
VectorCopy( start, tent->s.origin2 );
// move origin a bit to come closer to the drawn gun muzzle
VectorMA( tent->s.origin2, 4, right, tent->s.origin2 );
VectorMA( tent->s.origin2, -1, up, tent->s.origin2 );
tent->s.eventParm = 255; // don't make the explosion at the end
}
VectorCopy( impactpoint, start );
#if 1 // lightning
VectorSubtract( end, impactpoint, dir );
VectorNormalize(dir);
#endif
// the player can hit him/herself with the bounced rail
passent = ENTITYNUM_NONE;
}
else
{
VectorCopy( tr.endpos, start );
passent = traceEnt->s.number;
}
if (bg_projectileinfo[projnum].trailType != PT_RAIL) {
continue;
}
}
else
#endif
{
G_Damage( traceEnt, self, self,
#if 1 // ZTM: Knockback in direction projectile was moving
dir,
#else
forward,
#endif
tr.endpos,
damage,
0, mod);
hitClient = LogAccuracyHit( traceEnt, self );
// Splash damage!
if (G_RadiusDamage(tr.endpos, self, self, damage, splashRadius, traceEnt, splashMod)) {
hitClient = qtrue;
}
if( hitClient ) {
hits++;
}
}
}
// weapon_railgun_fire
if (bg_projectileinfo[projnum].maxHits > 1) {
if ( tr.contents & CONTENTS_SOLID ) {
break; // we hit something solid enough to stop the beam
}
// unlink this entity, so the next trace will go past it
trap_UnlinkEntity( traceEnt );
unlinkedEntities[unlinked] = traceEnt;
unlinked++;
if (i+1 >= bg_projectileinfo[projnum].maxHits) {
break;
}
} else {
break;
}
}
// link back in any entities we unlinked
for ( i = 0 ; i < unlinked ; i++ ) {
trap_LinkEntity( unlinkedEntities[i] );
}
if (self && self->player) {
#ifndef TURTLEARENA // AWARDS
if (bg_projectileinfo[projnum].maxHits > 1) {
// give the shooter a reward sound if they have made two railgun hits in a row
if ( hits == 0 ) {
// complete miss
self->player->accurateCount = 0;
} else {
// check for "impressive" reward sound
self->player->accurateCount += hits;
if ( self->player->accurateCount >= 2 ) {
self->player->accurateCount -= 2;
self->player->ps.persistant[PERS_IMPRESSIVE_COUNT]++;
// add the sprite over the player's head
#ifdef IOQ3ZTM
self->player->ps.eFlags &= ~EF_AWARD_BITS;
#else
self->player->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
#endif
self->player->ps.eFlags |= EF_AWARD_IMPRESSIVE;
self->player->rewardTime = level.time + REWARD_SPRITE_TIME;
}
self->player->accuracy_hits++;
}
}
else
#endif
if (hits) {
self->player->accuracy_hits++;
}
}
// From weapon_railgun_fire
if (bg_projectileinfo[projnum].trailType == PT_RAIL)
{
gentity_t *tent;
// the final trace endpos will be the terminal point of the rail trail
// snap the endpos to integers to save net bandwidth, but nudged towards the line
SnapVectorTowards( tr.endpos, start );
// send railgun beam effect
tent = G_TempEntity( tr.endpos, EV_RAILTRAIL );
// set player number for custom colors on the railtrail
tent->s.playerNum = self->s.playerNum;
// Set projectile number
tent->s.weapon = projnum;
// ZTM: NOTE: This could be a problem if multiple hands use the same handSide.
tent->s.weaponHands = MAX_HANDS;
if (self->player) {
for (i = 0; i < MAX_HANDS; i++)
{
if (self->player->pers.playercfg.handSide[i] == handSide) {
tent->s.weaponHands = i;
break;
}
}
}
VectorCopy( start, tent->s.origin2 );
// move origin a bit to come closer to the drawn gun muzzle
if (handSide == HS_RIGHT)
VectorMA( tent->s.origin2, 4, right, tent->s.origin2 );
else if (handSide == HS_LEFT)
VectorMA( tent->s.origin2, -4, right, tent->s.origin2 );
VectorMA( tent->s.origin2, -1, up, tent->s.origin2 );
}
continue;
}
bolt = G_Spawn();
bolt->classname = bg_projectileinfo[projnum].name;
if (self && self->player && bg_projectileinfo[projnum].grappling)
{
if (bg_projectileinfo[projnum].timetolive == -1)
bolt->nextthink = -1;
else
bolt->nextthink = level.time + bg_projectileinfo[projnum].timetolive;
bolt->think = Weapon_HookFree;
self->player->hook = bolt;
}
else if (bg_projectileinfo[projnum].homing)
{
bolt->nextthink = level.time + bg_projectileinfo[projnum].homing;
bolt->think = G_HomingMissile;
}
else
{
if (bg_projectileinfo[projnum].timetolive == -1)
bolt->nextthink = -1;
else
bolt->nextthink = level.time + bg_projectileinfo[projnum].timetolive;
if (bg_projectileinfo[projnum].fallToGround)
bolt->think = G_MissileFall; // Just fall out of air.
else
bolt->think = G_ExplodeMissile;
}
bolt->s.eType = ET_MISSILE;
bolt->r.svFlags = SVF_USE_CURRENT_ORIGIN;
bolt->s.weapon = projnum;
if (self) {
bolt->r.ownerNum = self->s.number;
} else {
bolt->r.ownerNum = ENTITYNUM_WORLD;
}
bolt->parent = self;
// grapple
bolt->s.otherEntityNum = bolt->r.ownerNum; // use to match beam in client
if (!bg_projectileinfo[projnum].damageAttacker) {
bolt->flags |= FL_MISSILE_NO_DAMAGE_PARENT;
}
bolt->damage = damage;
bolt->splashDamage = splashDamage;
bolt->splashRadius = splashRadius;
bolt->methodOfDeath = mod;
bolt->splashMethodOfDeath = splashMod;
bolt->clipmask = MASK_SHOT;
bolt->target_ent = NULL;
VectorCopy( start, bolt->s.pos.trBase );
bolt->s.pos.trTime = level.time - MISSILE_PRESTEP_TIME; // move a bit on the very first frame
G_SetMissileVelocity(bolt, dir, projnum);
VectorCopy (start, bolt->r.currentOrigin);
if (bg_projectileinfo[projnum].bounceType == PB_FULL)
bolt->s.eFlags = EF_BOUNCE;
else if (bg_projectileinfo[projnum].bounceType == PB_HALF)
bolt->s.eFlags = EF_BOUNCE_HALF;
if (bg_projectileinfo[projnum].flags & PF_USE_GRAVITY)
bolt->s.pos.trType = TR_GRAVITY;
// Limit bounces
bolt->s.modelindex2 = bg_projectileinfo[projnum].maxBounces;
// ZTM: Shootable missiles, taken from XREAL
if (bg_projectileinfo[projnum].shootable)
{
// Make the projectile shootable
bolt->s.contents = CONTENTS_SHOOTABLE;
VectorCopy(mins, bolt->s.mins);
VectorCopy(maxs, bolt->s.maxs);
bolt->takedamage = qtrue;
bolt->health = bg_projectileinfo[projnum].damage;
if (bg_projectileinfo[projnum].fallToGround)
bolt->die = G_MissileFall_Die;
else
bolt->die = G_Missile_Die;
}
// Save handSide in missile
bolt->s.weaponHands = handSide;
if (self && self->player)
{
// Taken from Q3's fire_prox;
// ZTM: Used by prox mines so that if that player changes teams the mines
// don't "change" teams as well (or something...).
bolt->s.team = self->player->sess.sessionTeam;
}
else
{
bolt->s.team = TEAM_FREE;
}
// Needed for stickOnImpact and grappling projectiles
vectoangles( forward, bolt->s.angles );
}
return qtrue;
}
/*
================
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,
vec3_t dir, vec3_t point, int damage, int dflags, int mod ) {
gclient_t *client;
int take;
//int save;
int asave;
int knockback;
int max;
vec3_t bouncedir, impactpoint;
if (!targ->takedamage) {
return;
}
// the intermission has allready been qualified for, so don't
// allow any extra scoring
if ( level.intermissionQueued ) {
return;
}
if ( targ->client && mod != MOD_JUICED) {
if ( targ->client->invulnerabilityTime > level.time) {
if ( dir && point ) {
G_InvulnerabilityEffect( targ, dir, point, impactpoint, bouncedir );
}
return;
}
}
//Sago: This was moved up
client = targ->client;
//Sago: See if the client was sent flying
//Check if damage is by somebody who is not a player!
if( (!attacker || attacker->s.eType != ET_PLAYER) && client && client->lastSentFlying>-1 && ( mod==MOD_FALLING || mod==MOD_LAVA || mod==MOD_SLIME || mod==MOD_TRIGGER_HURT || mod==MOD_SUICIDE) ) {
if( client->lastSentFlyingTime+5000<level.time) {
client->lastSentFlying = -1; //More than 5 seconds, not a kill!
} else {
//G_Printf("LastSentFlying %i\n",client->lastSentFlying);
attacker = &g_entities[client->lastSentFlying];
}
}
if ( !inflictor ) {
inflictor = &g_entities[ENTITYNUM_WORLD];
}
if ( !attacker ) {
attacker = &g_entities[ENTITYNUM_WORLD];
}
// shootable doors / buttons don't actually have any health
if ( targ->s.eType == ET_MOVER ) {
if ( targ->use && targ->moverState == MOVER_POS1 ) {
targ->use( targ, inflictor, attacker );
}
return;
}
if( g_gametype.integer == GT_OBELISK && CheckObeliskAttack( targ, attacker ) ) {
return;
}
// reduce damage by the attacker's handicap value
// unless they are rocket jumping
if ( attacker->client && attacker != targ ) {
max = attacker->client->ps.stats[STAT_MAX_HEALTH];
if( bg_itemlist[attacker->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
max /= 2;
}
damage = damage * max / 100;
}
//Sago: I have moved this up
//client = targ->client;
if ( client ) {
if ( client->noclip ) {
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;
}
// 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);
// 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;
}
//Remeber the last person to hurt the player
if( !g_awardpushing.integer || targ==attacker || OnSameTeam (targ, attacker)) {
targ->client->lastSentFlying = -1;
} else {
/*if ( pm->waterlevel <= 1 ) {
if ( pml.walking && !(pml.groundTrace.surfaceFlags & SURF_SLICK) ) {
// if getting knocked back, no friction
if ( ! (pm->ps->pm_flags & PMF_TIME_KNOCKBACK) ) {
control = speed < pm_stopspeed ? pm_stopspeed : speed;
drop += control*pm_friction*pml.frametime;
}
}
}*/
targ->client->lastSentFlying = attacker->s.number;
targ->client->lastSentFlyingTime = level.time;
}
}
// 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 ( mod != MOD_JUICED && mod != MOD_CRUSH && targ != attacker && !(dflags & DAMAGE_NO_TEAM_PROTECTION) && OnSameTeam (targ, attacker) ) {
if ( ( !g_friendlyFire.integer && g_gametype.integer != GT_ELIMINATION && g_gametype.integer != GT_CTF_ELIMINATION ) || ( g_elimination_selfdamage.integer<2 && (g_gametype.integer == GT_ELIMINATION || g_gametype.integer == GT_CTF_ELIMINATION) ) ) {
return;
}
}
if (mod == MOD_PROXIMITY_MINE) {
if (inflictor && inflictor->parent && OnSameTeam(targ, inflictor->parent)) {
return;
}
if (targ == attacker) {
return;
}
}
// check for godmode
if ( targ->flags & FL_GODMODE ) {
return;
}
if(targ->client && targ->client->spawnprotected) {
if(level.time>targ->client->respawnTime+g_spawnprotect.integer)
targ->client->spawnprotected = qfalse;
else
if( (mod > MOD_UNKNOWN && mod < MOD_WATER) || mod == MOD_TELEFRAG || mod>MOD_TRIGGER_HURT)
return;
}
}
// battlesuit protects from all radius damage (but takes knockback)
// and protects 50% against all damage
if ( client && client->ps.powerups[PW_BATTLESUIT] ) {
G_AddEvent( targ, EV_POWERUP_BATTLESUIT, 0 );
if ( ( dflags & DAMAGE_RADIUS ) || ( mod == MOD_FALLING ) ) {
return;
}
damage *= 0.5;
}
// add to the attacker's hit counter (if the target isn't a general entity like a prox mine)
if ( attacker->client && client
&& targ != attacker && targ->health > 0
&& targ->s.eType != ET_MISSILE
&& targ->s.eType != ET_GENERAL) {
if ( OnSameTeam( targ, attacker ) ) {
attacker->client->ps.persistant[PERS_HITS]--;
} else {
attacker->client->ps.persistant[PERS_HITS]++;
}
attacker->client->ps.persistant[PERS_ATTACKEE_ARMOR] = (targ->health<<8)|(client->ps.stats[STAT_ARMOR]);
}
// always give half damage if hurting self
// calculated after knockback, so rocket jumping works
if ( targ == attacker) {
damage *= 0.5;
}
if(targ && targ->client && attacker->client )
damage = catchup_damage(damage, attacker->client->ps.persistant[PERS_SCORE], targ->client->ps.persistant[PERS_SCORE]);
if(g_damageModifier.value > 0.01) {
damage *= g_damageModifier.value;
}
if ( damage < 1 ) {
damage = 1;
}
if(targ == attacker && (g_dmflags.integer & DF_NO_SELF_DAMAGE) )
damage = 0;
if ((g_gametype.integer == GT_ELIMINATION || g_gametype.integer == GT_CTF_ELIMINATION || g_gametype.integer == GT_LMS || g_elimination_allgametypes.integer)
&& g_elimination_selfdamage.integer<1 && ( targ == attacker || mod == MOD_FALLING )) {
damage = 0;
}
//So people can be telefragged!
if ((g_gametype.integer == GT_ELIMINATION || g_gametype.integer == GT_CTF_ELIMINATION || g_gametype.integer == GT_LMS) && level.time < level.roundStartTime && ((mod == MOD_LAVA) || (mod == MOD_SLIME)) ) {
damage = 1000;
}
take = damage;
//save = 0;
// save some from armor
asave = CheckArmor (targ, take, dflags);
take -= asave;
if ( g_debugDamage.integer ) {
G_Printf( "%i: client:%i health:%i damage:%i armor:%i\n", level.time, targ->s.number,
targ->health, take, asave );
}
// 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 if(client->lastSentFlying) {
client->ps.persistant[PERS_ATTACKER] = client->lastSentFlying;
} else {
client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD;
}
client->damage_armor += asave;
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
if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_1FCTF || g_gametype.integer == GT_CTF_ELIMINATION) {
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;
}
//If vampire is enabled, gain health but not from self or teammate, cannot steal more than targ has
if( g_vampire.value>0.0 && (targ != attacker) && take > 0 &&
!(OnSameTeam(targ, attacker)) && attacker->health > 0 && targ->health > 0 )
{
if(take<targ->health)
attacker->health += (int)(((float)take)*g_vampire.value);
else
attacker->health += (int)(((float)targ->health)*g_vampire.value);
if(attacker->health>g_vampireMaxHealth.integer)
attacker->health = g_vampireMaxHealth.integer;
}
// do the damage
if (take) {
targ->health = targ->health - take;
if ( targ->client ) {
targ->client->ps.stats[STAT_HEALTH] = targ->health;
}
if ( targ->health <= 0 ) {
if ( client )
targ->flags |= FL_NO_KNOCKBACK;
if (targ->health < -999)
targ->health = -999;
targ->enemy = attacker;
targ->die (targ, inflictor, attacker, take, mod);
return;
} else if ( targ->pain ) {
targ->pain (targ, attacker, take);
}
}
}
void Weapon_LightningFire( gentity_t *ent ) {
trace_t tr;
vec3_t end;
#ifdef MISSIONPACK
vec3_t impactpoint, bouncedir;
#endif
gentity_t *traceEnt, *tent;
int damage, i, passent;
damage = 8 * s_quadFactor;
passent = ent->s.number;
for (i = 0; i < 10; i++) {
VectorMA( muzzle, LIGHTNING_RANGE, forward, end );
// eser - lightning discharge
if (trap_PointContents (muzzle, -1) & MASK_WATER)
{
int zaps;
gentity_t *tent;
zaps = ent->client->ps.ammo[WP_LIGHTNING]; // determines size/power of discharge
if (!zaps) return; // prevents any subsequent frames causing second discharge + error
zaps++; // pmove does an ammo[gun]--, so we must compensate
SnapVectorTowards (muzzle, ent->s.origin); // save bandwidth
tent = G_TempEntity (muzzle, EV_LIGHTNING_DISCHARGE);
tent->s.eventParm = zaps; // duration / size of explosion graphic
ent->client->ps.ammo[WP_LIGHTNING] = 0; // drain ent's lightning count
if (G_RadiusDamage (muzzle, ent, damage * zaps, (damage * zaps) + 16, NULL, MOD_LIGHTNING_DISCHARGE, qtrue))
ent->client->accuracy_hits++;
return;
}
// eser - lightning discharge
trap_Trace( &tr, muzzle, NULL, NULL, end, passent, MASK_SHOT );
#ifdef MISSIONPACK
// if not the first trace (the lightning bounced of an invulnerability sphere)
if (i) {
// add bounced off lightning bolt temp entity
// the first lightning bolt is a cgame only visual
//
tent = G_TempEntity( muzzle, EV_LIGHTNINGBOLT );
VectorCopy( tr.endpos, end );
SnapVector( end );
VectorCopy( end, tent->s.origin2 );
}
#endif
if ( tr.entityNum == ENTITYNUM_NONE ) {
return;
}
traceEnt = &g_entities[ tr.entityNum ];
if ( traceEnt->takedamage) {
#ifdef MISSIONPACK
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
VectorCopy( impactpoint, muzzle );
VectorSubtract( end, impactpoint, forward );
VectorNormalize(forward);
// the player can hit him/herself with the bounced lightning
passent = ENTITYNUM_NONE;
}
else {
VectorCopy( tr.endpos, muzzle );
passent = traceEnt->s.number;
}
continue;
}
#endif
if( LogAccuracyHit( traceEnt, ent ) ) {
ent->client->accuracy_hits++;
}
G_Damage( traceEnt, ent, ent, forward, tr.endpos, damage, 0, MOD_LIGHTNING);
}
if ( traceEnt->takedamage && traceEnt->client ) {
tent = G_TempEntity( tr.endpos, EV_MISSILE_HIT );
tent->s.otherEntityNum = traceEnt->s.number;
tent->s.eventParm = DirToByte( tr.plane.normal );
tent->s.weapon = ent->s.weapon;
} else if ( !( tr.surfaceFlags & SURF_NOIMPACT ) ) {
tent = G_TempEntity( tr.endpos, EV_MISSILE_MISS );
tent->s.eventParm = DirToByte( tr.plane.normal );
}
break;
}
}
void Bullet_Fire (gentity_t *ent, float spread, int damage, int mod ) {
trace_t tr;
vec3_t end;
#ifdef MISSIONPACK
vec3_t impactpoint, bouncedir;
#endif
float r;
float u;
gentity_t *tent;
gentity_t *traceEnt;
int i, passent;
damage *= s_quadFactor;
//unlagged - attack prediction #2
if ( g_unlagged.integer ) {
// we have to use something now that the client knows in advance
int seed = ent->client->attackTime % 256;
// this has to match what's on the client
r = Q_random(&seed) * M_PI * 2.0f;
u = sin(r) * Q_crandom(&seed) * spread * 16;
r = cos(r) * Q_crandom(&seed) * spread * 16;
} else {
r = random() * M_PI * 2.0f;
u = sin(r) * crandom() * spread * 16;
r = cos(r) * crandom() * spread * 16;
}
//-unlagged - attack prediction #2
VectorMA (muzzle, 8192*16, forward, end);
VectorMA (end, r, right, end);
VectorMA (end, u, up, end);
passent = ent->s.number;
for (i = 0; i < 10; i++) {
//unlagged - backward reconciliation #2
// backward-reconcile the other clients
if ( g_unlagged.integer )
G_DoTimeShiftFor( ent );
//-unlagged - backward reconciliation #2
trap_Trace (&tr, muzzle, NULL, NULL, end, passent, MASK_SHOT);
//unlagged - backward reconciliation #2
// put them back
if ( g_unlagged.integer )
G_UndoTimeShiftFor( ent );
//-unlagged - backward reconciliation #2
if ( tr.surfaceFlags & SURF_NOIMPACT ) {
return;
}
traceEnt = &g_entities[ tr.entityNum ];
// snap the endpos to integers, but nudged towards the line
SnapVectorTowards( tr.endpos, muzzle );
// send bullet impact
if ( traceEnt->takedamage && traceEnt->client ) {
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_FLESH );
tent->s.eventParm = traceEnt->s.number;
//unlagged - attack prediction #2
// we need the client number to determine whether or not to
// suppress this event
if ( g_unlagged.integer )
tent->s.clientNum = ent->s.clientNum;
//-unlagged - attack prediction #2
if( LogAccuracyHit( traceEnt, ent ) ) {
ent->client->accuracy_hits++;
}
} else {
tent = G_TempEntity( tr.endpos, EV_BULLET_HIT_WALL );
tent->s.eventParm = DirToByte( tr.plane.normal );
//unlagged - attack prediction #2
// we need the client number to determine whether or not to
// suppress this event
if ( g_unlagged.integer )
tent->s.clientNum = ent->s.clientNum;
//-unlagged - attack prediction #2
}
tent->s.otherEntityNum = ent->s.number;
if ( traceEnt->takedamage) {
#ifdef MISSIONPACK
if ( traceEnt->client && traceEnt->client->invulnerabilityTime > level.time ) {
if (G_InvulnerabilityEffect( traceEnt, forward, tr.endpos, impactpoint, bouncedir )) {
G_BounceProjectile( muzzle, impactpoint, bouncedir, end );
VectorCopy( impactpoint, muzzle );
// the player can hit him/herself with the bounced rail
passent = ENTITYNUM_NONE;
}
else {
VectorCopy( tr.endpos, muzzle );
passent = traceEnt->s.number;
}
continue;
}
else {
#endif
G_Damage( traceEnt, ent, ent, forward, tr.endpos,
damage, DAMAGE_COMBAT, mod);
#ifdef MISSIONPACK
}
#endif
}
break;
}
}
