naive implementation

Author: longda

.gitignore

@@ -0,0 +1,30 @@
+/[Ll]ibrary/
+/[Tt]emp/
+/[Oo]bj/
+/[Bb]uild/
+/[Bb]uilds/
+/Assets/AssetStoreTools*
+
+# Autogenerated VS/MD solution and project files
+ExportedObj/
+*.csproj
+*.unityproj
+*.sln
+*.suo
+*.tmp
+*.user
+*.userprefs
+*.pidb
+*.booproj
+*.svd
+
+
+# Unity3D generated meta files
+*.pidb.meta
+
+# Unity3D Generated File On Crash Reports
+sysinfo.txt
+
+# Builds
+*.apk
+*.unitypackage

Assets/Materials.meta

@@ -0,0 +1,103 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+public class Grid : MonoBehaviour
+{
+	public Transform player;
+	public LayerMask unwalkableMask;
+	public Vector2 gridWorldSize;
+	public float nodeRadius;
+	Node[,] grid;
+
+	float nodeDiameter;
+	int gridSizeX, gridSizeY;
+
+	void Start()
+	{
+		nodeDiameter = nodeRadius * 2;
+		gridSizeX = Mathf.RoundToInt(gridWorldSize.x / nodeDiameter);
+		gridSizeY = Mathf.RoundToInt(gridWorldSize.y / nodeDiameter);
+		CreateGrid();
+	}
+
+	void CreateGrid()
+	{
+		grid = new Node[gridSizeX, gridSizeY];
+		Vector3 worldBottomLeft = transform.position - Vector3.right * gridWorldSize.x / 2 - Vector3.forward * gridWorldSize.y / 2;
+
+		for (var x = 0; x < gridSizeX; x++)
+		{
+			for (var y = 0; y < gridSizeY; y++)
+			{
+				Vector3 worldPoint = worldBottomLeft + Vector3.right * (x * nodeDiameter + nodeRadius) + Vector3.forward * (y * nodeDiameter + nodeRadius);
+				bool walkable = !(Physics.CheckSphere(worldPoint, nodeRadius, unwalkableMask));
+				grid[x, y] = new Node(walkable, worldPoint, x, y);
+			}
+		}
+	}
+
+	public List<Node> GetNeighbors(Node node)
+	{
+		List<Node> neighbors = new List<Node>();
+
+		for (var x = -1; x <= 1; x++)
+		{
+			for (var y = -1; y <= 1; y++)
+			{
+					if (x == 0 && y == 0) continue;
+
+					int checkX = node.gridX + x;
+					int checkY = node.gridY + y;
+
+					if (checkX >= 0 && checkX < gridSizeX && checkY >= 0 && checkY < gridSizeY)
+					{
+						neighbors.Add(grid[checkX, checkY]);
+					}
+			}
+		}
+
+		return neighbors;
+	}
+
+	public Node NodeFromWorldPoint(Vector3 worldPosition)
+	{
+		float percentX = (worldPosition.x + gridWorldSize.x / 2) / gridWorldSize.x;
+		float percentY = (worldPosition.z + gridWorldSize.y / 2) / gridWorldSize.y;
+		percentX = Mathf.Clamp01(percentX);
+		percentY = Mathf.Clamp01(percentY);
+
+		int x = Mathf.RoundToInt((gridSizeX - 1) * percentX);
+		int y = Mathf.RoundToInt((gridSizeY - 1) * percentY);
+
+		return grid[x, y];
+	}
+
+	public List<Node> path;
+	void OnDrawGizmos()
+	{
+		Gizmos.DrawWireCube(transform.position, new Vector3(gridWorldSize.x, 1, gridWorldSize.y));
+
+		if (grid != null)
+		{
+			Node playerNode = NodeFromWorldPoint(player.position);
+
+			foreach (Node n in grid)
+			{
+				Gizmos.color = n.walkable ? Color.white : Color.red;
+
+				if (path != null && path.Contains(n))
+				{
+					Gizmos.color = Color.black;
+				}
+
+				if (playerNode == n)
+				{
+					Gizmos.color = Color.cyan;
+				}
+
+				Gizmos.DrawCube(n.worldPosition, Vector3.one * (nodeDiameter - 0.1f));
+			}
+		}
+	}
+}

Assets/Materials/Ground.mat

@@ -0,0 +1,24 @@
+using UnityEngine;
+using System.Collections;
+
+public class Node
+{
+	public bool walkable;
+	public Vector3 worldPosition;
+	public int gridX;
+	public int gridY;
+
+	public int gCost;
+	public int hCost;
+	public Node parent;
+
+	public Node(bool walkable, Vector3 worldPos, int gridX, int gridY)
+	{
+		this.walkable = walkable;
+		worldPosition = worldPos;
+		this.gridX = gridX;
+		this.gridY = gridY;
+	}
+
+	public int fCost { get { return gCost + hCost; } }
+}

Assets/Materials/Ground.mat.meta

@@ -0,0 +1,95 @@
+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+
+public class Pathfinding : MonoBehaviour
+{
+	public Transform seeker, target;
+
+	Grid grid;
+
+	void Awake()
+	{
+		grid = GetComponent<Grid>();
+	}
+
+	void Update()
+	{
+		FindPath(seeker.position, target.position);
+	}
+
+	void FindPath(Vector3 startPos, Vector3 targetPos)
+	{
+		Node startNode = grid.NodeFromWorldPoint(startPos);
+		Node targetNode = grid.NodeFromWorldPoint(targetPos);
+		List<Node> openSet = new List<Node>();
+		HashSet<Node> closedSet = new HashSet<Node>();
+		openSet.Add(startNode);
+
+		while (openSet.Count > 0)
+		{
+			Node currentNode = openSet[0];
+
+			for (var i = 1; i < openSet.Count; i++)
+			{
+				if (openSet[i].fCost < currentNode.fCost || openSet[i].fCost == currentNode.fCost && openSet[i].hCost < currentNode.hCost)
+				{
+					currentNode = openSet[i];
+				}
+			}
+
+			openSet.Remove(currentNode);
+			closedSet.Add(currentNode);
+
+			if (currentNode == targetNode)
+			{
+				RetracePath(startNode, targetNode);
+				return;
+			}
+
+			foreach (Node neighbor in grid.GetNeighbors(currentNode))
+			{
+				if (!neighbor.walkable || closedSet.Contains(neighbor)) continue;
+
+				int newMovementCostToNeighbor = currentNode.gCost + GetDistance(currentNode, neighbor);
+
+				if (newMovementCostToNeighbor < neighbor.gCost || !openSet.Contains(neighbor))
+				{
+					neighbor.gCost = newMovementCostToNeighbor;
+					neighbor.hCost = GetDistance(neighbor, targetNode);
+					neighbor.parent = currentNode;
+
+					if (!openSet.Contains(neighbor))
+					{
+						openSet.Add(neighbor);
+					}
+				}
+			}
+		}
+	}
+
+	void RetracePath(Node startNode, Node endNode)
+	{
+		List<Node> path = new List<Node>();
+		Node currentNode = endNode;
+
+		while (currentNode != startNode)
+		{
+			path.Add(currentNode);
+			currentNode = currentNode.parent;
+		}
+
+		path.Reverse();
+
+		grid.path = path;
+	}
+
+	// equation details: ep3 @ 14.00
+	int GetDistance(Node nodeA, Node nodeB)
+	{
+		int distX = Mathf.Abs(nodeA.gridX - nodeB.gridX);
+		int distY = Mathf.Abs(nodeA.gridY - nodeB.gridY);
+
+		return distX > distY ? 14 * distY + 10 * (distX - distY) : 14 * distX + 10 * (distY - distX);
+	}
+}

Assets/Materials/Obstacle.mat

@@ -0,0 +1,2 @@
+m_EditorVersion: 5.4.2f2-GVR11
+m_StandardAssetsVersion: 0