# How to detect collision of a wall with grid movement?

Hi everybody

I have this little game, where my player is moving around a simple level, using a grid based movement script (See code below). My problem is that I have tried to implement a 2D raycast, which has to detect if the next ‘tile’ is a movable tile (not a wall). However all the examples I have found on the internet hasn’t been something I could make work. So please help me with how I can detect if the player is allowed to move, before he moves.

``````using System.Collections;
using UnityEngine;

public class GridMove : MonoBehaviour {
public float moveSpeed = 2f;

private float gridSize = 1f;
private enum Orientation {
Horizontal,
Vertical
};
private Orientation gridOrientation = Orientation.Vertical;
private bool allowDiagonals = false;
private bool correctDiagonalSpeed = true;
private Vector2 input;
private bool isMoving = false;
private Vector3 startPosition;
private Vector3 endPosition;
private float t;
private float factor;
private Animator animator;

// Use this for initialization
void Start () {
animator = GetComponent<Animator>();
}

public void Update() {
if (!isMoving) {
input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
if (!allowDiagonals) {
if (Mathf.Abs(input.x) > Mathf.Abs(input.y)) {
input.y = 0;
} else {
input.x = 0;
}
}

if (input != Vector2.zero) {
StartCoroutine(Move(transform));
animator.SetBool("isWalking", true);
}
else {
animator.SetBool("isWalking", false);
}
}
}

public IEnumerator Move(Transform transform) {
isMoving = true;
startPosition = transform.position;
t = 0;

animator.SetFloat("x", input.x);
animator.SetFloat("y", input.y);

if(gridOrientation == Orientation.Horizontal) {
endPosition = new Vector3(startPosition.x + System.Math.Sign(input.x) * gridSize,
startPosition.y, startPosition.z + System.Math.Sign(input.y) * gridSize);
} else {
endPosition = new Vector3(startPosition.x + System.Math.Sign(input.x) * gridSize,
startPosition.y + System.Math.Sign(input.y) * gridSize, startPosition.z);
}

if(allowDiagonals && correctDiagonalSpeed && input.x != 0 && input.y != 0) {
factor = 0.7071f;
} else {
factor = 1f;
}

while (t < 1f) {
t += Time.deltaTime * (moveSpeed/gridSize) * factor;
transform.position = Vector3.Lerp(startPosition, endPosition, t);
yield return null;
}

isMoving = false;
yield return 0;
}
}
``````

If you’re using a grid, you don’t even need to use the physics engine for this. In fact, you can get a huge performance boost by not doing this.

Let’s say we represent your grid’s movable areas with a 2d boolean array, where false values mean you cannot move. The array is arranged as x, y. Consider the following:

``````XXXXX
X00PX
X000X
X000X
XXXXX
``````

X is a wall, 0 is movable space, and P is the player. Let’s represent this in a a boolean array where tiles[0,0] is the top left, and tiles[4,4] is the bottom right.

Now all you need is a method like this:

``````bool TileIsPassable(int x, int y) {
return tiles[x, y];
}
``````

Then all you need to do is transform your coordinates into the x, y coordinates of the grid. If your grid squares are unit squares (1 meter each), then you can use the direct values from a Vector2 (or even a Vector3):

``````bool canPass = TileIsPassable(Vector2.x, Vector2.y);
``````