Trigger catapult

An entity named trigger_catapult is also available in , but it seems to be a different entity with different functionality.
It is used to launch the player or other objects into the air.
Its ability to set an entity's flying direction or target, to consider their current velocity and – in the case of players – to supress their controls makes it a powerful tool to contol how they will fly and thus where they will land.
 They are typically used for Aerial Faith Plates to accomplish a kind of Fling that doesn't necessarily require the player to use portals.
== Configuration ==
The fling direction is determined by the keyvalues Launch target or Launch direction. The latter is ignored if the former is set. Other than that, the mapper can determine a minimum, a maximum and a direction that an entity's velocity must satisfy in order to be launched at all.
==== Launch target ====
// Squirrel function simulating a trigger_catapult with launch target
// trigger_catapult(launchedEntityHandle, targetVector, float)
::trigger_catapult <- function(ent, target, speed=450)
{
	local g = 600 // sv_gravity
	local d = target - ent.GetOrigin() // vector from start to target
	local t = d.Length() / speed // seconds the flight will take
	local vz = d.z / t + 0.5 * g * t // initial z-speed that we need
	local v = Vector(d.x / t, d.y / t, vz) // v.Length() is threshold base
	ent.SetVelocity(v)
}
The simplest configuration is to create or find an entity (e.g. or anything else) whose origin is positioned at the location that the player or object should fly to, and to specify that entity's name in the Launch target keyvalue of the trigger_catapult.
With this set, the two speed keyvalues determine the flying height, where typically a higher speed flattens the flinging arc and a lower speed steepens it. The actual launch speed also varies slightly depending on where this trigger_catapult is touched (since you cannot treat every launch position equally). The target will be missed if the launched object is affected by forces other than gravity after launch.
If a Launch target is set and an object (that passes the filters) touches the trigger_catapult, the game calculates the time in which the object should reach the target by dividing the initial distance between the two by the appropriate speed keyvalue (which is why the game crashes if that speed happens to be zero): . Based on this time, the game shoots the object in a direction such that it reaches the target in exactly the calculated time, as seen in the code on the right. The speed which the game wants to shoot the entity with is the base value for the eventual threshold check, see below. Anyway, that's why specifying a really low speed results in a very high launch speed upwards since a low speed means a long time before the object should reach the target.
==== Launch direction ====
One can also leave the Launch target blank and instead set the Launch direction. In this case, the speed keyvalues truly represent the speed at which an object will be launched with, except if the Launch direction keyvalue is set to Up (exactly -90 0 0) where the launch speed is 1.5 times as much (this is not related to the Use Exact Velocity keyvalue). To reach a maximum height of from the start height in the case of Up (-90 0 0), set the speed to .
In general, if an entity is launched at a speed of u/s and at an angle of (0 to -90, where 0 means horizontal and -90 means up), then the launched object will reach its highest point in seconds, which lies units higher and units away (in the x-y-plane) from its launching point.
==== Velocity threshold ====
If Use Threshold Check is set to Yes, this trigger_catapult will only fling an entity if its velocity is at least u/s but at most u/s, where is the velocity that the game would shoot the entity with. If no Launch target is set, it is equal to the appropriate speed keyvalue, otherwise it's what the game calculates, see the code above.
 If Use Absolute Threshold Check is set to Yes, the threshold keyvalues represent actual velocities.
In addition, the Entry Angle Tolerance can be used to limit the direction in which the velocity of an entity must point in order for it to be flung at all. If set to , the entity is only flung if the angle between its entry velocity and the vector from the launch position to the target is at most , where means at most 90° off, means always (at most 180° off), see dot product.
==== Supress player controls ====
The Air Control Supression Time can be used to prevent a player from strafing out of an intended flinging arc. It disables a player's controls in mid-air for a fixed number of seconds after the launch. This effect doesn't end when they land, so a mapper may want to get this duration about right, if necessary by measuring it in-game (e.g. with and ).
For a predictable flinging arc, this helps eliminate one disturbing factor but there are more to consider, for instance portal funneling, static obstacles, other unpredictably flying objects, , gunfire, (3500 u/s by default), etc.
==== Testing ====
If you compiled a map and you are unhappy with a configuration, you don't need to recompile to test a different one: Change the trigger_catapult's keyvalues in-game using . If there is no name, use trigger_catapult as a name to target all of them. All changes done with ent_fire are discarded when the map changes or reloads.
In-game, the predicted flinging arcs can be viewed using the commands , and . Setting developer to ≥ 1 also prints debug information about ongoing threshold checks.
==KeyValues==
:* 0 : Best
:* 1 : Solution One
:* 2 : Solution Two
==Flags==
==Inputs==
==Outputs==