# Creating a controllable character

There are two ways to create a controllable character in Unity, by using the Character Controller component or physical Rigidbody. Both of them have their pros and cons, and the choice to use one or the other is usually based on the needs of the project. For instance, if we want to create a basic role playing game, where a character is expected to be able to walk, fight, run, and interact with treasure chests, we would recommend using the Character Controller component. The character is not going to be affected by physical forces, and the Character Controller component gives us the ability to go up slopes and stairs without the need to add extra code. Sounds amazing, doesn’t it? There is one caveat. The Character Controller component becomes useless if we decide to make our character non-humanoid. If our character is a dragon, spaceship, ball, or a piece of gum, the Character Controller component won’t know what to do with it.

It’s not programmed for those entities and their behavior. So, if we want our character to swing across the pit with his whip and dodge traps by rolling over his shoulder, the Character Controller component will cause us many problems.

In this article, we will look into the creation of a character that is greatly affected by physical forces, therefore, we will look into the creation of a custom Character Controller with Rigidbody, as shown in the preceding screenshot.

# Custom Character Controller

In this section, we will write a script that will take control of basic character manipulations. It will register a player’s input and translate it into movement. We will talk about vectors and vector arithmetic, try out raycasting, make a character obey our controls and see different ways to register input, describe the purpose of the FixedUpdate function, and learn to control Rigidbody.

We shall start with teaching our character to walk in all directions, but before we start coding, there is a bit of theory that we need to know behind character movement.

Most game engines, if not all, use vectors to control the movement of objects. Vectors simply represent direction and magnitude, and they are usually used to define an object’s position (specifically its pivot point) in a 3D space. Vector is a structure that consists of three variables—X, Y, and Z. In Unity, this structure is called Vector3:

To make the object move, knowing its vector is not enough.

Length of vectors is known as magnitude. In physics, speed is a pure scalar, or something with a magnitude but no direction. To give an object a direction, we use vectors. Greater magnitude means greater speed. By controlling vectors and magnitude, we can easily change our direction or increase speed at any time we want.

Vectors are very important to understand if we want to create any movement in a game. Through the examples in this article, we will explain some basic vector manipulations and describe their influence on the character. It is recommended that you learn extra material about vectors to be able to perfect a Character Controller based on game needs.

## Setting up the project

To start this section, we need an example scene. Perform the following steps:

1. Select Chapter 2 folder from book assets, and click on on the Unity_chapter2 scene inside the custom_scene folder.
2. In the Custom scripts folder, create a new JavaScript file. Call it CH_Controller (we will reference this script in the future, so try to remember its name, if you choose a different one):
3. In a Hierarchy view, click on the object called robot. Translate the mouse to a Scene view and press F; the camera will focus on a funny looking character that we will teach to walk, run, jump, and behave as a character from a video game.

## Creating movement

The following is the theory of what needs to be done to make a character move:

1. Register a player’s input.
2. Store information into a vector variable.
3. Use it to move a character.

Sounds like a simple task, doesn’t it? However, when it comes to moving a player-controlled character, there are a lot of things that we need to keep in mind, such as vector manipulation, registering input from the user, raycasting, Character Controller component manipulation, and so on. All these things are simple on their own, but when it comes to putting them all together, they might bring a few problems. To make sure that none of these problems will catch us by surprise, we will go through each of them step by step.

### Manipulating character vector

By receiving input from the player, we will be able to manipulate character movement. The following is the list of actions that we need to perform in Unity:

1. Open the CH_Character script.
2. Declare public variables Speed and MoveDirection of types float and Vector3 respectively. Speed is self-explanatory, it will determine at which speed our character will be moving. MoveDirection is a vector that will contain information about the direction in which our character will be moving.
3. Declare a new function called Movement. It will be checking horizontal and vertical inputs from the player.
4. Finally, we will use this information and apply movement to the character. An example of the code is as follows:
5. ```public var Speed : float = 5.0;
public var MoveDirection : Vector3 = Vector3.zero;
function Movement (){
if (Input.GetAxis("Horizontal") || Input.GetAxis("Vertical"))
MoveDirection = Vector3(Input.GetAxisRaw("Horizontal"),MoveDirecti
on.y, Input.GetAxisRaw("Vertical"));
this.transform.Translate(MoveDirection);
}```

### Register input from the user

In order to move the character, we need to register an input from the user. To do that, we will use the Input.GetAxis function. It registers input and returns values from -1 to 1 from the keyboard and joystick. Input.GetAxis can only register input that had been defined by passing a string parameter to it. To find out which options are available, we will go to Edit | Projectsettings | Input. In the Inspector view, we will see Input Manager.

Click on the Axes drop-down menu and you will be able to see all available input information that can be passed to the Input.GetAxis function. Alternatively, we can use Input.GetAxisRaw. The only difference is that we aren’t using Unity’s built-in smoothing and processing data as it is, which allows us to have greater control over character movement.

To create your own input axes, simply increase the size of the array by 1 and specify your preferences (later we will look into a better way of doing and registering input for different buttons).

this.transform is an access to transformation of this particular object. transform contains all the information about translation, rotation, scale, and children of this object. Translate is a function inside Unity that translates GameObject to a specific direction based on a given vector.

If we simply leave it as it is, our character will move with the speed of light. That happens because translation is being applied on character every frame. Relying on frame rate when dealing with translation is very risky, and as each computer has different processing power, execution of our function will vary based on performance. To solve this problem, we will tell it to apply movement based on a common factor—time:

`this.transform.Translate(MoveDirection * Time.deltaTime);`

This will make our character move one Unity unit every second, which is still a bit too slow. Therefore, we will multiply our movement speed by the Speed variable:

`this.transform.Translate((MoveDirection * Speed) * Time.deltaTime);`

Now, when the Movement function is written, we need to call it from Update. A word of warning though—controlling GameObject or Rigidbody from the usual Update function is not recommended since, as mentioned previously, that frame rate is unreliable. Thankfully, there is a FixedUpdate function that will help us by applying movement at every fixed frame. Simply change the Update function to FixedUpdate and call the Movement function from there:

```function FixedUpdate (){
Movement();
}```

### The Rigidbody component

Now, when our character is moving, take a closer look at the Rigidbody component that we have attached to it. Under the Constraints drop-down menu, we will notice that Freeze Rotation for X and Z axes is checked, as shown in the following screenshot:

If we uncheck those boxes and try to move our character, we will notice that it starts to fall in the direction of the movement. Why is this happening? Well, remember, we talked about Rigidbody being affected by physics laws in the engine? That applies to friction as well. To avoid force of friction affecting our character, we forced it to avoid rotation along all axes but Y. We will use the Y axis to rotate our character from left to right in the future.

Another problem that we will see when moving our character around is a significant increase in speed when walking in a diagonal direction. This is not an unusual bug, but an expected behavior of the MoveDirection vector. That happens because for directional movement we use vertical and horizontal vectors. As a result, we have a vector that inherits magnitude from both, in other words, its magnitude is equal to the sum of vertical and horizontal vectors.

To prevent that from happening, we need to set the magnitude of the new vector to 1. This operation is called vector normalization. With normalization and speed multiplier, we can always make sure to control our magnitude:

```this.transform.Translate((MoveDirection.normalized * Speed) * Time.
deltaTime);```

## Jumping

Jumping is not as hard as it seems. Thanks to Rigidbody, our character is already affected by gravity, so the only thing we need to do is to send it up in the air. Jump force is different from the speed that we applied to movement. To make a decent jump, we need to set it to 500.0). For this specific example, we don’t want our character to be controllable in the air (as in real life, that is physically impossible). Instead, we will make sure that he preserves transition velocity when jumping, to be able to jump in different directions. But, for now, let’s limit our movement in air by declaring a separate vector for jumping.

### User input verification

In order to make a jump, we need to be sure that we are on the ground and not floating in the air. To check that, we will declare three variables—IsGrounded, Jumping, and inAir—of a type boolean. IsGrounded will check if we are grounded. Jumping will determine if we pressed the jump button to perform a jump. inAir will help us to deal with a jump if we jumped off the platform without pressing the jump button. In this case, we don’t want our character to fly with the same speed as he walks; we need to add an airControl variable that will smooth our fall.

Just as we did with movement, we need to register if the player pressed a jump button. To achieve this, we will perform a check right after registering Vertical and Horizontal inputs:

```public var jumpSpeed : float = 500.0;
public var jumpDirection : Vector3 = Vector3.zero;
public var IsGrounded : boolean = false;
public var Jumping : boolean = false;
public var inAir : boolean = false;
public var airControl : float = 0.5;
function Movement(){
if (Input.GetAxis("Horizontal") || Input.GetAxis("Vertical")) {
MoveDirection = Vector3(Input.GetAxisRaw("Horizontal"),MoveDirection.y,Input.GetAxisRaw("Vertical"));
}
if (Input.GetButtonDown("Jump") && isGrounded) {}
} ```

GetButtonDown determines if we pressed a specific button (in this case, Space bar), as specified in Input Manager. We also need to check if our character is grounded to make a jump.

We will apply vertical force to a rigidbody by using the AddForce function that takes the vector as a parameter and pushes a rigidbody in the specified direction. We will also toggle Jumping boolean to true, as we pressed the jump button and preserve velocity with JumpDirection:

```if (Input.GetButtonDown("Jump") &&isGrounded){
Jumping = true;
jumpDirection = MoveDirection;
}
if (isGrounded)
this.transform.Translate((MoveDirection.normalized * Speed) * Time.deltaTime);
else if (Jumping || inAir)
this.transform.Translate((jumpDirection * Speed * airControl) * Time.deltaTime);```

To make sure that our character doesn’t float in space, we need to restrict its movement and apply translation with MoveDirection only, when our character is on the ground, or else we will use jumpDirection.

### Raycasting

The jumping functionality is almost written; we now need to determine whether our character is grounded. The easiest way to check that is to apply raycasting. Raycasting simply casts a ray in a specified direction and length, and returns if it hits any collider on its way (a collider of the object that the ray had been cast from is ignored):

To perform a raycast, we will need to specify a starting position, direction (vector), and length of the ray. In return, we will receive true, if the ray hits something, or false, if it doesn’t:

```function FixedUpdate ()
{
if (Physics.Raycast(transform.position, -transform.up, collider.
height/2 + 2)){
isGrounded = true;
Jumping = false;
inAir = false;
}
else if (!inAir){
inAir = true;
JumpDirection = MoveDirection;
}
Movement();
}  ```

As we have already mentioned, we used transform.position to specify the starting position of the ray as a center of our collider. -transform.up is a vector that is pointing downwards and collider.height is the height of the attached collider. We are using half of the height, as the starting position is located in the middle of the collider and extended ray for two units, to make sure that our ray will hit the ground. The rest of the code is simply toggling state booleans.

#### Improving efficiency in raycasting

But what if the ray didn’t hit anything? That can happen in two cases—if we walk off the cliff or are performing a jump. In any case, we have to check for it.

If the ray didn’t hit a collider, then obviously we are in the air and need to specify that. As this is our first check, we need to preserve our current velocity to ensure that our character doesn’t drop down instantly.

Raycasting is a very handy thing and being used in many games. However, you should not rely on it too often. It is very expensive and can dramatically drop down your frame rate.

Right now, we are casting rays every frame, which is extremely inefficient. To improve our performance, we only need to cast rays when performing a jump, but never when grounded. To ensure this, we will put all our raycasting section in FixedUpdate to fire when the character is not grounded.

```function FixedUpdate (){
if (!isGrounded){
if (Physics.Raycast(transform.position, -transform.up,
collider.height/2 + 0.2)){
isGrounded = true;
Jumping = false;
inAir = false;
}
else if (!inAir){
inAir = true;
jumpDirection = MoveDirection;
}
}
Movement();
}
function OnCollisionExit(collisionInfo : Collision){
isGrounded = false;
}```

To determine if our character is not on the ground, we will use a default function— OnCollisionExit(). Unlike OnControllerColliderHit(), which had been used with Character Controller, this function is only for colliders and rigidbodies. So, whenever our character is not touching any collider or rigidbody, we will expect to be in the air, therefore, not grounded.

Let’s hit Play and see our character jumping on our command.

Now that we have our character jumping, there are a few issues that should be resolved. First of all, if we decide to jump on the sharp edge of the platform, we will see that our collider penetrates other colliders. Thus, our collider ends up being stuck in the wall without a chance of getting out:

A quick patch to this problem will be pushing the character away from the contact point while jumping. We will use the OnCollisionStay() function that’s called at every frame when we are colliding with an object. This function receives collision contact information that can help us determine who we are colliding with, its velocity, name, if it has Rigidbody, and so on. In our case we are interested in contact points. Perform the following steps:

1. Declare a new private variable contact of a ContactPoint type that describes the collision point of colliding objects.
2. Declare the OnCollisonStay function.
3. Inside this function, we will take the first point of contact with the collider and assign it to our private variable.
4. Add force to the contact position to reverse the character’s velocity, but only if the character is not on the ground.
5. Declare a new variable and call it jumpClimax of boolean type.

Contacts is an array of all contact points.

Finally, we need to move away from that contact point by reversing our velocity. The AddForceAtPosition function will help us here. It is similar to the one that we used for jumping, however, this one applies force at a specified position (contact point):

```public var jumpClimax :boolean = false;
...
function OnCollisionStay(collisionInfo : Collision){
contact = collisionInfo.contacts[0];
if (inAir || Jumping)
}   ```

The next patch will aid us in the future, when we will be adding animation to our character later in this article. To make sure that our jumping animation runs smoothly, we need to know when our character reaches jumping climax, in other words, when it stops going up and start a falling.

In the FixedUpdate function, right after the last else if statement, put the following code snippet:

```else if (inAir&&rigidbody.velocity.y == 0.0) {
jumpClimax = true;
}```

Nothing complex here. In theory, the moment we stop going up is a climax of our jump, that’s why we check if we are in the air (obviously we can’t reach jump climax when on the ground), and if vertical velocity of rigidbody is 0.0. The last part is to set our jumping climax to false. We’ll do that at the moment when we touch the ground:

```if (Physics.Raycast(transform.position, -transform.up, collider.
height/2 + 2)){
isGrounded = true;
Jumping = false;
inAir = false;
jumpClimax = false;
}```

## Running

We taught our character to walk, jump, and stand aimlessly on the same spot. The next logical step will be to teach him running. From a technical point of view, there is nothing too hard. Running is simply the same thing as walking, but with a greater speed. Perform the following steps:

1. Declare a new variable IsRunning of a type boolean, which will be used to determine whether our character has been told to run or not.
2. Inside the Movement function, at the very top, we will check if the player is pressing left or right, and shift and assign an appropriate value to isRunning:
3. ```public var isRunning : boolean = false;
...
function Movement()
{
if (Input.GetKey (KeyCode.LeftShift) || Input.GetKey (KeyCode.
RightShift))
isRunning = true;
else
isRunning = false;
...
}   ```

Another way to get input from the user is to use KeyCode. It is an enumeration for all physical keys on the keyboard. Look at the KeyCode script reference for a complete list of available keys, on the official website: http://unity3d.com/ support/documentation/ScriptReference/KeyCode