Jumper.cs Example C# Code

// Comment this line out to remove debug gizmo drawing.
//  You probably want to do that for the release version.
#define DEBUG_DRAWTRAJECTORY

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
#if DEBUG_DRAWTRAJECTORY
using UnityEngine.UI;
#endif

public class Jumper : MonoBehaviour
{
    // default settings
    const float DEFAULT_GRAVITY = -9.8f;
    const float DEFAULT_ASCENT = 5*9.8f;

    // When true, adds a parabolic upward component to jumps.
    [SerializeField]
    private bool allowBallisticAscent = true;
    // When true, checks if player goes to high and unceremoniously 
    //  puts them back at the right hight if they go over.
    // Old fix for precision issues. Safely experimented with, or ignored, like others.
    [SerializeField]
    private bool applyHeightOvershootCorrection = false;
    // The speed at the which the character leaves the ground to jump. This and 
    //  gravity (in PlayerMovement.cs) determine how much of the jump the character 
    //  is in control of.
    [SerializeField]
    float maxAscentSpeed = DEFAULT_ASCENT;

    // Flag that activates some special code in OffsetFromVelocity that
    //  corrects precision errors during a certain transfer to parabolic movement.
    bool releaseTransition = false;
    // Whether the jump is currently in the portion that is 'powered' aka non-ballistic.
    bool inPoweredAscent = false;
    // Normally ApplyToVerticalSpeed() only applies while inPoweredAscent, but sometimes a frame
    //  needs it's velocity pushed to PlayerMovement anyway. This flag sets that behaviour.
    bool forcePushVerticalSpeed = false;
    // During parabolic motion, maxAscentSpeed would be overwritten. Then maxAscentSpeed would be lost.
    // Instead, most calculations use appliedAscentSpeed, so that maxAscentSpeed is kept in its initial
    //  state.
    float appliedAscentSpeed = 0;
    // Timer that keeps track of how much of the jump is powered vs parabolic.
    Timer ascentTimer;
    // Cached value of gravity. Update via SetGravity(). Very important that this matches
    //  PlayerMovement.gravity. (actually, PlayerMovement.gravity*PlayerMovement.gravMultiplier)
    float gravity = DEFAULT_GRAVITY;
    // Save the initial position of a jump. Used for tracking height.
    Vector3 startPosition;
    float currentJumpMaxHeight;
    // Projected height at which poweredAscent will end and parabolic motion will take over.
    float releaseHeight = 0;

    // debug information used for drawing those arcs.
#if DEBUG_DRAWTRAJECTORY
    float apex = 0;
    int frameCounter = 0;
    Vector3 lastPosition;
    bool debug_draw = false;
#endif

    void Start()
    {
        ascentTimer = new Timer();
        appliedAscentSpeed = maxAscentSpeed;
        startPosition = transform.position;
        currentJumpMaxHeight = 0;
#if DEBUG_DRAWTRAJECTORY
        lastPosition = transform.position;
#endif
    }

    void Update()
    {
        // If the jump is configured not to use parabolic motion, 
        //  or to use overshoot correction, this block 0's out the 
        //  vertical speed when we get too high. It also sets 
        //  hitApex, which is used later.
        bool hitApex = false;
        if (applyHeightOvershootCorrection || !allowBallisticAscent)
        {
            float currentJumpHeight = transform.position.y - startPosition.y;

            if (hitApex = currentJumpHeight > currentJumpMaxHeight)
            { 
                forcePushVerticalSpeed = true;
                appliedAscentSpeed = 0;
                Vector3 position = transform.position;
                position.y = startPosition.y + currentJumpMaxHeight;
                transform.position = position;
            }
        }

#if DEBUG_DRAWTRAJECTORY
        if (debug_draw)
        {
            frameCounter++;

            float currentJumpHeight = transform.position.y - startPosition.y;

            Color r1 = new Color(0.7f, 0.7f, 1f);
            Color r2 = new Color(0f, 0f, 1f);
            Color y1 = new Color(1f, 1f, 0f);
            Color y2 = new Color(0.5f, 0.5f, 0f);

            Color y = (frameCounter%2 == 0) ? y1 : y2;
            Color r = (frameCounter%2 == 0) ? r1 : r2;

            Color c = (inPoweredAscent) ? r : y;
            Debug.DrawLine(lastPosition + Vector3.down, transform.position + Vector3.down, 
                c, 10f);
            if (currentJumpHeight > currentJumpMaxHeight)
            {
                float diff = currentJumpHeight - currentJumpMaxHeight;
                Debug.DrawLine(transform.position + Vector3.down, transform.position + Vector3.down + Vector3.down*diff, 
                    Color.red, 10f);
            }
            float candidateApex = transform.position.y - startPosition.y;
            apex = (candidateApex > apex) ? candidateApex : apex;
        }
#endif

        if (allowBallisticAscent)
        {
            if (inPoweredAscent)
            {
                float timerElapse = 0;
                if (ascentTimer.UpdateAndCheck(ref timerElapse))
                { 
                    // if we're at the end of the powered ascent, switch to parabolic motion.
                    ReleaseJump(true); 
                }
            }
        }
        else 
        {
            // end the jump if we hit the top
            if (hitApex && inPoweredAscent)
            { ReleaseJump(); }
        }
#if DEBUG_DRAWTRAJECTORY
        lastPosition = transform.position;
#endif
    }

    // PlayerMovement calls this to let jumper overwrite vertical 
    //  speed, it may choose not to if not in powered ascent.
    public float ApplyToVerticalSpeed(float vertVelocity)
    { 
        float result = (inPoweredAscent || forcePushVerticalSpeed) 
            ? appliedAscentSpeed : vertVelocity; 
        forcePushVerticalSpeed = false;
        return result;
    }

    // Previously gravity was not factored into a frame's offset calculation at
    //  an analytical level. This generated a great deal of error. This 
    //  function takes a velocity, and returns the ballistic offset the 
    //  velocity would result in.
    public float OffsetFromVelocity(float velocity)
    {
        if (releaseTransition)
        { 
            releaseTransition = false;
            float travelledHeight = transform.position.y - startPosition.y;
            float overshoot = travelledHeight - releaseHeight;
            float overshootRatio = overshoot / (velocity*Time.deltaTime);
            float okayRatio = 1f-overshootRatio;
            float ascentPortion = okayRatio*velocity*Time.deltaTime;
            float ballisticTimePortion = Time.deltaTime*overshootRatio;
            float ballisticPortion = velocity*ballisticTimePortion
                + 0.5f*gravity*(ballisticTimePortion*ballisticTimePortion);
            return ascentPortion + ballisticPortion;
        }
        else if (inPoweredAscent) 
        { 
            return velocity*Time.deltaTime;
        }
        else
        { 
            return velocity*Time.deltaTime+0.5f*gravity*(Time.deltaTime*Time.deltaTime); 
        }
    }

    public void SetGravity(float gravity)
    { this.gravity = gravity; }

    public void SetMaxAscent(float ascent)
    { this.maxAscentSpeed = ascent; }

    // End the powered ascent (blue) portion of the jump.
    public void ReleaseJump(bool mixedModel = false)
    { // switch to parabolic
        if (!inPoweredAscent)
        { return; }

        inPoweredAscent = false;
        if (allowBallisticAscent)
        {
            appliedAscentSpeed = maxAscentSpeed;
            releaseTransition = mixedModel;
        }
        else
        {
            appliedAscentSpeed = 0f;
        }
        forcePushVerticalSpeed = !allowBallisticAscent;
    }

    // Start a jump to a given height.
    public void Jump(float maxHeight)
    {
        // save the starting position of the jump.
        startPosition = transform.position;
        // save the intended max height for the jump.
        currentJumpMaxHeight = maxHeight;

#if DEBUG_DRAWTRAJECTORY
        apex = 0;
        debug_draw = true;
#endif
        // This portion runs even when the jump is not parabolic, but make no mistake,
        //  this block deals entirely with jumps that have parabolic components.
        // The rest of the code simply doesn't use the info generated by this block if 
        //  the jump isn't parabolic.
        {
            // Given that there is an established ascent speed, we can calculate how high
            //  that ascent will take us until gravity cancels it out. (the yellow part) The rest of the 
            //  height will need to be covered by a controlled or 'powered' portion of
            //  the jump. (the blue part).

            // Calculate the yellow part.
            float parabolicTime = FlatParabolicFlightTime(maxAscentSpeed);
            float parabolicHeight = MaxParabolicHeight(maxAscentSpeed, 0.5f*parabolicTime);
            if (parabolicHeight < maxHeight)
            {
                // if the yellow part doesn't cover the whole jump, calculate a supplamental
                //  blue part.
                inPoweredAscent = true;
                float controlledHeight = ControlledJumpHeight(maxHeight, parabolicHeight);
                float controlledTime = ControlledJumpTime(controlledHeight, maxAscentSpeed);
                releaseHeight = controlledHeight;
                appliedAscentSpeed = maxAscentSpeed;
                ascentTimer.Start(controlledTime);
            }
            else
            { 
                // if the jump max height is less than the parabolic height that the ascent height
                // would create
                float jumptime = (maxHeight == 0) ? 0 : 2.0f*FallTime(maxHeight);
                releaseHeight = maxHeight;
                appliedAscentSpeed = ParabolicVelocity(jumptime);
                forcePushVerticalSpeed = true;
                inPoweredAscent = false;
            }
        }
    }

    public void HitGround()
    {
#if DEBUG_DRAWTRAJECTORY
        debug_draw = false;
#endif
    }

    // PHYSICS STUFF =======================================================================

    private float FlatParabolicFlightTime(float iniVel)
    { return (2.0f*iniVel)/Mathf.Abs(gravity); }

    private float MaxParabolicHeight(float iniVel, float halfFlightTime)
    { // split calculation into multiple parts for debug examination
        float vt = iniVel*halfFlightTime;
        float halfgtt = 0.5f*Mathf.Abs(gravity)*(halfFlightTime*halfFlightTime);
        return vt - halfgtt; 
    }

    private float ParabolicVelocity(float parabolicTime)
    { return -0.5f*gravity*parabolicTime; }

    private float ControlledJumpHeight(float maxJumpHeight, float parabolicHeight)
    { return maxJumpHeight - parabolicHeight; }

    private float ControlledJumpTime(float controlledJumpHeight, float iniVel)
    { return controlledJumpHeight/iniVel; }

    private float FallTime(float height)
    { return Mathf.Sqrt( Mathf.Abs((2*height)/gravity) ); }
}
[Home] C# Platformer Code Example
