PlatformerController: is inertia (Mario physics) possible ?

Archived Forums Questions & Answers
1

Hello,

I'm using the PlatformerController script from the 2D Gameplay tutorial and was wondering how easy or how hard it was to make the character behave with more realistic controls.

For example, when the character runs in one direction and then he receive commands to go the opposite way, I would want the physic to react accordingly and NOT having the character immediately go in the opposite direction with immediate full speed. I would also want this kind of behavior in mid-air... everything like in Super Mario Bros.

Can someone help ? I'm a real newb... :(

Thank you.

4 Answers

4
2

Have you tried tweaking the PlatformerController's acceleration properties?

EDIT: These are the properties I was referring to (I should have said "smoothing" rather than acceleration). Try lowering them.

// How fast does the character change speeds?  Higher is faster.
var speedSmoothing = 5.0;

// This controls how fast the graphics of the character "turn around" when the player turns around using the controls.
var rotationSmoothing = 10.0;

Tweaking that property (inAirControlAcceleration) doesn't do anything close to what I'm searching for. I'm not sure which parameters I have to fiddle with in order to achieve this. I have the feeling that I have to insert a new formula or change an existing one in order to do it. Tweaking a variable won't work, I think.

 –
3

You will need to change the code that calculates movement to take into account momentum yourself. Something like using directed speed should work, but since you want the character to run in the opposite direction of which they are moving when sliding, you will need to store it separately from the momentum. Something like changing the code in PlatformerControllerMovement, UpdateSmoothedMovementDirection and Update like so:

//PlatformerControllerMovement...{...
// The current movement momentum.  This gets smoothed by speedSmoothing.
@System.NonSerialized
var momentum = 0.0;
//...}

//UpdateSmoothedMovementDirection...{...
    // Choose target speed
    var targetSpeed = Mathf.Clamp(h,-1.0,1.0);

    // Pick speed modifier
    if (Input.GetButton ("Fire2") && canControl)
        targetSpeed *= movement.runSpeed;
    else
        targetSpeed *= movement.walkSpeed;

    //Calculate the speed to move at
    movement.speed = Mathf.Lerp (movement.speed, Mathf.Abs(targetSpeed), curSmooth);

    var traction = GetSurfaceTraction(); //Decide how you want to get this
    // Less traction = less change to momentum
    curSmooth *= traction;

    //Calculate the speed to actually apply as motion
    movement.momentum = Mathf.Lerp (movement.momentum, targetSpeed, curSmooth);
//...}

//Update...{...
    // Calculate actual motion
    var currentMovementOffset = Vector3(movement.momentum, movement.verticalSpeed, 0) + movement.inAirVelocity;
//...}

This way, the momentum representing the speed at which the character will be translated will slow down according to smoothing and friction, while the movement speed of the character as it animates will behave as before (since it has less effect than before, you may consider even removing the smoothing from speed altogether and only applying it to the momentum).

EDIT 08/30: I'm not sure what problems you could be having in making these three simple changes, but here is the complete working script with the changes:

// Does this script currently respond to Input?
var canControl = true;

// The character will spawn at spawnPoint's position when needed. This could be changed via a script at runtime to implement, e.g. waypoints/savepoints.
var spawnPoint : Transform;

class PlatformerControllerMovement {
    // The speed when walking 
    var walkSpeed = 3.0;
    // when pressing "Fire1" button (control) we start running
    var runSpeed = 10.0;

    var inAirControlAcceleration = 1.0;

    // The gravity for the character
    var gravity = 60.0;
    var maxFallSpeed = 20.0;

    // How fast does the character change speeds?  Higher is faster.
    var speedSmoothing = 2.0;

    // This controls how fast the graphics of the character "turn around" when the player turns around using the controls.
    var rotationSmoothing = 10.0;

    // The current move direction in x-y.  This will always been (1,0,0) or (-1,0,0)
    // The next line, @System.NonSerialized , tells Unity to not serialize the variable or show it in the inspector view.  Very handy for organization!
    @System.NonSerialized
    var direction = Vector3.zero;

    // The current vertical speed
    @System.NonSerialized
    var verticalSpeed = 0.0;

    // The current movement speed.  This gets smoothed by speedSmoothing.
    @System.NonSerialized
    var speed = 0.0;

    // The current movement momentum.  This gets smoothed by speedSmoothing.
    @System.NonSerialized
    var momentum = 0.0;

    // Is the user pressing the left or right movement keys?
    @System.NonSerialized
    var isMoving = false;

    // The last collision flags returned from controller.Move
    @System.NonSerialized
    var collisionFlags : CollisionFlags; 

    // We will keep track of an approximation of the character's current velocity, so that we return it from GetVelocity () for our camera to use for prediction.
    @System.NonSerialized
    var velocity : Vector3;

    // This keeps track of our current velocity while we're not grounded?
    @System.NonSerialized
    var inAirVelocity = Vector3.zero;

    // This will keep track of how long we have we been in the air (not grounded)
    @System.NonSerialized
    var hangTime = 0.0;
}

var movement : PlatformerControllerMovement;

// We will contain all the jumping related variables in one helper class for clarity.
class PlatformerControllerJumping {
    // Can the character jump?
    var enabled = true;

    // How high do we jump when pressing jump and letting go immediately
    var height = 1.0;
    // We add extraHeight units (meters) on top when holding the button down longer while jumping
    var extraHeight = 4.1;

    // This prevents inordinarily too quick jumping
    // The next line, @System.NonSerialized , tells Unity to not serialize the variable or show it in the inspector view.  Very handy for organization!
    @System.NonSerialized
    var repeatTime = 0.05;

    @System.NonSerialized
    var timeout = 0.15;

    // Are we jumping? (Initiated with jump button and not grounded yet)
    @System.NonSerialized
    var jumping = false;

    @System.NonSerialized
    var reachedApex = false;

    // Last time the jump button was clicked down
    @System.NonSerialized
    var lastButtonTime = -10.0;

    // Last time we performed a jump
    @System.NonSerialized
    var lastTime = -1.0;

    // the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
    @System.NonSerialized
    var lastStartHeight = 0.0;
}

var jump : PlatformerControllerJumping;

private var controller : CharacterController;

// Moving platform support.
private var activePlatform : Transform;
private var activeLocalPlatformPoint : Vector3;
private var activeGlobalPlatformPoint : Vector3;
private var lastPlatformVelocity : Vector3;

// This is used to keep track of special effects in UpdateEffects ();
private var areEmittersOn = false;

function Awake () {
    movement.direction = transform.TransformDirection (Vector3.forward);
    controller = GetComponent (CharacterController);
    Spawn ();
}

function Spawn () {
    // reset the character's speed
    movement.verticalSpeed = 0.0;
    movement.speed = 0.0;

    // reset the character's position to the spawnPoint
    transform.position = spawnPoint.position;

}

function OnDeath () {
    Spawn ();
}

function UpdateSmoothedMovementDirection () {   
    var h = Input.GetAxisRaw ("Horizontal");

    if (!canControl)
        h = 0.0;

    movement.isMoving = Mathf.Abs (h) > 0.1;

    if (movement.isMoving)
        movement.direction = Vector3 (h, 0, 0);

    // Grounded controls
    if (controller.isGrounded) {
        // Smooth the speed based on the current target direction
        var curSmooth = movement.speedSmoothing * Time.deltaTime;

        // Choose target speed
        var targetSpeed = Mathf.Clamp(h,-1.0,1.0);

        // Pick speed modifier
        if (Input.GetButton ("Fire2") && canControl)
            targetSpeed *= movement.runSpeed;
        else
            targetSpeed *= movement.walkSpeed;

        //Calculate the speed to move at
        movement.speed = Mathf.Lerp (movement.speed, Mathf.Abs(targetSpeed), curSmooth);

        var traction = 0.5; //Decide how you want to get this
        // Less traction = less change to momentum
        curSmooth *= traction;

        //Calculate the speed to actually apply as motion
        movement.momentum = Mathf.Lerp (movement.momentum, targetSpeed, curSmooth);

        movement.hangTime = 0.0;
    }
    else {
        // In air controls
        movement.hangTime += Time.deltaTime;
        if (movement.isMoving)
            movement.inAirVelocity += Vector3 (Mathf.Sign(h), 0, 0) * Time.deltaTime * movement.inAirControlAcceleration;
    }
}

function FixedUpdate () {
    // Make sure we are absolutely always in the 2D plane.
    transform.position.z = 0;

}

function ApplyJumping () {
    // Prevent jumping too fast after each other
    if (jump.lastTime + jump.repeatTime > Time.time)
        return;

    if (controller.isGrounded) {
        // Jump
        // - Only when pressing the button down
        // - With a timeout so you can press the button slightly before landing     
        if (jump.enabled && Time.time < jump.lastButtonTime + jump.timeout) {
            movement.verticalSpeed = CalculateJumpVerticalSpeed (jump.height);
            movement.inAirVelocity = lastPlatformVelocity;
            SendMessage ("DidJump", SendMessageOptions.DontRequireReceiver);
        }
    }
}

function ApplyGravity () {
    // Apply gravity
    var jumpButton = Input.GetButton ("Jump");

    if (!canControl)
        jumpButton = false;

    // When we reach the apex of the jump we send out a message
    if (jump.jumping && !jump.reachedApex && movement.verticalSpeed <= 0.0) {
        jump.reachedApex = true;
        SendMessage ("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
    }

    // * When jumping up we don't apply gravity for some time when the user is holding the jump button
    //   This gives more control over jump height by pressing the button longer
    var extraPowerJump =  jump.jumping && movement.verticalSpeed > 0.0 && jumpButton && transform.position.y < jump.lastStartHeight + jump.extraHeight && !IsTouchingCeiling ();

    if (extraPowerJump)
        return;
    else if (controller.isGrounded)
        movement.verticalSpeed = -movement.gravity * Time.deltaTime;
    else
        movement.verticalSpeed -= movement.gravity * Time.deltaTime;

    // Make sure we don't fall any faster than maxFallSpeed.  This gives our character a terminal velocity.
    movement.verticalSpeed = Mathf.Max (movement.verticalSpeed, -movement.maxFallSpeed);
}

function CalculateJumpVerticalSpeed (targetJumpHeight : float) {
    // From the jump height and gravity we deduce the upwards speed 
    // for the character to reach at the apex.
    return Mathf.Sqrt (2 * targetJumpHeight * movement.gravity);
}

function DidJump () {
    jump.jumping = true;
    jump.reachedApex = false;
    jump.lastTime = Time.time;
    jump.lastStartHeight = transform.position.y;
    jump.lastButtonTime = -10;
}

function UpdateEffects () {
    wereEmittersOn = areEmittersOn;
    areEmittersOn = jump.jumping && movement.verticalSpeed > 0.0;

    // By comparing the previous value of areEmittersOn to the new one, we will only update the particle emitters when needed
    if (wereEmittersOn != areEmittersOn) {
        for (var emitter in GetComponentsInChildren (ParticleEmitter)) {
            emitter.emit = areEmittersOn;
        }
    }
}

function Update () {
    if (Input.GetButtonDown ("Jump") && canControl) {
        jump.lastButtonTime = Time.time;
    }

    UpdateSmoothedMovementDirection();

    // Apply gravity
    // - extra power jump modifies gravity
    ApplyGravity ();

    // Apply jumping logic
    ApplyJumping ();

    // Moving platform support
    if (activePlatform != null) {
        var newGlobalPlatformPoint = activePlatform.TransformPoint(activeLocalPlatformPoint);
        var moveDistance = (newGlobalPlatformPoint - activeGlobalPlatformPoint);
        transform.position = transform.position + moveDistance;
        lastPlatformVelocity = (newGlobalPlatformPoint - activeGlobalPlatformPoint) / Time.deltaTime;
    } else {
        lastPlatformVelocity = Vector3.zero;    
    }

    activePlatform = null;

    // Save lastPosition for velocity calculation.
    lastPosition = transform.position;

    // Calculate actual motion
    var currentMovementOffset = Vector3(movement.momentum, movement.verticalSpeed, 0) + movement.inAirVelocity;

    // We always want the movement to be framerate independent.  Multiplying by Time.deltaTime does this.
    currentMovementOffset *= Time.deltaTime;

    // Move our character!
    movement.collisionFlags = controller.Move (currentMovementOffset);

    // Calculate the velocity based on the current and previous position.  
    // This means our velocity will only be the amount the character actually moved as a result of collisions.
    movement.velocity = (transform.position - lastPosition) / Time.deltaTime;

    // Moving platforms support
    if (activePlatform != null) {
        activeGlobalPlatformPoint = transform.position;
        activeLocalPlatformPoint = activePlatform.InverseTransformPoint (transform.position);
    }

    // Set rotation to the move direction   
    if (movement.direction.sqrMagnitude > 0.01)
        transform.rotation = Quaternion.Slerp (transform.rotation, Quaternion.LookRotation (movement.direction), Time.deltaTime * movement.rotationSmoothing);

    // We are in jump mode but just became grounded
    if (controller.isGrounded) {
        movement.inAirVelocity = Vector3.zero;
        if (jump.jumping) {
            jump.jumping = false;
            SendMessage ("DidLand", SendMessageOptions.DontRequireReceiver);

            var jumpMoveDirection = movement.direction * movement.speed + movement.inAirVelocity;
            if (jumpMoveDirection.sqrMagnitude > 0.01)
                movement.direction = jumpMoveDirection.normalized;
        }
    }   

    // Update special effects like rocket pack particle effects
    UpdateEffects ();
}

function OnControllerColliderHit (hit : ControllerColliderHit)
{
    if (hit.moveDirection.y > 0.01) 
        return;

    // Make sure we are really standing on a straight platform
    // Not on the underside of one and not falling down from it either!
    if (hit.moveDirection.y < -0.9 && hit.normal.y > 0.9) {
        activePlatform = hit.collider.transform;    
    }
}

// Various helper functions below:
function GetSpeed () {
    return movement.speed;
}

function GetVelocity () {
    return movement.velocity;
}

function IsMoving () {
    return movement.isMoving;
}

function IsJumping () {
    return jump.jumping;
}

function IsTouchingCeiling () {
    return (movement.collisionFlags & CollisionFlags.CollidedAbove) != 0;
}

function GetDirection () {
    return movement.direction;
}

function GetHangTime() {
    return movement.hangTime;
}

function Reset () {
    gameObject.tag = "Player";
}

function SetControllable (controllable : boolean) {
    canControl = controllable;
}

// Require a character controller to be attached to the same game object
@script RequireComponent (CharacterController)
@script AddComponentMenu ("2D Platformer/Platformer Controller")

I noticed that the Windows version seems a bit buggier than it's Mac counterpart. I might try this out on my Mac tonight and see what happens. Or maybe I didn't insert your code at the right places... ? My programming knowledge is pretty poor so I might do something wrong. I'll try on my Mac first and see if I'm going somewhere with this... Thanks for trying to help me, by the way! :)

 –

I don't know what to say Phil. I've pulled up the 2D Gameplay Tutorial, added the exact changes above and got the results that you were asking about, playing with the traction to get the feel of different surfaces. To get more realistic results than that, tune the speedSmoothing and walk/run speeds to something more natural.

 –

Hmmm... would it be possible for you to send me the whole script so I can check what I did wrong ? Or maybe I could send you my script so you can verify ? Being an artist, I really suck at programming so I probably did more than one thing wrong...

 –

For whatever reason, your script worked the first time I tried. I'll try to compare both and see where I made my mistakes. Thank you very much for your help!! :)

 –

Hello again, I've found out that there was one single different thing between the two scripts you provided me: In the "UpdateSmoothedMovementDirection", inside the "if(controller.isGrounded)", you first wrote "var traction = GetSurfaceTraction();" and in the whole script you showed me, at the same place, this is written instead: "var traction = 0.5;". Do you think it might be the reason why it didn't work ?

 –
4

I’m just starting to learn unity so I have little or no idea what I’m doing but I remember these guys talking about smooth rotation of the head when using your mouse to aim where it’s looking at, instead of instantly looking in that direction.

http://unity3d.com/support/old-resources/unite-presentations/character-animation-tips-amp-tricks

5

Check out my 2D controller from the Asset Store: http://forum.unity3d.com/threads/173640-Released-2D-Platform-Controller