Set up your project

Add a game board 

Add a player character 

Add a turn system

Add a food resource

Add obstacles

Add win and lose conditions

Improve graphics

Animation

Add an enemy

Final word and improvement ideas

Take advantage of this completely revamped course to learn how to design and build a 2D Roguelike Game. Throughout this course, you will organize and prioritize your tasks, go over complex programming concepts, and explore the use of pixel art in Unity. By the end of it, you'll have a fully functioning game that you can then build upon to make it your own!

Create a 2D Roguelike Game

22f2f309-72d5-50d1-be98-3c638c5a8189:IJ50VM7ryBj2kIwUvpBbLL

Overview

Smooth movement

Next steps

Before you add the last gameplay element to the game (enemies), let’s first look at improving the game visually. In this tutorial, you’ll create smooth player character movement between cells: instead of the player character “jumping” from one cell to another, you’ll learn a way to make the movement more smooth.

In this tutorial, you’ll focus on improving the graphics of your game to make it more appealing.  You’ll edit the PlayerController script to allow for smoother player character motion. 

The jumping movement between cells might be typical of a traditional roguelike, but let’s add some polish to the experience by making the player character gradually move between the cells. 

To implement this functionality, you’ll need to edit the PlayerController script in the following ways: 

Add a boolean variable that stores whether the player is currently moving or not.

Add a Vector3 variable that stores the target cell the player character is trying to move to (the new cell’s center) and a float variable that stores the velocity at which the player character will move to this new cell.

Change the MoveTo function to wait before moving the player character to the position of the cell and instead set the target move Vector3 to the new position and the moving boolean to true.

In the Update function, if the moving boolean is true, move the transform toward the target position, and when it reaches it, set the moving boolean back to false and notify any object in the new cell that the player character has entered it.

public class PlayerController : MonoBehaviour
{
   public float MoveSpeed = 5.0f;

   private bool m_IsMoving;
   private Vector3 m_MoveTarget;

   . . .
  
   public void MoveTo(Vector2Int cell)
   {
       //technically the player is not there yet, but the movement is only cosmetic
       //and we know nothing can stop it as we checked everything before starting it
       //so safe to update there!
       m_CellPosition = cell;
      
       m_IsMoving = true;
       m_MoveTarget = m_Board.CellToWorld(m_CellPosition);
   }

   public void Init()
   {
       m_IsMoving = false;
       m_IsGameOver = false;
   }

   private void Update()
   {
       if (m_IsGameOver)
       {
           if (Keyboard.current.enterKey.wasPressedThisFrame)
           {
               GameManager.Instance.StartNewGame();
           }

           return;
       }

       if (m_IsMoving)
       {
           transform.position = Vector3.MoveTowards(transform.position, m_MoveTarget, MoveSpeed * Time.deltaTime);

           if (transform.position == m_MoveTarget)
           {
               m_IsMoving = false;
               var cellData = m_Board.GetCellData(m_CellPosition);
               if(cellData.ContainedObject != null)
                   cellData.ContainedObject.PlayerEntered();
           }
       }
      
      . . .

       if(hasMoved)
       {
           //check if the new position is passable, then move there if it is.
           BoardManager.CellData cellData = m_Board.GetCellData(newCellTarget);

           if(cellData != null && cellData.Passable)
           {
               GameManager.Instance.TurnManager.Tick();

               if (cellData.ContainedObject == null)
               {
                   MoveTo(newCellTarget);
               }
               else if(cellData.ContainedObject.PlayerWantsToEnter())
               {
                   MoveTo(newCellTarget);
               }
           }
       }
   }
}


Let’s review the changes and additions we made:

The IsMoving boolean and MoveTarget Vector3 were added, as well as a public float variable MoveSpeed that defines the speed at which the player character moves. Making MoveSpeed a public property will allow it to be adjusted through the Inspector window.

The IsMoving boolean is reset to false in the Init function. Try to always reset the values to their original states in the Init function, otherwise that state will carry over when restarting a game.

The MoveTo function has completely changed: CellPosition is still updated , but now it sets the “moving” boolean to true and stores the position of the target cell as the target position.

Update has a new condition: if isMoving is true, it moves the player character toward their target. Vector3.MoveTowards will move from the first parameter to the second parameter, never exceeding the maximum distance that is the third parameter. Finally, when the current position is the same as the target position, the player character stops moving and calls PlayerEntered on the CellObject in the cell.

Note: Check out the 2D Adventure Game for a more in depth explanation of delta time and speed. 

We updated the code at the end of the Update function that handles checking if the character can move to remove the call to PlayerEntered because it’s now handled by the new moving part. Otherwise the player character would gather food or exit the level before even reaching it.

Now if you enter Play mode, you should see that the player character moves more smoothly across cells. But there are still two problems:

Every time a new level is created, the player character moves across the scene to get to its starting position. To fix this, you need to modify the MoveTo function to allow it to immediately move the player character to the new position and call that modified version in the Spawn function only.

If you press the movement keys before the move is finished, the character starts moving weirdly across the screen. This is because in code the character keeps moving with every key press, updating the target position with the new cell non stop. To fix this, you need to restrict this possibility.

Before you check out the solutions below, try to come up with your own!

public class PlayerController : MonoBehaviour
{
   public float MoveSpeed = 5.0f;

   private bool m_IsMoving;
   private Vector3 m_MoveTarget;

   . . .
  
   public void MoveTo(Vector2Int cell)
   {
       //technically the player is not there yet, but the movement is only cosmetic
       //and we know nothing can stop it as we checked everything before starting it
       //so safe to update there!
       m_CellPosition = cell;
      
       m_IsMoving = true;
       m_MoveTarget = m_Board.CellToWorld(m_CellPosition);
   }

   public void Init()
   {
       m_IsMoving = false;
       m_IsGameOver = false;
   }

   private void Update()
   {
       if (m_IsGameOver)
       {
           if (Keyboard.current.enterKey.wasPressedThisFrame)
           {
               GameManager.Instance.StartNewGame();
           }

           return;
       }

       if (m_IsMoving)
       {
           transform.position = Vector3.MoveTowards(transform.position, m_MoveTarget, MoveSpeed * Time.deltaTime);

           if (transform.position == m_MoveTarget)
           {
               m_IsMoving = false;
               var cellData = m_Board.GetCellData(m_CellPosition);
               if(cellData.ContainedObject != null)
                   cellData.ContainedObject.PlayerEntered();
           }
       }
      
      . . .

       if(hasMoved)
       {
           //check if the new position is passable, then move there if it is.
           BoardManager.CellData cellData = m_Board.GetCellData(newCellTarget);

           if(cellData != null && cellData.Passable)
           {
               GameManager.Instance.TurnManager.Tick();

               if (cellData.ContainedObject == null)
               {
                   MoveTo(newCellTarget);
               }
               else if(cellData.ContainedObject.PlayerWantsToEnter())
               {
                   MoveTo(newCellTarget);
               }
           }
       }
   }
}

The IsMoving boolean and MoveTarget Vector3 were added, as well as a public float that saves the speed at which the player character moves. Making this a public property will allow it to be adjusted through the Inspector window.

The MoveTo function has completely changed: CellPosition is still updated (because the game tests everything for allowing movement before moving and it’s turn based, nothing can interrupt a movement once it has started, so we know the player will end in that cell), but now it sets the “moving” boolean to true and stores the position of the target cell as the target position.

Update has a new condition: if isMoving is true, it moves the player character toward their target. Vector3.MoveTowards will move from the first parameter to the second parameter, never exceeding the maximum distance that is the third parameter. Finally, when the current position is the same as the target position, the player character stops moving and notifies the cell that the player character has entered it.

Every time a new level is created, the player character moves across the scene to get to its starting position at the very beginning. To fix this, you need to modify the MoveTo function to allow it to immediately move the player character to the new position and call that modified version in the Spawn function only.

Before you check out the solutions below,  try to come up with your own by using the suggestions. Here are our solutions:

public void MoveTo(Vector2Int cell, bool immediate)
{
   m_CellPosition = cell;

   if (immediate)
   {
       m_IsMoving = false;
       transform.position = m_Board.CellToWorld(m_CellPosition);
   }
   else
   {
       m_IsMoving = true;
       m_MoveTarget = m_Board.CellToWorld(m_CellPosition);
   }
}

All calls to MoveTo will have to be updated to provide the second parameter now, with it being true in the Spawn function but false in the Update function.

For the second problem, you can add a return at the end of the moving block in Update; this way, as long as the character is moving, all the input reading below it in Update won’t happen.

private void Update()
{
...
if (m_IsMoving)
{
   transform.position = Vector3.MoveTowards(transform.position, m_MoveTarget, MoveSpeed * Time.deltaTime);
  
   if (transform.position == m_MoveTarget)
   {
       m_IsMoving = false;
       var cellData = m_Board.GetCellData(m_CellPosition);
       if(cellData.ContainedObject != null)
           cellData.ContainedObject.PlayerEntered();
   }

   return;
}
...
}


This is an easy fix that works well for this small game, but as a downside, it makes the game slower because the user has to wait for the movement to finish before moving again.

If you prefer, you can check if IsMoving is true in the hasMoved block at the end of the Update function, and if it is, directly move the position to the target position before calling MoveTo with the new target. This way the game has a smooth transition if the user plays slowly, but reverts to snappy, fast movement if the user continuously presses the move buttons.

Your game now looks a lot more polished and professional! In the next tutorial, you’ll improve the look of the game even more, with a focus on animation to take your game to the next level.

Improve graphics

1. Overview

2. Smooth movement

3. Smooth movement

4. Next steps

Complete this tutorial