g_combat.c File Reference

#include "g_local.h"

Go to the source code of this file.

Functions
qboolean	CanDamage (edict_t *targ, edict_t *inflictor)
void	Killed (edict_t *targ, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
void	SpawnDamage (int type, vec3_t origin, vec3_t normal, int damage)
static int	CheckPowerArmor (edict_t *ent, vec3_t point, vec3_t normal, int damage, int dflags)
static int	CheckArmor (edict_t *ent, vec3_t point, vec3_t normal, int damage, int te_sparks, int dflags)
void	M_ReactToDamage (edict_t *targ, edict_t *attacker)
qboolean	CheckTeamDamage (edict_t *targ, edict_t *attacker)
void	T_Damage (edict_t *targ, edict_t *inflictor, edict_t *attacker, vec3_t dir, vec3_t point, vec3_t normal, int damage, int knockback, int dflags, int mod)
void	T_RadiusDamage (edict_t *inflictor, edict_t *attacker, float damage, edict_t *ignore, float radius, int mod)

Function Documentation

CanDamage()

qboolean CanDamage	(	edict_t *	targ,
		edict_t *	inflictor
	)

Definition at line 30 of file g_combat.c.

{
    vec3_t  dest;
    trace_t trace;
 
// bmodels need special checking because their origin is 0,0,0
    if (targ->movetype == MOVETYPE_PUSH) {
        VectorAdd(targ->absmin, targ->absmax, dest);
        VectorScale(dest, 0.5, dest);
        trace = gi.trace(inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
        if (trace.fraction == 1.0)
            return qtrue;
        if (trace.ent == targ)
            return qtrue;
        return qfalse;
    }
 
    trace = gi.trace(inflictor->s.origin, vec3_origin, vec3_origin, targ->s.origin, inflictor, MASK_SOLID);
    if (trace.fraction == 1.0)
        return qtrue;
 
    VectorCopy(targ->s.origin, dest);
    dest[0] += 15.0;
    dest[1] += 15.0;
    trace = gi.trace(inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
    if (trace.fraction == 1.0)
        return qtrue;
 
    VectorCopy(targ->s.origin, dest);
    dest[0] += 15.0;
    dest[1] -= 15.0;
    trace = gi.trace(inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
    if (trace.fraction == 1.0)
        return qtrue;
 
    VectorCopy(targ->s.origin, dest);
    dest[0] -= 15.0;
    dest[1] += 15.0;
    trace = gi.trace(inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
    if (trace.fraction == 1.0)
        return qtrue;
 
    VectorCopy(targ->s.origin, dest);
    dest[0] -= 15.0;
    dest[1] -= 15.0;
    trace = gi.trace(inflictor->s.origin, vec3_origin, vec3_origin, dest, inflictor, MASK_SOLID);
    if (trace.fraction == 1.0)
        return qtrue;
 
 
    return qfalse;
}

Referenced by bfg_explode(), and T_RadiusDamage().

CheckArmor()

static int CheckArmor ( edict_t *  ent, vec3_t  point, vec3_t  normal, int  damage, int  te_sparks, int  dflags  )

static

Definition at line 243 of file g_combat.c.

{
    gclient_t   *client;
    int         save;
    int         index;
    gitem_t     *armor;
 
    if (!damage)
        return 0;
 
    client = ent->client;
 
    if (!client)
        return 0;
 
    if (dflags & DAMAGE_NO_ARMOR)
        return 0;
 
    index = ArmorIndex(ent);
    if (!index)
        return 0;
 
    armor = GetItemByIndex(index);
 
    if (dflags & DAMAGE_ENERGY)
        save = ceil(((gitem_armor_t *)armor->info)->energy_protection * damage);
    else
        save = ceil(((gitem_armor_t *)armor->info)->normal_protection * damage);
    if (save >= client->pers.inventory[index])
        save = client->pers.inventory[index];
 
    if (!save)
        return 0;
 
    client->pers.inventory[index] -= save;
    SpawnDamage(te_sparks, point, normal, save);
 
    return save;
}

Referenced by T_Damage().

CheckPowerArmor()

static int CheckPowerArmor ( edict_t *  ent, vec3_t  point, vec3_t  normal, int  damage, int  dflags  )

static

Definition at line 165 of file g_combat.c.

{
    gclient_t   *client;
    int         save;
    int         power_armor_type;
    int         index;
    int         damagePerCell;
    int         pa_te_type;
    int         power;
    int         power_used;
 
    if (!damage)
        return 0;
 
    client = ent->client;
 
    if (dflags & DAMAGE_NO_ARMOR)
        return 0;
 
    index = 0;  // shut up gcc
 
    if (client) {
        power_armor_type = PowerArmorType(ent);
        if (power_armor_type != POWER_ARMOR_NONE) {
            index = ITEM_INDEX(FindItem("Cells"));
            power = client->pers.inventory[index];
        }
    } else if (ent->svflags & SVF_MONSTER) {
        power_armor_type = ent->monsterinfo.power_armor_type;
        power = ent->monsterinfo.power_armor_power;
    } else
        return 0;
 
    if (power_armor_type == POWER_ARMOR_NONE)
        return 0;
    if (!power)
        return 0;
 
    if (power_armor_type == POWER_ARMOR_SCREEN) {
        vec3_t      vec;
        float       dot;
        vec3_t      forward;
 
        // only works if damage point is in front
        AngleVectors(ent->s.angles, forward, NULL, NULL);
        VectorSubtract(point, ent->s.origin, vec);
        VectorNormalize(vec);
        dot = DotProduct(vec, forward);
        if (dot <= 0.3)
            return 0;
 
        damagePerCell = 1;
        pa_te_type = TE_SCREEN_SPARKS;
        damage = damage / 3;
    } else {
        damagePerCell = 2;
        pa_te_type = TE_SHIELD_SPARKS;
        damage = (2 * damage) / 3;
    }
 
    save = power * damagePerCell;
    if (!save)
        return 0;
    if (save > damage)
        save = damage;
 
    SpawnDamage(pa_te_type, point, normal, save);
    ent->powerarmor_time = level.time + 0.2;
 
    power_used = save / damagePerCell;
 
    if (client)
        client->pers.inventory[index] -= power_used;
    else
        ent->monsterinfo.power_armor_power -= power_used;
    return save;
}

Referenced by T_Damage().

CheckTeamDamage()

qboolean CheckTeamDamage	(	edict_t *	targ,
		edict_t *	attacker
	)

Definition at line 351 of file g_combat.c.

{
    //FIXME make the next line real and uncomment this block
    // if ((ability to damage a teammate == OFF) && (targ's team == attacker's team))
    return qfalse;
}

Referenced by T_Damage().

Killed()

void Killed	(	edict_t *	targ,
		edict_t *	inflictor,
		edict_t *	attacker,
		int	damage,
		vec3_t	point
	)

Definition at line 89 of file g_combat.c.

{
    if (targ->health < -999)
        targ->health = -999;
 
    targ->enemy = attacker;
 
    if ((targ->svflags & SVF_MONSTER) && (targ->deadflag != DEAD_DEAD)) {
//      targ->svflags |= SVF_DEADMONSTER;   // now treat as a different content type
        if (!(targ->monsterinfo.aiflags & AI_GOOD_GUY)) {
            level.killed_monsters++;
            if (coop->value && attacker->client)
                attacker->client->resp.score++;
            // medics won't heal monsters that they kill themselves
            if (strcmp(attacker->classname, "monster_medic") == 0)
                targ->owner = attacker;
        }
    }
 
    if (targ->movetype == MOVETYPE_PUSH || targ->movetype == MOVETYPE_STOP || targ->movetype == MOVETYPE_NONE) {
        // doors, triggers, etc
        targ->die(targ, inflictor, attacker, damage, point);
        return;
    }
 
    if ((targ->svflags & SVF_MONSTER) && (targ->deadflag != DEAD_DEAD)) {
        targ->touch = NULL;
        monster_death_use(targ);
    }
 
    targ->die(targ, inflictor, attacker, damage, point);
}

Referenced by T_Damage().

M_ReactToDamage()

void M_ReactToDamage	(	edict_t *	targ,
		edict_t *	attacker
	)

Definition at line 283 of file g_combat.c.

{
    if (!(attacker->client) && !(attacker->svflags & SVF_MONSTER))
        return;
 
    if (attacker == targ || attacker == targ->enemy)
        return;
 
    // if we are a good guy monster and our attacker is a player
    // or another good guy, do not get mad at them
    if (targ->monsterinfo.aiflags & AI_GOOD_GUY) {
        if (attacker->client || (attacker->monsterinfo.aiflags & AI_GOOD_GUY))
            return;
    }
 
    // we now know that we are not both good guys
 
    // if attacker is a client, get mad at them because he's good and we're not
    if (attacker->client) {
        targ->monsterinfo.aiflags &= ~AI_SOUND_TARGET;
 
        // this can only happen in coop (both new and old enemies are clients)
        // only switch if can't see the current enemy
        if (targ->enemy && targ->enemy->client) {
            if (visible(targ, targ->enemy)) {
                targ->oldenemy = attacker;
                return;
            }
            targ->oldenemy = targ->enemy;
        }
        targ->enemy = attacker;
        if (!(targ->monsterinfo.aiflags & AI_DUCKED))
            FoundTarget(targ);
        return;
    }
 
    // it's the same base (walk/swim/fly) type and a different classname and it's not a tank
    // (they spray too much), get mad at them
    if (((targ->flags & (FL_FLY | FL_SWIM)) == (attacker->flags & (FL_FLY | FL_SWIM))) &&
        (strcmp(targ->classname, attacker->classname) != 0) &&
        (strcmp(attacker->classname, "monster_tank") != 0) &&
        (strcmp(attacker->classname, "monster_supertank") != 0) &&
        (strcmp(attacker->classname, "monster_makron") != 0) &&
        (strcmp(attacker->classname, "monster_jorg") != 0)) {
        if (targ->enemy && targ->enemy->client)
            targ->oldenemy = targ->enemy;
        targ->enemy = attacker;
        if (!(targ->monsterinfo.aiflags & AI_DUCKED))
            FoundTarget(targ);
    }
    // if they *meant* to shoot us, then shoot back
    else if (attacker->enemy == targ) {
        if (targ->enemy && targ->enemy->client)
            targ->oldenemy = targ->enemy;
        targ->enemy = attacker;
        if (!(targ->monsterinfo.aiflags & AI_DUCKED))
            FoundTarget(targ);
    }
    // otherwise get mad at whoever they are mad at (help our buddy) unless it is us!
    else if (attacker->enemy && attacker->enemy != targ) {
        if (targ->enemy && targ->enemy->client)
            targ->oldenemy = targ->enemy;
        targ->enemy = attacker->enemy;
        if (!(targ->monsterinfo.aiflags & AI_DUCKED))
            FoundTarget(targ);
    }
}

Referenced by T_Damage().

SpawnDamage()

void SpawnDamage	(	int	type,
		vec3_t	origin,
		vec3_t	normal,
		int	damage
	)

Definition at line 128 of file g_combat.c.

{
    if (damage > 255)
        damage = 255;
    gi.WriteByte(svc_temp_entity);
    gi.WriteByte(type);
//  gi.WriteByte (damage);
    gi.WritePosition(origin);
    gi.WriteDir(normal);
    gi.multicast(origin, MULTICAST_PVS);
}

Referenced by CheckArmor(), CheckPowerArmor(), and T_Damage().

T_Damage()

void T_Damage	(	edict_t *	targ,
		edict_t *	inflictor,
		edict_t *	attacker,
		vec3_t	dir,
		vec3_t	point,
		vec3_t	normal,
		int	damage,
		int	knockback,
		int	dflags,
		int	mod
	)

Definition at line 358 of file g_combat.c.

{
    gclient_t   *client;
    int         take;
    int         save;
    int         asave;
    int         psave;
    int         te_sparks;
 
    if (!targ->takedamage)
        return;
 
    // friendly fire avoidance
    // if enabled you can't hurt teammates (but you can hurt yourself)
    // knockback still occurs
    if ((targ != attacker) && ((deathmatch->value && ((int)(dmflags->value) & (DF_MODELTEAMS | DF_SKINTEAMS))) || coop->value)) {
        if (OnSameTeam(targ, attacker)) {
            if ((int)(dmflags->value) & DF_NO_FRIENDLY_FIRE)
                damage = 0;
            else
                mod |= MOD_FRIENDLY_FIRE;
        }
    }
    meansOfDeath = mod;
 
    // easy mode takes half damage
    if (skill->value == 0 && deathmatch->value == 0 && targ->client) {
        damage *= 0.5;
        if (!damage)
            damage = 1;
    }
 
    client = targ->client;
 
    if (dflags & DAMAGE_BULLET)
        te_sparks = TE_BULLET_SPARKS;
    else
        te_sparks = TE_SPARKS;
 
    VectorNormalize(dir);
 
// bonus damage for suprising a monster
    if (!(dflags & DAMAGE_RADIUS) && (targ->svflags & SVF_MONSTER) && (attacker->client) && (!targ->enemy) && (targ->health > 0))
        damage *= 2;
 
    if (targ->flags & FL_NO_KNOCKBACK)
        knockback = 0;
 
// figure momentum add
    if (!(dflags & DAMAGE_NO_KNOCKBACK)) {
        if ((knockback) && (targ->movetype != MOVETYPE_NONE) && (targ->movetype != MOVETYPE_BOUNCE) && (targ->movetype != MOVETYPE_PUSH) && (targ->movetype != MOVETYPE_STOP)) {
            vec3_t  kvel;
            float   mass;
 
            if (targ->mass < 50)
                mass = 50;
            else
                mass = targ->mass;
 
            if (targ->client  && attacker == targ)
                VectorScale(dir, 1600.0 * (float)knockback / mass, kvel);   // the rocket jump hack...
            else
                VectorScale(dir, 500.0 * (float)knockback / mass, kvel);
 
            VectorAdd(targ->velocity, kvel, targ->velocity);
        }
    }
 
    take = damage;
    save = 0;
 
    // check for godmode
    if ((targ->flags & FL_GODMODE) && !(dflags & DAMAGE_NO_PROTECTION)) {
        take = 0;
        save = damage;
        SpawnDamage(te_sparks, point, normal, save);
    }
 
    // check for invincibility
    if ((client && client->invincible_framenum > level.framenum) && !(dflags & DAMAGE_NO_PROTECTION)) {
        if (targ->pain_debounce_time < level.time) {
            gi.sound(targ, CHAN_ITEM, gi.soundindex("items/protect4.wav"), 1, ATTN_NORM, 0);
            targ->pain_debounce_time = level.time + 2;
        }
        take = 0;
        save = damage;
    }
 
    psave = CheckPowerArmor(targ, point, normal, take, dflags);
    take -= psave;
 
    asave = CheckArmor(targ, point, normal, take, te_sparks, dflags);
    take -= asave;
 
    //treat cheat/powerup savings the same as armor
    asave += save;
 
    // team damage avoidance
    if (!(dflags & DAMAGE_NO_PROTECTION) && CheckTeamDamage(targ, attacker))
        return;
 
// do the damage
    if (take) {
        if ((targ->svflags & SVF_MONSTER) || (client))
        {
            // SpawnDamage(TE_BLOOD, point, normal, take);
            SpawnDamage(TE_BLOOD, point, dir, take);
        }
        else
            SpawnDamage(te_sparks, point, normal, take);
 
 
        targ->health = targ->health - take;
 
        if (targ->health <= 0) {
            if ((targ->svflags & SVF_MONSTER) || (client))
                targ->flags |= FL_NO_KNOCKBACK;
            Killed(targ, inflictor, attacker, take, point);
            return;
        }
    }
 
    if (targ->svflags & SVF_MONSTER) {
        M_ReactToDamage(targ, attacker);
        if (!(targ->monsterinfo.aiflags & AI_DUCKED) && (take)) {
            targ->pain(targ, attacker, knockback, take);
            // nightmare mode monsters don't go into pain frames often
            if (skill->value == 3)
                targ->pain_debounce_time = level.time + 5;
        }
    } else if (client) {
        if (!(targ->flags & FL_GODMODE) && (take))
            targ->pain(targ, attacker, knockback, take);
    } else if (take) {
        if (targ->pain)
            targ->pain(targ, attacker, knockback, take);
    }
 
    // 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->damage_parmor += psave;
        client->damage_armor += asave;
        client->damage_blood += take;
        client->damage_knockback += knockback;
        VectorCopy(point, client->damage_from);
    }
}

Referenced by bfg_explode(), bfg_think(), bfg_touch(), blaster_touch(), door_blocked(), door_secret_blocked(), fire_hit(), fire_lead(), fire_rail(), floater_zap(), func_object_touch(), Grenade_Explode(), hurt_touch(), KillBox(), M_WorldEffects(), mutant_jump_touch(), P_FallingDamage(), P_WorldEffects(), parasite_drain_attack(), plat_blocked(), rocket_touch(), rotating_blocked(), rotating_touch(), T_RadiusDamage(), target_laser_think(), train_blocked(), turret_blocked(), and use_target_changelevel().

T_RadiusDamage()

void T_RadiusDamage	(	edict_t *	inflictor,
		edict_t *	attacker,
		float	damage,
		edict_t *	ignore,
		float	radius,
		int	mod
	)

Definition at line 514 of file g_combat.c.

{
    float   points;
    edict_t *ent = NULL;
    vec3_t  v;
    vec3_t  dir;
 
    while ((ent = findradius(ent, inflictor->s.origin, radius)) != NULL) {
        if (ent == ignore)
            continue;
        if (!ent->takedamage)
            continue;
 
        VectorAdd(ent->mins, ent->maxs, v);
        VectorMA(ent->s.origin, 0.5, v, v);
        VectorSubtract(inflictor->s.origin, v, v);
        points = damage - 0.5 * VectorLength(v);
        if (ent == attacker)
            points = points * 0.5;
        if (points > 0) {
            if (CanDamage(ent, inflictor)) {
                VectorSubtract(ent->s.origin, inflictor->s.origin, dir);
                T_Damage(ent, inflictor, attacker, dir, inflictor->s.origin, vec3_origin, (int)points, (int)points, DAMAGE_RADIUS, mod);
            }
        }
    }
}

Referenced by barrel_explode(), bfg_touch(), func_explosive_explode(), Grenade_Explode(), misc_viper_bomb_touch(), rocket_touch(), target_explosion_explode(), and use_target_splash().