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

Functions
	STATIC_INIT (g_jumppads)

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

void	trigger_push_findtarget (entity this)

bool	trigger_push_test (entity this, entity item)
	if (item != NULL) returns true if the item can be reached by using this jumppad, false otherwise if (item == NULL) tests jumppad's trajectory and eventually spawns waypoints for it (return value doesn't matter) More...

void	trigger_push_touch (entity this, entity toucher)

Variables
vector	dest

IntrusiveList	g_jumppads

float	height

bool	istypefrag

float	jumppadcount

entity	jumppadsused [NUM_JUMPPADSUSED]

const int	NUM_JUMPPADSUSED = 3

const int	PUSH_ONCE = BIT(0)

const int	PUSH_SILENT = BIT(1)

float	pushltime

Function Documentation

◆ STATIC_INIT()

STATIC_INIT ( g_jumppads )

Definition at line 8 of file jumppads.qh.

References IL_NEW.

8 { g_jumppads = IL_NEW(); }

IL_NEW

#define IL_NEW()

Definition: intrusivelist.qh:39

g_jumppads

IntrusiveList g_jumppads

Definition: jumppads.qh:7

◆ trigger_push_calculatevelocity()

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

Definition at line 31 of file jumppads.qc.

References fabs(), normalize(), NULL, solve_quadratic(), sqrt(), vector(), and vlen().

Referenced by jumppad_push(), trigger_push_test(), and trigger_push_touch().

 {
     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 call graph for this function:

Here is the caller graph for this function:

◆ trigger_push_findtarget()

void trigger_push_findtarget ( entity this )

Definition at line 558 of file jumppads.qc.

References active, ACTIVE_ACTIVE, angles, BITSET_ASSIGN, cnt, drawmask, EF_NODEPTHTEST, effects, entity(), g_jumppads, height, IL_PUSH(), InitializeEntity(), jumppad_push(), mangle, MASK_NORMAL, move_time, movedir, NET_HANDLE, noise, NULL, origin, precache_sound(), ReadString, setorigin(), SF_TRIGGER_INIT, solid, SOLID_TRIGGER, spawnflags, spawnfunc(), speed, strfree, strzone(), target, targetname, team, time, to, trigger_push_findtarget(), trigger_push_test(), trigger_push_touch(), use, WriteByte(), WriteCoord(), and WriteString().

Referenced by trigger_push_findtarget().

 {
     trigger_push_test(this, NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ trigger_push_test()

bool trigger_push_test	(	entity	this,
		entity	item
	)

if (item != NULL) returns true if the item can be reached by using this jumppad, false otherwise if (item == NULL) tests jumppad's trajectory and eventually spawns waypoints for it (return value doesn't matter)

Definition at line 387 of file jumppads.qc.

References absmax, absmin, boxesoverlap(), DPCONTENTS_BODY, DPCONTENTS_BOTCLIP, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, enemy, entity(), eZ, fabs(), find(), height, if(), LABEL, min(), movedir, MOVETYPE_NONE, normalize(), NULL, objerror(), setorigin(), spawn(), target, targetname, team, trace_endpos, trace_ent, trigger_push_calculatevelocity(), vdist, vec2, vector(), vlen(), and waypoint_spawnforteleporter().

Referenced by navigation_findnearestwaypoint_withdist_except(), and trigger_push_findtarget().

 {
 #ifdef SVQC
     vector org = trigger_push_get_start_point(this);
 #endif
 
     if (this.target)
     {
         int n = 0;
 #ifdef SVQC
         vector vel = '0 0 0';
 #endif
         for(entity t = NULL; (t = find(t, targetname, this.target)); )
         {
             ++n;
 #ifdef SVQC
             if(t.move_movetype != MOVETYPE_NONE)
                 continue;
 
             // bots can't tell teamed jumppads from normal ones
             if (this.team)
                 continue;
 
             entity e = spawn();
             setsize(e, PL_MIN_CONST, PL_MAX_CONST);
             e.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
             e.velocity = trigger_push_calculatevelocity(org, t, this.height, e);
 
             vel = e.velocity;
             vector best_target = '0 0 0';
             vector best_org = '0 0 0';
             vector best_vel = '0 0 0';
             bool valid_best_target = false;
             if (item)
             {
                 if (!trigger_push_testorigin_for_item(e, item, org))
                 {
                     delete(e);
                     return false;
                 }
             }
             else
             {
                 if (trigger_push_testorigin(e, t, this, org))
                 {
                     best_target = trace_endpos;
                     best_org = org;
                     best_vel = e.velocity;
                     valid_best_target = true;
                 }
             }
 
             vector new_org;
             vector dist = t.origin - org;
             if (dist.x || dist.y) // if not perfectly vertical
             {
                 // test trajectory with different starting points, sometimes the trajectory
                 // starting from the jumppad origin can't reach the real destination
                 // and destination waypoint ends up near the jumppad itself
                 vector flatdir = normalize(dist - eZ * dist.z);
                 vector ofs = flatdir * 0.5 * min(fabs(this.absmax.x - this.absmin.x), fabs(this.absmax.y - this.absmin.y));
                 new_org = org + ofs;
 
                 LABEL(new_test)
                 e.velocity = trigger_push_calculatevelocity(new_org, t, this.height, e);
                 if (item)
                 {
                     if (!trigger_push_testorigin_for_item(e, item, new_org))
                     {
                         delete(e);
                         return false;
                     }
                 }
                 else
                 {
                     vel = e.velocity;
                     if (vdist(vec2(e.velocity), <, autocvar_sv_maxspeed))
                         e.velocity = autocvar_sv_maxspeed * flatdir;
                     if (trigger_push_testorigin(e, t, this, new_org) && (!valid_best_target || trace_endpos.z > best_target.z + 50))
                     {
                         best_target = trace_endpos;
                         best_org = new_org;
                         best_vel = vel;
                         valid_best_target = true;
                     }
                 }
                 if (ofs && new_org != org - ofs)
                 {
                     new_org = org - ofs;
                     goto new_test;
                 }
             }
 
             if (item)
             {
                 delete(e);
                 return true;
             }
 
             if (valid_best_target)
             {
                 if (!(boxesoverlap(this.absmin, this.absmax + eZ * 50, best_target + PL_MIN_CONST, best_target + PL_MAX_CONST)))
                 {
                     float velxy = vlen(vec2(best_vel));
                     float cost = vlen(vec2(t.origin - best_org)) / velxy;
                     if(velxy < autocvar_sv_maxspeed)
                         velxy = autocvar_sv_maxspeed;
                     cost += vlen(vec2(best_target - t.origin)) / velxy;
                     waypoint_spawnforteleporter(this, best_target, cost, e);
                 }
             }
             delete(e);
 #endif
         }
 
         if(item)
             return false;
 
         if(!n)
         {
             // no dest!
 #ifdef SVQC
             objerror (this, "Jumppad with nonexistant target");
 #endif
             return false;
         }
         else if(n == 1)
         {
             // exactly one dest - bots love that
             if (!this.team)
                 this.enemy = find(NULL, targetname, this.target);
             else // bots can't tell teamed jumppads from normal ones
                 this.enemy = NULL;
         }
         else
         {
             // have to use random selection every single time
             this.enemy = NULL;
         }
 
     }
 #ifdef SVQC
     else
     {
         if (!this.team)
         {
             entity e = spawn();
             setsize(e, PL_MIN_CONST, PL_MAX_CONST);
             e.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
             setorigin(e, org);
             e.velocity = this.movedir;
             tracetoss(e, e);
             if (item)
             {
                 bool r = (trace_ent == item);
                 delete(e);
                 return r;
             }
             if (!(boxesoverlap(this.absmin, this.absmax + eZ * 50, trace_endpos + PL_MIN_CONST, trace_endpos + PL_MAX_CONST)))
                 waypoint_spawnforteleporter(this, trace_endpos, vlen(trace_endpos - org) / vlen(e.velocity), e);
             delete(e);
         }
         else if (item)
             return false;
     }
 
     defer(this, 0.1, trigger_push_updatelink);
 #endif
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ trigger_push_touch()

void trigger_push_touch	(	entity	this,
		entity	toucher
	)

Definition at line 260 of file jumppads.qc.

References absmax, absmin, active, ACTIVE_NOT, DIFF_TEAM, DPCONTENTS_BODY, DPCONTENTS_BOTCLIP, DPCONTENTS_PLAYERCLIP, DPCONTENTS_SOLID, enemy, entity(), EXACTTRIGGER_TOUCH, eZ, func_null(), height, INVERT_TEAMS, jumppad_push(), movedir, nextthink, NULL, PUSH_ONCE, setorigin(), setthink, spawn(), spawnflags, sqrt(), stepheightvec, target, team, time, trace_endpos, trace_ent, trace_startsolid, trigger_push_calculatevelocity(), trigger_push_get_push_time(), v, vdist, vec2, and vector().

Referenced by trigger_push_findtarget().

 {
     if (this.active == ACTIVE_NOT)
         return;
 
     if(this.team)
         if(((this.spawnflags & INVERT_TEAMS) == 0) == (DIFF_TEAM(this, toucher)))
             return;
 
     EXACTTRIGGER_TOUCH(this, toucher);
 
     noref bool success = jumppad_push(this, toucher);
 
 #ifdef SVQC
     if (success && (this.spawnflags & PUSH_ONCE))
     {
         settouch(this, func_null);
         setthink(this, SUB_Remove);
         this.nextthink = time;
     }
 #endif
 }