common.qc File Reference

#include "common.qh"
#include <common/constants.qh>
#include <common/deathtypes/all.qh>
#include <common/items/_mod.qh>
#include <common/net_linked.qh>
#include <common/notifications/all.qh>
#include <common/state.qh>
#include <common/stats.qh>
#include <common/util.qh>
#include <common/weapons/_all.qh>
#include <common/wepent.qh>
#include <server/command/common.qh>
#include <server/damage.qh>
#include <server/hook.qh>
#include <server/items/items.qh>
#include <server/mutators/_mod.qh>
#include <server/weapons/csqcprojectile.qh>

Include dependency graph for common.qc:

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

Go to the source code of this file.

Functions
void	adaptor_think2use_hittype_splash (entity this)
bool	SUB_NoImpactCheck (entity this, entity toucher)
float	W_CheckProjectileDamage (entity inflictor, entity projowner, int deathtype, float exception)
void	W_DamageOverTime_Think (entity this, float duration, float duration_power, float damage, float edgedamage, float rad, float force, entity cantbe, float think_delay)
	Applies damage over time, called within a think function.
bool	W_DualWielding (entity player)
void	W_GiveWeapon (entity e, int wep)
void	W_GuideProjectile (entity this,.entity weaponentity, float guide_start_time, float guide_rate, float guide_rate_delay, float guide_goal, float guide_delay, entity eff, entity snd, float vol)
	Guides a projectile towards the crosshair (v_forward).
void	W_LaserPlay (entity this, float rad, float damage, float edgedamage, float burntime, WarpZone_FindRadius_cond_callback_t cb)
	Randomly chooses a player within the radius to shoot a laser towards.
void	W_LaserPlay_trace_callback (vector start, vector hit, vector end)
void	W_PlayStrengthSound (entity player)
void	W_PrepareExplosionByDamage (entity this, entity attacker, void(entity this) explode)
float	W_SeekOutEnemy (entity this, float speed_decel, float speed_accel, float speed_max, float turn_rate, bool smart, float smart_mindist, float smart_trace_min, float smart_trace_max)
	Automatically guides a projectile towards its enemy.
vector	W_SteerProjectileTo (vector thisdir, vector goaldir, float maxturn_cos)
bool	WarpZone_Projectile_Touch_ImpactFilter_Callback (entity this, entity toucher)

Variables
vector	W_LaserPlay_end_org
vector	W_LaserPlay_last_hit_org
float	wait

Function Documentation

adaptor_think2use_hittype_splash()

void adaptor_think2use_hittype_splash

(

entity

this

)

Definition at line 106 of file common.qc.

{
    if (!(IS_ONGROUND(this))) // if onground, we ARE touching something, but HITTYPE_SPLASH is to be networked if the damage causing projectile is not touching ANYTHING
        this.projectiledeathtype |= HITTYPE_SPLASH;
    adaptor_think2use(this);
}

References entity(), HITTYPE_SPLASH, IS_ONGROUND, and projectiledeathtype.

Referenced by M_Spider_Attack_Web(), W_Arc_Attack_Bolt(), W_Electro_Attack_Orb(), W_Electro_Orb_Follow_Think(), W_Electro_Orb_Stick(), W_Hagar_Attack(), W_Hagar_Attack2(), W_Hagar_Attack2_Load_Release(), W_Hook_Attack2(), W_Mortar_Attack2(), W_RocketMinsta_Attack(), and W_Seeker_Fire_Flac().

SUB_NoImpactCheck()

bool SUB_NoImpactCheck	(	entity	this,
		entity	toucher )

Definition at line 113 of file common.qc.

{
    // zero hitcontents = this is not the real impact, but either the
    // mirror-impact of something hitting the projectile instead of the
    // projectile hitting the something, or a touchareagrid one. Neither of
    // these stop the projectile from moving, so...
    // NOTE: this notice is disabled to prevent spam as projectiles can hit content-less objects (other projectiles!)
#if 0
    if (trace_dphitcontents == 0)
    {
        LOG_TRACEF("A hit from a projectile happened with no hit contents! DEBUG THIS, this should never happen for projectiles! Projectile will self-destruct. (edict: %i, classname: %s, origin: %v)", this, this.classname, this.origin);
        checkclient(this); // TODO: .health is checked in the engine with this, possibly replace with a QC function?
    }
#endif
    if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
        return true;
 
    if (toucher == NULL && this.size != '0 0 0')
    {
        vector tic = this.velocity * sys_frametime;
        tic += normalize(tic) * vlen(this.maxs - this.mins);
        traceline(this.origin - tic, this.origin + tic, MOVE_NORMAL, this);
        if (trace_fraction >= 1)
        {
            // NOTE: this notice can occur when projectiles hit non-world objects, better to not spam the console!
            //LOG_TRACE("Odd... did not hit...?");
        }
        else if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
        {
            LOG_TRACE("Detected and prevented the sky-grapple bug.");
            return true;
        }
    }
 
    return false;
}

References checkclient, classname, entity(), LOG_TRACE, LOG_TRACEF, maxs, mins, MOVE_NORMAL, normalize(), NULL, origin, Q3SURFACEFLAG_NOIMPACT, size, sys_frametime, toucher, trace_dphitcontents, trace_dphitq3surfaceflags, trace_fraction, vector, velocity, and vlen().

Referenced by WarpZone_Projectile_Touch_ImpactFilter_Callback().

W_CheckProjectileDamage()

float W_CheckProjectileDamage	(	entity	inflictor,
		entity	projowner,
		int	deathtype,
		float	exception )

Definition at line 45 of file common.qc.

{
    bool is_from_contents = (deathtype == DEATH_SLIME.m_id || deathtype == DEATH_LAVA.m_id);
    bool is_from_owner = (inflictor == projowner);
    bool is_from_exception = (exception != -1);
 
    //dprint(strcat("W_CheckProjectileDamage: from_contents ", ftos(is_from_contents), " : from_owner ", ftos(is_from_owner), " : exception ", strcat(ftos(is_from_exception), " (", ftos(exception), "). \n")));
 
    if (autocvar_g_projectiles_damage <= -2)
    {
        return false; // no damage to projectiles at all, not even with the exceptions
    }
    else if (autocvar_g_projectiles_damage == -1)
    {
        if (is_from_exception)
            return exception; // if exception is detected, allow it to override
        else
            return false; // otherwise, no other damage is allowed
    }
    else if (autocvar_g_projectiles_damage == 0)
    {
        if (is_from_exception)
            return exception; // if exception is detected, allow it to override
        else if (!is_from_contents)
            return false; // otherwise, only allow damage from contents
    }
    else if (autocvar_g_projectiles_damage == 1)
    {
        if (is_from_exception)
            return exception; // if exception is detected, allow it to override
        else if (!(is_from_contents || is_from_owner))
            return false; // otherwise, only allow self damage and damage from contents
    }
    else if (autocvar_g_projectiles_damage == 2) // allow any damage, but override for exceptions
    {
        if (is_from_exception)
            return exception; // if exception is detected, allow it to override
    }
 
    return true; // if none of these return, then allow damage anyway.
}

References autocvar_g_projectiles_damage, and entity().

Referenced by GrapplingHook_Damage(), M_Golem_Attack_Lightning_Damage(), W_Arc_Bolt_Damage(), W_Devastator_Damage(), W_Electro_Orb_Damage(), W_Fireball_Damage(), W_Hagar_Damage(), W_Hook_Damage(), W_MineLayer_Damage(), W_Mortar_Grenade_Damage(), W_OverkillRocketPropelledChainsaw_Damage(), and W_Seeker_Missile_Damage().

W_DamageOverTime_Think()

void W_DamageOverTime_Think	(	entity	this,
		float	duration,
		float	duration_power,
		float	damage,
		float	edgedamage,
		float	rad,
		float	force,
		entity	cantbe,
		float	think_delay )

Applies damage over time, called within a think function.

Definition at line 285 of file common.qc.

{
    float dt = time - this.teleport_time;
    float dmg_remaining_next = bound(0, 1 - dt / duration, 1) ** duration_power;
 
    float f = this.dmg_last - dmg_remaining_next;
    this.dmg_last = dmg_remaining_next;
 
    RadiusDamage(this, this.realowner,
        f * damage,
        f * edgedamage,
        rad,
        cantbe,
        NULL,
        f * force,
        this.projectiledeathtype,
        this.weaponentity_fld,
        NULL
    );
    this.projectiledeathtype |= HITTYPE_SPAM; // ensure it doesn't spam its effect
 
    if (dt < duration)
        this.nextthink = time + think_delay;
    else
        delete(this);
}

References bound(), dmg_last, entity(), HITTYPE_SPAM, nextthink, NULL, projectiledeathtype, RadiusDamage(), realowner, teleport_time, time, and weaponentity_fld.

Referenced by W_Electro_ExplodeComboThink(), and W_Hook_ExplodeThink().

W_DualWielding()

bool W_DualWielding

(

entity

player

)

Definition at line 20 of file common.qc.

{
    int held_weapons = 0;
    for (int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        .entity weaponentity = weaponentities[slot];
        if (player.(weaponentity) && player.(weaponentity).m_switchweapon != WEP_Null)
            ++held_weapons;
    }
 
    return held_weapons > 1;
}

References entity(), MAX_WEAPONSLOTS, and weaponentities.

Referenced by IMPULSE(), PlayerThink(), W_GuideProjectile(), W_ResetGunAlign(), W_SetupShot_Dir_ProjectileSize_Range(), and weapon_prepareattack_do().

W_GiveWeapon()

void W_GiveWeapon	(	entity	e,
		int	wep )

Definition at line 33 of file common.qc.

{
    if (!wep)
        return;
    STAT(WEAPONS, e) |= WepSet_FromWeapon(REGISTRY_GET(Weapons, wep));
}

References entity(), REGISTRY_GET, STAT, Weapons, and WepSet_FromWeapon.

Referenced by Item_GiveTo(), and TEST().

W_GuideProjectile()

void W_GuideProjectile	(	entity	this,
		.entity	weaponentity,
		float	guide_start_time,
		float	guide_rate,
		float	guide_rate_delay,
		float	guide_goal,
		float	guide_delay,
		entity	eff,
		entity	snd,
		float	vol )

Guides a projectile towards the crosshair (v_forward).

Call makevectors first

Definition at line 349 of file common.qc.

{
    float f = (guide_rate_delay)
        ? bound(0, (time - guide_start_time) / guide_rate_delay, 1)
        : 1;
 
    vector md = this.realowner.(weaponentity).movedir;
    vector dv = (W_DualWielding(this.realowner))
        ? v_right * -md.y + v_up * md.z
        : '0 0 0'; // don't override!
 
    float velspeed = vlen(this.velocity);
 
    makevectors(this.realowner.v_angle);
    vector desireddir = WarpZone_RefSys_TransformVelocity(this.realowner, this, v_forward);
    vector desiredorigin = WarpZone_RefSys_TransformOrigin(this.realowner, this, this.realowner.origin + this.realowner.view_ofs + dv);
    vector olddir = normalize(this.velocity);
 
    // now it gets tricky... we want to move like some curve to approximate the target direction
    // but we are limiting the rate at which we can turn!
    vector goal = desiredorigin + ((this.origin - desiredorigin) * desireddir + guide_goal) * desireddir;
    vector newdir = W_SteerProjectileTo(olddir, normalize(goal - this.origin), cos(guide_rate * f * frametime * DEG2RAD));
 
    this.velocity = newdir * velspeed;
    this.angles = vectoangles(this.velocity);
 
    if (!this.count && guide_delay > 0 && (eff || snd))
    {
        if (eff)
            Send_Effect(eff, this.origin, this.velocity, 1);
        if (snd)
            sound(this.realowner, CH_WEAPON_B, snd, vol, ATTN_NORM);
        this.count = 1;
    }
}

References angles, ATTN_NORM, bound(), CH_WEAPON_B, cos(), count, DEG2RAD, entity(), frametime, makevectors, movedir, normalize(), origin, realowner, Send_Effect(), sound, time, v_forward, v_right, v_up, vectoangles(), vector, velocity, vlen(), W_DualWielding(), W_SteerProjectileTo(), WarpZone_RefSys_TransformOrigin(), and WarpZone_RefSys_TransformVelocity().

Referenced by W_Devastator_Think(), and W_Seeker_Tag_Think().

W_LaserPlay()

void W_LaserPlay	(	entity	this,
		float	rad,
		float	damage,
		float	edgedamage,
		float	burntime,
		WarpZone_FindRadius_cond_callback_t	cb )

Randomly chooses a player within the radius to shoot a laser towards.

Definition at line 191 of file common.qc.

{
    if (damage <= 0 && edgedamage <= 0)
        return;
 
    RandomSelection_Init();
    entity last = NULL;
    float rad2 = rad * rad;
    WarpZone_SearchInRadius_otherent = this;
    for (entity e = WarpZone_SearchInRadius(this.origin, rad, MOVE_NOMONSTERS, cb); e; e = e.chain)
    {
        // adjust the hit location to be a random position inside the entity's bbox
        vector p = e.origin + e.mins;
        p.x += random() * (e.maxs.x - e.mins.x);
        p.y += random() * (e.maxs.y - e.mins.y);
        p.z += random() * (e.maxs.z - e.mins.z);
        float dist2 = vlen2(this.origin - WarpZone_UnTransformOrigin(e, p));
        if (dist2 <= rad2) // there's a chance this is false, so we optimize by only calling sqrt if true
        {
            e.dest = p;
            e.dmg_radius = sqrt(dist2);
            last = e;
            RandomSelection_AddEnt(e, 1 / (1 + e.dmg_radius), !StatusEffects_active(STATUSEFFECT_Burning, e));
        }
    }
    if (RandomSelection_chosen_ent)
    {
        float dist = damage + (edgedamage - damage) * (RandomSelection_chosen_ent.dmg_radius / rad);
        Fire_AddDamage(RandomSelection_chosen_ent, this.realowner, dist * burntime, burntime, this.projectiledeathtype | HITTYPE_BOUNCE);
 
        // WarpZone_TraceLine_ThroughZone with callback to draw the line-effect through zones on the way to the end,
        // but then for the final segment draw towards .dest instead of the trace's end (.WarpZone_findradius_nearest).
        // This is probably the best we can do
        W_LaserPlay_last_hit_org = this.origin;
        if (RandomSelection_chosen_ent.warpzone_transform != '0 0 0' || RandomSelection_chosen_ent.warpzone_shift != '0 0 0')
        {
            W_LaserPlay_end_org = RandomSelection_chosen_ent.WarpZone_findradius_nearest;
            WarpZone_TraceLine_ThroughZone(this.origin, WarpZone_UnTransformOrigin(RandomSelection_chosen_ent, W_LaserPlay_end_org),
                MOVE_NOTHING, NULL, NULL, W_LaserPlay_trace_callback);
        }
        Send_Effect(EFFECT_FIREBALL_LASER, W_LaserPlay_last_hit_org, RandomSelection_chosen_ent.dest - W_LaserPlay_last_hit_org, 1);
        //trailparticles(this, particleeffectnum(EFFECT_FIREBALL_LASER), this.origin, RandomSelection_chosen_ent.dest);
    }
}

References entity(), Fire_AddDamage(), HITTYPE_BOUNCE, MOVE_NOMONSTERS, MOVE_NOTHING, NULL, origin, projectiledeathtype, random(), RandomSelection_AddEnt, RandomSelection_chosen_ent, RandomSelection_Init(), realowner, Send_Effect(), sqrt(), StatusEffects_active(), vector, vlen2, W_LaserPlay_end_org, W_LaserPlay_last_hit_org, W_LaserPlay_trace_callback(), WarpZone_SearchInRadius(), WarpZone_SearchInRadius_otherent, WarpZone_TraceLine_ThroughZone, and WarpZone_UnTransformOrigin().

Referenced by napalm_ball_think(), napalm_fountain_think(), W_Fireball_Firemine_Think(), and W_Fireball_Think().

W_LaserPlay_trace_callback()

void W_LaserPlay_trace_callback	(	vector	start,
		vector	hit,
		vector	end )

Definition at line 182 of file common.qc.

{
    if (end == W_LaserPlay_end_org) // must be the final trace segment
        return;
    W_LaserPlay_last_hit_org = hit;
    Send_Effect(EFFECT_FIREBALL_LASER, start, hit - start, 1);
    //trailparticles(this, particleeffectnum(EFFECT_FIREBALL_LASER), start, hit);
}

References Send_Effect(), vector, W_LaserPlay_end_org, and W_LaserPlay_last_hit_org.

Referenced by W_LaserPlay().

W_PlayStrengthSound()

void W_PlayStrengthSound

(

entity

player

)

Definition at line 40 of file common.qc.

{
    MUTATOR_CALLHOOK(W_PlayStrengthSound, player);
}

References entity(), MUTATOR_CALLHOOK, and W_PlayStrengthSound().

Referenced by MUTATOR_HOOKABLE(), MUTATOR_HOOKFUNCTION(), W_PlayStrengthSound(), W_SetupShot_Dir_ProjectileSize_Range(), and W_Shotgun_Melee_Think().

W_PrepareExplosionByDamage()

void W_PrepareExplosionByDamage	(	entity	this,
		entity	attacker,
		void(entity this)	explode )

Definition at line 87 of file common.qc.

{
    this.takedamage = DAMAGE_NO;
    this.event_damage = func_null;
 
    MUTATOR_CALLHOOK(PrepareExplosionByDamage, this, attacker);
 
    if (IS_CLIENT(attacker) && !autocvar_g_projectiles_keep_owner)
    {
        this.owner = attacker;
        this.realowner = attacker;
    }
 
    // do not explode NOW but in the NEXT FRAME!
    // because recursive calls to RadiusDamage are not allowed
    this.nextthink = time;
    setthink(this, explode);
}

References autocvar_g_projectiles_keep_owner, DAMAGE_NO, entity(), func_null(), IS_CLIENT, MUTATOR_CALLHOOK, nextthink, owner, realowner, setthink, takedamage, and time.

Referenced by M_Golem_Attack_Lightning_Damage(), nade_damage(), nade_translocate_DestroyDamage(), turret_projectile_damage(), W_Arc_Bolt_Damage(), W_Devastator_Damage(), W_Fireball_Damage(), W_Hagar_Damage(), W_Hook_Damage(), W_MineLayer_Damage(), W_Mortar_Grenade_Damage(), W_OverkillRocketPropelledChainsaw_Damage(), W_Seeker_Missile_Damage(), and walker_rocket_damage().

W_SeekOutEnemy()

float W_SeekOutEnemy	(	entity	this,
		float	speed_decel,
		float	speed_accel,
		float	speed_max,
		float	turn_rate,
		bool	smart,
		float	smart_mindist,
		float	smart_trace_min,
		float	smart_trace_max )

Automatically guides a projectile towards its enemy.

RefSys must be setup

Definition at line 239 of file common.qc.

{
    if (this.enemy != NULL
    &&  this.enemy.takedamage != DAMAGE_AIM || IS_DEAD(this.enemy))
        this.enemy = NULL;
    if (!this.enemy)
        return 0;
 
    float spd = vlen(this.velocity);
    spd = bound(
        spd - speed_decel * frametime,
        speed_max,
        spd + speed_accel * frametime);
 
    vector eorg = WarpZone_RefSys_TransformOrigin(this.enemy, this, 0.5 * (this.enemy.absmin + this.enemy.absmax));
    float dist = vlen(eorg - this.origin);
    vector desireddir = (eorg - this.origin) * 1 / dist;
    vector olddir = this.velocity * 1 / spd; // get my current direction
 
    // Do evasive maneuvers for world objects? ( this should be a cpu hog. :P )
    if (smart && dist > smart_mindist)
    {
        // Is it a better idea (shorter distance) to trace to the target itself?
        if (vdist(this.origin + olddir * this.wait, <, dist))
            WarpZone_TraceLine(this.origin, this.origin + olddir * this.wait, false, this);
        else
            WarpZone_TraceLine(this.origin, eorg, false, this);
 
        // Setup adaptive tracelength
        this.wait = bound(
            smart_trace_min,
            vlen(this.origin - WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos)),
            smart_trace_max);
 
        // Calc how important it is that we turn and add this to the desired (enemy) dir
        desireddir = normalize((trace_plane_normal * (1 - trace_fraction)) + (desireddir * trace_fraction));
    }
 
    vector newdir = normalize(olddir + desireddir * turn_rate); // take the average of the 2 directions; not the best method but simple & easy
    this.velocity = newdir * spd; // make me fly in the new direction at my flight speed
    return dist;
}

References bound(), DAMAGE_AIM, enemy, entity(), frametime, IS_DEAD, normalize(), NULL, origin, trace_endpos, trace_fraction, trace_plane_normal, vdist, vector, velocity, vlen(), wait, WarpZone_RefSys_TransformOrigin(), WarpZone_trace_transform, WarpZone_TraceLine, and WarpZone_UnTransformOrigin().

Referenced by M_Mage_Attack_Spike_Think(), and W_Seeker_Missile_Think().

W_SteerProjectileTo()

vector W_SteerProjectileTo	(	vector	thisdir,
		vector	goaldir,
		float	maxturn_cos )

Definition at line 315 of file common.qc.

{
    if (thisdir * goaldir > maxturn_cos)
        return goaldir;
    if (thisdir * goaldir < -0.9998) // less than 1 degree and opposite
        return thisdir; // refuse to guide (better than letting a numerical error happen)
 
    // solve:
    //   g = normalize(thisdir + goaldir * X)
    //   thisdir * g = maxturn
    //
    //   gg = thisdir + goaldir * X
    //   (thisdir * gg)^2 = maxturn^2 * (gg * gg)
    //
    //   (1 + (thisdir * goaldir) * X)^2 = maxturn^2 * (1 + X*X + 2 * X * thisdir * goaldir)
    float f = thisdir * goaldir;
    //   (1 + f * X)^2 = maxturn^2 * (1 + X*X + 2 * X * f)
    //   0 = (m^2 - f^2) * x^2 + (2 * f * (m^2 - 1)) * x + (m^2 - 1)
    float m2 = maxturn_cos * maxturn_cos;
    vector v = solve_quadratic(m2 - f * f, 2 * f * (m2 - 1), m2 - 1);
    return normalize(thisdir + goaldir * v.y); // the larger solution!
}

References normalize(), solve_quadratic(), and vector.

Referenced by W_GuideProjectile().

WarpZone_Projectile_Touch_ImpactFilter_Callback()

bool WarpZone_Projectile_Touch_ImpactFilter_Callback	(	entity	this,
		entity	toucher )

Definition at line 150 of file common.qc.

{
    if (toucher && toucher == this.owner)
        return true;
 
    if (autocvar_g_projectiles_interact == 1 && toucher.classname == "blasterbolt")
    {
        if (this.movetype == MOVETYPE_BOUNCE || this.movetype == MOVETYPE_BOUNCEMISSILE)
            // We'll bounce off it due to limitations so let it deflect us
            // to hide the problem, see PROJECTILE_MAKETRIGGER.
            gettouch(toucher)(toucher, this);
        return true;
    }
 
    if (SUB_NoImpactCheck(this, toucher))
    {
        if (this.classname == "nade")
            return false; // no checks here
        else if (this.classname == "grapplinghook")
            RemoveHook(this);
        else
            delete(this);
        return true;
    }
    if (trace_ent && trace_ent.solid > SOLID_TRIGGER)
        UpdateCSQCProjectile(this);
    return false;
}

References autocvar_g_projectiles_interact, classname, entity(), gettouch, movetype, MOVETYPE_BOUNCE, MOVETYPE_BOUNCEMISSILE, owner, RemoveHook(), SOLID_TRIGGER, SUB_NoImpactCheck(), toucher, trace_ent, and UpdateCSQCProjectile().

Referenced by WarpZone_Projectile_Touch().

Variable Documentation

W_LaserPlay_end_org

vector W_LaserPlay_end_org

Definition at line 181 of file common.qc.

Referenced by W_LaserPlay(), and W_LaserPlay_trace_callback().

W_LaserPlay_last_hit_org

vector W_LaserPlay_last_hit_org

Definition at line 180 of file common.qc.

Referenced by W_LaserPlay(), and W_LaserPlay_trace_callback().

wait

float wait

Definition at line 236 of file common.qc.