subs.qc File Reference

#include "subs.qh"

Include dependency graph for subs.qc:

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

Go to the source code of this file.

Functions
void	SUB_CalcAngleMove (entity this, vector destangle, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcAngleMoveDone (entity this)
void	SUB_CalcAngleMoveEnt (entity ent, vector destangle, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMove (entity this, vector tdest, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMove_Bezier (entity this, vector tcontrol, vector tdest, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_CalcMove_controller_setbezier (entity controller, vector org, vector control, vector destin)
void	SUB_CalcMove_controller_setlinear (entity controller, vector org, vector destin)
void	SUB_CalcMove_controller_think (entity this)
void	SUB_CalcMoveDone (entity this)
void	SUB_CalcMoveEnt (entity ent, vector tdest, float tspeedtype, float tspeed, void(entity this) func)
void	SUB_Friction (entity this)
void	SUB_NullThink (entity this)
void	SUB_SetFade (entity ent, float vanish_time, float fading_time)
void	SUB_SetFade_Think (entity this)
void	SUB_VanishOrRemove (entity ent)

Variables
float	friction
float	platmovetype_turn

Function Documentation

SUB_CalcAngleMove()

void SUB_CalcAngleMove	(	entity	this,
		vector	destangle,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func
	)

Definition at line 331 of file subs.qc.

References angles, avelocity, finalangle, floor(), ltime, nextthink, objerror(), setthink, SUB_CalcAngleMoveDone(), TSPEED_END, TSPEED_LINEAR, TSPEED_START, TSPEED_TIME, vector(), and vlen().

Referenced by SUB_CalcAngleMoveEnt(), and train_wait().

{
    if (!tspeed)
        objerror (this, "No speed is defined!");

    // take the shortest distance for the angles
    this.angles_x -= 360 * floor((this.angles_x - destangle_x) / 360 + 0.5);
    this.angles_y -= 360 * floor((this.angles_y - destangle_y) / 360 + 0.5);
    this.angles_z -= 360 * floor((this.angles_z - destangle_z) / 360 + 0.5);
    vector delta = destangle - this.angles;
    float traveltime;

    switch(tspeedtype)
    {
        default:
        case TSPEED_START:
        case TSPEED_END:
        case TSPEED_LINEAR:
            traveltime = vlen (delta) / tspeed;
            break;
        case TSPEED_TIME:
            traveltime = tspeed;
            break;
    }

    this.think1 = func;
    this.finalangle = destangle;
    setthink(this, SUB_CalcAngleMoveDone);

    if (traveltime < 0.1)
    {
        this.avelocity = '0 0 0';
        this.nextthink = this.ltime + 0.1;
        return;
    }

    this.avelocity = delta * (1 / traveltime);
    this.nextthink = this.ltime + traveltime;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcAngleMoveDone()

void SUB_CalcAngleMoveDone

(

entity

this

)

Definition at line 320 of file subs.qc.

References angles, avelocity, finalangle, nextthink, and SUB_CalcAngleMoveDone().

Referenced by SUB_CalcAngleMove(), SUB_CalcAngleMoveDone(), and SUB_NullThink().

{
    // After rotating, set angle to exact final angle
    this.angles = this.finalangle;
    this.avelocity = '0 0 0';
    this.nextthink = -1;
    if (this.think1 && this.think1 != SUB_CalcAngleMoveDone) // avoid endless loops
        this.think1 (this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcAngleMoveEnt()

void SUB_CalcAngleMoveEnt	(	entity	ent,
		vector	destangle,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func
	)

Definition at line 371 of file subs.qc.

References anglemods(), angles, endsWith, entity(), find(), getSendEntity, InitializeEntity(), lodmodelindex0, lodmodelindex1, lodmodelindex2, makevectors, max(), maxs, mins, model, modelindex, movedir, MOVETYPE_NONE, MOVETYPE_PUSH, normalize(), NULL, objerror(), origin, set_movetype(), setorigin(), solid, SOLID_BSP, SOLID_TRIGGER, SUB_CalcAngleMove(), targetname, v_forward, vdist, vector(), and vlen().

{
    SUB_CalcAngleMove (ent, destangle, tspeedtype, tspeed, func);
}

Here is the call graph for this function:

SUB_CalcMove()

void SUB_CalcMove	(	entity	this,
		vector	tdest,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func
	)

Definition at line 256 of file subs.qc.

References finaldest, ltime, nextthink, objerror(), origin, platmovetype_end, platmovetype_start, setthink, SUB_CalcMove_Bezier(), SUB_CalcMoveDone(), TSPEED_END, TSPEED_LINEAR, TSPEED_START, TSPEED_TIME, vector(), velocity, and vlen().

Referenced by door_go_down(), door_go_up(), plat_go_down(), plat_go_up(), SUB_CalcMoveEnt(), and train_next().

{
    vector  delta;
    float   traveltime;

    if (!tspeed)
        objerror (this, "No speed is defined!");

    this.think1 = func;
    this.finaldest = tdest;
    setthink(this, SUB_CalcMoveDone);

    if (tdest == this.origin)
    {
        this.velocity = '0 0 0';
        this.nextthink = this.ltime + 0.1;
        return;
    }

    delta = tdest - this.origin;

    switch(tspeedtype)
    {
        default:
        case TSPEED_START:
        case TSPEED_END:
        case TSPEED_LINEAR:
            traveltime = vlen (delta) / tspeed;
            break;
        case TSPEED_TIME:
            traveltime = tspeed;
            break;
    }

    // Very short animations don't really show off the effect
    // of controlled animation, so let's just use linear movement.
    // Alternatively entities can choose to specify non-controlled movement.
    // The only currently implemented alternative movement is linear (value 1)
    if (traveltime < 0.15 || (this.platmovetype_start == 1 && this.platmovetype_end == 1)) // is this correct?
    {
        this.velocity = delta * (1/traveltime); // QuakeC doesn't allow vector/float division
        this.nextthink = this.ltime + traveltime;
        return;
    }

    // now just run like a bezier curve...
    SUB_CalcMove_Bezier(this, (this.origin + tdest) * 0.5, tdest, tspeedtype, tspeed, func);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcMove_Bezier()

void SUB_CalcMove_Bezier	(	entity	this,
		vector	tcontrol,
		vector	tdest,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func
	)

Definition at line 194 of file subs.qc.

References entity(), finaldest, getthink, ltime, move_controller, new_pure, nextthink, NULL, objerror(), origin, platmovetype, platmovetype_end, platmovetype_start, setthink, SUB_CalcMove_controller_setbezier(), SUB_CalcMove_controller_think(), SUB_CalcMoveDone(), SUB_NullThink(), time, TSPEED_END, TSPEED_LINEAR, TSPEED_START, TSPEED_TIME, velocity, and vlen().

Referenced by SUB_CalcMove(), and train_next().

{
    float   traveltime;
    entity controller;

    if (!tspeed)
        objerror (this, "No speed is defined!");

    this.think1 = func;
    this.finaldest = tdest;
    setthink(this, SUB_CalcMoveDone);

    switch(tspeedtype)
    {
        default:
        case TSPEED_START:
            traveltime = 2 * vlen(tcontrol - this.origin) / tspeed;
            break;
        case TSPEED_END:
            traveltime = 2 * vlen(tcontrol - tdest)       / tspeed;
            break;
        case TSPEED_LINEAR:
            traveltime = vlen(tdest - this.origin)        / tspeed;
            break;
        case TSPEED_TIME:
            traveltime = tspeed;
            break;
    }

    if (traveltime < 0.1) // useless anim
    {
        this.velocity = '0 0 0';
        this.nextthink = this.ltime + 0.1;
        return;
    }

    // delete the previous controller, otherwise changing movement midway is glitchy
    if (this.move_controller != NULL)
    {
        delete(this.move_controller);
    }
    controller = new_pure(SUB_CalcMove_controller);
    controller.owner = this;
    this.move_controller = controller;
    controller.platmovetype = this.platmovetype;
    controller.platmovetype_start = this.platmovetype_start;
    controller.platmovetype_end = this.platmovetype_end;
    SUB_CalcMove_controller_setbezier(controller, this.origin, tcontrol, tdest);
    controller.finaldest = (tdest + '0 0 0.125'); // where do we want to end? Offset to overshoot a bit.
    controller.animstate_starttime = time;
    controller.animstate_endtime = time + traveltime;
    setthink(controller, SUB_CalcMove_controller_think);
    controller.think1 = getthink(this);

    // the thinking is now done by the controller
    setthink(this, SUB_NullThink); // for PushMove
    this.nextthink = this.ltime + traveltime;

    // invoke controller
    getthink(controller)(controller);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcMove_controller_setbezier()

void SUB_CalcMove_controller_setbezier	(	entity	controller,
		vector	org,
		vector	control,
		vector	destin
	)

Definition at line 166 of file subs.qc.

References setorigin().

Referenced by SUB_CalcMove_Bezier().

{
    // 0 * (1-t) * (1-t) + 2 * control * t * (1-t) + destin * t * t
    // 2 * control * t - 2 * control * t * t + destin * t * t
    // 2 * control * t + (destin - 2 * control) * t * t

    setorigin(controller, org);
    control -= org;
    destin -= org;

    controller.destvec = 2 * control; // control point
    controller.destvec2 = destin - 2 * control; // quadratic part required to reach end point
    // also: initial d/dphasepos origin = 2 * control, final speed = 2 * (destin - control)
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcMove_controller_setlinear()

void SUB_CalcMove_controller_setlinear	(	entity	controller,
		vector	org,
		vector	destin
	)

Definition at line 181 of file subs.qc.

References setorigin().

{
    // 0 * (1-t) * (1-t) + 2 * control * t * (1-t) + destin * t * t
    // 2 * control * t - 2 * control * t * t + destin * t * t
    // 2 * control * t + (destin - 2 * control) * t * t

    setorigin(controller, org);
    destin -= org;

    controller.destvec = destin; // end point
    controller.destvec2 = '0 0 0';
}

Here is the call graph for this function:

SUB_CalcMove_controller_think()

void SUB_CalcMove_controller_think

(

entity

this

)

Definition at line 106 of file subs.qc.

References animstate_endtime, animstate_starttime, cubic_speedfunc(), destvec, destvec2, entity(), finaldest, floor(), getthink, nextthink, NULL, origin, owner, platmovetype_end, platmovetype_start, setthink, time, v, vectoangles(), and vector().

Referenced by SUB_CalcMove_Bezier().

{
    float traveltime;
    float phasepos;
    float nexttick;
    vector delta;
    vector delta2;
    vector veloc;
    vector angloc;
    vector nextpos;
    delta = this.destvec;
    delta2 = this.destvec2;
    if(time < this.animstate_endtime)
    {
        nexttick = time + PHYS_INPUT_FRAMETIME;

        traveltime = this.animstate_endtime - this.animstate_starttime;
        phasepos = (nexttick - this.animstate_starttime) / traveltime; // range: [0, 1]
        phasepos = cubic_speedfunc(this.platmovetype_start, this.platmovetype_end, phasepos);
        nextpos = this.origin + (delta * phasepos) + (delta2 * phasepos * phasepos);
        // derivative: delta + 2 * delta2 * phasepos (e.g. for angle positioning)

        if(this.owner.platmovetype_turn)
        {
            vector destangle;
            destangle = delta + 2 * delta2 * phasepos;
            destangle = vectoangles(destangle);
            destangle_x = -destangle_x; // flip up / down orientation

            // take the shortest distance for the angles
            vector v = this.owner.angles;
            v.x -= 360 * floor((v.x - destangle_x) / 360 + 0.5);
            v.y -= 360 * floor((v.y - destangle_y) / 360 + 0.5);
            v.z -= 360 * floor((v.z - destangle_z) / 360 + 0.5);
            this.owner.angles = v;
            angloc = destangle - this.owner.angles;
            angloc = angloc * (1 / PHYS_INPUT_FRAMETIME); // so it arrives for the next frame
            this.owner.avelocity = angloc;
        }
        if(nexttick < this.animstate_endtime)
            veloc = nextpos - this.owner.origin;
        else
            veloc = this.finaldest - this.owner.origin;
        veloc = veloc * (1 / PHYS_INPUT_FRAMETIME); // so it arrives for the next frame

        this.owner.velocity = veloc;
        this.nextthink = nexttick;
    }
    else
    {
        // derivative: delta + 2 * delta2 (e.g. for angle positioning)
        entity own = this.owner;
        setthink(own, this.think1);
        // set the owner's reference to this entity to NULL
        own.move_controller = NULL;
        delete(this);
        getthink(own)(own);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcMoveDone()

void SUB_CalcMoveDone

(

entity

this

)

Definition at line 94 of file subs.qc.

References finaldest, nextthink, setorigin(), SUB_CalcMoveDone(), and velocity.

Referenced by SUB_CalcMove(), SUB_CalcMove_Bezier(), SUB_CalcMoveDone(), and SUB_NullThink().

{
    // After moving, set origin to exact final destination

    setorigin (this, this.finaldest);
    this.velocity = '0 0 0';
    this.nextthink = -1;
    if (this.think1 && this.think1 != SUB_CalcMoveDone)
        this.think1 (this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_CalcMoveEnt()

void SUB_CalcMoveEnt	(	entity	ent,
		vector	tdest,
		float	tspeedtype,
		float	tspeed,
		void(entity this)	func
	)

Definition at line 305 of file subs.qc.

References SUB_CalcMove().

{
    SUB_CalcMove(ent, tdest, tspeedtype, tspeed, func);
}

Here is the call graph for this function:

SUB_Friction()

void SUB_Friction

(

entity

this

)

Definition at line 24 of file subs.qc.

References frametime, friction, IS_ONGROUND, nextthink, time, and velocity.

{
    this.nextthink = time;
    if(IS_ONGROUND(this))
        this.velocity = this.velocity * (1 - frametime * this.friction);
}

SUB_NullThink()

void SUB_NullThink

(

entity

this

)

Definition at line 3 of file subs.qc.

References entity(), spawnfunc(), SUB_CalcAngleMoveDone(), and SUB_CalcMoveDone().

Referenced by SUB_CalcMove_Bezier().

{ }

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_SetFade()

void SUB_SetFade	(	entity	ent,
		float	vanish_time,
		float	fading_time
	)

Definition at line 77 of file subs.qc.

References setthink, and SUB_SetFade_Think().

Referenced by Item_InitializeLoot(), Monster_Dead_Fade(), monster_dropitem(), PlayerDamage(), Portal_Remove(), respawn(), and thrown_wep_think().

{
    if (fading_time <= 0)
        fading_time = 0.01;
    ent.fade_rate = 1/fading_time;
    setthink(ent, SUB_SetFade_Think);
    ent.nextthink = vanish_time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_SetFade_Think()

void SUB_SetFade_Think

(

entity

this

)

Definition at line 57 of file subs.qc.

References alpha, fade_rate, frametime, nextthink, setthink, SUB_SetFade_Think(), SUB_VanishOrRemove(), and time.

Referenced by SUB_SetFade(), and SUB_SetFade_Think().

{
    if(this.alpha == 0)
        this.alpha = 1;
    setthink(this, SUB_SetFade_Think);
    this.nextthink = time;
    this.alpha -= frametime * this.fade_rate;
    if (this.alpha < 0.01)
        SUB_VanishOrRemove(this);
    else
        this.nextthink = time;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUB_VanishOrRemove()

void SUB_VanishOrRemove

(

entity

ent

)

Definition at line 38 of file subs.qc.

References IS_CLIENT.

Referenced by SUB_SetFade_Think(), and thrown_wep_think().

{
    if (IS_CLIENT(ent))
    {
        // vanish
        ent.alpha = -1;
        ent.effects = 0;
#ifdef SVQC
        ent.glow_size = 0;
        ent.pflags = 0;
#endif
    }
    else
    {
        // remove
        delete(ent);
    }
}

Here is the caller graph for this function:

Variable Documentation

friction

float friction

Definition at line 23 of file subs.qc.

Referenced by SUB_Friction().

platmovetype_turn

float platmovetype_turn

Definition at line 105 of file subs.qc.

Referenced by train_next(), and train_wait().