## DEV Community

Ellie

Posted on • Updated on

# Unity Transform: Position

So I've been learning a lot of Unity lately, but want to really solidify what I've been learning.

What better way to do that than writing a blog about it?

In this series we are going to get into some basic, but SUPER important things when getting started with Unity game development.

These things are:

• Position
• Scale
• Rotation

Let's jump right into it!

## Position

So, what you see in this image is the Unity editor, and there is just a white square plane in the middle of the scene.

If you take a close look in the inspector, you can see an area called transform. Below that, you can see position.

This refers to the position in the scene and is determined by x, y, and z coordinates. In this example, our plane is right in the middle of the scene at `Vector3(0, 0, 0)`. If you get confused by which one is which (meaning the x, y, and z-axis) you can take a look at the thing circled in orange, which comes in handy when changing the position of objects.

By the way, what even is a `Vector3`?? Well, `Vector3` in Unity represents a 3D position or direction using x, y, and z coordinates. You can learn more about that here.

### Here comes THE CUBE!

So, as you can see we have added a cube on top of our plane. Why?

Well, we are going to make the cube move, it should be able to move forward, backward, left, and right with the arrow keys, and even jump up with the spacebar. By doing this you should be able to have a solid understanding of positioning in Unity.

Some things to be aware of in this post:

• Horizontal input (left and right arrow keys) moves the cube left and right along the X-axis (the red one).
• Vertical input (up and down arrow keys) moves the cube forward and backward along the Z-axis (the blue one).
• Jumping is controlled separately (with the space bar), and changes the cube's position on the Y-axis (the green one).

Now that we've defined some important words that you'll see later on, let's get into the code!

``````public class CubePosition : MonoBehaviour
{
public float speed = 10.0f;
public float jumpForce = 10.0f;
public float horizontalInput;
public float verticalInput;
private Rigidbody rb;
}
``````

First, we are going to go ahead and define some of our public and private variables. We make some of the variables public so we can easily edit them later in the Unity editor.ðŸ‘‡

We can directly edit the Speed and Jump Force here, and Horizontal and Vertical Input will change automatically when we click the arrow keys (after we add that logic later).

The private variable `rb` is a reference to the Rigidbody component attached to the cube, which allows us to apply physics-based behaviors to it. Later, we'll use this to make the cube jump!

Next, we have our `Start()` and `Update()` functions.

``````void Start()
{
rb = GetComponent<Rigidbody>();
}

// Update is called once per frame
void Update()
{
Move();
Jump();
}
``````

Here we have two methods, `Start()` runs once when the game starts, right before anything else happens and `Update()` runs once per frame.

`Start()` assigns the cube's Rigidbody component to rb, allowing for physics-based movement.

Then, within `Update()`, we call 2 functions that we will now create!

## Let's Move!

First, the `Move()` method!

``````void Move()
{
horizontalInput = Input.GetAxis("Horizontal");
verticalInput = Input.GetAxis("Vertical");

// this moves the cube forward and backward
transform.Translate(Vector3.forward * Time.deltaTime * speed * verticalInput);
// this moves the cube left and right
transform.Translate(Vector3.right * Time.deltaTime * speed * horizontalInput);
}
``````

The `Move()` method gets player input for movement, using `Input.GetAxis` for both vertical (forward/backward) and horizontal (left/right) directions. Then, we assign these inputs to `horizontalInput` and `verticalInput` variables.

After that, we use `transform.Translate` to make the game object move.

``````transform.Translate(Vector3.forward * Time.deltaTime * speed * verticalInput);
``````

Here, we are controlling the forward and backward movement of the object (on the Z-axis).

`Vector3.forward` (which is the shorthand for `Vector3(0,0,1)`) targets movement along the Z-axis and is multiplied by:

• `Time.deltaTime` for consistent speed across frames
• `speed` for movement speed
• `verticalInput` for direction based on player input

Then we do something very similar to allow for left and right movement.

``````transform.Translate(Vector3.right * Time.deltaTime * speed * horizontalInput);
``````

Here, we use `Vector3.right` (shorthand for `Vector3(1,0,0)`) for movement along the X-axis and multiply it by `Time.deltaTime`, `speed`, and `horizontalInput`.

Yay! Now our cube can move forward, backward, left, and right!

## Let's Jump!

Note: it's not generally a good idea to mix two different movement systems, but for the sake of simplicity I am leaving it like this for nowðŸ˜…

Now let's move on to our `Jump()` method:

``````void Jump()
{
if (Input.GetKeyDown(KeyCode.Space))
{
// this moves the cube up (jump)
}
}
``````

The `Jump()` method makes it possible for our cube to jump into the air. It checks if the player has pressed the space bar
with `(Input.GetKeyDown(KeyCode.Space))`.

If the player has pressed the space bar, there is an upward force applied to the object. We calculate this force by multiplying `Vector3.up` (along the Y-axis) by `jumpForce` (the strength of the jump), and `ForceMode.Impulse` to make sure the force is applied right away.

That's all we need to make the cube move with the arrow keys and space bar! Here's the entire script if you would like to try it yourself. But make sure to add a Rigidbody component to the cube so it uses gravity.

### Complete Script

``````using UnityEngine;

public class CubePosition : MonoBehaviour
{
public float speed = 10.0f;
public float jumpForce = 10.0f;
public float horizontalInput;
public float verticalInput;
private Rigidbody rb;

// Start is called before the first frame update
void Start()
{
rb = GetComponent<Rigidbody>();
}

// Update is called once per frame
void Update()
{
Move();
Jump();
}
void Move()
{
horizontalInput = Input.GetAxis("Horizontal");
verticalInput = Input.GetAxis("Vertical");

// this moves the cube forward and backward
transform.Translate(Vector3.forward * Time.deltaTime * speed * verticalInput);
// this moves the cube left and right
transform.Translate(Vector3.right * Time.deltaTime * speed * horizontalInput);

}

void Jump()
{
if(Input.GetKeyDown(KeyCode.Space))
{
// this moves the cube up (jump)
}
}
}
``````

### The Result

You can test what we've created here.

Last but not least, here's a video of our cube in action! In this video, you can see how the x, y, and z values change as I click the arrow keys and space bar.

Well, that's all for this post. If you end up making your own cube and adding movement, feel free to share it in the comments!

If you have any suggestions for how to improve this post or notice anything I have excluded please let me know ðŸ˜„

If you're looking for more resources to learn how to code check out my Free Coding Resources site, it has links to a bunch of my favorite courses/resources!

And of course, be sure to check out Unity Learn, it's an amazing resource!

If you have any questions or want to connect, the best place to reach me is on Twitter/X.

Happy coding!