Пример #1
0
		/// <param name="changeDirectionModifier">Value from 0.0 to 1.0.  Percentage chance of changing direction.</param>
		public DirectionPicker(Random random, Direction previousDirection, double changeDirectionModifier)
		{
			_random = random;
			_directionsPicked = new List<Direction>();
			_previousDirection = previousDirection;
			_changeDirectionModifer = changeDirectionModifier;
		}
Пример #2
0
		public bool HasAdjacentCellInDirection(Vector2I location, Direction direction)
		{
			// Check that the location falls within the bounds of the map:
			if (!Bounds.Contains(location))
			{
				return false;
			}

			// Check if there is an adjacent cell in the direction:
			if (direction.Equals(Direction.North))
			{
				return location.Y > 0;
			}
			else if (direction.Equals(Direction.South))
			{
				return location.Y < (Rows - 1);
			}
			else if (direction.Equals(Direction.West))
			{
				return location.X > 0;
			}
			else if (direction.Equals(Direction.East))
			{
				return location.X < (Columns - 1);
			}
			else
			{
				return false;
			}
		}
Пример #3
0
		static Direction()
		{
			_random = new Random();
			North = new Direction(new Vector2I(0, -1));
			South = new Direction(new Vector2I(0, 1));
			East = new Direction(new Vector2I(1, 0));
			West = new Direction(new Vector2I(-1, 0));
		}
Пример #4
0
		public Entity()
		{
			_isAlive = true;
			_speed = 1.0f;
			_orientation = Direction.North;
			_range = 4.0f;

			Size = 1.0f;
		}
Пример #5
0
		private Vector2I CreateSide(Vector2I location, Direction direction, SideType sideType)
		{
			var target = GetTargetLocation(location, direction);

			if (direction.Equals(Direction.North))
			{
				this[location].NorthSide = sideType;
				this[target].SouthSide = sideType;
			}
			else if (direction.Equals(Direction.South))
			{
				this[location].SouthSide = sideType;
				this[target].NorthSide = sideType;
			}
			else if (direction.Equals(Direction.West))
			{
				this[location].WestSide = sideType;
				this[target].EastSide = sideType;
			}
			else if (direction.Equals(Direction.East))
			{
				this[location].EastSide = sideType;
				this[target].WestSide = sideType;
			}

			return target;
		}
Пример #6
0
		public Vector2I CreateDoor(Vector2I location, Direction direction)
		{
			return CreateSide(location, direction, SideType.Door);
		}
Пример #7
0
		public Vector2I CreateWall(Vector2I location, Direction direction)
		{
			return CreateSide(location, direction, SideType.Wall);
		}
Пример #8
0
		public Vector2I CreateCorridor(Vector2I location, Direction direction)
		{
			return CreateSide(location, direction, SideType.Empty);
		}
Пример #9
0
		public bool AdjacentCellInDirectionIsCorridor(Vector2I location, Direction direction)
		{
			if (!HasAdjacentCellInDirection(location, direction))
			{
				return false;
			}
			var target = GetTargetLocation(location, direction);
			return this[target].IsCorridor;
		}
Пример #10
0
		public bool AdjacentCellInDirectionIsVisited(Vector2I location, Direction direction)
		{
			if (!HasAdjacentCellInDirection(location, direction))
			{
				throw new InvalidOperationException("No adjacent cell exists for the location and direction provided.");
			}
			return this[location + direction.ToVector2I()].Visited;
		}
		private static IEnumerable<Vector2I> GetRoomPoints(int x, int y, int xlen, int ylen, Direction d)
		{
			// north and south share the same x strategy
			// east and west share the same y strategy
			Func<int, int, int> a = GetFeatureLowerBound;
			Func<int, int, int> b = GetFeatureUpperBound;

			if (d == Direction.North)
			{
				for (var xt = a(x, xlen); xt < b(x, xlen); xt++) for (var yt = y; yt > y - ylen; yt--) yield return new Vector2I(xt, yt);
			}
			else if (d == Direction.East)
			{
				for (var xt = x; xt < x + xlen; xt++) for (var yt = a(y, ylen); yt < b(y, ylen); yt++) yield return new Vector2I(xt, yt);
			}
			else if (d == Direction.South)
			{
				for (var xt = a(x, xlen); xt < b(x, xlen); xt++) for (var yt = y; yt < y + ylen; yt++) yield return new Vector2I(xt, yt);
			}
			else if (d == Direction.West)
			{
				for (var xt = x; xt > x - xlen; xt--) for (var yt = a(y, ylen); yt < b(y, ylen); yt++) yield return new Vector2I(xt, yt);
			}
		}
Пример #12
0
		private void Move(Level level, Direction direction)
		{
			// TODO: Modify speed according to the friction value of the current block.
			// TODO: Move slower if traveling on the background layer.
			// TODO: Don't allow walking through a position where all layers, including the background, are empty.
			MoveBy(level, direction, _speed);
		}
Пример #13
0
		private void MoveBy(Level level, Direction direction, float speed)
		{
			var vi = direction.ToVector2I();
			MoveBy(level, new Vector2(vi.X * speed, vi.Y * speed));
		}
		private bool MakeRoom(IProgress<string> progress, int x, int y, int xlength, int ylength, Direction direction)
		{
			// define the dimensions of the room, it should be at least 4x4 tiles (2x2 for walking on, the rest is walls)
			int xlen = GetRand(MIN_ROOM_COLUMNS, xlength);
			int ylen = GetRand(MIN_ROOM_ROWS, ylength);

			// the tile type it's going to be filled with
			const Tile Floor = Tile.DirtFloor;

			const Tile Wall = Tile.DirtWall;
			// choose the way it's pointing at

			var points = GetRoomPoints(x, y, xlen, ylen, direction).ToArray();

			// Check if there's enough space left for it
			if (points.Any(s =>
				!MathHelper.IsInRange(s.Y, 0, _rows + 1) ||
				!MathHelper.IsInRange(s.X, 0, _columns + 1) ||
				GetCellType(s.X, s.Y) != Tile.Unused))
			{
				return false;
			}
			progress.Report($"Making room:int x={x}, int y={y}, int xlength={xlength}, int ylength={ylen}, int direction={direction}");

			foreach (var p in points)
			{
				SetCell(p.X, p.Y, IsWall(x, y, xlen, ylen, p.X, p.Y, direction) ? Wall : Floor);
			}

			// yay, all done
			return true;
		}
		private bool MakeCorridor(int x, int y, int length, Direction direction)
		{
			// define the dimensions of the corridor (er.. only the width and height..)
			int len = this.GetRand(2, length);
			const Tile Floor = Tile.Corridor;

			int xtemp;
			int ytemp = 0;

			if (direction == Direction.North)
			{
				// north
				// check if there's enough space for the corridor
				// start with checking it's not out of the boundaries
				if (x < 0 || x > this._columns) return false;
				xtemp = x;

				// same thing here, to make sure it's not out of the boundaries
				for (ytemp = y; ytemp > (y - len); ytemp--)
				{
					if (ytemp < 0 || ytemp > this._rows) return false; // oh boho, it was!
					if (GetCellType(xtemp, ytemp) != Tile.Unused) return false;
				}

				// if we're still here, let's start building
				Corridors++;
				for (ytemp = y; ytemp > (y - len); ytemp--)
				{
					this.SetCell(xtemp, ytemp, Floor);
				}
			}
			else if (direction == Direction.East)
			{
				// east
				if (y < 0 || y > this._rows) return false;
				ytemp = y;

				for (xtemp = x; xtemp < (x + len); xtemp++)
				{
					if (xtemp < 0 || xtemp > this._columns) return false;
					if (GetCellType(xtemp, ytemp) != Tile.Unused) return false;
				}

				Corridors++;
				for (xtemp = x; xtemp < (x + len); xtemp++)
				{
					this.SetCell(xtemp, ytemp, Floor);
				}
			}
			else if (direction == Direction.South)
			{
				// south
				if (x < 0 || x > this._columns) return false;
				xtemp = x;

				for (ytemp = y; ytemp < (y + len); ytemp++)
				{
					if (ytemp < 0 || ytemp > this._rows) return false;
					if (GetCellType(xtemp, ytemp) != Tile.Unused) return false;
				}

				Corridors++;
				for (ytemp = y; ytemp < (y + len); ytemp++)
				{
					this.SetCell(xtemp, ytemp, Floor);
				}
			}
			else if (direction == Direction.West)
			{
				// west
				if (ytemp < 0 || ytemp > this._rows) return false;
				ytemp = y;

				for (xtemp = x; xtemp > (x - len); xtemp--)
				{
					if (xtemp < 0 || xtemp > this._columns) return false;
					if (GetCellType(xtemp, ytemp) != Tile.Unused) return false;
				}

				Corridors++;
				for (xtemp = x; xtemp > (x - len); xtemp--)
				{
					this.SetCell(xtemp, ytemp, Floor);
				}
			}

			// woot, we're still here! let's tell the other guys we're done!!
			return true;
		}
Пример #16
0
		protected Vector2I GetTargetLocation(Vector2I location, Direction direction)
		{
			if (!HasAdjacentCellInDirection(location, direction))
			{
				throw new InvalidOperationException("No adjacent cell exists for the location and direction provided.");
			}

			if (direction.Equals(Direction.North))
			{
				return location - Vector2I.UnitY;
			}
			else if (direction.Equals(Direction.South))
			{
				return location + Vector2I.UnitY;
			}
			else if (direction.Equals(Direction.West))
			{
				return location - Vector2I.UnitX;
			}
			else if (direction.Equals(Direction.East))
			{
				return location + Vector2I.UnitX;
			}
			else
			{
				throw new InvalidOperationException("No adjacent cell exists for the location and direction provided.");
			}
		}
		private static bool IsWall(int x, int y, int xlen, int ylen, int xt, int yt, Direction d)
		{
			Func<int, int, int> a = GetFeatureLowerBound;

			Func<int, int, int> b = IsFeatureWallBound;

			if (d == Direction.North)
			{
				return xt == a(x, xlen) || xt == b(x, xlen) || yt == y || yt == y - ylen + 1;
			}
			else if (d == Direction.East)
			{
				return xt == x || xt == x + xlen - 1 || yt == a(y, ylen) || yt == b(y, ylen);
			}
			else if (d == Direction.South)
			{
				return xt == a(x, xlen) || xt == b(x, xlen) || yt == y || yt == y + ylen - 1;
			}
			else if (d == Direction.West)
			{
				return xt == x || xt == x - xlen + 1 || yt == a(y, ylen) || yt == b(y, ylen);
			}

			throw new InvalidOperationException();
		}