Пример #1
0
        private Rover GenerateRover(int positionX, int positionY, FacingTypes facingTo)
        {
            var roverInitialState = new RoverState(positionX, positionY, facingTo);
            var roverContext      = new RoverContext(roverInitialState);

            return(new Rover(roverContext));
        }
Пример #2
0
 public void ExecuteCommand(RoverState state)
 {
     if (CanMove(state))
     {
         _movesStrategy[state.CurrentFacing].Move(state);
     }
 }
Пример #3
0
        public void RoverCanMoveForward(RoverState initialState, RoverState expectedState)
        {
            var rover = new Rover.Rover(_fixture.map, initialState);

            rover.MoveForward();
            Assert.True(rover.GetCurrentState().Equals(expectedState));
        }
Пример #4
0
        public void TestRoverStateCanCloneOtherRoverState(RoverState state)
        {
            var clonedState = RoverState.Clone(state);

            Assert.True(clonedState.Equals(state));
            Assert.True(state.Equals(clonedState));
        }
Пример #5
0
        public void RoverCanTrun(RoverState initialState, Rover.Rover.Turns turn, RoverState expectedState)
        {
            var rover = new Rover.Rover(_fixture.map, initialState);

            rover.Turn(turn);
            Assert.True(rover.GetCurrentState().Equals(expectedState));
        }
Пример #6
0
        public void move_rover_forwards_and_backwards()
        {
            RoverState initialState = new RoverState { Facing = rover.CurrentState.Facing, X = rover.CurrentState.X, Y = rover.CurrentState.Y };

            rover.ExecuteCommands("FBFBFB");

            Assert.AreEqual(rover.CurrentState.Facing, initialState.Facing);
            Assert.AreEqual(rover.CurrentState.X, initialState.X);
            Assert.AreEqual(rover.CurrentState.Y, initialState.Y);
        }
        public void Test_RoverState_Constructor()
        {
            const int x = 5, y = 5;
            const Utils.Orientation orientation = Utils.Orientation.South;
            var state = new RoverState(x, y, orientation);

            Assert.AreEqual(state.X, x);
            Assert.AreEqual(state.Y, y);
            Assert.AreEqual(state.Orientation, orientation);
        }
Пример #8
0
        public void MoveForwardTest()
        {
            RoverState initialState = new RoverState();

            initialState.RoverPosition.X = 0;
            initialState.RoverPosition.Y = 0;
            initialState.RoverDirection  = Direction.N;

            MarsRoverBuggy buggy = new MarsRoverBuggy(initialState);


            buggy.MoveForward();
            Assert.AreEqual(0, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(1, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.N, buggy.RoverState.RoverDirection);

            buggy.MoveForward();
            Assert.AreEqual(0, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.N, buggy.RoverState.RoverDirection);

            buggy.TurnRight();
            buggy.MoveForward();
            Assert.AreEqual(1, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.E, buggy.RoverState.RoverDirection);

            buggy.MoveForward();
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.E, buggy.RoverState.RoverDirection);

            buggy.TurnLeft();
            buggy.MoveForward();
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(3, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.N, buggy.RoverState.RoverDirection);

            buggy.MoveForward();
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(4, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.N, buggy.RoverState.RoverDirection);

            buggy.TurnRight();
            buggy.TurnRight();
            buggy.MoveForward();
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(3, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.S, buggy.RoverState.RoverDirection);

            buggy.MoveForward();
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.X);
            Assert.AreEqual(2, buggy.RoverState.RoverPosition.Y);
            Assert.AreEqual(Direction.S, buggy.RoverState.RoverDirection);
        }
Пример #9
0
        public void move_rover_in_a_square()
        {
            RoverState initialState = new RoverState { Facing = rover.CurrentState.Facing, X = rover.CurrentState.X, Y = rover.CurrentState.Y };

            rover.ExecuteCommands("FFRFF");

            Assert.AreEqual(rover.CurrentState.Facing, Facing.East);
            Assert.AreEqual(rover.CurrentState.X, 2);
            Assert.AreEqual(rover.CurrentState.Y, 2);

            rover.ExecuteCommands("RFFRFFR");

            Assert.AreEqual(rover.CurrentState.Facing, initialState.Facing);
            Assert.AreEqual(rover.CurrentState.X, initialState.X);
            Assert.AreEqual(rover.CurrentState.Y, initialState.Y);
        }
        public void Test_RoverState_Overrides()
        {
            const int x = 5, y = 5;
            const Utils.Orientation orientation = Utils.Orientation.South;

            var state1 = new RoverState(x, y, orientation);
            var state2 = new RoverState(x, y, orientation);

            Assert.IsTrue(state1 == state2);

            state2 = state1.Clone();

            Assert.IsTrue(state1 == state2 && !Object.ReferenceEquals(state1, state2));

            Assert.IsTrue(state1.ToString().Equals($"{x} {y} {Utils.GetDescription(orientation)}"));
        }
Пример #11
0
        private bool CanMove(RoverState state)
        {
            switch (state.CurrentFacing)
            {
            case FacingTypes.North:
                return(state.PositionX > MIN_POSITION);

            case FacingTypes.West:
                return(state.PositionY > MIN_POSITION);

            case FacingTypes.East:
                return(state.PositionY < MAX_POSITION);

            case FacingTypes.South:
                return(state.PositionX < MAX_POSITION);

            default:
                return(true);
            }
        }
Пример #12
0
        public void MoveRightTest()
        {
            RoverState initialState = new RoverState();

            initialState.RoverPosition.X = 0;
            initialState.RoverPosition.Y = 0;
            initialState.RoverDirection  = Direction.N;

            MarsRoverBuggy buggy = new MarsRoverBuggy(initialState);

            buggy.TurnRight();
            Assert.AreEqual(Direction.E, buggy.RoverState.RoverDirection);

            buggy.TurnRight();
            Assert.AreEqual(Direction.S, buggy.RoverState.RoverDirection);

            buggy.TurnRight();
            Assert.AreEqual(Direction.W, buggy.RoverState.RoverDirection);

            buggy.TurnRight();
            Assert.AreEqual(Direction.N, buggy.RoverState.RoverDirection);
        }
Пример #13
0
 public void TestRoverStateCanCompareEquality(RoverState state1, RoverState state2, bool expected)
 {
     Assert.Equal(expected, state1.Equals(state2));
     Assert.Equal(expected, state2.Equals(state1));
 }
Пример #14
0
 public void TestRoverStateCanOutputState(RoverState state)
 {
     Assert.Equal($"{state.x} {state.y} {DirectionEnumHelper.ToString(state.direction)}", state.Output());
 }
Пример #15
0
 public Rover(Position position, Direction direction, IGrid grid)
 {
     RoverState = new RoverState(position, direction);
     _navigator = new Navigator(grid);
     _obstacleDetector = new ObstacleDetector(grid);
 }
Пример #16
0
 public MoveForwardCommand(RoverState roverState, INavigator navigator, IObstacleDetector obstacleDetector)
     : base(roverState, navigator, obstacleDetector)
 {
 }
Пример #17
0
 protected GoCommand(RoverState roverState)
 {
     RoverState = roverState;
 }
Пример #18
0
        public void move_rover_with_some_unrecognized_commands()
        {
            RoverState initialState = new RoverState { Facing = rover.CurrentState.Facing, X = rover.CurrentState.X, Y = rover.CurrentState.Y };

            rover.ExecuteCommands("FFQBB");                             //I'm not 100% sure about this terminating behavior; but let's roll with it for now.

            Assert.AreEqual(rover.CurrentState.X, initialState.X);
            Assert.AreNotEqual(rover.CurrentState.Y, initialState.Y);
        }
Пример #19
0
        public void RoverCanReturnCurrentSatus(RoverState initialState)
        {
            var rover = new Rover.Rover(_fixture.map, initialState);

            Assert.True(initialState.Equals(rover.GetCurrentState()));
        }
Пример #20
0
 public void Move(RoverState state)
 {
     state.PositionY--;
 }
Пример #21
0
 public TurnRightCommand(RoverState roverState)
     : base(roverState)
 {
 }
Пример #22
0
 public void Move(RoverState state)
 {
     state.PositionX++;
 }
Пример #23
0
 public TurnLeftCommand(RoverState roverState)
     : base(roverState)
 {
 }
Пример #24
0
 protected MoveCommand(RoverState roverState, INavigator navigator, IObstacleDetector obstacleDetector)
     : base(roverState)
 {
     Navigator = navigator;
     ObstacleDetector = obstacleDetector;
 }
Пример #25
0
 public void ExecuteCommand(RoverState state)
 {
     state.CurrentFacing = _rotatesToLeft[state.CurrentFacing].Rotate();
 }
Пример #26
0
 public void SetOperating()
 {
     State = RoverState.Operating;
 }
Пример #27
0
 public void SetStopped()
 {
     State = RoverState.Stopped;
 }
Пример #28
0
 public MarsRoverBuggy(RoverState rs)
 {
     RoverState = rs;
 }
Пример #29
0
 public void setRover(RoverState StateIn)
 {
     throttlePID = new RoverPidController(10, 1e-5F, 1e-5F, 50, 1);
     this.roverState = StateIn;
     altitude = Vector3d.Distance(Vessel.mainBody.position, Vessel.transform.position);
     roverActive = true;
     Vessel.ActionGroups.SetGroup(KSPActionGroup.Brakes, false);
 }