hook.qc File Reference

#include "hook.qh"
#include <common/constants.qh>
#include <common/effects/all.qh>
#include <common/net_linked.qh>
#include <common/physics/player.qh>
#include <common/state.qh>
#include <common/stats.qh>
#include <common/util.qh>
#include <common/vehicles/all.qh>
#include <common/weapons/_all.qh>
#include <lib/warpzone/common.qh>
#include <lib/warpzone/server.qh>
#include <server/bot/api.qh>
#include <server/command/common.qh>
#include <server/command/vote.qh>
#include <server/damage.qh>
#include <server/mutators/_mod.qh>
#include <server/player.qh>
#include <server/round_handler.qh>
#include <server/weapons/common.qh>
#include <server/weapons/csqcprojectile.qh>
#include <server/weapons/selection.qh>
#include <server/weapons/tracing.qh>
#include <server/weapons/weaponsystem.qh>
#include <server/world.qh>

Include dependency graph for hook.qc:

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

Go to the source code of this file.

Functions
void	FireGrapplingHook (entity actor,.entity weaponentity)
void	GrapplingHook_Damage (entity this, entity inflictor, entity attacker, float damage, int deathtype,.entity weaponentity, vector hitloc, vector force)
void	GrapplingHook_Stop (entity this)
void	GrapplingHookReset (entity this)
bool	GrapplingHookSend (entity this, entity to, int sf)
void	GrapplingHookThink (entity this)
void	GrapplingHookTouch (entity this, entity toucher)
	PRECACHE (GrappleHookInit)
void	RemoveGrapplingHooks (entity pl)
void	RemoveHook (entity this)

Variables
int	autocvar_g_grappling_hook_tarzan
vector	hook_end
vector	hook_start

Function Documentation

FireGrapplingHook()

void FireGrapplingHook	(	entity	actor,
		.entity	weaponentity
	)

Definition at line 364 of file hook.qc.

References autocvar_g_balance_grapplehook_damagedbycontents, autocvar_g_balance_grapplehook_gravity, autocvar_g_balance_grapplehook_health, autocvar_g_balance_grapplehook_speed_fly, CH_WEAPON_B, DAMAGE_AIM, EF_LOWPRECISION, entity(), g_bot_dodge, g_damagedbycontents, g_projectiles, GrapplingHook_Damage(), GrapplingHookReset(), GrapplingHookSend(), GrapplingHookThink(), GrapplingHookTouch(), hook, hook_shotorigin, IL_PUSH(), movedir, MOVETYPE_FLY, MOVETYPE_TOSS, PROJECTILE_MAKETRIGGER, RES_HEALTH, set_movetype(), setorigin(), SetResourceExplicit(), setthink, time, v_up, vectoangles(), vector(), W_GunAlign(), W_SetupProjVelocity_Explicit(), W_SetupShot_ProjectileSize, w_shotdir, w_shotorg, WarpZone_RefSys_SpawnSameRefSys(), and weaponLocked().

{
    if(weaponLocked(actor)) return;
    if(actor.vehicle) return;

    int s = W_GunAlign(actor.(weaponentity), STAT(GUNALIGN, actor)) - 1;
    vector vs = hook_shotorigin[s];
    vector oldmovedir = actor.(weaponentity).movedir;
    actor.(weaponentity).movedir = vs;
    W_SetupShot_ProjectileSize(actor, weaponentity, '-3 -3 -3', '3 3 3', true, 0, SND_HOOK_FIRE, CH_WEAPON_B, 0, WEP_HOOK.m_id);
    W_MuzzleFlash(WEP_HOOK, actor, weaponentity, w_shotorg, '0 0 0');
    actor.(weaponentity).movedir = oldmovedir;

    entity missile = WarpZone_RefSys_SpawnSameRefSys(actor);
    missile.owner = missile.realowner = actor;
    actor.(weaponentity).hook = missile;
    missile.weaponentity_fld = weaponentity;
    missile.reset = GrapplingHookReset;
    missile.classname = "grapplinghook";
    missile.flags = FL_PROJECTILE;
    IL_PUSH(g_projectiles, missile);
    IL_PUSH(g_bot_dodge, missile);

    set_movetype(missile, ((autocvar_g_balance_grapplehook_gravity) ? MOVETYPE_TOSS : MOVETYPE_FLY));
    PROJECTILE_MAKETRIGGER(missile);

    //setmodel (missile, MDL_HOOK); // precision set below
    setsize (missile, '-3 -3 -3', '3 3 3');
    setorigin(missile, w_shotorg);

    missile.state = 0; // not latched onto anything

    W_SetupProjVelocity_Explicit(missile, w_shotdir, v_up, autocvar_g_balance_grapplehook_speed_fly, 0, 0, 0, false);

    missile.angles = vectoangles (missile.velocity);
    //missile.glow_color = 250; // 244, 250
    //missile.glow_size = 120;
    settouch(missile, GrapplingHookTouch);
    setthink(missile, GrapplingHookThink);
    missile.nextthink = time;

    missile.effects = /*EF_FULLBRIGHT | EF_ADDITIVE |*/ EF_LOWPRECISION;

    SetResourceExplicit(missile, RES_HEALTH, autocvar_g_balance_grapplehook_health);
    missile.event_damage = GrapplingHook_Damage;
    missile.takedamage = DAMAGE_AIM;
    missile.damageforcescale = 0;
    missile.damagedbycontents = (autocvar_g_balance_grapplehook_damagedbycontents);
    if(missile.damagedbycontents)
        IL_PUSH(g_damagedbycontents, missile);

    missile.hook_start = missile.hook_end = missile.origin;

    Net_LinkEntity(missile, false, 0, GrapplingHookSend);
}

Here is the call graph for this function:

GrapplingHook_Damage()

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

Definition at line 342 of file hook.qc.

References autocvar_g_maxpushtime, GetResource(), PHYS_INPUT_BUTTON_CHAT, realowner, RemoveHook(), RES_HEALTH, TakeResource(), time, and W_CheckProjectileDamage().

Referenced by FireGrapplingHook().

{
    if(GetResource(this, RES_HEALTH) <= 0)
        return;

    if (!W_CheckProjectileDamage(inflictor.realowner, this.realowner, deathtype, -1)) // no exceptions
        return; // g_balance_projectiledamage says to halt

    TakeResource(this, RES_HEALTH, damage);

    if (GetResource(this, RES_HEALTH) <= 0)
    {
        if(attacker != this.realowner)
        {
            this.realowner.pusher = attacker;
            this.realowner.pushltime = time + autocvar_g_maxpushtime;
            this.realowner.istypefrag = PHYS_INPUT_BUTTON_CHAT(this.realowner);
        }
        RemoveHook(this);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GrapplingHook_Stop()

void GrapplingHook_Stop

(

entity

this

)

Definition at line 114 of file hook.qc.

References ATTEN_NORM, CH_SHOTS, func_null(), GrapplingHookThink(), hook_length, MOVETYPE_NONE, nextthink, origin, set_movetype(), setthink, sound, state, time, velocity, and VOL_BASE.

Referenced by GrapplingHookTouch().

{
    Send_Effect(EFFECT_HOOK_IMPACT, this.origin, '0 0 0', 1);
    sound (this, CH_SHOTS, SND_HOOK_IMPACT, VOL_BASE, ATTEN_NORM);

    this.state = 1;
    setthink(this, GrapplingHookThink);
    this.nextthink = time;
    settouch(this, func_null);
    this.velocity = '0 0 0';
    set_movetype(this, MOVETYPE_NONE);
    this.hook_length = -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GrapplingHookReset()

void GrapplingHookReset

(

entity

this

)

Definition at line 109 of file hook.qc.

References RemoveHook().

Referenced by FireGrapplingHook().

{
    RemoveHook(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GrapplingHookSend()

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

Definition at line 129 of file hook.qc.

References etof(), hook_end, hook_start, MSG_BROADCAST, realowner, weaponentity_fld, weaponslot(), and WriteByte().

Referenced by FireGrapplingHook().

{
    WriteHeader(MSG_ENTITY, ENT_CLIENT_HOOK);
    sf = sf & 0x7F;
    if(sound_allowed(MSG_BROADCAST, this.realowner))
        sf |= 0x80;
    WriteByte(MSG_ENTITY, sf);
    if(sf & 1)
    {
        WriteByte(MSG_ENTITY, etof(this.realowner));
        WriteByte(MSG_ENTITY, weaponslot(this.weaponentity_fld));
    }
    if(sf & 2)
    {
        WriteVector(MSG_ENTITY, this.hook_start);
    }
    if(sf & 4)
    {
        WriteVector(MSG_ENTITY, this.hook_end);
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GrapplingHookThink()

void GrapplingHookThink

(

entity

this

)

Definition at line 154 of file hook.qc.

References aiment, angles, autocvar_g_balance_grapplehook_airfriction, autocvar_g_balance_grapplehook_force_rubber, autocvar_g_balance_grapplehook_force_rubber_overstretch, autocvar_g_balance_grapplehook_length_min, autocvar_g_balance_grapplehook_nade_time, autocvar_g_balance_grapplehook_pull_frozen, autocvar_g_balance_grapplehook_speed_pull, autocvar_g_balance_grapplehook_stretch, autocvar_g_grappling_hook_tarzan, autocvar_g_maxpushtime, bound(), dir, entity(), error(), frametime, hook_end, hook_length, HOOK_PULLING, HOOK_RELEASING, hook_shotorigin, hook_start, IS_VEHICLE, M_ARGV, makevectors, max(), move_movetype, MOVETYPE_FLY, MOVETYPE_FOLLOW, MOVETYPE_WALK, MUTATOR_CALLHOOK, nextthink, normalize(), origin, PHYS_INPUT_BUTTON_CHAT, realowner, RemoveHook(), round_handler_IsActive, round_handler_IsRoundStarted, set_movetype(), state, time, UNSET_ONGROUND, UpdateCSQCProjectile(), v, v_forward, v_right, v_up, vector(), vlen(), W_GunAlign(), WarpZone_RefSys_AddIncrementally(), WarpZone_RefSys_TransformOrigin(), WarpZone_RefSys_TransformVelocity(), and weaponentity_fld.

Referenced by FireGrapplingHook(), and GrapplingHook_Stop().

{
    float spd, dist, minlength, pullspeed, ropestretch, ropeairfriction, rubberforce, newlength, rubberforce_overstretch;
    vector dir, org, end, v0, dv, v, myorg, vs;
    .entity weaponentity = this.weaponentity_fld;
    if(this.realowner.(weaponentity).hook != this)  // how did that happen?
    {
        error("Owner lost the hook!\n");
        return;
    }
    if((this.move_movetype == MOVETYPE_FOLLOW && LostMovetypeFollow(this))
        || game_stopped || (round_handler_IsActive() && !round_handler_IsRoundStarted())
        || ((this.aiment.flags & FL_PROJECTILE) && this.aiment.classname != "nade"))
    {
        RemoveHook(this);
        return;
    }
    if(this.aiment)
        WarpZone_RefSys_AddIncrementally(this, this.aiment);

    this.nextthink = time;

    int s = W_GunAlign(this.realowner.(weaponentity), STAT(GUNALIGN, this.realowner)) - 1;
    vs = hook_shotorigin[s];

    makevectors(this.realowner.v_angle);
    org = this.realowner.origin + this.realowner.view_ofs + v_forward * vs.x + v_right * -vs.y + v_up * vs.z;
    myorg = WarpZone_RefSys_TransformOrigin(this.realowner, this, org);

    if(this.hook_length < 0)
        this.hook_length = vlen(myorg - this.origin);

    int tarzan = autocvar_g_grappling_hook_tarzan;
    entity pull_entity = this.realowner;
    float velocity_multiplier = 1;
    MUTATOR_CALLHOOK(GrappleHookThink, this, tarzan, pull_entity, velocity_multiplier);
    tarzan = M_ARGV(1, int);
    pull_entity = M_ARGV(2, entity);
    velocity_multiplier = M_ARGV(3, float);

    if(this.state == 1)
    {
        pullspeed = autocvar_g_balance_grapplehook_speed_pull;//2000;
        // speed the rope is pulled with

        rubberforce = autocvar_g_balance_grapplehook_force_rubber;//2000;
        // force the rope will use if it is stretched

        rubberforce_overstretch = autocvar_g_balance_grapplehook_force_rubber_overstretch;//1000;
        // force the rope will use if it is stretched

        minlength = autocvar_g_balance_grapplehook_length_min;//100;
        // minimal rope length
        // if the rope goes below this length, it isn't pulled any more

        ropestretch = autocvar_g_balance_grapplehook_stretch;//400;
        // if the rope is stretched by more than this amount, more rope is
        // given to you again

        ropeairfriction = autocvar_g_balance_grapplehook_airfriction;//0.2
        // while hanging on the rope, this friction component will help you a
        // bit to control the rope

        bool frozen_pulling = (autocvar_g_grappling_hook_tarzan >= 2 && autocvar_g_balance_grapplehook_pull_frozen);

        dir = this.origin - myorg;
        dist = vlen(dir);
        dir = normalize(dir);

        if(tarzan)
        {
            v = v0 = WarpZone_RefSys_TransformVelocity(pull_entity, this, pull_entity.velocity);

            // first pull the rope...
            if(this.realowner.(weaponentity).hook_state & HOOK_PULLING)
            {
                newlength = this.hook_length;
                newlength = max(newlength - pullspeed * frametime, minlength);

                if(newlength < dist - ropestretch) // overstretched?
                {
                    newlength = dist - ropestretch;
                    if(v * dir < 0) // only if not already moving in hook direction
                        v = v + frametime * dir * rubberforce_overstretch;
                }

                this.hook_length = newlength;
            }

            if(pull_entity.move_movetype == MOVETYPE_FLY)
                set_movetype(pull_entity, MOVETYPE_WALK);

            if(this.realowner.(weaponentity).hook_state & HOOK_RELEASING)
            {
                newlength = dist;
                this.hook_length = newlength;
            }
            else
            {
                // then pull the player
                spd = bound(0, (dist - this.hook_length) / ropestretch, 1);
                v = v * (1 - frametime * ropeairfriction);
                v = v + frametime * dir * spd * rubberforce;

                dv = ((v - v0) * dir) * dir;
                if(tarzan >= 2)
                {
                    if(this.aiment.move_movetype == MOVETYPE_WALK || this.aiment.classname == "nade")
                    {
                        entity aim_ent = ((IS_VEHICLE(this.aiment) && this.aiment.owner) ? this.aiment.owner : this.aiment);
                        v = v - dv * 0.5;
                        if((frozen_pulling && STAT(FROZEN, this.aiment)) || !frozen_pulling)
                        {
                            this.aiment.velocity = this.aiment.velocity - dv * 0.5;
                            UNSET_ONGROUND(this.aiment);
                            if(this.aiment.flags & FL_PROJECTILE)
                                UpdateCSQCProjectile(this.aiment);
                        }
                        if(this.aiment.classname == "nade")
                            this.aiment.nextthink = time + autocvar_g_balance_grapplehook_nade_time; // set time after letting go?
                        aim_ent.pusher = this.realowner;
                        aim_ent.pushltime = time + autocvar_g_maxpushtime;
                        aim_ent.istypefrag = PHYS_INPUT_BUTTON_CHAT(aim_ent);
                    }
                }

                UNSET_ONGROUND(pull_entity);
            }

            if(!frozen_pulling && !(this.aiment.flags & FL_PROJECTILE))
                pull_entity.velocity = WarpZone_RefSys_TransformVelocity(this, pull_entity, v * velocity_multiplier);

            if(frozen_pulling && autocvar_g_balance_grapplehook_pull_frozen == 2 && !STAT(FROZEN, this.aiment))
            {
                RemoveHook(this);
                return;
            }
        }
        else
        {
            end = this.origin - dir*50;
            dist = vlen(end - myorg);
            if(dist < 200)
                spd = dist * (pullspeed / 200);
            else
                spd = pullspeed;
            if(spd < 50)
                spd = 0;
            this.realowner.velocity = dir*spd;
            set_movetype(this.realowner, MOVETYPE_FLY);

            UNSET_ONGROUND(this.realowner);
        }
    }

    makevectors(this.angles.x * '-1 0 0' + this.angles.y * '0 1 0');
    myorg = WarpZone_RefSys_TransformOrigin(this, this.realowner, this.origin); // + v_forward * (-9);

    if(myorg != this.hook_start)
    {
        this.SendFlags |= 2;
        this.hook_start = myorg;
    }
    if(org != this.hook_end)
    {
        this.SendFlags |= 4;
        this.hook_end = org;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GrapplingHookTouch()

void GrapplingHookTouch	(	entity	this,
		entity	toucher
	)

Definition at line 324 of file hook.qc.

References aiment, GrapplingHook_Stop(), MOVETYPE_FOLLOW, PROJECTILE_TOUCH, and WarpZone_RefSys_BeginAddingIncrementally().

Referenced by FireGrapplingHook().

{
    if(toucher.move_movetype == MOVETYPE_FOLLOW)
        return;
    PROJECTILE_TOUCH(this, toucher);

    GrapplingHook_Stop(this);

    if(toucher)
        //if(toucher.move_movetype != MOVETYPE_NONE)
        {
            SetMovetypeFollow(this, toucher);
            WarpZone_RefSys_BeginAddingIncrementally(this, this.aiment);
        }

    //this.realowner.disableclientprediction = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRECACHE()

PRECACHE

(

GrappleHookInit

)

Definition at line 421 of file hook.qc.

References CL_Weapon_GetShotOrg(), g_grappling_hook, and hook_shotorigin.

{
    if(g_grappling_hook)
    {
        hook_shotorigin[0] = '8 8 -12';
        hook_shotorigin[1] = '8 8 -12';
        hook_shotorigin[2] = '8 8 -12';
        hook_shotorigin[3] = '8 8 -12';
    }
    else
    {
        Weapon w = WEP_HOOK;
        w.wr_init(w);
        hook_shotorigin[0] = shotorg_adjust_values(CL_Weapon_GetShotOrg(WEP_HOOK.m_id), false, false, 1);
        hook_shotorigin[1] = shotorg_adjust_values(CL_Weapon_GetShotOrg(WEP_HOOK.m_id), false, false, 2);
        hook_shotorigin[2] = shotorg_adjust_values(CL_Weapon_GetShotOrg(WEP_HOOK.m_id), false, false, 3);
        hook_shotorigin[3] = shotorg_adjust_values(CL_Weapon_GetShotOrg(WEP_HOOK.m_id), false, false, 4);
    }
}

Here is the call graph for this function:

RemoveGrapplingHooks()

void RemoveGrapplingHooks

(

entity

pl

)

Definition at line 78 of file hook.qc.

References hook, MAX_WEAPONSLOTS, MOVETYPE_FLY, MOVETYPE_WALK, NULL, set_movetype(), and weaponentities.

Referenced by ClientDisconnect(), Freeze(), PlayerDamage(), PutObserverInServer(), Teleport_Touch(), and vehicles_enter().

{
    if(pl.move_movetype == MOVETYPE_FLY)
        set_movetype(pl, MOVETYPE_WALK);

    for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
    {
        .entity weaponentity = weaponentities[slot];
        if(!pl.(weaponentity))
            continue; // continue incase other slots exist?
        if(pl.(weaponentity).hook)
            delete(pl.(weaponentity).hook);
        pl.(weaponentity).hook = NULL;
    }

    //pl.disableclientprediction = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveHook()

void RemoveHook

(

entity

this

)

Definition at line 96 of file hook.qc.

References entity(), MOVETYPE_FLY, MOVETYPE_WALK, NULL, realowner, set_movetype(), and weaponentity_fld.

Referenced by Damage(), Freeze(), GrapplingHook_Damage(), GrapplingHookReset(), GrapplingHookThink(), MUTATOR_HOOKFUNCTION(), Unfreeze(), vehicles_spawn(), and WarpZone_Projectile_Touch_ImpactFilter_Callback().

{
    entity player = this.realowner;
    .entity weaponentity = this.weaponentity_fld;

    if(player.(weaponentity).hook == this)
        player.(weaponentity).hook = NULL;

    if(player.move_movetype == MOVETYPE_FLY)
        set_movetype(player, MOVETYPE_WALK);
    delete(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

autocvar_g_grappling_hook_tarzan

int autocvar_g_grappling_hook_tarzan

Definition at line 152 of file hook.qc.

Referenced by GrapplingHookThink().

hook_end

vector hook_end

Definition at line 128 of file hook.qc.

Referenced by GrapplingHookSend(), and GrapplingHookThink().

hook_start

vector hook_start

Definition at line 128 of file hook.qc.

Referenced by GrapplingHookSend(), and GrapplingHookThink().