[C#] Can Someone Help Explain This To Me?

Unity Engine
1

In Unity, I’ve been able to pick up a few things rather easily, however I’ve always had a very big problem with movement with Unity. That is, I don’t know how to go beyond whatever a tutorial tells me to do, and I don’t really understand what that tutorial is trying to do, no matter how much I try to break it down. Could someone explain to me what they mean in the Scripting API for CharacterController.Move?

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public float speed = 6.0F;
    public float jumpSpeed = 8.0F;
    public float gravity = 20.0F;
    private Vector3 moveDirection = Vector3.zero;
    void Update() {
        CharacterController controller = GetComponent<CharacterController>();
        if (controller.isGrounded) {
            moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
            moveDirection = transform.TransformDirection(moveDirection);
            moveDirection *= speed;
            if (Input.GetButton("Jump"))
                moveDirection.y = jumpSpeed;
           
        }
        moveDirection.y -= gravity * Time.deltaTime;
        controller.Move(moveDirection * Time.deltaTime);
    }
}

Lines, like 13, 14, and 19 really confuse me, because I understand the syntax and what C# is doing with that data, however I don’t understand what the purpose of it is. Could someone just comment out the code and establish what it’s all doing for me? I’d really appreciate it. Thanks

2

It is just a vector math. You will hardly understand if you don’t understand vectors.

3

Essentially, line 12:moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0f, Input.GetAxis("Vertical")); is getting the horizontal and vertical “axis” values from the Input class. This will generally be -1 to 1 for keyboards and joysticks:

  • Vertical - Up = 1
  • Vertical - Down = -1
  • Horizontal - Right = 1
  • Horizontal - Left = -1

This is being used to correspond to Vector3 directions. Vector3s represent either a position or a direction in 3D space. It’s saying “whatever our horizontal input is, from -1 to 1, that’s going to be our X direction (left or right), and whatever our vertical input is, from -1 to 1, that’s going to be our Z direction (back or forward)”.

It’s worth noting here that the coordinate system in Unity is set up such that:

  • Forward = +Z
  • Back = -Z
  • Right = +X
  • Left = -X
  • Up = +Y
  • Down = -Y

And you can access these directions very quickly with the Vector3 shorthand members of “Vector3.forward”, “Vector3.right”, “Vector3.up”, etc… (Vector3.forward, for instance has x / y / z values which are “0 / 0 / 1” which is +Z).

And it’ll make a lot of sense the more you think about it. The next thing you have to think about is the difference between a local direction and a world direction. Say you have a character who’s standing right on the origin point (0,0,0) in world space and facing north (forward, or +Z). To that character, local space and world space mean the same thing- “to his right” means +X, and “behind him” means -Z.

Now turn the character so that he’s facing left. Suddenly his “to his right”, his personal +X, is actually +Z in world space.

Line 13:moveDirection = transform.TransformDirection(moveDirection); transform.TransformDirection(), turns the “transform”'s personal directions into world directions, so by saying “transform.TransformDirection(Vector3.forward)” which is a shorthand way of writing “+Z” as a direction (personal “forward”), you’re translating what “forward” means to that transform into what that direction is in world space, which can be anything depending on how the object is rotated. The result is always going to be a unit value though (like +1Z or -1Z), so in order to vary how far you’re going to move in that direction, you have to multiply that by speed, which is what they do next on line 14:moveDirection *= speed;

Line 19:moveDirection.y -= gravity * Time.deltaTime; pulls the object down in the global -y direction (“down” in the global sense, not the object’s personal sense) in order to simulate the effect of gravity. This is useful to keep your object firmly planted on terra firma- or “drop” if you step off a ledge or jump. The value set for gravity there is 20f, so essentially “20 units per second”, which is sort of arbitrary but works well as long as you have an object that’s roughly 1-2 units tall, and not 50. Time.deltaTime is actually “the amount of time the last frame took to process”, so it’s a great way to smooth things out and make them framerate-independent, meaning that your game won’t actually move faster with a higher framerate or slower with a lower framerate.

Hope that helps!

1 Like
4

To a degree that helped hahaha, I understood the axis and most of the stuff to do with Vectors, it was more or less just the fact that the people who wrote that code in the first place didn’t comment it so it could be understood a lot better, which is kind of odd considering how it’s there to help people learn the scripting API of Unity.