Exemple #1
0
        /// <summary>
        /// Creates Places list, walking critical path and adding subpaths recursively.
        /// Creates _lockedDoorCandidates list, places on the way to end room and to chest places.
        /// </summary>
        /// <param name="startRoom"></param>
        /// <param name="path"></param>
        private void InitLists(RoomTrait startRoom, List <MazeMove> path)
        {
            var room  = startRoom;
            var depth = 0;

            foreach (var move in path)
            {
                this.Places.Add(new PlaceNode(room, depth, false));
                room.RoomIndex = this.Places.Count - 1;
                room.isOnPath  = true;
                var lockedDoorCandidate = new LockedDoorCandidateNode(room, move.Direction, this.Places.Count - 1);
                _lockedDoorCandidates.AddLast(lockedDoorCandidate);
                for (var direction = 0; direction < 4; direction++)
                {
                    if (move.Direction != direction && room.Links[direction] == LinkType.To)
                    {
                        var nextRoom = room.Neighbor[direction];
                        if (nextRoom != null)
                        {
                            CreateEmptyPlacesRecursive(nextRoom, depth + 1);
                        }
                    }
                }
                room = room.Neighbor[move.Direction];
                depth++;
            }
        }
Exemple #2
0
        /// <summary>
        /// Section of teh floor, contain Puzzles.
        /// </summary>
        /// <param name="startRoom">Start room of this section.</param>
        /// <param name="path">Critical path for this section.</param>
        /// <param name="haveBossRoom">Should we place a boss door in this section.</param>
        /// <param name="rng">Randrom generator for this dungeon.</param>
        public DungeonFloorSection(RoomTrait startRoom, List <MazeMove> path, bool haveBossRoom, MTRandom rng)
        {
            _lockColorProvider    = new LockColorProvider();
            _lockedDoorCandidates = new LinkedList <LockedDoorCandidateNode>();
            this.Places           = new List <PlaceNode>();
            this.Puzzles          = new List <Puzzle>();

            _placeBossDoor = haveBossRoom;
            _rng           = rng;

            this.InitLists(startRoom, path);
        }
Exemple #3
0
 /// <summary>
 /// CalculateWeights helper method.
 /// </summary>
 /// <param name="room"></param>
 /// <param name="count"></param>
 /// <returns></returns>
 private int CalculateSubPathWeightRecursive(RoomTrait room, int count)
 {
     for (var direction = 0; direction < 4; direction++)
     {
         if (room.Links[direction] != LinkType.To)
         {
             continue;
         }
         var nextRoom = room.Neighbor[direction];
         if (nextRoom != null)
         {
             count = CalculateSubPathWeightRecursive(nextRoom, count + 1);
         }
     }
     return(count);
 }
Exemple #4
0
 /// <summary>
 ///	Recursively add subpath rooms to Places list.
 /// </summary>
 /// <param name="room"></param>
 /// <param name="depth"></param>
 private void CreateEmptyPlacesRecursive(RoomTrait room, int depth)
 {
     this.Places.Add(new PlaceNode(room, depth, false));
     room.RoomIndex = this.Places.Count - 1;
     for (var direction = 0; direction < 4; direction++)
     {
         if (room.Links[direction] != LinkType.To)
         {
             continue;
         }
         var nextRoom = room.Neighbor[direction];
         if (nextRoom != null)
         {
             CreateEmptyPlacesRecursive(nextRoom, depth + 1);
         }
     }
 }
Exemple #5
0
		/// <summary>
		/// Makes it a locked place with a locked door.
		/// </summary>
		public void DeclareLock(bool lockSelf = false)
		{
			var doorElement = _section.GetLock(lockSelf);
			if (doorElement == null)
				return;

			this.PlaceIndex = doorElement.PlaceIndex;
			_room = doorElement.Room;
			this.UpdatePosition();
			this.IsLock = true;
			this.LockColor = _section.GetLockColor();
			this.DoorDirection = doorElement.Direction;

			_room.ReserveDoor(this.DoorDirection);
			_room.isLocked = true;
			if (_room.RoomType != RoomType.End || _room.RoomType != RoomType.Start)
				_room.RoomType = RoomType.Room;

			// Boss door - special case
			if ((DungeonBlockType)_room.DoorType[this.DoorDirection] == DungeonBlockType.BossDoor)
			{
				this.IsBossLock = true;
				this.AddDoor(this.DoorDirection, DungeonBlockType.BossDoor);
			}
			else
				this.AddDoor(this.DoorDirection, DungeonBlockType.DoorWithLock);

			if (lockSelf)
				this.GetLockDoor().IsLocked = true;
		}
Exemple #6
0
 public void SetNeighbor(int direction, RoomTrait room)
 {
     this.Neighbor[direction] = room;
 }
Exemple #7
0
			public PlaceNode(RoomTrait room, int depth, bool isUsed)
			{
				this.Room = room;
				this.Depth = depth;
				this.IsUsed = isUsed;
			}
Exemple #8
0
			public LockedDoorCandidateNode(RoomTrait room, int direction, int placeIndex)
			{
				this.Room = room;
				this.Direction = direction;
				this.PlaceIndex = placeIndex;
			}
Exemple #9
0
		/// <summary>
		///	Recursively add subpath rooms to Places list.
		/// </summary>
		/// <param name="room"></param>
		/// <param name="depth"></param>
		private void CreateEmptyPlacesRecursive(RoomTrait room, int depth)
		{
			this.Places.Add(new PlaceNode(room, depth, false));
			room.RoomIndex = this.Places.Count - 1;
			for (var direction = 0; direction < 4; direction++)
			{
				if (room.Links[direction] != LinkType.To) continue;
				var nextRoom = room.Neighbor[direction];
				if (nextRoom != null)
					CreateEmptyPlacesRecursive(nextRoom, depth + 1);
			}
		}
Exemple #10
0
		/// <summary>
		/// Creates Places list, walking critical path and adding subpaths recursively.
		/// Creates _lockedDoorCandidates list, places on the way to end room and to chest places.
		/// </summary>
		/// <param name="startRoom"></param>
		/// <param name="path"></param>
		private void InitLists(RoomTrait startRoom, List<MazeMove> path)
		{
			var room = startRoom;
			var depth = 0;
			foreach (var move in path)
			{
				this.Places.Add(new PlaceNode(room, depth, false));
				room.RoomIndex = this.Places.Count - 1;
				room.isOnPath = true;
				var lockedDoorCandidate = new LockedDoorCandidateNode(room, move.Direction, this.Places.Count - 1);
				_lockedDoorCandidates.AddLast(lockedDoorCandidate);
				for (var direction = 0; direction < 4; direction++)
				{
					if (move.Direction != direction && room.Links[direction] == LinkType.To)
					{
						var nextRoom = room.Neighbor[direction];
						if (nextRoom != null)
							CreateEmptyPlacesRecursive(nextRoom, depth + 1);
					}
				}
				room = room.Neighbor[move.Direction];
				depth++;
			}
		}
Exemple #11
0
		public void SetNeighbor(int direction, RoomTrait room)
		{
			this.Neighbor[direction] = room;
		}
Exemple #12
0
		/// <summary>
		/// CalculateWeights helper method.
		/// </summary>
		/// <param name="room"></param>
		/// <param name="count"></param>
		/// <returns></returns>
		private int CalculateSubPathWeightRecursive(RoomTrait room, int count)
		{
			for (var direction = 0; direction < 4; direction++)
			{
				if (room.Links[direction] != LinkType.To) continue;
				var nextRoom = room.Neighbor[direction];
				if (nextRoom != null)
					count = CalculateSubPathWeightRecursive(nextRoom, count + 1);
			}
			return count;
		}
Exemple #13
0
 public PlaceNode(RoomTrait room, int depth, bool isUsed)
 {
     this.Room   = room;
     this.Depth  = depth;
     this.IsUsed = isUsed;
 }
Exemple #14
0
 public LockedDoorCandidateNode(RoomTrait room, int direction, int placeIndex)
 {
     this.Room       = room;
     this.Direction  = direction;
     this.PlaceIndex = placeIndex;
 }
Exemple #15
0
		/// <summary>
		/// This place will precede locked place and contain some means to unlock it.
		/// </summary>
		/// <param name="lockPlace"></param>
		public void DeclareUnlock(PuzzlePlace lockPlace)
		{
			var place = lockPlace as PuzzlePlace;
			if (place == null || place.PlaceIndex == -1)
				throw new PuzzleException("We can't declare unlock");

			this.PlaceIndex = _section.GetUnlock(place);
			_room = _section.Places[PlaceIndex].Room;
			this.IsUnlock = true;

			this.UpdatePosition();
		}
Exemple #16
0
		/// <summary>
		/// Declares that this place is not to be used by any other puzzles.
		/// If we didn't declare this place to be something, reserve random place.
		/// </summary>
		public void ReservePlace()
		{
			if (this.IsUnlock || this.IsLock || this.IsBossLock)
				_section.ReservePlace(PlaceIndex);
			else
			{
				PlaceIndex = _section.ReservePlace();
				_room = _section.Places[PlaceIndex].Room;

				this.UpdatePosition();
			}
		}
Exemple #17
0
		/// <summary>
		/// Section of teh floor, contain Puzzles.
		/// </summary>
		/// <param name="startRoom">Start room of this section.</param>
		/// <param name="path">Critical path for this section.</param>
		/// <param name="haveBossRoom">Should we place a boss door in this section.</param>
		/// <param name="rng">Randrom generator for this dungeon.</param>
		public DungeonFloorSection(RoomTrait startRoom, List<MazeMove> path, bool haveBossRoom, MTRandom rng)
		{
			_lockColorProvider = new LockColorProvider();
			_lockedDoorCandidates = new LinkedList<LockedDoorCandidateNode>();
			this.Places = new List<PlaceNode>();
			this.Puzzles = new List<Puzzle>();

			_placeBossDoor = haveBossRoom;
			_rng = rng;

			this.InitLists(startRoom, path);
		}