raven/jedioutcast
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
jedioutcast/code/game/g_combat.cpp
James Monroe 6af9b594e1 Jedi Outcast Patch v1.03
2013-04-04 16:05:53 -05:00

5584 lines
155 KiB
C++
Raw Blame History

// g_combat.c
// leave this line at the top for all g_xxxx.cpp files...
#include "g_headers.h"
#include "g_local.h"
#include "b_local.h"
#include "g_functions.h"
#include "anims.h"
#include "objectives.h"
#include "../cgame/cg_local.h"
#include "g_icarus.h"
#include "wp_saber.h"
#include "Q3_Interface.h"
#include "../qcommon/stripPublic.h"
extern cvar_t *g_debugDamage;
extern qboolean stop_icarus;
extern cvar_t *g_dismemberment;
extern cvar_t *g_dismemberProbabilities;
extern cvar_t *g_saberRealisticCombat;
extern cvar_t *g_timescale;
extern cvar_t *d_slowmodeath;
extern gentity_t *player;
gentity_t *g_lastClientDamaged;
extern int killPlayerTimer;
extern void NPC_TempLookTarget ( gentity_t *self, int lookEntNum, int minLookTime, int maxLookTime );
extern void G_AddVoiceEvent( gentity_t *self, int event, int speakDebounceTime );
extern qboolean PM_HasAnimation( gentity_t *ent, int animation );
extern qboolean G_TeamEnemy( gentity_t *self );
extern void CG_ChangeWeapon( int num );
extern void ChangeWeapon( gentity_t *ent, int newWeapon );
extern void G_SetEnemy( gentity_t *self, gentity_t *enemy );
extern void PM_SetLegsAnimTimer( gentity_t *ent, int *legsAnimTimer, int time );
extern void PM_SetTorsoAnimTimer( gentity_t *ent, int *torsoAnimTimer, int time );
extern int PM_PickAnim( gentity_t *self, int minAnim, int maxAnim );
extern qboolean PM_InOnGroundAnim ( playerState_t *ps );
extern void G_SoundOnEnt( gentity_t *ent, soundChannel_t channel, const char *soundPath );
extern void G_ATSTCheckPain( gentity_t *self, gentity_t *other, vec3_t point, int damage, int mod,int hitLoc );
extern qboolean Jedi_WaitingAmbush( gentity_t *self );
extern qboolean G_ClearViewEntity( gentity_t *ent );
extern qboolean PM_CrouchAnim( int anim );
extern qboolean PM_InKnockDown( playerState_t *ps );
extern qboolean PM_InRoll( playerState_t *ps );
extern qboolean PM_SpinningAnim( int anim );
extern qboolean PM_RunningAnim( int anim );
extern int PM_PowerLevelForSaberAnim( playerState_t *ps );
extern qboolean PM_SaberInSpecialAttack( int anim );
extern qboolean PM_SpinningSaberAnim( int anim );
extern qboolean PM_FlippingAnim( int anim );
extern qboolean PM_InSpecialJump( int anim );
extern qboolean PM_RollingAnim( int anim );
extern qboolean PM_InAnimForSaberMove( int anim, int saberMove );
extern qboolean PM_SaberInStart( int move );
extern qboolean PM_SaberInReturn( int move );
extern int PM_AnimLength( int index, animNumber_t anim );
static int G_CheckForLedge( gentity_t *self, vec3_t fallCheckDir, float checkDist );
static int G_CheckSpecialDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc );
static int G_PickDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc );
static void G_TrackWeaponUsage( gentity_t *self, gentity_t *inflictor, int add, int mod );
static qboolean G_Dismemberable( gentity_t *self, int hitLoc );
extern gitem_t *FindItemForAmmo( ammo_t ammo );
/*
============
AddScore
Adds score to both the client and his team
============
*/
void AddScore( gentity_t *ent, int score ) {
if ( !ent->client ) {
return;
}
// no scoring during pre-match warmup
ent->client->ps.persistant[PERS_SCORE] += score;
}
/*
=================
TossClientItems
Toss the weapon and powerups for the killed player
=================
*/
extern gentity_t *WP_DropThermal( gentity_t *ent );
extern qboolean WP_SaberLose( gentity_t *self, vec3_t throwDir );
gentity_t *TossClientItems( gentity_t *self )
{
gentity_t *dropped = NULL;
gitem_t *item = NULL;
int weapon;
if ( self->client->NPC_class == CLASS_SEEKER || self->client->NPC_class == CLASS_REMOTE )
{
// these things are so small that they shouldn't bother throwing anything
return NULL;
}
// drop the weapon if not a saber or enemy-only weapon
weapon = self->s.weapon;
if ( weapon == WP_SABER )
{
if ( self->weaponModel < 0 || WP_SaberLose( self, NULL ) )
{
self->s.weapon = WP_NONE;
}
}
else if ( weapon == WP_BLASTER_PISTOL )
{//FIXME: either drop the pistol and make the pickup only give ammo or drop ammo
}
else if ( weapon > WP_SABER && weapon <= MAX_PLAYER_WEAPONS )//&& self->client->ps.ammo[ weaponData[weapon].ammoIndex ]
{
self->s.weapon = WP_NONE;
if ( weapon == WP_THERMAL && self->client->ps.torsoAnim == BOTH_ATTACK10 )
{//we were getting ready to throw the thermal, drop it!
self->client->ps.weaponChargeTime = level.time - FRAMETIME;//so it just kind of drops it
dropped = WP_DropThermal( self );
}
else
{// find the item type for this weapon
item = FindItemForWeapon( (weapon_t) weapon );
}
if ( item && !dropped )
{
// spawn the item
dropped = Drop_Item( self, item, 0, qtrue );
//TEST: dropped items never go away
dropped->e_ThinkFunc = thinkF_NULL;
dropped->nextthink = -1;
if ( !self->s.number )
{//player's dropped items never go away
//dropped->e_ThinkFunc = thinkF_NULL;
//dropped->nextthink = -1;
dropped->count = 0;//no ammo
}
else
{//FIXME: base this on the NPC's actual amount of ammo he's used up...
switch ( weapon )
{
case WP_BRYAR_PISTOL:
dropped->count = 20;
break;
case WP_BLASTER:
dropped->count = 15;
break;
case WP_DISRUPTOR:
dropped->count = 20;
break;
case WP_BOWCASTER:
dropped->count = 5;
break;
case WP_REPEATER:
dropped->count = 20;
break;
case WP_DEMP2:
dropped->count = 10;
break;
case WP_FLECHETTE:
dropped->count = 30;
break;
case WP_ROCKET_LAUNCHER:
dropped->count = 3;
break;
case WP_THERMAL:
dropped->count = 4;
break;
case WP_TRIP_MINE:
dropped->count = 3;
break;
case WP_DET_PACK:
dropped->count = 1;
break;
case WP_STUN_BATON:
dropped->count = 20;
break;
default:
dropped->count = 0;
break;
}
}
// well, dropped weapons are G2 models, so they have to be initialised if they want to draw..give us a radius so we don't get prematurely culled
if ( weapon != WP_THERMAL
&& weapon != WP_TRIP_MINE
&& weapon != WP_DET_PACK )
{
gi.G2API_InitGhoul2Model( dropped->ghoul2, item->world_model, G_ModelIndex( item->world_model ));
dropped->s.radius = 10;
}
}
}
// else if (( self->client->NPC_class == CLASS_SENTRY ) || ( self->client->NPC_class == CLASS_PROBE )) // Looks dumb, Steve told us to take it out.
// {
// item = FindItemForAmmo( AMMO_BLASTER );
// Drop_Item( self, item, 0, qtrue );
// }
else if ( self->client->NPC_class == CLASS_MARK1 )
{
if (Q_irand( 1, 2 )>1)
{
item = FindItemForAmmo( AMMO_METAL_BOLTS );
}
else
{
item = FindItemForAmmo( AMMO_BLASTER );
}
Drop_Item( self, item, 0, qtrue );
}
else if ( self->client->NPC_class == CLASS_MARK2 )
{
if (Q_irand( 1, 2 )>1)
{
item = FindItemForAmmo( AMMO_METAL_BOLTS );
}
else
{
item = FindItemForAmmo( AMMO_POWERCELL );
}
Drop_Item( self, item, 0, qtrue );
}
return dropped;//NOTE: presumes only drop one thing
}
void G_DropKey( gentity_t *self )
{//drop whatever security key I was holding
gitem_t *item = NULL;
if ( !Q_stricmp( "goodie", self->message ) )
{
item = FindItemForInventory( INV_GOODIE_KEY );
}
else
{
item = FindItemForInventory( INV_SECURITY_KEY );
}
gentity_t *dropped = Drop_Item( self, item, 0, qtrue );
//Don't throw the key
VectorClear( dropped->s.pos.trDelta );
dropped->message = G_NewString( self->message );
self->message = NULL;
}
void ObjectDie (gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath )
{
if(self->target)
G_UseTargets(self, attacker);
//remove my script_targetname
G_FreeEntity( self );
}
/*
==================
ExplodeDeath
==================
*/
//FIXME: all hacked up...
//void CG_SurfaceExplosion( vec3_t origin, vec3_t normal, float radius, float shake_speed, qboolean smoke );
void ExplodeDeath( gentity_t *self )
{
// gentity_t *tent;
vec3_t forward;
self->takedamage = qfalse;//stop chain reaction runaway loops
self->s.loopSound = 0;
VectorCopy( self->currentOrigin, self->s.pos.trBase );
// tent = G_TempEntity( self->s.origin, EV_FX_EXPLOSION );
AngleVectors(self->s.angles, forward, NULL, NULL); // FIXME: letting effect always shoot up? Might be ok.
if ( self->fxID > 0 )
{
G_PlayEffect( self->fxID, self->currentOrigin, forward );
}
// else
// {
// CG_SurfaceExplosion( self->currentOrigin, forward, 20.0f, 12.0f, ((self->spawnflags&4)==qfalse) ); //FIXME: This needs to be consistent to all exploders!
// G_Sound(self, self->sounds );
// }
if(self->splashDamage > 0 && self->splashRadius > 0)
{
gentity_t *attacker = self;
if ( self->owner )
{
attacker = self->owner;
}
G_RadiusDamage( self->currentOrigin, attacker, self->splashDamage, self->splashRadius,
attacker, MOD_UNKNOWN );
}
ObjectDie( self, self, self, 20, 0 );
}
void ExplodeDeath_Wait( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc )
{
self->e_DieFunc = dieF_NULL;
self->nextthink = level.time + Q_irand(100, 500);
self->e_ThinkFunc = thinkF_ExplodeDeath;
}
void ExplodeDeath( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath,int dFlags,int hitLoc )
{
self->currentOrigin[2] += 16; // me bad for hacking this. should either do it in the effect file or make a custom explode death??
ExplodeDeath( self );
}
void GoExplodeDeath( gentity_t *self, gentity_t *other, gentity_t *activator)
{
G_ActivateBehavior(self,BSET_USE);
self->targetname = ""; //Make sure this entity cannot be told to explode again (recursive death fix)
ExplodeDeath( self );
}
qboolean G_ActivateBehavior (gentity_t *self, int bset );
void G_CheckVictoryScript(gentity_t *self)
{
if ( !G_ActivateBehavior( self, BSET_VICTORY ) )
{
if ( self->NPC && self->s.weapon == WP_SABER )
{//Jedi taunt from within their AI
self->NPC->blockedSpeechDebounceTime = 0;//get them ready to taunt
return;
}
if ( self->client && self->client->NPC_class == CLASS_GALAKMECH )
{
self->wait = 1;
TIMER_Set( self, "gloatTime", Q_irand( 5000, 8000 ) );
self->NPC->blockedSpeechDebounceTime = 0;//get him ready to taunt
return;
}
//FIXME: any way to not say this *right away*? Wait for victim's death anim/scream to finish?
if ( self->NPC && self->NPC->group && self->NPC->group->commander && self->NPC->group->commander->NPC && self->NPC->group->commander->NPC->rank > self->NPC->rank && !Q_irand( 0, 2 ) )
{//sometimes have the group commander speak instead
self->NPC->group->commander->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 );
//G_AddVoiceEvent( self->NPC->group->commander, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 );
}
else if ( self->NPC )
{
self->NPC->greetingDebounceTime = level.time + Q_irand( 2000, 5000 );
//G_AddVoiceEvent( self, Q_irand(EV_VICTORY1, EV_VICTORY3), 2000 );
}
}
}
qboolean OnSameTeam( gentity_t *ent1, gentity_t *ent2 )
{
if ( !ent1->client || !ent2->client )
{
if ( ent1->noDamageTeam )
{
if ( ent2->client && ent2->client->playerTeam == ent1->noDamageTeam )
{
return qtrue;
}
else if ( ent2->noDamageTeam == ent1->noDamageTeam )
{
if ( ent1->splashDamage && ent2->splashDamage && Q_stricmp("ambient_etherian_fliers", ent1->classname) != 0 )
{//Barrels, exploding breakables and mines will blow each other up
return qfalse;
}
else
{
return qtrue;
}
}
}
return qfalse;
}
// shouldn't need this anymore, there were problems with certain droids, but now they have been labeled TEAM_ENEMY so this isn't needed
// if ((( ent1->client->playerTeam == TEAM_IMPERIAL ) && ( ent1->client->playerTeam == TEAM_BOTS )) ||
// (( ent1->client->playerTeam == TEAM_BOTS ) && ( ent1->client->playerTeam == TEAM_IMPERIAL )))
// {
// return qtrue;
// }
return ( ent1->client->playerTeam == ent2->client->playerTeam );
}
/*
-------------------------
G_AlertTeam
-------------------------
*/
void G_AlertTeam( gentity_t *victim, gentity_t *attacker, float radius, float soundDist )
{
gentity_t *radiusEnts[ 128 ];
vec3_t mins, maxs;
int numEnts;
float distSq, sndDistSq = (soundDist*soundDist);
if ( attacker == NULL || attacker->client == NULL )
return;
//Setup the bbox to search in
for ( int i = 0; i < 3; i++ )
{
mins[i] = victim->currentOrigin[i] - radius;
maxs[i] = victim->currentOrigin[i] + radius;
}
//Get the number of entities in a given space
numEnts = gi.EntitiesInBox( mins, maxs, radiusEnts, 128 );
//Cull this list
for ( i = 0; i < numEnts; i++ )
{
//Validate clients
if ( radiusEnts[i]->client == NULL )
continue;
//only want NPCs
if ( radiusEnts[i]->NPC == NULL )
continue;
//Don't bother if they're ignoring enemies
if ( radiusEnts[i]->svFlags & SVF_IGNORE_ENEMIES )
continue;
//This NPC specifically flagged to ignore alerts
if ( radiusEnts[i]->NPC->scriptFlags & SCF_IGNORE_ALERTS )
continue;
//This NPC specifically flagged to ignore alerts
if ( !(radiusEnts[i]->NPC->scriptFlags&SCF_LOOK_FOR_ENEMIES) )
continue;
//this ent does not participate in group AI
if ( (radiusEnts[i]->NPC->scriptFlags&SCF_NO_GROUPS) )
continue;
//Skip the requested avoid radiusEnts[i] if present
if ( radiusEnts[i] == victim )
continue;
//Skip the attacker
if ( radiusEnts[i] == attacker )
continue;
//Must be on the same team
if ( radiusEnts[i]->client->playerTeam != victim->client->playerTeam )
continue;
//Must be alive
if ( radiusEnts[i]->health <= 0 )
continue;
if ( radiusEnts[i]->enemy == NULL )
{//only do this if they're not already mad at someone
distSq = DistanceSquared( radiusEnts[i]->currentOrigin, victim->currentOrigin );
if ( distSq > 16384 /*128 squared*/ && !gi.inPVS( victim->currentOrigin, radiusEnts[i]->currentOrigin ) )
{//not even potentially visible/hearable
continue;
}
//NOTE: this allows sound alerts to still go through doors/PVS if the teammate is within 128 of the victim...
if ( soundDist <= 0 || distSq > sndDistSq )
{//out of sound range
if ( !InFOV( victim, radiusEnts[i], radiusEnts[i]->NPC->stats.hfov, radiusEnts[i]->NPC->stats.vfov )
|| !NPC_ClearLOS( radiusEnts[i], victim->currentOrigin ) )
{//out of FOV or no LOS
continue;
}
}
//FIXME: This can have a nasty cascading effect if setup wrong...
G_SetEnemy( radiusEnts[i], attacker );
}
}
}
/*
-------------------------
G_DeathAlert
-------------------------
*/
#define DEATH_ALERT_RADIUS 512
#define DEATH_ALERT_SOUND_RADIUS 512
void G_DeathAlert( gentity_t *victim, gentity_t *attacker )
{//FIXME: with all the other alert stuff, do we really need this?
G_AlertTeam( victim, attacker, DEATH_ALERT_RADIUS, DEATH_ALERT_SOUND_RADIUS );
}
/*
----------------------------------------
DeathFX
Applies appropriate special effects that occur while the entity is dying
Not to be confused with NPC_RemoveBodyEffects (NPC.cpp), which only applies effect when removing the body
----------------------------------------
*/
void DeathFX( gentity_t *ent )
{
if ( !ent || !ent->client )
return;
/*
switch( ent->client->playerTeam )
{
case TEAM_BOTS:
if (!Q_stricmp( ent->NPC_type, "mouse" ))
{
vec3_t effectPos;
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 20;
G_PlayEffect( "mouseexplosion1", effectPos );
G_PlayEffect( "smaller_chunks", effectPos );
}
else if (!Q_stricmp( ent->NPC_type, "probe" ))
{
vec3_t effectPos;
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] += 50;
G_PlayEffect( "probeexplosion1", effectPos );
G_PlayEffect( "small_chunks", effectPos );
}
else
{
vec3_t effectPos;
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 15;
G_PlayEffect( "droidexplosion1", effectPos );
G_PlayEffect( "small_chunks", effectPos );
}
break;
default:
break;
}
*/
// team no longer indicates species/race. NPC_class should be used to identify certain npc types
vec3_t effectPos, right;
switch(ent->client->NPC_class)
{
case CLASS_MOUSE:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 20;
G_PlayEffect( "env/small_explode", effectPos );
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mouse/misc/death1" );
break;
case CLASS_PROBE:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] += 50;
G_PlayEffect( "probeexplosion1", effectPos );
break;
case CLASS_ATST:
AngleVectors( ent->currentAngles, NULL, right, NULL );
VectorMA( ent->currentOrigin, 20, right, effectPos );
effectPos[2] += 180;
G_PlayEffect( "droidexplosion1", effectPos );
VectorMA( effectPos, -40, right, effectPos );
G_PlayEffect( "droidexplosion1", effectPos );
break;
case CLASS_SEEKER:
case CLASS_REMOTE:
G_PlayEffect( "env/small_explode", ent->currentOrigin );
break;
case CLASS_GONK:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 5;
// statusTextIndex = Q_irand( IGT_RESISTANCEISFUTILE, IGT_NAMEIS8OF12 );
G_SoundOnEnt( ent, CHAN_AUTO, va("sound/chars/gonk/misc/death%d.wav",Q_irand( 1, 3 )) );
G_PlayEffect( "env/med_explode", effectPos );
break;
// should list all remaining droids here, hope I didn't miss any
case CLASS_R2D2:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 10;
G_PlayEffect( "env/med_explode", effectPos );
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark2/misc/mark2_explo" );
break;
case CLASS_PROTOCOL://??
case CLASS_R5D2:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 10;
G_PlayEffect( "env/med_explode", effectPos );
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark2/misc/mark2_explo" );
break;
case CLASS_MARK2:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 15;
G_PlayEffect( "droidexplosion1", effectPos );
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark2/misc/mark2_explo" );
break;
case CLASS_INTERROGATOR:
VectorCopy( ent->currentOrigin, effectPos );
effectPos[2] -= 15;
G_PlayEffect( "droidexplosion1", effectPos );
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/interrogator/misc/int_droid_explo" );
break;
case CLASS_MARK1:
AngleVectors( ent->currentAngles, NULL, right, NULL );
VectorMA( ent->currentOrigin, 10, right, effectPos );
effectPos[2] -= 15;
G_PlayEffect( "droidexplosion1", effectPos );
VectorMA( effectPos, -20, right, effectPos );
G_PlayEffect( "droidexplosion1", effectPos );
VectorMA( effectPos, -20, right, effectPos );
G_PlayEffect( "droidexplosion1", effectPos );
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/mark1/misc/mark1_explo" );
break;
case CLASS_SENTRY:
G_SoundOnEnt( ent, CHAN_AUTO, "sound/chars/sentry/misc/sentry_explo" );
VectorCopy( ent->currentOrigin, effectPos );
G_PlayEffect( "env/med_explode", effectPos );
break;
default:
break;
}
}
void G_SetMissionStatusText( gentity_t *attacker, int mod )
{
if ( statusTextIndex >= 0 )
{
return;
}
if ( mod == MOD_FALLING )
{//fell to your death
statusTextIndex = STAT_WATCHYOURSTEP;
}
else if ( mod == MOD_CRUSH )
{//crushed
statusTextIndex = STAT_JUDGEMENTMUCHDESIRED;
}
// borg no longer exist
// else if ( attacker && attacker->client && attacker->client->playerTeam == TEAM_BORG )
// {//assimilated
// statusTextIndex = Q_irand( IGT_RESISTANCEISFUTILE, IGT_NAMEIS8OF12 );
// }
else if ( attacker && Q_stricmp( "trigger_hurt", attacker->classname ) == 0 )
{//Killed by something that should have been clearly dangerous
// statusTextIndex = Q_irand( IGT_JUDGEMENTDESIRED, IGT_JUDGEMENTMUCHDESIRED );
statusTextIndex = STAT_JUDGEMENTMUCHDESIRED;
}
else if ( attacker && attacker->s.number != 0 && attacker->client && attacker->client->playerTeam == TEAM_PLAYER )
{//killed by a teammate
statusTextIndex = STAT_INSUBORDINATION;
}
/*
else if ()
{//killed a teammate- note: handled above
if ( Q_irand( 0, 1 ) )
{
statusTextIndex = IGT_YOUCAUSEDDEATHOFTEAMMATE;
}
else
{
statusTextIndex = IGT_KILLEDANINNOCENTCREWMAN;
}
}
else
{
//This next block is not contiguous
IGT_INADEQUATE,
IGT_RESPONSETIME,
IGT_SHOOTINRANGE,
IGT_TRYAGAIN,
IGT_TRAINONHOLODECK,
IGT_WHATCOLORSHIRT,
IGT_NOTIMPRESS7OF9,
IGT_NEELIXFAREDBETTER,
IGT_THATMUSTHURT,
IGT_TUVOKDISAPPOINTED,
IGT_STARFLEETNOTIFYFAMILY,
IGT_TEAMMATESWILLMISSYOU,
IGT_LESSTHANEXEMPLARY,
IGT_SACRIFICEDFORTHEWHOLE,
IGT_NOTLIVELONGANDPROSPER,
IGT_BETTERUSEOFSIMULATIONS,
}
*/
/*
//These can be set by designers
IGT_INSUBORDINATION,
IGT_YOUCAUSEDDEATHOFTEAMMATE,
IGT_DIDNTPROTECTTECH,
IGT_DIDNTPROTECT7OF9,
IGT_NOTSTEALTHYENOUGH,
IGT_STEALTHTACTICSNECESSARY,
*/
}
void G_MakeTeamVulnerable( void )
{
int i, newhealth;
gentity_t *ent;
gentity_t *self = &g_entities[0];
if ( !self->client )
{
return;
}
// for ( i = 0; i < globals.num_entities ; i++, ent++)
for ( i = 0; i < globals.num_entities ; i++)
{
if(!PInUse(i))
continue;
// if ( !ent->inuse )
// {
// continue;
// }
// if ( !ent )
// {
// continue;
// }
ent=&g_entities[i];
if ( !ent->client )
{
continue;
}
if ( ent->client->playerTeam != TEAM_PLAYER )
{
continue;
}
if ( !(ent->flags&FL_UNDYING) )
{
continue;
}
ent->flags &= ~FL_UNDYING;
newhealth = Q_irand( 5, 40 );
if ( ent->health > newhealth )
{
ent->health = newhealth;
}
}
}
void G_StartMatrixEffect( gentity_t *ent, qboolean falling = qfalse, int length = 1000 )
{//FIXME: only do this if no other enemies around?
if ( g_timescale->value != 1.0 )
{//already in some slow-mo mode
return;
}
gentity_t *matrix = G_Spawn();
if ( matrix )
{
G_SetOrigin( matrix, ent->currentOrigin );
gi.linkentity( matrix );
matrix->s.otherEntityNum = ent->s.number;
matrix->e_clThinkFunc = clThinkF_CG_MatrixEffect;
matrix->s.eType = ET_THINKER;
matrix->svFlags |= SVF_BROADCAST;// Broadcast to all clients
matrix->s.time = level.time;
matrix->s.eventParm = length;
matrix->e_ThinkFunc = thinkF_G_FreeEntity;
matrix->nextthink = level.time + length + 500;
if ( falling )
{//no timescale or vert bob
matrix->s.weapon = 1;
}
}
}
qboolean G_JediInRoom( vec3_t from )
{
gentity_t *ent;
int i;
// for ( i = 1, ent = &g_entities[1]; i < globals.num_entities; i++, ent++ )
for ( i = 1; i < globals.num_entities; i++)
{
if(!PInUse(i))
continue;
// if ( !ent->inuse )
// {
// continue;
// }
// if ( !ent )
// {
// continue;
// }
ent = &g_entities[i];
if ( !ent->NPC )
{
continue;
}
if ( ent->health <= 0 )
{
continue;
}
if ( ent->s.eFlags&EF_NODRAW )
{
continue;
}
if ( ent->s.weapon != WP_SABER )
{
continue;
}
if ( !gi.inPVS( ent->currentOrigin, from ) )
{
continue;
}
return qtrue;
}
return qfalse;
}
qboolean G_GetHitLocFromSurfName( gentity_t *ent, const char *surfName, int *hitLoc, vec3_t point, vec3_t dir, vec3_t bladeDir, int mod )
{
qboolean dismember = qfalse;
*hitLoc = HL_NONE;
if ( !surfName || !surfName[0] )
{
return qfalse;
}
if( !ent->client )
{
return qfalse;
}
if ( ent->client
&& ( ent->client->NPC_class == CLASS_R2D2
|| ent->client->NPC_class == CLASS_R2D2
|| ent->client->NPC_class == CLASS_GONK
|| ent->client->NPC_class == CLASS_MOUSE
|| ent->client->NPC_class == CLASS_SENTRY
|| ent->client->NPC_class == CLASS_INTERROGATOR
|| ent->client->NPC_class == CLASS_SENTRY
|| ent->client->NPC_class == CLASS_PROBE ) )
{//we don't care about per-surface hit-locations or dismemberment for these guys
return qfalse;
}
if ( ent->client && (ent->client->NPC_class == CLASS_ATST) )
{
//FIXME: almost impossible to hit these... perhaps we should
// check for splashDamage and do radius damage to these parts?
// Or, if we ever get bbox G2 traces, that may fix it, too
if (!Q_stricmp("head_light_blaster_cann",surfName))
{
*hitLoc = HL_ARM_LT;
}
else if (!Q_stricmp("head_concussion_charger",surfName))
{
*hitLoc = HL_ARM_RT;
}
return(qfalse);
}
else if ( ent->client && (ent->client->NPC_class == CLASS_MARK1) )
{
if (!Q_stricmp("l_arm",surfName))
{
*hitLoc = HL_ARM_LT;
}
else if (!Q_stricmp("r_arm",surfName))
{
*hitLoc = HL_ARM_RT;
}
else if (!Q_stricmp("torso_front",surfName))
{
*hitLoc = HL_CHEST;
}
else if (!Q_stricmp("torso_tube1",surfName))
{
*hitLoc = HL_GENERIC1;
}
else if (!Q_stricmp("torso_tube2",surfName))
{
*hitLoc = HL_GENERIC2;
}
else if (!Q_stricmp("torso_tube3",surfName))
{
*hitLoc = HL_GENERIC3;
}
else if (!Q_stricmp("torso_tube4",surfName))
{
*hitLoc = HL_GENERIC4;
}
else if (!Q_stricmp("torso_tube5",surfName))
{
*hitLoc = HL_GENERIC5;
}
else if (!Q_stricmp("torso_tube6",surfName))
{
*hitLoc = HL_GENERIC6;
}
return(qfalse);
}
else if ( ent->client && (ent->client->NPC_class == CLASS_MARK2) )
{
if (!Q_stricmp("torso_canister1",surfName))
{
*hitLoc = HL_GENERIC1;
}
else if (!Q_stricmp("torso_canister2",surfName))
{
*hitLoc = HL_GENERIC2;
}
else if (!Q_stricmp("torso_canister3",surfName))
{
*hitLoc = HL_GENERIC3;
}
return(qfalse);
}
else if ( ent->client && (ent->client->NPC_class == CLASS_GALAKMECH) )
{
if (!Q_stricmp("torso_antenna",surfName)||!Q_stricmp("torso_antenna_base",surfName))
{
*hitLoc = HL_GENERIC1;
}
else if (!Q_stricmp("torso_shield_off",surfName))
{
*hitLoc = HL_GENERIC2;
}
else
{
*hitLoc = HL_CHEST;
}
return(qfalse);
}
//FIXME: check the hitLoc and hitDir against the cap tag for the place
//where the split will be- if the hit dir is roughly perpendicular to
//the direction of the cap, then the split is allowed, otherwise we
//hit it at the wrong angle and should not dismember...
int actualTime = (cg.time?cg.time:level.time);
if ( !Q_strncmp( "hips", surfName, 4 ) )
{//FIXME: test properly for legs
*hitLoc = HL_WAIST;
if ( ent->client != NULL && ent->ghoul2.size() )
{
mdxaBone_t boltMatrix;
vec3_t tagOrg, angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
if (ent->kneeLBolt>=0)
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->kneeLBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
if ( DistanceSquared( point, tagOrg ) < 100 )
{//actually hit the knee
*hitLoc = HL_LEG_LT;
}
}
if (*hitLoc == HL_WAIST)
{
if (ent->kneeRBolt>=0)
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->kneeRBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
if ( DistanceSquared( point, tagOrg ) < 100 )
{//actually hit the knee
*hitLoc = HL_LEG_RT;
}
}
}
}
}
else if ( !Q_strncmp( "torso", surfName, 5 ) )
{
if ( !ent->client )
{
*hitLoc = HL_CHEST;
}
else
{
vec3_t t_fwd, t_rt, t_up, dirToImpact;
float frontSide, rightSide, upSide;
AngleVectors( ent->client->renderInfo.torsoAngles, t_fwd, t_rt, t_up );
VectorSubtract( point, ent->client->renderInfo.torsoPoint, dirToImpact );
frontSide = DotProduct( t_fwd, dirToImpact );
rightSide = DotProduct( t_rt, dirToImpact );
upSide = DotProduct( t_up, dirToImpact );
if ( upSide < -10 )
{//hit at waist
*hitLoc = HL_WAIST;
}
else
{//hit on upper torso
if ( rightSide > 4 )
{
*hitLoc = HL_ARM_RT;
}
else if ( rightSide < -4 )
{
*hitLoc = HL_ARM_LT;
}
else if ( rightSide > 2 )
{
if ( frontSide > 0 )
{
*hitLoc = HL_CHEST_RT;
}
else
{
*hitLoc = HL_BACK_RT;
}
}
else if ( rightSide < -2 )
{
if ( frontSide > 0 )
{
*hitLoc = HL_CHEST_LT;
}
else
{
*hitLoc = HL_BACK_LT;
}
}
else if ( upSide > -3 && mod == MOD_SABER )
{
*hitLoc = HL_HEAD;
}
else if ( frontSide > 0 )
{
*hitLoc = HL_CHEST;
}
else
{
*hitLoc = HL_BACK;
}
}
}
}
else if ( !Q_strncmp( "head", surfName, 4 ) )
{
*hitLoc = HL_HEAD;
}
else if ( !Q_strncmp( "r_arm", surfName, 5 ) )
{
*hitLoc = HL_ARM_RT;
if ( ent->client != NULL && ent->ghoul2.size() )
{
mdxaBone_t boltMatrix;
vec3_t tagOrg, angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
if (ent->handRBolt>=0)
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->handRBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
if ( DistanceSquared( point, tagOrg ) < 256 )
{//actually hit the hand
*hitLoc = HL_HAND_RT;
}
}
}
}
else if ( !Q_strncmp( "l_arm", surfName, 5 ) )
{
*hitLoc = HL_ARM_LT;
if ( ent->client != NULL && ent->ghoul2.size() )
{
mdxaBone_t boltMatrix;
vec3_t tagOrg, angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
if (ent->handLBolt>=0)
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->handLBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
if ( DistanceSquared( point, tagOrg ) < 256 )
{//actually hit the hand
*hitLoc = HL_HAND_LT;
}
}
}
}
else if ( !Q_strncmp( "r_leg", surfName, 5 ) )
{
*hitLoc = HL_LEG_RT;
if ( ent->client != NULL && ent->ghoul2.size() )
{
mdxaBone_t boltMatrix;
vec3_t tagOrg, angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
if (ent->footRBolt>=0)
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->footRBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
if ( DistanceSquared( point, tagOrg ) < 100 )
{//actually hit the foot
*hitLoc = HL_FOOT_RT;
}
}
}
}
else if ( !Q_strncmp( "l_leg", surfName, 5 ) )
{
*hitLoc = HL_LEG_LT;
if ( ent->client != NULL && ent->ghoul2.size() )
{
mdxaBone_t boltMatrix;
vec3_t tagOrg, angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
if (ent->footLBolt>=0)
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, ent->footLBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
if ( DistanceSquared( point, tagOrg ) < 100 )
{//actually hit the foot
*hitLoc = HL_FOOT_LT;
}
}
}
}
else if ( !Q_strncmp( "r_hand", surfName, 6 ) || !Q_strncmp( "w_", surfName, 2 ) )
{//right hand or weapon
*hitLoc = HL_HAND_RT;
}
else if ( !Q_strncmp( "l_hand", surfName, 6 ) )
{
*hitLoc = HL_HAND_LT;
}
#ifdef _DEBUG
else
{
Com_Printf( "ERROR: surface %s does not belong to any hitLocation!!!\n", surfName );
}
#endif //_DEBUG
if ( g_saberRealisticCombat->integer )
{
dismember = qtrue;
}
else if ( g_dismemberment->integer >= 11381138 || !ent->client->dismembered )
{
if ( ent->client && ent->client->NPC_class == CLASS_PROTOCOL )
{
dismember = qtrue;
}
else if ( dir && (dir[0] || dir[1] || dir[2]) &&
bladeDir && (bladeDir[0] || bladeDir[1] || bladeDir[2]) )
{//we care about direction (presumably for dismemberment)
if ( g_dismemberProbabilities->value<=0.0f||G_Dismemberable( ent, *hitLoc ) )
{//either we don't care about probabilties or the probability let us continue
char *tagName = NULL;
float aoa = 0.5f;
//dir must be roughly perpendicular to the hitLoc's cap bolt
switch ( *hitLoc )
{
case HL_LEG_RT:
tagName = "*hips_cap_r_leg";
break;
case HL_LEG_LT:
tagName = "*hips_cap_l_leg";
break;
case HL_WAIST:
tagName = "*hips_cap_torso";
aoa = 0.25f;
break;
case HL_CHEST_RT:
case HL_ARM_RT:
case HL_BACK_LT:
tagName = "*torso_cap_r_arm";
break;
case HL_CHEST_LT:
case HL_ARM_LT:
case HL_BACK_RT:
tagName = "*torso_cap_l_arm";
break;
case HL_HAND_RT:
tagName = "*r_arm_cap_r_hand";
break;
case HL_HAND_LT:
tagName = "*l_arm_cap_l_hand";
break;
case HL_HEAD:
tagName = "*torso_cap_head";
aoa = 0.25f;
break;
case HL_CHEST:
case HL_BACK:
case HL_FOOT_RT:
case HL_FOOT_LT:
default:
//no dismemberment possible with these, so no checks needed
break;
}
if ( tagName )
{
int tagBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], tagName );
if ( tagBolt != -1 )
{
mdxaBone_t boltMatrix;
vec3_t tagOrg, tagDir, angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, tagBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, tagOrg );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, tagDir );
if ( DistanceSquared( point, tagOrg ) < 256 )
{//hit close
float dot = DotProduct( dir, tagDir );
if ( dot < aoa && dot > -aoa )
{//hit roughly perpendicular
dot = DotProduct( bladeDir, tagDir );
if ( dot < aoa && dot > -aoa )
{//blade was roughly perpendicular
dismember = qtrue;
}
}
}
}
}
}
}
}
return dismember;
}
int G_GetHitLocation ( gentity_t *target, vec3_t ppoint )
{
vec3_t point, point_dir;
vec3_t forward, right, up;
vec3_t tangles, tcenter;
float tradius;
float udot, fdot, rdot;
int Vertical, Forward, Lateral;
int HitLoc;
//get target forward, right and up
if(target->client)
{//ignore player's pitch and roll
VectorSet(tangles, 0, target->currentAngles[YAW], 0);
}
AngleVectors(tangles, forward, right, up);
//get center of target
VectorAdd(target->absmin, target->absmax, tcenter);
VectorScale(tcenter, 0.5, tcenter);
//get radius width of target
tradius = (fabs(target->maxs[0]) + fabs(target->maxs[1]) + fabs(target->mins[0]) + fabs(target->mins[1]))/4;
//get impact point
if(ppoint && !VectorCompare(ppoint, vec3_origin))
{
VectorCopy(ppoint, point);
}
else
{
return HL_NONE;
}
/*
//get impact dir
if(pdir && !VectorCompare(pdir, vec3_origin))
{
VectorCopy(pdir, dir);
}
else
{
return;
}
//put point at controlled distance from center
VectorSubtract(point, tcenter, tempvec);
tempvec[2] = 0;
hdist = VectorLength(tempvec);
VectorMA(point, hdist - tradius, dir, point);
//now a point on the surface of a cylinder with a radius of tradius
*/
VectorSubtract(point, tcenter, point_dir);
VectorNormalize(point_dir);
//Get bottom to top (Vertical) position index
udot = DotProduct(up, point_dir);
if(udot>.800)
Vertical = 4;
else if(udot>.400)
Vertical = 3;
else if(udot>-.333)
Vertical = 2;
else if(udot>-.666)
Vertical = 1;
else
Vertical = 0;
//Get back to front (Forward) position index
fdot = DotProduct(forward, point_dir);
if(fdot>.666)
Forward = 4;
else if(fdot>.333)
Forward = 3;
else if(fdot>-.333)
Forward = 2;
else if(fdot>-.666)
Forward = 1;
else
Forward = 0;
//Get left to right (Lateral) position index
rdot = DotProduct(right, point_dir);
if(rdot>.666)
Lateral = 4;
else if(rdot>.333)
Lateral = 3;
else if(rdot>-.333)
Lateral = 2;
else if(rdot>-.666)
Lateral = 1;
else
Lateral = 0;
HitLoc = Vertical * 25 + Forward * 5 + Lateral;
if(HitLoc <= 10)
{//feet
if ( rdot > 0 )
{
return HL_FOOT_RT;
}
else
{
return HL_FOOT_LT;
}
}
else if(HitLoc <= 50)
{//legs
if ( rdot > 0 )
{
return HL_LEG_RT;
}
else
{
return HL_LEG_LT;
}
}
else if ( HitLoc == 56||HitLoc == 60||HitLoc == 61||HitLoc == 65||HitLoc == 66||HitLoc == 70 )
{//hands
if ( rdot > 0 )
{
return HL_HAND_RT;
}
else
{
return HL_HAND_LT;
}
}
else if ( HitLoc == 83||HitLoc == 87||HitLoc == 88||HitLoc == 92||HitLoc == 93||HitLoc == 97 )
{//arms
if ( rdot > 0 )
{
return HL_ARM_RT;
}
else
{
return HL_ARM_LT;
}
}
else if((HitLoc >= 107 && HitLoc <= 109)||
(HitLoc >= 112 && HitLoc <= 114)||
(HitLoc >= 117 && HitLoc <= 119))
{//head
return HL_HEAD;
}
else
{
if ( udot < 0.3 )
{
return HL_WAIST;
}
else if ( fdot < 0 )
{
if ( rdot > 0.4 )
{
return HL_BACK_RT;
}
else if ( rdot < -0.4 )
{
return HL_BACK_LT;
}
else
{
return HL_BACK;
}
}
else
{
if ( rdot > 0.3 )
{
return HL_CHEST_RT;
}
else if ( rdot < -0.3 )
{
return HL_CHEST_LT;
}
else
{
return HL_CHEST;
}
}
}
//return HL_NONE;
}
int G_PickPainAnim( gentity_t *self, vec3_t point, int damage, int hitLoc = HL_NONE )
{
if ( hitLoc == HL_NONE )
{
hitLoc = G_GetHitLocation( self, point );
}
switch( hitLoc )
{
case HL_FOOT_RT:
return BOTH_PAIN12;
//PAIN12 = right foot
break;
case HL_FOOT_LT:
return -1;
break;
case HL_LEG_RT:
if ( !Q_irand( 0, 1 ) )
{
return BOTH_PAIN11;
}
else
{
return BOTH_PAIN13;
}
//PAIN11 = twitch right leg
//PAIN13 = right knee
break;
case HL_LEG_LT:
return BOTH_PAIN14;
//PAIN14 = twitch left leg
break;
case HL_BACK_RT:
return BOTH_PAIN7;
//PAIN7 = med left shoulder
break;
case HL_BACK_LT:
return Q_irand( BOTH_PAIN15, BOTH_PAIN16 );
//PAIN15 = med right shoulder
//PAIN16 = twitch right shoulder
break;
case HL_BACK:
if ( !Q_irand( 0, 1 ) )
{
return BOTH_PAIN1;
}
else
{
return BOTH_PAIN5;
}
//PAIN1 = back
//PAIN5 = same as 1
break;
case HL_CHEST_RT:
return BOTH_PAIN3;
//PAIN3 = long, right shoulder
break;
case HL_CHEST_LT:
return BOTH_PAIN2;
//PAIN2 = long, left shoulder
break;
case HL_WAIST:
case HL_CHEST:
if ( !Q_irand( 0, 3 ) )
{
return BOTH_PAIN6;
}
else if ( !Q_irand( 0, 2 ) )
{
return BOTH_PAIN8;
}
else if ( !Q_irand( 0, 1 ) )
{
return BOTH_PAIN17;
}
else
{
return BOTH_PAIN19;
}
//PAIN6 = gut
//PAIN8 = chest
//PAIN17 = twitch crotch
//PAIN19 = med crotch
break;
case HL_ARM_RT:
case HL_HAND_RT:
return BOTH_PAIN9;
//PAIN9 = twitch right arm
break;
case HL_ARM_LT:
case HL_HAND_LT:
return BOTH_PAIN10;
//PAIN10 = twitch left arm
break;
case HL_HEAD:
return BOTH_PAIN4;
//PAIN4 = head
break;
default:
return -1;
break;
}
}
extern void G_BounceMissile( gentity_t *ent, trace_t *trace );
void LimbThink( gentity_t *ent )
{//FIXME: just use object thinking?
vec3_t origin;
trace_t tr;
ent->nextthink = level.time + FRAMETIME;
if ( ent->enemy )
{//alert people that I am a piece of one of their friends
AddSightEvent( ent->enemy, ent->currentOrigin, 384, AEL_DISCOVERED );
}
if ( ent->s.pos.trType == TR_STATIONARY )
{//stopped
if ( level.time > ent->s.apos.trTime + ent->s.apos.trDuration )
{
ent->nextthink = level.time + Q_irand( 5000, 15000 );
ent->e_ThinkFunc = thinkF_G_FreeEntity;
//FIXME: these keep drawing for a frame or so after being freed?! See them lerp to origin of world...
}
else
{
EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
}
return;
}
// get current position
EvaluateTrajectory( &ent->s.pos, level.time, origin );
// get current angles
EvaluateTrajectory( &ent->s.apos, level.time, ent->currentAngles );
// trace a line from the previous position to the current position,
// ignoring interactions with the missile owner
gi.trace( &tr, ent->currentOrigin, ent->mins, ent->maxs, origin,
ent->owner ? ent->owner->s.number : ENTITYNUM_NONE, ent->clipmask );
VectorCopy( tr.endpos, ent->currentOrigin );
if ( tr.startsolid )
{
tr.fraction = 0;
}
gi.linkentity( ent );
if ( tr.fraction != 1 )
{
G_BounceMissile( ent, &tr );
if ( ent->s.pos.trType == TR_STATIONARY )
{//stopped, stop spinning
//lay flat
//pitch
VectorCopy( ent->currentAngles, ent->s.apos.trBase );
vec3_t flatAngles;
if ( ent->s.angles2[0] == -1 )
{//any pitch is okay
flatAngles[0] = ent->currentAngles[0];
}
else
{//lay flat
if ( ent->owner
&& ent->owner->client
&& ent->owner->client->NPC_class == CLASS_PROTOCOL
&& ent->count == BOTH_DISMEMBER_TORSO1 )
{
if ( ent->currentAngles[0] > 0 || ent->currentAngles[0] < -180 )
{
flatAngles[0] = -90;
}
else
{
flatAngles[0] = 90;
}
}
else
{
if ( ent->currentAngles[0] > 90 || ent->currentAngles[0] < -90 )
{
flatAngles[0] = 180;
}
else
{
flatAngles[0] = 0;
}
}
}
//yaw
flatAngles[1] = ent->currentAngles[1];
//roll
if ( ent->s.angles2[2] == -1 )
{//any roll is okay
flatAngles[2] = ent->currentAngles[2];
}
else
{
if ( ent->currentAngles[2] > 90 || ent->currentAngles[2] < -90 )
{
flatAngles[2] = 180;
}
else
{
flatAngles[2] = 0;
}
}
VectorSubtract( flatAngles, ent->s.apos.trBase, ent->s.apos.trDelta );
for ( int i = 0; i < 3; i++ )
{
ent->s.apos.trDelta[i] = AngleNormalize180( ent->s.apos.trDelta[i] );
}
ent->s.apos.trTime = level.time;
ent->s.apos.trDuration = 1000;
ent->s.apos.trType = TR_LINEAR_STOP;
//VectorClear( ent->s.apos.trDelta );
}
}
}
float hitLocHealthPercentage[HL_MAX] =
{
0.0f, //HL_NONE = 0,
0.05f, //HL_FOOT_RT,
0.05f, //HL_FOOT_LT,
0.20f, //HL_LEG_RT,
0.20f, //HL_LEG_LT,
0.30f, //HL_WAIST,
0.15f, //HL_BACK_RT,
0.15f, //HL_BACK_LT,
0.30f, //HL_BACK,
0.15f, //HL_CHEST_RT,
0.15f, //HL_CHEST_LT,
0.30f, //HL_CHEST,
0.05f, //HL_ARM_RT,
0.05f, //HL_ARM_LT,
0.01f, //HL_HAND_RT,
0.01f, //HL_HAND_LT,
0.10f, //HL_HEAD
0.0f, //HL_GENERIC1,
0.0f, //HL_GENERIC2,
0.0f, //HL_GENERIC3,
0.0f, //HL_GENERIC4,
0.0f, //HL_GENERIC5,
0.0f //HL_GENERIC6
};
char *hitLocName[HL_MAX] =
{
"none", //HL_NONE = 0,
"right foot", //HL_FOOT_RT,
"left foot", //HL_FOOT_LT,
"right leg", //HL_LEG_RT,
"left leg", //HL_LEG_LT,
"waist", //HL_WAIST,
"back right shoulder", //HL_BACK_RT,
"back left shoulder", //HL_BACK_LT,
"back", //HL_BACK,
"front right shouler", //HL_CHEST_RT,
"front left shoulder", //HL_CHEST_LT,
"chest", //HL_CHEST,
"right arm", //HL_ARM_RT,
"left arm", //HL_ARM_LT,
"right hand", //HL_HAND_RT,
"left hand", //HL_HAND_LT,
"head", //HL_HEAD
"generic1", //HL_GENERIC1,
"generic2", //HL_GENERIC2,
"generic3", //HL_GENERIC3,
"generic4", //HL_GENERIC4,
"generic5", //HL_GENERIC5,
"generic6" //HL_GENERIC6
};
qboolean G_LimbLost( gentity_t *ent, int hitLoc )
{
switch ( hitLoc )
{
case HL_FOOT_RT:
if ( ent->locationDamage[HL_FOOT_RT] >= Q3_INFINITE )
{
return qtrue;
}
//NOTE: falls through
case HL_LEG_RT:
//NOTE: feet fall through
if ( ent->locationDamage[HL_LEG_RT] >= Q3_INFINITE )
{
return qtrue;
}
return qfalse;
break;
case HL_FOOT_LT:
if ( ent->locationDamage[HL_FOOT_LT] >= Q3_INFINITE )
{
return qtrue;
}
//NOTE: falls through
case HL_LEG_LT:
//NOTE: feet fall through
if ( ent->locationDamage[HL_LEG_LT] >= Q3_INFINITE )
{
return qtrue;
}
return qfalse;
break;
case HL_HAND_LT:
if ( ent->locationDamage[HL_HAND_LT] >= Q3_INFINITE )
{
return qtrue;
}
//NOTE: falls through
case HL_ARM_LT:
case HL_CHEST_LT:
case HL_BACK_RT:
//NOTE: hand falls through
if ( ent->locationDamage[HL_ARM_LT] >= Q3_INFINITE
|| ent->locationDamage[HL_CHEST_LT] >= Q3_INFINITE
|| ent->locationDamage[HL_BACK_RT] >= Q3_INFINITE
|| ent->locationDamage[HL_WAIST] >= Q3_INFINITE )
{
return qtrue;
}
return qfalse;
break;
case HL_HAND_RT:
if ( ent->locationDamage[HL_HAND_RT] >= Q3_INFINITE )
{
return qtrue;
}
//NOTE: falls through
case HL_ARM_RT:
case HL_CHEST_RT:
case HL_BACK_LT:
//NOTE: hand falls through
if ( ent->locationDamage[HL_ARM_RT] >= Q3_INFINITE
|| ent->locationDamage[HL_CHEST_RT] >= Q3_INFINITE
|| ent->locationDamage[HL_BACK_LT] >= Q3_INFINITE
|| ent->locationDamage[HL_WAIST] >= Q3_INFINITE )
{
return qtrue;
}
return qfalse;
break;
case HL_HEAD:
if ( ent->locationDamage[HL_HEAD] >= Q3_INFINITE )
{
return qtrue;
}
//NOTE: falls through
case HL_WAIST:
//NOTE: head falls through
if ( ent->locationDamage[HL_WAIST] >= Q3_INFINITE )
{
return qtrue;
}
return qfalse;
break;
default:
return (ent->locationDamage[hitLoc]>=Q3_INFINITE);
break;
}
}
static qboolean G_Dismember( gentity_t *ent, vec3_t point,
const char *limbBone, const char *rotateBone, char *limbName,
char *limbCapName, char *stubCapName, char *limbTagName, char *stubTagName,
int limbAnim, float limbRollBase, float limbPitchBase,
int damage, int hitLoc )
{
int newBolt;
vec3_t dir, newPoint, limbAngles = {0,ent->client->ps.legsYaw,0};
gentity_t *limb;
trace_t trace;
//make sure this limb hasn't been lopped off already!
if ( gi.G2API_GetSurfaceRenderStatus( &ent->ghoul2[ent->playerModel], limbName ) )
{//already lost this limb
return qfalse;
}
//NOTE: only reason I have this next part is because G2API_GetSurfaceRenderStatus is *not* working
if ( G_LimbLost( ent, hitLoc ) )
{//already lost this limb
return qfalse;
}
//FIXME: when timescale is high, can sometimes cut off a surf that includes a surf that was already cut off
//0) create a limb ent
VectorCopy( point, newPoint );
newPoint[2] += 6;
limb = G_Spawn();
G_SetOrigin( limb, newPoint );
//VectorCopy(ent->currentAngles,limbAngles);
//G_SetAngles( limb, ent->currentAngles );
VectorCopy( newPoint, limb->s.pos.trBase );
//1) copy the g2 instance of the victim into the limb
gi.G2API_CopyGhoul2Instance( ent->ghoul2, limb->ghoul2 );
limb->playerModel = 0;//assumption!
limb->craniumBone = ent->craniumBone;
limb->cervicalBone = ent->cervicalBone;
limb->thoracicBone = ent->thoracicBone;
limb->upperLumbarBone = ent->upperLumbarBone;
limb->lowerLumbarBone = ent->lowerLumbarBone;
limb->hipsBone = ent->hipsBone;
limb->rootBone = ent->rootBone;
//2) set the root surf on the limb
if ( limbTagName )
{//add smoke to cap tag
newBolt = gi.G2API_AddBolt( &limb->ghoul2[limb->playerModel], limbTagName );
if ( newBolt != -1 )
{
G_PlayEffect( "blaster/smoke_bolton", limb->playerModel, newBolt, limb->s.number);
}
}
/*
if ( limbBone && hitLoc == HL_HEAD )
{//stop the current anim on the limb?
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "model_root" );
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "motion" );
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "upper_lumbar" );
}
*/
gi.G2API_StopBoneAnimIndex( &limb->ghoul2[limb->playerModel], limb->hipsBone );
gi.G2API_SetRootSurface( limb->ghoul2, limb->playerModel, limbName );
/*
if ( limbBone && hitLoc != HL_WAIST )
{//play the dismember anim on the limb?
//FIXME: screws up origin
animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
//play the proper dismember anim on the limb
gi.G2API_SetBoneAnim(&limb->ghoul2[limb->playerModel], 0, animations[limbAnim].firstFrame - 1,
animations[limbAnim].numFrames + animations[limbAnim].firstFrame - 1,
BONE_ANIM_OVERRIDE_FREEZE, 1, cg.time);
}
*/
if ( limbBone && hitLoc == HL_WAIST && ent->client->NPC_class == CLASS_PROTOCOL )
{//play the dismember anim on the limb?
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "model_root" );
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "motion" );
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "pelvis" );
gi.G2API_StopBoneAnim( &limb->ghoul2[limb->playerModel], "upper_lumbar" );
//FIXME: screws up origin
animation_t *animations = level.knownAnimFileSets[ent->client->clientInfo.animFileIndex].animations;
//play the proper dismember anim on the limb
gi.G2API_SetBoneAnim(&limb->ghoul2[limb->playerModel], 0, animations[limbAnim].firstFrame,
animations[limbAnim].numFrames + animations[limbAnim].firstFrame,
BONE_ANIM_OVERRIDE_FREEZE, 1, cg.time );
}
if ( rotateBone )
{
gi.G2API_SetNewOrigin( &limb->ghoul2[0], gi.G2API_AddBolt( &limb->ghoul2[0], rotateBone ) );
//now let's try to position the limb at the *exact* right spot
int newBolt = gi.G2API_AddBolt( &ent->ghoul2[0], rotateBone );
if ( newBolt != -1 )
{
int actualTime = (cg.time?cg.time:level.time);
mdxaBone_t boltMatrix;
vec3_t angles;
VectorSet( angles, 0, ent->currentAngles[YAW], 0 );
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, newBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, limb->s.origin );
G_SetOrigin( limb, limb->s.origin );
VectorCopy( limb->s.origin, limb->s.pos.trBase );
//angles, too
/*
vec3_t limbF, limbR;
newBolt = gi.G2API_AddBolt( &ent->ghoul2[0], limbBone );
if ( newBolt != -1 )
{
gi.G2API_GetBoltMatrix( ent->ghoul2, ent->playerModel, newBolt,
&boltMatrix, angles, ent->currentOrigin,
actualTime, NULL, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, POSITIVE_X, limbF );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, NEGATIVE_Y, limbR );
vectoangles( limbF, limbAngles );
vectoangles( limbR, angles );
limbAngles[YAW] += 180;
limbAngles[ROLL] = angles[PITCH]*-1.0f;
}
*/
}
}
if ( limbCapName )
{//turn on caps
gi.G2API_SetSurfaceOnOff( &limb->ghoul2[limb->playerModel], limbCapName, 0 );
}
//3) turn off w/descendants that surf in original model
//NOTE: we actually change the ent's stuff on the cgame side so that there is no 50ms lag
// also, if the limb was going to start in solid, we can delete it and return
if ( stubTagName )
{//add smoke to cap surf, spawn effect
limb->target = G_NewString( stubTagName );
/*
newBolt = gi.G2API_AddBolt( &ent->ghoul2[ent->playerModel], stubTagName );
if ( newBolt != -1 )
{
G_PlayEffect( "blaster/smoke_bolton", ent->playerModel, newBolt, ent->s.number);
}
*/
}
if ( limbName )
{
limb->target2 = G_NewString( limbName );
//gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], limbName, 0x00000100 );//G2SURFACEFLAG_NODESCENDANTS
}
if ( stubCapName )
{//turn on caps
limb->target3 = G_NewString( stubCapName );
//gi.G2API_SetSurfaceOnOff( &ent->ghoul2[ent->playerModel], stubCapName, 0 );
}
limb->count = limbAnim;
//
limb->s.radius = 60;
//4) toss the limb away
limb->classname = "limb";
limb->owner = ent;
limb->enemy = ent->enemy;
if ( ent->weaponModel >= 0 && !ent->client->ps.saberInFlight )
{//the corpse hasn't dropped their weapon
if ( limbAnim == BOTH_DISMEMBER_RARM || limbAnim == BOTH_DISMEMBER_TORSO1 )//&& ent->s.weapon == WP_SABER && ent->weaponModel != -1 )
{//FIXME: is this first check needed with this lower one?
if ( !gi.G2API_GetSurfaceRenderStatus( &limb->ghoul2[0], "r_hand" ) )
{//only copy the weapon over if the right hand is actually on this limb...
//copy it to limb
if ( ent->s.weapon != WP_NONE )
{//only if they actually still have a weapon
limb->s.weapon = ent->s.weapon;
limb->weaponModel = ent->weaponModel;
}//else - weaponModel is not -1 but don't have a weapon? Oops, somehow G2 model wasn't removed?
//remove it on owner
if ( ent->weaponModel >= 0 )
{
gi.G2API_RemoveGhoul2Model( ent->ghoul2, ent->weaponModel );
ent->weaponModel = -1;
}
if ( ent->client->ps.saberEntityNum != ENTITYNUM_NONE && ent->client->ps.saberEntityNum > 0 )
{//remove the owner ent's saber model and entity
if ( g_entities[ent->client->ps.saberEntityNum].inuse )
{
G_FreeEntity( &g_entities[ent->client->ps.saberEntityNum] );
}
ent->client->ps.saberEntityNum = ENTITYNUM_NONE;
}
}
else
{
if ( ent->weaponModel >= 0 )
{
gi.G2API_RemoveGhoul2Model( limb->ghoul2, ent->weaponModel );
limb->weaponModel = -1;
}
}
}
else
{
if ( ent->weaponModel >= 0 )
{
gi.G2API_RemoveGhoul2Model( limb->ghoul2, ent->weaponModel );
limb->weaponModel = -1;
}
}
}
limb->e_clThinkFunc = clThinkF_CG_Limb;
limb->e_ThinkFunc = thinkF_LimbThink;
limb->nextthink = level.time + FRAMETIME;
gi.linkentity( limb );
//need size, contents, clipmask
limb->svFlags = SVF_USE_CURRENT_ORIGIN;
limb->clipmask = MASK_SOLID;
limb->contents = CONTENTS_CORPSE;
VectorSet( limb->mins, -3.0f, -3.0f, -6.0f );
VectorSet( limb->maxs, 3.0f, 3.0f, 6.0f );
//make sure it doesn't start in solid
gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
if ( trace.startsolid )
{
limb->s.pos.trBase[2] -= limb->mins[2];
gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
if ( trace.startsolid )
{
limb->s.pos.trBase[2] += limb->mins[2];
gi.trace( &trace, limb->s.pos.trBase, limb->mins, limb->maxs, limb->s.pos.trBase, limb->s.number, limb->clipmask );
if ( trace.startsolid )
{//stuck? don't remove
G_FreeEntity( limb );
return qfalse;
}
}
}
//move it
VectorCopy( limb->s.pos.trBase, limb->currentOrigin );
gi.linkentity( limb );
limb->s.eType = ET_THINKER;//ET_GENERAL;
limb->physicsBounce = 0.2f;
limb->s.pos.trType = TR_GRAVITY;
limb->s.pos.trTime = level.time; // move a bit on the very first frame
VectorSubtract( point, ent->currentOrigin, dir );
VectorNormalize( dir );
//no trDuration?
//spin it
//new way- try to preserve the exact angle and position of the limb as it was when attached
VectorSet( limb->s.angles2, limbPitchBase, 0, limbRollBase );
VectorCopy( limbAngles, limb->s.apos.trBase );
/*
//old way- just set an angle...
limb->s.apos.trBase[0] += limbPitchBase;
limb->s.apos.trBase[1] = ent->client->ps.viewangles[1];
limb->s.apos.trBase[2] += limbRollBase;
*/
limb->s.apos.trTime = level.time;
limb->s.apos.trType = TR_LINEAR;
VectorClear( limb->s.apos.trDelta );
if ( hitLoc == HL_HAND_RT || hitLoc == HL_HAND_LT )
{//hands fly farther
VectorMA( ent->client->ps.velocity, 200, dir, limb->s.pos.trDelta );
//make it bounce some
limb->s.eFlags |= EF_BOUNCE_HALF;
limb->s.apos.trDelta[0] = Q_irand( -300, 300 );
limb->s.apos.trDelta[1] = Q_irand( -800, 800 );
}
else if ( limbAnim == BOTH_DISMEMBER_HEAD1
|| limbAnim == BOTH_DISMEMBER_LARM
|| limbAnim == BOTH_DISMEMBER_RARM )
{//head and arms don't fly as far
limb->s.eFlags |= EF_BOUNCE_SHRAPNEL;
VectorMA( ent->client->ps.velocity, 150, dir, limb->s.pos.trDelta );
limb->s.apos.trDelta[0] = Q_irand( -200, 200 );
limb->s.apos.trDelta[1] = Q_irand( -400, 400 );
}
else// if ( limbAnim == BOTH_DISMEMBER_TORSO1 || limbAnim == BOTH_DISMEMBER_LLEG || limbAnim == BOTH_DISMEMBER_RLEG )
{//everything else just kinda falls off
limb->s.eFlags |= EF_BOUNCE_SHRAPNEL;
VectorMA( ent->client->ps.velocity, 100, dir, limb->s.pos.trDelta );
limb->s.apos.trDelta[0] = Q_irand( -100, 100 );
limb->s.apos.trDelta[1] = Q_irand( -200, 200 );
}
//roll? No, doesn't work...
//limb->s.apos.trDelta[2] = Q_irand( -300, 300 );//FIXME: this scales it down @ 80% and does weird stuff in timescale != 1.0
//limb->s.apos.trDelta[2] = limbRoll;
//preserve scale so giants don't have tiny limbs
VectorCopy( ent->s.modelScale, limb->s.modelScale );
//mark ent as dismembered
ent->locationDamage[hitLoc] = Q3_INFINITE;//mark this limb as gone
ent->client->dismembered = qtrue;
return qtrue;
}
static qboolean G_Dismemberable( gentity_t *self, int hitLoc )
{
if ( self->client->dismembered )
{//cannot dismember me right now
return qfalse;
}
if ( g_dismemberment->integer < 11381138 && !g_saberRealisticCombat->integer )
{
if ( g_dismemberProbabilities->value > 0.0f )
{//use the ent-specific dismemberProbabilities
float dismemberProb = 0;
// check which part of the body it is. Then check the npc's probability
// of that body part coming off, if it doesn't pass, return out.
switch ( hitLoc )
{
case HL_LEG_RT:
case HL_LEG_LT:
dismemberProb = self->client->dismemberProbLegs;
break;
case HL_WAIST:
dismemberProb = self->client->dismemberProbWaist;
break;
case HL_BACK_RT:
case HL_BACK_LT:
case HL_CHEST_RT:
case HL_CHEST_LT:
case HL_ARM_RT:
case HL_ARM_LT:
dismemberProb = self->client->dismemberProbArms;
break;
case HL_HAND_RT:
case HL_HAND_LT:
dismemberProb = self->client->dismemberProbHands;
break;
case HL_HEAD:
dismemberProb = self->client->dismemberProbHead;
break;
default:
return qfalse;
break;
}
//check probability of this happening on this npc
if ( floor((Q_flrand( 1, 100 )*g_dismemberProbabilities->value)) > dismemberProb*2.0f )//probabilities seemed really really low, had to crank them up
{
return qfalse;
}
}
}
return qtrue;
}
static qboolean G_Dismemberable2( gentity_t *self, int hitLoc )
{
if ( self->client->dismembered )
{//cannot dismember me right now
return qfalse;
}
if ( g_dismemberment->integer < 11381138 && !g_saberRealisticCombat->integer )
{
if ( g_dismemberProbabilities->value <= 0.0f )
{//add the passed-in damage to the locationDamage array, check to see if it's taken enough damage to actually dismember
if ( self->locationDamage[hitLoc] < (self->client->ps.stats[STAT_MAX_HEALTH]*hitLocHealthPercentage[hitLoc]) )
{//this location has not taken enough damage to dismember
return qfalse;
}
}
}
return qtrue;
}
extern qboolean G_StandardHumanoid( const char *modelName );
qboolean G_DoDismemberment( gentity_t *self, vec3_t point, int mod, int damage, int hitLoc, qboolean force = qfalse )
{
extern cvar_t *g_iscensored;
// dismemberment -- FIXME: should have a check for how long npc has been dead so people can't
// continue to dismember a dead body long after it's been dead
//NOTE that you can only cut one thing off unless the dismemberment is >= 11381138
#ifdef GERMAN_CENSORED
if ( 0 ) //germany == censorship
#else
if ( !g_iscensored->integer && ( g_dismemberment->integer || g_saberRealisticCombat->integer > 1 ) && mod == MOD_SABER )//only lightsaber
#endif
{//FIXME: don't do strcmps here
if ( G_StandardHumanoid( self->NPC_type )
&& (force||g_dismemberProbabilities->value>0.0f||G_Dismemberable2( self, hitLoc )) )
{//either it's a forced dismemberment or we're using probabilities (which are checked before this) or we've done enough damage to this location
//FIXME: check the hitLoc and hitDir against the cap tag for the place
//where the split will be- if the hit dir is roughly perpendicular to
//the direction of the cap, then the split is allowed, otherwise we
//hit it at the wrong angle and should not dismember...
char *limbBone = NULL, *rotateBone = NULL, *limbName = NULL, *limbCapName = NULL, *stubCapName = NULL, *limbTagName = NULL, *stubTagName = NULL;
int anim = -1;
float limbRollBase = 0, limbPitchBase = 0;
qboolean doDismemberment = qfalse;
switch( hitLoc )//self->hitLoc
{
case HL_LEG_RT:
if ( g_dismemberment->integer > 1 )
{
doDismemberment = qtrue;
limbBone = "rtibia";
rotateBone = "rtalus";
limbName = "r_leg";
limbCapName = "r_leg_cap_hips_off";
stubCapName = "hips_cap_r_leg_off";
limbTagName = "*r_leg_cap_hips";
stubTagName = "*hips_cap_r_leg";
anim = BOTH_DISMEMBER_RLEG;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_LEG_LT:
if ( g_dismemberment->integer > 1 )
{
doDismemberment = qtrue;
limbBone = "ltibia";
rotateBone = "ltalus";
limbName = "l_leg";
limbCapName = "l_leg_cap_hips_off";
stubCapName = "hips_cap_l_leg_off";
limbTagName = "*l_leg_cap_hips";
stubTagName = "*hips_cap_l_leg";
anim = BOTH_DISMEMBER_LLEG;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_WAIST:
if ( g_dismemberment->integer > 2 &&
(!self->s.number||!self->message))
{
doDismemberment = qtrue;
limbBone = "pelvis";
rotateBone = "thoracic";
limbName = "torso";
limbCapName = "torso_cap_hips_off";
stubCapName = "hips_cap_torso_off";
limbTagName = "*torso_cap_hips";
stubTagName = "*hips_cap_torso";
anim = BOTH_DISMEMBER_TORSO1;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_CHEST_RT:
case HL_ARM_RT:
case HL_BACK_RT:
if ( g_dismemberment->integer )
{
doDismemberment = qtrue;
limbBone = "rhumerus";
rotateBone = "rradius";
limbName = "r_arm";
limbCapName = "r_arm_cap_torso_off";
stubCapName = "torso_cap_r_arm_off";
limbTagName = "*r_arm_cap_torso";
stubTagName = "*torso_cap_r_arm";
anim = BOTH_DISMEMBER_RARM;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_CHEST_LT:
case HL_ARM_LT:
case HL_BACK_LT:
if ( g_dismemberment->integer &&
(!self->s.number||!self->message))
{//either the player or not carrying a key on my arm
doDismemberment = qtrue;
limbBone = "lhumerus";
rotateBone = "lradius";
limbName = "l_arm";
limbCapName = "l_arm_cap_torso_off";
stubCapName = "torso_cap_l_arm_off";
limbTagName = "*l_arm_cap_torso";
stubTagName = "*torso_cap_l_arm";
anim = BOTH_DISMEMBER_LARM;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_HAND_RT:
if ( g_dismemberment->integer )
{
doDismemberment = qtrue;
limbBone = "rradiusX";
rotateBone = "rhand";
limbName = "r_hand";
limbCapName = "r_hand_cap_r_arm_off";
stubCapName = "r_arm_cap_r_hand_off";
limbTagName = "*r_hand_cap_r_arm";
stubTagName = "*r_arm_cap_r_hand";
anim = BOTH_DISMEMBER_RARM;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_HAND_LT:
if ( g_dismemberment->integer )
{
doDismemberment = qtrue;
limbBone = "lradiusX";
rotateBone = "lhand";
limbName = "l_hand";
limbCapName = "l_hand_cap_l_arm_off";
stubCapName = "l_arm_cap_l_hand_off";
limbTagName = "*l_hand_cap_l_arm";
stubTagName = "*l_arm_cap_l_hand";
anim = BOTH_DISMEMBER_RARM;
limbRollBase = 0;
limbPitchBase = 0;
}
break;
case HL_HEAD:
if ( g_dismemberment->integer > 2 )
{
doDismemberment = qtrue;
limbBone = "cervical";
rotateBone = "cranium";
limbName = "head";
limbCapName = "head_cap_torso_off";
stubCapName = "torso_cap_head_off";
limbTagName = "*head_cap_torso";
stubTagName = "*torso_cap_head";
anim = BOTH_DISMEMBER_HEAD1;
limbRollBase = -1;
limbPitchBase = -1;
}
break;
case HL_FOOT_RT:
case HL_FOOT_LT:
case HL_CHEST:
case HL_BACK:
default:
break;
}
if ( doDismemberment )
{
return G_Dismember( self, point, limbBone, rotateBone, limbName,
limbCapName, stubCapName, limbTagName, stubTagName,
anim, limbRollBase, limbPitchBase, damage, hitLoc );
}
}
}
return qfalse;
}
static int G_CheckSpecialDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
{
int deathAnim = -1;
if ( PM_InRoll( &self->client->ps ) )
{
deathAnim = BOTH_DEATH_ROLL; //# Death anim from a roll
}
else if ( PM_FlippingAnim( self->client->ps.legsAnim ) )
{
deathAnim = BOTH_DEATH_FLIP; //# Death anim from a flip
}
else if ( PM_SpinningAnim( self->client->ps.legsAnim ) )
{
float yawDiff = AngleNormalize180(AngleNormalize180(self->client->renderInfo.torsoAngles[YAW]) - AngleNormalize180(self->client->ps.viewangles[YAW]));
if ( yawDiff > 135 || yawDiff < -135 )
{
deathAnim = BOTH_DEATH_SPIN_180; //# Death anim when facing backwards
}
else if ( yawDiff < -60 )
{
deathAnim = BOTH_DEATH_SPIN_90_R; //# Death anim when facing 90 degrees right
}
else if ( yawDiff > 60 )
{
deathAnim = BOTH_DEATH_SPIN_90_L; //# Death anim when facing 90 degrees left
}
}
else if ( PM_InKnockDown( &self->client->ps ) )
{//since these happen a lot, let's handle them case by case
int animLength = PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.legsAnim );
switch ( self->client->ps.legsAnim )
{
case BOTH_KNOCKDOWN1:
if ( animLength - self->client->ps.legsAnimTimer > 100 )
{//on our way down
if ( self->client->ps.legsAnimTimer > 600 )
{//still partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_KNOCKDOWN2:
if ( animLength - self->client->ps.legsAnimTimer > 700 )
{//on our way down
if ( self->client->ps.legsAnimTimer > 600 )
{//still partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_KNOCKDOWN3:
if ( animLength - self->client->ps.legsAnimTimer > 100 )
{//on our way down
if ( self->client->ps.legsAnimTimer > 1300 )
{//still partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_DN;
}
}
break;
case BOTH_KNOCKDOWN4:
if ( animLength - self->client->ps.legsAnimTimer > 300 )
{//on our way down
if ( self->client->ps.legsAnimTimer > 350 )
{//still partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
else
{//crouch death
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
break;
case BOTH_KNOCKDOWN5:
if ( self->client->ps.legsAnimTimer < 750 )
{//flat
deathAnim = BOTH_DEATH_LYING_DN;
}
break;
case BOTH_GETUP1:
if ( self->client->ps.legsAnimTimer < 350 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 800 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 450 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_GETUP2:
if ( self->client->ps.legsAnimTimer < 150 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 850 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 500 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_GETUP3:
if ( self->client->ps.legsAnimTimer < 250 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 600 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 150 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_DN;
}
}
break;
case BOTH_GETUP4:
if ( self->client->ps.legsAnimTimer < 250 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 600 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 850 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_GETUP5:
if ( self->client->ps.legsAnimTimer > 850 )
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 1500 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_DN;
}
}
break;
case BOTH_GETUP_CROUCH_B1:
if ( self->client->ps.legsAnimTimer < 800 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 400 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_GETUP_CROUCH_F1:
if ( self->client->ps.legsAnimTimer < 800 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 150 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_DN;
}
}
break;
case BOTH_FORCE_GETUP_B1:
if ( self->client->ps.legsAnimTimer < 325 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 725 )
{//spinning up
deathAnim = BOTH_DEATH_SPIN_180; //# Death anim when facing backwards
}
else if ( self->client->ps.legsAnimTimer < 900 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 50 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_FORCE_GETUP_B2:
if ( self->client->ps.legsAnimTimer < 575 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 875 )
{//spinning up
deathAnim = BOTH_DEATH_SPIN_180; //# Death anim when facing backwards
}
else if ( self->client->ps.legsAnimTimer < 900 )
{//crouching
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else
{//lying down
//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
break;
case BOTH_FORCE_GETUP_B3:
if ( self->client->ps.legsAnimTimer < 150 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 775 )
{//flipping
deathAnim = BOTH_DEATHBACKWARD2; //backflip
}
else
{//lying down
//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
break;
case BOTH_FORCE_GETUP_B4:
if ( self->client->ps.legsAnimTimer < 325 )
{//standing up
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 150 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_FORCE_GETUP_B5:
if ( self->client->ps.legsAnimTimer < 550 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 1025 )
{//kicking up
deathAnim = BOTH_DEATHBACKWARD2; //backflip
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 50 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_FORCE_GETUP_B6:
if ( self->client->ps.legsAnimTimer < 225 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 425 )
{//crouching up
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -150 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
else if ( self->client->ps.legsAnimTimer < 825 )
{//flipping up
deathAnim = BOTH_DEATHFORWARD3; //backflip
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 225 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_UP;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_UP;
}
}
break;
case BOTH_FORCE_GETUP_F1:
if ( self->client->ps.legsAnimTimer < 275 )
{//standing up
}
else if ( self->client->ps.legsAnimTimer < 750 )
{//flipping
deathAnim = BOTH_DEATH14;
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 100 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_DN;
}
}
break;
case BOTH_FORCE_GETUP_F2:
if ( self->client->ps.legsAnimTimer < 1200 )
{//standing
}
else
{//lying down
if ( animLength - self->client->ps.legsAnimTimer > 225 )
{//partially up
deathAnim = BOTH_DEATH_FALLING_DN;
}
else
{//down
deathAnim = BOTH_DEATH_LYING_DN;
}
}
break;
}
}
else if ( PM_InOnGroundAnim( &self->client->ps ) )
{
if ( AngleNormalize180(self->client->renderInfo.torsoAngles[PITCH]) < 0 )
{
deathAnim = BOTH_DEATH_LYING_UP; //# Death anim when lying on back
}
else
{
deathAnim = BOTH_DEATH_LYING_DN; //# Death anim when lying on front
}
}
else if ( PM_CrouchAnim( self->client->ps.legsAnim ) )
{
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
if ( thrown < -200 )
{
deathAnim = BOTH_DEATHBACKWARD1; //# Death anim when crouched and thrown back
if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
{
self->client->ps.velocity[2] = 100;
}
}
else
{
deathAnim = BOTH_DEATH_CROUCHED; //# Death anim when crouched
}
}
return deathAnim;
}
extern qboolean PM_FinishedCurrentLegsAnim( gentity_t *self );
static int G_PickDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
{//FIXME: play dead flop anims on body if in an appropriate _DEAD anim when this func is called
int deathAnim = -1;
if ( hitLoc == HL_NONE )
{
hitLoc = G_GetHitLocation( self, point );//self->hitLoc
}
//dead flops...if you are already playing a death animation, I guess it can just return directly
switch( self->client->ps.legsAnim )
{
case BOTH_DEATH1: //# First Death anim
case BOTH_DEAD1:
case BOTH_DEATH2: //# Second Death anim
case BOTH_DEAD2:
case BOTH_DEATH8: //#
case BOTH_DEAD8:
case BOTH_DEATH13: //#
case BOTH_DEAD13:
case BOTH_DEATH14: //#
case BOTH_DEAD14:
case BOTH_DEATH16: //#
case BOTH_DEAD16:
case BOTH_DEADBACKWARD1: //# First thrown backward death finished pose
case BOTH_DEADBACKWARD2: //# Second thrown backward death finished pose
return -2;
break;
/*
if ( PM_FinishedCurrentLegsAnim( self ) )
{//done with the anim
deathAnim = BOTH_DEADFLOP2;
}
else
{
deathAnim = -2;
}
break;
case BOTH_DEADFLOP2:
deathAnim = BOTH_DEADFLOP2;
break;
*/
case BOTH_DEATH10: //#
case BOTH_DEAD10:
case BOTH_DEATH15: //#
case BOTH_DEAD15:
case BOTH_DEADFORWARD1: //# First thrown forward death finished pose
case BOTH_DEADFORWARD2: //# Second thrown forward death finished pose
return -2;
break;
/*
if ( PM_FinishedCurrentLegsAnim( self ) )
{//done with the anim
deathAnim = BOTH_DEADFLOP1;
}
else
{
deathAnim = -2;
}
break;
*/
case BOTH_DEADFLOP1:
//deathAnim = BOTH_DEADFLOP1;
return -2;
break;
case BOTH_DEAD3: //# Third Death finished pose
case BOTH_DEAD4: //# Fourth Death finished pose
case BOTH_DEAD5: //# Fifth Death finished pose
case BOTH_DEAD6: //# Sixth Death finished pose
case BOTH_DEAD7: //# Seventh Death finished pose
case BOTH_DEAD9: //#
case BOTH_DEAD11: //#
case BOTH_DEAD12: //#
case BOTH_DEAD17: //#
case BOTH_DEAD18: //#
case BOTH_DEAD19: //#
case BOTH_DEAD20: //#
case BOTH_DEAD21: //#
case BOTH_DEAD22: //#
case BOTH_DEAD23: //#
case BOTH_DEAD24: //#
case BOTH_DEAD25: //#
case BOTH_LYINGDEAD1: //# Killed lying down death finished pose
case BOTH_STUMBLEDEAD1: //# Stumble forward death finished pose
case BOTH_FALLDEAD1LAND: //# Fall forward and splat death finished pose
case BOTH_DEATH3: //# Third Death anim
case BOTH_DEATH4: //# Fourth Death anim
case BOTH_DEATH5: //# Fifth Death anim
case BOTH_DEATH6: //# Sixth Death anim
case BOTH_DEATH7: //# Seventh Death anim
case BOTH_DEATH9: //#
case BOTH_DEATH11: //#
case BOTH_DEATH12: //#
case BOTH_DEATH17: //#
case BOTH_DEATH18: //#
case BOTH_DEATH19: //#
case BOTH_DEATH20: //#
case BOTH_DEATH21: //#
case BOTH_DEATH22: //#
case BOTH_DEATH23: //#
case BOTH_DEATH24: //#
case BOTH_DEATH25: //#
case BOTH_DEATHFORWARD1: //# First Death in which they get thrown forward
case BOTH_DEATHFORWARD2: //# Second Death in which they get thrown forward
case BOTH_DEATHFORWARD3: //# Second Death in which they get thrown forward
case BOTH_DEATHBACKWARD1: //# First Death in which they get thrown backward
case BOTH_DEATHBACKWARD2: //# Second Death in which they get thrown backward
case BOTH_DEATH1IDLE: //# Idle while close to death
case BOTH_LYINGDEATH1: //# Death to play when killed lying down
case BOTH_STUMBLEDEATH1: //# Stumble forward and fall face first death
case BOTH_FALLDEATH1: //# Fall forward off a high cliff and splat death - start
case BOTH_FALLDEATH1INAIR: //# Fall forward off a high cliff and splat death - loop
case BOTH_FALLDEATH1LAND: //# Fall forward off a high cliff and splat death - hit bottom
return -2;
break;
case BOTH_DEATH_ROLL: //# Death anim from a roll
case BOTH_DEATH_FLIP: //# Death anim from a flip
case BOTH_DEATH_SPIN_90_R: //# Death anim when facing 90 degrees right
case BOTH_DEATH_SPIN_90_L: //# Death anim when facing 90 degrees left
case BOTH_DEATH_SPIN_180: //# Death anim when facing backwards
case BOTH_DEATH_LYING_UP: //# Death anim when lying on back
case BOTH_DEATH_LYING_DN: //# Death anim when lying on front
case BOTH_DEATH_FALLING_DN: //# Death anim when falling on face
case BOTH_DEATH_FALLING_UP: //# Death anim when falling on back
case BOTH_DEATH_CROUCHED: //# Death anim when crouched
case BOTH_RIGHTHANDCHOPPEDOFF:
return -2;
break;
}
// Not currently playing a death animation, so try and get an appropriate one now.
if ( deathAnim == -1 )
{
deathAnim = G_CheckSpecialDeathAnim( self, point, damage, mod, hitLoc );
if ( deathAnim == -1 )
{//base on hitLoc
vec3_t fwd;
AngleVectors( self->currentAngles, fwd, NULL, NULL );
float thrown = DotProduct( fwd, self->client->ps.velocity );
//death anims
switch( hitLoc )
{
case HL_FOOT_RT:
if ( !Q_irand( 0, 2 ) && thrown < 250 )
{
deathAnim = BOTH_DEATH24;//right foot trips up, spin
}
else if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH4;//back: forward
}
else
{
deathAnim = BOTH_DEATH5;//same as 4
}
break;
case HL_FOOT_LT:
if ( !Q_irand( 0, 2 ) && thrown < 250 )
{
deathAnim = BOTH_DEATH25;//left foot trips up, spin
}
else if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH4;//back: forward
}
else
{
deathAnim = BOTH_DEATH5;//same as 4
}
break;
case HL_LEG_RT:
if ( !Q_irand( 0, 2 ) && thrown < 250 )
{
deathAnim = BOTH_DEATH3;//right leg collapse
}
else if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH5;//same as 4
}
else
{
deathAnim = BOTH_DEATH4;//back: forward
}
break;
case HL_LEG_LT:
if ( !Q_irand( 0, 2 ) && thrown < 250 )
{
deathAnim = BOTH_DEATH7;//left leg collapse
}
else if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH5;//same as 4
}
else
{
deathAnim = BOTH_DEATH4;//back: forward
}
break;
case HL_BACK:
if ( fabs(thrown) < 50 || (fabs(thrown) < 200&&!Q_irand(0,3)) )
{
if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH17;//head/back: croak
}
else
{
deathAnim = BOTH_DEATH10;//back: bend back, fall forward
}
}
else
{
if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH4;//back: forward
}
else
{
deathAnim = BOTH_DEATH5;//same as 4
}
}
break;
case HL_HAND_RT:
case HL_CHEST_RT:
case HL_ARM_RT:
case HL_BACK_LT:
if ( (damage <= self->max_health*0.25&&Q_irand(0,1)) || (fabs(thrown)<200&&!Q_irand(0,2)) || !Q_irand( 0, 10 ) )
{
if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH9;//chest right: snap, fall forward
}
else
{
deathAnim = BOTH_DEATH20;//chest right: snap, fall forward
}
}
else if ( (damage <= self->max_health*0.5&&Q_irand(0,1)) || !Q_irand( 0, 10 ) )
{
deathAnim = BOTH_DEATH3;//chest right: back
}
else if ( (damage <= self->max_health*0.75&&Q_irand(0,1)) || !Q_irand( 0, 10 ) )
{
deathAnim = BOTH_DEATH6;//chest right: spin
}
else
{
//TEMP HACK: play spinny deaths less often
if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH8;//chest right: spin high
}
else
{
switch ( Q_irand( 0, 3 ) )
{
default:
case 0:
deathAnim = BOTH_DEATH9;//chest right: snap, fall forward
break;
case 1:
deathAnim = BOTH_DEATH3;//chest right: back
break;
case 2:
deathAnim = BOTH_DEATH6;//chest right: spin
break;
case 3:
deathAnim = BOTH_DEATH20;//chest right: spin
break;
}
}
}
break;
case HL_CHEST_LT:
case HL_ARM_LT:
case HL_HAND_LT:
case HL_BACK_RT:
if ( (damage <= self->max_health*0.25&&Q_irand(0,1)) || (fabs(thrown)<200&&!Q_irand(0,2)) || !Q_irand(0, 10) )
{
if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH11;//chest left: snap, fall forward
}
else
{
deathAnim = BOTH_DEATH21;//chest left: snap, fall forward
}
}
else if ( (damage <= self->max_health*0.5&&Q_irand(0,1)) || !Q_irand(0, 10) )
{
deathAnim = BOTH_DEATH7;//chest left: back
}
else if ( (damage <= self->max_health*0.75&&Q_irand(0,1)) || !Q_irand(0, 10) )
{
deathAnim = BOTH_DEATH12;//chest left: spin
}
else
{
//TEMP HACK: play spinny deaths less often
if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH14;//chest left: spin high
}
else
{
switch ( Q_irand( 0, 3 ) )
{
default:
case 0:
deathAnim = BOTH_DEATH11;//chest left: snap, fall forward
break;
case 1:
deathAnim = BOTH_DEATH7;//chest left: back
break;
case 2:
deathAnim = BOTH_DEATH12;//chest left: spin
break;
case 3:
deathAnim = BOTH_DEATH21;//chest left: spin
break;
}
}
}
break;
case HL_CHEST:
case HL_WAIST:
if ( (damage <= self->max_health*0.25&&Q_irand(0,1)) || thrown > -50 )
{
if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH18;//gut: fall right
}
else
{
deathAnim = BOTH_DEATH19;//gut: fall left
}
}
else if ( (damage <= self->max_health*0.5&&!Q_irand(0,1)) || (fabs(thrown)<200&&!Q_irand(0,3)) )
{
if ( Q_irand( 0, 2 ) )
{
deathAnim = BOTH_DEATH2;//chest: backward short
}
else if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH22;//chest: backward short
}
else
{
deathAnim = BOTH_DEATH23;//chest: backward short
}
}
else if ( thrown < -300 && Q_irand( 0, 1 ) )
{
if ( Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATHBACKWARD1;//chest: fly back
}
else
{
deathAnim = BOTH_DEATHBACKWARD2;//chest: flip back
}
}
else if ( thrown < -200 && Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH15;//chest: roll backward
}
else
{
if ( !Q_irand( 0, 1 ) )
{
deathAnim = BOTH_DEATH1;//chest: backward med
}
else
{
deathAnim = BOTH_DEATH16;//same as 1
}
}
break;
case HL_HEAD:
if ( damage <= self->max_health*0.5 && Q_irand(0,2) )
{
deathAnim = BOTH_DEATH17;//head/back: croak
}
else
{
if ( Q_irand( 0, 2 ) )
{
deathAnim = BOTH_DEATH13;//head: stumble, fall back
}
else
{
deathAnim = BOTH_DEATH10;//head: stumble, fall back
}
}
break;
default:
break;
}
}
}
// Validate.....
if ( deathAnim == -1 || !PM_HasAnimation( self, deathAnim ))
{
// I guess we'll take what we can get.....
deathAnim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 );
}
return deathAnim;
}
int G_CheckLedgeDive( gentity_t *self, float checkDist, vec3_t checkVel, qboolean tryOpposite, qboolean tryPerp )
{
// Intelligent Ledge-Diving Deaths:
// If I'm an NPC, check for nearby ledges and fall off it if possible
// How should/would/could this interact with knockback if we already have some?
// Ideally - apply knockback if there are no ledges or a ledge in that dir
// But if there is a ledge and it's not in the dir of my knockback, fall off the ledge instead
if ( !self || !self->client )
{
return 0;
}
vec3_t fallForwardDir, fallRightDir;
vec3_t angles = {0};
int cliff_fall = 0;
if ( checkVel && !VectorCompare( checkVel, vec3_origin ) )
{//already moving in a dir
angles[1] = vectoyaw( self->client->ps.velocity );
AngleVectors( angles, fallForwardDir, fallRightDir, NULL );
}
else
{//try forward first
angles[1] = self->client->ps.viewangles[1];
AngleVectors( angles, fallForwardDir, fallRightDir, NULL );
}
VectorNormalize( fallForwardDir );
float fallDist = G_CheckForLedge( self, fallForwardDir, checkDist );
if ( fallDist >= 128 )
{
VectorClear( self->client->ps.velocity );
G_Throw( self, fallForwardDir, 85 );
self->client->ps.velocity[2] = 100;
self->client->ps.groundEntityNum = ENTITYNUM_NONE;
}
else if ( tryOpposite )
{
VectorScale( fallForwardDir, -1, fallForwardDir );
fallDist = G_CheckForLedge( self, fallForwardDir, checkDist );
if ( fallDist >= 128 )
{
VectorClear( self->client->ps.velocity );
G_Throw( self, fallForwardDir, 85 );
self->client->ps.velocity[2] = 100;
self->client->ps.groundEntityNum = ENTITYNUM_NONE;
}
}
if ( !cliff_fall && tryPerp )
{//try sides
VectorNormalize( fallRightDir );
fallDist = G_CheckForLedge( self, fallRightDir, checkDist );
if ( fallDist >= 128 )
{
VectorClear( self->client->ps.velocity );
G_Throw( self, fallRightDir, 85 );
self->client->ps.velocity[2] = 100;
}
else
{
VectorScale( fallRightDir, -1, fallRightDir );
fallDist = G_CheckForLedge( self, fallRightDir, checkDist );
if ( fallDist >= 128 )
{
VectorClear( self->client->ps.velocity );
G_Throw( self, fallRightDir, 85 );
self->client->ps.velocity[2] = 100;
}
}
}
if ( fallDist >= 256 )
{
cliff_fall = 2;
}
else if ( fallDist >= 128 )
{
cliff_fall = 1;
}
return cliff_fall;
}
/*
==================
player_die
==================
*/
void NPC_SetAnim(gentity_t *ent,int type,int anim,int priority);
extern void AI_DeleteSelfFromGroup( gentity_t *self );
extern void AI_GroupMemberKilled( gentity_t *self );
extern qboolean FlyingCreature( gentity_t *ent );
extern void G_DrivableATSTDie( gentity_t *self );
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath, int dflags, int hitLoc )
{
int anim;
int contents;
qboolean deathScript = qfalse;
qboolean lastInGroup = qfalse;
qboolean specialAnim = qfalse;
qboolean holdingSaber = qfalse;
int cliff_fall = 0;
//FIXME: somehow people are sometimes not completely dying???
if ( self->client->ps.pm_type == PM_DEAD && (meansOfDeath != MOD_SNIPER || (self->flags & FL_DISINTEGRATED)) )
{//do dismemberment/twitching
if ( self->client->NPC_class == CLASS_MARK1 )
{
DeathFX(self);
self->takedamage = qfalse;
self->client->ps.eFlags |= EF_NODRAW;
self->contents = 0;
// G_FreeEntity( self ); // Is this safe? I can't see why we'd mark it nodraw and then just leave it around??
self->e_ThinkFunc = thinkF_G_FreeEntity;
self->nextthink = level.time + FRAMETIME;
}
else
{
anim = G_PickDeathAnim( self, self->pos1, damage, meansOfDeath, hitLoc );
if ( dflags & DAMAGE_DISMEMBER )
{
G_DoDismemberment( self, self->pos1, meansOfDeath, damage, hitLoc );
}
if ( anim >= 0 )
{
NPC_SetAnim(self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_RESTART|SETANIM_FLAG_HOLD);
}
}
return;
}
#ifndef FINAL_BUILD
if ( d_saberCombat->integer && attacker && attacker->client )
{
gi.Printf( S_COLOR_YELLOW"combatant %s died, killer anim = %s\n", self->targetname, animTable[attacker->client->ps.torsoAnim].name );
}
#endif//FINAL_BUILD
if ( self->NPC )
{
if ( self->client && Jedi_WaitingAmbush( self ) )
{//ambushing trooper
self->client->noclip = qfalse;
}
NPC_FreeCombatPoint( self->NPC->combatPoint );
if ( self->NPC->group )
{
lastInGroup = (self->NPC->group->numGroup < 2);
AI_GroupMemberKilled( self );
AI_DeleteSelfFromGroup( self );
}
if ( self->NPC->tempGoal )
{
G_FreeEntity( self->NPC->tempGoal );
self->NPC->tempGoal = NULL;
}
if ( self->s.eFlags & EF_LOCKED_TO_WEAPON )
{
// dumb, just get the NPC out of the chair
extern void RunEmplacedWeapon( gentity_t *ent, usercmd_t **ucmd );
usercmd_t cmd, *ad_cmd;
memset( &cmd, 0, sizeof( usercmd_t ));
//gentity_t *old = self->owner;
if ( self->owner )
{
self->owner->s.frame = self->owner->startFrame = self->owner->endFrame = 0;
self->owner->svFlags &= ~SVF_ANIMATING;
}
cmd.buttons |= BUTTON_USE;
ad_cmd = &cmd;
RunEmplacedWeapon( self, &ad_cmd );
//self->owner = old;
}
}
if ( attacker && attacker->NPC && attacker->NPC->group && attacker->NPC->group->enemy == self )
{
attacker->NPC->group->enemy = NULL;
}
if ( self->s.weapon == WP_SABER )
{
holdingSaber = qtrue;
}
if ( self->client->ps.saberEntityNum != ENTITYNUM_NONE && self->client->ps.saberEntityNum > 0 )
{
if ( self->client->ps.saberInFlight )
{//just drop it
self->client->ps.saberActive = qfalse;
}
else
{
if ( (hitLoc != HL_HAND_RT
|| self->client->dismembered
|| meansOfDeath != MOD_SABER )//if might get hand cut off, leave saber in hand
&& holdingSaber
&& ( Q_irand( 0, 1 )
|| meansOfDeath == MOD_EXPLOSIVE
|| meansOfDeath == MOD_REPEATER_ALT
|| meansOfDeath == MOD_FLECHETTE_ALT
|| meansOfDeath == MOD_ROCKET
|| meansOfDeath == MOD_ROCKET_ALT
|| meansOfDeath == MOD_THERMAL
|| meansOfDeath == MOD_THERMAL_ALT
|| meansOfDeath == MOD_DETPACK
|| meansOfDeath == MOD_LASERTRIP
|| meansOfDeath == MOD_LASERTRIP_ALT
|| meansOfDeath == MOD_MELEE
|| meansOfDeath == MOD_FORCE_GRIP
|| meansOfDeath == MOD_KNOCKOUT
|| meansOfDeath == MOD_CRUSH
|| meansOfDeath == MOD_IMPACT
|| meansOfDeath == MOD_FALLING
|| meansOfDeath == MOD_EXPLOSIVE_SPLASH ) )
{//drop it
TossClientItems( self );
}
else
{//just free it
if ( g_entities[self->client->ps.saberEntityNum].inuse )
{
G_FreeEntity( &g_entities[self->client->ps.saberEntityNum] );
}
self->client->ps.saberEntityNum = ENTITYNUM_NONE;
}
}
}
if ( self->client->NPC_class == CLASS_SHADOWTROOPER )
{//drop a force crystal
gitem_t *item;
item = FindItemForAmmo( AMMO_FORCE );
Drop_Item( self, item, 0, qtrue );
}
//Use any target we had
if ( meansOfDeath != MOD_KNOCKOUT )
{
G_UseTargets( self, self );
}
if ( attacker )
{
if ( attacker->client && !attacker->s.number )
{
if ( self->client )
{//killed a client
if ( self->client->playerTeam == TEAM_ENEMY || (self->NPC && self->NPC->charmedTime > level.time) )
{//killed an enemy
attacker->client->sess.missionStats.enemiesKilled++;
}
}
if ( attacker != self )
{
G_TrackWeaponUsage( attacker, inflictor, 30, meansOfDeath );
}
}
G_CheckVictoryScript(attacker);
//player killing a jedi with a lightsaber spawns a matrix-effect entity
if ( d_slowmodeath->integer )
{
if ( !self->s.number )
{//what the hell, always do slow-mo when player dies
//FIXME: don't do this when crushed to death?
if ( meansOfDeath == MOD_FALLING && self->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//falling to death, have not hit yet
G_StartMatrixEffect( self, qtrue, 10000 );
}
else if ( meansOfDeath != MOD_CRUSH )
{//for all deaths except being crushed
G_StartMatrixEffect( self );
}
}
else if ( d_slowmodeath->integer < 4 )
{//any jedi killed by player-saber
if ( d_slowmodeath->integer < 3 )
{//must be the last jedi in the room
if ( !G_JediInRoom( attacker->currentOrigin ) )
{
lastInGroup = qtrue;
}
else
{
lastInGroup = qfalse;
}
}
if ( !attacker->s.number
&& holdingSaber
&& meansOfDeath == MOD_SABER
&& attacker->client
&& attacker->client->ps.weapon == WP_SABER
&& !attacker->client->ps.saberInFlight
&& (d_slowmodeath->integer > 2||lastInGroup) )//either slow mo death level 3 (any jedi) or 2 and I was the last jedi in the room
{//Matrix!
G_StartMatrixEffect( self );
}
}
else
{//all player-saber kills
if ( !attacker->s.number
&& meansOfDeath == MOD_SABER
&& attacker->client
&& attacker->client->ps.weapon == WP_SABER
&& !attacker->client->ps.saberInFlight
&& (d_slowmodeath->integer > 4||lastInGroup||holdingSaber))//either slow mo death level 5 (any enemy) or 4 and I was the last in my group or I'm a saber user
{//Matrix!
G_StartMatrixEffect( self );
}
}
}
}
self->enemy = attacker;
self->client->renderInfo.lookTarget = ENTITYNUM_NONE;
self->client->ps.persistant[PERS_KILLED]++;
if ( self->client->playerTeam == TEAM_PLAYER )
{//FIXME: just HazTeam members in formation on away missions?
//or more controlled- via deathscripts?
// Don't count player
if (( &g_entities[0] != NULL && g_entities[0].client ) && (self->s.number != 0))
{//add to the number of teammates lost
g_entities[0].client->ps.persistant[PERS_TEAMMATES_KILLED]++;
}
else // Player died, fire off scoreboard soon
{
cg.missionStatusDeadTime = level.time + 1000; // Too long?? Too short??
cg.zoomMode = 0; // turn off zooming when we die
}
}
if ( self->s.number == 0 && attacker )
{
// G_SetMissionStatusText( attacker, meansOfDeath );
//TEST: If player killed, unmark all teammates from being undying so they can buy it too
//NOTE: we want this to happen ONLY on our squad ONLY on missions... in the tutorial or on voyager levels this could be really weird.
G_MakeTeamVulnerable();
}
if ( attacker && attacker->client)
{
if ( attacker == self || OnSameTeam (self, attacker ) )
{
AddScore( attacker, -1 );
}
else
{
AddScore( attacker, 1 );
}
}
else
{
AddScore( self, -1 );
}
// if client is in a nodrop area, don't drop anything
contents = gi.pointcontents( self->currentOrigin, -1 );
if ( !holdingSaber
//&& self->s.number != 0
&& !( contents & CONTENTS_NODROP )
&& meansOfDeath != MOD_SNIPER
&& (!self->client||self->client->NPC_class!=CLASS_GALAKMECH))
{
TossClientItems( self );
}
if ( meansOfDeath == MOD_SNIPER )
{//I was disintegrated
if ( self->message )
{//I was holding a key
//drop the key
G_DropKey( self );
}
}
if ( holdingSaber )
{//never drop a lightsaber!
if ( self->client->ps.saberActive )
{
self->client->ps.saberActive = qfalse;
if ( self->client->playerTeam == TEAM_PLAYER )
{
G_SoundOnEnt( self, CHAN_AUTO, "sound/weapons/saber/saberoff.wav" );
#ifdef _IMMERSION
G_Force( self, G_ForceIndex( "fffx/weapons/saber/saberoff", FF_CHANNEL_WEAPON ) );
#endif // _IMMERSION
}
else
{
G_SoundOnEnt( self, CHAN_AUTO, "sound/weapons/saber/enemy_saber_off.wav" );
#ifdef _IMMERSION
G_Force( self, G_ForceIndex( "fffx/weapons/saber/enemy_saber_off", FF_CHANNEL_WEAPON ) );
#endif // _IMMERSION
}
}
}
else if ( self->s.weapon != WP_BLASTER_PISTOL )
{// Sigh...borg shouldn't drop their weapon attachments when they die..
self->s.weapon = WP_NONE;
if ( self->weaponModel >= 0 && self->ghoul2.size())
{
gi.G2API_RemoveGhoul2Model( self->ghoul2, self->weaponModel );
self->weaponModel = -1;
}
}
self->s.powerups &= ~PW_REMOVE_AT_DEATH;//removes everything but electricity and force push
//FIXME: do this on a callback? So people can't walk through long death anims?
//Maybe set on last frame? Would be cool for big blocking corpses if the never got set?
//self->contents = CONTENTS_CORPSE;//now done a second after death
/*
self->takedamage = qfalse; // no gibbing
if ( self->client->playerTeam == TEAM_PARASITE )
{
self->contents = CONTENTS_NONE; // FIXME: temp fix
}
else
{
self->contents = CONTENTS_CORPSE;
self->maxs[2] = -8;
}
*/
if ( !self->s.number )
{//player
self->contents = CONTENTS_CORPSE;
self->maxs[2] = -8;
}
self->clipmask&=~(CONTENTS_MONSTERCLIP|CONTENTS_BOTCLIP);//so dead NPC can fly off ledges
//FACING==========================================================
if ( attacker && self->s.number == 0 )
{
self->client->ps.stats[STAT_DEAD_YAW] = AngleNormalize180( self->client->ps.viewangles[YAW] );
}
self->currentAngles[PITCH] = 0;
self->currentAngles[ROLL] = 0;
if ( self->NPC )
{
self->NPC->desiredYaw = 0;
self->NPC->desiredPitch = 0;
self->NPC->confusionTime = 0;
self->NPC->charmedTime = 0;
}
VectorCopy( self->currentAngles, self->client->ps.viewangles );
//FACING==========================================================
if ( player && player->client && player->client->ps.viewEntity == self->s.number )
{//I was the player's viewentity and I died, kick him back to his normal view
G_ClearViewEntity( player );
}
else if ( !self->s.number && self->client->ps.viewEntity > 0 && self->client->ps.viewEntity < ENTITYNUM_NONE )
{
G_ClearViewEntity( self );
}
else if ( !self->s.number && self->client->ps.viewEntity > 0 && self->client->ps.viewEntity < ENTITYNUM_NONE )
{
G_ClearViewEntity( self );
}
self->s.loopSound = 0;
// remove powerups
memset( self->client->ps.powerups, 0, sizeof(self->client->ps.powerups) );
if ( self->client->NPC_class == CLASS_MARK1 )
{
Mark1_die( self, inflictor, attacker, damage, meansOfDeath, dflags, hitLoc );
}
else if ( self->client->NPC_class == CLASS_INTERROGATOR )
{
Interrogator_die( self, inflictor, attacker, damage, meansOfDeath, dflags, hitLoc );
}
else if ( self->client->NPC_class == CLASS_GALAKMECH )
{//FIXME: need keyframed explosions?
NPC_SetAnim( self, SETANIM_BOTH, BOTH_DEATH1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
G_AddEvent( self, Q_irand(EV_DEATH1, EV_DEATH3), self->health );
}
else if ( self->client->NPC_class == CLASS_ATST )
{//FIXME: need keyframed explosions
if ( !self->s.number )
{
G_DrivableATSTDie( self );
}
anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 ); //initialize to good data
if ( anim != -1 )
{
NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
}
else if ( self->s.number && self->message && meansOfDeath != MOD_SNIPER )
{//imp with a key on his arm
//pick a death anim that leaves key visible
switch ( Q_irand( 0, 3 ) )
{
case 0:
anim = BOTH_DEATH4;
break;
case 1:
anim = BOTH_DEATH21;
break;
case 2:
anim = BOTH_DEATH17;
break;
case 3:
default:
anim = BOTH_DEATH18;
break;
}
//FIXME: verify we have this anim?
NPC_SetAnim( self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
if ( meansOfDeath == MOD_KNOCKOUT || meansOfDeath == MOD_MELEE )
{
G_AddEvent( self, EV_JUMP, 0 );
}
else
{
G_AddEvent( self, Q_irand(EV_DEATH1, EV_DEATH3), self->health );
}
}
else if ( meansOfDeath == MOD_FALLING || (self->client->ps.legsAnim == BOTH_FALLDEATH1INAIR && self->client->ps.torsoAnim == BOTH_FALLDEATH1INAIR) || (self->client->ps.legsAnim == BOTH_FALLDEATH1 && self->client->ps.torsoAnim == BOTH_FALLDEATH1) )
{
//FIXME: no good way to predict you're going to fall to your death... need falling bushes/triggers?
if ( self->client->ps.groundEntityNum == ENTITYNUM_NONE //in the air
&& self->client->ps.velocity[2] < 0 //falling
&& self->client->ps.legsAnim != BOTH_FALLDEATH1INAIR //not already in falling loop
&& self->client->ps.torsoAnim != BOTH_FALLDEATH1INAIR )//not already in falling loop
{
NPC_SetAnim(self, SETANIM_BOTH, BOTH_FALLDEATH1INAIR, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
if ( !self->NPC )
{
G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
}
else if (!(self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
{
G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
//so we don't do this again
self->NPC->aiFlags |= NPCAI_DIE_ON_IMPACT;
//self->client->ps.gravity *= 0.5;//Fall a bit slower
self->client->ps.friction = 1;
}
}
else
{
int deathAnim = BOTH_FALLDEATH1LAND;
if ( PM_InOnGroundAnim( &self->client->ps ) )
{
if ( AngleNormalize180(self->client->renderInfo.torsoAngles[PITCH]) < 0 )
{
deathAnim = BOTH_DEATH_LYING_UP; //# Death anim when lying on back
}
else
{
deathAnim = BOTH_DEATH_LYING_DN; //# Death anim when lying on front
}
}
else if ( PM_InKnockDown( &self->client->ps ) )
{
if ( AngleNormalize180(self->client->renderInfo.torsoAngles[PITCH]) < 0 )
{
deathAnim = BOTH_DEATH_FALLING_UP; //# Death anim when falling on back
}
else
{
deathAnim = BOTH_DEATH_FALLING_DN; //# Death anim when falling on face
}
}
NPC_SetAnim(self, SETANIM_BOTH, deathAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
//HMM: check for nodrop?
G_SoundOnEnt( self, CHAN_BODY, "sound/player/fallsplat.wav" );
if ( gi.VoiceVolume[self->s.number]
&& self->NPC && (self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
{//I was talking, so cut it off... with a jump sound?
G_SoundOnEnt( self, CHAN_VOICE_ATTEN, "*pain100.wav" );
}
}
}
else
{// normal death
anim = G_CheckSpecialDeathAnim( self, self->pos1, damage, meansOfDeath, hitLoc );
if ( anim == -1 )
{
if ( self->s.legsAnim == BOTH_RESTRAINED1 || self->s.legsAnim == BOTH_RESTRAINED1POINT )
{//super special case, floating in air lying down
anim = BOTH_RESTRAINED1;
}
else if ( PM_InOnGroundAnim( &self->client->ps ) && PM_HasAnimation( self, BOTH_LYINGDEATH1 ) )
{//on ground, need different death anim
anim = BOTH_LYINGDEATH1;
}
else if ( meansOfDeath == MOD_TRIGGER_HURT && (self->s.powerups&(1<<PW_SHOCKED)) )
{//electrocuted
anim = BOTH_DEATH17;
}
else if ( meansOfDeath == MOD_WATER )
{//drowned
anim = BOTH_DEATH17;
}
else if ( meansOfDeath != MOD_SNIPER )
{
cliff_fall = G_CheckLedgeDive( self, 128, self->client->ps.velocity, qtrue, qfalse );
if ( cliff_fall == 2 )
{
if ( !FlyingCreature( self ) && g_gravity->value > 0 )
{
if ( !self->NPC )
{
G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
}
else if (!(self->NPC->aiFlags&NPCAI_DIE_ON_IMPACT) )
{
G_SoundOnEnt( self, CHAN_VOICE, "*falling1.wav" );//CHAN_VOICE_ATTEN
self->NPC->aiFlags |= NPCAI_DIE_ON_IMPACT;
self->client->ps.friction = 0;
}
}
}
if ( self->client->ps.pm_time > 0 && self->client->ps.pm_flags & PMF_TIME_KNOCKBACK && self->client->ps.velocity[2] > 0 )
{
float thrown, dot;
vec3_t throwdir, forward;
AngleVectors(self->currentAngles, forward, NULL, NULL);
thrown = VectorNormalize2(self->client->ps.velocity, throwdir);
dot = DotProduct(forward, throwdir);
if ( thrown > 100 )
{
if ( dot > 0.3 )
{//falling forward
if ( cliff_fall == 2 && PM_HasAnimation( self, BOTH_FALLDEATH1 ) )
{
anim = BOTH_FALLDEATH1;
}
else
{
switch ( Q_irand( 0, 7 ) )
{
case 0:
case 1:
case 2:
anim = BOTH_DEATH4;
break;
case 3:
case 4:
case 5:
anim = BOTH_DEATH5;
break;
case 6:
anim = BOTH_DEATH8;
break;
case 7:
anim = BOTH_DEATH14;
break;
}
if ( PM_HasAnimation( self, anim ))
{
self->client->ps.gravity *= 0.8;
self->client->ps.friction = 0;
if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
{
self->client->ps.velocity[2] = 100;
}
}
else
{
anim = -1;
}
}
}
else if ( dot < -0.3 )
{
if ( thrown >= 250 && !Q_irand( 0, 3 ) )
{
if ( Q_irand( 0, 1 ) )
{
anim = BOTH_DEATHBACKWARD1;
}
else
{
anim = BOTH_DEATHBACKWARD2;
}
}
else
{
switch ( Q_irand( 0, 7 ) )
{
case 0:
case 1:
anim = BOTH_DEATH1;
break;
case 2:
case 3:
anim = BOTH_DEATH2;
break;
case 4:
case 5:
anim = BOTH_DEATH22;
break;
case 6:
case 7:
anim = BOTH_DEATH23;
break;
}
}
if ( PM_HasAnimation( self, anim ) )
{
self->client->ps.gravity *= 0.8;
self->client->ps.friction = 0;
if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
{
self->client->ps.velocity[2] = 100;
}
}
else
{
anim = -1;
}
}
else
{//falling to one of the sides
if ( cliff_fall == 2 && PM_HasAnimation( self, BOTH_FALLDEATH1 ) )
{
anim = BOTH_FALLDEATH1;
if ( self->client->ps.velocity[2] > 0 && self->client->ps.velocity[2] < 100 )
{
self->client->ps.velocity[2] = 100;
}
}
}
}
}
}
}
else
{
specialAnim = qtrue;
}
if ( anim == -1 )
{
if ( meansOfDeath == MOD_ELECTROCUTE
|| (meansOfDeath == MOD_CRUSH && self->s.eFlags&EF_FORCE_GRIPPED) )
{//electrocuted or choked to death
anim = BOTH_DEATH17;
}
else
{
anim = G_PickDeathAnim( self, self->pos1, damage, meansOfDeath, hitLoc );
}
}
if ( anim == -1 )
{
anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 ); //initialize to good data
//TEMP HACK: these spinny deaths should happen less often
if ( ( anim == BOTH_DEATH8 || anim == BOTH_DEATH14 ) && Q_irand( 0, 1 ) )
{
anim = PM_PickAnim( self, BOTH_DEATH1, BOTH_DEATH25 ); //initialize to good data
}
}
if ( meansOfDeath == MOD_KNOCKOUT )
{
//FIXME: knock-out sound, and don't remove me
G_AddEvent( self, EV_JUMP, 0 );
G_UseTargets2( self, self, self->target2 );
G_AlertTeam( self, attacker, 512, 32 );
if ( self->NPC )
{//stick around for a while
self->NPC->timeOfDeath = level.time + 10000;
}
}
else if ( meansOfDeath == MOD_SNIPER )
{
gentity_t *tent;
vec3_t spot;
VectorCopy( self->currentOrigin, spot );
self->flags |= FL_DISINTEGRATED;
self->svFlags |= SVF_BROADCAST;
tent = G_TempEntity( spot, EV_DISINTEGRATION );
tent->s.eventParm = PW_DISRUPTION;
tent->svFlags |= SVF_BROADCAST;
tent->owner = self;
G_AlertTeam( self, attacker, 512, 88 );
if ( self->playerModel >= 0 )
{
// don't let 'em animate
gi.G2API_PauseBoneAnimIndex( &self->ghoul2[self->playerModel], self->rootBone, cg.time );
gi.G2API_PauseBoneAnimIndex( &self->ghoul2[self->playerModel], self->motionBone, cg.time );
gi.G2API_PauseBoneAnimIndex( &self->ghoul2[self->playerModel], self->lowerLumbarBone, cg.time );
anim = -1;
}
//not solid anymore
self->contents = 0;
self->maxs[2] = -8;
if ( self->NPC )
{
//need to pad deathtime some to stick around long enough for death effect to play
self->NPC->timeOfDeath = level.time + 2000;
}
}
else
{
if ( hitLoc == HL_HEAD
&& !(dflags&DAMAGE_RADIUS)
&& meansOfDeath!=MOD_REPEATER_ALT
&& meansOfDeath!=MOD_FLECHETTE_ALT
&& meansOfDeath!=MOD_ROCKET
&& meansOfDeath!=MOD_ROCKET_ALT
&& meansOfDeath!=MOD_THERMAL
&& meansOfDeath!=MOD_THERMAL_ALT
&& meansOfDeath!=MOD_DETPACK
&& meansOfDeath!=MOD_LASERTRIP
&& meansOfDeath!=MOD_LASERTRIP_ALT
&& meansOfDeath!=MOD_EXPLOSIVE
&& meansOfDeath!=MOD_EXPLOSIVE_SPLASH )
{//no sound when killed by headshot (explosions don't count)
G_AlertTeam( self, attacker, 512, 0 );
if ( gi.VoiceVolume[self->s.number] )
{//I was talking, so cut it off... with a jump sound?
G_SoundOnEnt( self, CHAN_VOICE, "*jump1.wav" );
}
}
else
{
if ( (self->client->ps.eFlags&EF_FORCE_GRIPPED) )
{//killed while gripped - no loud scream
G_AlertTeam( self, attacker, 512, 32 );
}
else if ( cliff_fall != 2 )
{
if ( meansOfDeath == MOD_KNOCKOUT || meansOfDeath == MOD_MELEE )
{
G_AddEvent( self, EV_JUMP, 0 );
}
else
{
G_AddEvent( self, Q_irand(EV_DEATH1, EV_DEATH3), self->health );
}
G_DeathAlert( self, attacker );
}
else
{//screaming death is louder
G_AlertTeam( self, attacker, 512, 1024 );
}
}
}
if ( attacker && attacker->s.number == 0 )
{//killed by player
//FIXME: this should really be wherever my body comes to rest...
AddSightEvent( attacker, self->currentOrigin, 384, AEL_DISCOVERED, 10 );
//FIXME: danger event so that others will run away from this area since it's obviously dangerous
}
if ( anim >= 0 )//can be -1 if it fails, -2 if it's already in a death anim
{
NPC_SetAnim(self, SETANIM_BOTH, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
}
}
//do any dismemberment if there's any to do...
if ( (dflags&DAMAGE_DISMEMBER) && G_DoDismemberment( self, self->pos1, meansOfDeath, damage, hitLoc ) && !specialAnim )
{//we did dismemberment and our death anim is okay to override
if ( hitLoc == HL_HAND_RT && self->locationDamage[hitLoc] >= Q3_INFINITE && cliff_fall != 2 && self->client->ps.groundEntityNum != ENTITYNUM_NONE )
{//just lost our right hand and we're on the ground, use the special anim
NPC_SetAnim( self, SETANIM_BOTH, BOTH_RIGHTHANDCHOPPEDOFF, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
}
// don't allow player to respawn for a few seconds
self->client->respawnTime = level.time + 2000;//self->client->ps.legsAnimTimer;
//lock it to this anim forever
if ( self->client )
{
PM_SetLegsAnimTimer( self, &self->client->ps.legsAnimTimer, -1 );
PM_SetTorsoAnimTimer( self, &self->client->ps.torsoAnimTimer, -1 );
}
//Flying creatures should drop when killed
//FIXME: This may screw up certain things that expect to float even while dead <?>
self->svFlags &= ~SVF_CUSTOM_GRAVITY;
self->client->ps.pm_type = PM_DEAD;
//need to update STAT_HEALTH here because ClientThink_real for self may happen before STAT_HEALTH is updated from self->health and pmove will stomp death anim with a move anim
self->client->ps.stats[STAT_HEALTH] = self->health;
if ( self->NPC )
{//If an NPC, make sure we start running our scripts again- this gets set to infinite while we fall to our deaths
self->NPC->nextBStateThink = level.time;
}
if ( G_ActivateBehavior( self, BSET_DEATH ) )
{
deathScript = qtrue;
}
if ( self->NPC && (self->NPC->scriptFlags&SCF_FFDEATH) )
{
if ( G_ActivateBehavior( self, BSET_FFDEATH ) )
{//FIXME: should running this preclude running the normal deathscript?
deathScript = qtrue;
}
G_UseTargets2( self, self, self->target4 );
}
if ( !deathScript && !(self->svFlags&SVF_KILLED_SELF) )
{
//Should no longer run scripts
//WARNING!!! DO NOT DO THIS WHILE RUNNING A SCRIPT, ICARUS WILL CRASH!!!
//FIXME: shouldn't ICARUS handle this internally?
ICARUS_FreeEnt(self);
}
// Free up any timers we may have on us.
TIMER_Clear( self );
// Set pending objectives to failed
OBJ_SetPendingObjectives(self);
gi.linkentity (self);
self->bounceCount = -1; // This is a cheap hack for optimizing the pointcontents check in deadthink
if ( self->NPC )
{
self->NPC->timeOfDeath = level.time;//this will change - used for debouncing post-death events
self->s.time = level.time;//this will not chage- this is actual time of death
}
// Start any necessary death fx for this entity
DeathFX( self );
}
qboolean G_CheckForStrongAttackMomentum( gentity_t *self )
{//see if our saber attack has too much momentum to be interrupted
if ( PM_PowerLevelForSaberAnim( &self->client->ps ) > FORCE_LEVEL_2 )
{//strong attacks can't be interrupted
if ( PM_InAnimForSaberMove( self->client->ps.torsoAnim, self->client->ps.saberMove ) )
{//our saberMove was not already interupted by some other anim (like pain)
if ( PM_SaberInStart( self->client->ps.saberMove ) )
{
float animLength = PM_AnimLength( self->client->clientInfo.animFileIndex, (animNumber_t)self->client->ps.torsoAnim );
if ( animLength - self->client->ps.torsoAnimTimer > 750 )
{//start anim is already 3/4 of a second into it, can't interrupt it now
return qtrue;
}
}
else if ( PM_SaberInReturn( self->client->ps.saberMove ) )
{
if ( self->client->ps.torsoAnimTimer > 750 )
{//still have a good amount of time left in the return anim, can't interrupt it
return qtrue;
}
}
else
{//cannot interrupt actual transitions and attacks
return qtrue;
}
}
}
return qfalse;
}
void PlayerPain( gentity_t *self, gentity_t *inflictor, gentity_t *other, vec3_t point, int damage, int mod, int hitLoc )
{
if ( self->client->NPC_class == CLASS_ATST )
{//different kind of pain checking altogether
G_ATSTCheckPain( self, other, point, damage, mod, hitLoc );
int blasterTest = gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "head_light_blaster_cann" );
int chargerTest = gi.G2API_GetSurfaceRenderStatus( &self->ghoul2[self->playerModel], "head_concussion_charger" );
if ( blasterTest && chargerTest )
{//lost both side guns
//take away that weapon
self->client->ps.stats[STAT_WEAPONS] &= ~( 1 << WP_ATST_SIDE );
//switch to primary guns
if ( self->client->ps.weapon == WP_ATST_SIDE )
{
CG_ChangeWeapon( WP_ATST_MAIN );
}
}
}
else
{
// play an apropriate pain sound
if ( level.time > self->painDebounceTime && !(self->flags & FL_GODMODE) )
{//first time hit this frame and not in godmode
self->client->ps.damageEvent++;
if ( !Q3_TaskIDPending( self, TID_CHAN_VOICE ) )
{
if ( self->client->damage_blood )
{//took damage myself, not just armor
G_AddEvent( self, EV_PAIN, self->health );
}
}
}
if ( damage != -1 && (mod==MOD_MELEE || damage==0/*fake damage*/ || (Q_irand( 0, 10 ) <= damage && self->client->damage_blood)) )
{//-1 == don't play pain anim
if ( ( ((mod==MOD_SABER||mod==MOD_MELEE)&&self->client->damage_blood) || mod == MOD_CRUSH ) && (self->s.weapon == WP_SABER||self->s.weapon==WP_MELEE) )//FIXME: not only if using saber, but if in third person at all? But then 1st/third person functionality is different...
{//FIXME: only strong-level saber attacks should make me play pain anim?
if ( !G_CheckForStrongAttackMomentum( self ) && !PM_SpinningSaberAnim( self->client->ps.legsAnim )
&& !PM_SaberInSpecialAttack( self->client->ps.torsoAnim )
&& !PM_InKnockDown( &self->client->ps ) )
{//strong attacks and spins cannot be interrupted by pain, no pain when in knockdown
int parts = SETANIM_BOTH;
if ( self->client->ps.groundEntityNum != ENTITYNUM_NONE &&
!PM_SpinningSaberAnim( self->client->ps.legsAnim ) &&
!PM_FlippingAnim( self->client->ps.legsAnim ) &&
!PM_InSpecialJump( self->client->ps.legsAnim ) &&
!PM_RollingAnim( self->client->ps.legsAnim )&&
!PM_CrouchAnim( self->client->ps.legsAnim )&&
!PM_RunningAnim( self->client->ps.legsAnim ))
{//if on a surface and not in a spin or flip, play full body pain
parts = SETANIM_BOTH;
}
else
{//play pain just in torso
parts = SETANIM_TORSO;
}
if ( self->painDebounceTime < level.time )
{
//temp HACK: these are the only 2 pain anims that look good when holding a saber
NPC_SetAnim( self, parts, PM_PickAnim( self, BOTH_PAIN2, BOTH_PAIN3 ), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
self->client->ps.saberMove = LS_READY;//don't finish whatever saber move you may have been in
//WTF - insn't working
if ( self->health < 10 && d_slowmodeath->integer > 5 )
{
G_StartMatrixEffect( self );
}
}
if ( parts == SETANIM_BOTH && damage > 30 || (self->painDebounceTime>level.time&&damage>10))
{//took a lot of damage in 1 hit //or took 2 hits in quick succession
self->aimDebounceTime = level.time + self->client->ps.torsoAnimTimer;
self->client->ps.pm_time = self->client->ps.torsoAnimTimer;
self->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
}
self->client->ps.weaponTime = self->client->ps.torsoAnimTimer;
self->attackDebounceTime = level.time + self->client->ps.torsoAnimTimer;
}
self->painDebounceTime = level.time + self->client->ps.torsoAnimTimer;
}
}
}
if ( self->painDebounceTime <= level.time )
{
self->painDebounceTime = level.time + 700;
}
}
/*
================
CheckArmor
================
*/
int CheckArmor (gentity_t *ent, int damage, int dflags)
{
gclient_t *client;
int save;
int count;
if (!damage)
return 0;
client = ent->client;
if (!client)
return 0;
if ( (dflags&DAMAGE_NO_ARMOR) )
return 0;
if ( client->NPC_class == CLASS_GALAKMECH )
{//special case
if ( client->ps.stats[STAT_ARMOR] <= 0 )
{//no shields
client->ps.powerups[PW_GALAK_SHIELD] = 0;
return 0;
}
else
{//shields take all the damage
client->ps.stats[STAT_ARMOR] -= damage;
if ( client->ps.stats[STAT_ARMOR] <= 0 )
{
client->ps.powerups[PW_GALAK_SHIELD] = 0;
client->ps.stats[STAT_ARMOR] = 0;
}
return damage;
}
}
else
{
// armor
count = client->ps.stats[STAT_ARMOR];
// No damage to entity until armor is at less than 50% strength
if (count > (client->ps.stats[STAT_MAX_HEALTH]/2)) // MAX_HEALTH is considered max armor. Or so I'm told.
{
save = damage;
}
else
{
if ( !ent->s.number && client->NPC_class == CLASS_ATST )
{//player in ATST... armor takes *all* the damage
save = damage;
}
else
{
save = ceil( (float) damage * ARMOR_PROTECTION );
}
}
//Always round up
if (damage == 1)
{
if ( client->ps.stats[STAT_ARMOR] > 0 )
client->ps.stats[STAT_ARMOR] -= save;
return 0;
}
if (save >= count)
save = count;
if (!save)
return 0;
client->ps.stats[STAT_ARMOR] -= save;
return save;
}
}
extern void NPC_SetPainEvent( gentity_t *self );
void G_Knockdown( gentity_t *self, gentity_t *attacker, vec3_t pushDir, float strength, qboolean breakSaberLock )
{
if ( !self || !self->client || !attacker || !attacker->client )
{
return;
}
//break out of a saberLock?
if ( breakSaberLock )
{
self->client->ps.saberLockTime = 0;
self->client->ps.saberLockEnemy = ENTITYNUM_NONE;
}
if ( self->health > 0 )
{
if ( !self->s.number )
{
NPC_SetPainEvent( self );
}
else
{
GEntity_PainFunc( self, attacker, attacker, self->currentOrigin, 0, MOD_MELEE );
}
G_CheckLedgeDive( self, 72, pushDir, qfalse, qfalse );
if ( !PM_SpinningSaberAnim( self->client->ps.legsAnim )
&& !PM_FlippingAnim( self->client->ps.legsAnim )
&& !PM_RollingAnim( self->client->ps.legsAnim )
&& !PM_InKnockDown( &self->client->ps ) )
{
int knockAnim = BOTH_KNOCKDOWN1;//default knockdown
if ( !self->s.number && ( !g_spskill->integer || strength < 300 ) )
{//player only knocked down if pushed *hard*
return;
}
else if ( PM_CrouchAnim( self->client->ps.legsAnim ) )
{//crouched knockdown
knockAnim = BOTH_KNOCKDOWN4;
}
else
{//plain old knockdown
vec3_t pLFwd, pLAngles = {0,self->client->ps.viewangles[YAW],0};
AngleVectors( pLAngles, pLFwd, NULL, NULL );
if ( DotProduct( pLFwd, pushDir ) > 0.2f )
{//pushing him from behind
knockAnim = BOTH_KNOCKDOWN3;
}
else
{//pushing him from front
knockAnim = BOTH_KNOCKDOWN1;
}
}
if ( knockAnim == BOTH_KNOCKDOWN1 && strength > 150 )
{//push *hard*
knockAnim = BOTH_KNOCKDOWN2;
}
NPC_SetAnim( self, SETANIM_BOTH, knockAnim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
if ( self->s.number )
{//randomize getup times
int addTime = Q_irand( -300, 1000 );
self->client->ps.legsAnimTimer += addTime;
self->client->ps.torsoAnimTimer += addTime;
}
}
}
}
void G_CheckKnockdown( gentity_t *targ, gentity_t *attacker, vec3_t newDir, int dflags, int mod )
{
if ( !targ || !attacker )
{
return;
}
if ( !(dflags&DAMAGE_RADIUS) )
{//not inherently explosive damage, check mod
if ( mod!=MOD_REPEATER_ALT
&&mod!=MOD_FLECHETTE_ALT
&&mod!=MOD_ROCKET
&&mod!=MOD_ROCKET_ALT
&&mod!=MOD_THERMAL
&&mod!=MOD_THERMAL_ALT
&&mod!=MOD_DETPACK
&&mod!=MOD_LASERTRIP
&&mod!=MOD_LASERTRIP_ALT
&&mod!=MOD_EXPLOSIVE
&&mod!=MOD_EXPLOSIVE_SPLASH )
{
return;
}
}
if ( !targ->client || targ->client->NPC_class == CLASS_PROTOCOL || !G_StandardHumanoid( targ->NPC_type ) )
{
return;
}
if ( targ->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//already in air
return;
}
if ( !targ->s.number )
{//player less likely to be knocked down
if ( !g_spskill->integer )
{//never in easy
return;
}
if ( !cg.renderingThirdPerson || cg.zoomMode )
{//never if not in chase camera view (so more likely with saber out)
return;
}
if ( g_spskill->integer == 1 )
{//33% chance on medium
if ( Q_irand( 0, 2 ) )
{
return;
}
}
else
{//50% chance on hard
if ( Q_irand( 0, 1 ) )
{
return;
}
}
}
float strength = VectorLength( targ->client->ps.velocity );
if ( targ->client->ps.velocity[2] > 100 && strength > Q_irand( 150, 350 ) )//600 ) )
{//explosive concussion possibly do a knockdown?
G_Knockdown( targ, attacker, newDir, strength, qtrue );
}
}
void G_ApplyKnockback( gentity_t *targ, vec3_t newDir, float knockback )
{
vec3_t kvel;
float mass;
//--- TEMP TEST
if ( newDir[2] <= 0.0f )
{
newDir[2] += (( 0.0f - newDir[2] ) * 1.2f );
}
knockback *= 2.0f;
if ( knockback > 120 )
{
knockback = 120;
}
//--- TEMP TEST
if ( targ->physicsBounce > 0 ) //overide the mass
mass = targ->physicsBounce;
else
mass = 200;
if ( g_gravity->value > 0 )
{
VectorScale( newDir, g_knockback->value * (float)knockback / mass * 0.8, kvel );
kvel[2] = newDir[2] * ( g_knockback->value * (float)knockback ) / ( mass * 1.5 ) + 20;
}
else
{
VectorScale( newDir, g_knockback->value * (float)knockback / mass, kvel );
}
if ( targ->client )
{
VectorAdd( targ->client->ps.velocity, kvel, targ->client->ps.velocity );
}
else if ( targ->s.pos.trType != TR_STATIONARY && targ->s.pos.trType != TR_LINEAR_STOP && targ->s.pos.trType != TR_NONLINEAR_STOP )
{
VectorAdd( targ->s.pos.trDelta, kvel, targ->s.pos.trDelta );
VectorCopy( targ->currentOrigin, targ->s.pos.trBase );
targ->s.pos.trTime = level.time;
}
// set the timer so that the other client can't cancel
// out the movement immediately
if ( targ->client && !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;
}
}
static int G_CheckForLedge( gentity_t *self, vec3_t fallCheckDir, float checkDist )
{
vec3_t start, end;
trace_t tr;
VectorMA( self->currentOrigin, checkDist, fallCheckDir, end );
//Should have clip burshes masked out by now and have bbox resized to death size
gi.trace( &tr, self->currentOrigin, self->mins, self->maxs, end, self->s.number, self->clipmask );
if ( tr.allsolid || tr.startsolid )
{
return 0;
}
VectorCopy( tr.endpos, start );
VectorCopy( start, end );
end[2] -= 256;
gi.trace( &tr, start, self->mins, self->maxs, end, self->s.number, self->clipmask );
if ( tr.allsolid || tr.startsolid )
{
return 0;
}
if ( tr.fraction >= 1.0 )
{
return (start[2]-tr.endpos[2]);
}
return 0;
}
static void G_FriendlyFireReaction( gentity_t *self, gentity_t *other, int dflags )
{
if ( (!player->client->ps.viewEntity || other->s.number != player->client->ps.viewEntity))
{//hit by a teammate
if ( other != self->enemy && self != other->enemy )
{//we weren't already enemies
if ( self->enemy || other->enemy || (other->s.number&&other->s.number!=player->client->ps.viewEntity) )
{//if one of us actually has an enemy already, it's okay, just an accident OR wasn't hit by player or someone controlled by player OR player hit ally and didn't get 25% chance of getting mad (FIXME:accumulate anger+base on diff?)
return;
}
else if ( self->NPC && !other->s.number )//should be assumed, but...
{//dammit, stop that!
if ( !(dflags&DAMAGE_RADIUS) )
{
//if it's radius damage, ignore it
if ( self->NPC->ffireDebounce < level.time )
{
//FIXME: way something? NEED DIALOGUE
self->NPC->ffireCount++;
//Com_Printf( "incr: %d < %d\n", self->NPC->ffireCount, 3+((2-g_spskill->integer)*2) );
self->NPC->ffireDebounce = level.time + 500;
}
}
}
}
}
}
float damageModifier[HL_MAX] =
{
1.0f, //HL_NONE,
0.25f, //HL_FOOT_RT,
0.25f, //HL_FOOT_LT,
0.75f, //HL_LEG_RT,
0.75f, //HL_LEG_LT,
1.0f, //HL_WAIST,
1.0f, //HL_BACK_RT,
1.0f, //HL_BACK_LT,
1.0f, //HL_BACK,
1.0f, //HL_CHEST_RT,
1.0f, //HL_CHEST_LT,
1.0f, //HL_CHEST,
0.5f, //HL_ARM_RT,
0.5f, //HL_ARM_LT,
0.25f, //HL_HAND_RT,
0.25f, //HL_HAND_LT,
2.0f, //HL_HEAD,
1.0f, //HL_GENERIC1,
1.0f, //HL_GENERIC2,
1.0f, //HL_GENERIC3,
1.0f, //HL_GENERIC4,
1.0f, //HL_GENERIC5,
1.0f, //HL_GENERIC6,
};
void G_TrackWeaponUsage( gentity_t *self, gentity_t *inflictor, int add, int mod )
{
if ( !self || !self->client || self->s.number )
{//player only
return;
}
int weapon = WP_NONE;
//FIXME: need to check the MOD to find out what weapon (if *any*) actually did the killing
if ( inflictor && !inflictor->client && mod != MOD_SABER && inflictor->lastEnemy && inflictor->lastEnemy != self )
{//a missile that was reflected, ie: not owned by me originally
if ( inflictor->owner == self && self->s.weapon == WP_SABER )
{//we reflected it
weapon = WP_SABER;
}
}
if ( weapon == WP_NONE )
{
switch ( mod )
{
case MOD_SABER:
weapon = WP_SABER;
break;
case MOD_BRYAR:
case MOD_BRYAR_ALT:
weapon = WP_BRYAR_PISTOL;
break;
case MOD_BLASTER:
case MOD_BLASTER_ALT:
weapon = WP_BLASTER;
break;
case MOD_DISRUPTOR:
case MOD_SNIPER:
weapon = WP_DISRUPTOR;
break;
case MOD_BOWCASTER:
case MOD_BOWCASTER_ALT:
weapon = WP_BOWCASTER;
break;
case MOD_REPEATER:
case MOD_REPEATER_ALT:
weapon = WP_REPEATER;
break;
case MOD_DEMP2:
case MOD_DEMP2_ALT:
weapon = WP_DEMP2;
break;
case MOD_FLECHETTE:
case MOD_FLECHETTE_ALT:
weapon = WP_FLECHETTE;
break;
case MOD_ROCKET:
case MOD_ROCKET_ALT:
weapon = WP_ROCKET_LAUNCHER;
break;
case MOD_THERMAL:
case MOD_THERMAL_ALT:
weapon = WP_THERMAL;
break;
case MOD_DETPACK:
weapon = WP_DET_PACK;
break;
case MOD_LASERTRIP:
case MOD_LASERTRIP_ALT:
weapon = WP_TRIP_MINE;
break;
case MOD_MELEE:
if ( self->s.weapon == WP_STUN_BATON )
{
weapon = WP_STUN_BATON;
}
else if ( self->s.weapon == WP_MELEE )
{
weapon = WP_MELEE;
}
break;
}
}
if ( weapon != WP_NONE )
{
self->client->sess.missionStats.weaponUsed[weapon] += add;
}
}
qboolean G_NonLocationSpecificDamage( int meansOfDeath )
{
if ( meansOfDeath == MOD_EXPLOSIVE
|| meansOfDeath == MOD_REPEATER_ALT
|| meansOfDeath == MOD_FLECHETTE_ALT
|| meansOfDeath == MOD_ROCKET
|| meansOfDeath == MOD_ROCKET_ALT
|| meansOfDeath == MOD_THERMAL
|| meansOfDeath == MOD_THERMAL_ALT
|| meansOfDeath == MOD_DETPACK
|| meansOfDeath == MOD_LASERTRIP
|| meansOfDeath == MOD_LASERTRIP_ALT
|| meansOfDeath == MOD_MELEE
|| meansOfDeath == MOD_FORCE_GRIP
|| meansOfDeath == MOD_KNOCKOUT
|| meansOfDeath == MOD_CRUSH
|| meansOfDeath == MOD_EXPLOSIVE_SPLASH )
{
return qtrue;
}
return qfalse;
}
/*
============
T_Damage
targ entity that is being damaged
inflictor entity that is causing the damage
attacker entity that caused the inflictor to damage targ
example: targ=monster, inflictor=rocket, attacker=player
dir direction of the attack for knockback
point point at which the damage is being inflicted, used for headshots
damage amount of damage being inflicted
knockback force to be applied against targ as a result of the damage
inflictor, attacker, dir, and point can be NULL for environmental effects
dflags these flags are used to control how T_Damage works
DAMAGE_RADIUS damage was indirect (from a nearby explosion)
DAMAGE_NO_ARMOR armor does not protect from this damage
DAMAGE_NO_KNOCKBACK do not affect velocity, just view angles
DAMAGE_NO_PROTECTION kills godmode, armor, everything
DAMAGE_NO_HIT_LOC Damage not based on hit location
============
*/
void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker, vec3_t dir, vec3_t point, int damage, int dflags, int mod, int hitLoc )
{
gclient_t *client;
int take;
int save;
int asave = 0;
int knockback;
vec3_t newDir;
qboolean alreadyDead = qfalse;
if (!targ->takedamage) {
return;
}
if ( targ->health <= 0 && !targ->client )
{ // allow corpses to be disintegrated
if( mod != MOD_SNIPER || (targ->flags & FL_DISINTEGRATED) )
return;
}
// if we are the player and we are locked to an emplaced gun, we have to reroute damage to the gun....sigh.
if ( targ->s.eFlags & EF_LOCKED_TO_WEAPON && targ->s.number == 0 && targ->owner && !( targ->owner->flags & FL_GODMODE ))
{
// swapping the gun into our place to absorb our damage
targ = targ->owner;
}
if ( (targ->flags&FL_SHIELDED) && mod != MOD_SABER && !targ->client)
{//magnetically protected, this thing can only be damaged by lightsabers
return;
}
if ( (targ->flags&FL_DMG_BY_SABER_ONLY) && mod != MOD_SABER )
{//can only be damaged by lightsabers (but no shield... yeah, it's redundant, but whattayagonnado?)
return;
}
if (( targ->flags & FL_DMG_BY_HEAVY_WEAP_ONLY ) && !( dflags & DAMAGE_HEAVY_WEAP_CLASS ))
{
// can only be damaged by an heavy type weapon...but impacting missile was in the heavy weap class...so we just aren't taking damage from this missile
return;
}
if ( targ->client && targ->client->NPC_class == CLASS_ATST )
{
// extra checks can be done here
if ( mod == MOD_SNIPER || mod == MOD_DISRUPTOR )
{
// disruptor does not hurt an atst
return;
}
}
if ( mod == MOD_SABER )
{//sabers do less damage to mark1's and atst's
if ( targ->client && (targ->client->NPC_class == CLASS_ATST || targ->client->NPC_class == CLASS_MARK1) )
{
// I guess always do 5 points of damage...feel free to tweak as needed
if ( damage > 5 )
{
damage = 5;
}
}
}
if ( !inflictor ) {
inflictor = &g_entities[ENTITYNUM_WORLD];
}
if ( !attacker ) {
attacker = &g_entities[ENTITYNUM_WORLD];
}
// no more weakling allies!
// if ( attacker->s.number != 0 && damage >= 2 && targ->s.number != 0 && attacker->client && attacker->client->playerTeam == TEAM_PLAYER )
// {//player-helpers do only half damage to enemies
// damage = ceil((float)damage/2.0f);
// }
client = targ->client;
if ( client ) {
if ( client->noclip && !targ->s.number ) {
return;
}
}
if ( dflags&DAMAGE_NO_DAMAGE )
{
damage = 0;
}
if ( dir == NULL )
{
dflags |= DAMAGE_NO_KNOCKBACK;
}
else
{
VectorNormalize2( dir, newDir );
}
if ( targ->s.number != 0 )
{//not the player
if ( (targ->flags&FL_GODMODE) || (targ->flags&FL_UNDYING) )
{//have god or undying on, so ignore no protection flag
dflags &= ~DAMAGE_NO_PROTECTION;
}
}
if ( client && PM_InOnGroundAnim( &client->ps ))
{
dflags |= DAMAGE_NO_KNOCKBACK;
}
if ( !attacker->s.number && targ->client && attacker->client && targ->client->playerTeam == attacker->client->playerTeam )
{//player doesn't do knockback against allies unless he kills them
dflags |= DAMAGE_DEATH_KNOCKBACK;
}
if ( client && client->NPC_class == CLASS_GALAKMECH )
{//hit Galak
if ( client->ps.stats[STAT_ARMOR] > 0 )
{//shields are up
dflags &= ~DAMAGE_NO_ARMOR;//always affect armor
if ( mod == MOD_ELECTROCUTE
|| mod == MOD_DEMP2
|| mod == MOD_DEMP2_ALT )
{//shield protects us from this
damage = 0;
}
}
else
{//shields down
if ( mod == MOD_MELEE
|| (mod == MOD_CRUSH && attacker && attacker->client) )
{//Galak takes no impact damage
return;
}
if ( (dflags & DAMAGE_RADIUS)
|| mod == MOD_REPEATER_ALT
|| mod == MOD_FLECHETTE_ALT
|| mod == MOD_ROCKET
|| mod == MOD_ROCKET_ALT
|| mod == MOD_THERMAL
|| mod == MOD_THERMAL_ALT
|| mod == MOD_DETPACK
|| mod == MOD_LASERTRIP
|| mod == MOD_LASERTRIP_ALT
|| mod == MOD_EXPLOSIVE_SPLASH
|| mod == MOD_ENERGY_SPLASH
|| mod == MOD_SABER )
{//galak without shields takes quarter damage from explosives and lightsaber
damage = ceil((float)damage/4.0f);
}
}
}
if ( mod == MOD_DEMP2 || mod == MOD_DEMP2_ALT )
{
if ( client )
{
if ( client->NPC_class == CLASS_PROTOCOL || client->NPC_class == CLASS_SEEKER ||
client->NPC_class == CLASS_R2D2 || client->NPC_class == CLASS_R5D2 ||
client->NPC_class == CLASS_MOUSE || client->NPC_class == CLASS_GONK )
{
// DEMP2 does more damage to these guys.
damage *= 2;
}
else if ( client->NPC_class == CLASS_PROBE || client->NPC_class == CLASS_INTERROGATOR ||
client->NPC_class == CLASS_MARK1 || client->NPC_class == CLASS_MARK2 || client->NPC_class == CLASS_SENTRY ||
client->NPC_class == CLASS_ATST )
{
// DEMP2 does way more damage to these guys.
damage *= 5;
}
}
else if ( targ->s.weapon == WP_TURRET )
{
damage *= 6;// more damage to turret things
}
}
knockback = damage;
//Attempt to apply extra knockback
if ( dflags & DAMAGE_EXTRA_KNOCKBACK )
{
knockback *= 2;
}
if ( knockback > 200 ) {
knockback = 200;
}
if ( mod == MOD_CRUSH )
{
knockback = 0;
}
else if ( targ->flags & FL_NO_KNOCKBACK )
{
knockback = 0;
}
else if ( targ->client && attacker->client && targ->client->playerTeam == attacker->client->playerTeam )
{
knockback = 0;
}
else if ( dflags & DAMAGE_NO_KNOCKBACK )
{
knockback = 0;
}
// figure momentum add, even if the damage won't be taken
if ( knockback && !(dflags&DAMAGE_DEATH_KNOCKBACK) ) //&& targ->client
{
G_ApplyKnockback( targ, newDir, knockback );
G_CheckKnockdown( targ, attacker, newDir, dflags, mod );
}
// check for godmode, completely getting out of the damage
if ( targ->flags & FL_GODMODE && !(dflags&DAMAGE_NO_PROTECTION) )
{
if ( targ->client
&& attacker->client
&& targ->client->playerTeam == attacker->client->playerTeam
&& (!targ->NPC || !targ->NPC->charmedTime) )
{//complain, but don't turn on them
G_FriendlyFireReaction( targ, attacker, dflags );
}
return;
}
// Check for team damage
/*
if ( targ != attacker && !(dflags&DAMAGE_IGNORE_TEAM) && OnSameTeam (targ, attacker) )
{//on same team
if ( !targ->client )
{//a non-player object should never take damage from an ent on the same team
return;
}
if ( attacker->client && attacker->client->playerTeam == targ->noDamageTeam )
{//NPC or player shot an object on his own team
return;
}
if ( attacker->s.number != 0 && targ->s.number != 0 &&//player not involved in any way in this exchange
attacker->client && targ->client &&//two NPCs
attacker->client->playerTeam == targ->client->playerTeam ) //on the same team
{//NPCs on same team don't hurt each other
return;
}
if ( targ->s.number == 0 &&//player was hit
attacker->client && targ->client &&//by an NPC
attacker->client->playerTeam == TEAM_PLAYER ) //on the same team
{
if ( attacker->enemy != targ )//by accident
{//do no damage, no armor loss, no reaction, run no scripts
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;
}
}
take = damage;
save = 0;
//FIXME: Do not use this method of difficulty changing
// Scale the amount of damage given to the player based on the skill setting
/*
if ( targ->s.number == 0 && targ != attacker )
{
take *= ( g_spskill->integer + 1) * 0.75;
}
if ( take < 1 ) {
take = 1;
}
*/
if ( client )
{
//don't lose armor if on same team
// save some from armor
asave = CheckArmor (targ, take, dflags);
if ( !asave )
{//all out of armor
targ->client->ps.powerups[PW_BATTLESUIT] = 0;
}
else
{
targ->client->ps.powerups[PW_BATTLESUIT] = level.time + ARMOR_EFFECT_TIME;
}
take -= asave;
}
if ( !(dflags&DAMAGE_NO_HIT_LOC) || !(dflags&DAMAGE_RADIUS))
{
if ( !G_NonLocationSpecificDamage( mod ) )
{//certain kinds of damage don't care about hitlocation
take = ceil( (float)take*damageModifier[hitLoc] );
}
}
if ( g_debugDamage->integer ) {
gi.Printf( "[%d]client:%i health:%i damage:%i armor:%i hitloc:%s\n", level.time, targ->s.number, targ->health, take, asave, hitLocName[hitLoc] );
}
// 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 ) {
client->ps.persistant[PERS_ATTACKER] = attacker->s.number; //attack can be the world ent
client->damage_armor += asave;
client->damage_blood += take;
client->damage_knockback += knockback;
if ( dir ) { //can't check newdir since it's local, newdir is dir normalized
VectorCopy ( newDir, client->damage_from );
client->damage_fromWorld = qfalse;
} else {
VectorCopy ( targ->currentOrigin, client->damage_from );
client->damage_fromWorld = qtrue;
}
}
// do the damage
if ( targ->health <= 0 )
{
alreadyDead = qtrue;
}
if ( attacker && attacker->client && !attacker->s.number )
{
if ( !alreadyDead )
{
int add;
if ( take > targ->health )
{
add = targ->health;
}
else
{
add = take;
}
add += asave;
add = ceil(add/10.0f);
if ( attacker != targ )
{
G_TrackWeaponUsage( attacker, inflictor, add, mod );
}
}
}
if ( take || (dflags&DAMAGE_NO_DAMAGE) )
{
if ( !targ->client || !attacker->client )
{
targ->health = targ->health - take;
if (targ->health < 0)
{
targ->health = 0;
}
if ( !alreadyDead && ( ((targ->flags&FL_UNDYING) && !(dflags&DAMAGE_NO_PROTECTION)) || (dflags&DAMAGE_NO_KILL)) )
{
if(targ->health < 1)
{
G_ActivateBehavior( targ, BSET_DEATH );
targ->health = 1;
}
}
}
else
{//two clients
team_t targTeam = TEAM_FREE;
team_t attackerTeam = TEAM_FREE;
if ( player->client->ps.viewEntity && targ->s.number == player->client->ps.viewEntity )
{
targTeam = player->client->playerTeam;
}
else if ( targ->client ) {
targTeam = targ->client->playerTeam;
}
else {
targTeam = targ->noDamageTeam;
}
// if ( targTeam == TEAM_DISGUISE ) {
// targTeam = TEAM_PLAYER;
// }
if ( player->client->ps.viewEntity && attacker->s.number == player->client->ps.viewEntity )
{
attackerTeam = player->client->playerTeam;
}
else if ( attacker->client ) {
attackerTeam = attacker->client->playerTeam;
}
else {
attackerTeam = attacker->noDamageTeam;
}
// if ( attackerTeam == TEAM_DISGUISE ) {
// attackerTeam = TEAM_PLAYER;
// }
if ( targTeam != attackerTeam )
{//on the same team
targ->health = targ->health - take;
//MCG - Falling should never kill player- only if a trigger_hurt does so.
if ( mod == MOD_FALLING && targ->s.number == 0 && targ->health < 1 )
{
targ->health = 1;
}
else if (targ->health < 0)
{
targ->health = 0;
}
if ( !alreadyDead && ( ((targ->flags&FL_UNDYING) && !(dflags&DAMAGE_NO_PROTECTION)) || (dflags&DAMAGE_NO_KILL) ) )
{
if ( targ->health < 1 )
{
G_ActivateBehavior( targ, BSET_DEATH );
targ->health = 1;
}
}
else if ( targ->health < 1 && attacker->client )
{ // The player or NPC just killed an enemy so increment the kills counter
attacker->client->ps.persistant[PERS_ENEMIES_KILLED]++;
}
}
else if ( targTeam == TEAM_PLAYER )
{//on the same team, and target is an ally
qboolean takeDamage = qtrue;
qboolean yellAtAttacker = qtrue;
//1) player doesn't take damage from teammates unless they're angry at him
if ( targ->s.number == 0 )
{//the player
if ( attacker->enemy != targ && attacker != targ )
{//an NPC shot the player by accident
takeDamage = qfalse;
}
}
//2) NPCs don't take any damage from player during combat
else
{//an NPC
if ( ((dflags & DAMAGE_RADIUS)) && !(dflags&DAMAGE_IGNORE_TEAM) )
{//An NPC got hit by player and this is during combat or it was slash damage
//NOTE: though it's not realistic to have teammates not take splash damage,
// even when not in combat, it feels really bad to have them able to
// actually be killed by the player's splash damage
takeDamage = qfalse;
}
if ( (dflags & DAMAGE_RADIUS) )
{//you're fighting and it's just radius damage, so don't even mention it
yellAtAttacker = qfalse;
}
}
if ( takeDamage )
{
targ->health = targ->health - take;
if ( !alreadyDead && (((targ->flags&FL_UNDYING) && !(dflags&DAMAGE_NO_PROTECTION) && attacker->s.number != 0) || (dflags&DAMAGE_NO_KILL) ) )
{//guy is marked undying and we're not the player or we're in combat
if ( targ->health < 1 )
{
G_ActivateBehavior( targ, BSET_DEATH );
targ->health = 1;
}
}
else if ( !alreadyDead && (((targ->flags&FL_UNDYING) && !(dflags&DAMAGE_NO_PROTECTION) && !attacker->s.number && !targ->s.number) || (dflags&DAMAGE_NO_KILL)) )
{// player is undying and he's attacking himself, don't let him die
if ( targ->health < 1 )
{
G_ActivateBehavior( targ, BSET_DEATH );
targ->health = 1;
}
}
else if ( targ->health < 0 )
{
targ->health = 0;
if ( attacker->s.number == 0 && targ->NPC )
{
targ->NPC->scriptFlags |= SCF_FFDEATH;
}
}
}
if ( yellAtAttacker )
{
if ( !targ->NPC || !targ->NPC->charmedTime )
{
G_FriendlyFireReaction( targ, attacker, dflags );
}
}
}
}
if ( targ->client ) {
targ->client->ps.stats[STAT_HEALTH] = targ->health;
g_lastClientDamaged = targ;
}
//TEMP HACK FOR PLAYER LOOK AT ENEMY CODE
//FIXME: move this to a player pain func?
if ( targ->s.number == 0 )
{
if ( !targ->enemy //player does not have an enemy yet
|| targ->enemy->s.weapon != WP_SABER //or player's enemy is not a jedi
|| attacker->s.weapon == WP_SABER )//and attacker is a jedi
//keep enemy jedi over shooters
{
if ( attacker->enemy == targ || !OnSameTeam( targ, attacker ) )
{//don't set player's enemy to teammates that hit him by accident
targ->enemy = attacker;
}
NPC_SetLookTarget( targ, attacker->s.number, level.time+1000 );
}
}
else if ( attacker->s.number == 0 && (!targ->NPC || !targ->NPC->timeOfDeath) && (mod == MOD_SABER || attacker->s.weapon != WP_SABER || !attacker->enemy || attacker->enemy->s.weapon != WP_SABER) )//keep enemy jedi over shooters
{//this looks dumb when they're on the ground and you keep hitting them, so only do this when first kill them
if ( !OnSameTeam( targ, attacker ) )
{//don't set player's enemy to teammates that he hits by accident
attacker->enemy = targ;
}
NPC_SetLookTarget( attacker, targ->s.number, level.time+1000 );
}
//TEMP HACK FOR PLAYER LOOK AT ENEMY CODE
//add up the damage to the location
if ( targ->client )
{
if ( targ->locationDamage[hitLoc] < Q3_INFINITE )
{
targ->locationDamage[hitLoc] += take;
}
}
if ( targ->health > 0 && targ->NPC && targ->NPC->surrenderTime > level.time )
{//he was surrendering, goes down with one hit
targ->health = 0;
}
if ( targ->health <= 0 )
{
if ( knockback && (dflags&DAMAGE_DEATH_KNOCKBACK) )//&& targ->client
{//only do knockback on death
if ( mod == MOD_FLECHETTE )
{//special case because this is shotgun-ish damage, we need to multiply the knockback
knockback *= 12;//*6 for 6 flechette shots
}
G_ApplyKnockback( targ, newDir, knockback );
}
if ( client )
targ->flags |= FL_NO_KNOCKBACK;
if (targ->health < -999)
targ->health = -999;
// If we are a breaking glass brush, store the damage point so we can do cool things with it.
if ( targ->svFlags & SVF_GLASS_BRUSH )
{
VectorCopy( point, targ->pos1 );
VectorCopy( dir, targ->pos2 );
}
if ( targ->client )
{//HACK
if ( point )
{
VectorCopy( point, targ->pos1 );
}
else
{
VectorCopy( targ->currentOrigin, targ->pos1 );
}
}
if ( !alreadyDead && !targ->enemy )
{//just killed and didn't have an enemy before
targ->enemy = attacker;
}
GEntity_DieFunc( targ, inflictor, attacker, take, mod, dflags, hitLoc );
}
else
{
GEntity_PainFunc( targ, inflictor, attacker, point, take, mod, hitLoc );
if ( targ->s.number == 0 )
{//player run painscript
G_ActivateBehavior( targ, BSET_PAIN );
if ( targ->health <= 25 )
{
G_ActivateBehavior( targ, BSET_FLEE );
}
}
}
}
}
/*
============
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 at 0,0,0
VectorAdd (targ->absmin, targ->absmax, midpoint);
VectorScale (midpoint, 0.5, midpoint);
VectorCopy (midpoint, dest);
gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (( tr.fraction == 1.0 && !(targ->contents & MASK_SOLID)) || tr.entityNum == targ->s.number ) // if we also test the entitynum's we can bust up bbrushes better!
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;
gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (( tr.fraction == 1.0 && !(targ->contents & MASK_SOLID)) || tr.entityNum == targ->s.number )
return qtrue;
VectorCopy (midpoint, dest);
dest[0] += 15.0;
dest[1] -= 15.0;
gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (( tr.fraction == 1.0 && !(targ->contents & MASK_SOLID)) || tr.entityNum == targ->s.number )
return qtrue;
VectorCopy (midpoint, dest);
dest[0] -= 15.0;
dest[1] += 15.0;
gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (( tr.fraction == 1.0 && !(targ->contents & MASK_SOLID)) || tr.entityNum == targ->s.number )
return qtrue;
VectorCopy (midpoint, dest);
dest[0] -= 15.0;
dest[1] -= 15.0;
gi.trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
if (( tr.fraction == 1.0 && !(targ->contents & MASK_SOLID)) || tr.entityNum == targ->s.number )
return qtrue;
return qfalse;
}
/*
============
G_RadiusDamage
============
*/
void G_RadiusDamage ( vec3_t origin, gentity_t *attacker, float damage, float radius,
gentity_t *ignore, int mod) {
float points, dist;
gentity_t *ent;
gentity_t *entityList[MAX_GENTITIES];
int numListedEntities;
vec3_t mins, maxs;
vec3_t v;
vec3_t dir;
int i, e;
if ( radius < 1 ) {
radius = 1;
}
for ( i = 0 ; i < 3 ; i++ ) {
mins[i] = origin[i] - radius;
maxs[i] = origin[i] + radius;
}
numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
for ( e = 0 ; e < numListedEntities ; e++ ) {
ent = entityList[ e ];
if ( ent == ignore )
continue;
if ( !ent->takedamage )
continue;
if ( !ent->contents )
continue;
// find the distance from the edge of the bounding box
for ( i = 0 ; i < 3 ; i++ ) {
if ( origin[i] < ent->absmin[i] ) {
v[i] = ent->absmin[i] - origin[i];
} else if ( origin[i] > ent->absmax[i] ) {
v[i] = origin[i] - ent->absmax[i];
} else {
v[i] = 0;
}
}
dist = VectorLength( v );
if ( dist >= radius ) {
continue;
}
points = damage * ( 1.0 - dist / radius );
if (CanDamage (ent, origin))
{//FIXME: still do a little damage in in PVS and close?
if ( ent->svFlags & (SVF_GLASS_BRUSH|SVF_BBRUSH) )
{
VectorAdd( ent->absmin, ent->absmax, v );
VectorScale( v, 0.5f, v );
}
else
{
VectorCopy( ent->currentOrigin, v );
}
VectorSubtract( v, origin, dir);
// push the center of mass higher than the origin so players
// get knocked into the air more
dir[2] += 24;
if ( ent->svFlags & SVF_GLASS_BRUSH )
{
if ( points > 1.0f )
{
// we want to cap this at some point, otherwise it just gets crazy
if ( points > 6.0f )
{
VectorScale( dir, 6.0f, dir );
}
else
{
VectorScale( dir, points, dir );
}
}
ent->splashRadius = radius;// * ( 1.0 - dist / radius );
}
G_Damage (ent, NULL, attacker, dir, origin, (int)points, DAMAGE_RADIUS, mod);
}
}
}
Reference in a new issue View git blame Copy permalink