tracing.qh File Reference

#include <common/weapons/_all.qh>
#include <common/stats.qh>

Include dependency graph for tracing.qh:

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

Go to the source code of this file.

Macros
#define	W_SetupProjVelocity_Basic(ent, pspeed, pspread)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, pspeed, 0, 0, pspread, false)
#define	W_SetupProjVelocity_BOTH(ent, wepname, isprimary)
#define	W_SetupProjVelocity_PRE(ent, wepname, prefix)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR(wepname, prefix##speed), 0, 0, WEP_CVAR(wepname, prefix##spread), false)
#define	W_SetupProjVelocity_PRI(ent, wepname)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_PRI(wepname, speed), 0, 0, WEP_CVAR_PRI(wepname, spread), false)
#define	W_SetupProjVelocity_SEC(ent, wepname)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_SEC(wepname, speed), 0, 0, WEP_CVAR_SEC(wepname, spread), false)
#define	W_SetupProjVelocity_UP_BOTH(ent, wepname, isprimary)
#define	W_SetupProjVelocity_UP_PRE(ent, wepname, prefix)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR(wepname, prefix##speed), WEP_CVAR(wepname, prefix##speed_up), WEP_CVAR(wepname, prefix##speed_z), WEP_CVAR(wepname, prefix##spread), false)
#define	W_SetupProjVelocity_UP_PRI(ent, wepname)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_PRI(wepname, speed), WEP_CVAR_PRI(wepname, speed_up), WEP_CVAR_PRI(wepname, speed_z), WEP_CVAR_PRI(wepname, spread), false)
#define	W_SetupProjVelocity_UP_SEC(ent, wepname)   W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_SEC(wepname, speed), WEP_CVAR_SEC(wepname, speed_up), WEP_CVAR_SEC(wepname, speed_z), WEP_CVAR_SEC(wepname, spread), false)
#define	W_SetupShot(ent, wepent, antilag, recoil, snd, chan, maxdamage, deathtype)   W_SetupShot_ProjectileSize(ent, wepent, '0 0 0', '0 0 0', antilag, recoil, snd, chan, maxdamage, deathtype)
#define	W_SetupShot_Dir(ent, wepent, s_forward, antilag, recoil, snd, chan, maxdamage, deathtype)   W_SetupShot_Dir_ProjectileSize(ent, wepent, s_forward, '0 0 0', '0 0 0', antilag, recoil, snd, chan, maxdamage, deathtype)
#define	W_SetupShot_Dir_ProjectileSize(ent, wepent, s_forward, mi, ma, antilag, recoil, snd, chan, maxdamage, deathtype)   W_SetupShot_Dir_ProjectileSize_Range(ent, wepent, s_forward, mi, ma, antilag, recoil, snd, chan, maxdamage, max_shot_distance, deathtype)
#define	W_SetupShot_ProjectileSize(ent, wepent, mi, ma, antilag, recoil, snd, chan, maxdamage, deathtype)   W_SetupShot_Dir_ProjectileSize(ent, wepent, v_forward, mi, ma, antilag, recoil, snd, chan, maxdamage, deathtype)
#define	W_SetupShot_Range(ent, wepent, antilag, recoil, snd, chan, maxdamage, range, deathtype)   W_SetupShot_Dir_ProjectileSize_Range(ent, wepent, v_forward, '0 0 0', '0 0 0', antilag, recoil, snd, chan, maxdamage, range, deathtype)

Functions
void	crosshair_trace (entity pl)
void	crosshair_trace_plusvisibletriggers (entity pl)
void	crosshair_trace_plusvisibletriggers__is_wz (entity pl, bool is_wz)
void	fireBullet (entity this,.entity weaponentity, vector start, vector dir, float spread, float max_solid_penetration, float damage, float headshot_multiplier, float force, float dtype, entity tracer_effect)
void	fireBullet_antilag (entity this,.entity weaponentity, vector start, vector dir, float spread, float max_solid_penetration, float damage, float headshot_multiplier, float force, float dtype, entity tracer_effect, bool do_antilag)
void	fireBullet_trace_callback (vector start, vector hit, vector end)
void	FireRailgunBullet (entity this,.entity weaponentity, vector start, vector end, float bdamage, bool headshot_notify, float bforce, float mindist, float maxdist, float halflifedist, float forcehalflifedist, int deathtype)
	STATIC_INIT (g_railgunhit)
	STATIC_INIT (g_ctrace_changed)
void	traceline_antilag (entity source, vector v1, vector v2, float nomonst, entity forent, float lag)
vector	W_CalculateProjectileVelocity (entity actor, vector pvelocity, vector mvelocity, float forceAbsolute)
void	W_SetupProjVelocity_Explicit (entity proj, vector dir, vector upDir, float pSpeed, float pUpSpeed, float pZSpeed, float spread, float forceAbsolute)
void	W_SetupShot_Dir_ProjectileSize_Range (entity ent,.entity weaponentity, vector s_forward, vector mi, vector ma, float antilag, float recoil, Sound snd, float chan, float maxdamage, float range, int deathtype)
void	WarpZone_crosshair_trace (entity pl)
void	WarpZone_crosshair_trace_plusvisibletriggers (entity pl)
void	WarpZone_traceline_antilag (entity source, vector v1, vector v2, float nomonst, entity forent, float lag)

Variables
float	autocvar_g_ballistics_density_corpse
float	autocvar_g_ballistics_density_player
float	autocvar_g_ballistics_mindistance
bool	autocvar_g_ballistics_penetrate_clips = true
float	autocvar_g_ballistics_solidpenetration_exponent = 1
bool	autocvar_g_norecoil
int	autocvar_g_projectiles_newton_style
float	autocvar_g_projectiles_newton_style_2_maxfactor
float	autocvar_g_projectiles_newton_style_2_minfactor
int	autocvar_g_projectiles_spread_style
float	autocvar_g_trueaim_minrange
float	ballistics_density
entity	fireBullet_last_hit
entity	fireBullet_trace_callback_eff
IntrusiveList	g_ctrace_changed
IntrusiveList	g_railgunhit
float	railgundistance
vector	railgunforce
bool	railgunhit
vector	railgunhitloc
float	railgunhitsolidbackup
vector	w_shotdir
vector	w_shotend
vector	w_shotorg

Macro Definition Documentation

W_SetupProjVelocity_Basic

#define W_SetupProjVelocity_Basic	(		ent,
			pspeed,
			pspread
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, pspeed, 0, 0, pspread, false)

Definition at line 48 of file tracing.qh.

Referenced by W_Nexball_Attack2().

W_SetupProjVelocity_BOTH

#define W_SetupProjVelocity_BOTH	(		ent,
			wepname,
			isprimary
	)

Value:

if(isprimary) { W_SetupProjVelocity_PRI(ent, wepname); } \
    else { W_SetupProjVelocity_SEC(ent, wepname); }

Definition at line 69 of file tracing.qh.

W_SetupProjVelocity_PRE

#define W_SetupProjVelocity_PRE	(		ent,
			wepname,
			prefix
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR(wepname, prefix##speed), 0, 0, WEP_CVAR(wepname, prefix##spread), false)

Definition at line 62 of file tracing.qh.

W_SetupProjVelocity_PRI

#define W_SetupProjVelocity_PRI	(		ent,
			wepname
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_PRI(wepname, speed), 0, 0, WEP_CVAR_PRI(wepname, spread), false)

Definition at line 64 of file tracing.qh.

W_SetupProjVelocity_SEC

#define W_SetupProjVelocity_SEC	(		ent,
			wepname
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_SEC(wepname, speed), 0, 0, WEP_CVAR_SEC(wepname, spread), false)

Definition at line 66 of file tracing.qh.

W_SetupProjVelocity_UP_BOTH

#define W_SetupProjVelocity_UP_BOTH	(		ent,
			wepname,
			isprimary
	)

Value:

if(isprimary) { W_SetupProjVelocity_UP_PRI(ent, wepname); } \
    else { W_SetupProjVelocity_UP_SEC(ent, wepname); }

Definition at line 58 of file tracing.qh.

W_SetupProjVelocity_UP_PRE

#define W_SetupProjVelocity_UP_PRE	(		ent,
			wepname,
			prefix
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR(wepname, prefix##speed), WEP_CVAR(wepname, prefix##speed_up), WEP_CVAR(wepname, prefix##speed_z), WEP_CVAR(wepname, prefix##spread), false)

Definition at line 51 of file tracing.qh.

W_SetupProjVelocity_UP_PRI

#define W_SetupProjVelocity_UP_PRI	(		ent,
			wepname
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_PRI(wepname, speed), WEP_CVAR_PRI(wepname, speed_up), WEP_CVAR_PRI(wepname, speed_z), WEP_CVAR_PRI(wepname, spread), false)

Definition at line 53 of file tracing.qh.

W_SetupProjVelocity_UP_SEC

#define W_SetupProjVelocity_UP_SEC	(		ent,
			wepname
	)		W_SetupProjVelocity_Explicit(ent, w_shotdir, v_up, WEP_CVAR_SEC(wepname, speed), WEP_CVAR_SEC(wepname, speed_up), WEP_CVAR_SEC(wepname, speed_z), WEP_CVAR_SEC(wepname, spread), false)

Definition at line 55 of file tracing.qh.

W_SetupShot

#define W_SetupShot	(		ent,
			wepent,
			antilag,
			recoil,
			snd,
			chan,
			maxdamage,
			deathtype
	)		W_SetupShot_ProjectileSize(ent, wepent, '0 0 0', '0 0 0', antilag, recoil, snd, chan, maxdamage, deathtype)

Definition at line 33 of file tracing.qh.

Referenced by CheatCommand(), W_Nexball_Attack(), and W_Nexball_Attack2().

W_SetupShot_Dir

#define W_SetupShot_Dir	(		ent,
			wepent,
			s_forward,
			antilag,
			recoil,
			snd,
			chan,
			maxdamage,
			deathtype
	)		W_SetupShot_Dir_ProjectileSize(ent, wepent, s_forward, '0 0 0', '0 0 0', antilag, recoil, snd, chan, maxdamage, deathtype)

Definition at line 31 of file tracing.qh.

W_SetupShot_Dir_ProjectileSize

#define W_SetupShot_Dir_ProjectileSize	(		ent,
			wepent,
			s_forward,
			mi,
			ma,
			antilag,
			recoil,
			snd,
			chan,
			maxdamage,
			deathtype
	)		W_SetupShot_Dir_ProjectileSize_Range(ent, wepent, s_forward, mi, ma, antilag, recoil, snd, chan, maxdamage, max_shot_distance, deathtype)

Definition at line 27 of file tracing.qh.

W_SetupShot_ProjectileSize

#define W_SetupShot_ProjectileSize	(		ent,
			wepent,
			mi,
			ma,
			antilag,
			recoil,
			snd,
			chan,
			maxdamage,
			deathtype
	)		W_SetupShot_Dir_ProjectileSize(ent, wepent, v_forward, mi, ma, antilag, recoil, snd, chan, maxdamage, deathtype)

Definition at line 29 of file tracing.qh.

Referenced by FireGrapplingHook().

W_SetupShot_Range

#define W_SetupShot_Range	(		ent,
			wepent,
			antilag,
			recoil,
			snd,
			chan,
			maxdamage,
			range,
			deathtype
	)		W_SetupShot_Dir_ProjectileSize_Range(ent, wepent, v_forward, '0 0 0', '0 0 0', antilag, recoil, snd, chan, maxdamage, range, deathtype)

Definition at line 35 of file tracing.qh.

Function Documentation

crosshair_trace()

void crosshair_trace

(

entity

pl

)

Definition at line 508 of file tracing.qc.

References ANTILAG_LATENCY, CS(), cursor_trace_endpos, cursor_trace_start, MOVE_NORMAL, normalize(), and traceline_antilag().

Referenced by CheatCommand(), crosshair_trace_plusvisibletriggers__is_wz(), and MUTATOR_HOOKFUNCTION().

{
    traceline_antilag(pl, CS(pl).cursor_trace_start, CS(pl).cursor_trace_start + normalize(CS(pl).cursor_trace_endpos - CS(pl).cursor_trace_start) * max_shot_distance, MOVE_NORMAL, pl, ANTILAG_LATENCY(pl));
}

Here is the call graph for this function:

Here is the caller graph for this function:

crosshair_trace_plusvisibletriggers()

void crosshair_trace_plusvisibletriggers

(

entity

pl

)

Definition at line 513 of file tracing.qc.

References crosshair_trace_plusvisibletriggers__is_wz().

Referenced by Drag(), and sandbox_ObjectEdit_Get().

{
    crosshair_trace_plusvisibletriggers__is_wz(pl, false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

crosshair_trace_plusvisibletriggers__is_wz()

void crosshair_trace_plusvisibletriggers__is_wz	(	entity	pl,
		bool	is_wz
	)

Definition at line 523 of file tracing.qc.

References crosshair_trace(), FOREACH_ENTITY_FLOAT, g_ctrace_changed, IL_CLEAR, IL_EACH, solid, SOLID_TRIGGER, and WarpZone_crosshair_trace().

Referenced by crosshair_trace_plusvisibletriggers(), and WarpZone_crosshair_trace_plusvisibletriggers().

{
    FOREACH_ENTITY_FLOAT(solid, SOLID_TRIGGER,
    {
        if(it.model != "")
        {
            it.solid = SOLID_BSP;
            IL_PUSH(g_ctrace_changed, it);
        }
    });

    if (is_wz)
        WarpZone_crosshair_trace(pl);
    else
        crosshair_trace(pl);

    IL_EACH(g_ctrace_changed, true, { it.solid = SOLID_TRIGGER; });

    IL_CLEAR(g_ctrace_changed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

fireBullet()

void fireBullet	(	entity	this,
		.entity	weaponentity,
		vector	start,
		vector	dir,
		float	spread,
		float	max_solid_penetration,
		float	damage,
		float	headshot_multiplier,
		float	force,
		float	dtype,
		entity	tracer_effect
	)

Definition at line 503 of file tracing.qc.

References fireBullet_antilag().

{
    fireBullet_antilag(this, weaponentity, start, dir, spread, max_solid_penetration, damage, headshot_multiplier, force, dtype, tracer_effect, true);
}

Here is the call graph for this function:

fireBullet_antilag()

void fireBullet_antilag	(	entity	this,
		.entity	weaponentity,
		vector	start,
		vector	dir,
		float	spread,
		float	max_solid_penetration,
		float	damage,
		float	headshot_multiplier,
		float	force,
		float	dtype,
		entity	tracer_effect,
		bool	do_antilag
	)

Definition at line 357 of file tracing.qc.

References accuracy_add(), accuracy_isgooddamage(), antilag_getlag(), antilag_restore_all(), antilag_takeback_all(), autocvar_g_ballistics_mindistance, autocvar_g_ballistics_penetrate_clips, autocvar_g_ballistics_solidpenetration_exponent, Damage(), Damage_DamageInfo(), DPCONTENTS_BODY, DPCONTENTS_CORPSE, DPCONTENTS_OPAQUE, DPCONTENTS_SOLID, dphitcontentsmask, entity(), fireBullet_last_hit, fireBullet_trace_callback(), fireBullet_trace_callback_eff, Headshot(), IS_PLAYER, M_ARGV, max(), min(), MOVE_NORMAL, MUTATOR_CALLHOOK, normalize(), NULL, pow(), PS, Q3SURFACEFLAG_NODRAW, Q3SURFACEFLAG_NONSOLID, Q3SURFACEFLAG_SKY, randomvec(), SOLID_BSP, SOLID_SLIDEBOX, trace_dphitcontents, trace_dphitq3surfaceflags, trace_endpos, trace_ent, trace_fraction, trailparticles, vdist, vector(), vlen(), WarpZone_trace_forent, WarpZone_trace_transform, WarpZone_TraceBox_ThroughZone(), WarpZone_TransformOrigin(), WarpZone_TransformVelocity(), world, and yoda.

Referenced by fireBullet().

{
    dir = normalize(dir + randomvec() * spread);
    vector end = start + dir * max_shot_distance;

    fireBullet_last_hit = NULL;
    fireBullet_trace_callback_eff = tracer_effect;

    float solid_penetration_fraction = 1;
    float damage_fraction = 1;
    float total_damage = 0;

    float lag = ((do_antilag) ? antilag_getlag(this) : 0);
    if(lag)
        antilag_takeback_all(this, lag);

    // change shooter to SOLID_BBOX so the shot can hit corpses
    int oldsolid = this.dphitcontentsmask;
    if(this)
        this.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;

    WarpZone_trace_forent = this;

    bool headshot = false; // indicates that one of the hit targets was a headshot
    for (;;)
    {
        WarpZone_TraceBox_ThroughZone(start, '0 0 0', '0 0 0', end, false, WarpZone_trace_forent, NULL, fireBullet_trace_callback);
        dir = WarpZone_TransformVelocity(WarpZone_trace_transform, dir);
        end = WarpZone_TransformOrigin(WarpZone_trace_transform, end);
        start = trace_endpos;
        entity hit = trace_ent;

        // traced up to max_shot_distance and didn't hit anything at all
        if (trace_fraction == 1.0)
            break;

        // When hitting sky, stop.
        if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_SKY)
            break;

        // can't use noimpact, as we need to pass through walls
        //if (trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
            //break;

        // if we hit "weapclip", bail out
        //
        // rationale of this check:
        //
        // any shader that is solid, nodraw AND trans is meant to clip weapon
        // shots and players, but has no other effect!
        //
        // if it is not trans, it is caulk and should not have this side effect
        //
        // matching shaders:
        //   common/weapclip (intended)
        //   common/noimpact (is supposed to eat projectiles, but is erased anyway)
        bool is_weapclip = false;
        if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NODRAW)
        if (!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NONSOLID))
        if (!(trace_dphitcontents & DPCONTENTS_OPAQUE))
            is_weapclip = true;

        if(!hit || hit.solid == SOLID_BSP || hit.solid == SOLID_SLIDEBOX)
            Damage_DamageInfo(start, damage * damage_fraction, 0, 0, max(1, force) * dir * damage_fraction, dtype, hit.species, this);

        if (hit && hit != WarpZone_trace_forent && hit != fireBullet_last_hit)  // Avoid self-damage (except after going through a warp); avoid hitting the same entity twice (engine bug).
        {
            fireBullet_last_hit = hit;
            yoda = 0;
            MUTATOR_CALLHOOK(FireBullet_Hit, this, hit, start, end, damage, this.(weaponentity));
            damage = M_ARGV(4, float);
            if(headshot_multiplier && Headshot(hit, this, start, end))
            {
                damage *= headshot_multiplier;
                headshot = true;
            }
            bool gooddamage = accuracy_isgooddamage(this, hit);
            Damage(hit, this, this, damage * damage_fraction, dtype, weaponentity, start, force * dir * damage_fraction);
            // calculate hits for ballistic weapons
            if(gooddamage)
            {
                // do not exceed 100%
                float added_damage = min(damage - total_damage, damage * damage_fraction);
                total_damage += damage * damage_fraction;
                accuracy_add(this, this.(weaponentity).m_weapon, 0, added_damage);
            }
        }

        if (is_weapclip && !autocvar_g_ballistics_penetrate_clips)
            break;

        // go through solid!
        // outside the world? forget it
        if(start.x > world.maxs.x || start.y > world.maxs.y || start.z > world.maxs.z || start.x < world.mins.x || start.y < world.mins.y || start.z < world.mins.z)
            break;

        float maxdist;
        entity hitstore = IS_PLAYER(hit) ? PS(hit) : hit;
        if(max_solid_penetration < 0)
            break;
        else if(hitstore.ballistics_density < -1)
            break; // -2: no solid penetration, ever
        else if(hitstore.ballistics_density < 0)
            maxdist = vlen(hit.maxs - hit.mins) + 1; // -1: infinite travel distance
        else if(hitstore.ballistics_density == 0)
            maxdist = max_solid_penetration * solid_penetration_fraction;
        else
            maxdist = max_solid_penetration * solid_penetration_fraction / hitstore.ballistics_density;

        if(maxdist <= autocvar_g_ballistics_mindistance)
            break;

        // move the entity along its velocity until it's out of solid, then let it resume
        // The previously hit entity is ignored here!
        traceline_inverted (start, start + dir * maxdist, MOVE_NORMAL, WarpZone_trace_forent, true, hit);
        if(trace_fraction == 1) // 1: we never got out of solid
            break;

        float dist_taken = max(autocvar_g_ballistics_mindistance, vlen(trace_endpos - start));
        float fraction_used_of_what_is_left = dist_taken / maxdist;
        solid_penetration_fraction -= solid_penetration_fraction * fraction_used_of_what_is_left;
        solid_penetration_fraction = max(solid_penetration_fraction, 0);
        damage_fraction = pow(solid_penetration_fraction, autocvar_g_ballistics_solidpenetration_exponent);

        // Only show effect when going through a player (invisible otherwise)
        if (hit && (hit.solid != SOLID_BSP))
            if(vdist(trace_endpos - start, >, 4))
                trailparticles(this, fireBullet_trace_callback_eff, start, trace_endpos);

        start = trace_endpos;

        if(hit.solid == SOLID_BSP)
            Damage_DamageInfo(start, 0, 0, 0, max(1, force) * normalize(dir) * -damage_fraction, dtype, 0, this);
    }

    if(headshot)
        Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_HEADSHOT);

    if(lag)
        antilag_restore_all(this);

    // restore shooter solid type
    if(this)
        this.dphitcontentsmask = oldsolid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fireBullet_trace_callback()

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

Definition at line 349 of file tracing.qc.

References fireBullet_last_hit, fireBullet_trace_callback_eff, NULL, trailparticles, vdist, and WarpZone_trace_forent.

Referenced by fireBullet_antilag().

{
    if(vdist(hit - start, >, 16))
        trailparticles(NULL, fireBullet_trace_callback_eff, start, hit);
    WarpZone_trace_forent = NULL;
    fireBullet_last_hit = NULL;
}

Here is the caller graph for this function:

FireRailgunBullet()

void FireRailgunBullet	(	entity	this,
		.entity	weaponentity,
		vector	start,
		vector	end,
		float	bdamage,
		bool	headshot_notify,
		float	bforce,
		float	mindist,
		float	maxdist,
		float	halflifedist,
		float	forcehalflifedist,
		int	deathtype
	)

Definition at line 231 of file tracing.qc.

References accuracy_add(), antilag_debug, ANTILAG_LATENCY, ATTEN_IDLE, bound(), CH_SHOTS, CS(), Damage_DamageInfo(), dir, entity(), FOREACH_CLIENT, g_railgunhit, Headshot(), IL_CLEAR, IL_EACH, IL_PUSH(), IS_REAL_CLIENT, IS_SPEC, min(), msg_entity, MSG_ONE, normalize(), NULL, SND, SOLID_BSP, SOLID_NOT, SOLID_SLIDEBOX, trace_dphitq3surfaceflags, trace_endpos, trace_ent, trace_fraction, vector(), vlen(), VOL_BASEVOICE, WarpZone_trace_firstzone, WarpZone_trace_transform, WarpZone_traceline_antilag(), WarpZone_TransformVelocity(), and WarpZone_UnTransformOrigin().

{
    vector dir = normalize(end - start);
    vector force = dir * bforce;

    // go a little bit into the wall because we need to hit this wall later
    end = end + dir;

    float totaldmg = 0;
    bool headshot = false; // indicates that one of the targets hit was a headshot

    // trace multiple times until we hit a wall, each obstacle will be made
    // non-solid so we can hit the next, while doing this we spawn effects and
    // note down which entities were hit so we can damage them later
    entity o = this;
    while (1)
    {
        if(CS(this).antilag_debug)
            WarpZone_traceline_antilag (this, start, end, false, o, CS(this).antilag_debug);
        else
            WarpZone_traceline_antilag (this, start, end, false, o, ANTILAG_LATENCY(this));
        if(o && WarpZone_trace_firstzone)
        {
            o = NULL;
            continue;
        }

        if(trace_ent.solid == SOLID_BSP || trace_ent.solid == SOLID_SLIDEBOX)
            Damage_DamageInfo(trace_endpos, bdamage, 0, 0, force, deathtype, trace_ent.species, this);

        // if it is NULL we can't hurt it so stop now
        if (trace_ent == NULL || trace_fraction == 1)
            break;

        if(headshot_notify && !headshot && Headshot(trace_ent, this, start, end))
            headshot = true;

        // make the entity non-solid so we can hit the next one
        IL_PUSH(g_railgunhit, trace_ent);
        trace_ent.railgunhit = true;
        trace_ent.railgunhitloc = end;
        trace_ent.railgunhitsolidbackup = trace_ent.solid;
        trace_ent.railgundistance = vlen(WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos) - start);
        trace_ent.railgunforce = WarpZone_TransformVelocity(WarpZone_trace_transform, force);

        // stop if this is a wall
        if (trace_ent.solid == SOLID_BSP)
            break;

        // make the entity non-solid
        trace_ent.solid = SOLID_NOT;
    }

    vector endpoint = trace_endpos;
    entity endent = trace_ent;
    float endq3surfaceflags = trace_dphitq3surfaceflags;

    // find all the entities the railgun hit and restore their solid state
    IL_EACH(g_railgunhit, it.railgunhit,
    {
        it.solid = it.railgunhitsolidbackup;
    });

    // Find all players the beam passed close by (even those hit)
    float length = vlen(endpoint - start);
    entity pseudoprojectile = NULL;
    FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != this, {
        // not when spectating the shooter
        if (IS_SPEC(it) && it.enemy == this) continue;

        // nearest point on the beam
        vector beampos = start + dir * bound(0, (it.origin - start) * dir, length);

        if(!pseudoprojectile)
            pseudoprojectile = new(pseudoprojectile); // we need this so the sound uses the "entchannel4" volume

        msg_entity = it;
        // we want this to be very loud when close but fall off quickly -> using max base volume and high attenuation
        soundtoat(MSG_ONE, pseudoprojectile, beampos, CH_SHOTS, SND(NEXWHOOSH_RANDOM()), VOL_BASEVOICE, ATTEN_IDLE, 0);
    });
    if(pseudoprojectile)
        delete(pseudoprojectile);

    // find all the entities the railgun hit and hurt them
    IL_EACH(g_railgunhit, it.railgunhit,
    {
        // removal from the list is handled below

        float foff = ExponentialFalloff(mindist, maxdist, halflifedist, it.railgundistance);
        float ffs = ExponentialFalloff(mindist, maxdist, forcehalflifedist, it.railgundistance);

        if(accuracy_isgooddamage(this, it))
            totaldmg += bdamage * foff;

        // apply the damage
        if (it.takedamage)
            Damage(it, this, this, bdamage * foff, deathtype, weaponentity, it.railgunhitloc, it.railgunforce * ffs);

        it.railgunhitloc = '0 0 0';
        it.railgunhitsolidbackup = SOLID_NOT;
        it.railgunhit = false;
        it.railgundistance = 0;
    });

    IL_CLEAR(g_railgunhit);

    if(headshot)
        Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_HEADSHOT);

    // calculate hits and fired shots for hitscan
    if(this.(weaponentity))
        accuracy_add(this, this.(weaponentity).m_weapon, 0, min(bdamage, totaldmg));

    trace_endpos = endpoint;
    trace_ent = endent;
    trace_dphitq3surfaceflags = endq3surfaceflags;
}

Here is the call graph for this function:

STATIC_INIT() [1/2]

STATIC_INIT

(

g_railgunhit

)

Definition at line 85 of file tracing.qh.

References IL_NEW.

{ g_railgunhit = IL_NEW(); }

STATIC_INIT() [2/2]

STATIC_INIT

(

g_ctrace_changed

)

Definition at line 110 of file tracing.qh.

References IL_NEW.

{ g_ctrace_changed = IL_NEW(); }

traceline_antilag()

void traceline_antilag	(	entity	source,
		vector	v1,
		vector	v2,
		float	nomonst,
		entity	forent,
		float	lag
	)

Definition at line 203 of file antilag.qc.

References autocvar_g_antilag, CS_CVAR, IS_CLIENT, and traceline_antilag_force().

Referenced by crosshair_trace().

{
    bool noantilag = ((IS_CLIENT(source)) ? CS_CVAR(source).cvar_cl_noantilag : false);
    if (autocvar_g_antilag != 2 || noantilag)
        lag = 0;
    traceline_antilag_force(source, v1, v2, nomonst, forent, lag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

W_CalculateProjectileVelocity()

vector W_CalculateProjectileVelocity	(	entity	actor,
		vector	pvelocity,
		vector	mvelocity,
		float	forceAbsolute
	)

Definition at line 169 of file tracing.qc.

References autocvar_g_projectiles_newton_style, autocvar_g_projectiles_newton_style_2_maxfactor, autocvar_g_projectiles_newton_style_2_minfactor, get_shotvelocity(), normalize(), vector(), vlen(), and W_WeaponSpeedFactor().

Referenced by ctf_Handle_Throw(), IMPULSE(), kh_Key_DropAll(), kh_Key_DropOne(), W_Nexball_Attack(), and W_SetupProjVelocity_Explicit().

{
    vector mdirection;
    float mspeed;
    vector outvelocity;

    mvelocity = mvelocity * W_WeaponSpeedFactor(actor);

    mdirection = normalize(mvelocity);
    mspeed = vlen(mvelocity);

    outvelocity = get_shotvelocity(pvelocity, mdirection, mspeed, (forceAbsolute ? 0 : autocvar_g_projectiles_newton_style), autocvar_g_projectiles_newton_style_2_minfactor, autocvar_g_projectiles_newton_style_2_maxfactor);

    return outvelocity;
}

Here is the call graph for this function:

Here is the caller graph for this function:

W_SetupProjVelocity_Explicit()

void W_SetupProjVelocity_Explicit	(	entity	proj,
		vector	dir,
		vector	upDir,
		float	pSpeed,
		float	pUpSpeed,
		float	pZSpeed,
		float	spread,
		float	forceAbsolute
	)

Definition at line 185 of file tracing.qc.

References autocvar_g_projectiles_spread_style, autocvar_g_weaponspreadfactor, error(), ftos(), gettime(), GETTIME_HIRES, LOG_INFO, normalize(), NULL, vlen(), W_CalculateProjectileVelocity(), and W_CalculateSpread().

Referenced by FireGrapplingHook().

{
    if(proj.owner == NULL)
        error("Unowned missile");

    dir = dir + upDir * (pUpSpeed / pSpeed);
    dir.z += pZSpeed / pSpeed;
    pSpeed *= vlen(dir);
    dir = normalize(dir);

    #if 0
    if(autocvar_g_projectiles_spread_style != mspercallsstyle)
    {
        mspercallsum = mspercallcount = 0;
        mspercallsstyle = autocvar_g_projectiles_spread_style;
    }
    mspercallsum -= gettime(GETTIME_HIRES);
    #endif

    dir = W_CalculateSpread(dir, spread, autocvar_g_weaponspreadfactor, autocvar_g_projectiles_spread_style);

    #if 0
    mspercallsum += gettime(GETTIME_HIRES);
    mspercallcount += 1;
    LOG_INFO("avg: ", ftos(mspercallcount / mspercallsum), " per sec");
    #endif

    proj.velocity = W_CalculateProjectileVelocity(proj.owner, proj.owner.velocity, pSpeed * dir, forceAbsolute);
}

Here is the call graph for this function:

Here is the caller graph for this function:

W_SetupShot_Dir_ProjectileSize_Range()

void W_SetupShot_Dir_ProjectileSize_Range	(	entity	ent,
		.entity	weaponentity,
		vector	s_forward,
		vector	mi,
		vector	ma,
		float	antilag,
		float	recoil,
		Sound	snd,
		float	chan,
		float	maxdamage,
		float	range,
		int	deathtype
	)

Definition at line 24 of file tracing.qc.

References accuracy_add(), accuracy_canbegooddamage(), antilag_debug, ANTILAG_LATENCY, ATTN_NORM, autocvar_g_antilag, autocvar_g_norecoil, autocvar_g_trueaim_minrange, CS(), CS_CVAR, cursor_trace_ent, DEATH_WEAPONOF, DPCONTENTS_BODY, DPCONTENTS_CORPSE, DPCONTENTS_SOLID, entity(), IS_CLIENT, IS_PLAYER, LOG_INFO, MOVE_NOMONSTERS, MOVE_NORMAL, movedir, normalize(), NULL, sound, Weapon::spawnflags, TC, trace_endpos, trace_ent, tracebox_antilag(), traceline_antilag_force(), v_forward, v_right, v_up, vdist, vector(), VOL_BASE, W_DualWielding(), W_HitPlotAnalysis(), W_PlayStrengthSound(), w_shotdir, w_shotend, w_shotorg, WarpZone_trace_transform, WarpZone_TraceLine(), WarpZone_traceline_antilag(), WarpZone_UnTransformOrigin(), and WEP_FLAG_PENETRATEWALLS.

{
    TC(Sound, snd);
    float nudge = 1; // added to traceline target and subtracted from result  TOOD(divVerent): do we still need this? Doesn't the engine do this now for us?
    float oldsolid = ent.dphitcontentsmask;
    Weapon wep = DEATH_WEAPONOF(deathtype);
    if(!IS_CLIENT(ent))
        antilag = false; // no antilag for non-clients!
    if (IS_PLAYER(ent) && (wep.spawnflags & WEP_FLAG_PENETRATEWALLS))
    {
        // This is the reason rifle, MG, OKMG and other fireBullet weapons don't hit the crosshair when shooting at walls.
        // This is intentional, otherwise if you stand too close to a (glass) wall and attempt to shoot an enemy through it,
        // trueaim will cause the shot to hit the wall exactly but then miss the enemy (unless shooting from eye/center).
        // TODO for fireBullet, find how far the shot will penetrate and aim at that
        //      for fireRailgunbullet, find the farthest target and aim at that
        //      this will avoid issues when another player is passing in front of you when you shoot
        //      (currently such a shot will hit him but then miss the original target)
        ent.dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_CORPSE;
    }
    else
        ent.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
    if(antilag)
        WarpZone_traceline_antilag(NULL, ent.origin + ent.view_ofs, ent.origin + ent.view_ofs + s_forward * range, MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
        // passing NULL, because we do NOT want it to touch dphitcontentsmask
    else
        WarpZone_TraceLine(ent.origin + ent.view_ofs, ent.origin + ent.view_ofs + s_forward * range, MOVE_NOMONSTERS, ent);
    ent.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;

    vector forward, right, up;
    forward = v_forward;
    right = v_right;
    up = v_up;
    w_shotend = WarpZone_UnTransformOrigin(WarpZone_trace_transform, trace_endpos); // warpzone support
    v_forward = forward;
    v_right = right;
    v_up = up;

    // un-adjust trueaim if shotend is too close
    if(vdist(w_shotend - (ent.origin + ent.view_ofs), <, autocvar_g_trueaim_minrange))
        w_shotend = ent.origin + ent.view_ofs + s_forward * autocvar_g_trueaim_minrange;

    // track max damage
    if (IS_PLAYER(ent) && accuracy_canbegooddamage(ent))
        accuracy_add(ent, wep, maxdamage, 0);

    if(IS_PLAYER(ent))
        W_HitPlotAnalysis(ent, wep, forward, right, up);

    vector md = ent.(weaponentity).movedir;
    vector vecs = ((md.x > 0) ? md : '0 0 0');

    vector dv = right * -vecs.y + up * vecs.z;
    w_shotorg = ent.origin + ent.view_ofs;
    if(antilag)
    {
        if(CS(ent).antilag_debug)
            tracebox_antilag(ent, w_shotorg, mi, ma, w_shotorg + dv, MOVE_NORMAL, ent, CS(ent).antilag_debug);
        else
            tracebox_antilag(ent, w_shotorg, mi, ma, w_shotorg + dv, MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
    }
    else
        tracebox(w_shotorg, mi, ma, w_shotorg + dv, MOVE_NORMAL, ent);
    w_shotorg = trace_endpos;

    // now move the shotorg forward as much as requested if possible
    if(antilag)
    {
        if(CS(ent).antilag_debug)
            tracebox_antilag(ent, w_shotorg, mi, ma, w_shotorg + forward * (vecs.x + nudge), MOVE_NORMAL, ent, CS(ent).antilag_debug);
        else
            tracebox_antilag(ent, w_shotorg, mi, ma, w_shotorg + forward * (vecs.x + nudge), MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
    }
    else
        tracebox(w_shotorg, mi, ma, w_shotorg + forward * (vecs.x + nudge), MOVE_NORMAL, ent);
    w_shotorg = trace_endpos - forward * nudge;
    // calculate the shotdir from the chosen shotorg
    if(W_DualWielding(ent))
        w_shotdir = s_forward;
    else
        w_shotdir = normalize(w_shotend - w_shotorg);

    //vector prevdir = w_shotdir;
    //vector prevorg = w_shotorg;
    //vector prevend = w_shotend;

    if (antilag)
    if (!CS_CVAR(ent).cvar_cl_noantilag)
    {
        if (autocvar_g_antilag == 1) // switch to "ghost" if not hitting original
        {
            traceline(w_shotorg, w_shotorg + w_shotdir * range, MOVE_NORMAL, ent);
            if (!trace_ent.takedamage)
            {
                traceline_antilag_force (ent, w_shotorg, w_shotorg + w_shotdir * range, MOVE_NORMAL, ent, ANTILAG_LATENCY(ent));
                if (trace_ent.takedamage && IS_PLAYER(trace_ent))
                {
                    entity e;
                    e = trace_ent;
                    traceline(w_shotorg, e.origin, MOVE_NORMAL, ent);
                    if(trace_ent == e)
                        w_shotdir = normalize(trace_ent.origin - w_shotorg);
                }
            }
        }
        else if(autocvar_g_antilag == 3) // client side hitscan
        {
            // this part MUST use prydon cursor
            if (CS(ent).cursor_trace_ent)                 // client was aiming at someone
            if (CS(ent).cursor_trace_ent != ent)         // just to make sure
            if (CS(ent).cursor_trace_ent.takedamage)      // and that person is killable
            if (IS_PLAYER(CS(ent).cursor_trace_ent)) // and actually a player
            {
                // verify that the shot would miss without antilag
                // (avoids an issue where guns would always shoot at their origin)
                traceline(w_shotorg, w_shotorg + w_shotdir * range, MOVE_NORMAL, ent);
                if (!trace_ent.takedamage)
                {
                    // verify that the shot would hit if altered
                    traceline(w_shotorg, CS(ent).cursor_trace_ent.origin, MOVE_NORMAL, ent);
                    if (trace_ent == CS(ent).cursor_trace_ent)
                        w_shotdir = normalize(CS(ent).cursor_trace_ent.origin - w_shotorg);
                    else
                        LOG_INFO("antilag fail");
                }
            }
        }
    }

    ent.dphitcontentsmask = oldsolid; // restore solid type (generally SOLID_SLIDEBOX)

    if (!autocvar_g_norecoil)
        ent.punchangle_x = recoil * -1;

    if (snd != SND_Null) {
        sound(ent, chan, snd, (W_DualWielding(ent) ? VOL_BASE * 0.7 : VOL_BASE), ATTN_NORM);
        W_PlayStrengthSound(ent);
    }

    // nudge w_shotend so a trace to w_shotend hits
    w_shotend = w_shotend + normalize(w_shotend - w_shotorg) * nudge;
    //if(w_shotend != prevend) { printf("SERVER: shotEND differs: %s - %s\n", vtos(w_shotend), vtos(prevend)); }
    //if(w_shotorg != prevorg) { printf("SERVER: shotORG differs: %s - %s\n", vtos(w_shotorg), vtos(prevorg)); }
    //if(w_shotdir != prevdir) { printf("SERVER: shotDIR differs: %s - %s\n", vtos(w_shotdir), vtos(prevdir)); }
}

Here is the call graph for this function:

WarpZone_crosshair_trace()

void WarpZone_crosshair_trace

(

entity

pl

)

Definition at line 544 of file tracing.qc.

References ANTILAG_LATENCY, CS(), cursor_trace_endpos, cursor_trace_start, MOVE_NORMAL, normalize(), and WarpZone_traceline_antilag().

Referenced by crosshair_trace_plusvisibletriggers__is_wz(), crosshair_trace_waypoints(), and IMPULSE().

{
    WarpZone_traceline_antilag(pl, CS(pl).cursor_trace_start, CS(pl).cursor_trace_start + normalize(CS(pl).cursor_trace_endpos - CS(pl).cursor_trace_start) * max_shot_distance, MOVE_NORMAL, pl, ANTILAG_LATENCY(pl));
}

Here is the call graph for this function:

Here is the caller graph for this function:

WarpZone_crosshair_trace_plusvisibletriggers()

void WarpZone_crosshair_trace_plusvisibletriggers

(

entity

pl

)

Definition at line 518 of file tracing.qc.

References crosshair_trace_plusvisibletriggers__is_wz().

Referenced by formatmessage(), and IMPULSE().

{
    crosshair_trace_plusvisibletriggers__is_wz(pl, true);
}

Here is the call graph for this function:

Here is the caller graph for this function:

WarpZone_traceline_antilag()

void WarpZone_traceline_antilag	(	entity	source,
		vector	v1,
		vector	v2,
		float	nomonst,
		entity	forent,
		float	lag
	)

Definition at line 221 of file antilag.qc.

References autocvar_g_antilag, CS_CVAR, IS_CLIENT, and WarpZone_traceline_antilag_force().

Referenced by FireRailgunBullet(), W_SetupShot_Dir_ProjectileSize_Range(), and WarpZone_crosshair_trace().

{
    bool noantilag = ((IS_CLIENT(source)) ? CS_CVAR(source).cvar_cl_noantilag : false);
    if (autocvar_g_antilag != 2 || noantilag)
        lag = 0;
    WarpZone_traceline_antilag_force(source, v1, v2, nomonst, forent, lag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

autocvar_g_ballistics_density_corpse

float autocvar_g_ballistics_density_corpse

Definition at line 6 of file tracing.qh.

Referenced by PlayerDamage().

autocvar_g_ballistics_density_player

float autocvar_g_ballistics_density_player

Definition at line 7 of file tracing.qh.

Referenced by PutPlayerInServer().

autocvar_g_ballistics_mindistance

float autocvar_g_ballistics_mindistance

Definition at line 8 of file tracing.qh.

Referenced by fireBullet_antilag().

autocvar_g_ballistics_penetrate_clips

bool autocvar_g_ballistics_penetrate_clips = true

Definition at line 9 of file tracing.qh.

Referenced by fireBullet_antilag().

autocvar_g_ballistics_solidpenetration_exponent

float autocvar_g_ballistics_solidpenetration_exponent = 1

Definition at line 10 of file tracing.qh.

Referenced by fireBullet_antilag().

autocvar_g_norecoil

bool autocvar_g_norecoil

Definition at line 15 of file tracing.qh.

Referenced by spawnfunc(), and W_SetupShot_Dir_ProjectileSize_Range().

autocvar_g_projectiles_newton_style

int autocvar_g_projectiles_newton_style

Definition at line 11 of file tracing.qh.

Referenced by W_CalculateProjectileVelocity().

autocvar_g_projectiles_newton_style_2_maxfactor

float autocvar_g_projectiles_newton_style_2_maxfactor

Definition at line 12 of file tracing.qh.

Referenced by W_CalculateProjectileVelocity().

autocvar_g_projectiles_newton_style_2_minfactor

float autocvar_g_projectiles_newton_style_2_minfactor

Definition at line 13 of file tracing.qh.

Referenced by W_CalculateProjectileVelocity().

autocvar_g_projectiles_spread_style

int autocvar_g_projectiles_spread_style

Definition at line 14 of file tracing.qh.

Referenced by W_SetupProjVelocity_Explicit().

autocvar_g_trueaim_minrange

float autocvar_g_trueaim_minrange

Definition at line 16 of file tracing.qh.

Referenced by ClientInit_misc(), and W_SetupShot_Dir_ProjectileSize_Range().

ballistics_density

float ballistics_density

Definition at line 77 of file tracing.qh.

fireBullet_last_hit

entity fireBullet_last_hit

Definition at line 92 of file tracing.qh.

Referenced by fireBullet_antilag(), and fireBullet_trace_callback().

fireBullet_trace_callback_eff

entity fireBullet_trace_callback_eff

Definition at line 91 of file tracing.qh.

Referenced by fireBullet_antilag(), and fireBullet_trace_callback().

g_ctrace_changed

IntrusiveList g_ctrace_changed

Definition at line 109 of file tracing.qh.

Referenced by crosshair_trace_plusvisibletriggers__is_wz().

g_railgunhit

IntrusiveList g_railgunhit

Definition at line 84 of file tracing.qh.

Referenced by FireRailgunBullet().

railgundistance

float railgundistance

Definition at line 87 of file tracing.qh.

railgunforce

vector railgunforce

Definition at line 88 of file tracing.qh.

railgunhit

bool railgunhit

Definition at line 80 of file tracing.qh.

railgunhitloc

vector railgunhitloc

Definition at line 82 of file tracing.qh.

railgunhitsolidbackup

float railgunhitsolidbackup

Definition at line 81 of file tracing.qh.

w_shotdir

vector w_shotdir

Definition at line 19 of file tracing.qh.

Referenced by CheatCommand(), FireGrapplingHook(), W_Nexball_Attack(), and W_SetupShot_Dir_ProjectileSize_Range().

w_shotend

vector w_shotend

Definition at line 20 of file tracing.qh.

Referenced by W_SetupShot_Dir_ProjectileSize_Range().

w_shotorg

vector w_shotorg

Definition at line 18 of file tracing.qh.

Referenced by CheatCommand(), FireGrapplingHook(), TrueAimCheck(), W_Nexball_Attack(), W_Nexball_Attack2(), and W_SetupShot_Dir_ProjectileSize_Range().