damage.qh File Reference

#include <common/weapons/_all.qh>

Include dependency graph for damage.qh:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DMG_NOWEP   (weaponentities[0])

Functions
string	AppendItemcodes (string s, entity player)
	bool (entity targ, entity inflictor, float amount, float limit) event_heal
void	Damage (entity targ, entity inflictor, entity attacker, float damage, int deathtype,.entity weaponentity, vector hitloc, vector force)
void	Damage_DamageInfo (vector org, float coredamage, float edgedamage, float rad, vector force, int deathtype, float bloodtype, entity dmgowner)
bool	Damage_DamageInfo_SendEntity (entity this, entity to, int sf)
float	Fire_AddDamage (entity e, entity o, float d, float t, float dt)
void	Fire_ApplyDamage (entity e)
void	GiveFrags (entity attacker, entity targ, float f, int deathtype,.entity weaponentity)
bool	Heal (entity targ, entity inflictor, float amount, float limit)
float	IsFlying (entity a)
void	LogDeath (string mode, int deathtype, entity killer, entity killed)
void	Obituary (entity attacker, entity inflictor, entity targ, int deathtype,.entity weaponentity)
void	Obituary_SpecialDeath (entity notif_target, bool murder, bool msg_from_ent, int deathtype, string s1, string s2, string s3, string s4, float f1, float f2, float f3)
float	Obituary_WeaponDeath (entity notif_target, float murder, int deathtype, string s1, string s2, string s3, float f1, float f2)
float	RadiusDamage (entity inflictor, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, float forceintensity, int deathtype,.entity weaponentity, entity directhitentity)
float	RadiusDamageForSource (entity inflictor, vector inflictororigin, vector inflictorvelocity, entity attacker, float coredamage, float edgedamage, float rad, entity cantbe, entity mustbe, bool inflictorselfdamage, float forceintensity, vector forcexyzscale, int deathtype,.entity weaponentity, entity directhitentity)
	Returns total damage applied to creatures.
	STATIC_INIT (g_damagedbycontents)
	void (entity this, entity inflictor, entity attacker, float damage, int deathtype,.entity weaponentity, vector hitloc, vector force) event_damage
void	W_SwitchWeapon_Force (Player this, Weapon w,.entity weaponentity)

Variables
float	autocvar_g_balance_armor_blockpercent
float	autocvar_g_balance_damagepush_speedfactor
int	autocvar_g_balance_firetransfer_damage
int	autocvar_g_balance_firetransfer_time
float	autocvar_g_balance_selfdamagepercent
float	autocvar_g_friendlyfire
float	autocvar_g_friendlyfire_virtual
float	autocvar_g_friendlyfire_virtual_force
float	autocvar_g_maxpushtime
float	autocvar_g_mirrordamage
bool	autocvar_g_mirrordamage_onlyweapons
bool	autocvar_g_mirrordamage_virtual
int	autocvar_g_player_damageplayercenter
float	autocvar_g_teamdamage_resetspeed
float	autocvar_g_teamdamage_threshold
bool	autocvar_g_teamkill_punishing
float	autocvar_g_throughfloor_damage
float	autocvar_g_throughfloor_damage_max_stddev
bool	autocvar_g_throughfloor_debug
float	autocvar_g_throughfloor_force
float	autocvar_g_throughfloor_force_max_stddev
float	autocvar_g_throughfloor_max_steps_other
float	autocvar_g_throughfloor_max_steps_player
float	autocvar_g_throughfloor_min_steps_other
float	autocvar_g_throughfloor_min_steps_player
bool	canteamdamage
float	checkrules_firstblood
float	damagedbycontents
float	damagedbytriggers
float	damageextraradius
float	damageforcescale
vector	death_origin
string	deathmessage
float	dmg
float	dmg_edge
float	dmg_force
float	dmg_radius
float	dmg_team
float	fire_damagepersec
float	fire_deathtype
float	fire_hitsound
entity	fire_owner
IntrusiveList	g_damagedbycontents
float	hitsound_damage_dealt
int	impressive_hits
bool	istypefrag
int	killsound
const float	MAX_DAMAGEEXTRARADIUS = 16
const float	MIN_DAMAGEEXTRARADIUS = 0.1
float	pain_finished
entity	pusher
bool	RadiusDamage_running
float	spawnshieldtime
float	taunt_soundtime
float	teamkill_complain
entity	teamkill_soundsource
float	teamkill_soundtime
int	totalfrags
int	typehitsound
float	w_deathtype
float	yoda

Macro Definition Documentation

DMG_NOWEP

#define DMG_NOWEP   (weaponentities[0])

Definition at line 104 of file damage.qh.

Referenced by buff_Vengeance_DelayedDamage(), bumblebee_blowup(), bumblebee_pilot_frame(), CheatImpulse(), ClientKill_Now(), CommonCommand_editmob(), CreatureFrame_FallDamage(), CreatureFrame_hotliquids(), ctf_CaptureShield_Touch(), door_blocked(), door_generic_plat_blocked(), DrownPlayer(), Fire_ApplyDamage(), func_breakable_destroy(), generic_plat_blocked(), havocbot_role_ctf_carrier(), instagib_countdown(), M_Golem_Attack_Lightning_Explode(), M_Golem_Attack_Smash(), M_Mage_Attack_Push(), M_Mage_Attack_Spike_Explode(), M_Spider_Attack_Web_Explode(), M_Wyvern_Attack_Fireball_Explode(), M_Zombie_Attack_Leap_Touch(), misc_laser_think(), Monster_Attack_Melee(), Monster_Move(), Monster_Think(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), nade_heal_touch(), nade_normal_boom(), nade_spawn_DestroyDamage(), nade_translocate_DestroyDamage(), ons_CaptureShield_Touch(), ons_ControlPoint_Icon_Think(), Onslaught_CheckWinner(), plat_crush(), player_regen(), PlayerTouchExplode(), racer_blowup(), raptor_blowup(), raptor_bomblet_boom(), SetPlayerTeam(), spiderbot_blowup(), target_kill_use(), tdeath(), trigger_hurt_touch(), turret_flac_projectile_think_explode(), turret_projectile_explode(), turret_tesla_toast(), vehicles_impact(), vehicles_projectile_explode(), vehicles_touch(), walker_melee_do_dmg(), and walker_rocket_explode().

Function Documentation

AppendItemcodes()

string AppendItemcodes	(	string	s,
		entity	player )

Definition at line 82 of file damage.qc.

{
    for (int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        .entity weaponentity = weaponentities[slot];
        int w = player.(weaponentity).m_weapon.m_id;
        if (w == 0)
            w = player.(weaponentity).cnt; // previous weapon
        if (w != 0 || slot == 0)
            s = strcat(s, ftos(w));
    }
    if (PHYS_INPUT_BUTTON_CHAT(player))
        s = strcat(s, "T");
    // TODO: include these codes as a flag on the item itself
    MUTATOR_CALLHOOK(LogDeath_AppendItemCodes, player, s);
    s = M_ARGV(1, string);
    return s;
}

References cnt, entity(), ftos(), M_ARGV, m_weapon, MAX_WEAPONSLOTS, MUTATOR_CALLHOOK, PHYS_INPUT_BUTTON_CHAT, strcat(), and weaponentities.

Referenced by LogDeath().

bool()

bool	(	entity	targ,
		entity	inflictor,
		float	amount,
		float	limit )

References entity().

Damage()

void Damage	(	entity	targ,
		entity	inflictor,
		entity	attacker,
		float	damage,
		int	deathtype,
		.entity	weaponentity,
		vector	hitloc,
		vector	force )

Definition at line 484 of file damage.qc.

{
    if (game_stopped || (IS_CLIENT(targ) && CS(targ).killcount == FRAGS_SPECTATOR))
        return;
 
    // special rule: gravity bombs and sound-based attacks do not affect team mates (other than for disconnecting the hook)
    if ((DEATH_ISWEAPON(deathtype, WEP_HOOK) || (deathtype & HITTYPE_SOUND))
    && IS_PLAYER(targ) && SAME_TEAM(targ, attacker))
        return;
 
    entity attacker_save = attacker;
 
    float complainteamdamage = 0;
    float mirrordamage = 0;
    float mirrorforce = 0;
 
    if (deathtype == DEATH_KILL.m_id || deathtype == DEATH_TEAMCHANGE.m_id || deathtype == DEATH_AUTOTEAMCHANGE.m_id || damage == INFINITY)
    {
        // exit the vehicle before killing (fixes a crash)
        if (IS_PLAYER(targ) && targ.vehicle)
            vehicles_exit(targ.vehicle, VHEF_RELEASE);
 
        StatusEffects_remove(STATUSEFFECT_SpawnShield, targ, STATUSEFFECT_REMOVE_CLEAR);
        targ.flags &= ~FL_GODMODE;
        damage = INFINITY;
    }
    else if (deathtype == DEATH_MIRRORDAMAGE.m_id || deathtype == DEATH_NOAMMO.m_id)
    {
        // no processing
    }
    else
    {
        // nullify damage if teamplay is on
        if (deathtype != DEATH_TELEFRAG.m_id
        && IS_PLAYER(attacker))
        {
            // avoid dealing damage or force to other independent players
            // and avoid dealing damage or force to things owned by other independent players
            if ((IS_PLAYER(targ) && targ != attacker && (IS_INDEPENDENT_PLAYER(attacker) || IS_INDEPENDENT_PLAYER(targ)))
            || (targ.realowner && IS_INDEPENDENT_PLAYER(targ.realowner) && attacker != targ.realowner))
            {
                damage = 0;
                force = '0 0 0';
            }
            else if (!STAT(FROZEN, targ) && SAME_TEAM(attacker, targ))
            {
                if (autocvar_teamplay_mode == 1)
                    damage = 0;
                else if (attacker != targ)
                {
                    if (autocvar_teamplay_mode == 2)
                    {
                        if (IS_PLAYER(targ) && !IS_DEAD(targ))
                        {
                            attacker.dmg_team += damage;
                            complainteamdamage = attacker.dmg_team - autocvar_g_teamdamage_threshold;
                        }
                    }
                    else if (autocvar_teamplay_mode == 3)
                        damage = 0;
                    else if (autocvar_teamplay_mode == 4)
                    {
                        if (IS_PLAYER(targ) && !IS_DEAD(targ))
                        {
                            attacker.dmg_team += damage;
                            complainteamdamage = attacker.dmg_team - autocvar_g_teamdamage_threshold;
                            if (complainteamdamage > 0)
                                mirrordamage = autocvar_g_mirrordamage * complainteamdamage;
                            mirrorforce = autocvar_g_mirrordamage * vlen(force);
                            damage = autocvar_g_friendlyfire * damage;
                            // mirrordamage will be used LATER
 
                            if (autocvar_g_mirrordamage_virtual)
                            {
                                vector v = healtharmor_applydamage(GetResource(attacker, RES_HEALTH), GetResource(attacker, RES_ARMOR),
                                                                   autocvar_g_balance_armor_blockpercent, deathtype, mirrordamage);
                                attacker.dmg_take += v.x;
                                attacker.dmg_save += v.y;
                                attacker.dmg_inflictor = inflictor;
                                mirrordamage = v.z;
                                mirrorforce = 0;
                            }
 
                            if (autocvar_g_friendlyfire_virtual)
                            {
                                vector v = healtharmor_applydamage(GetResource(targ, RES_HEALTH), GetResource(targ, RES_ARMOR),
                                                                   autocvar_g_balance_armor_blockpercent, deathtype, damage);
                                targ.dmg_take += v.x;
                                targ.dmg_save += v.y;
                                targ.dmg_inflictor = inflictor;
                                damage = 0;
                                if (!autocvar_g_friendlyfire_virtual_force)
                                    force = '0 0 0';
                            }
                        }
                        else if (!targ.canteamdamage)
                            damage = 0;
                    }
                }
            }
        }
 
        if (!DEATH_ISSPECIAL(deathtype))
        {
            damage             *= autocvar_g_weapondamagefactor;
            mirrordamage       *= autocvar_g_weapondamagefactor;
            complainteamdamage *= autocvar_g_weapondamagefactor;
            force       *= autocvar_g_weaponforcefactor;
            mirrorforce *= autocvar_g_weaponforcefactor;
        }
 
        // should this be changed at all? If so, in what way?
        MUTATOR_CALLHOOK(Damage_Calculate, inflictor, attacker, targ, deathtype, damage, mirrordamage, force, attacker.(weaponentity));
        damage = M_ARGV(4, float);
        mirrordamage = M_ARGV(5, float);
        force = M_ARGV(6, vector);
 
        if (IS_PLAYER(targ) && damage > 0 && attacker)
            for (int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
            {
                .entity went = weaponentities[slot];
                if (targ.(went).hook && targ.(went).hook.aiment == attacker)
                    RemoveHook(targ.(went).hook);
            }
 
        if (targ == attacker)
            damage *= autocvar_g_balance_selfdamagepercent; // Partial damage if the attacker hits himself
 
        // count the damage
        if (attacker && targ != attacker
        && !IS_DEAD(targ)
        && deathtype != DEATH_BUFF_INFERNO.m_id
        && deathtype != DEATH_BUFF_VENGEANCE.m_id
        && targ.takedamage == DAMAGE_AIM)
        {
            entity victim;
            if (IS_VEHICLE(targ) && targ.owner)
                victim = targ.owner;
            else
                victim = targ;
 
            // TODO: allow the mutator hook to tell if the hit sound should be team or not
            if (IS_PLAYER(victim) || (IS_TURRET(victim) && victim.active == ACTIVE_ACTIVE) || IS_MONSTER(victim)
            || MUTATOR_CALLHOOK(PlayHitsound, victim, attacker))
            {
                if (DIFF_TEAM(victim, attacker))
                {
                    if (damage > 0)
                    {
                        if (deathtype != DEATH_FIRE.m_id)
                        {
                            if (PHYS_INPUT_BUTTON_CHAT(victim))
                                ++attacker.typehitsound;
                            else
                                attacker.hitsound_damage_dealt += damage;
                        }
 
                        ++impressive_hits;
 
                        if (!DEATH_ISSPECIAL(deathtype)
                        && IS_PLAYER(targ) // don't do this for vehicles
                        && IsFlying(victim))
                            yoda = 1;
                    }
                }
                else if (IS_PLAYER(attacker) && !STAT(FROZEN, victim) && !(deathtype & HITTYPE_SPAM)) // same team
                {
                    if (deathtype != DEATH_FIRE.m_id)
                        ++attacker.typehitsound;
                    if (complainteamdamage > 0
                    && time > CS(attacker).teamkill_complain)
                    {
                        CS(attacker).teamkill_complain = time + 5;
                        CS(attacker).teamkill_soundtime = time + 0.4;
                        CS(attacker).teamkill_soundsource = targ;
                    }
                }
            }
        }
    }
 
    // apply push
    if (targ.damageforcescale && force
    && (!IS_PLAYER(targ) || !StatusEffects_active(STATUSEFFECT_SpawnShield, targ) || targ == attacker))
    {
        vector farce = damage_explosion_calcpush(targ.damageforcescale * force, targ.velocity, autocvar_g_balance_damagepush_speedfactor);
        if (targ.move_movetype == MOVETYPE_PHYSICS)
        {
            entity farcent = new(farce);
            farcent.enemy = targ;
            farcent.movedir = farce * 10;
            if (targ.mass)
                farcent.movedir *= targ.mass;
            farcent.origin = hitloc;
            farcent.forcetype = FORCETYPE_FORCEATPOS;
            farcent.nextthink = time + 0.1;
            setthink(farcent, SUB_Remove);
        }
        else if (targ.move_movetype != MOVETYPE_NOCLIP)
            targ.velocity += farce;
        UNSET_ONGROUND(targ);
        UpdateCSQCProjectile(targ);
    }
    // apply damage
    if ((damage != 0 || (targ.damageforcescale && force))
    && targ.event_damage)
        targ.event_damage(targ, inflictor, attacker, damage, deathtype, weaponentity, hitloc, force);
 
    // apply mirror damage if any
    if ((!autocvar_g_mirrordamage_onlyweapons || DEATH_WEAPONOF(deathtype) != WEP_Null)
    && (mirrordamage > 0 || mirrorforce > 0))
    {
        attacker = attacker_save;
 
        force = normalize(attacker.origin + attacker.view_ofs - hitloc) * mirrorforce;
        Damage(attacker, inflictor, attacker, mirrordamage, DEATH_MIRRORDAMAGE.m_id, weaponentity, attacker.origin, force);
    }
}

References ACTIVE_ACTIVE, autocvar_g_balance_armor_blockpercent, autocvar_g_balance_damagepush_speedfactor, autocvar_g_balance_selfdamagepercent, autocvar_g_friendlyfire, autocvar_g_friendlyfire_virtual, autocvar_g_friendlyfire_virtual_force, autocvar_g_mirrordamage, autocvar_g_mirrordamage_onlyweapons, autocvar_g_mirrordamage_virtual, autocvar_g_teamdamage_threshold, autocvar_g_weapondamagefactor, autocvar_g_weaponforcefactor, autocvar_teamplay_mode, CS(), Damage(), DAMAGE_AIM, damage_explosion_calcpush(), DEATH_ISSPECIAL, DEATH_ISWEAPON, DEATH_WEAPONOF, DIFF_TEAM, entity(), FL_GODMODE, FORCETYPE_FORCEATPOS, FRAGS_SPECTATOR, game_stopped, GetResource(), healtharmor_applydamage(), HITTYPE_SOUND, HITTYPE_SPAM, impressive_hits, INFINITY, IS_CLIENT, IS_DEAD, IS_INDEPENDENT_PLAYER, IS_MONSTER, IS_PLAYER, IS_TURRET, IS_VEHICLE, IsFlying(), killcount, M_ARGV, MAX_WEAPONSLOTS, MOVETYPE_NOCLIP, MOVETYPE_PHYSICS, MUTATOR_CALLHOOK, normalize(), PHYS_INPUT_BUTTON_CHAT, RemoveHook(), RES_ARMOR, SAME_TEAM, setthink, STAT, STATUSEFFECT_REMOVE_CLEAR, StatusEffects_active(), StatusEffects_remove(), SUB_Remove(), teamkill_complain, time, UNSET_ONGROUND, UpdateCSQCProjectile(), vector, vehicles_exit(), VHEF_RELEASE, vlen(), weaponentities, and yoda.

Referenced by buff_Vengeance_DelayedDamage(), bumblebee_pilot_frame(), ClientKill_Now(), CommonCommand_editmob(), CreatureFrame_FallDamage(), CreatureFrame_hotliquids(), ctf_CaptureShield_Touch(), Damage(), door_blocked(), door_generic_plat_blocked(), DrownPlayer(), Fire_ApplyDamage(), fireBullet_falloff(), generic_plat_blocked(), havocbot_role_ctf_carrier(), instagib_countdown(), M_Golem_Attack_Lightning_Explode(), M_Zombie_Attack_Leap_Touch(), misc_laser_think(), Monster_Attack_Melee(), Monster_Move(), Monster_Think(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), MUTATOR_HOOKFUNCTION(), nade_heal_touch(), nade_spawn_DestroyDamage(), nade_translocate_DestroyDamage(), ons_CaptureShield_Touch(), Onslaught_CheckWinner(), plat_crush(), RadiusDamageForSource(), SetPlayerTeam(), target_kill_use(), tdeath(), trigger_hurt_touch(), turret_tesla_toast(), vehicles_impact(), vehicles_touch(), W_Arc_Beam_Think(), W_Fireball_Explode(), W_OverkillRocketPropelledChainsaw_Think(), W_Shotgun_Melee_Think(), and walker_melee_do_dmg().

Damage_DamageInfo()

void Damage_DamageInfo	(	vector	org,
		float	coredamage,
		float	edgedamage,
		float	rad,
		vector	force,
		int	deathtype,
		float	bloodtype,
		entity	dmgowner )

Definition at line 35 of file damageeffects.qc.

{
    // TODO maybe call this from non-edgedamage too?
    // TODO maybe make the client do the particle effects for the weapons and the impact sounds using this info?
 
    if(!sound_allowed(MSG_BROADCAST, dmgowner))
        deathtype |= 0x8000;
 
    entity e = new_pure(damageinfo);
    // origin is just data to be sent
    //setorigin(e, org);
    e.origin = org;
    e.projectiledeathtype = deathtype;
    e.dmg = coredamage;
    e.dmg_edge = edgedamage;
    bool rad_negative = false;
    if(rad < 0)
    {
        // make it positive (unsigned) so it can be sent as byte
        rad_negative = true;
        rad = -rad;
    }
    e.dmg_radius = rad;
    e.dmg_force = vlen(force);
    e.velocity = (e.dmg_force ? force / e.dmg_force : '0 0 0');
 
    e.species = bloodtype & BITS(4); // it only uses bits from 0 to 3, see SPECIES_* constants
    if(rad_negative)
        e.species |= BIT(7);
 
    e.colormap = (teamplay) ? dmgowner.team : dmgowner.clientcolors; // NOTE: doesn't work on non-clients
 
    Net_LinkEntity(e, false, 0.2, Damage_DamageInfo_SendEntity);
}

References BIT, BITS, Damage_DamageInfo_SendEntity(), entity(), MSG_BROADCAST, Net_LinkEntity(), new_pure, org, sound_allowed(), teamplay, vector, and vlen().

Referenced by fireBullet_falloff(), FireRailgunBullet(), nade_normal_boom(), RadiusDamageForSource(), raptor_bomb_burst(), W_Seeker_Tag_Explode(), and W_Seeker_Tag_Touch().

Damage_DamageInfo_SendEntity()

bool Damage_DamageInfo_SendEntity	(	entity	this,
		entity	to,
		int	sf )

Definition at line 7 of file damageeffects.qc.

{
    vector org = vec3(floor(this.origin.x), floor(this.origin.y), floor(this.origin.z));
    WriteHeader(MSG_ENTITY, ENT_CLIENT_DAMAGEINFO);
    WriteShort(MSG_ENTITY, this.projectiledeathtype);
    WriteVector(MSG_ENTITY, org);
    WriteByte(MSG_ENTITY, bound(1, this.dmg, 255));
    WriteByte(MSG_ENTITY, bound(0, this.dmg_radius, 255));
    WriteByte(MSG_ENTITY, bound(1, this.dmg_edge, 255));
 
    // we can't send the force vector compressed with compressShortVector to 1 byte since
    // it's too inaccurate and would break decals when hitting a surface with a small angle
    // (the traceline performed by the client to spawn a decal wouldn't hit the surface at all)
    // so we send force direction with 3 bytes and force length with 1 byte
    // Since this.velocity is a normalized vector we map vector components
    // from [-1, 1] to [-127, 127]
    WriteChar(MSG_ENTITY, rint(this.velocity.x * BITS(7)));
    WriteChar(MSG_ENTITY, rint(this.velocity.y * BITS(7)));
    WriteChar(MSG_ENTITY, rint(this.velocity.z * BITS(7)));
 
    // max 255 * 4 = 1020 force length, min 0 (discards negative values)
    WriteByte(MSG_ENTITY, bound(0, this.dmg_force / 4, BITS(8)));
 
    WriteByte(MSG_ENTITY, this.species);
    WriteByte(MSG_ENTITY, this.colormap);
    return true;
}

References BITS, bound(), colormap, dmg, dmg_edge, dmg_force, dmg_radius, entity(), floor(), MSG_ENTITY, org, origin, projectiledeathtype, rint(), species, vec3, vector, velocity, WriteByte(), WriteChar(), WriteHeader, and WriteShort().

Referenced by Damage_DamageInfo().

Fire_AddDamage()

float Fire_AddDamage	(	entity	e,
		entity	o,
		float	d,
		float	t,
		float	dt )

Definition at line 968 of file damage.qc.

{
    if (d <= 0)
        return -1;
    if (IS_PLAYER(e) && IS_DEAD(e))
        return -1;
 
    t = max(t, 0.1);
    float dps = d / t;
 
    if (StatusEffects_active(STATUSEFFECT_Burning, e))
    {
        float fireendtime = StatusEffects_gettime(STATUSEFFECT_Burning, e);
 
        float mintime = fireendtime - time;
        float maxtime = max(mintime, t);
 
        float mindps = e.fire_damagepersec;
        float maxdps = max(mindps, dps);
 
        if (maxtime > mintime || maxdps > mindps)
        {
            // Constraints:
 
            // damage we have right now
            float mindamage = mindps * mintime;
 
            // damage we want to get
            float maxdamage = mindamage + d;
 
            // but we can't exceed maxtime * maxdps!
            float totaldamage = min(maxdamage, maxtime * maxdps);
 
            // LEMMA:
            // Look at:
            // totaldamage = min(mindamage + d, maxtime * maxdps)
            // We see:
            // totaldamage <= maxtime * maxdps
            // ==> totaldamage / maxdps <= maxtime.
            // We also see:
            // totaldamage / mindps = min(mindamage / mindps + d, maxtime * maxdps / mindps)
            //                     >= min(mintime, maxtime)
            // ==> totaldamage / maxdps >= mintime.
 
            /*
            // how long do we damage then?
            // at least as long as before
            // but, never exceed maxdps
            totaltime = max(mintime, totaldamage / maxdps); // always <= maxtime due to lemma
            */
 
            // alternate:
            // at most as long as maximum allowed
            // but, never below mindps
            float totaltime = min(maxtime, totaldamage / mindps); // always >= mintime due to lemma
 
            // assuming t > mintime, dps > mindps:
            // we get d = t * dps = maxtime * maxdps
            // totaldamage = min(maxdamage, maxtime * maxdps) = min(... + d, maxtime * maxdps) = maxtime * maxdps
            // totaldamage / maxdps = maxtime
            // totaldamage / mindps > totaldamage / maxdps = maxtime
            // FROM THIS:
            // a) totaltime = max(mintime, maxtime) = maxtime
            // b) totaltime = min(maxtime, totaldamage / maxdps) = maxtime
 
            // assuming t <= mintime:
            // we get maxtime = mintime
            // a) totaltime = max(mintime, ...) >= mintime, also totaltime <= maxtime by the lemma, therefore totaltime = mintime = maxtime
            // b) totaltime = min(maxtime, ...) <= maxtime, also totaltime >= mintime by the lemma, therefore totaltime = mintime = maxtime
 
            // assuming dps <= mindps:
            // we get mindps = maxdps.
            // With this, the lemma says that mintime <= totaldamage / mindps = totaldamage / maxdps <= maxtime.
            // a) totaltime = max(mintime, totaldamage / maxdps) = totaldamage / maxdps
            // b) totaltime = min(maxtime, totaldamage / mindps) = totaldamage / maxdps
 
            e.fire_damagepersec = totaldamage / totaltime;
            StatusEffects_apply(STATUSEFFECT_Burning, e, time + totaltime, 0);
            if (totaldamage > 1.2 * mindamage)
            {
                e.fire_deathtype = dt;
                if (e.fire_owner != o)
                {
                    e.fire_owner = o;
                    e.fire_hitsound = false;
                }
            }
            if (accuracy_isgooddamage(o, e))
                accuracy_add(o, DEATH_WEAPONOF(dt), 0, max(0, totaldamage - mindamage), 0); // add to hit
            return max(0, totaldamage - mindamage); // can never be negative, but to make sure
        }
        else
            return 0;
    }
    else
    {
        e.fire_damagepersec = dps;
        StatusEffects_apply(STATUSEFFECT_Burning, e, time + t, 0);
        e.fire_deathtype = dt;
        e.fire_owner = o;
        e.fire_hitsound = false;
        if (accuracy_isgooddamage(o, e))
            accuracy_add(o, DEATH_WEAPONOF(dt), 0, d, 0); // add to hit
        return d;
    }
}

References accuracy_add(), accuracy_isgooddamage(), DEATH_WEAPONOF, entity(), IS_DEAD, IS_PLAYER, max(), min(), StatusEffects_active(), StatusEffects_apply(), StatusEffects_gettime(), and time.

Referenced by CreatureFrame_hotliquids(), M_Wyvern_Attack_Fireball_Explode(), MUTATOR_HOOKFUNCTION(), W_Fireball_Firemine_Touch(), and W_LaserPlay().

Fire_ApplyDamage()

void Fire_ApplyDamage

(

entity

e

)

Definition at line 1075 of file damage.qc.

{
    entity o;
    float t;
    for (t = 0, o = e.owner; o.owner && t < 16; o = o.owner, ++t);
    if (IS_NOT_A_CLIENT(o))
        o = e.fire_owner;
 
    float fireendtime = StatusEffects_gettime(STATUSEFFECT_Burning, e);
    t = min(frametime, fireendtime - time);
    float d = e.fire_damagepersec * t;
 
    float hi = e.fire_owner.hitsound_damage_dealt;
    float ty = e.fire_owner.typehitsound;
    Damage(e, e, e.fire_owner, d, e.fire_deathtype, DMG_NOWEP, e.origin, '0 0 0');
    if (e.fire_hitsound && e.fire_owner)
    {
        e.fire_owner.hitsound_damage_dealt = hi;
        e.fire_owner.typehitsound = ty;
    }
    e.fire_hitsound = true;
 
    if (!IS_INDEPENDENT_PLAYER(e) && !STAT(FROZEN, e) && !StatusEffects_active(STATUSEFFECT_Frozen, e))
        IL_EACH(g_damagedbycontents, it.damagedbycontents && it != e,
        {
            if (!IS_DEAD(it) && it.takedamage && !IS_INDEPENDENT_PLAYER(it)
            && boxesoverlap(e.absmin - '1 1 1', e.absmax + '1 1 1', it.absmin, it.absmax))
            {
                t = autocvar_g_balance_firetransfer_time * (fireendtime - time);
                d = autocvar_g_balance_firetransfer_damage * e.fire_damagepersec * t;
                Fire_AddDamage(it, o, d, t, DEATH_FIRE.m_id);
            }
        });
}

GiveFrags()

void GiveFrags	(	entity	attacker,
		entity	targ,
		float	f,
		int	deathtype,
		.entity	weaponentity )

Definition at line 44 of file damage.qc.

{
    // TODO route through PlayerScores instead
    if (game_stopped)
        return;
 
    if (f < 0)
    {
        if (targ == attacker) // suicide
            GameRules_scoring_add(attacker, SUICIDES, 1);
        else
        {
            // teamkill
            int teamkills = GameRules_scoring_add(attacker, TEAMKILLS, 1);
            if (autocvar_g_teamkill_punishing)
                f -= (teamkills * (teamkills - 1)) * 0.5; // negative 1, 2, 4, 7, 11, 16, 22, etc.
        }
    }
    else
    {
        // regular frag
        GameRules_scoring_add(attacker, KILLS, 1);
        if (!warmup_stage && targ.playerid)
            PlayerStats_GameReport_Event_Player(attacker, sprintf("kills-%d", targ.playerid), 1);
    }
 
    GameRules_scoring_add(targ, DEATHS, 1);
 
    // FIXME fix the mess this is (we have REAL points now!)
    if (MUTATOR_CALLHOOK(GiveFragsForKill, attacker, targ, f, deathtype, attacker.(weaponentity)))
        f = M_ARGV(2, float);
 
    attacker.totalfrags += f;
 
    if (f)
        GameRules_scoring_add_team(attacker, SCORE, f);
}

References autocvar_g_teamkill_punishing, entity(), game_stopped, GameRules_scoring_add, GameRules_scoring_add_team, M_ARGV, MUTATOR_CALLHOOK, PlayerStats_GameReport_Event_Player, and warmup_stage.

Referenced by MUTATOR_HOOKFUNCTION(), and Obituary().

Heal()

bool Heal	(	entity	targ,
		entity	inflictor,
		float	amount,
		float	limit )

Definition at line 951 of file damage.qc.

{
    // TODO: mutator hook to control healing
    if (game_stopped
    || (IS_CLIENT(targ) && CS(targ).killcount == FRAGS_SPECTATOR)
    || STAT(FROZEN, targ) || IS_DEAD(targ))
        return false;
 
    bool healed = (targ.event_heal)
        ? targ.event_heal(targ, inflictor, amount, limit)
        : false;
    // TODO: additional handling? what if the healing kills them? should this abort if healing would do so etc
    // TODO: healing fx!
    // TODO: armor healing?
    return healed;
}

References CS(), entity(), FRAGS_SPECTATOR, game_stopped, IS_CLIENT, IS_DEAD, killcount, and STAT.

Referenced by bumblebee_pilot_frame(), M_Mage_Defend_Heal(), MUTATOR_HOOKFUNCTION(), trigger_heal_touch(), and W_Arc_Beam_Think().

IsFlying()

float IsFlying

(

entity

a

)

Definition at line 843 of file player.qc.

{
    if(IS_ONGROUND(this))
        return false;
    if(this.waterlevel >= WATERLEVEL_SWIMMING)
        return false;
    tracebox(this.origin, this.mins, this.maxs, this.origin - '0 0 24', MOVE_NORMAL, this);
    //traceline(this.origin, this.origin - '0 0 48', MOVE_NORMAL, this);
    if(trace_fraction < 1)
        return false;
    return true;
}

References entity(), IS_ONGROUND, maxs, mins, MOVE_NORMAL, origin, trace_fraction, waterlevel, and WATERLEVEL_SWIMMING.

Referenced by Damage(), MUTATOR_HOOKABLE(), sys_phys_update(), W_Devastator_Explode(), W_Electro_Explode(), W_MineLayer_Explode(), W_Mortar_Grenade_Explode(), W_Mortar_Grenade_Explode2(), W_OverkillNex_Attack(), W_RocketMinsta_Laser_Explode(), W_Vaporizer_Attack(), and W_Vortex_Attack().

LogDeath()

void LogDeath	(	string	mode,
		int	deathtype,
		entity	killer,
		entity	killed )

Definition at line 101 of file damage.qc.

{
    if (!autocvar_sv_eventlog)
        return;
    string s = strcat(":kill:", mode,
        ":", ftos(killer.playerid),
        ":", ftos(killed.playerid));
    s = strcat(s, ":type=", Deathtype_Name(deathtype), ":items=");
    s = AppendItemcodes(s, killer);
    if (killed != killer)
    {
        s = strcat(s, ":victimitems=");
        s = AppendItemcodes(s, killed);
    }
    GameLogEcho(s);
}

References AppendItemcodes(), autocvar_sv_eventlog, Deathtype_Name(), entity(), ftos(), GameLogEcho(), and strcat().

Referenced by Obituary().

Obituary()

void Obituary	(	entity	attacker,
		entity	inflictor,
		entity	targ,
		int	deathtype,
		.entity	weaponentity )

Definition at line 223 of file damage.qc.

{
    // Sanity check
    if (!IS_PLAYER(targ))
    {
        backtrace("Obituary called on non-player?!\n");
        return;
    }
 
    // Declarations
    float notif_firstblood = false;
    float kill_count_to_attacker, kill_count_to_target;
    bool notif_anonymous = false;
    string attacker_name = attacker.netname;
 
    // Set final information for the death
    targ.death_origin = targ.origin;
    string deathlocation = (autocvar_notification_server_allows_location ? NearestLocation(targ.death_origin) : "");
 
    // Abort now if a mutator requests it
    if (MUTATOR_CALLHOOK(ClientObituary, inflictor, attacker, targ, deathtype, attacker.(weaponentity)))
    {
        CS(targ).killcount = 0;
        return;
    }
    notif_anonymous = M_ARGV(5, bool);
 
    // TODO: Replace "???" with a translatable "Anonymous player" string
    // https://gitlab.com/xonotic/xonotic-data.pk3dir/-/issues/2839
    if (notif_anonymous)
        attacker_name = "???";
 
    #ifdef NOTIFICATIONS_DEBUG
    Debug_Notification(sprintf(
        "Obituary(%s, %s, %s, %s = %d);\n",
        attacker_name,
        inflictor.netname,
        targ.netname,
        Deathtype_Name(deathtype),
        deathtype
    ));
    #endif
 
    // =======
    // SUICIDE
    // =======
    if (targ == attacker)
    {
        if (DEATH_ISSPECIAL(deathtype))
        {
            if (deathtype == DEATH_TEAMCHANGE.m_id || deathtype == DEATH_AUTOTEAMCHANGE.m_id)
                Obituary_SpecialDeath(targ, false, false, deathtype, targ.netname, deathlocation, "", "", targ.team, 0, 0);
            else
            {
                switch (DEATH_ENT(deathtype))
                {
                    case DEATH_MIRRORDAMAGE:
                        Obituary_SpecialDeath(targ, false, false, deathtype, targ.netname, deathlocation, "", "", CS(targ).killcount, 0, 0);
                        break;
                    case DEATH_HURTTRIGGER:
                    {
                        bool msg_from_ent = (inflictor && inflictor.message != "");
                        Obituary_SpecialDeath(targ, false, msg_from_ent, deathtype,
                            targ.netname,
                            (msg_from_ent ? inflictor.message : deathlocation),
                            (msg_from_ent ? deathlocation : ""),
                            "", CS(targ).killcount, 0, 0
                        );
                        break;
                    }
                    default:
                        Obituary_SpecialDeath(targ, false, false, deathtype, targ.netname, deathlocation, "", "", CS(targ).killcount, 0, 0);
                        break;
                }
            }
        }
        else if (!Obituary_WeaponDeath(targ, false, deathtype, targ.netname, deathlocation, "", CS(targ).killcount, 0))
        {
            backtrace("SUICIDE: what the hell happened here?\n");
            return;
        }
        LogDeath("suicide", deathtype, targ, targ);
        if (deathtype != DEATH_AUTOTEAMCHANGE.m_id) // special case: don't negate frags if auto switched
            GiveFrags(attacker, targ, -1, deathtype, weaponentity);
    }
 
    // ======
    // MURDER
    // ======
    else if (IS_PLAYER(attacker))
    {
        if (SAME_TEAM(attacker, targ))
        {
            LogDeath("tk", deathtype, attacker, targ);
            GiveFrags(attacker, targ, -1, deathtype, weaponentity);
 
            CS(attacker).killcount = 0;
 
            Send_Notification(NOTIF_ONE, attacker, MSG_CENTER, CENTER_DEATH_TEAMKILL_FRAG, targ.netname);
            Send_Notification(NOTIF_ONE, targ, MSG_CENTER, CENTER_DEATH_TEAMKILL_FRAGGED, attacker_name);
            Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_TEAM_NUM(targ.team, INFO_DEATH_TEAMKILL), targ.netname, attacker_name, deathlocation, CS(targ).killcount);
 
            // In this case, the death message will ALWAYS be "foo was betrayed by bar"
            // No need for specific death/weapon messages...
        }
        else
        {
            LogDeath("frag", deathtype, attacker, targ);
            GiveFrags(attacker, targ, 1, deathtype, weaponentity);
 
            CS(attacker).taunt_soundtime = time + 1;
            ++CS(attacker).killcount;
 
            ++attacker.killsound;
 
            // TODO: improve SPREE_ITEM and KILL_SPREE_LIST
            // these 2 macros are spread over multiple files
            #define SPREE_ITEM(counta,countb,center,normal,gentle) \
                case counta: \
                    Send_Notification(NOTIF_ONE, attacker, MSG_ANNCE, ANNCE_KILLSTREAK_##countb); \
                    if (!warmup_stage) \
                        PlayerStats_GameReport_Event_Player(attacker, PLAYERSTATS_ACHIEVEMENT_KILL_SPREE_##counta, 1); \
                    break;
 
            switch (CS(attacker).killcount)
            {
                KILL_SPREE_LIST
                default:
                    break;
            }
            #undef SPREE_ITEM
 
            if (!warmup_stage && !checkrules_firstblood)
            {
                checkrules_firstblood = true;
                notif_firstblood = true; // modify the current messages so that they too show firstblood information
                PlayerStats_GameReport_Event_Player(attacker, PLAYERSTATS_ACHIEVEMENT_FIRSTBLOOD, 1);
                PlayerStats_GameReport_Event_Player(targ, PLAYERSTATS_ACHIEVEMENT_FIRSTVICTIM, 1);
 
                // tell spree_inf and spree_cen that this is a first-blood and first-victim event
                kill_count_to_attacker = -1;
                kill_count_to_target = -2;
            }
            else
            {
                kill_count_to_attacker = CS(attacker).killcount;
                kill_count_to_target = 0;
            }
 
            if (targ.istypefrag)
            {
                Send_Notification(
                    NOTIF_ONE,
                    attacker,
                    MSG_CHOICE,
                    CHOICE_TYPEFRAG,
                    targ.netname,
                    kill_count_to_attacker,
                    (IS_BOT_CLIENT(targ) ? -1 : CS(targ).ping)
                );
                Send_Notification(
                    NOTIF_ONE,
                    targ,
                    MSG_CHOICE,
                    CHOICE_TYPEFRAGGED,
                    attacker_name,
                    kill_count_to_target,
                    GetResource(attacker, RES_HEALTH),
                    GetResource(attacker, RES_ARMOR),
                    (IS_BOT_CLIENT(attacker) ? -1 : CS(attacker).ping)
                );
            }
            else if (!frag_centermessage_override(attacker, targ, deathtype, kill_count_to_attacker, kill_count_to_target, attacker_name))
            {
                Send_Notification(
                    NOTIF_ONE,
                    attacker,
                    MSG_CHOICE,
                    CHOICE_FRAG,
                    targ.netname,
                    kill_count_to_attacker,
                    (IS_BOT_CLIENT(targ) ? -1 : CS(targ).ping)
                );
                Send_Notification(
                    NOTIF_ONE,
                    targ,
                    MSG_CHOICE,
                    CHOICE_FRAGGED,
                    attacker_name,
                    kill_count_to_target,
                    GetResource(attacker, RES_HEALTH),
                    GetResource(attacker, RES_ARMOR),
                    (IS_BOT_CLIENT(attacker) ? -1 : CS(attacker).ping)
                );
            }
 
            if (!Obituary_WeaponDeath(targ, true, deathtype, targ.netname, attacker_name, deathlocation, CS(targ).killcount, kill_count_to_attacker))
            {
                bool msg_from_ent = (DEATH_ENT(deathtype) == DEATH_HURTTRIGGER && inflictor && inflictor.message2 != "");
                Obituary_SpecialDeath(targ, true, msg_from_ent, deathtype,
                    targ.netname,
                    attacker_name,
                    (msg_from_ent ? inflictor.message2 : deathlocation),
                    (msg_from_ent ? deathlocation : ""),
                    CS(targ).killcount, kill_count_to_attacker, 0
                );
            }
        }
    }
 
    // =============
    // ACCIDENT/TRAP
    // =============
    else
    {
        switch (DEATH_ENT(deathtype))
        {
            // For now, we're just forcing HURTTRIGGER to behave as "DEATH_VOID" and giving it no special options...
            // Later on you will only be able to make custom messages using DEATH_CUSTOM,
            // and there will be a REAL DEATH_VOID implementation which mappers will use.
            case DEATH_HURTTRIGGER:
            {
                bool msg_from_ent = (inflictor && inflictor.message != "");
                Obituary_SpecialDeath(targ, false, msg_from_ent, deathtype,
                    targ.netname,
                    (msg_from_ent ? inflictor.message : deathlocation),
                    (msg_from_ent ? deathlocation : ""),
                    "",
                    CS(targ).killcount, 0, 0
                );
                break;
            }
            case DEATH_CUSTOM:
                Obituary_SpecialDeath(targ, false, false, deathtype,
                    targ.netname,
                    ((strstrofs(deathmessage, "%", 0) < 0) ? strcat("%s ", deathmessage) : deathmessage),
                    deathlocation,
                    "",
                    CS(targ).killcount, 0, 0
                );
                break;
            default:
                Obituary_SpecialDeath(targ, false, false, deathtype, targ.netname, deathlocation, "", "", CS(targ).killcount, 0, 0);
                break;
        }
 
        LogDeath("accident", deathtype, targ, targ);
        GiveFrags(targ, targ, -1, deathtype, weaponentity);
 
        if (GameRules_scoring_add(targ, SCORE, 0) == -5)
        {
            Send_Notification(NOTIF_ONE, targ, MSG_ANNCE, ANNCE_ACHIEVEMENT_BOTLIKE);
            if (!warmup_stage)
                PlayerStats_GameReport_Event_Player(attacker, PLAYERSTATS_ACHIEVEMENT_BOTLIKE, 1);
        }
    }
 
    // reset target kill count
    CS(targ).killcount = 0;
}

References APP_TEAM_NUM, autocvar_notification_server_allows_location, backtrace, checkrules_firstblood, CS(), DEATH_ENT, DEATH_ISSPECIAL, deathmessage, Deathtype_Name(), entity(), frag_centermessage_override(), GameRules_scoring_add, GetResource(), GiveFrags(), IS_BOT_CLIENT, IS_PLAYER, KILL_SPREE_LIST, killcount, LogDeath(), M_ARGV, MUTATOR_CALLHOOK, NearestLocation(), NULL, Obituary_SpecialDeath(), Obituary_WeaponDeath(), ping, PLAYERSTATS_ACHIEVEMENT_BOTLIKE, PLAYERSTATS_ACHIEVEMENT_FIRSTBLOOD, PLAYERSTATS_ACHIEVEMENT_FIRSTVICTIM, PlayerStats_GameReport_Event_Player, RES_ARMOR, SAME_TEAM, Send_Notification(), strcat(), strstrofs, time, and warmup_stage.

Referenced by PlayerDamage().

Obituary_SpecialDeath()

void Obituary_SpecialDeath	(	entity	notif_target,
		bool	murder,
		bool	msg_from_ent,
		int	deathtype,
		string	s1,
		string	s2,
		string	s3,
		string	s4,
		float	f1,
		float	f2,
		float	f3 )

Definition at line 118 of file damage.qc.

{
    if (!DEATH_ISSPECIAL(deathtype))
    {
        backtrace("Obituary_SpecialDeath called without a special deathtype?\n");
        return;
    }
 
    entity deathent = REGISTRY_GET(Deathtypes, deathtype - DT_FIRST);
    if (!deathent)
    {
        backtrace("Obituary_SpecialDeath: Could not find deathtype entity!\n");
        return;
    }
 
    if ((g_cts || notif_target.killindicator_teamchange == -2) && deathtype == DEATH_KILL.m_id)
        return; // TODO: somehow put this in CTS gametype file!
 
    Notification death_message = (msg_from_ent)
        ? (murder ? deathent.death_msg_ent_murder : deathent.death_msg_ent_self)
        : (murder ? deathent.death_msgmurder : deathent.death_msgself);
    if (death_message)
    {
        Send_Notification_Core(
            NOTIF_ONE,
            notif_target,
            MSG_MULTI,
            death_message,
            s1, s2, s3, s4,
            f1, f2, f3, 0
        );
        Send_Notification_Core(
            NOTIF_ALL_EXCEPT,
            notif_target,
            MSG_INFO,
            death_message.nent_msginfo,
            s1, s2, s3, s4,
            f1, f2, f3, 0
        );
    }
}

References backtrace, DEATH_ISSPECIAL, DT_FIRST, entity(), f1, f2, g_cts, REGISTRY_GET, s1, s2, and Send_Notification_Core().

Referenced by Obituary().

Obituary_WeaponDeath()

float Obituary_WeaponDeath	(	entity	notif_target,
		float	murder,
		int	deathtype,
		string	s1,
		string	s2,
		string	s3,
		float	f1,
		float	f2 )

References entity(), f1, f2, s1, and s2.

RadiusDamage()

float RadiusDamage	(	entity	inflictor,
		entity	attacker,
		float	coredamage,
		float	edgedamage,
		float	rad,
		entity	cantbe,
		entity	mustbe,
		float	forceintensity,
		int	deathtype,
		.entity	weaponentity,
		entity	directhitentity )

Definition at line 937 of file damage.qc.

{
    return RadiusDamageForSource(
        inflictor, (inflictor.origin + (inflictor.mins + inflictor.maxs) * 0.5), inflictor.velocity, attacker,
        coredamage, edgedamage, rad, cantbe, mustbe,
        false, forceintensity, '1 1 1',
        deathtype, weaponentity, directhitentity
    );
}

References entity(), and RadiusDamageForSource().

Referenced by bumblebee_blowup(), CheatImpulse(), func_breakable_destroy(), M_Golem_Attack_Lightning_Explode(), M_Golem_Attack_Smash(), M_Mage_Attack_Push(), M_Mage_Attack_Spike_Explode(), M_Spider_Attack_Web_Explode(), M_Wyvern_Attack_Fireball_Explode(), nade_normal_boom(), PlayerTouchExplode(), racer_blowup(), raptor_blowup(), raptor_bomblet_boom(), spiderbot_blowup(), turret_flac_projectile_think_explode(), turret_projectile_explode(), vehicles_projectile_explode(), W_Arc_Bolt_Explode(), W_Arc_Bolt_Touch(), W_Crylink_LinkExplode(), W_Crylink_LinkJoinEffect_Think(), W_Crylink_Touch(), W_DamageOverTime_Think(), W_Devastator_DoRemoteExplode(), W_Electro_Explode(), W_Electro_ExplodeCombo(), W_Fireball_Explode(), W_Hagar_Explode(), W_Hagar_Explode2(), W_HLAC_Touch(), W_MineLayer_DoRemoteExplode(), W_MineLayer_Explode(), W_Mortar_Grenade_Explode(), W_Mortar_Grenade_Explode2(), W_OverkillRocketPropelledChainsaw_Explode(), W_RocketMinsta_Explosion(), W_RocketMinsta_Laser_Damage(), W_Seeker_Flac_Explode(), W_Seeker_Missile_Explode(), W_Tuba_NoteOn(), and walker_rocket_explode().

RadiusDamageForSource()

float RadiusDamageForSource	(	entity	inflictor,
		vector	inflictororigin,
		vector	inflictorvelocity,
		entity	attacker,
		float	coredamage,
		float	edgedamage,
		float	rad,
		entity	cantbe,
		entity	mustbe,
		bool	inflictorselfdamage,
		float	forceintensity,
		vector	forcexyzscale,
		int	deathtype,
		.entity	weaponentity,
		entity	directhitentity )

Returns total damage applied to creatures.

Definition at line 714 of file damage.qc.

{
    if (RadiusDamage_running)
    {
        backtrace("RadiusDamage called recursively! Expect stuff to go HORRIBLY wrong.");
        return 0;
    }
 
    if (rad < 0)
        rad = 0;
 
    RadiusDamage_running = true;
 
    float tfloordmg = autocvar_g_throughfloor_damage;
    float tfloorforce = autocvar_g_throughfloor_force;
 
    float stat_damagedone = 0;
    float total_damage_to_creatures = 0;
 
    vector force;
    if (!(deathtype & (HITTYPE_SOUND | HITTYPE_SPAM))) // do not send bandwidth-hogging radial spam attacks
    {
        force = inflictorvelocity;
        if (force == '0 0 0')
            force = '0 0 -1';
        else
            force = normalize(force);
        if (forceintensity >= 0)
            Damage_DamageInfo(inflictororigin, coredamage, edgedamage, rad, forceintensity * force, deathtype, 0, attacker);
        else
            Damage_DamageInfo(inflictororigin, coredamage, edgedamage, -rad, (-forceintensity) * force, deathtype, 0, attacker);
    }
 
    RadiusDamageForSource_cond_inflictor = inflictor;
    RadiusDamageForSource_cond_cantbe = cantbe;
    RadiusDamageForSource_cond_mustbe = mustbe;
    RadiusDamageForSource_cond_inflictorselfdamage = inflictorselfdamage;
    entity targ = WarpZone_SearchInRadius(inflictororigin, rad + MAX_DAMAGEEXTRARADIUS, MOVE_NOTHING, RadiusDamageForSource_cond);
    for (; targ; targ = targ.chain)
    {
        // calculate distance from nearest point on target to nearest point on inflictor
        // instead of origin to ensure full damage on impacts
 
        vector nearest = targ.WarpZone_findradius_nearest;
 
        // optimize code by getting inflictororigin_wz from WarpZone_FindRadius calculations instead of
        //vector inflictororigin_wz = WarpZone_TransformOrigin(targ, inflictororigin);
 
        vector inflictororigin_wz = targ.WarpZone_findradius_nearest + targ.WarpZone_findradius_dist;
        vector inflictornearest = NearestPointOnBoundingBox(
            inflictororigin_wz + inflictor.mins, inflictororigin_wz + inflictor.maxs, nearest);
        vector diff = inflictornearest - nearest;
 
        // round up a little on the damage to ensure full damage on impacts
        // and turn the distance into a fraction of the radius
        float dist = max(0, vlen(diff) - bound(MIN_DAMAGEEXTRARADIUS, targ.damageextraradius, MAX_DAMAGEEXTRARADIUS));
        if (dist > rad)
            continue;
 
 
        float f = (rad > 0) ? 1 - (dist / rad) : 1;
        // at this point f can't be < 0 or > 1
        float finaldmg = coredamage * f + edgedamage * (1 - f);
        if (finaldmg <= 0)
            continue;
 
 
        vector hitloc;
        float a, c;
 
        // if it's a player, use the view origin as reference
        vector center = CENTER_OR_VIEWOFS(targ);
 
        if (autocvar_g_player_damageplayercenter)
        {
            if (targ != attacker) // always use target's bbox centerpoint
                center = targ.origin + ((targ.mins + targ.maxs) * 0.5);
            else // targ == attacker
            {
            #if 0
                // code stolen from W_SetupShot_Dir_ProjectileSize_Range()
                vector md = targ.(weaponentity).movedir;
                vector dv = v_right * -md.y + v_up * md.z;
                vector mi = '0 0 0', ma = '0 0 0';
 
                if (IS_CLIENT(targ)) // no antilag for non-clients!
                    tracebox_antilag(targ, center, mi, ma, center + dv, MOVE_NORMAL, targ, (CS(targ).antilag_debug ? CS(targ).antilag_debug : ANTILAG_LATENCY(targ));
                else
                    tracebox(center, mi, ma, center + dv, MOVE_NORMAL, targ);
 
                center.z = trace_endpos.z;
            #else
                // very cheap way but it skips move into solid checks which is fine most of the time for now AFAIK
                // this should only really be an issue with some rare edge cases where
                // shot origin was prevented from going into a ceiling but it still explodes at the ceiling
                // shot origin wasn't raised as high as possible and the shooter gets upwards knockback
                // TL;DR: no bugs if vertical shot origin is always within player bbox
                center.z += targ.(weaponentity).movedir.z;
            #endif
            }
        }
 
        /* debug prints
        print(sprintf("origin  vec %v\n", targ.origin));
        print(sprintf("movedir vec %v\n", targ.(weaponentity).movedir));
        print(sprintf("old def vec %v\n", CENTER_OR_VIEWOFS(targ)));
        print(sprintf("origin+vofs %v\n", targ.origin + targ.view_ofs));
        print(sprintf("bbox center %v\n", (targ.origin + ((targ.mins + targ.maxs) * 0.5))));
        print(sprintf("center  vec %v\n", center));
        print(sprintf("shotorg vec %v\n", w_shotorg));
        print("\n");
        */
 
        force = normalize(center - inflictororigin_wz);
        force *= (finaldmg / max(coredamage, edgedamage)) * forceintensity;
        hitloc = nearest;
 
        // apply special force scalings
        if (forcexyzscale.x)
            force.x *= forcexyzscale.x;
        if (forcexyzscale.y)
            force.y *= forcexyzscale.y;
        if (forcexyzscale.z)
            force.z *= forcexyzscale.z;
 
        if (targ != directhitentity)
        {
            float hits;
            float total;
            float hitratio;
            float mininv_f, mininv_d;
 
            // test line of sight to multiple positions on box,
            // and do damage if any of them hit
            hits = 0;
 
            // we know: max stddev of hitratio = 1 / (2 * sqrt(n))
            // so for a given max stddev:
            // n = (1 / (2 * max stddev of hitratio))^2
 
            mininv_d = (finaldmg * (1-tfloordmg)) / autocvar_g_throughfloor_damage_max_stddev;
            mininv_f = (vlen(force) * (1-tfloorforce)) / autocvar_g_throughfloor_force_max_stddev;
 
            if (autocvar_g_throughfloor_debug)
                LOG_INFOF("THROUGHFLOOR: D=%f F=%f max(dD)=1/%f max(dF)=1/%f", finaldmg, vlen(force), mininv_d, mininv_f);
 
            total = 0.25 * (max(mininv_f, mininv_d) ** 2);
 
            if (autocvar_g_throughfloor_debug)
                LOG_INFOF(" steps=%f", total);
 
            if (IS_PLAYER(targ))
                total = ceil(bound(autocvar_g_throughfloor_min_steps_player, total, autocvar_g_throughfloor_max_steps_player));
            else
                total = ceil(bound(autocvar_g_throughfloor_min_steps_other, total, autocvar_g_throughfloor_max_steps_other));
 
            if (autocvar_g_throughfloor_debug)
                LOG_INFOF(" steps=%f dD=%f dF=%f", total, finaldmg * (1-tfloordmg) / (2 * sqrt(total)), vlen(force) * (1-tfloorforce) / (2 * sqrt(total)));
 
            for (c = 0; c < total; ++c)
            {
                //traceline(targ.WarpZone_findradius_findorigin, nearest, MOVE_NOMONSTERS, inflictor);
                WarpZone_TraceLine(inflictororigin, WarpZone_UnTransformOrigin(targ, nearest), MOVE_NOMONSTERS, inflictor);
                if (trace_fraction == 1 || trace_ent == targ)
                {
                    ++hits;
                    if (hits > 1)
                        hitloc += nearest;
                    else
                        hitloc = nearest;
                }
                nearest.x = targ.origin.x + targ.mins.x + random() * targ.size.x;
                nearest.y = targ.origin.y + targ.mins.y + random() * targ.size.y;
                nearest.z = targ.origin.z + targ.mins.z + random() * targ.size.z;
            }
 
            nearest = hitloc * (1 / max(1, hits));
            hitratio = hits / total;
            a = bound(0, tfloordmg + (1 - tfloordmg) * hitratio, 1);
            finaldmg *= a;
            a = bound(0, tfloorforce + (1 - tfloorforce) * hitratio, 1);
            force *= a;
 
            if (autocvar_g_throughfloor_debug)
                LOG_INFOF(" D=%f F=%f", finaldmg, vlen(force));
 
            /*if (targ == attacker)
            {
                print("hits ", ftos(hits), " / ", ftos(total));
                print(" finaldmg ", ftos(finaldmg), " force ", ftos(vlen(force)));
                print(" (", vtos(force), ") (", ftos(a), ")\n");
            }*/
        }
 
        if (finaldmg || force)
        {
            if (targ.iscreature)
            {
                total_damage_to_creatures += finaldmg;
 
                if (accuracy_isgooddamage(attacker, targ))
                    stat_damagedone += finaldmg;
            }
 
            if (targ == directhitentity || DEATH_ISSPECIAL(deathtype))
                Damage(targ, inflictor, attacker, finaldmg, deathtype, weaponentity, nearest, force);
            else
                Damage(targ, inflictor, attacker, finaldmg, deathtype | HITTYPE_SPLASH, weaponentity, nearest, force);
        }
    }
 
    RadiusDamage_running = false;
 
    if (!DEATH_ISSPECIAL(deathtype))
        accuracy_add(attacker, DEATH_WEAPONOF(deathtype), 0, min(max(coredamage, edgedamage), stat_damagedone), 0); // add to hit
 
    return total_damage_to_creatures;
}

References accuracy_add(), accuracy_isgooddamage(), antilag_debug, ANTILAG_LATENCY, autocvar_g_player_damageplayercenter, autocvar_g_throughfloor_damage, autocvar_g_throughfloor_damage_max_stddev, autocvar_g_throughfloor_debug, autocvar_g_throughfloor_force, autocvar_g_throughfloor_force_max_stddev, autocvar_g_throughfloor_max_steps_other, autocvar_g_throughfloor_max_steps_player, autocvar_g_throughfloor_min_steps_other, autocvar_g_throughfloor_min_steps_player, backtrace, bound(), ceil(), CENTER_OR_VIEWOFS, CS(), Damage(), Damage_DamageInfo(), DEATH_ISSPECIAL, DEATH_WEAPONOF, entity(), HITTYPE_SOUND, HITTYPE_SPAM, HITTYPE_SPLASH, IS_CLIENT, IS_PLAYER, LOG_INFOF, max(), MAX_DAMAGEEXTRARADIUS, min(), MIN_DAMAGEEXTRARADIUS, MOVE_NOMONSTERS, MOVE_NORMAL, MOVE_NOTHING, movedir, NearestPointOnBoundingBox(), normalize(), RadiusDamage_running, RadiusDamageForSource_cond(), RadiusDamageForSource_cond_cantbe, RadiusDamageForSource_cond_inflictor, RadiusDamageForSource_cond_inflictorselfdamage, RadiusDamageForSource_cond_mustbe, random(), sqrt(), trace_endpos, trace_ent, trace_fraction, tracebox_antilag(), v_right, v_up, vector, vlen(), WarpZone_SearchInRadius(), WarpZone_TraceLine, and WarpZone_UnTransformOrigin().

Referenced by RadiusDamage(), W_Blaster_Touch(), and W_Devastator_Explode().

STATIC_INIT()

STATIC_INIT

(

g_damagedbycontents

)

Definition at line 144 of file damage.qh.

{
    g_damagedbycontents = IL_NEW();
}

References g_damagedbycontents, and IL_NEW.

void()

void	(	entity	this,
		entity	inflictor,
		entity	attacker,
		float	damage,
		int	deathtype,
		.entity	weaponentity,
		vector	hitloc,
		vector	force )

References entity(), and vector.

W_SwitchWeapon_Force()

void W_SwitchWeapon_Force	(	Player	this,
		Weapon	w,
		.entity	weaponentity )

Definition at line 237 of file selection.qc.

{
    TC(Weapon, wep);
    entity w_ent = this.(weaponentity);
    w_ent.cnt = w_ent.m_switchweapon.m_id;
    w_ent.m_switchweapon = wep;
    w_ent.selectweapon = wep.m_id;
}

References entity(), Weapon::m_id, and TC.

Referenced by GiveItems(), Item_GiveTo(), MUTATOR_HOOKFUNCTION(), TEST(), W_Hagar_Attack_Auto(), W_HLAC_Attack_Frame(), W_MachineGun_Attack_Auto(), W_MachineGun_Attack_Frame(), W_OverkillHeavyMachineGun_Attack_Auto(), W_OverkillMachineGun_Attack_Auto(), W_Shotgun_Attack3_Frame1(), W_Shotgun_Attack3_Frame2(), W_ThrowWeapon(), and W_WeaponFrame().

Variable Documentation

autocvar_g_balance_armor_blockpercent

float autocvar_g_balance_armor_blockpercent

Definition at line 21 of file damage.qh.

Referenced by ClientInit_CheckUpdate(), ctf_FlagcarrierWaypoints(), Damage(), if(), MUTATOR_HOOKFUNCTION(), PlayerCorpseDamage(), PlayerDamage(), PlayerFrame(), and WaypointSprite_AttachCarrier().

autocvar_g_balance_damagepush_speedfactor

float autocvar_g_balance_damagepush_speedfactor

Definition at line 18 of file damage.qh.

Referenced by ClientInit_CheckUpdate(), Damage(), and MUTATOR_HOOKFUNCTION().

autocvar_g_balance_firetransfer_damage

int autocvar_g_balance_firetransfer_damage

Definition at line 19 of file damage.qh.

autocvar_g_balance_firetransfer_time

int autocvar_g_balance_firetransfer_time

Definition at line 20 of file damage.qh.

autocvar_g_balance_selfdamagepercent

float autocvar_g_balance_selfdamagepercent

Definition at line 25 of file damage.qh.

Referenced by Damage().

autocvar_g_friendlyfire

float autocvar_g_friendlyfire

Definition at line 26 of file damage.qh.

Referenced by Damage(), MUTATOR_HOOKFUNCTION(), and turret_damage().

autocvar_g_friendlyfire_virtual

float autocvar_g_friendlyfire_virtual

Definition at line 27 of file damage.qh.

Referenced by Damage().

autocvar_g_friendlyfire_virtual_force

float autocvar_g_friendlyfire_virtual_force

Definition at line 28 of file damage.qh.

Referenced by Damage().

autocvar_g_maxpushtime

float autocvar_g_maxpushtime

Definition at line 17 of file damage.qh.

Referenced by GrapplingHook_Damage(), GrapplingHookThink(), MUTATOR_HOOKFUNCTION(), PlayerDamage(), Portal_TeleportPlayer(), and TeleportPlayer().

autocvar_g_mirrordamage

float autocvar_g_mirrordamage

Definition at line 14 of file damage.qh.

Referenced by Damage().

autocvar_g_mirrordamage_onlyweapons

bool autocvar_g_mirrordamage_onlyweapons

Definition at line 16 of file damage.qh.

Referenced by Damage().

autocvar_g_mirrordamage_virtual

bool autocvar_g_mirrordamage_virtual

Definition at line 15 of file damage.qh.

Referenced by Damage().

autocvar_g_player_damageplayercenter

int autocvar_g_player_damageplayercenter

Definition at line 106 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_teamdamage_resetspeed

float autocvar_g_teamdamage_resetspeed

Definition at line 22 of file damage.qh.

Referenced by PlayerThink().

autocvar_g_teamdamage_threshold

float autocvar_g_teamdamage_threshold

Definition at line 23 of file damage.qh.

Referenced by Damage().

autocvar_g_teamkill_punishing

bool autocvar_g_teamkill_punishing

Definition at line 24 of file damage.qh.

Referenced by GiveFrags().

autocvar_g_throughfloor_damage

float autocvar_g_throughfloor_damage

Definition at line 6 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_damage_max_stddev

float autocvar_g_throughfloor_damage_max_stddev

Definition at line 8 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_debug

bool autocvar_g_throughfloor_debug

Definition at line 5 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_force

float autocvar_g_throughfloor_force

Definition at line 7 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_force_max_stddev

float autocvar_g_throughfloor_force_max_stddev

Definition at line 9 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_max_steps_other

float autocvar_g_throughfloor_max_steps_other

Definition at line 13 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_max_steps_player

float autocvar_g_throughfloor_max_steps_player

Definition at line 11 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_min_steps_other

float autocvar_g_throughfloor_min_steps_other

Definition at line 12 of file damage.qh.

Referenced by RadiusDamageForSource().

autocvar_g_throughfloor_min_steps_player

float autocvar_g_throughfloor_min_steps_player

Definition at line 10 of file damage.qh.

Referenced by RadiusDamageForSource().

canteamdamage

bool canteamdamage

Definition at line 65 of file damage.qh.

Referenced by spawnfunc().

checkrules_firstblood

float checkrules_firstblood

Definition at line 43 of file damage.qh.

Referenced by Obituary().

damagedbycontents

float damagedbycontents

Definition at line 45 of file damage.qh.

Referenced by CopyBody(), ka_TouchEvent(), Monster_Spawn(), PlayerCorpseDamage(), PutObserverInServer(), PutPlayerInServer(), respawn(), vehicle_initialize(), vehicles_spawn(), and W_Electro_Attack_Orb().

damagedbytriggers

float damagedbytriggers

Definition at line 46 of file damage.qh.

damageextraradius

float damageextraradius

Definition at line 128 of file damage.qh.

damageforcescale

float damageforcescale

Definition at line 125 of file damage.qh.

death_origin

vector death_origin

Definition at line 67 of file damage.qh.

Referenced by formatmessage(), IMPULSE(), IMPULSE(), and IMPULSE().

deathmessage

string deathmessage

Definition at line 73 of file damage.qh.

Referenced by Obituary().

dmg

float dmg

Definition at line 34 of file damage.qh.

dmg_edge

float dmg_edge

Definition at line 35 of file damage.qh.

dmg_force

float dmg_force

Definition at line 36 of file damage.qh.

dmg_radius

float dmg_radius

Definition at line 37 of file damage.qh.

dmg_team

float dmg_team

Definition at line 53 of file damage.qh.

Referenced by PlayerThink(), and PutPlayerInServer().

fire_damagepersec

float fire_damagepersec

Definition at line 134 of file damage.qh.

fire_deathtype

float fire_deathtype

Definition at line 135 of file damage.qh.

fire_hitsound

float fire_hitsound

Definition at line 137 of file damage.qh.

fire_owner

entity fire_owner

Definition at line 136 of file damage.qh.

g_damagedbycontents

IntrusiveList g_damagedbycontents

Definition at line 143 of file damage.qh.

Referenced by CopyBody(), CreatureFrame_All(), ctf_Handle_Drop(), ctf_Handle_Pickup(), ctf_RespawnFlag(), Fire_ApplyDamage(), FireGrapplingHook(), ka_DropEvent(), ka_SpawnBalls(), ka_TouchEvent(), M_Golem_Attack_Lightning(), M_Spider_Attack_Web(), Monster_Spawn(), MUTATOR_HOOKFUNCTION(), PlayerCorpseDamage(), PutObserverInServer(), PutPlayerInServer(), STATIC_INIT(), toss_nade(), turret_hk_missile_think(), vehicle_initialize(), W_Arc_Attack_Bolt(), W_Devastator_Attack(), W_Electro_Attack_Orb(), W_Electro_Orb_Stick(), W_Hagar_Attack(), W_Hagar_Attack2(), W_Hagar_Attack2_Load_Release(), W_Hook_Attack2(), W_MineLayer_Attack(), W_MineLayer_Stick(), W_Mortar_Attack(), W_Mortar_Attack2(), W_OverkillRocketPropelledChainsaw_Attack(), and W_Seeker_Fire_Missile().

hitsound_damage_dealt

float hitsound_damage_dealt

Definition at line 69 of file damage.qh.

impressive_hits

int impressive_hits

Definition at line 49 of file damage.qh.

Referenced by Damage(), W_OverkillNex_Attack(), W_Vaporizer_Attack(), and W_Vortex_Attack().

istypefrag

bool istypefrag

Definition at line 58 of file damage.qh.

killsound

int killsound

Definition at line 70 of file damage.qh.

MAX_DAMAGEEXTRARADIUS

const float MAX_DAMAGEEXTRARADIUS = 16

Definition at line 127 of file damage.qh.

MIN_DAMAGEEXTRARADIUS

const float MIN_DAMAGEEXTRARADIUS = 0.1

Definition at line 126 of file damage.qh.

pain_finished

float pain_finished

Definition at line 51 of file damage.qh.

pusher

entity pusher

Definition at line 57 of file damage.qh.

RadiusDamage_running

bool RadiusDamage_running

Definition at line 111 of file damage.qh.

Referenced by RadiusDamageForSource().

spawnshieldtime

float spawnshieldtime

Definition at line 61 of file damage.qh.

Referenced by Item_Touch(), nade_touch(), W_Devastator_RemoteExplode(), W_Electro_Orb_Stick(), W_MineLayer_RemoteExplode(), W_MineLayer_Stick(), and W_Tuba_NoteOff().

taunt_soundtime

float taunt_soundtime

Definition at line 59 of file damage.qh.

Referenced by PlayerPreThink().

teamkill_complain

float teamkill_complain

Definition at line 54 of file damage.qh.

Referenced by Damage(), and W_Nexball_Touch().

teamkill_soundsource

entity teamkill_soundsource

Definition at line 56 of file damage.qh.

teamkill_soundtime

float teamkill_soundtime

Definition at line 55 of file damage.qh.

Referenced by PlayerPreThink().

totalfrags

int totalfrags

Definition at line 63 of file damage.qh.

typehitsound

int typehitsound

Definition at line 70 of file damage.qh.

w_deathtype

float w_deathtype

Definition at line 93 of file damage.qh.

yoda

float yoda

Definition at line 48 of file damage.qh.

Referenced by Damage(), fireBullet_falloff(), MUTATOR_HOOKFUNCTION(), W_OverkillNex_Attack(), W_Vaporizer_Attack(), and W_Vortex_Attack().