/// <summary> /// General left rotation /// </summary> /// <param name="node">top of rotated subtree</param> private void RotateLeft(IntervalNode <TKey, TValue> node) { var pivot = node.Right; NodeDirection dir = node.ParentDirection; var parent = node.Parent; var tempTree = pivot.Left; pivot.Left = node; node.Parent = pivot; node.Right = tempTree; if (tempTree != Sentinel) { tempTree.Parent = node; } if (dir == NodeDirection.LEFT) { parent.Right = pivot; } else if (dir == NodeDirection.RIGHT) { parent.Left = pivot; } else { Root = pivot; } pivot.Parent = parent; pivot.RecalculateMaxEnd(); node.RecalculateMaxEnd(); }
public void AddChild(BinaryTreeNode btn, NodeDirection nd) { btn.Parent = this; if(nd == NodeDirection.Left) this.LeftChild = btn; else this.RightChild = btn; }
public override void ConnectNodeToBlock(NodeDirection dir, BuildingBlock bb) { if (dir == NodeDirection.Bottom) { nextBuildingBlock = bb; } else { throw new ArgumentOutOfRangeException(); } }
public Node(float outputCooldown, int leftDownTileID, int rightDownTileID, NodeDirection direction, InputStrategy inputStrategy, ProcessStrategy processStrategy, OutputStrategy outputStrategy) : this(outputCooldown) { LeftDownTileID = leftDownTileID; RightDownTileID = rightDownTileID; Direction = direction; _inputStrategy = inputStrategy; _outputStrategy = outputStrategy; _processStrategy = processStrategy; }
public void AgragandoHijo(BinaryTreeNode btn, NodeDirection nd) { btn.Padre = this; if (nd == NodeDirection.Left) { this.IzqHijo = btn; } else { this.DerHijo = btn; } }
public override Point GetNode(NodeDirection dir) { switch (dir) { case NodeDirection.Top: return(new Point(this.rec.Location.X + this.rec.Width / 2, this.rec.Location.Y)); case NodeDirection.Bottom: return(new Point(this.rec.Location.X + this.rec.Width / 2, this.rec.Location.Y + this.rec.Height)); default: throw new ArgumentOutOfRangeException(); } }
private void AssignPatch(ref QuadTreeNode node, NodeDirection nodeDirection, int topLeftVertex, int topRightVertex, int bottomLeftVertex, int bottomRightVertex) { List <Vector3> vertices = new List <Vector3>(); List <Vector2> uvCoor = new List <Vector2>(); for (int z = topLeftVertex; z <= bottomLeftVertex; z += terrainRef.Width) { for (int x = z; x < (z + (topRightVertex - topLeftVertex) + 1); x++) { vertices.Add(terrainRef.Vertices[x]); uvCoor.Add(terrainRef.uvCoordinates[x]); } } node.Patch = new TerrainPatch((node.Level * 10) + (int)nodeDirection, node.BoundingBox2D, vertices, uvCoor, topRightVertex - topLeftVertex); }
public override void ConnectNodeToBlock(NodeDirection dir, BuildingBlock bb) { switch (dir) { case NodeDirection.Left: nextTrueBlock = bb; break; case NodeDirection.Right: nextFalseBlock = bb; break; default: throw new ArgumentOutOfRangeException(); } }
bool TestEnemyDirection(Node tNode, int step, NodeDirection direction) { switch (direction) { case NodeDirection.North: if (tNode.NorthNode != null && tNode.NorthNode.EnemyVisited == step) { return(true); } else { return(false); } case NodeDirection.East: if (tNode.EastNode != null && tNode.EastNode.EnemyVisited == step) { return(true); } else { return(false); } case NodeDirection.South: if (tNode.SouthNode != null && tNode.SouthNode.EnemyVisited == step) { return(true); } else { return(false); } case NodeDirection.West: if (tNode.WestNode != null && tNode.WestNode.EnemyVisited == step) { return(true); } else { return(false); } } return(false); }
public override Point GetNode(NodeDirection dir) { switch (dir) { case NodeDirection.Top: return(points[2]); case NodeDirection.Bottom: return(points[0]); case NodeDirection.Left: return(points[1]); case NodeDirection.Right: return(points[3]); default: throw new ArgumentOutOfRangeException(); } }
public static Node GetConveyour(NodeDirection direction) { return new Node(600f, 10, 11, direction, new StandartInput(), new StandartProcess(), new StandartOutput()); }
public abstract void ConnectNodeToBlock(NodeDirection dir, BuildingBlock bb);
public NodeTarget(ITreeItem node, NodeDirection direction) { this.node = node; this.direction = direction; }
public Node GetNode(NodeDirection direction, GridDirection compass) { return(nodes.Find(ni => ni.boundDirect == direction && ni.compassDirection == compass)); }
public abstract Point GetNode(NodeDirection dir);
public static Node GetRockMine(NodeDirection direction) { float outputCD = new Random().Next(1000, 1500); return new Node(outputCD, 12, 12, direction, new NoInput(), new GenerateRock(), new StandartOutput()); }
private void AssignPatch(ref QuadTreeNode node, NodeDirection nodeDirection, int topLeftVertex, int topRightVertex, int bottomLeftVertex, int bottomRightVertex) { List<Vector3> vertices = new List<Vector3>(); List<Vector2> uvCoor = new List<Vector2>(); for (int z = topLeftVertex; z <= bottomLeftVertex; z += terrainRef.Width) { for (int x = z; x < (z + (topRightVertex - topLeftVertex) + 1); x++) { vertices.Add(terrainRef.Vertices[x]); uvCoor.Add(terrainRef.uvCoordinates[x]); } } node.Patch = new TerrainPatch((node.Level * 10) + (int)nodeDirection, node.BoundingBox2D, vertices, uvCoor, topRightVertex - topLeftVertex); }
public NodeDistance(NodeDirection nodes, float distance) { this.nodes = nodes; this.distance = distance; }
public static Node Tower(NodeDirection direction) { return new Node(200, 15, 15, direction, new StandartInput(), new StandartProcess(), new NoOutput()); }
List <Vector2> OptomisePath(List <Vector2> inPath) { // If the path finding algo returns a path, optomise it so that any series of nodes in a line are compressed to a single node/destination for the enemy player. if (inPath == null || inPath.Count == 0) { return(new List <Vector2>()); } else { List <Vector2> optomisedPath = new List <Vector2>(); Vector2 startPosition; Vector2 lastNode = new Vector2(0, 0); Vector2 destinationNode = new Vector2(0, 0); NodeDirection nodeDirection = NodeDirection.Unset; NodeDirection lastNodeDirection = NodeDirection.Unset; // NodeDirection lineDirection; startPosition = inPath.First <Vector2>(); // pop off the first element to prime the loop lastNode = inPath.First <Vector2>(); optomisedPath.Add(inPath.First <Vector2>()); inPath.Remove(inPath.First <Vector2>()); for (int i = 0; i < inPath.Count; i++) // This is processed forwards and builds a List of vectors to be returned along the way, which is exactly what the enemy character expects. { Vector2 Node = inPath[i]; Vector2 difference = Node - lastNode; if (difference.X == 16) { nodeDirection = NodeDirection.Right; } else if (difference.X == -16) { nodeDirection = NodeDirection.Left; } else if (difference.Y == 16) { nodeDirection = NodeDirection.Down; } else if (difference.Y == -16) { nodeDirection = NodeDirection.Up; } else { Debug.Assert(true); } // If we've changed direction, store the position in the optomised path. if (lastNodeDirection != NodeDirection.Unset && lastNodeDirection != nodeDirection) { optomisedPath.Add(startPosition); startPosition = Node; } else { startPosition = startPosition + difference; } lastNodeDirection = nodeDirection; lastNode = Node; } // Add the final position optomisedPath.Add(startPosition); return(optomisedPath); } }