Example #1
0
        public Position NewHeadPosition()
        {
            var headPosition = this.Snake.Head;
            var newDirection = directions[(int)direction];

            var newPosition = new Position(headPosition.Row + newDirection.Row, headPosition.Col + newDirection.Col);

            return newPosition;
        }
        public static void Find(Position start, Position end, string[,] matrix, Position[] path = null, int counter = 0)
        {
            if (!IsInRange(start, matrix))
            {
                return;
            }

            if (!IsInRange(end, matrix))
            {
                return;
            }

            if (start == end)
            {
                PrintPath(path, counter);
                return;
            }

            if (path == null)
            {
                path = new Position[matrix.GetLength(0) * matrix.GetLength(1)];
                path[counter] = start;
                ++counter;
            }

            if (IsInRange(new Position(start.X + 1, start.Y), matrix) && matrix[start.X + 1, start.Y] == "0")
            {
                matrix[start.X + 1, start.Y] = "x";
                path[counter] = new Position(start.X + 1, start.Y);
                Find(new Position(start.X + 1, start.Y), end, matrix, path, counter + 1);
                matrix[start.X + 1, start.Y] = "0";
            }

            if (IsInRange(new Position(start.X, start.Y + 1), matrix) && matrix[start.X, start.Y + 1] == "0")
            {
                matrix[start.X, start.Y + 1] = "x";
                path[counter] = new Position(start.X, start.Y + 1);
                Find(new Position(start.X, start.Y + 1), end, matrix, path, counter + 1);
                matrix[start.X, start.Y + 1] = "0";
            }

            if (IsInRange(new Position(start.X - 1, start.Y), matrix) && matrix[start.X - 1, start.Y] == "0")
            {
                matrix[start.X - 1, start.Y] = "x";
                path[counter] = new Position(start.X - 1, start.Y);
                Find(new Position(start.X - 1, start.Y), end, matrix, path, counter + 1);
                matrix[start.X - 1, start.Y] = "0";
            }

            if (IsInRange(new Position(start.X, start.Y - 1), matrix) && matrix[start.X, start.Y - 1] == "0")
            {
                matrix[start.X, start.Y - 1] = "x";
                path[counter] = new Position(start.X, start.Y - 1);
                Find(new Position(start.X, start.Y - 1), end, matrix, path, counter + 1);
                matrix[start.X, start.Y - 1] = "0";
            }
        }
        public static bool Find(Position start, Position end, string[,] matrix)
        {
            if (!IsInRange(start, matrix))
            {
                return false;
            }

            if (!IsInRange(end, matrix))
            {
                return false;
            }

            if (start == end)
            {
                Console.WriteLine("A path is found");
                return true;
            }

            if (IsInRange(new Position(start.X + 1, start.Y), matrix) && matrix[start.X + 1, start.Y] == "0")
            {
                matrix[start.X + 1, start.Y] = "x";
                if (Find(new Position(start.X + 1, start.Y), end, matrix))
                {
                    return true;
                }
            }

            if (IsInRange(new Position(start.X, start.Y + 1), matrix) && matrix[start.X, start.Y + 1] == "0")
            {
                matrix[start.X, start.Y + 1] = "x";
                if (Find(new Position(start.X, start.Y + 1), end, matrix))
                {
                    return true;
                }
            }

            if (IsInRange(new Position(start.X - 1, start.Y), matrix) && matrix[start.X - 1, start.Y] == "0")
            {
                matrix[start.X - 1, start.Y] = "x";
                if (Find(new Position(start.X - 1, start.Y), end, matrix))
                {
                    return true;
                }
            }

            if (IsInRange(new Position(start.X, start.Y - 1), matrix) && matrix[start.X, start.Y - 1] == "0")
            {
                matrix[start.X, start.Y - 1] = "x";
                if (Find(new Position(start.X, start.Y - 1), end, matrix))
                {
                    return true;
                }
            }

            return false;
        }
Example #4
0
        public void ChangePosition()
        {
            this.Snake.Dequeue();

            var headPosition = this.Snake.Head;
            var newDirection = directions[(int)direction];

            var newPosition = new Position(headPosition.Row + newDirection.Row, headPosition.Col + newDirection.Col);

            this.Snake.Enqueue(newPosition);
        }
		public void Create_GoalOther_After58Turns()
		{
			var ball = new Position(1400, 600);
			var velo = new Velocity(11, 0);

			var act = BallPath.Create(ball, velo, 0, 1000);

			var expEnding = BallPath.Ending.GoalOther;
			var expLength = 58;

			Assert.AreEqual(expEnding, act.End);
			Assert.AreEqual(expLength, act.Count);
		}
		public void Create_GoalOwn_After47Turns()
		{
			var ball = new Position(400, 400);
			var velo = new Velocity(-10, 1.9f);

			var act = BallPath.Create(ball, velo, 0, 1000);

			var expEnding = BallPath.Ending.GoalOwn;
			var expLength = 47;

			Assert.AreEqual(expEnding, act.End);
			Assert.AreEqual(expLength, act.Count);
		}
		public void Create_EndOfGame_After10Turns()
		{
			var ball = new Position(1400, 600);
			var velo = new Velocity(11, 0);

			var act = BallPath.Create(ball, velo, 0,10);

			var expEnding = BallPath.Ending.EndOfGame;
			var expLength = 10;

			Assert.AreEqual(expEnding, act.End);
			Assert.AreEqual(expLength, act.Count);
		}
        private static void PrintPath(Position[] path, int counter)
        {
            var builder = new StringBuilder();
            builder.Append("{");

            for (int i = 0; i < counter; i++)
            {
                builder.Append(path[i].ToString() + ", ");
            }

            builder.Append("}");

            Console.WriteLine(builder);
        }
		public void Create_Player_ReachesTheTargetIn44Turns()
		{
			var player = new PlayerInfo()
			{
				Position = new Position(200, 200),
				Velocity = new Velocity(-2, 0),
			};

			var target = new Position(300, 200);

			var act = PlayerPath.Create(player, target, 100, Distance.Pickup);
			var exp = 44;
			Assert.AreEqual(exp, act.Count);
		}
        private static bool IsInRange(Position start, string[,] matrix)
        {
            if (start.X >= matrix.GetLength(0) || start.X < 0)
            {
                return false;
            }

            if (start.Y >= matrix.GetLength(1) || start.Y < 0)
            {
                return false;
            }

            return true;
        }
        public static void Main()
        {
            string[,] matrix = new string[6, 6]
                {
                    { "0", "0", "0", "x", "0", "x"},
                    { "0", "x", "0", "x", "0", "x"},
                    { "0", "0", "x", "0", "x", "0"},
                    { "0", "x", "0", "0", "0", "0"},
                    { "0", "0", "0", "x", "x", "0"},
                    { "0", "0", "0", "x", "0", "x"},
                };

            var start = new Position(2, 1);
            var end = new Position(2, 3);

            Pathfinder.Find(start, end, matrix);
        }
        protected static List<Position> FindArea(Position start, string[,] matrix, List<Position> area = null)
        {
            if (!IsInRange(start, matrix))
            {
                return new List<Position>();
            }

            if (area == null)
            {
                area = new List<Position>();
                area.Add(start);
                matrix[start.X, start.Y] = "x";
            }

            if (IsInRange(new Position(start.X + 1, start.Y), matrix) && matrix[start.X + 1, start.Y] == "0")
            {
                matrix[start.X + 1, start.Y] = "x";
                area.Add(new Position(start.X + 1, start.Y));
                FindArea(new Position(start.X + 1, start.Y), matrix, area);
            }

            if (IsInRange(new Position(start.X, start.Y + 1), matrix) && matrix[start.X, start.Y + 1] == "0")
            {
                matrix[start.X, start.Y + 1] = "x";
                area.Add(new Position(start.X, start.Y + 1));
                FindArea(new Position(start.X, start.Y + 1),matrix, area);
            }

            if (IsInRange(new Position(start.X - 1, start.Y), matrix) && matrix[start.X - 1, start.Y] == "0")
            {
                matrix[start.X - 1, start.Y] = "x";
                area.Add(new Position(start.X - 1, start.Y));
                FindArea(new Position(start.X - 1, start.Y), matrix, area);
            }

            if (IsInRange(new Position(start.X, start.Y - 1), matrix) && matrix[start.X, start.Y - 1] == "0")
            {
                matrix[start.X, start.Y - 1] = "x";
                area.Add(new Position(start.X, start.Y - 1));
                FindArea(new Position(start.X, start.Y - 1), matrix, area);
            }

            return area;
        }
Example #13
0
        protected override Position GetRandomPosition()
        {
            int foodX = randomGenerator.Next(0, Console.BufferHeight - 1);
            int foodY = randomGenerator.Next(0, Console.BufferWidth - 1);

            var position = new Position(foodX, foodY);
            if (this.snake != null)
            {
                while (this.snake.SnakeElements.Contains(position))
                {
                    foodX = randomGenerator.Next(0, Console.BufferHeight - 1);
                    foodY = randomGenerator.Next(0, Console.BufferWidth - 1);

                    position = new Position(foodX, foodY);
                }
            }

            return position;
        }
        public static void Main()
        {
            var matrix = new string[100, 100];

            for (int i = 0; i < 100; i++)
            {
                for (int j = 0; j < 100; j++)
                {
                    matrix[i, j] = "0";
                }
            }

            var start = new Position(2, 1);
            var end = new Position(88, 93);

            if (!Pathfinder.Find(start, end, matrix))
            {
                Console.WriteLine("A path is not found");
            }
        }
Example #15
0
        public void EnlargeSnake()
        {
            var headPosition = this.Snake.Head;
            var newDirection = directions[(int)direction];

            var newPosition = new Position(headPosition.Row + newDirection.Row, headPosition.Col + newDirection.Col);

            this.Snake.Enqueue(newPosition);
        }
Example #16
0
 public void GenerateNewFood(Position position)
 {
     var food = new Food(position);
     this.Food = food;
 }
Example #17
0
 public Food(Position position)
 {
     this.Position = position;
 }