コード例 #1
0
ファイル: DungeonNode.cs プロジェクト: tomaszkot/Roguelike
            internal List <IDoor> GenerateDoors(RoomPlacement room)
            {
                var listOfRoomSides = new List <EntranceSide>();

                if (room == RoomPlacement.LeftUpper)
                {
                    listOfRoomSides.Add(EntranceSide.Right);
                    listOfRoomSides.Add(EntranceSide.Bottom);
                }
                if (room == RoomPlacement.LeftLower)
                {
                    listOfRoomSides.Add(EntranceSide.Top);
                    listOfRoomSides.Add(EntranceSide.Right);
                }
                if (room == RoomPlacement.RightUpper)
                {
                    listOfRoomSides.Add(EntranceSide.Left);
                    listOfRoomSides.Add(EntranceSide.Bottom);
                }
                if (room == RoomPlacement.RightLower)
                {
                    listOfRoomSides.Add(EntranceSide.Left);
                    listOfRoomSides.Add(EntranceSide.Top);
                }
                if (room == RoomPlacement.Center)
                {
                    listOfRoomSides.Add(EntranceSide.Bottom);
                    listOfRoomSides.Add(EntranceSide.Top);
                    listOfRoomSides.Add(EntranceSide.Left);
                    listOfRoomSides.Add(EntranceSide.Right);
                }
                if (room == RoomPlacement.CorrindorVerticalRight || room == RoomPlacement.CorrindorVerticalLeft)
                {
                    listOfRoomSides.Add(EntranceSide.Top);
                    listOfRoomSides.Add(EntranceSide.Bottom);
                }
                if (room == RoomPlacement.CorrindorHorizontalTop || room == RoomPlacement.CorrindorHorizontalBottom)
                {
                    listOfRoomSides.Add(EntranceSide.Right);
                    listOfRoomSides.Add(EntranceSide.Left);
                }

                var res = new List <IDoor>();

                while (listOfRoomSides.Count > 0)
                {
                    List <Wall> wall = sides[listOfRoomSides[0]];

                    res.Add(CreateDoor(wall[wall.Count / 2]) as Door);
                    listOfRoomSides.RemoveAt(0);
                }

                return(res);
            }
コード例 #2
0
 public void CalculateCorridorPosition(List <DungeonNode> nodes, DungeonNode node1, DungeonNode node2, GenerationInfo infoCorridor)
 {
     if (node1.Placement == RoomPlacement.LeftUpper)
     {
         infoCorridor.MinNodeSize = new Size(Node2Position.X - node1.Width + wallLength[3], 4);
         CorridorPosition         = new Point(node1.Width - wallLength[1], Node1Position.Y + (node1.Height / 2) - wallLength[1]);
         placement = RoomPlacement.CorrindorHorizontalTop;
     }
     if (node1.Placement == RoomPlacement.RightUpper)
     {
         infoCorridor.MinNodeSize = new Size(4, Node2Position.Y - node1.Height + wallLength[3]);
         CorridorPosition         = new Point(Node1Position.X + (node1.Width / 2) - wallLength[1], node1.Height - wallLength[1]);
         placement = RoomPlacement.CorrindorVerticalRight;
     }
     if (node1.Placement == RoomPlacement.RightLower)
     {
         infoCorridor.MinNodeSize = new Size(bottomLenght - node2.Width + wallLength[3], 4);
         CorridorPosition         = new Point(node2.Width - wallLength[1], Node2Position.Y + (node2.Height / 2) - wallLength[1]);
         placement = RoomPlacement.CorrindorHorizontalBottom;
     }
     if (node1.Placement == RoomPlacement.LeftLower)
     {
         infoCorridor.MinNodeSize = new Size(4, Node1Position.Y - node2.Height + wallLength[3]);
         CorridorPosition         = new Point((node2.Width / 2) - wallLength[1], node2.Height - wallLength[1]);
         placement = RoomPlacement.CorrindorVerticalLeft;
     }
     if (node1.Placement == RoomPlacement.CorrindorHorizontalTop)
     {
         infoCorridor.MinNodeSize = new Size(4, centralRoomPosition - (nodes[(int)RoomPlacement.LeftUpper].Height / 2) + wallLength[1]);
         CorridorPosition         = new Point(centralRoomPosition + (node2.Width / 2) - wallLength[1], (nodes[(int)RoomPlacement.LeftUpper].Height / 2) + wallLength[1]);
         placement = RoomPlacement.CorrindorVerticalRight;
     }
     if (node1.Placement == RoomPlacement.CorrindorVerticalRight)
     {
         infoCorridor.MinNodeSize = new Size(upperLenght - centralRoomPosition - node2.Width + (nodes[(int)RoomPlacement.RightUpper].Width / 2) + wallLength[2], 4);
         CorridorPosition         = new Point(centralRoomPosition + node2.Width - wallLength[1], centralRoomPosition + (node2.Height / 2) - wallLength[1]);
         placement = RoomPlacement.CorrindorHorizontalTop;
     }
     if (node1.Placement == RoomPlacement.CorrindorHorizontalBottom)
     {
         infoCorridor.MinNodeSize = new Size(4, leftLenght - centralRoomPosition + (nodes[(int)RoomPlacement.LeftLower].Height / 2) - node2.Height + wallLength[2]);
         CorridorPosition         = new Point(centralRoomPosition + (node2.Width / 2) - wallLength[1], centralRoomPosition + node2.Height - wallLength[1]);
         placement = RoomPlacement.CorrindorVerticalLeft;
     }
     if (node1.Placement == RoomPlacement.CorrindorVerticalLeft)
     {
         infoCorridor.MinNodeSize = new Size(12 - (nodes[(int)RoomPlacement.LeftUpper].Width / 2) + wallLength[1], 4);
         CorridorPosition         = new Point((nodes[(int)RoomPlacement.LeftUpper].Width / 2) + wallLength[1], centralRoomPosition + (node2.Height / 2) - wallLength[1]);
         placement = RoomPlacement.CorrindorHorizontalBottom;
     }
 }
コード例 #3
0
        /**
         * Functie om de huidige ruimte op te slaan
         */
        public void SubmitRoom()
        {
            if (SelectedPoints.Count() < 3)
            {
                MessageQueue.Enqueue("Voer a.u.b. meer dan 2 punten in.");
                return;
            }

            // bepaal de kleinste x waarde
            Position smallestX = SelectedPoints.Aggregate((p1, p2) => p1.X < p2.X ? p1 : p2);
            // bepaal de kleinste y waarde
            Position smallestY = SelectedPoints.Aggregate((p1, p2) => p1.Y < p2.Y ? p1 : p2);
            // maakt de kamer zo hoog en links mogelijk
            List <Position> OffsetPositions = new List <Position>();

            foreach (Position position in SelectedPoints)
            {
                OffsetPositions.Add(new Position(position.X - smallestX.X, position.Y - smallestY.Y));
            }

            Debug.WriteLine(FramePoints.Count);

            List <RoomPlacement> framePositions = new List <RoomPlacement>();

            foreach (Frame frame in FramePoints)
            {
                framePositions.Add(
                    new RoomPlacement(
                        RoomPlacement.FromDimensions(frame.X - smallestX.X, frame.Y - smallestY.Y), frame.Rotation,
                        frame.Type
                        )
                    );
            }

            Room room = new Room(Name, Room.FromList(OffsetPositions), framePositions);

            if (RoomService.Instance.Save(room) != null)
            {
                //opent successvol dialoog
                MessageQueue.Enqueue("De kamer is succesvol opgeslagen.");
                return;
            }

            //opent onsuccesvol dialoog
            MessageQueue.Enqueue("Er is iets misgegaan tijdens het opslaan, probeer het nog een keer.");
        }
コード例 #4
0
        public List <Position> MakeRoom(Room selectedroom)
        {
            SelectedPoints = Room.ToList(selectedroom.Positions);
            Position Last = new Position(-1, -1);

            foreach (Position pos in SelectedPoints)
            {
                if (!Last.Equals(new Position(-1, -1)))
                {
                    if (Last.Y == pos.Y)
                    {
                        // als het getal negatief is moet er naar links worden getekend, positief is rechts
                        bool toRight = Last.X - pos.X >= 0;
                        // zolang het vorige coordinaat kleiner is
                        int i = Last.X;
                        while (i != pos.X)
                        {
                            Last = new Position(i, Last.Y);
                            BorderPoints.Add(Last);
                            if (toRight)
                            {
                                i -= 25;
                            }
                            else
                            {
                                i += 25;
                            }
                        }
                    }
                    else
                    {
                        bool toBottom = Last.Y - pos.Y >= 0;
                        int  i        = Last.Y;

                        // zolang het vorige coordinaat kleiner is
                        while (i != pos.Y)
                        {
                            Last = new Position(Last.X, i);
                            BorderPoints.Add(Last);
                            if (toBottom)
                            {
                                i -= 25;
                            }
                            else
                            {
                                i += 25;
                            }
                        }
                    }

                    Last = new Position(pos.X, pos.Y);
                }
                else
                {
                    Last = new Position(pos.X, pos.Y);
                }
            }

            // Voeg de room frames toe
            foreach (RoomPlacement placement in selectedroom.RoomPlacements)
            {
                Position pos   = RoomPlacement.ToPosition(placement.Positions);
                Frame    frame = new Frame(pos.X, pos.Y, placement.Type)
                {
                    AttachedPosition = CalculateNextPositionFromAngle(placement.Rotation, pos.X, pos.Y)
                };
                FramePoints.Add(frame);
            }

            LastSelected = SelectedPoints.Last();
            return(SelectedPoints);
        }