First off, the docs on movegravity state the following:

Closer inspection reveals the following:Code:MoveGravity( <initial velocity>, <time> ) Module: Motion Summary: Fling this entity. Call this on: script_model, script_origin or script_brushmodel Example:self MoveGravity( break_vector, time ); Required Args:1 : <initial velocity> The initial velocity to fling this entity at 2 : <time> The time to move the entity in seconds

1. Movegravity() will fling an object into a certain direction

2. Movegravity() will apply the correct rate of gravity to the object while doing so

3. (experimentally found) movegravity() doesnt care for any obstacle. It will just keep moving until time runs out.

4. Movegravity() needs both a time and a start vector.

Now lets go experiment.

The time part: movegravity() will move an object for as long as the time did not run out yet. So if you tell movegravity() to move an object for 10 seconds, the object will be moved for 10 seconds, regardless of obstacles of ANY kind.

You can break this movement by changing/setting the origin of the object or by just applying another move function on it.

The start vector part: This is where it gets interesting. movegravity() does sorta give the object an initial kick in a certain direction at a certain magnitude.

Experimenting reveals that setting a (0,0,0) initial vector will make the object fall. Setting (0,0,1000) will give the object a ginormous kick upwards.

Now the really fun part of all this. Using movegravity() to make objects "jump" from point A to point B.

We can assume objects which are moved by movegravity() with a positive startvector move in a parabolic fashion. Therefore, we have 2 theoretical points when an object is at a certain height. First point is when the object is going up, second point is where the object is going down (unless ofcourse the desired height is at the top of the parabolic movement or below the start)

As we are only interested in the point where the object is moving DOWN (realism and shit), calculations just became a lot easier.

First off, familiarize yourself with the following formula:

whereCode:s=0.5*a*t^2+v0*t

s=distance travelled

a=acceleration

t=time elapsed

v0=initial speed

You might remember this formula. If not, wikipedia it or just assume it is correct.

Now the tricky part which most of you will not know yet: this formula applies to both scalars (normal numbers) and vectors.

This means, that the symbols can also mean:

s=vector of distance travelled (3d)

a=acceleration in 3 dimensions

t=time elapsed (no, nothing changed here)

v0=initial speed in 3d

As one can easily see here, the v0 resembles the required input for the movegravity() function.

The a is a bit harder. This is the acceleration by the gravity in 3d. The gravitational vector looks like this:

where g is the gravitational acceleration (9.8m/s^2)Code:(0,0,-g)

As this acceleration is downward, it is negative on the z-axis.

Now, calculating jump height of a normal player reveals the following:

s=40 units (normal player jump height)

a=(0,0,-800) (normal g_gravity in a server)

v0 and t both unknown.

Now we have 2 unknown vars and only 1 equation. This wont work. We need an additional equation.

We know that the speed at the top of the jump is zero (dont know why? ask your science teacher-not me. Or wiki it.)

v(t)=v0+a*t

or (with v(t)=0)

v0= -a*t on t=tTop

If we solve this in 1-dimension, we can replace a with -800, so we can replace t with:

t=v0/a

Which leads us back to our first equation:

s=0.5*a*t^2+v0*t

replacing t with v0/a results in:

s=0.5*a*(v0/a)^2+v0*(v0/a)

or, setting both s and a to the found parameters:

40=(0.5/-800)*v0^2+v0^2/800

or

40= ((-1/1600)+(1/800))*v0^2

40= 1/1600*v0^2

64000=v0^2

Getting the square root of 64000 reveals v0 (at least in z-direction) for a normal jumping player to be approximately:

250 units/second.

The rest of the tutorial is still missing at this point. Will update/post to this thread to add more info