util.qc File Reference

#include "util.qh"
#include <lib/csqcmodel/cl_player.qh>
#include <common/physics/player.qh>
#include <common/physics/movetypes/movetypes.qh>
#include <common/ent_cs.qh>
#include <common/animdecide.qh>

Include dependency graph for util.qc:

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

Go to the source code of this file.

Functions
float	StrafeHUD_AngleToOffset (float angle, float range)
float	StrafeHUD_AngleToWidth (float angle, float range)
vector	StrafeHUD_CalculateTextIndicatorPosition (vector pos)
float	StrafeHUD_DetermineDirection (float angle, float wishangle, float antiflicker_angle)
int	StrafeHUD_DetermineForwardKeys (vector movement, int keys, bool is_local)
float	StrafeHUD_DetermineFrameTime ()
float	StrafeHUD_DetermineHudAngle (float absolute_wishangle, float absolute_overturnangle, float strafity)
bool	StrafeHUD_DetermineJumpHeld (entity e, int keys, bool is_local)
bool	StrafeHUD_DetermineOnGround (entity e, bool is_local)
bool	StrafeHUD_DetermineOnSlick (entity e)
float	StrafeHUD_DetermineWaterLevel (entity e)
float	StrafeHUD_DetermineWishAngle (vector movement, int keys, bool is_local)
string	StrafeHUD_GetLengthUnit (int length_unit)
float	StrafeHUD_GetLengthUnitFactor (int length_unit)
entity	StrafeHUD_GetStrafeplayer (bool is_local)
vector	StrafeHUD_MixColors (vector color1, vector color2, float ratio)
float	StrafeHUD_Project (float ratio, float range, bool reverse)
float	StrafeHUD_ProjectOffset (float offset, float range, bool reverse)
float	StrafeHUD_ProjectWidth (float offset, float width, float range)

Function Documentation

StrafeHUD_AngleToOffset()

float StrafeHUD_AngleToOffset	(	float	angle,
		float	range )

Definition at line 18 of file util.qc.

{
    return StrafeHUD_AngleToWidth(angle, range) + panel_size.x * 0.5;
}

References angle, panel_size, and StrafeHUD_AngleToWidth().

Referenced by StrafeHUD_DrawAngleIndicator(), and StrafeHUD_DrawStrafeHUD().

StrafeHUD_AngleToWidth()

float StrafeHUD_AngleToWidth	(	float	angle,
		float	range )

Definition at line 12 of file util.qc.

{
    return angle / range * panel_size.x;
}

References angle, and panel_size.

Referenced by StrafeHUD_AngleToOffset(), and StrafeHUD_DrawStrafeHUD().

StrafeHUD_CalculateTextIndicatorPosition()

vector StrafeHUD_CalculateTextIndicatorPosition

(

vector

pos

)

Definition at line 360 of file util.qc.

{
    pos.x *= panel_size.x * 0.5; // more intuitive since we start in the middle, this turns the range from -0.5 to +0.5 into -1 to +1
    pos.y *= panel_size.y;
    pos.z = 0;
 
    return pos;
}

References panel_size, and vector.

Referenced by StrafeHUD_DrawTextIndicator().

StrafeHUD_DetermineDirection()

float StrafeHUD_DetermineDirection	(	float	angle,
		float	wishangle,
		float	antiflicker_angle )

Definition at line 296 of file util.qc.

{
    if (wishangle > 0)
        return STRAFEHUD_DIRECTION_RIGHT;
    else if (wishangle < 0)
        return STRAFEHUD_DIRECTION_LEFT;
    else
    {
        if (angle > antiflicker_angle && angle < (180 - antiflicker_angle))
            return STRAFEHUD_DIRECTION_RIGHT;
        else if (angle < -antiflicker_angle && angle > (-180 + antiflicker_angle))
            return STRAFEHUD_DIRECTION_LEFT;
        else
            return STRAFEHUD_DIRECTION_NONE;
    }
}

References angle, STRAFEHUD_DIRECTION_LEFT, STRAFEHUD_DIRECTION_NONE, and STRAFEHUD_DIRECTION_RIGHT.

Referenced by HUD_StrafeHUD().

StrafeHUD_DetermineForwardKeys()

int StrafeHUD_DetermineForwardKeys	(	vector	movement,
		int	keys,
		bool	is_local )

Definition at line 216 of file util.qc.

{
    if (is_local) // if entity is local player
    {
        if (movement.x > 0)
            return STRAFEHUD_KEYS_FORWARD;
        else if (movement.x < 0)
            return STRAFEHUD_KEYS_BACKWARD;
        else
            return STRAFEHUD_KEYS_NONE;
    }
    else // alternatively determine direction by querying pressed keys
    {
        if ((keys & KEY_FORWARD) && !(keys & KEY_BACKWARD))
            return STRAFEHUD_KEYS_FORWARD;
        else if (!(keys & KEY_FORWARD) && (keys & KEY_BACKWARD))
            return STRAFEHUD_KEYS_BACKWARD;
        else
            return STRAFEHUD_KEYS_NONE;
    }
}

References KEY_BACKWARD, KEY_FORWARD, movement, STRAFEHUD_KEYS_BACKWARD, STRAFEHUD_KEYS_FORWARD, STRAFEHUD_KEYS_NONE, and vector.

Referenced by HUD_StrafeHUD().

StrafeHUD_DetermineFrameTime()

float StrafeHUD_DetermineFrameTime

(

)

Definition at line 138 of file util.qc.

{
    static float dt_update = 0;
    static int dt_time = 0;
    static float dt_sum = 0;
    static float dt = 0;
    if (csqcplayer_status == CSQCPLAYERSTATUS_PREDICTED && input_timelength > 0)
    {
        float dt_client = input_timelength;
 
        if (dt_client > 0.05) // server splits frames longer than 50 ms into two moves (DarkPlaces behaviour)
            dt_client *= 0.5; // does not ensure frames are smaller than 50 ms, just splits large frames in half, matches server behaviour
 
        /* calculate average frametime
         * calculated using a weighted arithmetic mean, where the weighting is equal to the frametime itself
         * for example, given a 1 ms frame and a 9 ms frame we have:
         *   a total time of 10 ms
         *   a weighted sum of 1 ms * 1 ms + 9 ms * 9 ms = 82 ms^2
         *   the final result is 82 ms^2 / 10 ms = 8.2 ms
         */
        dt_sum += dt_client * dt_client; // weighted sum of all frametimes (mean numerator)
        dt_time += dt_client; // time spent averaging (mean denominator)
 
        if ((time - dt_update) > autocvar_hud_panel_strafehud_fps_update || dt_update == 0)
        {
            dt = dt_sum / dt_time;
            dt_update = time;
            dt_time = dt_sum = 0;
        }
    }
    else // when spectating other players server ticrate will be used, this may not be accurate but there is no way to find other player's frametime
    {
        dt = ticrate;
        dt_update = dt_time = dt_sum = 0;
    }
 
    return dt;
}

References autocvar_hud_panel_strafehud_fps_update, csqcplayer_status, CSQCPLAYERSTATUS_PREDICTED, input_timelength, ticrate, and time.

Referenced by HUD_StrafeHUD().

StrafeHUD_DetermineHudAngle()

float StrafeHUD_DetermineHudAngle	(	float	absolute_wishangle,
		float	absolute_overturnangle,
		float	strafity )

Definition at line 238 of file util.qc.

{
    // determine the minimal required HUD angle to contain the full strafing angle range
    // this is useful for the velocity centered mode where the zones do not follow the strafing angle
    // how it works:
    //   the angle where the most acceleration occurs moves relative to the player velocity
    //   from 0 - wishangle to absolute_overturnangle - wishangle
    //   the angle farther away from the center is the maximum the optimal strafing angle can
    //   diverge from the direction of velocity
    //   this angle has to be multiplied by two since the HUD extends in both directions which
    //   halves the amount it extends in a single direction
    float range_minangle = max(absolute_wishangle, absolute_overturnangle - absolute_wishangle) * 2;
 
    float range_normal = autocvar_hud_panel_strafehud_range;
    float range_side   = autocvar_hud_panel_strafehud_range_sidestrafe;
    float range_used;
 
    float hfov = getproperty(VF_FOVX);
    if (isnan(range_normal) || isnan(range_side) || isnan(hfov))
        return 360;
 
    // negative values enable different behaviour
    // no exact matching so that all negative values are caught
    if (range_normal == 0) // range = 0, use minimum angle required if dynamically setting hud angle
        range_normal = autocvar__hud_configure ? 90 : range_minangle;
    else if (range_normal < 0) // range = -1, use the current field of view
        range_normal = hfov;
 
    if (range_side < -1) // range = -2, use the normal range
        range_used = range_normal;
    else
    {
        if (range_side == 0)  // range = 0, use minimum angle required if dynamically setting hud angle
            range_side = autocvar__hud_configure ? 90 : range_minangle;
        else if (range_side < 0) // range = -1, use the current field of view
            range_side = hfov;
 
        range_used = GeomLerp(range_normal, strafity, range_side);
    }
    float hudangle = bound(0, fabs(range_used), 360); // limit HUD range to 360 degrees, higher values don't make sense
 
    // limit strafe-meter angle to values suitable for the current projection mode
    switch (autocvar_hud_panel_strafehud_projection)
    {
        // those limits are a little less than the maximal FOV the game allows
        // however, they suffice for all realistic use cases
        case STRAFEHUD_PROJECTION_PERSPECTIVE:
            hudangle = min(hudangle, 170);
            break;
        case STRAFEHUD_PROJECTION_PANORAMIC:
            hudangle = min(hudangle, 350);
            break;
    }
 
    return hudangle;
}

References autocvar__hud_configure, autocvar_hud_panel_strafehud_projection, autocvar_hud_panel_strafehud_range, autocvar_hud_panel_strafehud_range_sidestrafe, bound(), fabs(), GeomLerp(), isnan(), max(), min(), STRAFEHUD_PROJECTION_PANORAMIC, STRAFEHUD_PROJECTION_PERSPECTIVE, and VF_FOVX.

Referenced by HUD_StrafeHUD().

StrafeHUD_DetermineJumpHeld()

bool StrafeHUD_DetermineJumpHeld	(	entity	e,
		int	keys,
		bool	is_local )

Definition at line 316 of file util.qc.

{
    if (is_local)
    {
        if ((PHYS_INPUT_BUTTON_JUMP(e) || PHYS_INPUT_BUTTON_JETPACK(e)) && !PHYS_CL_TRACK_CANJUMP(e))
            return true;
    }
    else
    {
        if ((keys & KEY_JUMP) && !PHYS_TRACK_CANJUMP(e))
            return true;
    }
 
    return false;
}

References entity(), KEY_JUMP, PHYS_CL_TRACK_CANJUMP, PHYS_INPUT_BUTTON_JETPACK, PHYS_INPUT_BUTTON_JUMP, and PHYS_TRACK_CANJUMP.

Referenced by HUD_Physics(), and HUD_StrafeHUD().

StrafeHUD_DetermineOnGround()

bool StrafeHUD_DetermineOnGround	(	entity	e,
		bool	is_local )

Definition at line 334 of file util.qc.

{
    return is_local ? IS_ONGROUND(e) : !(e.anim_implicit_state & ANIMIMPLICITSTATE_INAIR);
}

References ANIMIMPLICITSTATE_INAIR, entity(), and IS_ONGROUND.

Referenced by HUD_Physics(), and HUD_StrafeHUD().

StrafeHUD_DetermineOnSlick()

bool StrafeHUD_DetermineOnSlick

(

entity

e

)

Definition at line 341 of file util.qc.

{
    // do not use IS_ONSLICK(), it only works for the local player and only if client prediction is enabled
    trace_dphitq3surfaceflags = 0;
    tracebox(e.origin, e.mins, e.maxs, e.origin - '0 0 1', MOVE_NOMONSTERS, e);
    return boolean(trace_dphitq3surfaceflags & Q3SURFACEFLAG_SLICK);
}

References boolean, entity(), MOVE_NOMONSTERS, Q3SURFACEFLAG_SLICK, and trace_dphitq3surfaceflags.

Referenced by HUD_Physics(), and HUD_StrafeHUD().

StrafeHUD_DetermineWaterLevel()

float StrafeHUD_DetermineWaterLevel

(

entity

e

)

Definition at line 118 of file util.qc.

{
    // store old values
    void old_contentstransition(int, int) = e.contentstransition;
    float old_watertype = e.watertype;
    float old_waterlevel = e.waterlevel;
 
    e.contentstransition = func_null; // unset the contentstransition function if present
    _Movetype_CheckWater(e);
    float new_waterlevel = e.waterlevel; // store the player waterlevel
 
    // restore old values
    e.contentstransition = old_contentstransition;
    e.watertype = old_watertype;
    e.waterlevel = old_waterlevel;
 
    return new_waterlevel;
}

References _Movetype_CheckWater(), entity(), and func_null().

Referenced by HUD_StrafeHUD().

StrafeHUD_DetermineWishAngle()

float StrafeHUD_DetermineWishAngle	(	vector	movement,
		int	keys,
		bool	is_local )

Definition at line 178 of file util.qc.

{
    float wishangle;
    if (is_local) // if entity is local player
    {
        if (movement.y == 0)
            wishangle = 0;
        else
        {
            wishangle = RAD2DEG * atan2(movement.y, movement.x);
            // wrap the wish angle if it exceeds ±90°
            if (fabs(wishangle) > 90)
            {
                if (wishangle < 0)
                    wishangle += 180;
                else
                    wishangle -= 180;
 
                wishangle *= -1;
            }
        }
    }
    else // alternatively calculate wishdir by querying pressed keys
    {
        if (keys & (KEY_FORWARD | KEY_BACKWARD))
            wishangle = 45;
        else
            wishangle = 90;
        if (keys & KEY_LEFT)
            wishangle *= -1;
        else if (!(keys & KEY_RIGHT))
            wishangle = 0; // wraps at 180°
    }
 
    return wishangle;
}

References fabs(), KEY_BACKWARD, KEY_FORWARD, KEY_LEFT, KEY_RIGHT, movement, RAD2DEG, and vector.

Referenced by HUD_StrafeHUD().

StrafeHUD_GetLengthUnit()

string StrafeHUD_GetLengthUnit

(

int

length_unit

)

Definition at line 95 of file util.qc.

{
    switch (length_unit)
    {
        // translator-friendly strings without the initial space
        default:
        case 1:  return strcat(" ", _("qu"));
        case 2:  return strcat(" ", _("m"));
        case 3:  return strcat(" ", _("km"));
        case 4:  return strcat(" ", _("mi"));
        case 5:  return strcat(" ", _("nmi"));
    }
}

References strcat().

Referenced by StrafeHUD_DrawJumpHeight().

StrafeHUD_GetLengthUnitFactor()

float StrafeHUD_GetLengthUnitFactor

(

int

length_unit

)

Definition at line 82 of file util.qc.

{
    switch (length_unit)
    {
        default:
        case 1:  return 1.0;
        case 2:  return 0.0254;
        case 3:  return 0.0254 * 0.001;
        case 4:  return 0.0254 * 0.001 * 0.6213711922;
        case 5:  return 0.0254 * 0.001 * 0.5399568035;
    }
}

Referenced by StrafeHUD_DrawJumpHeight().

StrafeHUD_GetStrafeplayer()

entity StrafeHUD_GetStrafeplayer

(

bool

is_local

)

Definition at line 109 of file util.qc.

{
    // use the local csqcmodel entity if it's valid (i.e. is_local == true)
    return is_local
        ? csqcplayer
        : CSQCModel_server2csqc(player_localentnum - 1);
}

References CSQCModel_server2csqc(), csqcplayer, entity(), and player_localentnum.

Referenced by HUD_Physics(), and HUD_StrafeHUD().

StrafeHUD_MixColors()

vector StrafeHUD_MixColors	(	vector	color1,
		vector	color2,
		float	ratio )

Definition at line 351 of file util.qc.

{
    if (ratio <= 0)
        return color1;
    if (ratio >= 1)
        return color2;
    return color1 + (color2 - color1) * ratio;
}

References vector.

Referenced by HUD_StrafeHUD(), StrafeHUD_DrawSoftGradient(), and StrafeHUD_DrawStrafeEfficiency().

StrafeHUD_Project()

float StrafeHUD_Project	(	float	ratio,
		float	range,
		bool	reverse )

Definition at line 24 of file util.qc.

{
    range *= DEG2RAD * 0.5;
    switch (autocvar_hud_panel_strafehud_projection)
    {
        default:
        case STRAFEHUD_PROJECTION_LINEAR:
            return ratio;
        case STRAFEHUD_PROJECTION_PERSPECTIVE:
            if (!reverse)
            {
                ratio *= range;
                ratio = tan(ratio) / tan(range);
            }
            else
            {
                ratio = atan(ratio * tan(range));
                ratio /= range;
            }
            break;
        case STRAFEHUD_PROJECTION_PANORAMIC:
            if (!reverse)
            {
                ratio *= range;
                ratio = tan(ratio * 0.5) / tan(range * 0.5);
            }
            else
            {
                ratio = atan(ratio * tan(range * 0.5)) * 2;
                ratio /= range;
            }
            break;
    }
    return ratio;
}

References autocvar_hud_panel_strafehud_projection, DEG2RAD, STRAFEHUD_PROJECTION_LINEAR, STRAFEHUD_PROJECTION_PANORAMIC, and STRAFEHUD_PROJECTION_PERSPECTIVE.

Referenced by StrafeHUD_ProjectOffset().

StrafeHUD_ProjectOffset()

float StrafeHUD_ProjectOffset	(	float	offset,
		float	range,
		bool	reverse )

Definition at line 61 of file util.qc.

{
    if (autocvar_hud_panel_strafehud_projection == STRAFEHUD_PROJECTION_LINEAR)
        return offset;
 
    float ratio = (offset - (panel_size.x * 0.5)) / (panel_size.x * 0.5);
    ratio = StrafeHUD_Project(ratio, range, reverse);
    offset = ratio * (panel_size.x * 0.5) + (panel_size.x * 0.5);
    return offset;
}

References autocvar_hud_panel_strafehud_projection, panel_size, StrafeHUD_Project(), and STRAFEHUD_PROJECTION_LINEAR.

Referenced by StrafeHUD_DrawAngleIndicator(), StrafeHUD_DrawGradient(), StrafeHUD_DrawSoftGradient(), StrafeHUD_DrawStrafeHUD(), and StrafeHUD_ProjectWidth().

StrafeHUD_ProjectWidth()

float StrafeHUD_ProjectWidth	(	float	offset,
		float	width,
		float	range )

Definition at line 73 of file util.qc.

{
    if (autocvar_hud_panel_strafehud_projection == STRAFEHUD_PROJECTION_LINEAR)
        return width;
 
    return StrafeHUD_ProjectOffset(offset + width, range, false) - StrafeHUD_ProjectOffset(offset, range, false);
}

References autocvar_hud_panel_strafehud_projection, STRAFEHUD_PROJECTION_LINEAR, and StrafeHUD_ProjectOffset().

Referenced by StrafeHUD_DrawGradient(), and StrafeHUD_DrawStrafeHUD().