public static void DrawWireBounds(Vector3 center, Vector3 size, Color lineColor, Neighbors sides) { float bh = size.y-0.2f; float bs = size.x-0.2f; Vector3 here = center + new Vector3(-bs/2+0.1f, -bh/2+0.1f, -bs/2+0.1f); if((sides & Neighbors.FrontLeft) != 0) { Vector3[] frontLeft = new Vector3[]{ here+new Vector3(0,0,bs), here+new Vector3(0,bh,bs), here+new Vector3(0,bh,0), here+new Vector3(0,0,0) }; Handles.DrawSolidRectangleWithOutline(frontLeft, Color.clear, lineColor); } if((sides & Neighbors.FrontRight) != 0) { Vector3[] frontRight = new Vector3[]{ here+new Vector3(0,0,0), here+new Vector3(bs,0,0), here+new Vector3(bs,bh,0), here+new Vector3(0,bh,0), }; Handles.DrawSolidRectangleWithOutline(frontRight, Color.clear, lineColor); } if((sides & Neighbors.Top) != 0) { Vector3[] top = new Vector3[]{ here+new Vector3(bs,bh,0), here+new Vector3(bs,bh,bs), here+new Vector3(0,bh,bs), here+new Vector3(0,bh,0), }; Handles.DrawSolidRectangleWithOutline(top, Color.clear, lineColor); } if((sides & Neighbors.Bottom) != 0) { Vector3[] bottom = new Vector3[]{ here+new Vector3(bs,0,0), here+new Vector3(bs,0,bs), here+new Vector3(0,0,bs), here+new Vector3(0,0,0), }; Handles.DrawSolidRectangleWithOutline(bottom, Color.clear, lineColor); } if((sides & Neighbors.BackLeft) != 0) { Vector3[] backLeft = new Vector3[]{ here+new Vector3(0,0,bs), here+new Vector3(bs,0,bs), here+new Vector3(bs,bh,bs), here+new Vector3(0,bh,bs), }; Handles.DrawSolidRectangleWithOutline(backLeft, Color.clear, lineColor); } if((sides & Neighbors.BackRight) != 0) { Vector3[] backRight = new Vector3[]{ here+new Vector3(bs,bh,bs), here+new Vector3(bs,0,bs), here+new Vector3(bs,0,0), here+new Vector3(bs,bh,0) }; Handles.DrawSolidRectangleWithOutline(backRight, Color.clear, lineColor); } }
public void SetTileSpecOnTileAt(int spec, int x, int y, int z, Neighbors sides) { MapTile t = TileAt(x,y,z); if(!MapTileIsNull(t)) { t.SetTileSpecOnSides(spec, sides); } RemakeMesh(); }
public void AdjustHeightOnSidesOfTile( int x, int y, int z, int deltaH, Neighbors sides, bool top ) { MapTile t = TileAt(x,y,z); if(t == null) { return; } t.AdjustHeightOnSides(deltaH, sides, top, NextTile(t)); RemakeMesh(); }
private void BroadcastUpdate(LinkStateAdvertisement packet) { Neighbors .ForEach(neighbor => neighbor.ReceiveUpdate(packet)); }
/// <summary> /// Setting it's own neighbour /// </summary> /// <param name="nextNode"></param> /// <param name="distance"></param> public void SetNeighbour(Node nextNode, int distance) { Neighbors.Add(nextNode, distance); }
private Tile GetNeighbor(Tile target, Neighbors neighbor) { Tile tile = null; int col = target.col; int row = target.row; switch (neighbor) { case Neighbors.UpperLeft: if (col > 0 && row > 0) { tile = tiles [col - 1, row - 1]; } break; case Neighbors.Above: if (row > 0) { tile = tiles [col, row - 1]; } break; case Neighbors.UpperRight: if (col < 7 && row > 0) { tile = tiles [col + 1, row - 1]; } break; case Neighbors.Left: if (col > 0) { tile = tiles [col - 1, row]; } break; case Neighbors.Right: if (col < 7) { tile = tiles [col + 1, row]; } break; case Neighbors.LowerLeft: if (col > 0 && row < 7) { tile = tiles [col - 1, row + 1]; } break; case Neighbors.Below: if (row < 7) { tile = tiles [col, row + 1]; } break; case Neighbors.LowerRight: if (col < 7 && row < 7) { tile = tiles [col + 1, row + 1]; } break; } return tile; }
public void AdjustHeightOnSides(int ht, Neighbors mask, bool top, MapTile next) { if(top && (heights == null || heights.Length == 0)) { heights = new int[]{1, 1, 1, 1}; } if(!top && (baselines == null || baselines.Length == 0)) { baselines = new int[]{0, 0, 0, 0}; } int hts = ht > 0 ? 1 : -1; while(ht != 0) { int hcl = heights[(int)Corners.Left]; int hcf = heights[(int)Corners.Front]; int hcr = heights[(int)Corners.Right]; int hcb = heights[(int)Corners.Back]; int bcl = baselines[(int)Corners.Left]; int bcf = baselines[(int)Corners.Front]; int bcr = baselines[(int)Corners.Right]; int bcb = baselines[(int)Corners.Back]; int aboveTileZIfAny = next != null ? next.z : int.MaxValue; if(top) { //raise rules: if corners are different heights, only raise the lower one; // don't raise a corner if it will cause a collision with a tile above //lower rules: if corners are different heights, only lower the higher one; // don't lower a height to or below its corresponding baseline if((mask & Neighbors.FrontLeft) != 0) { if(hts > 0 ? (hcl <= hcf && z+hcl < aboveTileZIfAny) : (hcl >= hcf && hcl > bcl+1)) { heights[(int)Corners.Left] += hts; } if(hts > 0 ? (hcf <= hcl && z+hcf < aboveTileZIfAny) : (hcf >= hcl && hcf > bcf+1)) { heights[(int)Corners.Front] += hts; } } if((mask & Neighbors.FrontRight) != 0) { if(hts > 0 ? (hcr <= hcf && z+hcr < aboveTileZIfAny) : (hcr >= hcf && hcr > bcr+1)) { heights[(int)Corners.Right] += hts; } if(hts > 0 ? (hcf <= hcr && z+hcf < aboveTileZIfAny) : (hcf >= hcr && hcf > bcf+1)) { heights[(int)Corners.Front] += hts; } } if((mask & Neighbors.BackRight) != 0) { if(hts > 0 ? (hcr <= hcb && z+hcr < aboveTileZIfAny) : (hcr >= hcb && hcr > bcr+1)) { heights[(int)Corners.Right] += hts; } if(hts > 0 ? (hcb <= hcr && z+hcb < aboveTileZIfAny) : (hcb >= hcr && hcb > bcb+1)) { heights[(int)Corners.Back] += hts; } } if((mask & Neighbors.BackLeft) != 0) { if(hts > 0 ? (hcl <= hcb && z+hcl < aboveTileZIfAny) : (hcl >= hcb && hcl > bcl+1)) { heights[(int)Corners.Left] += hts; } if(hts > 0 ? (hcb <= hcl && z+hcb < aboveTileZIfAny) : (hcb >= hcl && hcb > bcb+1)) { heights[(int)Corners.Back] += hts; } } } else { //raise rules: if corners are different heights, only raise the lower one; // don't raise a baseline to or above its corresponding height; // while all corners are raised above 0, decrement all corners by 1 and increase z by 1. //lower rules: if corners are different heights, only lower the higher one; // don't lower a corner below 0 // (later: don't lower a corner below 0 if there is a tile below;) // (later: while any corner is below 0, increment all corners by 1 and decrease z by 1) if((mask & Neighbors.FrontLeft) != 0) { if(hts > 0 ? (bcl <= bcf && bcl+1<hcl) : (bcl >= bcf && bcl > 0)) { baselines[(int)Corners.Left] += hts; } if(hts > 0 ? (bcf <= bcl && bcf+1<hcf) : (bcf >= bcl && bcf > 0)) { baselines[(int)Corners.Front] += hts; } } if((mask & Neighbors.FrontRight) != 0) { if(hts > 0 ? (bcr <= bcf && bcr+1<hcr): (bcr >= bcf && bcr > 0)) { baselines[(int)Corners.Right] += hts; } if(hts > 0 ? (bcf <= bcr && bcf+1<hcf) : (bcf >= bcr && bcf > 0)) { baselines[(int)Corners.Front] += hts; } } if((mask & Neighbors.BackRight) != 0) { if(hts > 0 ? (bcr <= bcb && bcr+1<hcr) : (bcr >= bcb && bcr > 0)) { baselines[(int)Corners.Right] += hts; } if(hts > 0 ? (bcb <= bcr && bcb+1<hcb) : (bcb >= bcr && bcb > 0)) { baselines[(int)Corners.Back] += hts; } } if((mask & Neighbors.BackLeft) != 0) { if(hts > 0 ? (bcl <= bcb && bcl+1<hcl) : (bcl >= bcb && bcl > 0)) { baselines[(int)Corners.Left] += hts; } if(hts > 0 ? (bcb <= bcl && bcb+1<hcb) : (bcb >= bcl && bcb > 0)) { baselines[(int)Corners.Back] += hts; } } while(baselines[(int)Corners.Left] > 0 && baselines[(int)Corners.Front] > 0 && baselines[(int)Corners.Right] > 0 && baselines[(int)Corners.Back] > 0) { baselines[(int)Corners.Left]--; baselines[(int)Corners.Front]--; baselines[(int)Corners.Right]--; baselines[(int)Corners.Back]--; z++; } } ht -= hts; } }
public void AddEdge(GraphNode <T> graphNode) { Neighbors.Add(graphNode); }
/// <summary> /// Checks to see if given Region is a neighbor to this region. /// </summary> /// <param name="region"></param> /// <returns>True if this Region is a neighbor of given Region, false otherwise.</returns> public bool IsNeighbor(Region region) { return(Neighbors.Contains(region)); }
public void AddNeighbor(Vertex <T> vertex) { Neighbors.Add(vertex); }
private Neighbors GetBubbleNeighbors(Dimension gridPos, bool isShifted) { var neighbors = new Neighbors(); neighbors.Initialize(); //Left & Right neighbors.left.bubble = gridPos.columns > 0 ? this._gridBubbles[gridPos.rows, gridPos.columns - 1] : null; neighbors.left.gridPosition = new Dimension(gridPos.rows, gridPos.columns - 1); neighbors.left.canUseIt = gridPos.columns > 0; neighbors.right.bubble = (gridPos.columns + 1) < gridDimension.columns ? this._gridBubbles[gridPos.rows, gridPos.columns + 1] : null; neighbors.right.gridPosition = new Dimension(gridPos.rows, gridPos.columns + 1); neighbors.right.canUseIt = (gridPos.columns + 1) < gridDimension.columns; //- Top Right & Left if (gridPos.rows > 0) { if (isShifted) { neighbors.topLeft.gridPosition = new Dimension(gridPos.rows - 1, gridPos.columns); neighbors.topLeft.bubble = this._gridBubbles[gridPos.rows - 1, gridPos.columns]; neighbors.topRight.gridPosition = new Dimension(gridPos.rows - 1, gridPos.columns + 1); neighbors.topRight.bubble = (gridPos.columns + 1) < gridDimension.columns ? this._gridBubbles[gridPos.rows - 1, gridPos.columns + 1] : null; } else { neighbors.topLeft.gridPosition = new Dimension(gridPos.rows - 1, gridPos.columns - 1); neighbors.topLeft.bubble = (gridPos.columns - 1) >= 0 ? this._gridBubbles[gridPos.rows - 1, gridPos.columns - 1] : null; neighbors.topRight.gridPosition = new Dimension(gridPos.rows - 1, gridPos.columns); neighbors.topRight.bubble = this._gridBubbles[gridPos.rows - 1, gridPos.columns]; } } else { neighbors.topLeft.canUseIt = false; neighbors.topRight.canUseIt = false; neighbors.topLeft.bubble = null; neighbors.topRight.bubble = null; } //- Down Left & Right if ((gridPos.rows + 1) >= gridDimension.rows) { if (isShifted) { neighbors.downLeft.canUseIt = true; neighbors.downRight.canUseIt = ((gridPos.columns + 1) < gridDimension.columns); } else { neighbors.downLeft.canUseIt = gridPos.columns > 0; neighbors.downRight.canUseIt = true; } neighbors.downLeft.bubble = null; neighbors.downRight.bubble = null; } else { if (isShifted) { neighbors.downLeft.gridPosition = new Dimension(gridPos.rows + 1, gridPos.columns); neighbors.downLeft.bubble = this._gridBubbles[gridPos.rows + 1, gridPos.columns]; neighbors.downLeft.canUseIt = true; neighbors.downRight.gridPosition = new Dimension(gridPos.rows + 1, gridPos.columns + 1); neighbors.downRight.bubble = ((gridPos.columns + 1) < gridDimension.columns) ? this._gridBubbles[gridPos.rows + 1, gridPos.columns + 1] : null; neighbors.downRight.canUseIt = ((gridPos.columns + 1) < gridDimension.columns); } else { neighbors.downLeft.gridPosition = new Dimension(gridPos.rows + 1, gridPos.columns - 1); neighbors.downLeft.bubble = (gridPos.columns > 0) ? this._gridBubbles[gridPos.rows + 1, gridPos.columns - 1] : null; neighbors.downLeft.canUseIt = gridPos.columns > 0; neighbors.downRight.gridPosition = new Dimension(gridPos.rows + 1, gridPos.columns); neighbors.downRight.bubble = this._gridBubbles[gridPos.rows + 1, gridPos.columns]; neighbors.downRight.canUseIt = true; } } return(neighbors); }
public void RemovePeer(Peer toRemove) { Neighbors.Remove(toRemove); MessageState.SentMessages.Remove(toRemove); }
public virtual void AddNeighbor(Vertex <T> neighbor) { Neighbors.Add(neighbor); neighbor.Neighbors.Add(this); }
public int[] GetNeighboursIDs() { return(Neighbors.Select(s => s.NeighborNode.ID).ToArray()); }
public Neighbor[] GetNeighbours() { return(Neighbors.ToArray()); }
public void Add(Node neighbor) { Neighbors.Add(neighbor); }
/// <summary> /// Adds an edge based on the data in the passed-in EdgeToNeighbor instance. /// </summary> internal void AddDirected(EdgeToNeighbor e) { Neighbors.Add(e); }
private bool HasNeighbor(int[] node, int[] neighbor, out Neighbors node_dir, out Neighbors neighbor_dir) { node_dir = Neighbors.N; neighbor_dir = Neighbors.S; int dx = neighbor[0] - node[0]; int dy = neighbor[1] - node[1]; if (dy > 0) { if (dx < 0) { node_dir = Neighbors.NW; neighbor_dir = Neighbors.SE; } else if (dx == 0) { node_dir = Neighbors.N; neighbor_dir = Neighbors.S; } else /* if (dx > 0) */ { node_dir = Neighbors.NE; neighbor_dir = Neighbors.SW; } } else if (dy == 0) { if (dx < 0) { node_dir = Neighbors.W; neighbor_dir = Neighbors.E; } else if (dx == 0) { return false; } else /* if (dx > 0) */ { node_dir = Neighbors.E; neighbor_dir = Neighbors.W; } } else /* if (dy < 0) */ { if (dx < 0) { node_dir = Neighbors.SW; neighbor_dir = Neighbors.NE; } else if (dx == 0) { node_dir = Neighbors.S; neighbor_dir = Neighbors.N; } else /* if (dx > 0) */ { node_dir = Neighbors.SE; neighbor_dir = Neighbors.NW; } } if (!HasSurface (node) || !HasSurface (neighbor)) { return false; } bool nodeOpen = !IndexConnectable (node); bool neighborOpen = !IndexConnectable (neighbor); bool nodeBridged = IsBridged (node); bool neighborBridged = IsBridged (neighbor); if (nodeOpen && neighborOpen) { return true; } Edge nodeEdge = Edge.North; Edge neighborEdge = Edge.South; // only allow diagonals if both surfaces are open as above if (dx != 0 && dy != 0) { return false; } else if (dx > 0) { nodeEdge = Edge.East; neighborEdge = Edge.West; } else if (dx < 0) { nodeEdge = Edge.West; neighborEdge = Edge.East; } else if (dy > 0) { nodeEdge = Edge.North; neighborEdge = Edge.South; } else if (dy < 0) { nodeEdge = Edge.South; neighborEdge = Edge.North; } bool nodeConnection = EdgeConnectable (node, nodeEdge); bool neighborConnection = EdgeConnectable (neighbor, neighborEdge); if (nodeConnection && neighborConnection && (nodeBridged || neighborBridged)) { return true; } if (!nodeConnection && !neighborConnection && !(nodeBridged || neighborBridged)) { return true; } return false; }
public bool IsAdjacentTo(Vertex v) { return(Neighbors.Any(n => n.Id == v.Id)); }
/// <summary> /// Updates the node. This will copy data from another node into this node. Updated elements are checked for equality /// and the method will only return true if the node data has been changed. /// /// <param name="node">the <see cref="ZigBeeNode"> that contains the newer node data.</param> /// <returns>true if there were changes made as a result of the update</returns> /// </summary> public bool UpdateNode(ZigBeeNode node) { if (!node.IeeeAddress.Equals(IeeeAddress)) { Log.Debug("{IeeeAddress}: Ieee address inconsistent during update <>{NodeIeeeAddress}", IeeeAddress, node.IeeeAddress); return(false); } bool updated = false; if (NetworkAddress != 0 && !NetworkAddress.Equals(node.NetworkAddress)) { Log.Debug("{IeeeAddress}: Network address updated from {NetworkAddress} to {NodeNetworkAddress}", IeeeAddress, NetworkAddress, node.NetworkAddress); updated = true; NetworkAddress = node.NetworkAddress; } if (node.NodeDescriptor != null && (NodeDescriptor == null || !NodeDescriptor.Equals(node.NodeDescriptor))) { Log.Debug("{IeeeAddress}: Node descriptor updated", IeeeAddress); updated = true; NodeDescriptor = node.NodeDescriptor; } if (node.PowerDescriptor != null && (PowerDescriptor == null || !PowerDescriptor.Equals(node.PowerDescriptor))) { Log.Debug("{IeeeAddress}: Power descriptor updated", IeeeAddress); updated = true; PowerDescriptor = node.PowerDescriptor; } lock (AssociatedDevices) { if (!AssociatedDevices.SetEquals(node.AssociatedDevices)) { Log.Debug("{IeeeAddress}: Associated devices updated", IeeeAddress); updated = true; AssociatedDevices.Clear(); AssociatedDevices.UnionWith(node.AssociatedDevices); } } lock (BindingTable) { if (!BindingTable.SetEquals(node.BindingTable)) { Log.Debug("{IeeeAddress}: Binding table updated", IeeeAddress); updated = true; BindingTable.Clear(); BindingTable.UnionWith(node.BindingTable); } } lock (Neighbors) { if (!Neighbors.SetEquals(node.Neighbors)) { Log.Debug("{IeeeAddress}: Neighbors updated", IeeeAddress); updated = true; Neighbors.Clear(); Neighbors.UnionWith(node.Neighbors); } } lock (Routes) { if (!Routes.SetEquals(node.Routes)) { Log.Debug("{IeeeAddress}: Routes updated", IeeeAddress); updated = true; Routes.Clear(); Routes.UnionWith(node.Routes); } } // Endpoints are only copied over if they don't exist in the node // The assumption here is that endpoints are only set once, and not changed. // This should be valid as they are set through the SimpleDescriptor. foreach (var endpoint in node.Endpoints) { if (Endpoints.ContainsKey(endpoint.Key)) { continue; } Log.Debug("{IeeeAddress}: Endpoint {EndpointId} added", IeeeAddress, endpoint.Key); updated = true; Endpoints[endpoint.Key] = endpoint.Value; } return(updated); }
public float LowestHeightAt(Neighbors side) { int hcl = heights[(int)Corners.Left]; int hcf = heights[(int)Corners.Front]; int hcr = heights[(int)Corners.Right]; int hcb = heights[(int)Corners.Back]; switch(side) { case Neighbors.FrontLeftIdx: return Mathf.Min(hcl, hcf)+this.z; case Neighbors.FrontRightIdx: return Mathf.Min(hcr, hcf)+this.z; case Neighbors.BackLeftIdx: return Mathf.Min(hcl, hcb)+this.z; case Neighbors.BackRightIdx: return Mathf.Min(hcr, hcb)+this.z; default: Debug.LogError("given neighbor is not a side edge: "+side); return this.z; } }
public Boolean hasNeighbor(NeighborLocation loc) { return(Neighbors.ContainsKey(loc)); }
public void AddNehigbors(NodeOtelloPiece node) //ta in min pos hitta grannar { Neighbors.Enqueue(node); }
/// <summary>Runs the A* search algorithm algorithm on a graph.</summary> /// <param name="start">The node to start at.</param> /// <param name="neighbors">Delegate for gettign the neighbors of a node.</param> /// <param name="heuristic">Computes the heuristic value of a given node in a graph.</param> /// <param name="cost">Computes the cost of moving from the current node to a specific neighbor.</param> /// <param name="goal">The goal node.</param> /// <returns>Stepper of the shortest path or null if no path exists.</returns> public static Stepper <T> Astar(T start, Neighbors neighbors, Heuristic heuristic, Cost cost, T goal) { return(Astar(start, neighbors, heuristic, cost, goal, Equate.Default)); }
public void RemoveRouter(Router router) { Neighbors.Remove(router); Network.RemoveNode(router.Id); ReceiveUpdate(new LinkStateAdvertisement(LinkStateAdvertisement.Counter, Id, Network)); }
/// <summary>Runs the A* search algorithm algorithm on a graph.</summary> /// <param name="start">The node to start at.</param> /// <param name="neighbors">Delegate for gettign the neighbors of a node.</param> /// <param name="heuristic">Computes the heuristic value of a given node in a graph.</param> /// <param name="cost">Computes the cost of moving from the current node to a specific neighbor.</param> /// <param name="goal">The goal node.</param> /// <param name="equate">A delegate for checking for equality between two nodes.</param> /// <returns>Stepper of the shortest path or null if no path exists.</returns> public static Stepper <T> Astar(T start, Neighbors neighbors, Heuristic heuristic, Cost cost, T goal, Equate <T> equate) { return(Astar(start, neighbors, heuristic, cost, (T node) => { return equate(node, goal); })); }
void UVMap(MapTile t, Neighbors side, Vector2[] uvs, int idx) { if(uvs == null) { return; } int specIdx; if(t.tileSpecs == null || t.tileSpecs.Length == 0) { specIdx = -1; } else { switch(side) { case Neighbors.FrontLeft: specIdx = t.tileSpecs[0]; break; case Neighbors.FrontRight: specIdx = t.tileSpecs[1]; break; case Neighbors.BackRight: specIdx = t.tileSpecs[2]; break; case Neighbors.BackLeft: specIdx = t.tileSpecs[3]; break; case Neighbors.Bottom: specIdx = t.tileSpecs[4]; break; case Neighbors.Top: specIdx = t.tileSpecs[5]; break; default: specIdx = -1; break; } } if(specIdx == -1 || specIdx >= tileSpecs.Count || tileSpecs[specIdx] == null || tileSpecs[specIdx].texture == null) { uvs[idx+0] = new Vector2(0,0); uvs[idx+1] = new Vector2(0,0); uvs[idx+2] = new Vector2(0,0); uvs[idx+3] = new Vector2(0,0); } else { /* TileSpec spec = tileSpecs[specIdx];*/ Rect rect = tileRects[specIdx]; Vector2 ul = new Vector2(rect.x, rect.y); Vector2 ll = new Vector2(rect.x, rect.yMax); Vector2 ur = new Vector2(rect.xMax, rect.y); Vector2 lr = new Vector2(rect.xMax, rect.yMax); if(side == Neighbors.FrontLeft) { uvs[idx+0] = ll; uvs[idx+1] = lr; uvs[idx+2] = ul; uvs[idx+3] = ur; } else if(side == Neighbors.BackLeft) { uvs[idx+0] = lr; uvs[idx+1] = ur; uvs[idx+2] = ll; uvs[idx+3] = ul; } else if(side == Neighbors.BackRight) { uvs[idx+0] = ur; uvs[idx+1] = ul; uvs[idx+2] = lr; uvs[idx+3] = ll; } else if(side == Neighbors.Bottom) { uvs[idx+0] = lr; uvs[idx+1] = ur; uvs[idx+2] = ll; uvs[idx+3] = ul; } else { //works for front-right and top uvs[idx+0] = ul; uvs[idx+1] = ll; uvs[idx+2] = ur; uvs[idx+3] = lr; } } }
/// <summary>Runs the Greedy search algorithm algorithm on a graph.</summary> /// <param name="start">The node to start at.</param> /// <param name="neighbors">Step function for all neigbors of a given node.</param> /// <param name="heuristic">Computes the heuristic value of a given node in a graph.</param> /// <param name="goal">Predicate for determining if we have reached the goal node.</param> /// <returns>Stepper of the shortest path or null if no path exists.</returns> public static Stepper <T> Greedy(T start, Neighbors neighbors, Heuristic heuristic, T goal) { return(Greedy(start, neighbors, heuristic, goal, Equate.Default)); }
public void InsetSidesOfTile(int x, int y, int z, float inset, Neighbors mask) { MapTile t = TileAt(x,y,z); if(t != null) { t.InsetSides(inset, mask); RemakeMesh(); } }
/// <summary>Runs the Greedy search algorithm algorithm on a graph.</summary> /// <param name="start">The node to start at.</param> /// <param name="neighbors">Step function for all neigbors of a given node.</param> /// <param name="heuristic">Computes the heuristic value of a given node in a graph.</param> /// <param name="goal">Predicate for determining if we have reached the goal node.</param> /// <param name="equate">Delegate for checking for equality between two nodes.</param> /// <returns>Stepper of the shortest path or null if no path exists.</returns> public static Stepper <T> Greedy(T start, Neighbors neighbors, Heuristic heuristic, T goal, Equate <T> equate) { return(Greedy(start, neighbors, heuristic, (T node) => { return equate(node, goal); })); }
/// <summary> /// Calculates a path on the graph /// If the path is optimal is dependent on the heuristic implemented in the graph /// </summary> /// <param name="graph">IGraph implementation to search the path on</param> /// <param name="start">node in IGraph where the algorithm should start</param> /// <param name="goal">node in IGraph where the path should lead</param> /// <returns>List of integers wich correspond with the node id's in the IGraph implementation</returns> public static List <int> AStarSearch(IGraph graph, int start, int goal) { if (start == -1) { throw new System.ArgumentException("Parameter must be equal or larger than zero", "start"); } else if (goal == -1) { throw new System.ArgumentException("Parameter must be equal or larger than zero", "goal"); } IPriorityQueue priorityQueue = new MinHeap(); Dictionary <int, int> cameFrom = new Dictionary <int, int>(); Dictionary <int, double> costSoFar = new Dictionary <int, double>(); List <int> path = new List <int>(); Neighbors component = new Neighbors(); double newCost; double priority; int current; priorityQueue.Add(start, 0); cameFrom[start] = start; costSoFar[start] = 0; // as long as unvisited nodes are available do { // get element with the best value and remove it from the unvisited nodes current = priorityQueue.Poll(); // test if the current node is the goal if (current == goal) { break; } if (!graph.HasComponent <Neighbors>(current)) { continue; } component = graph.GetComponent <Neighbors>(current); // go through all nodes that are directly connected to the current one foreach (int next in component.GetNeighbors()) { // calculate cost for the current node newCost = costSoFar[current] + component.GetCost(next); // only add the node when it does not exist or when the cost is smaller than the current cost if (!costSoFar.ContainsKey(next) || newCost < costSoFar[next]) { // calculate priority and add node to frontier costSoFar[next] = newCost; priority = newCost + graph.Heuristic(next, goal); priorityQueue.Add(next, priority); cameFrom[next] = current; } } }while (priorityQueue.Size() > 0); // reconstruct path by folloing cameFrom from the goal to the start path.Add(current); while (cameFrom[current] != start) { path.Add(cameFrom[current]); current = cameFrom[current]; } path.Add(cameFrom[current]); path.Reverse(); return(path); }
public void AddEdge(Vertex <T> vertex) => Neighbors.Add(vertex);
public void AddNeighbor(GraphNode neighbor) { Neighbors.Add(neighbor); }
public void AddEdges(params Vertex <T>[] newNeighbors) => Neighbors.AddRange(newNeighbors);
public void AddNeighborVertex(Edge <T> e) { Edges.Add(e); Neighbors.Add(e.RightVertex); }
public void AddEdges(IEnumerable <Vertex <T> > newNeighbors) => Neighbors.AddRange(newNeighbors);
void AdjustIsoHeightAt(int idx, Neighbors collidedFace, Vector3 wpos, int dh) { Map m = (Map)target; int ny = idx/(int)m.size.x; int nx = idx-(ny*(int)m.size.x); int nz = editZ; MapTile t = m.TileAt(nx,ny,nz); if(t==null) { return; } Vector3 tpos = m.InverseTransformPointWorld(wpos); Neighbors side = Neighbors.None; //get the fractional part of each coord /* Debug.Log("adjust height at "+nx+","+ny+","+nz+", tpos "+tpos+", wpos "+wpos);*/ tpos.x = modf(tpos.x); tpos.y = modf(tpos.y); //tpos.z = modf(tpos.z); bool top = tpos.z > t.z + (t.maxHeight-t.z)/2; /* Debug.Log("tpos frac "+tpos.x+", "+tpos.y+", "+tpos.z);*/ if((collidedFace & Neighbors.FrontLeft) != 0) { side = Neighbors.FrontLeft; } else if((collidedFace & Neighbors.FrontRight) != 0) { side = Neighbors.FrontRight; } else if((collidedFace & Neighbors.BackRight) != 0) { side = Neighbors.BackRight; } else if((collidedFace & Neighbors.BackLeft) != 0) { side = Neighbors.BackLeft; } else { //top or bottom top = (collidedFace & Neighbors.Top) != 0; if(tpos.x < 0.3 && tpos.y < 0.75 && tpos.y > 0.25) { side = Neighbors.FrontLeft; } else if(tpos.x > 0.3 && tpos.y < 0.75 && tpos.y > 0.25) { side = Neighbors.BackRight; } else if(tpos.y < 0.3 && tpos.x < 0.75 && tpos.x > 0.25) { side = Neighbors.FrontRight; } else if(tpos.y > 0.3 && tpos.x < 0.75 && tpos.x > 0.25) { side = Neighbors.BackLeft; } } RegisterUndo("Adjust Tile Height"); m.AdjustHeightOnSidesOfTile(nx, ny, nz, dh, side, top); EditorUtility.SetDirty(target); }
public void RemoveEdge(Vertex <T> vertex) => Neighbors.Remove(vertex);
void SetTileSpecAt(int idx, Neighbors collidedFace) { Map m = (Map)target; int ny = idx/(int)m.size.x; int nx = idx-(ny*(int)m.size.x); int nz = editZ; RegisterUndo("Paint Tile"); m.SetTileSpecOnTileAt(specSelectedSpec, nx, ny, nz, collidedFace); EditorUtility.SetDirty(target); }
public override string ToString() => Neighbors.Aggregate(new StringBuilder($"{Value}: "), (sb, n) => sb.Append($"{n.Value} -> ")).ToString();
public void InsetSides(float inset, Neighbors mask) { if(sideInsets == null || sideInsets.Length == 0) { sideInsets = new float[]{0,0,0,0,0,0}; } if((mask & Neighbors.FrontLeft) != 0) { sideInsets[0] = inset; } if((mask & Neighbors.FrontRight) != 0) { sideInsets[1] = inset; } if((mask & Neighbors.BackRight) != 0) { sideInsets[2] = inset; } if((mask & Neighbors.BackLeft) != 0) { sideInsets[3] = inset; } if((mask & Neighbors.Bottom) != 0) { sideInsets[4] = inset; } if((mask & Neighbors.Top) != 0) { sideInsets[5] = inset; } }
/// <summary> /// Updates the node. This will copy data from another node into this node. Updated elements are checked for equality /// and the method will only return true if the node data has been changed. /// /// <param name="node">the <see cref="ZigBeeNode"> that contains the newer node data.</param> /// <returns>true if there were changes made as a result of the update</returns> /// </summary> public bool UpdateNode(ZigBeeNode node) { if (!node.IeeeAddress.Equals(IeeeAddress)) { return(false); } bool updated = false; if (!NetworkAddress.Equals(node.NetworkAddress)) { updated = true; NetworkAddress = node.NetworkAddress; } if (!NodeDescriptor.Equals(node.NodeDescriptor)) { updated = true; NodeDescriptor = node.NodeDescriptor; } if (!PowerDescriptor.Equals(node.PowerDescriptor)) { updated = true; PowerDescriptor = node.PowerDescriptor; } lock (AssociatedDevices) { if (!AssociatedDevices.Equals(node.AssociatedDevices)) { updated = true; AssociatedDevices.Clear(); AssociatedDevices.AddRange(node.AssociatedDevices); } } lock (BindingTable) { if (!BindingTable.Equals(node.BindingTable)) { updated = true; BindingTable.Clear(); BindingTable.AddRange(node.BindingTable); } } lock (Neighbors) { if (!Neighbors.Equals(node.Neighbors)) { updated = true; Neighbors.Clear(); Neighbors.AddRange(node.Neighbors); } } lock (Routes) { if (!Routes.Equals(node.Routes)) { updated = true; Routes.Clear(); Routes.AddRange(node.Routes); } } // TODO: How to deal with endpoints return(updated); }
public void SetTileSpecOnSides(int spec, Neighbors mask) { if(tileSpecs == null || tileSpecs.Length == 0) { tileSpecs = new int[]{-1, -1, -1, -1, -1, -1}; } if((mask & Neighbors.FrontLeft) != 0) { tileSpecs[0] = spec; } if((mask & Neighbors.FrontRight) != 0) { tileSpecs[1] = spec; } if((mask & Neighbors.BackRight) != 0) { tileSpecs[2] = spec; } if((mask & Neighbors.BackLeft) != 0) { tileSpecs[3] = spec; } if((mask & Neighbors.Bottom) != 0) { tileSpecs[4] = spec; } if((mask & Neighbors.Top) != 0) { tileSpecs[5] = spec; } }
private void DoNeighbor(Tile tile, Neighbors neighbor) { Tile target = GetNeighbor(tile, neighbor); if (target != null) { if (target.isCovered () && !target.isMine ()) { target.Uncover (); if (target.Value == 0) { DoUncover (target); } } } }