Grid Based First Person Movement (Wizardry, EoB, CoH style) C# Script

Getting Started
1

I see this question asked lots, and I asked it myself when I was first starting to get my hands dirty in Unity. Now that I know a bit more than I did a month ago, I’ve finally created a workable solution and thought it’d share it in hopes that it helps someone else.

It’s probably sloppy, there are probably more efficient ways to code it, and it’s not very well commented but here it is in case you find it useful. Attach this script to your MainCamera.

using UnityEngine;
using System.Collections;

public class PlayerCamera : MonoBehaviour
{
    [Tooltip("The 'animation' loop for movement to reach your desired movement units. The defaults move 1 Unity unit. Adjust this to suit your level design.")]
    public float fMovementIncrement = 0.05f;
    [Tooltip("The 'animation' loop for movement to reach your desired movement units. The defaults move 1 Unity unit. Adjust this to suit your level design.")]
    public float iMovementInterval = 20;
    [Tooltip("Locked Y position of the camera, adjust to suit your level design.")]
    public float fYLockPosition = 0f;
    [Tooltip("Public only for debugging, these values are overridden at runtime.")]
    public bool bMoving = false;
    [Tooltip("Public only for debugging, these values are overridden at runtime.")]
    public bool bRotating = false;
    [Tooltip("fRotateIncrement * iRotateInterval must equal 90 for full grid movement. For faster rotating, lower the interval and raise the increment.")]
    public float fRotateIncrement = 4.5f;
    [Tooltip("fRotateIncrement * iRotateInterval must equal 90 for full grid movement. For faster rotating, lower the interval and raise the increment.")]
    public int iRotateInterval = 20;
    [Tooltip("The WaitForSeconds value returned for each return yeild of the Coroutines.")]
    public float fWaitForSecondsInterval = 0.01f;

    public enum Compass { N, S, E, W }
    Compass currentCompass = Compass.N;

    void Start()
    {
        bMoving = false;
        bRotating = false;
    }

    void Update()
    {

        if (!bRotating && !bMoving)
        {
            transform.position = new Vector3(Mathf.Round(transform.position.x), fYLockPosition, Mathf.Round(transform.position.z));
        }
        if (Input.GetKey(KeyCode.W))
        {
            if (!bRotating && !bMoving)
            {
                StartCoroutine(StepForward());
            }
        }
        if (Input.GetKey(KeyCode.S))
        {
            if (!bRotating && !bMoving)
            {
                StartCoroutine(StepBackward());
            }
        }
        if (Input.GetKey(KeyCode.Q))
        {
            if (!bRotating && !bMoving)
            {
                StartCoroutine(StepLeft());
            }
        }
        if (Input.GetKey(KeyCode.E))
        {
            if (!bRotating && !bMoving)
            {
                StartCoroutine(StepRight());
            }
        }
        if (Input.GetKey(KeyCode.D))
        {
            if (!bRotating && !bMoving)
            {
                StartCoroutine(RotateRight());
            }
        }

        if (Input.GetKey(KeyCode.A))
        {
            if (!bRotating && !bMoving)
            {
                StartCoroutine(RotateLeft());
            }
        }

    }

    IEnumerator StepForward()
    {
        Vector3 newpos;
        if (currentCompass == Compass.N)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, .05f);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.S)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, -fMovementIncrement);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.E)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.W)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(-fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }


    }

    IEnumerator StepBackward()
    {
        Vector3 newpos;
        if (currentCompass == Compass.N)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, -.05f);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.S)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, fMovementIncrement);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.E)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(-fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.W)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }

    }

    IEnumerator StepLeft()
    {
        Vector3 newpos;
        if (currentCompass == Compass.N)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(-fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.S)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.E)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, fMovementIncrement);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.W)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, -fMovementIncrement);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }

        var wait = new WaitForSeconds(0.1f);


    }

    IEnumerator StepRight()
    {
        Vector3 newpos;
        if (currentCompass == Compass.N)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.S)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(-fMovementIncrement, 0, 0);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.E)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, -fMovementIncrement);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }
        if (currentCompass == Compass.W)
        {
            bMoving = true;
            for (int g = 0; g < iMovementInterval; g++)
            {
                newpos = new Vector3(0, 0, fMovementIncrement);
                transform.position += newpos;
                yield return new WaitForSeconds(fWaitForSecondsInterval);
            }
            yield return new WaitForSeconds(fWaitForSecondsInterval);
            bMoving = false;
        }

        var wait = new WaitForSeconds(0.1f);

    }

    IEnumerator RotateRight()
    {
        bRotating = true;

        for (int g = 0; g < iRotateInterval; g++)
        {
            transform.position = new Vector3(Mathf.Round(transform.position.x), fYLockPosition, Mathf.Round(transform.position.z));
            transform.eulerAngles += new Vector3(0, fRotateIncrement, 0);
            yield return new WaitForSeconds(fWaitForSecondsInterval);
        }

        switch (currentCompass)
        {
            case (Compass.W):
                currentCompass = Compass.N;
                Debug.Log("Compass is now N");
                //text.text ="N";
                break;
            case (Compass.E):
                currentCompass = Compass.S;
                Debug.Log("Compass is now S");
                //text.text ="S";
                break;
            case (Compass.S):
                currentCompass = Compass.W;
                Debug.Log("Compass is now W");
                //text.text ="W";
                break;
            case (Compass.N):
                currentCompass = Compass.E;
                Debug.Log("Compass is now E");
                //text.text ="E";
                break;
        }
        yield return new WaitForSeconds(fWaitForSecondsInterval);
        bRotating = false;

        var wait = new WaitForSeconds(fWaitForSecondsInterval);


    }

    IEnumerator RotateLeft()
    {
        bRotating = true;
        for (int g = 0; g < iRotateInterval; g++)
        {
            transform.position = new Vector3(Mathf.Round(transform.position.x), fYLockPosition, Mathf.Round(transform.position.z));
            transform.eulerAngles += new Vector3(0, -fRotateIncrement, 0);
            yield return new WaitForSeconds(fWaitForSecondsInterval);
        }

        switch (currentCompass)
        {
            case (Compass.W):
                currentCompass = Compass.S;
                break;
            case (Compass.E):
                currentCompass = Compass.N;
                break;
            case (Compass.S):
                currentCompass = Compass.E;
                break;
            case (Compass.N):
                currentCompass = Compass.W;
                break;
        }
        yield return new WaitForSeconds(fWaitForSecondsInterval);
        bRotating = false;

        var wait = new WaitForSeconds(fWaitForSecondsInterval);

    }
}
3 Likes
2

Thank you so much for this! How would you go about creating the tile map/level?

3

Here’s how I did it. It’s sloppy, old, uncommented and poorly formatted, and probably not very efficient. I think the concept itself is sound, however.

Basically, you first create your models (walls, floors, misc) that you want in the level in your 3D modeling package. I use Blender. Make sure that the ORIGIN of your object is where you want the position to be when it’s instantiated in Unity. Basically, you want the center of your object to be at the coordinates to be “drawn” when the map is loaded. For whatever reason, that was the center of the object in my project:

1070×696 74.7 KB

Create a folder named Resources in your project. This is where you will place all of the “tiles”. First Import your 3D model, then place into scene to make sure everything is textured and oriented correctly. Once that’s done, drag your GameObject into the Resources folder.
952×750 107 KB

You can repeat this for whatever object you want to place in your map.

I used XML for the actual map, so that I could easily make changes directly within the editor. I created a Script with a public string to hold the XML so I could modify it in the inspector.

Here’s an example map XML for the code:

<data>
   <map id="1" atlassize="8" posscale="2" rows="10" columns="20" layers="3" playerstartx="10" playerstarty="10" playerstartrot="180">
      <atlas aid="1" src="grassfloor1" yoffset="0" />
      <atlas aid="2" src="hedgecolumn1" yoffset="0" />
      <atlas aid="3" src="treeanimated1" yoffset="0" />
      <atlas aid="4" src="grassbillboard1" yoffset="-1" />
      <atlas aid="5" src="grassbillboard2" yoffset="-1" />
      <atlas aid="6" src="lamppost1" yoffset="0" />
      <atlas aid="7" src="rock1" yoffset="0" />
      <atlas aid="8" src="torchlamp1" yoffset="-1" />
      <layer posy="0" posscaley="1">
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
      </layer>
      <layer posy="1" posscaley="1">
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2, 
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,</layer>
      <layer posy="1" posscaley="1">
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0, 
0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0, 
0,0,0,0,3,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0, 
0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0, 
0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,0, 
0,0,0,0,0,8,4,0,0,6,0,0,0,0,0,0,0,0,0,0, 
0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0, 
0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0, 
0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
</layer>
   </map>
</data>

And here’s the C# script for parsing it, instantiating the objects:

using UnityEngine;
using System.Collections;
using System.Collections.Generic; //Needed for Lists
using System.Xml;
using System.IO;
using System.Text;

public class MapLoader : MonoBehaviour {
    [SerializeField]
    public string mapString;
    [SerializeField]
    public Transform levelObject;


    void Start () {
        StartCoroutine(LoadMap());
    }

    void Update () {
   
    }

    IEnumerator CreatePrefab(string name, Vector3 position)
    {
            GameObject goSearch = GameObject.Find(name);
            if (goSearch == null)
            {
                goSearch = new GameObject(name);
                goSearch.transform.parent = levelObject;
            }
            GameObject go = (GameObject)Instantiate(Resources.Load(name));
            go.transform.SetParent(goSearch.transform);
            go.transform.position = new Vector3(position.x, position.z, position.y);
            yield return new WaitForSeconds(0f);
    }

    IEnumerator LoadMap() //XML reader for loading map objects
    {
        int ID = 0;
        int Rows = 0;
        int Columns = 0;
        int Layers = 0;
        int posScale = 0;
        int posScaleY = 0;
        int atlasSize = 0;
        Dictionary<int, string> tileAtlas = new Dictionary<int, string>();
        Dictionary<int, int> tileAtlasYOffset = new Dictionary<int, int>();
        using (XmlReader reader = XmlReader.Create(new StringReader(mapString)))
        {
            reader.ReadToFollowing("map");
            ID = System.Int32.Parse(reader.GetAttribute("id"));
            atlasSize = System.Int32.Parse(reader.GetAttribute("atlassize"));
            posScale = System.Int32.Parse(reader.GetAttribute("posscale"));
            Rows = System.Int32.Parse(reader.GetAttribute("rows"));
            Columns = System.Int32.Parse(reader.GetAttribute("columns"));
            Layers = System.Int32.Parse(reader.GetAttribute("layers"));
            for (int atlasentry = 1; atlasentry <= atlasSize; atlasentry++)
            {
                try
                {
                    reader.ReadToFollowing("atlas");
                    tileAtlas.Add(atlasentry, reader.GetAttribute("src"));
                    tileAtlasYOffset.Add(atlasentry, System.Int32.Parse(reader.GetAttribute("yoffset")));
                }
                catch { }
            }
            for (int layer = 0; layer <= Layers; layer++)
            {
                reader.ReadToFollowing("layer");
                posScaleY = System.Int32.Parse(reader.GetAttribute("posscaley"));
                int posy = System.Int32.Parse(reader.GetAttribute("posy"));
                Debug.Log(posScaleY.ToString() + '-' + posy.ToString());
                int row = 0;
                    int column = 0;
                    foreach (string x in reader.ReadInnerXml().ToString().Replace("\t", "").Replace(" ", "").Split(','))
                    {
                    if (column == Columns)
                    { column = 0; row += 1; }
                    try
                    {
                        if (x != "0" && x != null)
                        {
                            string src = "No Prefab Found";
                            int yoffset = 0;
                            tileAtlas.TryGetValue(System.Int32.Parse(x), out src);
                            tileAtlasYOffset.TryGetValue(System.Int32.Parse(x), out yoffset);
                            StartCoroutine(CreatePrefab(src, new Vector3(row * posScale, column * posScale, (posy * posScaleY) + yoffset)));
                        }
                    }
                    catch { }
                        column++;
                    }
                    yield return new WaitForSeconds(0f);
            }
           
            }
    }
}
4

I used this script to do a very simple 3D maze. It worked great, thanks!

5

Now, being really new to this (doing this 3D maze was my personal challenge right after the basic tutorials), I can’t say I can follow your script in every detail.
That said, I wondered if I could make the player stop in my grid-based world when hitting a solid block or a wall. Further down the line, I’d even like the player to fall down to the floor below when moving beyond the edge of the floor.
To do this, I first tried to simply add a rigidbody with gravity on to my playercamera object (my level objects having physics, too). This led to some glitches and did not work at all.
Then I tried to attach the camera as a child really close to an invisible cube, instead (small enough to be able to turn without scraping the walls). This worked to stop the player from moving through objects, and your script nicely re-centered the player after the collision. Moving over an edge, though, proved …interesting, tumbling my camera along with the player cube in completely absurd ways.
I’m aware that I’m in over my head here, but I also think this is an excellent learning opportunity. Still, I seem a bit stuck: aside from my approach certainly being horribly messy and inefficient, why is my cube not dropping properly? Any help would be appreciated greatly.

6

Thank you, you’re amazing! I use it to my Turn-based game like shin megami tensei, it helps a lot.

7

You’re doing work of Gods Senpai!