In the previous chapter, we have added a background and some props to our scene. It is time to add some useful game elements, like the player!

Creating the player

Creating a player controllable entity needs some elements : a sprite, a way to control it and a way to let it interact with the world.

We will explore this process step by step.

Let’s begin with the sprite.

Add a sprite

Here is the image that we will use:

(Right click to save the image)

1. Copy the player image to the “Textures” folder.

2. Create a new Sprite. Name it “Player”.

3. Select the sprite to display in the “Sprite” property of the “Sprite Renderer” component.

If you have any trouble, refer to the previous part. We did exactly the same procedure for the background and props.

1. Select the “Player” sprite layer.

2. Place the player in the “Foreground” object.

3. Change its scale. (0.2, 0.2, 1) should be fine.

A word about components

We have just talked about a “Sprite Renderer” component. If you haven’t remarked, a game object is composed of a few components, visibles in the “Inspector” pane.

By default, an empty game object looks like:

This object has only one component: a “Transform”. This component is required and cannot be disabled or removed from an object.

You can add as many components as you want on an object. A script is added as a component, for example. Most of the components can be enabled or disabled during the lifetime of the object.

(You can click on the checkbox to disabled it. You can right-click on a component to reset it, remove it, etc.)

A “Sprite Renderer” is a component that is able to display a sprite texture.

Now that we have learned about the concept of component, let’s add one to the player!

Add a Box Collider

Click on the “Add Component” button of the player object. Choose a “Box Collider 2D”.

This will represent the player hitbox.

You can see the collider in the editor “Scene” view and tweak its size in the “Inspector” with the “Size” property.

We will set the size of the collider to (10, 10).

It’s way too large for a real shmup but it’s still smaller than the sprite:

For the time being, it will be enough.

Save the player game object to a prefab. You now have a basic player entity!

Polygon Collider 2D

If you want a super precise and custom shaped hitbox, Unity offers a “Polygon Collider 2D” component. It’s less efficient but allows you to set the shape exactly like you want.

The Rigidbody magic

There is one last component to add on our player: a “Rigidbody 2D”.

This will tell to the physics engine how to handle the game object. Furthermore, it will also allow collision events to be raised in scripts.

1. Select your Player game object in the “Hierarchy”.
2. Add a “Rigidbody 2D” component.

Now, hit play and observe:

The ship is falling!

Say hello to our beloved gravity. :)

As new scenes come with a default gravity and rigidbodies add a mass to an object, the ship is now attracted to the bottom.

Gravity can be used in some kind of games, but we don’t want to have to handle it here. Fortunately, it is simple to disable gravity on a rigidbody. Just set “Gravity Scale” to 0. That’s it, the ship is flying again.

You may also want to tick the “Fixed Angles” property as we don’t want our ship to rotate because of the physics.

The complete settings:

Moving the player

Time for some scripting! So far, we didn’t code anything. That’s the power of (love) Unity.

Inside Unity, create a new C# script in your “Scripts” folder. Call it “PlayerScript”.

Open your favorite editor or use the “Sync” submenu (Click on “Assets” in the menubar, then on “Sync MonoDevelop Project”) to edit the script.

If you come from XNA, you won’t be lost.

You can define some methods (called “Message” as we are not using C# inheritance system) that Unity will recognize and execute when needed.

Default scripts come with the Start and Update methods. Here is a short list of the most used “Message” functions:

• Awake() is called once when the object is created. See it as replacement of a classic constructor method.
• Start() is executed after Awake(). The difference is that the Start() method is not called if the script is not enabled (remember the checkbox on a component in the “Inspector”).
• Update() is executed for each frame in the main game loop.
• FixedUpdate() is called at every fixed framerate frame. You should use this method over Update() when dealing with physics (“RigidBody” and forces).
• Destroy() is invoked when the object is destroyed. It’s your last chance to clean or execute some code.

You also have some functions for the collisions :

• OnCollisionEnter2D(CollisionInfo2D info) is invoked when another collider is touching this object collider.
• OnCollisionExit2D(CollisionInfo2D info) is invoked when another collider is not touching this object collider anymore.
• OnTriggerEnter2D(Collider2D otherCollider) is invoked when another collider marked as a “Trigger” is touching this object collider.
• OnTriggerExit2D(Collider2D otherCollider) is invoked when another collider marked as a “Trigger” is not touching this object collider anymore.

Fiou… This explanation was a bit boring, but unavoidable. Sorry for that.

We will get back on some of them in details when we will be using them.

For our player script, we will add some simple controls: the arrow keys will move the ship.

using UnityEngine;

/// <summary>
/// Player controller and behavior
/// </summary>
public class PlayerScript : MonoBehaviour
{
    /// <summary>
    /// 1 - The speed of the ship
    /// </summary>
    public Vector2 speed = new Vector2(50, 50);

    // 2 - Store the movement and the component
    private Vector2 movement;
    private Rigidbody2D rigidbodyComponent;

    void Update()
    {
        // 3 - Retrieve axis information
        float inputX = Input.GetAxis("Horizontal");
        float inputY = Input.GetAxis("Vertical");

        // 4 - Movement per direction
        movement = new Vector2(
          speed.x * inputX,
          speed.y * inputY);

    }

    void FixedUpdate()
    {
        // 5 - Get the component and store the reference
        if (rigidbodyComponent == null) rigidbodyComponent = GetComponent<Rigidbody2D>();

        // 6 - Move the game object
        rigidbodyComponent.velocity = movement;
    }
}

(The numbers in the comments refer to the explanations below)

Explanations

1. We first define a public variable that will appear in the “Inspector” view of Unity. This is the speed applied to the ship.
2. The fields we need.
3. We use the default axis that can be redefined in “Edit” -> “Project Settings” -> “Input”. This will return a value between [-1, 1], 0 being the idle state, 1 the right, -1 the left.
4. We multiply the direction by the speed.
5. We need to access the rigidbody component, but we can avoid to do it every frame by storing a reference.
6. We change the rigidbody velocity. This will tell the physic engine to move the game object. We do that in FixedUpdate() as it is recommended to do everything that is physics-related in there.

Now, attach the script to the game object.

Hit the “Play” button in top of the editor. The ship is moving and your game is running! Congratulations, you have just made the equivalent of a “Hello, World!” for a game :)

Try to tweak the speed: click on the player, modify the speed values in the “Inspector” and look at the consequences.

This was the first sign of life in our game! Let’s add more!

The first enemy

A shmup is nothing without tons of enemies to blow up.

Let’s use an innocent octopus, named “Poulpi”:

(Right click to save the image)

Sprite

Time to create a new sprite! Again:

1. Copy the image to the “sprites” folder.
2. Create a new Sprite using this image.
3. Set the sprite layer to “Enemies”
4. Change the “Scale” property of the Transform to (0.3, 0.3, 1).
5. Add a “Box Collider 2D” with a size of (4, 4).
6. Add a “Rigidbody 2D” with a “Gravity Scale” of 0 and “Fixed Angles” ticked.

Save the prefab… and that’s it!

Script

We will script a simple behavior: the Poulpi will just move in a direction.

Create a new script “MoveScript”.

We could call it “EnemyScript” but we plan to reuse it later in another context.

We will copy some parts of what we have already written in the “PlayerScript” for movement. We will add another designer (a public member you can alter in the “Inspector”) variable for the direction:

using UnityEngine;

/// <summary>
/// Simply moves the current game object
/// </summary>
public class MoveScript : MonoBehaviour
{
    // 1 - Designer variables

    /// <summary>
    /// Object speed
    /// </summary>
    public Vector2 speed = new Vector2(10, 10);

    /// <summary>
    /// Moving direction
    /// </summary>
    public Vector2 direction = new Vector2(-1, 0);

    private Vector2 movement;
    private Rigidbody2D rigidbodyComponent;

    void Update()
    {
        // 2 - Movement
        movement = new Vector2(
          speed.x * direction.x,
          speed.y * direction.y);
    }

    void FixedUpdate()
    {
        if (rigidbodyComponent == null) rigidbodyComponent = GetComponent<Rigidbody2D>();

        // Apply movement to the rigidbody
        rigidbodyComponent.velocity = movement;
    }
}

Attach the script to the Poulpi. Hit “Play”: it should move just like below.

If you move the player in front of the enemy, the two sprites will collide. They will just block each other as we didn’t define the collision behavior yet.

Next step

You have learned how to add a player entity, controlled by the keyboard. Then, we created a basic enemy with a rudimentary AI.

Now, we want to destroy that moving thing! And for that, we need ammo!