g_combat.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
// g_combat.c

#include "g_local.h"


/*
============
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
============
*/
void AddScore( gentity_t *ent, vec3_t origin, int score ) {
    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 )
        level.teamScores[ ent->client->ps.persistant[PERS_TEAM] ] += score;
    CalculateRanks();
}

/*
=================
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;

    // 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_MACHINEGUN || weapon == WP_GRAPPLING_HOOK ) {
        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;
        }
    }

    if ( weapon > WP_MACHINEGUN && weapon != WP_GRAPPLING_HOOK && 
        self->client->ps.ammo[ weapon ] ) {
        // find the item type for this weapon
        item = BG_FindItemForWeapon( weapon );

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

    // drop all the powerups if not in teamplay
    if ( g_gametype.integer != GT_TEAM ) {
        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;
            }
        }
    }
}

#ifdef MISSIONPACK

/*
=================
TossClientCubes
=================
*/
extern gentity_t    *neutralObelisk;

void TossClientCubes( gentity_t *self ) {
    gitem_t     *item;
    gentity_t   *drop;
    vec3_t      velocity;
    vec3_t      angles;
    vec3_t      origin;

    self->client->ps.generic1 = 0;

    // this should never happen but we should never
    // get the server to crash due to skull being spawned in
    if (!G_EntitiesFree()) {
        return;
    }

    if( self->client->sess.sessionTeam == TEAM_RED ) {
        item = BG_FindItem( "Red Cube" );
    }
    else {
        item = BG_FindItem( "Blue Cube" );
    }

    angles[YAW] = (float)(level.time % 360);
    angles[PITCH] = 0;  // always forward
    angles[ROLL] = 0;

    AngleVectors( angles, velocity, NULL, NULL );
    VectorScale( velocity, 150, velocity );
    velocity[2] += 200 + crandom() * 50;

    if( neutralObelisk ) {
        VectorCopy( neutralObelisk->s.pos.trBase, origin );
        origin[2] += 44;
    } else {
        VectorClear( origin ) ;
    }

    drop = LaunchItem( item, origin, velocity );

    drop->nextthink = level.time + g_cubeTimeout.integer * 1000;
    drop->think = G_FreeEntity;
    drop->spawnflags = self->client->sess.sessionTeam;
}


/*
=================
TossClientPersistantPowerups
=================
*/
void TossClientPersistantPowerups( gentity_t *ent ) {
    gentity_t   *powerup;

    if( !ent->client ) {
        return;
    }

    if( !ent->client->persistantPowerup ) {
        return;
    }

    powerup = ent->client->persistantPowerup;

    powerup->r.svFlags &= ~SVF_NOCLIENT;
    powerup->s.eFlags &= ~EF_NODRAW;
    powerup->r.contents = CONTENTS_TRIGGER;
    trap_LinkEntity( powerup );

    ent->client->ps.stats[STAT_PERSISTANT_POWERUP] = 0;
    ent->client->persistantPowerup = NULL;
}
#endif


/*
==================
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 ) {
    gentity_t *ent;
    int i;

    //if this entity still has kamikaze
    if (self->s.eFlags & EF_KAMIKAZE) {
        // check if there is a kamikaze timer around for this owner
        for (i = 0; i < MAX_GENTITIES; i++) {
            ent = &g_entities[i];
            if (!ent->inuse)
                continue;
            if (ent->activator != self)
                continue;
            if (strcmp(ent->classname, "kamikaze timer"))
                continue;
            G_FreeEntity(ent);
            break;
        }
    }
    G_AddEvent( self, EV_GIB_PLAYER, killer );
    self->takedamage = qfalse;
    self->s.eType = ET_INVISIBLE;
    self->r.contents = 0;
}

/*
==================
body_die
==================
*/
void body_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
    if ( self->health > GIB_HEALTH ) {
        return;
    }
    if ( !g_blood.integer ) {
        self->health = GIB_HEALTH+1;
        return;
    }

    GibEntity( self, 0 );
}


// these are just for logging, the client prints its own messages
char    *modNames[] = {
    "MOD_UNKNOWN",
    "MOD_SHOTGUN",
    "MOD_GAUNTLET",
    "MOD_MACHINEGUN",
    "MOD_GRENADE",
    "MOD_GRENADE_SPLASH",
    "MOD_ROCKET",
    "MOD_ROCKET_SPLASH",
    "MOD_PLASMA",
    "MOD_PLASMA_SPLASH",
    "MOD_RAILGUN",
    "MOD_LIGHTNING",
    "MOD_BFG",
    "MOD_BFG_SPLASH",
    "MOD_WATER",
    "MOD_SLIME",
    "MOD_LAVA",
    "MOD_CRUSH",
    "MOD_TELEFRAG",
    "MOD_FALLING",
    "MOD_SUICIDE",
    "MOD_TARGET_LASER",
    "MOD_TRIGGER_HURT",
#ifdef MISSIONPACK
    "MOD_NAIL",
    "MOD_CHAINGUN",
    "MOD_PROXIMITY_MINE",
    "MOD_KAMIKAZE",
    "MOD_JUICED",
#endif
    "MOD_GRAPPLE"
};

#ifdef MISSIONPACK
/*
==================
Kamikaze_DeathActivate
==================
*/
void Kamikaze_DeathActivate( gentity_t *ent ) {
    G_StartKamikaze(ent);
    G_FreeEntity(ent);
}

/*
==================
Kamikaze_DeathTimer
==================
*/
void Kamikaze_DeathTimer( gentity_t *self ) {
    gentity_t *ent;

    ent = G_Spawn();
    ent->classname = "kamikaze timer";
    VectorCopy(self->s.pos.trBase, ent->s.pos.trBase);
    ent->r.svFlags |= SVF_NOCLIENT;
    ent->think = Kamikaze_DeathActivate;
    ent->nextthink = level.time + 5 * 1000;

    ent->activator = self;
}

#endif

/*
==================
CheckAlmostCapture
==================
*/
void CheckAlmostCapture( gentity_t *self, gentity_t *attacker ) {
    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 ) {
            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;
                }
            }
        }
    }
}

/*
==================
CheckAlmostScored
==================
*/
void CheckAlmostScored( gentity_t *self, gentity_t *attacker ) {
    gentity_t   *ent;
    vec3_t      dir;
    char        *classname;

    // if the player was carrying cubes
    if ( self->client->ps.generic1 ) {
        if ( self->client->sess.sessionTeam == TEAM_BLUE ) {
            classname = "team_redobelisk";
        }
        else {
            classname = "team_blueobelisk";
        }
        ent = G_Find(NULL, FOFS(classname), classname);
        // if we found the destination obelisk
        if ( ent ) {
            // 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;
                }
            }
        }
    }
}

/*
==================
player_die
==================
*/
void player_die( gentity_t *self, gentity_t *inflictor, gentity_t *attacker, int damage, int meansOfDeath ) {
    gentity_t   *ent;
    int         anim;
    int         contents;
    int         killer;
    int         i;
    char        *killerName, *obit;

    if ( self->client->ps.pm_type == PM_DEAD ) {
        return;
    }

    if ( level.intermissiontime ) {
        return;
    }

    // check for an almost capture
    CheckAlmostCapture( self, attacker );
    // check for a player that almost brought in cubes
    CheckAlmostScored( self, attacker );

    if (self->client && self->client->hook) {
        Weapon_HookFree(self->client->hook);
    }
#ifdef MISSIONPACK
    if ((self->client->ps.eFlags & EF_TICKING) && self->activator) {
        self->client->ps.eFlags &= ~EF_TICKING;
        self->activator->think = G_FreeEntity;
        self->activator->nextthink = level.time;
    }
#endif
    self->client->ps.pm_type = PM_DEAD;

    if ( attacker ) {
        killer = attacker->s.number;
        if ( attacker->client ) {
            killerName = attacker->client->pers.netname;
        } else {
            killerName = "<non-client>";
        }
    } else {
        killer = ENTITYNUM_WORLD;
        killerName = "<world>";
    }

    if ( killer < 0 || killer >= MAX_CLIENTS ) {
        killer = ENTITYNUM_WORLD;
        killerName = "<world>";
    }

    if ( meansOfDeath < 0 || meansOfDeath >= sizeof( modNames ) / sizeof( modNames[0] ) ) {
        obit = "<bad obituary>";
    } else {
        obit = modNames[ meansOfDeath ];
    }

    G_LogPrintf("Kill: %i %i %i: %s killed %s by %s\n", 
        killer, self->s.number, meansOfDeath, killerName, 
        self->client->pers.netname, obit );

    // broadcast the death event to everyone
    ent = G_TempEntity( self->r.currentOrigin, EV_OBITUARY );
    ent->s.eventParm = meansOfDeath;
    ent->s.otherEntityNum = self->s.number;
    ent->s.otherEntityNum2 = killer;
    ent->r.svFlags = SVF_BROADCAST; // send to everyone

    self->enemy = attacker;

    self->client->ps.persistant[PERS_KILLED]++;

    if (attacker && attacker->client) {
        attacker->client->lastkilled_client = self->s.number;

        if ( attacker == self || OnSameTeam (self, attacker ) ) {
            AddScore( attacker, self->r.currentOrigin, -1 );
        } else {
            AddScore( attacker, self->r.currentOrigin, 1 );

            if( meansOfDeath == MOD_GAUNTLET ) {
                
                // play humiliation on player
                attacker->client->ps.persistant[PERS_GAUNTLET_FRAG_COUNT]++;

                // add the sprite over the player's head
                attacker->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
                attacker->client->ps.eFlags |= EF_AWARD_GAUNTLET;
                attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;

                // also play humiliation on target
                self->client->ps.persistant[PERS_PLAYEREVENTS] ^= PLAYEREVENT_GAUNTLETREWARD;
            }

            // check for two kills in a short amount of time
            // if this is close enough to the last kill, give a reward sound
            if ( level.time - attacker->client->lastKillTime < CARNAGE_REWARD_TIME ) {
                // play excellent on player
                attacker->client->ps.persistant[PERS_EXCELLENT_COUNT]++;

                // add the sprite over the player's head
                attacker->client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
                attacker->client->ps.eFlags |= EF_AWARD_EXCELLENT;
                attacker->client->rewardTime = level.time + REWARD_SPRITE_TIME;
            }
            attacker->client->lastKillTime = level.time;

        }
    } else {
        AddScore( self, self->r.currentOrigin, -1 );
    }

    // Add team bonuses
    Team_FragBonuses(self, inflictor, attacker);

    // if I committed suicide, the flag does not fall, it returns.
    if (meansOfDeath == MOD_SUICIDE) {
        if ( self->client->ps.powerups[PW_NEUTRALFLAG] ) {      // only happens in One Flag CTF
            Team_ReturnFlag( TEAM_FREE );
            self->client->ps.powerups[PW_NEUTRALFLAG] = 0;
        }
        else if ( self->client->ps.powerups[PW_REDFLAG] ) {     // only happens in standard CTF
            Team_ReturnFlag( TEAM_RED );
            self->client->ps.powerups[PW_REDFLAG] = 0;
        }
        else if ( self->client->ps.powerups[PW_BLUEFLAG] ) {    // only happens in standard CTF
            Team_ReturnFlag( TEAM_BLUE );
            self->client->ps.powerups[PW_BLUEFLAG] = 0;
        }
    }

    // if client is in a nodrop area, don't drop anything (but return CTF flags!)
    contents = trap_PointContents( self->r.currentOrigin, -1 );
    if ( !( contents & CONTENTS_NODROP )) {
        TossClientItems( self );
    }
    else {
        if ( self->client->ps.powerups[PW_NEUTRALFLAG] ) {      // only happens in One Flag CTF
            Team_ReturnFlag( TEAM_FREE );
        }
        else if ( self->client->ps.powerups[PW_REDFLAG] ) {     // only happens in standard CTF
            Team_ReturnFlag( TEAM_RED );
        }
        else if ( self->client->ps.powerups[PW_BLUEFLAG] ) {    // only happens in standard CTF
            Team_ReturnFlag( TEAM_BLUE );
        }
    }
#ifdef MISSIONPACK
    TossClientPersistantPowerups( self );
    if( g_gametype.integer == GT_HARVESTER ) {
        TossClientCubes( self );
    }
#endif

    Cmd_Score_f( self );        // show scores
    // send updated scores to any clients that are following this one,
    // or they would get stale scoreboards
    for ( i = 0 ; i < level.maxclients ; i++ ) {
        gclient_t   *client;

        client = &level.clients[i];
        if ( client->pers.connected != CON_CONNECTED ) {
            continue;
        }
        if ( client->sess.sessionTeam != TEAM_SPECTATOR ) {
            continue;
        }
        if ( client->sess.spectatorClient == self->s.number ) {
            Cmd_Score_f( g_entities + i );
        }
    }

    self->takedamage = qtrue;   // can still be gibbed

    self->s.weapon = WP_NONE;
    self->s.powerups = 0;
    self->r.contents = CONTENTS_CORPSE;

    self->s.angles[0] = 0;
    self->s.angles[2] = 0;
    LookAtKiller (self, inflictor, attacker);

    VectorCopy( self->s.angles, self->client->ps.viewangles );

    self->s.loopSound = 0;

    self->r.maxs[2] = -8;

    // don't allow respawn until the death anim is done
    // g_forcerespawn may force spawning at some later time
    self->client->respawnTime = level.time + 1700;

    // remove powerups
    memset( self->client->ps.powerups, 0, sizeof(self->client->ps.powerups) );

    // never gib in a nodrop
    if ( (self->health <= GIB_HEALTH && !(contents & CONTENTS_NODROP) && g_blood.integer) || meansOfDeath == MOD_SUICIDE) {
        // gib death
        GibEntity( self, killer );
    } else {
        // normal death
        static int i;

        switch ( i ) {
        case 0:
            anim = BOTH_DEATH1;
            break;
        case 1:
            anim = BOTH_DEATH2;
            break;
        case 2:
        default:
            anim = BOTH_DEATH3;
            break;
        }

        // for the no-blood option, we need to prevent the health
        // from going to gib level
        if ( self->health <= GIB_HEALTH ) {
            self->health = GIB_HEALTH+1;
        }

        self->client->ps.legsAnim = 
            ( ( self->client->ps.legsAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;
        self->client->ps.torsoAnim = 
            ( ( self->client->ps.torsoAnim & ANIM_TOGGLEBIT ) ^ ANIM_TOGGLEBIT ) | anim;

        G_AddEvent( self, EV_DEATH1 + i, killer );

        // the body can still be gibbed
        self->die = body_die;

        // globally cycle through the different death animations
        i = ( i + 1 ) % 3;

#ifdef MISSIONPACK
        if (self->s.eFlags & EF_KAMIKAZE) {
            Kamikaze_DeathTimer( self );
        }
#endif
    }

    trap_LinkEntity (self);

}


/*
================
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;

    // armor
    count = client->ps.stats[STAT_ARMOR];
    save = ceil( damage * ARMOR_PROTECTION );
    if (save >= count)
        save = count;

    if (!save)
        return 0;

    client->ps.stats[STAT_ARMOR] -= save;

    return save;
}

/*
================
RaySphereIntersections
================
*/
int RaySphereIntersections( vec3_t origin, float radius, vec3_t point, vec3_t dir, vec3_t intersections[2] ) {
    float b, c, d, t;

    //  | origin - (point + t * dir) | = radius
    //  a = dir[0]^2 + dir[1]^2 + dir[2]^2;
    //  b = 2 * (dir[0] * (point[0] - origin[0]) + dir[1] * (point[1] - origin[1]) + dir[2] * (point[2] - origin[2]));
    //  c = (point[0] - origin[0])^2 + (point[1] - origin[1])^2 + (point[2] - origin[2])^2 - radius^2;

    // normalize dir so a = 1
    VectorNormalize(dir);
    b = 2 * (dir[0] * (point[0] - origin[0]) + dir[1] * (point[1] - origin[1]) + dir[2] * (point[2] - origin[2]));
    c = (point[0] - origin[0]) * (point[0] - origin[0]) +
        (point[1] - origin[1]) * (point[1] - origin[1]) +
        (point[2] - origin[2]) * (point[2] - origin[2]) -
        radius * radius;

    d = b * b - 4 * c;
    if (d > 0) {
        t = (- b + sqrt(d)) / 2;
        VectorMA(point, t, dir, intersections[0]);
        t = (- b - sqrt(d)) / 2;
        VectorMA(point, t, dir, intersections[1]);
        return 2;
    }
    else if (d == 0) {
        t = (- b ) / 2;
        VectorMA(point, t, dir, intersections[0]);
        return 1;
    }
    return 0;
}

#ifdef MISSIONPACK
/*
================
G_InvulnerabilityEffect
================
*/
int G_InvulnerabilityEffect( gentity_t *targ, vec3_t dir, vec3_t point, vec3_t impactpoint, vec3_t bouncedir ) {
    gentity_t   *impact;
    vec3_t      intersections[2], vec;
    int         n;

    if ( !targ->client ) {
        return qfalse;
    }
    VectorCopy(dir, vec);
    VectorInverse(vec);
    // sphere model radius = 42 units
    n = RaySphereIntersections( targ->client->ps.origin, 42, point, vec, intersections);
    if (n > 0) {
        impact = G_TempEntity( targ->client->ps.origin, EV_INVUL_IMPACT );
        VectorSubtract(intersections[0], targ->client->ps.origin, vec);
        vectoangles(vec, impact->s.angles);
        impact->s.angles[0] += 90;
        if (impact->s.angles[0] > 360)
            impact->s.angles[0] -= 360;
        if ( impactpoint ) {
            VectorCopy( intersections[0], impactpoint );
        }
        if ( bouncedir ) {
            VectorCopy( vec, bouncedir );
            VectorNormalize( bouncedir );
        }
        return qtrue;
    }
    else {
        return qfalse;
    }
}
#endif
/*
============
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
============
*/

void G_Damage( gentity_t *targ, gentity_t *inflictor, gentity_t *attacker,
               vec3_t dir, vec3_t point, int damage, int dflags, int mod ) {
    gclient_t   *client;
    int         take;
    int         save;
    int         asave;
    int         knockback;
    int         max;
#ifdef MISSIONPACK
    vec3_t      bouncedir, impactpoint;
#endif

    if (!targ->takedamage) {
        return;
    }

    // the intermission has allready been qualified for, so don't
    // allow any extra scoring
    if ( level.intermissionQueued ) {
        return;
    }
#ifdef MISSIONPACK
    if ( targ->client && mod != MOD_JUICED) {
        if ( targ->client->invulnerabilityTime > level.time) {
            if ( dir && point ) {
                G_InvulnerabilityEffect( targ, dir, point, impactpoint, bouncedir );
            }
            return;
        }
    }
#endif
    if ( !inflictor ) {
        inflictor = &g_entities[ENTITYNUM_WORLD];
    }
    if ( !attacker ) {
        attacker = &g_entities[ENTITYNUM_WORLD];
    }

    // shootable doors / buttons don't actually have any health
    if ( targ->s.eType == ET_MOVER ) {
        if ( targ->use && targ->moverState == MOVER_POS1 ) {
            targ->use( targ, inflictor, attacker );
        }
        return;
    }
#ifdef MISSIONPACK
    if( g_gametype.integer == GT_OBELISK && CheckObeliskAttack( targ, attacker ) ) {
        return;
    }
#endif
    // reduce damage by the attacker's handicap value
    // unless they are rocket jumping
    if ( attacker->client && attacker != targ ) {
        max = attacker->client->ps.stats[STAT_MAX_HEALTH];
#ifdef MISSIONPACK
        if( bg_itemlist[attacker->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
            max /= 2;
        }
#endif
        damage = damage * max / 100;
    }

    client = targ->client;

    if ( client ) {
        if ( client->noclip ) {
            return;
        }
    }

    if ( !dir ) {
        dflags |= DAMAGE_NO_KNOCKBACK;
    } else {
        VectorNormalize(dir);
    }

    knockback = damage;
    if ( knockback > 200 ) {
        knockback = 200;
    }
    if ( targ->flags & FL_NO_KNOCKBACK ) {
        knockback = 0;
    }
    if ( dflags & DAMAGE_NO_KNOCKBACK ) {
        knockback = 0;
    }

    // figure momentum add, even if the damage won't be taken
    if ( knockback && targ->client ) {
        vec3_t  kvel;
        float   mass;

        mass = 200;

        VectorScale (dir, g_knockback.value * (float)knockback / mass, kvel);
        VectorAdd (targ->client->ps.velocity, kvel, targ->client->ps.velocity);

        // set the timer so that the other client can't cancel
        // out the movement immediately
        if ( !targ->client->ps.pm_time ) {
            int     t;

            t = knockback * 2;
            if ( t < 50 ) {
                t = 50;
            }
            if ( t > 200 ) {
                t = 200;
            }
            targ->client->ps.pm_time = t;
            targ->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
        }
    }

    // check for completely getting out of the damage
    if ( !(dflags & DAMAGE_NO_PROTECTION) ) {

        // if TF_NO_FRIENDLY_FIRE is set, don't do damage to the target
        // if the attacker was on the same team
#ifdef MISSIONPACK
        if ( mod != MOD_JUICED && targ != attacker && !(dflags & DAMAGE_NO_TEAM_PROTECTION) && OnSameTeam (targ, attacker)  ) {
#else   
        if ( targ != attacker && OnSameTeam (targ, attacker)  ) {
#endif
            if ( !g_friendlyFire.integer ) {
                return;
            }
        }
#ifdef MISSIONPACK
        if (mod == MOD_PROXIMITY_MINE) {
            if (inflictor && inflictor->parent && OnSameTeam(targ, inflictor->parent)) {
                return;
            }
            if (targ == attacker) {
                return;
            }
        }
#endif

        // check for godmode
        if ( targ->flags & FL_GODMODE ) {
            return;
        }
    }

    // battlesuit protects from all radius damage (but takes knockback)
    // and protects 50% against all damage
    if ( client && client->ps.powerups[PW_BATTLESUIT] ) {
        G_AddEvent( targ, EV_POWERUP_BATTLESUIT, 0 );
        if ( ( dflags & DAMAGE_RADIUS ) || ( mod == MOD_FALLING ) ) {
            return;
        }
        damage *= 0.5;
    }

    // add to the attacker's hit counter (if the target isn't a general entity like a prox mine)
    if ( attacker->client && targ != attacker && targ->health > 0
            && targ->s.eType != ET_MISSILE
            && targ->s.eType != ET_GENERAL) {
        if ( OnSameTeam( targ, attacker ) ) {
            attacker->client->ps.persistant[PERS_HITS]--;
        } else {
            attacker->client->ps.persistant[PERS_HITS]++;
        }
        attacker->client->ps.persistant[PERS_ATTACKEE_ARMOR] = (targ->health<<8)|(client->ps.stats[STAT_ARMOR]);
    }

    // always give half damage if hurting self
    // calculated after knockback, so rocket jumping works
    if ( targ == attacker) {
        damage *= 0.5;
    }

    if ( damage < 1 ) {
        damage = 1;
    }
    take = damage;
    save = 0;

    // save some from armor
    asave = CheckArmor (targ, take, dflags);
    take -= asave;

    if ( g_debugDamage.integer ) {
        G_Printf( "%i: client:%i health:%i damage:%i armor:%i\n", level.time, targ->s.number,
            targ->health, take, asave );
    }

    // add to the damage inflicted on a player this frame
    // the total will be turned into screen blends and view angle kicks
    // at the end of the frame
    if ( client ) {
        if ( attacker ) {
            client->ps.persistant[PERS_ATTACKER] = attacker->s.number;
        } else {
            client->ps.persistant[PERS_ATTACKER] = ENTITYNUM_WORLD;
        }
        client->damage_armor += asave;
        client->damage_blood += take;
        client->damage_knockback += knockback;
        if ( dir ) {
            VectorCopy ( dir, client->damage_from );
            client->damage_fromWorld = qfalse;
        } else {
            VectorCopy ( targ->r.currentOrigin, client->damage_from );
            client->damage_fromWorld = qtrue;
        }
    }

    // See if it's the player hurting the emeny flag carrier
#ifdef MISSIONPACK
    if( g_gametype.integer == GT_CTF || g_gametype.integer == GT_1FCTF ) {
#else   
    if( g_gametype.integer == GT_CTF) {
#endif
        Team_CheckHurtCarrier(targ, attacker);
    }

    if (targ->client) {
        // set the last client who damaged the target
        targ->client->lasthurt_client = attacker->s.number;
        targ->client->lasthurt_mod = mod;
    }

    // do the damage
    if (take) {
        targ->health = targ->health - take;
        if ( targ->client ) {
            targ->client->ps.stats[STAT_HEALTH] = targ->health;
        }
            
        if ( targ->health <= 0 ) {
            if ( client )
                targ->flags |= FL_NO_KNOCKBACK;

            if (targ->health < -999)
                targ->health = -999;

            targ->enemy = attacker;
            targ->die (targ, inflictor, attacker, take, mod);
            return;
        } else if ( targ->pain ) {
            targ->pain (targ, attacker, take);
        }
    }

}


/*
============
CanDamage

Returns qtrue if the inflictor can directly damage the target.  Used for
explosions and melee attacks.
============
*/
qboolean CanDamage (gentity_t *targ, vec3_t origin) {
    vec3_t  dest;
    trace_t tr;
    vec3_t  midpoint;

    // use the midpoint of the bounds instead of the origin, because
    // bmodels may have their origin is 0,0,0
    VectorAdd (targ->r.absmin, targ->r.absmax, midpoint);
    VectorScale (midpoint, 0.5, midpoint);

    VectorCopy (midpoint, dest);
    trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
    if (tr.fraction == 1.0 || tr.entityNum == targ->s.number)
        return qtrue;

    // this should probably check in the plane of projection, 
    // rather than in world coordinate, and also include Z
    VectorCopy (midpoint, dest);
    dest[0] += 15.0;
    dest[1] += 15.0;
    trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
    if (tr.fraction == 1.0)
        return qtrue;

    VectorCopy (midpoint, dest);
    dest[0] += 15.0;
    dest[1] -= 15.0;
    trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
    if (tr.fraction == 1.0)
        return qtrue;

    VectorCopy (midpoint, dest);
    dest[0] -= 15.0;
    dest[1] += 15.0;
    trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
    if (tr.fraction == 1.0)
        return qtrue;

    VectorCopy (midpoint, dest);
    dest[0] -= 15.0;
    dest[1] -= 15.0;
    trap_Trace ( &tr, origin, vec3_origin, vec3_origin, dest, ENTITYNUM_NONE, MASK_SOLID);
    if (tr.fraction == 1.0)
        return qtrue;


    return qfalse;
}


/*
============
G_RadiusDamage
============
*/
qboolean G_RadiusDamage ( vec3_t origin, gentity_t *attacker, float damage, float radius,
                     gentity_t *ignore, int mod) {
    float       points, dist;
    gentity_t   *ent;
    int         entityList[MAX_GENTITIES];
    int         numListedEntities;
    vec3_t      mins, maxs;
    vec3_t      v;
    vec3_t      dir;
    int         i, e;
    qboolean    hitClient = qfalse;

    if ( radius < 1 ) {
        radius = 1;
    }

    for ( i = 0 ; i < 3 ; i++ ) {
        mins[i] = origin[i] - radius;
        maxs[i] = origin[i] + radius;
    }

    numListedEntities = trap_EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );

    for ( e = 0 ; e < numListedEntities ; e++ ) {
        ent = &g_entities[entityList[ e ]];

        if (ent == ignore)
            continue;
        if (!ent->takedamage)
            continue;

        // find the distance from the edge of the bounding box
        for ( i = 0 ; i < 3 ; i++ ) {
            if ( origin[i] < ent->r.absmin[i] ) {
                v[i] = ent->r.absmin[i] - origin[i];
            } else if ( origin[i] > ent->r.absmax[i] ) {
                v[i] = origin[i] - ent->r.absmax[i];
            } else {
                v[i] = 0;
            }
        }

        dist = VectorLength( v );
        if ( dist >= radius ) {
            continue;
        }

        points = damage * ( 1.0 - dist / radius );

        if( CanDamage (ent, origin) ) {
            if( LogAccuracyHit( ent, attacker ) ) {
                hitClient = qtrue;
            }
            VectorSubtract (ent->r.currentOrigin, origin, dir);
            // push the center of mass higher than the origin so players
            // get knocked into the air more
            dir[2] += 24;
            G_Damage (ent, NULL, attacker, dir, origin, (int)points, DAMAGE_RADIUS, mod);
        }
    }

    return hitClient;
}

---