codemp/game/g_combat.c

Go to the documentation of this file.

// Copyright (C) 1999-2000 Id Software, Inc.
//
// g_combat.c

//#include "g_local.h"
#include "b_local.h"
#include "bg_saga.h"

extern int G_ShipSurfaceForSurfName( const char *surfaceName );
extern qboolean G_FlyVehicleDestroySurface( gentity_t *veh, int surface );
extern void G_VehicleSetDamageLocFlags( gentity_t *veh, int impactDir, int deathPoint );
extern void G_VehUpdateShields( gentity_t *targ );
extern void G_LetGoOfWall( gentity_t *ent );
extern void BG_ClearRocketLock( playerState_t *ps );
//rww - pd
void BotDamageNotification(gclient_t *bot, gentity_t *attacker);
//end rww

void ThrowSaberToAttacker(gentity_t *self, gentity_t *attacker);

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 );
}

qboolean G_HeavyMelee( gentity_t *attacker )
{
        if (g_gametype.integer == GT_SIEGE 
                && attacker 
                && attacker->client
                && attacker->client->siegeClass != -1 
                && (bgSiegeClasses[attacker->client->siegeClass].classflags & (1<<CFL_HEAVYMELEE)) )
        {
                return qtrue;
        }
        return qfalse;
}

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->r.currentAngles[YAW], 0);
        }

        AngleVectors(tangles, forward, right, up);

        // Get center of target.
        VectorAdd(target->r.absmin, target->r.absmax, tcenter);
        VectorScale(tcenter, 0.5, tcenter);

        // Get radius width of target.
        tradius = (fabs(target->r.maxs[0]) + fabs(target->r.maxs[1]) + fabs(target->r.mins[0]) + fabs(target->r.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 if(fdot < 0)
                        {
                                return HL_BACK;
                        }
                }
                else
                {
                        if(rdot > 0.3)
                        {
                                return HL_CHEST_RT;
                        }
                        else if(rdot < -0.3)
                        {
                                return HL_CHEST_LT;
                        }
                        else if(fdot < 0)
                        {
                                return HL_CHEST;
                        }
                }
        }
        return HL_NONE;
}

/*
int G_PickPainAnim( gentity_t *self, vec3_t point, int damage )
{
        switch( G_GetHitLocation( self, point ) )
        {
        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;
        }
}
*/

void ExplodeDeath( gentity_t *self ) 
{
//      gentity_t       *tent;
        vec3_t          forward;

        self->takedamage = qfalse;//stop chain reaction runaway loops

        self->s.loopSound = 0;
        self->s.loopIsSoundset = qfalse;

        VectorCopy( self->r.currentOrigin, self->s.pos.trBase );

//      tent = G_TempEntity( self->s.origin, EV_FX_EXPLOSION );
        AngleVectors(self->s.angles, forward, NULL, NULL);

/*      
        if ( self->fxID > 0 )
        {
                G_PlayEffect( self->fxID, self->r.currentOrigin, forward );
        }
        else
        */

        {
//              CG_SurfaceExplosion( self->r.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->parent )
                {
                        attacker = self->parent;
                }
                G_RadiusDamage( self->r.currentOrigin, attacker, self->splashDamage, self->splashRadius, 
                                attacker, NULL, MOD_UNKNOWN );
        }

        ObjectDie( self, self, self, 20, 0 );
}


/*
============
ScorePlum
============
*/
void ScorePlum( gentity_t *ent, vec3_t origin, int score ) {
        gentity_t *plum;

        plum = G_TempEntity( origin, EV_SCOREPLUM );
        // only send this temp entity to a single client
        plum->r.svFlags |= SVF_SINGLECLIENT;
        plum->r.singleClient = ent->s.number;
        //
        plum->s.otherEntityNum = ent->s.number;
        plum->s.time = score;
}

/*
============
AddScore

Adds score to both the client and his team
============
*/
extern qboolean g_dontPenalizeTeam; //g_cmds.c
void AddScore( gentity_t *ent, vec3_t origin, int score )
{
        /*
        if (g_gametype.integer == GT_SIEGE)
        { //no scoring in this gametype at all.
                return;
        }
        */

        if ( !ent->client ) {
                return;
        }
        // no scoring during pre-match warmup
        if ( level.warmupTime ) {
                return;
        }
        // show score plum
        //ScorePlum(ent, origin, score);
        //
        ent->client->ps.persistant[PERS_SCORE] += score;
        if ( g_gametype.integer == GT_TEAM && !g_dontPenalizeTeam )
                level.teamScores[ ent->client->ps.persistant[PERS_TEAM] ] += score;
        CalculateRanks();
}

/*
=================
TossClientItems

rww - Toss the weapon away from the player in the specified direction
=================
*/
void TossClientWeapon(gentity_t *self, vec3_t direction, float speed)
{
        vec3_t vel;
        gitem_t *item;
        gentity_t *launched;
        int weapon = self->s.weapon;
        int ammoSub;

        if (g_gametype.integer == GT_SIEGE)
        { //no dropping weaps
                return;
        }

        if (weapon <= WP_BRYAR_PISTOL)
        { //can't have this
                return;
        }

        if (weapon == WP_EMPLACED_GUN ||
                weapon == WP_TURRET)
        {
                return;
        }

        // find the item type for this weapon
        item = BG_FindItemForWeapon( weapon );

        ammoSub = (self->client->ps.ammo[weaponData[weapon].ammoIndex] - bg_itemlist[BG_GetItemIndexByTag(weapon, IT_WEAPON)].quantity);

        if (ammoSub < 0)
        {
                int ammoQuan = item->quantity;
                ammoQuan -= (-ammoSub);

                if (ammoQuan <= 0)
                { //no ammo
                        return;
                }
        }

        vel[0] = direction[0]*speed;
        vel[1] = direction[1]*speed;
        vel[2] = direction[2]*speed;

        launched = LaunchItem(item, self->client->ps.origin, vel);

        launched->s.generic1 = self->s.number;
        launched->s.powerups = level.time + 1500;

        launched->count = bg_itemlist[BG_GetItemIndexByTag(weapon, IT_WEAPON)].quantity;

        self->client->ps.ammo[weaponData[weapon].ammoIndex] -= bg_itemlist[BG_GetItemIndexByTag(weapon, IT_WEAPON)].quantity;

        if (self->client->ps.ammo[weaponData[weapon].ammoIndex] < 0)
        {
                launched->count -= (-self->client->ps.ammo[weaponData[weapon].ammoIndex]);
                self->client->ps.ammo[weaponData[weapon].ammoIndex] = 0;
        }

        if ((self->client->ps.ammo[weaponData[weapon].ammoIndex] < 1 && weapon != WP_DET_PACK) ||
                (weapon != WP_THERMAL && weapon != WP_DET_PACK && weapon != WP_TRIP_MINE))
        {
                int i = 0;
                int weap = -1;

                self->client->ps.stats[STAT_WEAPONS] &= ~(1 << weapon);

                while (i < WP_NUM_WEAPONS)
                {
                        if ((self->client->ps.stats[STAT_WEAPONS] & (1 << i)) && i != WP_NONE)
                        { //this one's good
                                weap = i;
                                break;
                        }
                        i++;
                }

                if (weap != -1)
                {
                        self->s.weapon = weap;
                        self->client->ps.weapon = weap;
                }
                else
                {
                        self->s.weapon = 0;
                        self->client->ps.weapon = 0;
                }

                G_AddEvent(self, EV_NOAMMO, weapon);
        }
}

/*
=================
TossClientItems

Toss the weapon and powerups for the killed player
=================
*/
void TossClientItems( gentity_t *self ) {
        gitem_t         *item;
        int                     weapon;
        float           angle;
        int                     i;
        gentity_t       *drop;

        if (g_gametype.integer == GT_SIEGE)
        { //just don't drop anything then
                return;
        }

        // drop the weapon if not a gauntlet or machinegun
        weapon = self->s.weapon;

        // make a special check to see if they are changing to a new
        // weapon that isn't the mg or gauntlet.  Without this, a client
        // can pick up a weapon, be killed, and not drop the weapon because
        // their weapon change hasn't completed yet and they are still holding the MG.
        if ( weapon == WP_BRYAR_PISTOL) {
                if ( self->client->ps.weaponstate == WEAPON_DROPPING ) {
                        weapon = self->client->pers.cmd.weapon;
                }
                if ( !( self->client->ps.stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) {
                        weapon = WP_NONE;
                }
        }

        self->s.bolt2 = weapon;

        if ( weapon > WP_BRYAR_PISTOL && 
                weapon != WP_EMPLACED_GUN &&
                weapon != WP_TURRET &&
                self->client->ps.ammo[ weaponData[weapon].ammoIndex ] ) {
                gentity_t *te;

                // find the item type for this weapon
                item = BG_FindItemForWeapon( weapon );

                // tell all clients to remove the weapon model on this guy until he respawns
                te = G_TempEntity( vec3_origin, EV_DESTROY_WEAPON_MODEL );
                te->r.svFlags |= SVF_BROADCAST;
                te->s.eventParm = self->s.number;

                // spawn the item
                Drop_Item( self, item, 0 );
        }

        // drop all the powerups if not in teamplay
        if ( g_gametype.integer != GT_TEAM && g_gametype.integer != GT_SIEGE ) {
                angle = 45;
                for ( i = 1 ; i < PW_NUM_POWERUPS ; i++ ) {
                        if ( self->client->ps.powerups[ i ] > level.time ) {
                                item = BG_FindItemForPowerup( i );
                                if ( !item ) {
                                        continue;
                                }
                                drop = Drop_Item( self, item, angle );
                                // decide how many seconds it has left
                                drop->count = ( self->client->ps.powerups[ i ] - level.time ) / 1000;
                                if ( drop->count < 1 ) {
                                        drop->count = 1;
                                }
                                angle += 45;
                        }
                }
        }
}


/*
==================
LookAtKiller
==================
*/
void LookAtKiller( gentity_t *self, gentity_t *inflictor, gentity_t *attacker ) {
        vec3_t          dir;
        vec3_t          angles;

        if ( attacker && attacker != self ) {
                VectorSubtract (attacker->s.pos.trBase, self->s.pos.trBase, dir);
        } else if ( inflictor && inflictor != self ) {
                VectorSubtract (inflictor->s.pos.trBase, self->s.pos.trBase, dir);
        } else {
                self->client->ps.stats[STAT_DEAD_YAW] = self->s.angles[YAW];
                return;
        }

        self->client->ps.stats[STAT_DEAD_YAW] = vectoyaw ( dir );

        angles[YAW] = vectoyaw ( dir );
        angles[PITCH] = 0; 
        angles[ROLL] = 0;
}

/*
==================
GibEntity
==================
*/
void GibEntity( gentity_t *self, int killer ) {
        G_AddEvent( self, EV_GIB_PLAYER, killer );
        self->takedamage = qfalse;
        self->s.eType = ET_INVISIBLE;
        self->r.contents = 0;
}

void BodyRid(gentity_t *ent)
{
        trap_UnlinkEntity( ent );
        ent->physicsObject = qfalse;
}

/*
==================
body_die
==================
*/
void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
        // NOTENOTE No gibbing right now, this is star wars.
        qboolean doDisint = qfalse;

        if (self->s.eType == ET_NPC)
        { //well, just rem it then, so long as it's done with its death anim and it's not a standard weapon.
                if ( self->client && self->client->ps.torsoTimer <= 0 &&
                         (meansOfDeath == MOD_UNKNOWN ||
                          meansOfDeath == MOD_WATER ||
                          meansOfDeath == MOD_SLIME ||
                          meansOfDeath == MOD_LAVA ||
                          meansOfDeath == MOD_CRUSH ||
                          meansOfDeath == MOD_TELEFRAG ||
                          meansOfDeath == MOD_FALLING ||
                          meansOfDeath == MOD_SUICIDE ||
                          meansOfDeath == MOD_TARGET_LASER ||
                          meansOfDeath == MOD_TRIGGER_HURT) )
                {
                        self->think = G_FreeEntity;
                        self->nextthink = level.time;
                }
                return;
        }

        if (self->health < (GIB_HEALTH+1))
        {
                self->health = GIB_HEALTH+1;

                if (self->client && (level.time - self->client->respawnTime) < 2000)
                {
                        doDisint = qfalse;
                }
                else
                {
                        doDisint = qtrue;
                }
        }

        if (self->client && (self->client->ps.eFlags & EF_DISINTEGRATION))
        {
                return;
        }
        else if (self->s.eFlags & EF_DISINTEGRATION)
        {
                return;
        }

        if (doDisint)
        {
                if (self->client)
                {
                        self->client->ps.eFlags |= EF_DISINTEGRATION;
                        VectorCopy(self->client->ps.origin, self->client->ps.lastHitLoc);
                }
                else
                {
                        self->s.eFlags |= EF_DISINTEGRATION;
                        VectorCopy(self->r.currentOrigin, self->s.origin2);

                        //since it's the corpse entity, tell it to "remove" itself
                        self->think = BodyRid;
                        self->nextthink = level.time + 1000;
                }
                return;
        }
}


// these are just for logging, the client prints its own messages
char    *modNames[MOD_MAX] = {
        "MOD_UNKNOWN",
        "MOD_STUN_BATON",
        "MOD_MELEE",
        "MOD_SABER",
        "MOD_BRYAR_PISTOL",
        "MOD_BRYAR_PISTOL_ALT",
        "MOD_BLASTER",
        "MOD_TURBLAST",
        "MOD_DISRUPTOR",
        "MOD_DISRUPTOR_SPLASH",
        "MOD_DISRUPTOR_SNIPER",
        "MOD_BOWCASTER",
        "MOD_REPEATER",
        "MOD_REPEATER_ALT",
        "MOD_REPEATER_ALT_SPLASH",
        "MOD_DEMP2",
        "MOD_DEMP2_ALT",
        "MOD_FLECHETTE",
        "MOD_FLECHETTE_ALT_SPLASH",
        "MOD_ROCKET",
        "MOD_ROCKET_SPLASH",
        "MOD_ROCKET_HOMING",
        "MOD_ROCKET_HOMING_SPLASH",
        "MOD_THERMAL",
        "MOD_THERMAL_SPLASH",
        "MOD_TRIP_MINE_SPLASH",
        "MOD_TIMED_MINE_SPLASH",
        "MOD_DET_PACK_SPLASH",
        "MOD_VEHICLE",
        "MOD_CONC",
        "MOD_CONC_ALT",
        "MOD_FORCE_DARK",
        "MOD_SENTRY",
        "MOD_WATER",
        "MOD_SLIME",
        "MOD_LAVA",
        "MOD_CRUSH",
        "MOD_TELEFRAG",
        "MOD_FALLING",
        "MOD_SUICIDE",
        "MOD_TARGET_LASER",
        "MOD_TRIGGER_HURT"
};


/*
==================
CheckAlmostCapture
==================
*/
void CheckAlmostCapture( gentity_t *self, gentity_t *attacker ) {
#if 0
        gentity_t       *ent;
        vec3_t          dir;
        char            *classname;

        // if this player was carrying a flag
        if ( self->client->ps.powerups[PW_REDFLAG] ||
                self->client->ps.powerups[PW_BLUEFLAG] ||
                self->client->ps.powerups[PW_NEUTRALFLAG] ) {
                // get the goal flag this player should have been going for
                if ( g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY ) {
                        if ( self->client->sess.sessionTeam == TEAM_BLUE ) {
                                classname = "team_CTF_blueflag";
                        }
                        else {
                                classname = "team_CTF_redflag";
                        }
                }
                else {
                        if ( self->client->sess.sessionTeam == TEAM_BLUE ) {
                                classname = "team_CTF_redflag";
                        }
                        else {
                                classname = "team_CTF_blueflag";
                        }
                }
                ent = NULL;
                do
                {
                        ent = G_Find(ent, FOFS(classname), classname);
                } while (ent && (ent->flags & FL_DROPPED_ITEM));
                // if we found the destination flag and it's not picked up
                if (ent && !(ent->r.svFlags & SVF_NOCLIENT) ) {
                        // if the player was *very* close
                        VectorSubtract( self->client->ps.origin, ent->s.origin, dir );
                        if ( VectorLength(dir) < 200 ) {
                                self->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_HOLYSHIT;
                                if ( attacker->client ) {
                                        attacker->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_HOLYSHIT;
                                }
                        }
                }
        }
#endif
}

qboolean G_InKnockDown( playerState_t *ps )
{
        switch ( (ps->legsAnim) )
        {
        case BOTH_KNOCKDOWN1:
        case BOTH_KNOCKDOWN2:
        case BOTH_KNOCKDOWN3:
        case BOTH_KNOCKDOWN4:
        case BOTH_KNOCKDOWN5:
                return qtrue;
                break;
        case BOTH_GETUP1:
        case BOTH_GETUP2:
        case BOTH_GETUP3:
        case BOTH_GETUP4:
        case BOTH_GETUP5:
        case BOTH_FORCE_GETUP_F1:
        case BOTH_FORCE_GETUP_F2:
        case BOTH_FORCE_GETUP_B1:
        case BOTH_FORCE_GETUP_B2:
        case BOTH_FORCE_GETUP_B3:
        case BOTH_FORCE_GETUP_B4:
        case BOTH_FORCE_GETUP_B5:
                return qtrue;
                break;
        }
        return qfalse;
}

static int G_CheckSpecialDeathAnim( gentity_t *self, vec3_t point, int damage, int mod, int hitLoc )
{
        int deathAnim = -1;

        if ( BG_InRoll( &self->client->ps, self->client->ps.legsAnim ) )
        {
                deathAnim = BOTH_DEATH_ROLL;            //# Death anim from a roll
        }
        else if ( BG_FlippingAnim( self->client->ps.legsAnim ) )
        {
                deathAnim = BOTH_DEATH_FLIP;            //# Death anim from a flip
        }
        else if ( G_InKnockDown( &self->client->ps ) )
        {//since these happen a lot, let's handle them case by case
                int animLength = bgAllAnims[self->localAnimIndex].anims[self->client->ps.legsAnim].numFrames * fabs((float)(bgHumanoidAnimations[self->client->ps.legsAnim].frameLerp));
                switch ( self->client->ps.legsAnim )
                {
                case BOTH_KNOCKDOWN1:
                        if ( animLength - self->client->ps.legsTimer > 100 )
                        {//on our way down
                                if ( self->client->ps.legsTimer > 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.legsTimer > 700 )
                        {//on our way down
                                if ( self->client->ps.legsTimer > 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.legsTimer > 100 )
                        {//on our way down
                                if ( self->client->ps.legsTimer > 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.legsTimer > 300 )
                        {//on our way down
                                if ( self->client->ps.legsTimer > 350 )
                                {//still partially up
                                        deathAnim = BOTH_DEATH_FALLING_UP;
                                }
                                else
                                {//down
                                        deathAnim = BOTH_DEATH_LYING_UP;
                                }
                        }
                        else
                        {//crouch death
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer < 750 )
                        {//flat
                                deathAnim = BOTH_DEATH_LYING_DN;
                        }
                        break;
                case BOTH_GETUP1:
                        if ( self->client->ps.legsTimer < 350 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 800 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 450 )
                                {//partially up
                                        deathAnim = BOTH_DEATH_FALLING_UP;
                                }
                                else
                                {//down
                                        deathAnim = BOTH_DEATH_LYING_UP;
                                }
                        }
                        break;
                case BOTH_GETUP2:
                        if ( self->client->ps.legsTimer < 150 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 850 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 500 )
                                {//partially up
                                        deathAnim = BOTH_DEATH_FALLING_UP;
                                }
                                else
                                {//down
                                        deathAnim = BOTH_DEATH_LYING_UP;
                                }
                        }
                        break;
                case BOTH_GETUP3:
                        if ( self->client->ps.legsTimer < 250 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 600 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;
                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 150 )
                                {//partially up
                                        deathAnim = BOTH_DEATH_FALLING_DN;
                                }
                                else
                                {//down
                                        deathAnim = BOTH_DEATH_LYING_DN;
                                }
                        }
                        break;
                case BOTH_GETUP4:
                        if ( self->client->ps.legsTimer < 250 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 600 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 850 )
                                {//partially up
                                        deathAnim = BOTH_DEATH_FALLING_DN;
                                }
                                else
                                {//down
                                        deathAnim = BOTH_DEATH_LYING_UP;
                                }
                        }
                        break;
                case BOTH_GETUP5:
                        if ( self->client->ps.legsTimer > 850 )
                        {//lying down
                                if ( animLength - self->client->ps.legsTimer > 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.legsTimer < 800 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 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.legsTimer < 800 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 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.legsTimer < 325 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 725 )
                        {//spinning up
                                deathAnim = BOTH_DEATH_SPIN_180;        //# Death anim when facing backwards
                        }
                        else if ( self->client->ps.legsTimer < 900 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer > 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.legsTimer < 575 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 875 )
                        {//spinning up
                                deathAnim = BOTH_DEATH_SPIN_180;        //# Death anim when facing backwards
                        }
                        else if ( self->client->ps.legsTimer < 900 )
                        {//crouching
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer < 150 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 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.legsTimer < 325 )
                        {//standing up
                        }
                        else
                        {//lying down
                                if ( animLength - self->client->ps.legsTimer > 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.legsTimer < 550 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 1025 )
                        {//kicking up
                                deathAnim = BOTH_DEATHBACKWARD2; //backflip
                        }
                        else
                        {//lying down
                                if ( animLength - self->client->ps.legsTimer > 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.legsTimer < 225 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 425 )
                        {//crouching up
                                vec3_t fwd;
                                float thrown = 0;

                                AngleVectors( self->client->ps.viewangles, fwd, NULL, NULL );
                                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.legsTimer < 825 )
                        {//flipping up
                                deathAnim = BOTH_DEATHFORWARD3; //backflip
                        }
                        else
                        {//lying down
                                if ( animLength - self->client->ps.legsTimer > 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.legsTimer < 275 )
                        {//standing up
                        }
                        else if ( self->client->ps.legsTimer < 750 )
                        {//flipping
                                deathAnim = BOTH_DEATH14;
                        }
                        else
                        {//lying down