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;
     }
 }
Example #2
0
 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;
     }
 }
Example #3
0
        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;
        }
Example #4
0
        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
            }
        }
Example #5
0
        private void GetObjectsOver()
        {
            mNodeOver = GetNodeOver();

            if (mNodeOver != null)
            {
                mLinkOver = null;
                mLinkOverParent = null;
            }
            else
            {
                GetLinkOver(ref mLinkOver, ref mLinkOverParent);
            }


        }
Example #6
0
 void SelectLink(Link linkToSelect, PositionedNode linkParent)
 {
     mCurrentLink = linkToSelect;
     mCurrentLinkParent = linkParent;
 }
Example #7
0
        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

        }
Example #8
0
    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);
    }
Example #9
0
 public NodeConnection(PositionedNode positionedNode, float cost, string nodeLinkingTo)
 {
     PositionedNode = positionedNode;
     Cost           = cost;
     NodeLinkingTo  = nodeLinkingTo;
 }
Example #10
0
        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);
        }
Example #11
0
 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;
 }
Example #12
0
        public void AttachNodeToNodeAtIndex(PositionedNode node, int x, int y)
        {
            PositionedNode nodeToLinkTo = TiledNodeAt(x, y);

            if (nodeToLinkTo != null && !node.IsLinkedTo(nodeToLinkTo))
            {
                node.LinkTo(nodeToLinkTo);
            }

        }
Example #13
0
        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;
                }
            }
        }
Example #14
0
        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

        }
Example #15
0
        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];
            }

        }
Example #16
0
        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;
        }
Example #17
0
 void SelectLink(Link linkToSelect, PositionedNode linkParent)
 {
     mCurrentLink       = linkToSelect;
     mCurrentLinkParent = linkParent;
 }