private Rect CreateRectRoom(int width, int height, bool firstRoom = false)
        {
            int x, y;

            // Position the room
            if (firstRoom)
            {
                // Initial room, so start near center
                x = Rng.TriangleInt((_writer.Bounds.Width - width) / 2, (_writer.Bounds.Width - width) / 2 - 4);
                y = Rng.TriangleInt((_writer.Bounds.Height - height) / 2, (_writer.Bounds.Height - height) / 2 - 4);
            }
            else
            {
                // Place it wherever
                x = Rng.Int(_writer.Bounds.Width);
                y = Rng.Int(_writer.Bounds.Height);
            }

            Rect bounds = new Rect(x, y, width, height);

            // Check to see if the room can be positioned
            if (!_writer.IsOpen(bounds.Inflate(1), null))
            {
                return(Rect.Empty);
            }

            return(bounds);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Gets whether the given rectangle is empty (i.e. solid stone) and can have a feature placed in it.
        /// </summary>
        /// <param name="rect">The rectangle to test.</param>
        /// <param name="exception">An optional exception position. If this position is not stone, it is still possible
        /// to use the rect. Used for the connector to a new feature.</param>
        /// <remarks>It tests this by verifying each tile within the rect is a stone square. Originally only traced
        /// the perimeter, but that was allowing rooms to fully enclose other rooms.</remarks>
        public bool IsOpen(Rect rect, Vec2?exception)
        {
            // must be totally in bounds
            if (!_map.Bounds.Contains(rect))
            {
                return(false);
            }

            // and not cover an existing feature
            foreach (Vec2 tile in rect)
            {
                // allow the exception
                if (exception != null && (exception == tile))
                {
                    continue;
                }

                if (_map.Tiles[tile].Type != Tiles.Stone)
                {
                    return(false);
                }
            }

            return(true);
        }
Ejemplo n.º 3
0
 public void TestEnumerateColumn()
 {
     TestEnumeration(Rect.Column(4, 5, 3),
                     new Vec2(4, 5),
                     new Vec2(4, 6),
                     new Vec2(4, 7));
 }
Ejemplo n.º 4
0
 public void TestEnumerateRow()
 {
     TestEnumeration(Rect.Row(4, 5, 3),
                     new Vec2(4, 5),
                     new Vec2(5, 5),
                     new Vec2(6, 5));
 }
Ejemplo n.º 5
0
        public void TestRow()
        {
            Rect r = Rect.Row(4);

            Assert.AreEqual(0, r.Position.x);
            Assert.AreEqual(0, r.Position.y);
            Assert.AreEqual(4, r.Size.x);
            Assert.AreEqual(1, r.Size.y);
        }
Ejemplo n.º 6
0
        public void TestConstructorPositionIntSizeVec()
        {
            Rect r = new Rect(2, 4, new Vec2(3, 5));

            Assert.AreEqual(2, r.Position.x);
            Assert.AreEqual(4, r.Position.y);
            Assert.AreEqual(3, r.Size.x);
            Assert.AreEqual(5, r.Size.y);
        }
Ejemplo n.º 7
0
        public void TestColumn()
        {
            Rect r = Rect.Column(4);

            Assert.AreEqual(0, r.Position.x);
            Assert.AreEqual(0, r.Position.y);
            Assert.AreEqual(1, r.Size.x);
            Assert.AreEqual(4, r.Size.y);
        }
Ejemplo n.º 8
0
        public void TestRowPos()
        {
            Rect r = Rect.Row(-2, 3, 4);

            Assert.AreEqual(-2, r.Position.x);
            Assert.AreEqual(3, r.Position.y);
            Assert.AreEqual(4, r.Size.x);
            Assert.AreEqual(1, r.Size.y);
        }
Ejemplo n.º 9
0
        public void TestConstructorDefault()
        {
            Rect r = new Rect();

            Assert.AreEqual(0, r.Position.x);
            Assert.AreEqual(0, r.Position.y);
            Assert.AreEqual(0, r.Size.x);
            Assert.AreEqual(0, r.Size.y);
        }
Ejemplo n.º 10
0
        public void TestConstructorPositionVecSizeInt()
        {
            Rect r = new Rect(new Vec2(2, 4), 3, 5);

            Assert.AreEqual(2, r.Position.x);
            Assert.AreEqual(4, r.Position.y);
            Assert.AreEqual(3, r.Size.x);
            Assert.AreEqual(5, r.Size.y);
        }
Ejemplo n.º 11
0
        public void TestColumnVecPos()
        {
            Rect r = Rect.Column(new Vec2(-2, 3), 4);

            Assert.AreEqual(-2, r.Position.x);
            Assert.AreEqual(3, r.Position.y);
            Assert.AreEqual(1, r.Size.x);
            Assert.AreEqual(4, r.Size.y);
        }
Ejemplo n.º 12
0
        public void TestEmpty()
        {
            Rect r = Rect.Empty;

            Assert.AreEqual(0, r.Position.x);
            Assert.AreEqual(0, r.Position.y);
            Assert.AreEqual(0, r.Size.x);
            Assert.AreEqual(0, r.Size.x);
        }
Ejemplo n.º 13
0
        public void TestConstructorSizeVec()
        {
            Rect r = new Rect(new Vec2(3, 5));

            Assert.AreEqual(0, r.Position.x);
            Assert.AreEqual(0, r.Position.y);
            Assert.AreEqual(3, r.Size.x);
            Assert.AreEqual(5, r.Size.y);
        }
Ejemplo n.º 14
0
        public bool CreateFeature(string name, out Rect bounds)
        {
            switch (name)
            {
            case "room":
                return(MakeRoom(out bounds));

            default: throw new ArgumentException($"Unknown feature \"{name}\"");
            }
        }
Ejemplo n.º 15
0
        private void Populate(Rect bounds, int monsterDensity, int itemDensity)
        {
            // TODO: For testing, place one NPC in each room. For real this should probably be more random!
            //foreach (Rect room in _rooms)
            {
                int xOffset = Rng.Int(bounds.Width);
                int yOffset = Rng.Int(bounds.Height);

                Vec2 location = bounds.Position + new Vec2(xOffset, yOffset);

                _writer.Populate(location);
            }
        }
Ejemplo n.º 16
0
        private Rect CreateRoom(bool startingRoom = false)
        {
            int width  = Rng.Int(_writer.Options.RoomSizeMin, _writer.Options.RoomSizeMax);
            int height = Rng.Int(_writer.Options.RoomSizeMin, _writer.Options.RoomSizeMax);

            Rect bounds = CreateRectRoom(width, height, startingRoom);

            // Bail if we failed
            if (bounds == Rect.Empty)
            {
                return(bounds);
            }

            // Place the room
            foreach (Vec2 position in bounds)
            {
                _writer.SetTile(position, Tiles.Floor);
            }

            // And the walls surrounding the room
            foreach (Vec2 position in bounds.Trace())
            {
                _writer.SetTile(position, Tiles.Wall);
            }

            // === Room decoration code here ===
            //TileType decoration = ChooseInnerWall();

            //RoomDecoration.Decorate(bounds, new RoomDecorator(this, position => _writer.Populate(position, 60, 200)));

            //_writer.LightRect(bounds);

            // place the connectors
            //AddRoomConnectors(bounds);

            Populate(bounds, 20, 20);
            // === End room decoration code ===

            _rooms.Add(bounds);
            return(bounds);
        }
Ejemplo n.º 17
0
        public void TestCoordinates()
        {
            Rect rect = new Rect(1, 2, 3, 4);

            // x, y
            Assert.AreEqual(1, rect.x);
            Assert.AreEqual(2, rect.y);

            // size
            Assert.AreEqual(3, rect.Width);
            Assert.AreEqual(4, rect.Height);

            // ltrb
            Assert.AreEqual(1, rect.Left);
            Assert.AreEqual(2, rect.Top);
            Assert.AreEqual(1 + 3, rect.Right);
            Assert.AreEqual(2 + 4, rect.Bottom);

            // ltrb vecs
            Assert.AreEqual(new Vec2(1, 2), rect.TopLeft);
            Assert.AreEqual(new Vec2(1 + 3, 2), rect.TopRight);
            Assert.AreEqual(new Vec2(1, 2 + 4), rect.BottomLeft);
            Assert.AreEqual(new Vec2(1 + 3, 2 + 4), rect.BottomRight);
        }
Ejemplo n.º 18
0
 private bool MakeRoom(out Rect bounds)
 {
     bounds = CreateRoom();
     return(bounds != Rect.Empty);
 }
Ejemplo n.º 19
0
        public bool MakeHalls()
        {
            List <Vertex> vertices = new List <Vertex>();

            // add a vertex at the center of each room
            foreach (Rect room in _rooms)
            {
                vertices.Add(new Vertex <Rect>(new Vector2(room.Center.x, room.Center.y), room));
            }

            // Create a Delaunay triangulation of the rooms
            _delaunay = Delaunay2D.Triangulate(vertices);

            // Convert the Delaunay edges to Prim edges
            List <Prim.Edge> edges = new List <Prim.Edge>();

            foreach (Delaunay2D.Edge edge in _delaunay.Edges)
            {
                edges.Add(new Prim.Edge(edge.U, edge.V));
            }

            // Create a minimum spanning tree of the triangulation
            List <Prim.Edge> mst = Prim.MinimumSpanningTree(edges, edges[0].U);

            // Get the edges not part of the MST
            HashSet <Prim.Edge> selectedEdges  = new HashSet <Prim.Edge>(mst);
            HashSet <Prim.Edge> remainingEdges = new HashSet <Prim.Edge>(edges);

            remainingEdges.ExceptWith(selectedEdges);

            // Create some loops, since MSTs make for boring maps
            foreach (Prim.Edge edge in remainingEdges)
            {
                if (Rng.Int(100) < _writer.Options.ChanceOfExtraHallway)
                {
                    selectedEdges.Add(edge);
                }
            }

            // Drive a pathfinder to carve out the halls
            Motility motility = Motility.FourWayNeighbors | Motility.Unconstrained;

            foreach (Prim.Edge edge in selectedEdges)
            {
                Rect startRoom = (edge.U as Vertex <Rect>).Item;
                Rect endRoom   = (edge.V as Vertex <Rect>).Item;

                GridNode start = _writer.GetTile(new Vec2(startRoom.Center.x, startRoom.Center.y));
                GridNode goal  = _writer.GetTile(new Vec2(endRoom.Center.x, endRoom.Center.y));

                // Heuristic is Manhattan distance on a square grid
                IList <GridNode> path = _writer.Graph.FindPath <AStarSearchAlgorithm>(start, goal,
                                                                                      motility, (a, b) =>
                                                                                      Math.Abs((float)(a.Position.x - b.Position.x)) + Math.Abs((float)(a.Position.y - b.Position.y)));

                // Bail if the pathfinder failed to find a path (NOTE: if it does, it seems like it should be a problem)
                if (path == null)
                {
                    continue;
                }
                foreach (GridNode step in path)
                {
                    _writer.SetTile(step.Position, Tiles.Floor);
                    foreach (GridNode neighbor in step.Neighbors)
                    {
                        if ((_writer.GetTile(neighbor.Position)).Type == Tiles.Stone)
                        {
                            _writer.SetTile(neighbor.Position, Tiles.Wall);
                        }
                    }
                }
            }

            return(true);
        }