public void Activity(NodeNetwork nodeNetwork) { //If SHIFT+C is down, make the line visible and redraw it, otherwise make it invisible. if (InputManager.Keyboard.KeyDown(Keys.C) && (InputManager.Keyboard.KeyDown(Keys.LeftShift) || (InputManager.Keyboard.KeyDown(Keys.RightShift)))) { this.RelativePoint1.X = mMousePosition.X = InputManager.Mouse.WorldXAt(1); this.RelativePoint1.Y = mMousePosition.Y = InputManager.Mouse.WorldYAt(1); mNode = nodeNetwork.GetClosestNodeTo(ref mMousePosition); if (mNode != null) { this.RelativePoint2.X = mNode.Position.X; this.RelativePoint2.Y = mNode.Position.Y; this.Visible = true; } } else { this.Visible = false; } }
private void GetLinkOver(ref Link linkOver, ref PositionedNode linkOverParent) { Cursor cursor = GuiManager.Cursor; float worldX; float worldY; if (EditorData.NodeNetwork.Nodes.Count != 0) { float tolerance = 5 / SpriteManager.Camera.PixelsPerUnitAt(0); for (int i = 0; i < EditorData.NodeNetwork.Nodes.Count; i++) { PositionedNode node = EditorData.NodeNetwork.Nodes[i]; worldX = cursor.WorldXAt(node.Z); worldY = cursor.WorldYAt(node.Z); for (int linkIndex = 0; linkIndex < node.Links.Count; linkIndex++) { Segment segment = new Segment( node.Position, node.Links[linkIndex].NodeLinkingTo.Position); float distance = segment.DistanceTo(worldX, worldY); if (distance < tolerance) { linkOverParent = node; linkOver = node.Links[linkIndex]; return; } } } } linkOverParent = null; linkOver = null; }
private void PerformKeyboardShortcuts() { if (InputManager.Keyboard.KeyPushedConsideringInputReceiver(Keys.Delete)) { #region Delete Nodes if (mCurrentNodes.Count != 0) { for (int i = 0; i < mCurrentNodes.Count; i++) { EditorData.NodeNetwork.Remove(mCurrentNodes[i]); } EditorData.NodeNetwork.UpdateShapes(); SelectNode(null); } #endregion #region Delete Links if (mCurrentLink != null) { PositionedNode firstNode = mCurrentLinkParent; PositionedNode otherNode = mCurrentLink.NodeLinkingTo; firstNode.BreakLinkBetween(otherNode); EditorData.NodeNetwork.UpdateShapes(); SelectLink(null, null); } #endregion } }
private void GetObjectsOver() { mNodeOver = GetNodeOver(); if (mNodeOver != null) { mLinkOver = null; mLinkOverParent = null; } else { GetLinkOver(ref mLinkOver, ref mLinkOverParent); } }
void SelectLink(Link linkToSelect, PositionedNode linkParent) { mCurrentLink = linkToSelect; mCurrentLinkParent = linkParent; }
public void SelectNode(PositionedNode nodeToSelect) { #region Finding path between two nodes if (GuiData.ToolsWindow.IsFindPathToNodeButtonPressed && mCurrentNodes.Count != 0 && nodeToSelect != null) { // The button should come back up GuiData.ToolsWindow.IsFindPathToNodeButtonPressed = false; List<PositionedNode> positionedNodes = EditorData.NodeNetwork.GetPath(mCurrentNodes[0], nodeToSelect); mPathDisplay.ShowPath(positionedNodes); if (positionedNodes.Count == 0) { GuiManager.ShowMessageBox("The two nodes are not connected by links.", "Not Connected"); } } #endregion #region else, simply selecting node else { mCurrentNodes.Clear(); if (nodeToSelect != null) { mCurrentNodes.Add(nodeToSelect); } } #endregion }
public static Level MakeLevelFromShapes(List <PositionedShape> positionedShapes, int extraEdges, string levelName) { // initialise triangles int numTriangles = positionedShapes .Select(s => s.triangles.GetLength(0)) .Sum(); List <Int3> solution = new List <Int3>(); // initialise nodes int numNodes = positionedShapes .Select(s => s.nodes.Length) .Sum(); PositionedNode[] nodes = new PositionedNode[numNodes]; int nodeNum = 0; int edges = 0; foreach (var shape in positionedShapes) { // generate the solution from triangles given in shapes for (int i = 0; i < shape.triangles.GetLength(0); i++) { solution.Add( new Int3 ( shape.triangles[i, 0] + nodeNum, shape.triangles[i, 1] + nodeNum, shape.triangles[i, 2] + nodeNum ) ); edges += 3; } // node creation for (int j = 0; j < shape.nodes.Length; j++) { PositionedNode node = new PositionedNode { type = shape.nodeTypes[j], position = shape.nodes[j] }; nodes[nodeNum++] = node; } } Level level = new Level(); level.nodes = nodes; level.maxEdges = edges + extraEdges; level.solution = solution; string assetPath = Path.Combine("Assets/Objects/Levels", string.Format("{0}.asset", levelName)); AssetDatabase.CreateAsset(level, assetPath); return(level); }
public NodeConnection(PositionedNode positionedNode, float cost, string nodeLinkingTo) { PositionedNode = positionedNode; Cost = cost; NodeLinkingTo = nodeLinkingTo; }
public NodeNetwork ToNodeNetwork(bool linkHorizontally, bool linkVertically, bool linkDiagonally, bool requireTile) { var toReturn = new NodeNetwork(); int layercount = 0; foreach (MapLayer mapLayer in this.Layers) { if (!mapLayer.IsVisible) { switch (mapLayer.VisibleBehavior) { case LayerVisibleBehavior.Ignore: break; case LayerVisibleBehavior.Skip: continue; } } var allNodes = new Dictionary <int, Dictionary <int, Dictionary <int, PositionedNode> > >(); allNodes[layercount] = new Dictionary <int, Dictionary <int, PositionedNode> >(); MapLayer mLayer = mapLayer; int mLayerCount = layercount; Parallel.For(0, mapLayer.data[0].tiles.Count, count => { uint gid = mLayer.data[0].tiles[count]; Tileset tileSet = GetTilesetForGid(gid); if (tileSet != null || !requireTile) { var node = new PositionedNode(); //int tileWidth = requireTile ? tileSet.tilewidth : tilewidth; //int tileHeight = requireTile ? tileSet.tileheight : tileheight; int x = count % this.Width; int y = count / this.Width; float nodex; float nodey; float nodez; CalculateWorldCoordinates(mLayerCount, count, tilewidth, tileheight, mLayer.width, out nodex, out nodey, out nodez); node.X = nodex; node.Y = nodey; node.Z = nodez; lock (allNodes) { if (!allNodes[mLayerCount].ContainsKey(x)) { allNodes[mLayerCount][x] = new Dictionary <int, PositionedNode>(); } allNodes[mLayerCount][x][y] = node; } node.Name = string.Format("Node {0}", count); lock (toReturn) { toReturn.AddNode(node); } } }); SetupNodeLinks(linkHorizontally, linkVertically, linkDiagonally, allNodes[layercount]); RemoveExcludedNodesViaPolygonLayer(toReturn, mapLayer, allNodes[layercount]); LowerNodesInNodesDownShapeCollection(mapLayer, allNodes[layercount]); RaiseNodesInNodesUpShapeCollection(mapLayer, allNodes[layercount]); ++layercount; } toReturn.UpdateShapes(); return(toReturn); }
public override void Remove(PositionedNode nodeToRemove) { base.Remove(nodeToRemove); int tileX, tileY; WorldToIndex(nodeToRemove.Position.X, nodeToRemove.Position.Y, out tileX, out tileY); mTiledNodes[tileX][tileY] = null; }
public void AttachNodeToNodeAtIndex(PositionedNode node, int x, int y) { PositionedNode nodeToLinkTo = TiledNodeAt(x, y); if (nodeToLinkTo != null && !node.IsLinkedTo(nodeToLinkTo)) { node.LinkTo(nodeToLinkTo); } }
public void UpdateNodeAccordingToCosts(PositionedNode node) { float multiplierForThisNode = 1; for (int propertyIndex = 0; propertyIndex < PropertyIndexSize; propertyIndex++) { int shiftedValue = 1 << propertyIndex; if ((node.PropertyField & shiftedValue) == shiftedValue) { multiplierForThisNode += mCosts[propertyIndex]; } } // Now we know the cost multiplier to get to this node, which is multiplerForThisNode // Next we just have to calculate the distance to get to this node and foreach (Link link in node.mLinks) { PositionedNode otherNode = link.NodeLinkingTo; Link linkBack = otherNode.GetLinkTo(node); if (linkBack != null) { // reacalculate the cost: linkBack.Cost = (node.Position - otherNode.Position).Length() * multiplierForThisNode; } } }
private void CursorControlOverObjects() { Cursor cursor = GuiManager.Cursor; #region Pushing selects and grabs a Node or link if (cursor.PrimaryPush) { #region Check for nodes mNodeGrabbed = mNodeOver; cursor.SetObjectRelativePosition(mNodeGrabbed); SelectNode(mNodeGrabbed); #endregion #region Check for links if (mCurrentNodes.Count == 0) { SelectLink(mLinkOver, mLinkOverParent); } #endregion } #endregion #region Holding the button down can be used to adjust node properties if (cursor.PrimaryDown) { PerformDraggingUpdate(); } #endregion #region Clicking (releasing) the mouse lets go of grabbed Polygons if (cursor.PrimaryClick) { mNodeGrabbed = null; cursor.StaticPosition = false; cursor.ObjectGrabbed = null; TextManager.RemoveText(mDistanceDisplay); } #endregion }
public TileNodeNetwork(float xSeed, float ySeed, float gridSpacing, int numberOfXTiles, int numberOfYTiles, DirectionalType directionalType) { mCosts = new float[PropertyIndexSize]; // Maybe expand this to 64 if we ever move to a long bit field? OccupiedCircleRadius = .5f; mTiledNodes = new PositionedNode[numberOfXTiles][]; mNumberOfXTiles = numberOfXTiles; mNumberOfYTiles = numberOfYTiles; mDirectionalType = directionalType; mXSeed = xSeed; mYSeed = ySeed; mGridSpacing = gridSpacing; // Do an initial loop to create the arrays so that // linking works properly for (int x = 0; x < numberOfXTiles; x++) { mTiledNodes[x] = new PositionedNode[numberOfYTiles]; } }