Beispiel #1
0
        void CreatePathfindingNodes()
        {
            for (int y = Building.Rectangle.Top; y < Building.Rectangle.Bottom; y++)
            {
                for (int x = Building.Rectangle.Left; x < Building.Rectangle.Right; x++)
                {
                    ITile         tile     = Level.Map.GetTileByTopLeftCorner(x, y);
                    Vector3       position = new Vector3(tile.Center.X, GetHeightAt(tile.Center.X, tile.Center.Y).Value, tile.Center.Y);
                    IBuildingNode node     = Level.Map.PathFinding.CreateBuildingNode(Building, position, TowerTag);
                    nodes.Add(tile, node);
                }
            }

            //Connect roof edges
            foreach (var tileAndNode in nodes)
            {
                ITile         tile = tileAndNode.Key;
                IBuildingNode node = tileAndNode.Value;
                foreach (var neighbour in tile.GetNeighbours())
                {
                    if (neighbour == null)
                    {
                        continue;
                    }
                    //Connect to neighbor roof nodes
                    if (nodes.TryGetValue(neighbour, out IBuildingNode neighbourNode))
                    {
                        node.CreateEdge(neighbourNode, MovementType.Linear);
                    }
                    else if (neighbour.Building != null &&
                             neighbour.Building.BuildingPlugin is WalkableBuildingPlugin plugin)
                    {
                        IBuildingNode foreighNode = plugin.TryGetNodeAt(neighbour);

                        //Either is not loaded yet, will connect from the other side
                        // or does not contain a node (impossible in the current version)
                        if (foreighNode == null)
                        {
                            continue;
                        }

                        //Do not connect to keep
                        if (foreighNode.Tag == Keep.KeepTag)
                        {
                            continue;
                        }

                        if (!foreighNode.HasEdgeTo(node))
                        {
                            foreighNode.CreateEdge(node, MovementType.Teleport);
                        }

                        if (!node.HasEdgeTo(foreighNode))
                        {
                            node.CreateEdge(foreighNode, MovementType.Teleport);
                        }
                    }
                }
            }
        }
Beispiel #2
0
        void ConnectNeighbours()
        {
            ITile myTile = Level.Map.GetContainingTile(Building.Center);

            foreach (var neighbor in myTile.GetNeighbours())
            {
                if (neighbor?.Building == null)
                {
                    continue;
                }

                if (neighbor.Building.BuildingPlugin is WalkableBuildingPlugin plugin)
                {
                    IBuildingNode node = plugin.TryGetNodeAt(neighbor);


                    //Either is not loaded yet, will connect from the other side
                    // or does not contain a node (impossible in the current version)
                    if (node == null)
                    {
                        continue;
                    }


                    MovementType movementType;
                    if (node.Tag == WallTag)
                    {
                        movementType = MovementType.Linear;
                    }
                    else if (node.Tag == Gate.GateRoofTag || node.Tag == Tower.TowerTag)
                    {
                        movementType = MovementType.Teleport;
                    }
                    else
                    {
                        continue;
                    }

                    if (!pathNode.HasEdgeTo(node))
                    {
                        pathNode.CreateEdge(node, movementType);
                    }

                    if (!node.HasEdgeTo(pathNode))
                    {
                        node.CreateEdge(pathNode, movementType);
                    }
                }
            }
        }
Beispiel #3
0
        void CreatePathfindingNodes()
        {
            for (int y = Building.Rectangle.Top; y < Building.Rectangle.Bottom; y++)
            {
                for (int x = Building.Rectangle.Left; x < Building.Rectangle.Right; x++)
                {
                    ITile         tile     = Level.Map.GetTileByTopLeftCorner(x, y);
                    Vector3       position = new Vector3(tile.Center.X, GetHeightAt(tile.Center.X, tile.Center.Y).Value, tile.Center.Y);
                    IBuildingNode node     = Level.Map.PathFinding.CreateBuildingNode(Building, position, KeepTag);
                    nodes.Add(tile, node);
                }
            }

            //Connect roof edges
            foreach (var tileAndNode in nodes)
            {
                ITile         tile = tileAndNode.Key;
                IBuildingNode node = tileAndNode.Value;
                foreach (var neighbour in tile.GetNeighbours())
                {
                    if (neighbour == null)
                    {
                        continue;
                    }

                    //Connect to neighbor roof nodes
                    if (nodes.TryGetValue(neighbour, out IBuildingNode neighbourNode))
                    {
                        node.CreateEdge(neighbourNode, MovementType.Linear);
                    }

                    //Connects just to own nodes, does not connect to other buildings.
                }
            }

            //Connect to tile in front
            var           buildingFrontTile = Level.Map.GetContainingTile(Building.Center + Building.Forward * 2);
            ITileNode     tileNode          = Level.Map.PathFinding.GetTileNode(TileInFront);
            IBuildingNode buildingNode      = nodes[buildingFrontTile];

            tileNode.CreateEdge(buildingNode, MovementType.Teleport);
            buildingNode.CreateEdge(tileNode, MovementType.Teleport);
        }
Beispiel #4
0
        void CreatePathfindingNodes()
        {
            //Roof nodes
            for (int y = Building.Rectangle.Top; y < Building.Rectangle.Bottom; y++)
            {
                for (int x = Building.Rectangle.Left; x < Building.Rectangle.Right; x++)
                {
                    ITile         tile     = Level.Map.GetTileByTopLeftCorner(x, y);
                    Vector3       position = new Vector3(tile.Center.X, GetHeightAt(tile.Center.X, tile.Center.Y).Value, tile.Center.Y);
                    IBuildingNode node     = Level.Map.PathFinding.CreateBuildingNode(Building, position, GateRoofTag);
                    roofNodes.Add(tile, node);
                }
            }

            //Connect roof edges
            foreach (var tileAndNode in roofNodes)
            {
                ITile         tile = tileAndNode.Key;
                IBuildingNode node = tileAndNode.Value;
                foreach (var neighbour in tile.GetNeighbours())
                {
                    if (neighbour == null)
                    {
                        continue;
                    }
                    //Connect to neighbor roof nodes
                    if (roofNodes.TryGetValue(neighbour, out IBuildingNode neighbourNode))
                    {
                        node.CreateEdge(neighbourNode, MovementType.Linear);
                    }
                    else if (neighbour.Building != null &&
                             neighbour.Building.BuildingPlugin is WalkableBuildingPlugin plugin)
                    {
                        IBuildingNode foreighNode = plugin.TryGetNodeAt(neighbour);

                        //Either is not loaded yet, will connect from the other side
                        // or does not contain a node (impossible in the current version)
                        if (foreighNode == null)
                        {
                            continue;
                        }

                        if (foreighNode.Tag == Keep.KeepTag)
                        {
                            continue;
                        }

                        if (!foreighNode.HasEdgeTo(node))
                        {
                            foreighNode.CreateEdge(node, MovementType.Teleport);
                        }

                        if (!node.HasEdgeTo(foreighNode))
                        {
                            node.CreateEdge(foreighNode, MovementType.Teleport);
                        }
                    }
                }
            }

            //Gate nodes
            Vector3 centerPosition = Building.Center;

            //Goes through the strip of tiles at the center of the Gate, withY 0 because nodes have to follow
            // the flat base of the building
            List <IBuildingNode> newTunnelNodes = new List <IBuildingNode>();

            for (int i = -2; i < 2; i++)
            {
                Vector3       position = centerPosition + i * Building.Forward.WithY(0);
                ITile         tile     = Level.Map.GetContainingTile(position);
                IBuildingNode node     = Level.Map.PathFinding.CreateBuildingNode(Building, position, GateTunnelTag);
                tunnelNodes.Add(tile, node);
                newTunnelNodes.Add(node);
            }

            Vector3       doorPosition  = centerPosition + 2 * Building.Forward.WithY(0);
            ITile         doorInnerTile = Level.Map.GetContainingTile(doorPosition);
            IBuildingNode doorNode      = Level.Map.PathFinding.CreateBuildingNode(Building,
                                                                                   doorPosition,
                                                                                   GateDoorTag);

            tunnelNodes.Add(doorInnerTile, doorNode);
            newTunnelNodes.Add(doorNode);

            //Connect tunnel edges
            for (int i = 1; i < newTunnelNodes.Count; i++)
            {
                newTunnelNodes[i - 1].CreateEdge(newTunnelNodes[i], MovementType.Linear);
                newTunnelNodes[i].CreateEdge(newTunnelNodes[i - 1], MovementType.Linear);
            }

            //Connect front node and back node to outside tiles
            ITile backTile  = Level.Map.GetContainingTile(centerPosition - 3 * Building.Forward);
            ITile frontTile = Level.Map.GetContainingTile(centerPosition + 3 * Building.Forward);

            if (backTile != null)
            {
                INode backNode = Level.Map.PathFinding.GetTileNode(backTile);
                backNode.CreateEdge(newTunnelNodes[0], MovementType.Linear);
                newTunnelNodes[0].CreateEdge(backNode, MovementType.Linear);
            }

            if (frontTile != null)
            {
                INode frontNode = Level.Map.PathFinding.GetTileNode(frontTile);
                frontNode.CreateEdge(newTunnelNodes[newTunnelNodes.Count - 1], MovementType.Linear);
                newTunnelNodes[newTunnelNodes.Count - 1].CreateEdge(frontNode, MovementType.Linear);
            }

            //Connect roof with the tunnel
            ITile centerTile = Level.Map.GetContainingTile(Building.Center);

            tunnelNodes[centerTile].CreateEdge(roofNodes[centerTile], MovementType.Teleport);
            roofNodes[centerTile].CreateEdge(tunnelNodes[centerTile], MovementType.Teleport);
        }