Ejemplo n.º 1
0
        public void Turn(RelativeDirections direction)
        {
            if (!Enum.IsDefined(typeof(RelativeDirections), direction))
            {
                throw new RelativeDirectionNotValid(direction.ToString());
            }

            CompassDirections compassDirection;

            switch (direction)
            {
            case RelativeDirections.Left:
                compassDirection = (CompassDirections)(((int)Facade + 90) % 360);
                break;

            case RelativeDirections.Right:
                compassDirection = (CompassDirections)(((int)Facade + 270) % 360);
                break;

            default:
                throw new DevelopmentException($"There is uncovered switch-case state [{direction.ToString()}]");
            }

            Facade = compassDirection;
        }
        public IEntity Feel(RelativeDirections relativeDirection, Warrior TheWarrior, Room TheRoom)
        {
            var location  = _GetCurrentLocation(TheWarrior, TheRoom);
            var direction = _ComputeAbsoluteDirection(TheWarrior, relativeDirection);
            var entity    = _GetEntityAt(TheRoom, location, direction, 1);

            return(entity);
        }
Ejemplo n.º 3
0
        public void WhenTurnOperationExecuted_CurrentPositionShouldBeSame(RelativeDirections relativeDirection)
        {
            var sut             = new Rover();
            var initialPosition = new Point(sut.CurrentPoint.X, sut.CurrentPoint.Y);

            sut.Turn(relativeDirection);

            Assert.Equal(initialPosition, sut.CurrentPoint);
        }
Ejemplo n.º 4
0
        public void WhenMoveOperationExecuted_RoverStateShouldBeChange(int currentX, int currentY, CompassDirections currentDirection,
                                                                       RelativeDirections turn, CompassDirections expecedDirection)
        {
            var sut = new Rover(currentX, currentY, currentDirection);
            var expectedPosition = new Point(currentX, currentY);

            sut.Turn(turn);

            Assert.Equal(expectedPosition, sut.CurrentPoint);
            Assert.Equal(expecedDirection, sut.Facade);
        }
Ejemplo n.º 5
0
        public void Turn(RelativeDirections relativeDirection)
        {
            if (!Enum.IsDefined(typeof(RelativeDirections), relativeDirection))
            {
                throw new NotValidException($"Direction is not valid ({relativeDirection.ToString()})", null);
            }

            var compassDirection = relativeDirection switch
            {
                RelativeDirections.Left => (CompassDirections)(((int)Direction + 90) % 360),
                RelativeDirections.Right => (CompassDirections)(((int)Direction + 270) % 360),
                _ => throw new Exception($"Direction is not implemented ({relativeDirection.ToString()})")
            };

            Direction = compassDirection;
        }
Ejemplo n.º 6
0
        public void MoveBackwardThenInverse(RelativeDirections d)
        {
            switch (d)
            {
            case RelativeDirections.Right:
                //move backward then turn left
                break;

            case RelativeDirections.Left:
                //move backward then turn right
                break;

            case RelativeDirections.Front:
                //move backward, without changing direction
                break;

            default:
                break;
            }
        }
Ejemplo n.º 7
0
        public void ChangeDirectionAndMove(RelativeDirections d)
        {
            //make motors move robot 1 step in Direction (d)
            //1 step = UnitOfMovement cm
            switch (d)
            {
            case RelativeDirections.Right:
                //turn right then move forward
                break;

            case RelativeDirections.Left:
                //turn left then move forward
                break;

            case RelativeDirections.Front:
                //move forward, without changing direction
                break;

            default:
                break;
            }
        }
 public bool FeelsSomething(RelativeDirections relativeDirections)
 {
     throw new NotImplementedException();
 }
 public bool FeelsSomething(RelativeDirections relativeDirections)
 {
     return false;
 }
 public bool FeelsSomething(RelativeDirections relativeDirections)
 {
     return(false);
 }
 public bool FeelsSomething(RelativeDirections relativeDirections)
 {
     throw new NotImplementedException();
 }
        /// <summary>
        /// Can compute the direction you get by starting at an absolute direction (ie. North)
        /// using a relative direction (ie. left) and can compute the absolute direction
        /// that results (ie. West)
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="relativeDirection"></param>
        /// <returns></returns>
        private AbsoluteDirections _ComputeAbsoluteDirection(ISentientEntity entity, RelativeDirections relativeDirection)
        {
            var warriorDirection = FindDirectionFacing(entity);
            switch (warriorDirection)
            {
                case AbsoluteDirections.North:
                    switch (relativeDirection)
                    {
                        case RelativeDirections.InFront:
                            return AbsoluteDirections.North;
                        case RelativeDirections.ToTheLeftSide:
                            return AbsoluteDirections.West;
                        case RelativeDirections.Behind:
                            return AbsoluteDirections.South;
                        case RelativeDirections.ToTheRightSide:
                            return AbsoluteDirections.East;
                    }
                    break;
                case AbsoluteDirections.West:
                    switch (relativeDirection)
                    {
                        case RelativeDirections.InFront:
                            return AbsoluteDirections.West;
                        case RelativeDirections.ToTheLeftSide:
                            return AbsoluteDirections.South;
                        case RelativeDirections.Behind:
                            return AbsoluteDirections.East;
                        case RelativeDirections.ToTheRightSide:
                            return AbsoluteDirections.North;
                    }
                    break;
                case AbsoluteDirections.South:
                    switch (relativeDirection)
                    {
                        case RelativeDirections.InFront:
                            return AbsoluteDirections.South;
                        case RelativeDirections.ToTheLeftSide:
                            return AbsoluteDirections.East;
                        case RelativeDirections.Behind:
                            return AbsoluteDirections.North;
                        case RelativeDirections.ToTheRightSide:
                            return AbsoluteDirections.West;
                    }
                    break;
                case AbsoluteDirections.East:
                    switch (relativeDirection)
                    {
                        case RelativeDirections.InFront:
                            return AbsoluteDirections.East;
                        case RelativeDirections.ToTheLeftSide:
                            return AbsoluteDirections.North;
                        case RelativeDirections.Behind:
                            return AbsoluteDirections.West;
                        case RelativeDirections.ToTheRightSide:
                            return AbsoluteDirections.South;
                    }
                    break;
            }

            throw new GeneralGameException("The direction could not be computed. This makes no sense at all.");
        }
 public void Turn(ISentientEntity TheWarrior, RelativeDirections relativeDirections)
 {
     TheWarrior.CurrentDirection = _ComputeAbsoluteDirection(TheWarrior, relativeDirections);
 }
 public IEntity Feel(RelativeDirections relativeDirection, Warrior TheWarrior, Room TheRoom)
 {
     var location = _GetCurrentLocation(TheWarrior, TheRoom);
     var direction = _ComputeAbsoluteDirection(TheWarrior, relativeDirection);
     var entity = _GetEntityAt(TheRoom, location, direction, 1);
     return entity;
 }
 public void Turn(ISentientEntity TheWarrior, RelativeDirections relativeDirections)
 {
     TheWarrior.CurrentDirection = _ComputeAbsoluteDirection(TheWarrior, relativeDirections);
 }
        /// <summary>
        /// Can compute the direction you get by starting at an absolute direction (ie. North)
        /// using a relative direction (ie. left) and can compute the absolute direction
        /// that results (ie. West)
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="relativeDirection"></param>
        /// <returns></returns>
        private AbsoluteDirections _ComputeAbsoluteDirection(ISentientEntity entity, RelativeDirections relativeDirection)
        {
            var warriorDirection = FindDirectionFacing(entity);

            switch (warriorDirection)
            {
            case AbsoluteDirections.North:
                switch (relativeDirection)
                {
                case RelativeDirections.InFront:
                    return(AbsoluteDirections.North);

                case RelativeDirections.ToTheLeftSide:
                    return(AbsoluteDirections.West);

                case RelativeDirections.Behind:
                    return(AbsoluteDirections.South);

                case RelativeDirections.ToTheRightSide:
                    return(AbsoluteDirections.East);
                }
                break;

            case AbsoluteDirections.West:
                switch (relativeDirection)
                {
                case RelativeDirections.InFront:
                    return(AbsoluteDirections.West);

                case RelativeDirections.ToTheLeftSide:
                    return(AbsoluteDirections.South);

                case RelativeDirections.Behind:
                    return(AbsoluteDirections.East);

                case RelativeDirections.ToTheRightSide:
                    return(AbsoluteDirections.North);
                }
                break;

            case AbsoluteDirections.South:
                switch (relativeDirection)
                {
                case RelativeDirections.InFront:
                    return(AbsoluteDirections.South);

                case RelativeDirections.ToTheLeftSide:
                    return(AbsoluteDirections.East);

                case RelativeDirections.Behind:
                    return(AbsoluteDirections.North);

                case RelativeDirections.ToTheRightSide:
                    return(AbsoluteDirections.West);
                }
                break;

            case AbsoluteDirections.East:
                switch (relativeDirection)
                {
                case RelativeDirections.InFront:
                    return(AbsoluteDirections.East);

                case RelativeDirections.ToTheLeftSide:
                    return(AbsoluteDirections.North);

                case RelativeDirections.Behind:
                    return(AbsoluteDirections.West);

                case RelativeDirections.ToTheRightSide:
                    return(AbsoluteDirections.South);
                }
                break;
            }

            throw new GeneralGameException("The direction could not be computed. This makes no sense at all.");
        }