sv_weapon.qc File Reference

#include "sv_weapon.qh"

Include dependency graph for sv_weapon.qc:

Go to the source code of this file.

Functions
vector	trigger_push_calculatevelocity (vector org, entity tgt, float ht, entity pushed_entity)
void	W_Nexball_Attack (Weapon thiswep, entity actor,.entity weaponentity, float t)
void	W_Nexball_Attack2 (Weapon thiswep, entity actor,.entity weaponentity)
void	W_Nexball_Think (entity this)
void	W_Nexball_Touch (entity this, entity toucher)

Function Documentation

trigger_push_calculatevelocity()

vector trigger_push_calculatevelocity	(	vector	org,
		entity	tgt,
		float	ht,
		entity	pushed_entity
	)

Definition at line 31 of file jumppads.qc.

Referenced by W_Nexball_Attack2().

{
    float grav, sdist, zdist, vs, vz, jumpheight;
    vector sdir, torg;

    torg = tgt.origin + (tgt.mins + tgt.maxs) * 0.5;

    grav = PHYS_GRAVITY(NULL);
    if(pushed_entity && pushed_entity.gravity)
        grav *= pushed_entity.gravity;

    zdist = torg.z - org.z;
    sdist = vlen(torg - org - zdist * '0 0 1');
    sdir = normalize(torg - org - zdist * '0 0 1');

    // how high do we need to push the player?
    jumpheight = fabs(ht);
    if(zdist > 0)
        jumpheight = jumpheight + zdist;

    /*
        STOP.

        You will not understand the following equations anyway...
        But here is what I did to get them.

        I used the functions

          s(t) = t * vs
          z(t) = t * vz - 1/2 grav t^2

        and solved for:

          s(ti) = sdist
          z(ti) = zdist
          max(z, ti) = jumpheight

        From these three equations, you will find the three parameters vs, vz
        and ti.
     */

    // push him so high...
    vz = sqrt(fabs(2 * grav * jumpheight)); // NOTE: sqrt(positive)!

    // we start with downwards velocity only if it's a downjump and the jump apex should be outside the jump!
    if(ht < 0)
        if(zdist < 0)
            vz = -vz;

    vector solution;
    solution = solve_quadratic(0.5 * grav, -vz, zdist); // equation "z(ti) = zdist"
    // ALWAYS solvable because jumpheight >= zdist
    if(!solution.z)
        solution_y = solution.x; // just in case it is not solvable due to roundoff errors, assume two equal solutions at their center (this is mainly for the usual case with ht == 0)
    if(zdist == 0)
        solution_x = solution.y; // solution_x is 0 in this case, so don't use it, but rather use solution_y (which will be sqrt(0.5 * jumpheight / grav), actually)

    float flighttime;
    if(zdist < 0)
    {
        // down-jump
        if(ht < 0)
        {
            // almost straight line type
            // jump apex is before the jump
            // we must take the larger one
            flighttime = solution.y;
        }
        else
        {
            // regular jump
            // jump apex is during the jump
            // we must take the larger one too
            flighttime = solution.y;
        }
    }
    else
    {
        // up-jump
        if(ht < 0)
        {
            // almost straight line type
            // jump apex is after the jump
            // we must take the smaller one
            flighttime = solution.x;
        }
        else
        {
            // regular jump
            // jump apex is during the jump
            // we must take the larger one
            flighttime = solution.y;
        }
    }
    vs = sdist / flighttime;

    // finally calculate the velocity
    return sdir * vs + '0 0 1' * vz;
}

Here is the caller graph for this function:

W_Nexball_Attack()

void W_Nexball_Attack	(	Weapon	thiswep,
		entity	actor,
		.entity	weaponentity,
		float	t
	)

Definition at line 108 of file sv_weapon.qc.

References autocvar_g_balance_nexball_primary_speed, autocvar_g_nexball_basketball_meter_maxpower, autocvar_g_nexball_basketball_meter_minpower, BALL_MAXS, BALL_MINS, CH_WEAPON_A, DropBall(), entity(), g_nexball_meter_period, max(), MOVE_WORLDONLY, NULL, trace_startsolid, W_CalculateProjectileVelocity(), W_SetupShot, w_shotdir, and w_shotorg.

{
    entity ball;
    float mul, mi, ma;
    if(!(ball = actor.ballcarried))
        return;

    W_SetupShot(actor, weaponentity, false, 4, SND_NB_SHOOT1, CH_WEAPON_A, 0, WEP_PORTO.m_id); // TODO: use ballstealer weapon here? we don't want duplicates in the scoreboard
    tracebox(w_shotorg, BALL_MINS, BALL_MAXS, w_shotorg, MOVE_WORLDONLY, NULL);
    if(trace_startsolid)
    {
        if(STAT(NB_METERSTART, actor))
            STAT(NB_METERSTART, actor) = 0; // Shot failed, hide the power meter
        return;
    }

    //Calculate multiplier
    if(t < 0)
        mul = 1;
    else
    {
        mi = autocvar_g_nexball_basketball_meter_minpower;
        ma = max(mi, autocvar_g_nexball_basketball_meter_maxpower); // avoid confusion
        //One triangle wave period with 1 as max
        mul = 2 * (t % g_nexball_meter_period) / g_nexball_meter_period;
        if(mul > 1)
            mul = 2 - mul;
        mul = mi + (ma - mi) * mul; // range from the minimal power to the maximal power
    }

    DropBall(ball, w_shotorg, W_CalculateProjectileVelocity(actor, actor.velocity, w_shotdir * autocvar_g_balance_nexball_primary_speed * mul, false));


    //TODO: use the speed_up cvar too ??
}

Here is the call graph for this function:

W_Nexball_Attack2()

void W_Nexball_Attack2	(	Weapon	thiswep,
		entity	actor,
		.entity	weaponentity
	)

Definition at line 144 of file sv_weapon.qc.

References autocvar_g_balance_nexball_secondary_lifetime, autocvar_g_balance_nexball_secondary_speed, autocvar_g_nexball_tackling, CH_WEAPON_A, CSQCProjectile(), DropBall(), EF_BRIGHTFIELD, EF_LOWPRECISION, entity(), g_bot_dodge, g_projectiles, HITTYPE_SECONDARY, IL_PUSH(), MOVETYPE_FLY, PROJECTILE_ELECTRO, PROJECTILE_MAKETRIGGER, set_movetype(), setorigin(), setthink, time, trigger_push_calculatevelocity(), vectoangles(), W_Nexball_Think(), W_Nexball_Touch(), W_SetupProjVelocity_Basic, W_SetupShot, and w_shotorg.

{
    if(actor.ballcarried.enemy)
    {
        entity _ball = actor.ballcarried;
        W_SetupShot(actor, weaponentity, false, 4, SND_NB_SHOOT1, CH_WEAPON_A, 0, WEP_PORTO.m_id | HITTYPE_SECONDARY); // TODO: use the ball stealer weapon here? probably don't want duplicates
        DropBall(_ball, w_shotorg, trigger_push_calculatevelocity(_ball.origin, _ball.enemy, 32, _ball));
        setthink(_ball, W_Nexball_Think);
        _ball.nextthink = time;
        return;
    }

    if(!autocvar_g_nexball_tackling)
        return;

    W_SetupShot(actor, weaponentity, false, 2, SND_NB_SHOOT2, CH_WEAPON_A, 0, WEP_PORTO.m_id);
    entity missile = new(ballstealer);

    missile.owner = actor;

    set_movetype(missile, MOVETYPE_FLY);
    PROJECTILE_MAKETRIGGER(missile);

    //setmodel(missile, "models/elaser.mdl");  // precision set below
    setsize(missile, '0 0 0', '0 0 0');
    setorigin(missile, w_shotorg);

    W_SetupProjVelocity_Basic(missile, autocvar_g_balance_nexball_secondary_speed, 0);
    missile.angles = vectoangles(missile.velocity);
    settouch(missile, W_Nexball_Touch);
    setthink(missile, SUB_Remove);
    missile.nextthink = time + autocvar_g_balance_nexball_secondary_lifetime; //FIXME: use a distance instead?

    missile.effects = EF_BRIGHTFIELD | EF_LOWPRECISION;
    missile.flags = FL_PROJECTILE;
    IL_PUSH(g_projectiles, missile);
    IL_PUSH(g_bot_dodge, missile);

    CSQCProjectile(missile, true, PROJECTILE_ELECTRO, true);
}

Here is the call graph for this function:

W_Nexball_Think()

void W_Nexball_Think

(

entity

this

)

Definition at line 62 of file sv_weapon.qc.

References autocvar_g_nexball_safepass_turnrate, enemy, nextthink, normalize(), time, vector(), velocity, and vlen().

Referenced by W_Nexball_Attack2().

{
    //dprint("W_Nexball_Think\n");
    //vector new_dir = steerlib_arrive(this.enemy.origin, 2500);
    vector new_dir = normalize(this.enemy.origin + '0 0 50' - this.origin);
    vector old_dir = normalize(this.velocity);
    float _speed = vlen(this.velocity);
    vector new_vel = normalize(old_dir + (new_dir * autocvar_g_nexball_safepass_turnrate)) * _speed;
    //vector new_vel = (new_dir * autocvar_g_nexball_safepass_turnrate

    this.velocity = new_vel;

    this.nextthink = time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

W_Nexball_Touch()

void W_Nexball_Touch	(	entity	this,
		entity	toucher
	)

Definition at line 77 of file sv_weapon.qc.

References _sound, ATTEN_NORM, autocvar_g_balance_nexball_secondary_force, autocvar_g_nexball_basketball_teamsteal, CH_TRIGGER, CS(), entity(), GiveBall(), IS_DEAD, IS_PLAYER, LogNB(), normalize(), owner, PROJECTILE_TOUCH, SAME_TEAM, teamkill_complain, time, UNSET_ONGROUND, velocity, and VOL_BASE.

Referenced by W_Nexball_Attack2().

{
    entity ball, attacker;
    attacker = this.owner;
    //this.think = func_null;
    //this.enemy = NULL;

    PROJECTILE_TOUCH(this, toucher);
    if(attacker.team != toucher.team || autocvar_g_nexball_basketball_teamsteal)
        if((ball = toucher.ballcarried) && !STAT(FROZEN, toucher) && !IS_DEAD(toucher) && (IS_PLAYER(attacker)))
        {
            toucher.velocity = toucher.velocity + normalize(this.velocity) * toucher.damageforcescale * autocvar_g_balance_nexball_secondary_force;
            UNSET_ONGROUND(toucher);
            if(!attacker.ballcarried)
            {
                LogNB("stole", attacker);
                _sound(toucher, CH_TRIGGER, ball.noise2, VOL_BASE, ATTEN_NORM);

                if(SAME_TEAM(attacker, toucher) && time > CS(attacker).teamkill_complain)
                {
                    CS(attacker).teamkill_complain = time + 5;
                    CS(attacker).teamkill_soundtime = time + 0.4;
                    CS(attacker).teamkill_soundsource = toucher;
                }

                GiveBall(attacker, toucher.ballcarried);
            }
        }
    delete(this);
}

Here is the call graph for this function:

Here is the caller graph for this function: