// My personal checks for pathfinding private bool PathFindingChecks(CubeLocationScript neightbourScript, Vector3 neighbourHalfVect) { CubeLocationScript neightbourHalfScript = _locationManager.GetLocationScript(neighbourHalfVect); if (neightbourHalfScript != null) { // if (neightbourScript._isPanel) { // this might cause problems // return false; // } if (neightbourHalfScript._isPanel) { return(false); } if (neightbourScript._cubeOccupied) { return(false); } if (!_unitCanClimbWalls) // if human { if (!neightbourScript._isHumanWalkable && !neightbourScript._isHumanClimbable && !neightbourScript._isHumanJumpable) { return(false); } } ////////// return(true); } return(false); }
public void SetCubeNeighbours(CubeLocationScript cubeScript) { if (!isServer) { Debug.LogError("Got a client trying to do server stuff here!"); } if (cubeScript == null) { Debug.LogError("cubeScript == null! not sure what this means just yet"); } else { // If any of the half neighbours are panels, then this cubeScript location can be set to walkable/climable...etc foreach (Vector3 vect in cubeScript.NeighbourHalfVects) { CubeLocationScript neighbourScript = _locationManager.GetLocationScript(vect); // setup Panels in cubes if (neighbourScript != null && neighbourScript._isPanel) { // Debug.Log("f**k we HAVE A PANEL in half neighbour"); SetUpPanelInCube(neighbourScript); break; } } } }
//////////////////////////////////////////////// //////////////////////////////////////////////// public GameObject CreateDefaultCube(Vector3Int localGridLoc, Transform parent) { GameObject cubeObject = Instantiate(GetNodePrefab(NodeTypes.CubeObject), parent, false); // empty cube cubeObject.transform.SetParent(parent); cubeObject.transform.localPosition = localGridLoc; CubeLocationScript cubeScript = cubeObject.GetComponent <CubeLocationScript>(); cubeScript.CubeMoveable = false; if (Mathf.Abs(localGridLoc.y) % 2 == 0) // I fucken HATE THIS Has caused lots of issues { if (Mathf.Abs(localGridLoc.z) % 2 == 0) { if (Mathf.Abs(localGridLoc.x) % 2 == 0) { cubeScript.CubeMoveable = true; } } } Vector3 cubeGlobalPos = cubeObject.transform.position; Vector3Int globalGridLoc = new Vector3Int(Mathf.FloorToInt(cubeGlobalPos.x), Mathf.FloorToInt(cubeGlobalPos.y), Mathf.FloorToInt(cubeGlobalPos.z)); cubeScript.CubeID = globalGridLoc; cubeScript.MapNodeParent = parent.GetComponent <MapNode>(); cubeScript.CubeLayerID = parent.GetComponent <MapNode>().NodeLayerCount; return(cubeObject); }
// this is a bit different, the actual MOVEABLE cube script gets passed in here coz slopes sit in the cube object not the half cube objects // THIS IS GOING TO CAUSE PROBLEMS IN FUTURE COZ THERES NO CHECKS IF THEY CAN MOVE ONTO SLOPE, ITS ALWAYS YES private static void SetUpCeilingAnglePanel(CubeLocationScript cubeScript, PanelPieceScript panelScript) { Vector3 cubeLoc = cubeScript.CubeStaticLocVector; Vector3 TopHalfVect = new Vector3(cubeLoc.x, cubeLoc.y + 1, cubeLoc.z); Vector3 bottomHalfVect = new Vector3(cubeLoc.x, cubeLoc.y - 1, cubeLoc.z); CubeLocationScript cubeScriptHalfTop = LocationManager.GetHalfLocationScript_CLIENT(TopHalfVect); // ontop panel CubeLocationScript cubeScriptHalfBottom = LocationManager.GetHalfLocationScript_CLIENT(bottomHalfVect); // underneath panel if (cubeScriptHalfBottom != null) // ontop { panelScript.cubeScriptRight = cubeScript; panelScript.cubeRightVector = cubeLoc; panelScript.rightPosNode = new Vector3(0, 4.5f, 0); // future issue here if want to move unit bit further on x,z axis on slope SetHumanCubeRules(cubeScript, true, true, true); SetAlienCubeRules(cubeScript, true, true, true); } if (cubeScriptHalfTop != null) // underneath { panelScript.cubeScriptLeft = cubeScript; panelScript.cubeLeftVector = cubeLoc; panelScript.leftPosNode = new Vector3(0, -4.5f, 0); // future issue here if want to move unit bit further on x,z axis on slope SetHumanCubeRules(cubeScript, true, true, true); SetAlienCubeRules(cubeScript, true, true, true); } }
public void MoveUnit(List <CubeLocationScript> _pathNodes) { Debug.Log("MoveUnit!"); int[] stats = GetComponent <UnitScript>()._unitCombatStats; _unitsSpeed = stats[0]; if (_pathNodes.Count > 0) { _finalTarget = _pathNodes[_pathNodes.Count - 1]; _finalTargetVect = _finalTarget.CubeLocVector; if (moveInProgress) { _tempNodes = _pathNodes; _newPath = true; } else { Reset(); _nodes = _pathNodes; moveInProgress = true; SetTarget(); } } }
//////////////////////////////////////////////// public void MoveUnit(List <Vector3Int> path) { AnimationManager.SetAnimatorBool(_animators, "Combat_Walk", true); _unitsSpeed = gameObject.transform.GetComponent <UnitScript>().UnitCombatStats[1]; // movement _finalTargetLoc = path[path.Count - 1]; _finalTargetScript = LocationManager.GetLocationScript_CLIENT(_finalTargetLoc); if (path.Count > 0) { if (moveInProgress) { foreach (Vector3Int nodeVect in _nodes) { LocationManager.GetLocationScript_CLIENT(nodeVect)._platform_Panel_Cube._panelScriptChild.PanelIsDEActive(); } _newPathNodes = path; _newPathSet = true; } else { ResetValues(); _nodes = path; moveInProgress = true; foreach (Vector3Int nodeVect in _nodes) { LocationManager.GetLocationScript_CLIENT(nodeVect)._platform_Panel_Cube._panelScriptChild.PanelIsActive(); } SetNextTarget(); } } }
private void SetTarget() { if (_unitInterrupted) { _gameManager._playerManager._playerObject.GetComponent <UnitsAgent>().MakeUnitRecalculateMove(GetComponent <UnitScript>(), _finalTargetVect); _unitInterrupted = false; } if (_nodes.Count > 0) { if (!_newPath) { _currTarget = _nodes[locCount]; _currTargetVect = new Vector3(_currTarget.CubeLocVector.x, _currTarget.CubeLocVector.y, _currTarget.CubeLocVector.z); if (!_gameManager._locationManager.SetUnitOnCube(GetComponent <UnitScript>(), _currTargetVect)) { Debug.LogWarning("units movement interrupted >> recalculating"); _unitInterrupted = true; Reset(); StartCoroutine(RecalculateMove(3.0f)); } } else { SetNewpath(); } } }
////////////////////////////////////////////// private bool DetermineIfPanelIsLowerThanUnit() // Compares cube local locations { if (UnitsManager.ActiveUnit == null) { return(false); } CubeLocationScript unitCube = UnitsManager.ActiveUnit.CubeUnitIsOn; //Debug.Log("f**k unitCube = " + unitCube); //Debug.Log("f**k unitCube.MapNodeParent = " + unitCube.MapNodeParent); float unitMapNodeYLocPos = unitCube.MapNodeParent.transform.localPosition.y; float thisMapNodeYLocPos = cubeScriptParent.MapNodeParent.transform.localPosition.y; if (thisMapNodeYLocPos > unitMapNodeYLocPos) // Mapnodes above unit always turn transpaarent { return(false); } float unitCubeYLocPos = unitCube.transform.localPosition.y; float thisCubeYLocPos = cubeScriptParent.transform.localPosition.y; return(unitCubeYLocPos > thisCubeYLocPos); }
/////////////////////////////////////////// public static bool SetUnitOnCube_CLIENT(UnitScript unitScript, Vector3 loc) { int unitNetId = (int)unitScript.NetID.Value; CubeLocationScript cubescript = CheckIfCanMoveToCube_CLIENT(unitScript.CubeUnitIsOn, loc, unitScript.UnitCanClimbWalls); if (cubescript != null) { if (!_unitLocation.ContainsKey(unitNetId)) { _unitLocation.Add(unitNetId, cubescript); } else { CubeLocationScript oldCubescript = _unitLocation[unitNetId]; oldCubescript.CubeOccupied = false; _unitLocation[unitNetId] = cubescript; } cubescript.CubeOccupied = true; unitScript.CubeUnitIsOn = cubescript; Debug.Log("SetUnitOnCube loc: " + loc); return(true); } else { Debug.LogError("Unit cannot move to a location"); return(false); } }
/////////////////////////////////////////// public static bool SetUnitOnCube_CLIENT(UnitScript unitScript, Vector3Int loc) { Vector3Int unitId = unitScript.UnitID; CubeLocationScript cubescript = CheckIfCanMoveToCube_CLIENT(unitScript.CubeUnitIsOn, loc, unitScript.UnitCanClimbWalls); if (cubescript != null) { if (!_unitLocation.ContainsKey(unitId)) { _unitLocation.Add(unitId, cubescript); } else { CubeLocationScript oldCubescript = _unitLocation[unitId]; oldCubescript.CubeOccupied = false; _unitLocation[unitId] = cubescript; } cubescript.CubeOccupied = true; unitScript.CubeUnitIsOn = cubescript; //if (unitScript.CubeUnitIsOn != null && unitScript.CubeUnitIsOn._platform_Panel_Cube != null) //{ // cubescript._platform_Panel_Cube._panelScriptChild.PanelPieceChangeColor("Pink"); //} return(true); } else { Debug.LogError("Unit cannot move to a location " + loc); return(false); } }
private List <CubeLocationScript> RetracePath(int movement, CubeLocationScript startNode, CubeLocationScript endNode) { List <CubeLocationScript> path = new List <CubeLocationScript>(); CubeLocationScript currentNode = endNode; while (currentNode != startNode) { path.Add(currentNode); currentNode = currentNode.parentPathFinding; } path.Reverse(); List <CubeLocationScript> _finalPath = new List <CubeLocationScript>(); int pathLength = movement; if (movement > path.Count) { movement = path.Count; } for (int i = 0; i < movement; i++) { _finalPath.Add(path [i]); } foreach (CubeLocationScript script in _finalPath) { script.CreatePathFindingNode(); // puts circles in path, visual reference } return(_finalPath); }
//////////////////////////////////////////////// public static bool BuildMovementPath(CubeLocationScript endLocScript) { if (_currActiveCube == endLocScript) { return(true); } else { _currActiveCube = endLocScript; } UnitScript activeUnit = UnitsManager.ActiveUnit; if (activeUnit != null) { UnitsManager.ActiveUnit.ClearPathFindingNodes(); } _movePath = SetUnitsPath(endLocScript); if (_movePath != null) { CreatePathFindingNodes_CLIENT(UnitsManager.ActiveUnit, _movePath); return(true); } else { //_currActiveCube = null; return(false); } }
//////////////////////////////////////////////// // If ANY kind of wall/floor/object make neighbour cubes walkable public static void SetUpPanelInCube(CubeLocationScript neighbourHalfScript) { PanelPieceScript panelScript = neighbourHalfScript._panelScriptChild; switch (panelScript.name) { case "Floor": SetUpFloorPanel(neighbourHalfScript, panelScript); break; case "Wall": SetUpWallPanel(neighbourHalfScript, panelScript); break; case "FloorAngle": // angles put in half points SetUpFloorAnglePanel(neighbourHalfScript, panelScript); break; case "CeilingAngle": // This is the exact same as ceilingFloor SetUpCeilingAnglePanel(neighbourHalfScript, panelScript); break; default: Debug.Log("f**k no issue: " + panelScript.name); break; } }
private void SetUpFloorAnglePanel(CubeLocationScript cubeScript, PanelPieceScript panelScript) { Vector3 cubeLoc = cubeScript.CubeLocVector; //cubeScript._isPanel = false; // this might cause issues Vector3 centerVect = new Vector3(cubeLoc.x, cubeLoc.y, cubeLoc.z); panelScript.cubeScriptLeft = cubeScript; panelScript.cubeLeftVector = centerVect; panelScript.leftPosNode = new Vector3(0, 0, -4.5f); panelScript.cubeScriptRight = cubeScript; panelScript.cubeRightVector = centerVect; panelScript.rightPosNode = new Vector3(0, 0, 4.5f); //cubeScript._isHumanWalkable = true; // // 8 points for each panel // DoHalfPointsForWalls (new Vector3 (cubeLoc.x - 1, cubeLoc.y - 1, cubeLoc.z - 1)); // DoHalfPointsForWalls (new Vector3 (cubeLoc.x + 0, cubeLoc.y - 1, cubeLoc.z - 1)); // DoHalfPointsForWalls (new Vector3 (cubeLoc.x + 1, cubeLoc.y - 1, cubeLoc.z - 1)); // DoHalfPointsForWalls (new Vector3 (cubeLoc.x - 1, cubeLoc.y + 0, cubeLoc.z + 0)); // // middle // DoHalfPointsForWalls (new Vector3 (cubeLoc.x + 1, cubeLoc.y + 0, cubeLoc.z + 0)); // DoHalfPointsForWalls (new Vector3 (cubeLoc.x - 1, cubeLoc.y + 1, cubeLoc.z + 1)); // DoHalfPointsForWalls (new Vector3 (cubeLoc.x + 0, cubeLoc.y + 1, cubeLoc.z + 1)); // DoHalfPointsForWalls (new Vector3 (cubeLoc.x + 1, cubeLoc.y + 1, cubeLoc.z + 1)); }
public bool SetUnitOnCube(UnitScript unitScript, Vector3 loc) { if (!isServer) { Debug.LogError("Got a client trying to do server stuff here!"); } //Debug.Log("SetUnitOnCube"); int unitNetId = (int)unitScript.NetID.Value; CubeLocationScript cubescript = CheckIfCanMoveToCube(unitScript, unitScript.CubeUnitIsOn, loc); if (cubescript != null) { if (!_unitLocation.ContainsKey(unitNetId)) { _unitLocation.Add(unitNetId, cubescript); } else { CubeLocationScript oldCubescript = _unitLocation[unitNetId]; oldCubescript.CubeOccupied = false; oldCubescript.FlagToSayIsMine = null; _unitLocation[unitNetId] = cubescript; } cubescript.CubeOccupied = true; unitScript.CubeUnitIsOn = cubescript; return(true); } else { Debug.LogError("Unit cannot move to a location"); return(false); } }
public void ResetPathFindingValues() { _pathFindingNode = null; _parentPathFinding = null; fCost = 0; hCost = 0; gCost = 0; }
//////////////////////////////////////////////// //////////////////////////////////////////////// public static void CreatePanelForCube(int[] cubeData, CubeLocationScript cubeScript) { GameObject panelObject = WorldBuilder._nodeBuilder.CreatePanelObject(cubeScript); panelObject.GetComponent <ObjectScript>().objectStyle = (CubeObjectStyles)cubeData[1]; if (panelObject.GetComponent <Renderer>()) { ObjectTextures texEnum = (ObjectTextures)cubeData[2]; string matName = "MapTextures/Materials/" + texEnum.ToString(); Material mat = (Material)Resources.Load(matName, typeof(Material)); panelObject.GetComponent <Renderer>().material = mat; } PanelPieceScript panelScript = panelObject.GetComponent <PanelPieceScript>(); int rotX = cubeData[4]; int rotY = cubeData[5]; int rotZ = cubeData[6]; panelObject.GetComponent <ObjectScript>().forcedRotation = new Vector3Int(rotX, rotY, rotZ); panelObject.transform.localScale *= 200; if (cubeData[0] == (int)CubeObjectTypes.Panel_Floor) // Floor { panelObject.GetComponent <ObjectScript>().objectType = CubeObjectTypes.Panel_Floor; cubeScript.CubeIsSlope = false; panelScript._panelYAxis = 0; } else if (cubeData[0] == (int)CubeObjectTypes.Panel_Wall) // Floor { panelObject.GetComponent <ObjectScript>().objectType = CubeObjectTypes.Panel_Wall; cubeScript.CubeIsSlope = false; rotZ = 90; panelScript._panelYAxis = rotY; } else if (cubeData[0] == (int)CubeObjectTypes.Panel_Angle) // Floor { panelObject.GetComponent <ObjectScript>().objectType = CubeObjectTypes.Panel_Angle; cubeScript.CubeIsSlope = true; } else { Debug.LogError("GOT AN ISSUE HERE"); } //Debug.Log("f**k TEST >>>>>>>>>> rotX " + rotX + " + rotY " + rotY + " + rotZ " + rotZ); panelObject.transform.localRotation = Quaternion.Euler(new Vector3Int(rotX, rotY, rotZ)); // panelObject.transform.tag = panelName; // panelScript.name = panelName; }
//////////////////////////////////////////////// //////////////////////////////////////////////// //////////////////////////////////////////////// ////// SERVER FUNCTIONS //////////////////////// //////////////////////////////////////////////// //////////////////////////////////////////////// ////// CLIENT FUNCTIONS //////////////////////// //////////////////////////////////////////////// public static void SetCubeScriptToLocation_CLIENT(Vector3Int vect, CubeLocationScript script) { if (!_LocationLookup.ContainsKey(vect)) { _LocationLookup.Add(vect, script); return; } // Debug.LogError("trying to assign script to already taking location!!!"); // this now happens all the time because maps overlap eachother with new map system }
private void DoHalfPointsForWalls(Vector3 nodeVect) { CubeLocationScript nodeScript = _locationManager.GetLocationScript(nodeVect); if (nodeScript != null) { nodeScript._isPanel = true; nodeScript._isHumanWalkable = false; } }
public void SetUnitToNextLocation_CLIENT() { if (_pathNodeCount < _pathFindingNodes.Count) { Vector3 vect = _pathFindingNodes[_pathNodeCount].CubeStaticLocVector; CubeLocationScript script = LocationManager.GetLocationScript_CLIENT(vect); CubeUnitIsOn = script; } _pathNodeCount++; }
public static void SetCubeScriptToHalfLocation_CLIENT(Vector3 vect, CubeLocationScript script) { if (!_LocationHalfLookup.ContainsKey(vect)) { //Debug.Log("fucken adding HALF script to vect: " + vect + " script: " + script); _LocationHalfLookup.Add(vect, script); return; } Debug.LogError("trying to assign script to already taking location!!!"); }
private void StartMoving() { Vector3 unitCurrPos = _unit.transform.position; if (locCount < _nodes.Count) { CubeLocationScript target = _nodes [locCount]; if (target != null) { Vector3 currTarget = new Vector3(target.cubeLoc.x, target.cubeLoc.y, target.cubeLoc.z); if (!target._cubeOccupied || target._flagToSayIsMine == this || target._flagToSayIsMine == null) { target._flagToSayIsMine = this; target._cubeOccupied = true; collision = false; if (!target.gameObject.transform.Find("pathFindingNode(Clone)")) { target.CreatePathFindingNode(); // puts circles in path, visual reference } if (unitCurrPos != currTarget) { _unit.transform.position = Vector3.MoveTowards(unitCurrPos, currTarget, _nodes.Count * Time.deltaTime); } else { if (target.gameObject.transform.Find("pathFindingNode(Clone)").gameObject) { Destroy(target.gameObject.transform.Find("pathFindingNode(Clone)").gameObject); } target._cubeOccupied = false; target._flagToSayIsMine = null; _nodes [locCount] = null; locCount += 1; if (locCount == _nodes.Count) { FinishMoving(); } } } else if (target._flagToSayIsMine != this && target._flagToSayIsMine != false) { if (collision == false) { collision = true; CubeLocationScript nodeToRemove = _nodes [_nodes.Count - 1]; _nodes.Remove(nodeToRemove); } } } } }
// tries to spawn visual nodes in all current moveable locations for a unit public void DebugTestPathFindingNodes(UnitScript unit) { foreach (KeyValuePair <Vector3, CubeLocationScript> element in _LocationLookup) { CubeLocationScript script = CheckIfCanMoveToCube(unit, unit.CubeUnitIsOn, element.Key); if (script != null) { script.CreatePathFindingNode((int)unit.NetID.Value); } } }
int GetDistance(CubeLocationScript nodeA, CubeLocationScript nodeB) { int dstX = (int)Mathf.Abs(nodeA.CubeLocVector.x - nodeB.CubeLocVector.x); int dstY = (int)Mathf.Abs(nodeA.CubeLocVector.y - nodeB.CubeLocVector.y); if (dstX > dstY) { return(14 * dstY + 10 * (dstX - dstY)); } return(14 * dstX + 10 * (dstY - dstX)); }
/* * private void DoHalfPointsForWalls(Vector3 nodeVect) { * * CubeLocationScript nodeScript = _locationManager.GetLocationScript(nodeVect); * if (nodeScript != null) { * nodeScript._isPanel = true; * nodeScript.IsHumanWalkable = false; * } * } */ private void MakeClimbableEdges(Vector3 nodeVect) { CubeLocationScript nodeScript = _locationManager.GetLocationScript(nodeVect); if (nodeScript != null) { if (!nodeScript._isPanel) { //nodeScript.IsHumanClimbable = true; } } }
//////////////////////////////////////////////// //private void AnnoyingFuckingAngleMovementThing() // this is to fix the f*****g camera spinning around in weird angles 10% of the time when a unit moves onto a diff sided panel //{ // if (_TARGETObjectScript.objectType == CubeObjectTypes.Panel_Wall) // { // if (_lastPanelYAxis == -1) // { // _lastPanelYAxis = _TARGETPanelScript._panelYAxis; // changeWallAngle = false; // } // else // { // if (_lastPanelYAxis != _TARGETPanelScript._panelYAxis) // { // changeWallAngle = true; // } // else // { // changeWallAngle = false; // } // _lastPanelYAxis = _TARGETPanelScript._panelYAxis; // } // Debug.Log("f**k changeWallAngle " + changeWallAngle); // } //} //////////////////////////////////////////////// private void SetNextTarget() { _TARGETCubeID = _nodes[locCount]; _TARGETCubeScript = LocationManager.GetLocationScript_CLIENT(_TARGETCubeID); if (_TARGETCubeScript._platform_Panel_Cube.GetCubePanel != null) { _TARGETPanelScript = _TARGETCubeScript._platform_Panel_Cube.GetCubePanel; _TARGETObjectScript = _TARGETPanelScript.gameObject.GetComponent <ObjectScript>(); //AnnoyingFuckingAngleMovementThing(); if (MovementManager._gravityActivated) { // unitContainerTransformLOCAL.localEulerAngles = new Vector3(0, unitContainerTransformLOCAL.localEulerAngles.y, 0); // unitContainerAnglesGLOBAL.localEulerAngles = new Vector3(0, 0, 0); } else { rotateInProgress = false; if (_TARGETObjectScript.objectType != _currObjectScript.objectType) { rotateInProgress = true; } if (_TARGETObjectScript.objectType == _currObjectScript.objectType) { int currPanelYAxis = _currPanelScript._panelYAxis; int targetPanelYAxis = _TARGETPanelScript._panelYAxis; if (currPanelYAxis != targetPanelYAxis) { rotateInProgress = true; } } ChangeUnitsRotation(); ChangeCameraRotation(); } if (!LocationManager.SetUnitOnCube_CLIENT(GetComponent <UnitScript>(), _TARGETCubeID)) { Debug.LogWarning("units movement interrupted >> recalculating"); moveInProgress = false; ResetValues(); if (MovementManager.BuildMovementPath(_finalTargetScript)) { MovementManager.MakeActiveUnitMove_CLIENT(); } } } }
public CubeLocationScript CheckIfCanMoveToCube(Vector3 loc) { CubeLocationScript cubeScript = GetLocationScript(loc); if (cubeScript != null) { if (cubeScript._cubeOccupied) { cubeScript = null; } } return(cubeScript); }
private static int GetDistance(CubeLocationScript nodeA, CubeLocationScript nodeB) { int dstX = Mathf.FloorToInt(Mathf.Abs(nodeA.CubeID.x - nodeB.CubeID.x)); int dstY = Mathf.FloorToInt(Mathf.Abs(nodeA.CubeID.y - nodeB.CubeID.y)); int dstZ = Mathf.FloorToInt(Mathf.Abs(nodeA.CubeID.z - nodeB.CubeID.z)); if (dstX > dstZ) { return(14 * dstZ + 10 * (dstX - dstZ) + 10 * dstY); } return(14 * dstX + 10 * (dstZ - dstX) + 10 * dstY); }
//////////////////////////////////////////////// public static void SendCubeDataToSERVER_CLIENT(Vector3 vect) { CubeLocationScript script = GetLocationScript_CLIENT(vect); if (script != null) { NetWorkManager.NetworkAgent.CmdTellServerToUpdateLocation(vect, script.GetCubeData()); } else { Debug.LogError("GOT AN ISSUE HERE"); } }
private List <CubeLocationScript> RetracePath(CubeLocationScript startNode, CubeLocationScript endNode) { List <CubeLocationScript> path = new List <CubeLocationScript>(); CubeLocationScript currentNode = endNode; while (currentNode != startNode) { path.Add(currentNode); currentNode = currentNode._parentPathFinding; } path.Reverse(); ResetPath(); return(path); }