public static void CreateGrid() { GridOfArena = new NodeA[ArenaSizeX, ArenaSizeY]; Texture2D Map = Resources.LoadAll <Texture2D> ("Marcer") [0]; Transform MiniNodaLevel = Resources.LoadAll <Transform> ("Marcer") [0]; Vector3 BotomLeft = Vector3.zero - Vector3.right * (ArenaSizeX / 2) - Vector3.forward * (ArenaSizeY / 2); for (int x = 0; x < ArenaSizeX; x++) { for (int y = 0; y < ArenaSizeY; y++) { if (Map.GetPixel(x, y) == Color.green || Map.GetPixel(x, y) == Color.blue) { GridOfArena[x, y] = new NodeA(BotomLeft + Vector3.right * x + Vector3.forward * y, x, y, NodeA.NodeType.Walkable); Vector3 positionofnode = (BotomLeft + Vector3.right * x + Vector3.forward * y); Transform node = Instantiate(MiniNodaLevel, positionofnode, Quaternion.identity).transform; node.eulerAngles = new Vector3(90, 0, 0); node.localScale *= 2f; } else { GridOfArena[x, y] = new NodeA(BotomLeft + Vector3.right * x + Vector3.forward * y, x, y, NodeA.NodeType.Wall); } } } foreach (Shelter n in ShelterList) { n.SetSelterBlock(); } }
public NodeA(Node startNode, Node endNode, int ID) { from = 0; to = Math.Abs(startNode.column - endNode.column) + Math.Abs(startNode.row - endNode.row); total = to; parent = null; this.ID = ID; }
static void Main(string[] args) { var nodeB2 = new NodeB(); var nodeA2 = new NodeA(nodeB2); var nodeA1 = new NodeA(nodeB2, nodeA2, new NodeC()); nodeA1.Accept(new PrintVisitor()); }
public NodeA() { from = 0; to = 0; total = 0; ID = -1; parent = null; }
public NodeA(Node startNode, Node endNode, Node currentNode, NodeA parent, int ID) { from = Math.Abs(startNode.column - currentNode.column) + Math.Abs(startNode.row - currentNode.row); to = Math.Abs(currentNode.column - endNode.column) + Math.Abs(currentNode.row - endNode.row); total = to + from; this.parent = parent; this.ID = ID; }
static void Bridge_Exemplo1() { var bridge = new Bridge(); var nodeA = new NodeA(); var nodeB = new NodeB(); bridge.ReachTo(nodeA); bridge.ReachTo(nodeB); }
public override int GetHashCode() { unchecked { int hashCode = 105289569; hashCode = hashCode * -1521134295 + NodeA.GetHashCode(); hashCode = hashCode * -1521134295 + NodeB.GetHashCode(); return(hashCode); } }
public override int GetHashCode() { unchecked { var hashCode = NodeA.GetHashCode(); hashCode = hashCode ^ NodeB.GetHashCode(); hashCode = (hashCode * 397) ^ Distance.GetHashCode(); return(hashCode); } }
public virtual void MakeShoot(NodeA node) { if (_unit == null) { _unit = transform.parent.GetComponent <NetworkElement> (); } if (_bullet == null) { _bullet = Resources.Load <GameObject> ("Staff/Bullet") as GameObject; } _target = node.UnitOnNode.unit; StartCoroutine(MoveBullet(node)); }
public void TryNewParent(Node startNode, Node endNode, Node currentNode, NodeA parent) { double fromTmp = Math.Abs(startNode.column - currentNode.column) + Math.Abs(startNode.row - currentNode.row); double toTmp = Math.Abs(currentNode.column - endNode.column) + Math.Abs(currentNode.row - endNode.row); double totalTmp = to + from; if (totalTmp < this.total) { this.to = toTmp; this.from = fromTmp; this.total = totalTmp; this.parent = parent; } }
public IEnumerator LerpMove(NodeA targetNode) { unit.MoveUse(); Vector3 finalePose = targetNode.UnitPosition; float timer = 0; while (Vector3.Distance(transform.position, finalePose) > 0.1f && timer < 1f) { timer += Time.deltaTime; transform.position = Vector3.Lerp(transform.position, finalePose, 0.1f); yield return(new WaitForEndOfFrame()); } transform.position = finalePose; targetNode.UnitOnNode = this; }
public static NodeA NodeFromWorldPoint(Vector3 worldPosition) { try { float percentX = (worldPosition.x + ArenaSizeX / 2) / ArenaSizeX; float percentY = (worldPosition.z + ArenaSizeY / 2) / ArenaSizeY; percentX = Mathf.Clamp01(percentX); percentY = Mathf.Clamp01(percentY); int x = Mathf.RoundToInt((ArenaSizeX) * percentX); int y = Mathf.RoundToInt((ArenaSizeY) * percentY); lastNodeA = GridOfArena[x, y]; return(GridOfArena[x, y]); } catch { return(lastNodeA); } }
void CreateGrid() { GridOfArena = new NodeA[ArenaSizeX, ArenaSizeY]; Vector3 BotomLeft = transform.position - Vector3.right * (ArenaSizeX / 2) - Vector3.forward * (ArenaSizeY / 2); for (int x = 0; x < ArenaSizeX; x++) { for (int y = 0; y < ArenaSizeY; y++) { GridOfArena[x, y] = new NodeA(BotomLeft + Vector3.right * x + Vector3.right * 0.5f + Vector3.forward * y, x, y, WhatTypeNode(Map.GetPixel(x, y))); if (Map.GetPixel(x, y) == Color.green || Map.GetPixel(x, y) == Color.blue) { Vector3 positionofnode = (BotomLeft + Vector3.right * x + Vector3.right * 0.5f + Vector3.forward * y); Transform node = Instantiate(MiniNodaLevel, positionofnode, Quaternion.identity).transform; node.eulerAngles = new Vector3(90, 0, 0); node.localScale *= 0.6f; } } } }
public GridGraph(int[,] data) { this.nodes = new List <GridNode>(); //Creates a new list of nodes this.width = data.GetLength(0); //Sets the width this.height = data.GetLength(1); //Sets the height for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { this.nodes.Add(new GridNode(new Vector2(x, y), data[x, y])); //Creates a node for each position } } //Neighbours foreach (GridNode NodeA in this.nodes) //Runs through each node { foreach (GridNode NodeB in this.nodes) //Runs through every other node { NodeA.SetNeighbour(NodeB, (int)(NodeB.Location.X - NodeA.Location.X), (int)(NodeB.Location.Y - NodeA.Location.Y)); //Evaluates to see if they are neighbours } } }
public GridGraph(int[,] data) { this.nodes = new List <GridNode>(); this.width = data.GetLength(0); this.height = data.GetLength(1); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { this.nodes.Add(new GridNode(new Vector2(x, y), data[x, y])); } } //Neighbours foreach (GridNode NodeA in this.nodes) { foreach (GridNode NodeB in this.nodes) { NodeA.SetNeighbour(NodeB, NodeB.Location.X - NodeA.Location.X, NodeB.Location.Y - NodeA.Location.Y); } } }
public virtual IEnumerator MoveBullet(NodeA targetNode) { _unit.unit.AttackUse(); yield return(new WaitForSeconds(0.25f)); for (int i = 0; i < BulletPerShoot; i++) { _target.Manger.PlaySpecific(Sound); Vector3 targetPosition = targetNode.Position + Vector3.up * (Random.Range(-5, 11) / 20f) + Vector3.up * 0.6f; Vector3 selfPosition = transform.position + (targetPosition - (transform.position + Vector3.up * 0.3f)).normalized * 0.25f + Vector3.up * 0.3f; NetworkElement targetUnit = targetNode.UnitOnNode; GameObject localBullet = Instantiate(_bullet, selfPosition, Quaternion.identity); float distantion = Vector3.Distance(selfPosition, targetPosition); while (Vector3.Distance(localBullet.transform.position, targetPosition) > 0.05f) { localBullet.transform.Translate((targetPosition - selfPosition) / valuespeedBullet); yield return(new WaitForFixedUpdate()); } float n = Random.Range(0, 100); Shelter shelter; float DistanceTarget = Vector3.Distance(selfPosition, targetUnit.transform.position + Vector3.up * (Random.Range(-5, 11) / 20f)); float Range = NormalDist / DistanceTarget; float targetShelterValue = targetUnit.GetShelterLevel(out shelter); if (Range > 1) { Range = 1; } if (n < Range * 100f - targetShelterValue) { FinalDamage += Damage; } else { if (Random.Range(0, 101) > targetShelterValue * 0.75f) { if (shelter != null) { Instantiate(shelter.FX, shelter.transform.position, Quaternion.identity); shelter.ShelterLevl -= Damage * 3; if (shelter.ShelterLevl < 1) { Destroy(shelter.gameObject); } } } } Ammo--; Destroy(localBullet); yield return(new WaitForSeconds(WaitTime)); } if (_unit.Controlled) { if (FinalDamage > 0) { ClientReciverMK1.WriteMsg("/Damage" + _unit.unit.Manger.GetUnitId(targetNode.UnitOnNode) + ":" + FinalDamage + ":" + 0 + ":" + 0); _target.GetDamage(FinalDamage); FinalDamage = 0; } else { ClientReciverMK1.WriteMsg("/Damage" + _unit.unit.Manger.GetUnitId(targetNode.UnitOnNode) + ":" + 0 + ":" + 0 + ":" + -1); _target.GetDamage(0, 0, -1); } } }
public string ToDetailedString(DataFields dataFields) { return(NodeA.ToDetailedString(dataFields) + " => " + NodeB.ToDetailedString(dataFields) + " || " + GetCalculationsAsString()); }
public override int GetHashCode() { return(NodeA.GetHashCode() ^ NodeB.GetHashCode() ^ Values.GetHashCode()); }
void Update() { if (manager.CorrectUnit == ThisUnit && manager.PercUse) { RaycastHit hit; Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); Physics.Raycast(ray, out hit, Mathf.Infinity); if (AParm == 1 && hit.rigidbody != null) { Debug.Log(hit.rigidbody.name); UnitBehevior PointedTarget = hit.rigidbody.GetComponent <UnitBehevior>(); if (ThisUnit.TimeToReusePerc <= 0 && manager.PercUse && Input.GetKeyDown(KeyCode.Mouse0) && IsTarget(PointedTarget) && Vector3.Distance(transform.position, PointedTarget.transform.position) < Radious) { GridManager.CleatGrid(); manager.CleanJunk(); UnitBehevior unitTarget = manager.CorrectUnit; if (unitTarget.transform.position.x - manager.CorrectUnit.transform.position.x > 1) { unitTarget.Weapon.SpriteRendererValue.sortingOrder = 1; unitTarget.Weapon.SpriteRendererValue.flipX = false; unitTarget.HandRenderer.sortingOrder = 1; unitTarget.HandRenderer.flipX = false; unitTarget.BodyRenderer.sprite = unitTarget.data.IconBodyFace; } if (unitTarget.transform.position.x - manager.CorrectUnit.transform.position.x < -1) { unitTarget.Weapon.SpriteRendererValue.sortingOrder = -2; unitTarget.Weapon.SpriteRendererValue.flipX = true; unitTarget.HandRenderer.sortingOrder = -2; unitTarget.HandRenderer.flipX = true; unitTarget.BodyRenderer.sprite = unitTarget.data.IconBodyBack; } manager.CorrectUnit.PercBehevior.UsePerc(manager.CorrectUnit.Enemy, PointedTarget); manager.PercUse = false; Destroy(Show); manager.CorrectUnit.TimeToReusePerc = data.TimeToReuse; manager.EndTurn(); } } if (AParm == 2 && ThisUnit.TimeToReusePerc < 1) { if (!VisualEffect.gameObject.activeInHierarchy) { VisualEffect.gameObject.SetActive(true); } GridManager.CleatGrid(); point = GridManager.NodeFromWorldPoint(ray.GetPoint(15)).Position; vectorsOfGrande = GetMatrix(); VisualEffect.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear); var vel = VisualEffect.velocityOverLifetime; Vector3 dir = (point - transform.position).normalized; float dist = Vector3.Distance(point, transform.position); if (dist > Radious) { dist = Radious; } vel.x = new ParticleSystem.MinMaxCurve(dir.x * dist); vel.z = new ParticleSystem.MinMaxCurve(dir.z * dist); VisualEffect.Play(); Vector3 vector = GridManager.NodeFromWorldPoint(transform.position + dist * dir).Position; for (int i = 0; i < vectorsOfGrande.Length; i++) { vectorsOfGrande[i] += new Vector2(vector.x, vector.z); GridManager.CreateNodeShow(Color.cyan, new Vector3(vectorsOfGrande[i].x, 0, vectorsOfGrande[i].y)); } if (Input.GetKeyDown(KeyCode.Mouse0) && !UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject()) { var granadeLineFx = Instantiate(manager.OnTurnEffectFX[8].GetComponent <ParticleSystem>(), transform.position, Quaternion.identity); granadeLineFx.Stop(); var fxvel = granadeLineFx.velocityOverLifetime; fxvel.x = new ParticleSystem.MinMaxCurve(dir.x * dist); fxvel.z = new ParticleSystem.MinMaxCurve(dir.z * dist); granadeLineFx.gameObject.SetActive(true); granadeLineFx.Play(); VisualEffect.gameObject.SetActive(false); point = vector; Invoke("MakeBoom", 1); ThisUnit.TimeToReusePerc = data.TimeToReuse; manager.RetarderCall(1.5f); } } if (AParm == 3 && ThisUnit.TimeToReusePerc < 1) { NodeA node = new NodeA(Vector3.right * 1000, 1111, 1111, NodeA.TypeOfNode.Wall); if (Vector3.Distance(point, ray.GetPoint(15)) > 0.1f) { if (!VisualEffect.gameObject.activeInHierarchy) { VisualEffect.gameObject.SetActive(true); } VisualEffect.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear); var vel = VisualEffect.velocityOverLifetime; GridManager.CleatGrid(); point = GridManager.NodeFromWorldPoint(ray.GetPoint(15)).Position; Vector3 dir = (point - transform.position).normalized; float dist = Vector3.Distance(point, transform.position); if (dist > Radious) { dist = Radious; } vel.x = new ParticleSystem.MinMaxCurve(dir.x * dist); vel.z = new ParticleSystem.MinMaxCurve(dir.z * dist); VisualEffect.Play(); node = GridManager.NodeFromWorldPoint(transform.position + dir * dist); if (node._Bloc == NodeA.TypeOfNode.Walkable && node.UnitOnNode == null) { GridManager.CreateNodeShow(manager.ColorOfIfo[1], node.Position); } } if (Input.GetKeyDown(KeyCode.Mouse0) && node._Bloc == NodeA.TypeOfNode.Walkable && !UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject()) { GameObject fx = Instantiate(manager.OnTurnEffectFX[10 + CAParm], node.Position, Quaternion.identity); fx.transform.eulerAngles = new Vector3(0, -87.69f, 0); VisualEffect.gameObject.SetActive(false); ThisUnit.TimeToReusePerc = data.TimeToReuse; manager.RetarderCall(1f); } } } else if (VisualEffect != null && VisualEffect.gameObject.activeInHierarchy) { VisualEffect.gameObject.SetActive(false); } }
public CheckedNode(NodeA node, int cost) { Node = node; Cost = cost; }
public new string ToString() { return(NodeA.ToString().PadRight(10) + "<-> " + NodeB.ToString().PadRight(10) + "@".PadLeft(5) + distance.ToString("0.00")); }
public VectorClockConflict <T> ToModel() { return(new VectorClockConflict <T>(NodeA.ToModel(), NodeB.ToModel())); }
public override string ToString() { return(NodeA.ToString() + " -> " + NodeB.ToString()); }
//Given coordinates of two points function will draw path between them public List <Vector2> GoFromTo(double xStart, double yStart, double xEnd, double yEnd) { int rowStart = tileMap.GetLength(0) - (int)((yStart + mapTranslation.y) / tileSize.y); //-1 * ((tileMap.GetLength(1) - randX) * width + mapTranslation.x); int columnStart = (int)((xStart + mapTranslation.x) / tileSize.x); int rowEnd = tileMap.GetLength(0) - (int)((yEnd + mapTranslation.y) / tileSize.y); //-1 * ((tileMap.GetLength(1) - randX) * width + mapTranslation.x); int columnEnd = (int)((xEnd + mapTranslation.x) / tileSize.x); int rowStartLanding = 0; int rowEndLanding = 0; Node startNode = null; Node endNode = null; //Return list with points that AI should go through List <Vector2> path = new List <Vector2>(); //Instantiate(spikes, new Vector3(columnStart * tileSize.x + mapTranslation.x, (tileMap.GetLength(0) - rowStart) * tileSize.y + mapTranslation.y, 0), Quaternion.identity); //Instantiate(spikes, new Vector3(columnEnd * tileSize.x + mapTranslation.x, (tileMap.GetLength(0) - rowEnd) * tileSize.y + mapTranslation.y, 0), Quaternion.identity); //**********************************************************************************************************************************************************************************************// //******************************************************** FIND START AND END NODES ******************************************************************************************************// //**********************************************************************************************************************************************************************************************// //Check if start is on platform //If not it means that unit is in air and we draw vertical path to land it if (tileMap[ClampRow(rowStart + 1), ClampColumn(columnStart)] != 1) { for (int i = 0; i < tileMap.GetLength(0); i++) { if (tileMap[ClampRow(rowStart + 1 + i), ClampColumn(columnStart)] == 1) { //Debug.DrawLine(new Vector3((columnStart) * tileSize.x, (tileMap.GetLength(0) - (rowStart + i)) * tileSize.y, 0), // new Vector3((columnStart) * tileSize.x, (tileMap.GetLength(0) - rowStart) * tileSize.y, 0), // Color.white, 1, false); rowStartLanding = rowStart + i; break; } } } else { rowStartLanding = rowStart; } //Check if end is on platform //If not it means that unit is in air and we draw vertical path to land it if (tileMap[ClampRow(rowEnd + 1), ClampColumn(columnEnd)] != 1) { for (int i = 0; i < tileMap.GetLength(0); i++) { if (tileMap[ClampRow(rowEnd + 1 + i), ClampColumn(columnEnd)] == 1) { //Debug.DrawLine(new Vector3((columnEnd) * tileSize.x, (tileMap.GetLength(0) - (rowEnd + i)) * tileSize.y, 0), // new Vector3((columnEnd) * tileSize.x, (tileMap.GetLength(0) - rowEnd) * tileSize.y, 0), // Color.white, 1, false); rowEndLanding = rowEnd + i; break; } } } else { rowEndLanding = rowEnd; } //Now we look for closets node on platform where unit is or just landed //Looking for it we move 1 tile right and left each iteration untill we uncounter node bool leftIsOk = true; bool rightIsOk = true; //Search for start node for (int i = 0; i < tileMap.GetLength(1); i++) { int tmp = ClampColumn(columnStart + i); if (tileMap[ClampRow(rowStartLanding), ClampColumn(columnStart + i)] == 1) { rightIsOk = false; } if (tileMap[ClampRow(rowStartLanding), ClampColumn(columnStart - i)] == 1) { leftIsOk = false; } if (nodeMap[ClampRow(rowStartLanding), ClampColumn(columnStart + i)].Count != 0 && rightIsOk) { startNode = graph[nodeMap[ClampRow(rowStartLanding), ClampColumn(columnStart + i)][0]]; break; } if (nodeMap[ClampRow(rowStartLanding), ClampColumn(columnStart - i)].Count != 0 && leftIsOk) { startNode = graph[nodeMap[ClampRow(rowStartLanding), ClampColumn(columnStart - i)][0]]; break; } } leftIsOk = true; rightIsOk = true; //Search for end node for (int i = 0; i < tileMap.GetLength(1); i++) { if (tileMap[ClampRow(rowEndLanding), ClampColumn(columnEnd + i)] == 1) { rightIsOk = false; } if (tileMap[ClampRow(rowEndLanding), ClampColumn(columnEnd - i)] == 1) { leftIsOk = false; } if (nodeMap[ClampRow(rowEndLanding), ClampColumn(columnEnd + i)].Count != 0 && rightIsOk) { endNode = graph[nodeMap[ClampRow(rowEndLanding), ClampColumn(columnEnd + i)][0]]; break; } if (nodeMap[ClampRow(rowEndLanding), ClampColumn(columnEnd - i)].Count != 0 && leftIsOk) { endNode = graph[nodeMap[ClampRow(rowEndLanding), ClampColumn(columnEnd - i)][0]]; break; } } //Unsolved bug when strat or end cannot be found if (startNode == null || endNode == null) { return(new List <Vector2>()); } //Instantiate(spikes, new Vector3(columnStart * tileSize.x + mapTranslation.x, (tileMap.GetLength(0) - rowStartLanding) * tileSize.y + mapTranslation.y, 0), Quaternion.identity); //Instantiate(spikes, new Vector3(columnEnd * tileSize.x + mapTranslation.x, (tileMap.GetLength(0) - rowEndLanding) * tileSize.y + mapTranslation.y, 0), Quaternion.identity); //**********************************************************************************************************************************************************************************************// //***********************************r********************* FIND PATH FROM START TO END NODE ***************************************************************************************// //**********************************************************************************************************************************************************************************************// List <int> open = new List <int>(); List <int> closed = new List <int>(); List <NodeA> nodesA = new List <NodeA>(); int currentNodeAID; Node currentNode; //Init nodesA for (int i = 0; i < graph.Count; i++) { nodesA.Add(null); } //Create first nodeA nodesA[startNode.ID] = new NodeA(startNode, endNode, startNode.ID); nodesA[startNode.ID].opened = true; currentNodeAID = nodesA[startNode.ID].ID; currentNode = startNode; for (int i = 0; i < graph.Count; i++) { //If currnet node ID equal to end node ID then we found path if (currentNodeAID == endNode.ID) { break; } //Go through all neighbors for (int j = 0; j < currentNode.neighbors.Count; j++) { //If neighbors is not in open list we create it and fill with data if (nodesA[currentNode.neighbors[j].ID] == null) { nodesA[currentNode.neighbors[j].ID] = new NodeA(startNode, endNode, currentNode, nodesA[currentNodeAID], currentNode.neighbors[j].ID); nodesA[currentNode.neighbors[j].ID].opened = true; open.Add(currentNode.neighbors[j].ID); } //Else we check if my path to this neighbor has lower total cast else if (!nodesA[currentNode.neighbors[j].ID].closed) { nodesA[currentNode.neighbors[j].ID].TryNewParent(startNode, endNode, currentNode, nodesA[currentNodeAID]); } } //Closing current node and adding it to closed list nodesA[currentNodeAID].closed = true; closed.Add(nodesA[currentNodeAID].ID); //Find new current node by choosing first nodeA with smallest "total" value from open list double minTotal = Double.MaxValue; int minID = -1; for (int j = 0; j < open.Count; j++) { if (minTotal > nodesA[open[j]].total) { minID = j; minTotal = nodesA[open[j]].total; } } //Code below can render all steps that A*took if (i != 0) { Debug.DrawLine(new Vector3((currentNode.column) * tileSize.x, (tileMap.GetLength(0) - (currentNode.row)) * tileSize.y, 0), new Vector3((graph[nodesA[currentNodeAID].parent.ID].column) * tileSize.x, (tileMap.GetLength(0) - graph[nodesA[currentNodeAID].parent.ID].row) * tileSize.y, 0), Color.black, 1, false); } if (minID == -1 || open.Count == 0) { return(path); } currentNodeAID = nodesA[open[minID]].ID; currentNode = graph[currentNodeAID]; open.RemoveAt(minID); } List <Vector2> pathTmp = new List <Vector2>(); while (currentNodeAID != startNode.ID) { NodeA nextNodeA = nodesA[currentNodeAID].parent; Debug.DrawLine(new Vector3((graph[currentNodeAID].column) * tileSize.x, (tileMap.GetLength(0) - (graph[currentNodeAID].row)) * tileSize.y, 0), new Vector3((graph[nextNodeA.ID].column) * tileSize.x, (tileMap.GetLength(0) - (graph[nextNodeA.ID].row)) * tileSize.y, 0), Color.white, 1, false); currentNodeAID = nodesA[currentNodeAID].parent.ID; pathTmp.Add(new Vector2(graph[currentNodeAID].column * tileSize.x, (tileMap.GetLength(0) - graph[currentNodeAID].row) * tileSize.y)); } //PrintGraph(); //Reverce path for (int i = 0; i < pathTmp.Count; i++) { path.Add(pathTmp[pathTmp.Count - 1 - i]); } return(path); }
public bool Equals(EdgeDistance other) { return(((NodeA.Equals(other.NodeA) && NodeB.Equals(other.NodeB)) || (NodeA.Equals(other.NodeB) && NodeB.Equals(other.NodeA))) && Distance.Equals(other.Distance)); }