Creating a Grid Walking Style Character on Unity Engine

Creating a Grid Walking Style Character on Unity Engine · Kevin Hernandez

Pokemon? The Legend of Zelda? Final Fantasy? Looking for that weird walking (just up/down — left/right) style? don’t know how to implement it in your new video game project? well, I do and I’m gonna show you how to.

This tutorial is gonna break itself into X sections:

Creating your projectFirst of all, let’s create a new project on Unity.

Now let’s find some suitable graphics for our learning path. Feel free to use this asset (that also is free, lmao).

https://assetstore.unity.com/packages/2d/environments/tiny-rpg-town-environment-88293

Well, Actually we got a pre-made scene with 16 x 16 tiles, so let’s work on it!

Let’s use that selected sprite as our player.

Now, let’s do the interesting part of this tutorial. :)

Rename it as Player
Add a new C# Script and Call it: “PlayerController”

Go to the “PlayerController.cs” and let’s put some code lines here!

Now take this and paste it into PlayerController.cs:

Don’t worry, the code is perfectly explained on the github project’s repository. :)

plain text


using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum Direction
{
    up, down, left, right
}

public class PlayerController : MonoBehaviour
{

    public float Speed = 0f;
    public LayerMask TileCollision;

    Animator Anim;
    Vector3 TargetPosition;
    Direction Direction;
    bool isMoving;
    bool Slippery;


    bool GetCollision
    {
        get
        {
            RaycastHit2D rh;
            int Distance = 1;

            Vector2 dir = Vector2.zero;

            if (Direction == Direction.down)
                dir = Vector2.down;

            if (Direction == Direction.left)
                dir = Vector2.left;

            if (Direction == Direction.right)
                dir = Vector2.right;

            if (Direction == Direction.up)
                dir = Vector2.up;

            rh = Physics2D.Raycast(transform.position, dir, Distance, TileCollision);

            return rh.collider != null;
        }
    }


    private void Start()
    {
        Anim = GetComponent<Animator>();
        TargetPosition = new Vector2(transform.position.x, transform.position.y);
        Direction = Direction.down;
        isMoving = false;
        Slippery = false;

    }

    private void Update()
    {

        Vector2 AxisInput = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
        CheckAnimationController(AxisInput);


        if (AxisInput != Vector2.zero && TargetPosition == transform.position)
        {
            if (Mathf.Abs(AxisInput.x) > Mathf.Abs(AxisInput.y))
            {

                if (AxisInput.x > 0)
                {
                    Direction = Direction.right;

                    if (!GetCollision)
                    {
                        TargetPosition += Vector3.right;
                        isMoving = true;
                    }

                }
                else
                {
                    Direction = Direction.left;

                    if (!GetCollision)
                    {
                        TargetPosition += Vector3.left;
                        isMoving = true;
                    }

                }



            }
            else
            {
                if (AxisInput.y > 0)
                {
                    Direction = Direction.up;

                    if (!GetCollision)
                    {
                        TargetPosition += Vector3.up;
                        isMoving = true;
                    }

                }
                else
                {
                    Direction = Direction.down;

                    if (!GetCollision)
                    {
                        TargetPosition += Vector3.down;
                        isMoving = true;
                    }

                }
            }
        }

        transform.position = Vector3.MoveTowards(transform.position, TargetPosition, Speed * Time.deltaTime);

        isMoving = DidThePlayerCame(AxisInput); //Did the player Came?


    }

    bool DidThePlayerCame(Vector2 AxisInput)
    {
        if (transform.position == TargetPosition && (AxisInput.x == 0 && AxisInput.y == 0))
        {
            return false;
        }
        else
        {
            return true;
        }


    }

    void CheckAnimationController(Vector2 AxisInput)
    {
        if (Slippery)
        {
            //Slippery Movement
            Anim.SetFloat("Horizontal", AxisInput.x);
            Anim.SetFloat("Vertical", AxisInput.y);
            Anim.SetBool("isMoving", isMoving);
            Anim.SetBool("isSlippery", Slippery);

        }

        else
        {
            //Normal Movement
            Anim.SetFloat("Direction", (int)Direction + 0.1f);
            Anim.SetBool("isMoving", isMoving);
        }
    }
}

In the next part of the tutorial, we’ll make some walking animations for the player and also, implement melee attacks.

Meanwhile…

Next part of the tutorial: Creating a Grid Walking Style Character on Unity Engine (Part. 2)

Project on Github (PlayerController.cs explanation on readme.md): Go!

Creating a Grid Walking Style Character on Unity Engine (Part. 1)

Keep reading

Why I Built NuGet Lens to Visually Inspect .NET Solution Dependencies

How to Dockerize a Deno app 👀