Math Ninja

Random Height Platform Position Generation

I needed a way to reliably generate random platform heights as they appear into view in my endless runner game. The platform’s height shouldn’t be so high that its impossible for the player to jump on the platform and it shouldn’t be too low where it would be invisible to the player’s view.

The constraints I defined were:

1. Platform height should be between the lowest and highest point the player can see on the viewport.
2. The next platform that appears to the right of the camera view should have a height between the last platform the player is standing on minus the player jump height to the last platform the player is standing on plus the player jump height:

// These define the bottom and top boundaries of the camera respectively
// left out the calculations for brevity
float localBotCamEdge;
float localTopCamEdge;

// ninja is the player game object you control 
// with a floating point property named jumpHeight
float minHeightMod = lastPlatform.transform.localPosition.y - ninja.jumpHeight;
float maxHeightMod = lastPlatform.transform.localPosition.y + ninja.jumpHeight;
if (minHeightMod < localBotCamEdge)
    minHeightMod = localBotCamEdge;
if (maxHeightMod > localTopCamEdge)
    maxHeightMod = localTopCamEdge;

float randomHeight = Random.Range(minHeightMod, maxHeightMod);

Programming Player Jump

Here are 3 physics kinematic equations I used in my NinjaController.cs component to program player jump (wikipedia source):

1. v = u + at
2. v^2 = u^2 + 2as
3. s = ut + (1/2)at^2

• v is final velocity
• u is initial velocity
• a is acceleration
• t is time
• s is distance

The assumption I make is that u is always 0. So the 3 kinematic equations simplify down to:

1. v = at
2. v^2 = 2as
3. s = (1/2)at^2

The constraints I added to my NinjaController script are the following:

1. jumpHeight is a configurable value in the Unity Editor which represents s. This measures how far in the y-axis the player travelled off the platform.
2. timeToJumpApex is a configurable value in the Unity Editor which represents t. This measures the amount of time in seconds wher the player reaches the highest point in the jump.

The unknowns I’m solving for are:

1. a represents gravity which represents acceleration that prevents my ninja player from floating in the sky.
2. v or the jumpSpeed which represents a scalar velocity value.

To solve for gravity, I use the 3rd kinematic equation:

s = (1/2)at^2

jumpHeight = (1/2) * gravity * timeToJumpApex * timeToJumpApex
2 * jumpHeight = gravity * timeToJumpApex * timeToJumpApex
gravity = (2 * jumpHeight) / (timeToJumpApex * timeToJumpApex)

To solve for jumpSpeed, I use the 1st kinematic equation:

v = at

jumpSpeed = gravity * timeToJumpApex
// substitute gravity to be in terms of jumpHeight and timeToJumpApex
jumpSpeed = ((2 * jumpHeight) / (timeToJumpApex * timeToJumpApex)) * timeToJumpApex

The benefit of this approach is that I can define how high my player can jump which can be used to control how high or how low the next platform that comes from the right of the camera is.

The drawback of this approach is that if I wanted to directly tune the player’s jumpSpeed, I won’t be able to do so as its being controlled indirectly by the jumpHeight and timeToJumpApex variables. Alternatively, if I made the constraints to be the jumpSpeed and gravity where these are configurable in the Unity Editor, I could solve for jumpSpeed and timeToJumpApex using the kinematic equations defined above.

Coroutines Usage

At the time, I was trying to figure out was how to create a generic event driven system combining Coroutines and the Observer Pattern. I needed a way where I can register functions to callback functions or C# events that my system would invoke. I ended up coming with a system called WorldEventSystem.cs where I can define custom events and manually invoke them in a function called TimerEventLoop() which begins in the Start() function of WorldEventSystem.cs via StartCoroutine() function.

The way I planned it out was figuring out a list of custom events that would trigger every updateFrequency seconds. The custom events would be called in a coroutine function: TimerEventLoop(). The list I came up with was:

1. OnPreTimerElapsed()
2. OnTimerInterrupted()
3. OnCurrentTimerElapsed()
4. OnPostTimerElapsed()
5. OnPlayerActionEvaluated()

In code their declarations look something like this:

// register any callback functions that would occur at the start of TimerEventLoop() function
public delegate void PreTimerAction();
public static event PreTimerAction OnPreTimerElapsed;

// register any callback functions that would occur at the end of TimerEventLoop()
public delegate void PostTimerAction();
public static event PostTimerAction OnPostTimerElapsed;

// register any callback functions that may interrupt OnCurrentTimerElapsed();
// this event gets called before OnCurrentTimerElapsed()
// returns true if can be interrupted; false otherwise
public delegate bool InterruptTimerAction();
public static event InterruptTimerAction OnTimerInterrupted;

// register any callback functions that may get interrupted here
public delegate void CurrentTimerAction();
public static event CurrentTimerAction OnCurrentTimerElapsed;

// this was only used to register 1 function to check if a player is dead or not as it gets checked at the end of TimerEventLoop()
public delegate void EvaluatePlayerAction();
public static event EvaluatePlayerAction OnPlayerActionEvaluated;

using System.Collections;
using UnityEngine;

private IEnumerator TimerEventLoop()
{
    // add a busy wait here to ensure all delegates are loaded up with functions to execute
    while (OnPreTimerElapsed == null)
    {
        yield return new WaitForEndOfFrame();
    }

    while (!NinjaController.IsDead)
    {
        OnPreTimerElapsed();
        StartTime = startTime = Time.time;
        yield return new WaitForSeconds(updateFrequency);
        ElapsedTime = elapsedTime = Time.time - startTime;


        bool canInterrupt = false;
        while (elapsedTime < updateDuration)
        {
            foreach (InterruptTimerAction interruptAction in OnTimerInterrupted.GetInvocationList())
            {
                //it needs to run all functions subscribed to this event to ensure data stablility
                if (interruptAction())
                    canInterrupt = true;
            }

            if (canInterrupt) break;

            OnCurrentTimerElapsed();

            yield return new WaitForSeconds(updateFrequency);
            ElapsedTime = elapsedTime = Time.time - startTime;
        }

        OnPostTimerElapsed();
        OnPlayerActionEvaluated();

        yield return new WaitForSeconds(displayDelay);
    }

    yield return null;
}