Esempio n. 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));
        }
Esempio n. 2
0
 public void ExecuteCommand(RoverState state)
 {
     if (CanMove(state))
     {
         _movesStrategy[state.CurrentFacing].Move(state);
     }
 }
Esempio n. 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));
        }
Esempio n. 4
0
        public void TestRoverStateCanCloneOtherRoverState(RoverState state)
        {
            var clonedState = RoverState.Clone(state);

            Assert.True(clonedState.Equals(state));
            Assert.True(state.Equals(clonedState));
        }
Esempio n. 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));
        }
Esempio n. 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);
        }
        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);
        }
Esempio n. 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)}"));
        }
Esempio n. 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);
            }
        }
Esempio n. 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);
        }
Esempio n. 13
0
 public void TestRoverStateCanCompareEquality(RoverState state1, RoverState state2, bool expected)
 {
     Assert.Equal(expected, state1.Equals(state2));
     Assert.Equal(expected, state2.Equals(state1));
 }
Esempio n. 14
0
 public void TestRoverStateCanOutputState(RoverState state)
 {
     Assert.Equal($"{state.x} {state.y} {DirectionEnumHelper.ToString(state.direction)}", state.Output());
 }
Esempio n. 15
0
 public Rover(Position position, Direction direction, IGrid grid)
 {
     RoverState = new RoverState(position, direction);
     _navigator = new Navigator(grid);
     _obstacleDetector = new ObstacleDetector(grid);
 }
Esempio n. 16
0
 public MoveForwardCommand(RoverState roverState, INavigator navigator, IObstacleDetector obstacleDetector)
     : base(roverState, navigator, obstacleDetector)
 {
 }
Esempio n. 17
0
 protected GoCommand(RoverState roverState)
 {
     RoverState = roverState;
 }
Esempio n. 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);
        }
Esempio n. 19
0
        public void RoverCanReturnCurrentSatus(RoverState initialState)
        {
            var rover = new Rover.Rover(_fixture.map, initialState);

            Assert.True(initialState.Equals(rover.GetCurrentState()));
        }
Esempio n. 20
0
 public void Move(RoverState state)
 {
     state.PositionY--;
 }
Esempio n. 21
0
 public TurnRightCommand(RoverState roverState)
     : base(roverState)
 {
 }
Esempio n. 22
0
 public void Move(RoverState state)
 {
     state.PositionX++;
 }
Esempio n. 23
0
 public TurnLeftCommand(RoverState roverState)
     : base(roverState)
 {
 }
Esempio n. 24
0
 protected MoveCommand(RoverState roverState, INavigator navigator, IObstacleDetector obstacleDetector)
     : base(roverState)
 {
     Navigator = navigator;
     ObstacleDetector = obstacleDetector;
 }
Esempio n. 25
0
 public void ExecuteCommand(RoverState state)
 {
     state.CurrentFacing = _rotatesToLeft[state.CurrentFacing].Rotate();
 }
Esempio n. 26
0
 public void SetOperating()
 {
     State = RoverState.Operating;
 }
Esempio n. 27
0
 public void SetStopped()
 {
     State = RoverState.Stopped;
 }
Esempio n. 28
0
 public MarsRoverBuggy(RoverState rs)
 {
     RoverState = rs;
 }
Esempio n. 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);
 }