janis/industrialize-unity
1
0
Fork 0
mirror of https://github.com/DerTyp7/industrialize-unity.git synced 2025-10-31 05:17:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

new init

Browse Source
This commit is contained in:
Janis
2022-05-29 16:10:42 +02:00
parent cc60b43815
commit 108ce12ef2
113 changed files with 927 additions and 13477 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
Assets/Scripts/Pathfinding/Pathfinding.cs
View File

@@ -1,55 +1,65 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Pathfinding {
public class Pathfinding
{
private const int MOVE_STRAIGHT_COST = 10;
private const int MOVE_DIAGONAL_COST = 14;
public static Pathfinding Instance { get; private set; }
public static Pathfinding instance { get; private set; }
private Grid<PathNode> grid;
private List<PathNode> openList;
private List<PathNode> closedList;
public Pathfinding(int width, int height, float cellSize) {
Instance = this;
public Pathfinding(int width, int height, float cellSize)
{
instance = this;
grid = new Grid<PathNode>(width, height, cellSize, Vector3.zero, (Grid<PathNode> g, int x, int y) => new PathNode(g, x, y));
foreach (PathNode node in grid.gridArray) {
foreach (PathNode node in grid.gridArray)
{
node.neighbourList = GetNeighbourList(node);
}
}
public Grid<PathNode> GetGrid() {
public Grid<PathNode> GetGrid()
{
return grid;
}
public List<Vector3> FindPath(Vector3 startWorldPosition, Vector3 endWorldPosition, bool ignoreIsWalkable = false) {
public List<Vector3> FindPath(Vector3 startWorldPosition, Vector3 endWorldPosition, bool ignoreIsWalkable = false)
{
grid.GetXY(startWorldPosition, out int startX, out int startY);
grid.GetXY(endWorldPosition, out int endX, out int endY);
List<PathNode> path = FindPath(startX, startY, endX, endY, ignoreIsWalkable);
if (path == null) {
if (path == null)
{
return null;
} else {
}
else
{
List<Vector3> vectorPath = new List<Vector3>();
foreach (PathNode pathNode in path) {
foreach (PathNode pathNode in path)
{
vectorPath.Add(new Vector3(pathNode.x, pathNode.y) * grid.GetCellSize() + Vector3.one * grid.GetCellSize() * .5f);
}
return vectorPath;
}
}
public List<PathNode> FindPath(int startX, int startY, int endX, int endY, bool ignoreIsWalkable = false) {
public List<PathNode> FindPath(int startX, int startY, int endX, int endY, bool ignoreIsWalkable = false)
{
var timer = new System.Diagnostics.Stopwatch();
timer.Start();
PathNode startNode = grid.GetGridObject(startX, startY);
PathNode endNode = grid.GetGridObject(endX, endY);
if (startNode == null || endNode == null) {
if (startNode == null || endNode == null)
{
// Invalid Path
return null;
}
@@ -57,8 +67,10 @@ public class Pathfinding {
openList = new List<PathNode> { startNode };
closedList = new List<PathNode>();
for (int x = 0; x < grid.GetWidth(); x++) {
for (int y = 0; y < grid.GetHeight(); y++) {
for (int x = 0; x < grid.GetWidth(); x++)
{
for (int y = 0; y < grid.GetHeight(); y++)
{
PathNode pathNode = grid.GetGridObject(x, y);
pathNode.gCost = 99999999;
pathNode.CalculateFCost();
@@ -70,9 +82,11 @@ public class Pathfinding {
startNode.hCost = CalculateDistanceCost(startNode, endNode);
startNode.CalculateFCost();
while (openList.Count > 0) {
while (openList.Count > 0)
{
PathNode currentNode = GetLowestFCostNode(openList);
if (currentNode == endNode) {
if (currentNode == endNode)
{
// Reached final node
timer.Stop();
TimeSpan timeTaken = timer.Elapsed;
@@ -83,21 +97,25 @@ public class Pathfinding {
openList.Remove(currentNode);
closedList.Add(currentNode);
foreach (PathNode neighbourNode in currentNode.neighbourList) {
foreach (PathNode neighbourNode in currentNode.neighbourList)
{
if (closedList.Contains(neighbourNode)) continue;
if (!neighbourNode.isWalkable && !ignoreIsWalkable) { // If neighbouring node is not walkable instantly add them to closed
if (!neighbourNode.isWalkable && !ignoreIsWalkable)
{ // If neighbouring node is not walkable instantly add them to closed
closedList.Add(neighbourNode);
continue;
}
int tentativeGCost = currentNode.gCost + CalculateDistanceCost(currentNode, neighbourNode);
if (tentativeGCost < neighbourNode.gCost) {
if (tentativeGCost < neighbourNode.gCost)
{
neighbourNode.cameFromNode = currentNode;
neighbourNode.gCost = tentativeGCost;
neighbourNode.hCost = CalculateDistanceCost(neighbourNode, endNode);
neighbourNode.CalculateFCost();
if (!openList.Contains(neighbourNode)) {
if (!openList.Contains(neighbourNode))
{
openList.Add(neighbourNode);
}
}
@@ -108,24 +126,27 @@ public class Pathfinding {
return null;
}
private List<PathNode> GetNeighbourList(PathNode currentNode) {
private List<PathNode> GetNeighbourList(PathNode currentNode)
{
List<PathNode> neighbourList = new List<PathNode>();
if (currentNode.x - 1 >= 0) {
if (currentNode.x - 1 >= 0)
{
// Left
neighbourList.Add(GetNode(currentNode.x - 1, currentNode.y));
// Left Down
// if (currentNode.y - 1 >= 0) neighbourList.Add(GetNode(currentNode.x - 1, currentNode.y - 1));
// if (currentNode.y - 1 >= 0) neighbourList.Add(GetNode(currentNode.x - 1, currentNode.y - 1));
// Left Up
// if (currentNode.y + 1 < grid.GetHeight()) neighbourList.Add(GetNode(currentNode.x - 1, currentNode.y + 1));
// if (currentNode.y + 1 < grid.GetHeight()) neighbourList.Add(GetNode(currentNode.x - 1, currentNode.y + 1));
}
if (currentNode.x + 1 < grid.GetWidth()) {
if (currentNode.x + 1 < grid.GetWidth())
{
// Right
neighbourList.Add(GetNode(currentNode.x + 1, currentNode.y));
// Right Down
// if (currentNode.y - 1 >= 0) neighbourList.Add(GetNode(currentNode.x + 1, currentNode.y - 1));
// if (currentNode.y - 1 >= 0) neighbourList.Add(GetNode(currentNode.x + 1, currentNode.y - 1));
// Right Up
// if (currentNode.y + 1 < grid.GetHeight()) neighbourList.Add(GetNode(currentNode.x + 1, currentNode.y + 1));
// if (currentNode.y + 1 < grid.GetHeight()) neighbourList.Add(GetNode(currentNode.x + 1, currentNode.y + 1));
}
// Down
if (currentNode.y - 1 >= 0) neighbourList.Add(GetNode(currentNode.x, currentNode.y - 1));
@@ -135,15 +156,18 @@ public class Pathfinding {
return neighbourList;
}
public PathNode GetNode(int x, int y) {
public PathNode GetNode(int x, int y)
{
return grid.GetGridObject(x, y);
}
private List<PathNode> CalculatePath(PathNode endNode) {
private List<PathNode> CalculatePath(PathNode endNode)
{
List<PathNode> path = new List<PathNode>();
path.Add(endNode);
PathNode currentNode = endNode;
while (currentNode.cameFromNode != null) {
while (currentNode.cameFromNode != null)
{
path.Add(currentNode.cameFromNode);
currentNode = currentNode.cameFromNode;
}
@@ -151,17 +175,21 @@ public class Pathfinding {
return path;
}
private int CalculateDistanceCost(PathNode a, PathNode b) {
private int CalculateDistanceCost(PathNode a, PathNode b)
{
int xDistance = Mathf.Abs(a.x - b.x);
int yDistance = Mathf.Abs(a.y - b.y);
int remaining = Mathf.Abs(xDistance - yDistance);
return MOVE_DIAGONAL_COST * Mathf.Min(xDistance, yDistance) + MOVE_STRAIGHT_COST * remaining;
}
private PathNode GetLowestFCostNode(List<PathNode> pathNodeList) {
private PathNode GetLowestFCostNode(List<PathNode> pathNodeList)
{
PathNode lowestFCostNode = pathNodeList[0];
for (int i = 1; i < pathNodeList.Count; i++) {
if (pathNodeList[i].fCost < lowestFCostNode.fCost) {
for (int i = 1; i < pathNodeList.Count; i++)
{
if (pathNodeList[i].fCost < lowestFCostNode.fCost)
{
lowestFCostNode = pathNodeList[i];
}
}