private bool MoveCheck(PlateauModel plateau, RoverModel rover)
{
return((rover.XCoord >= 0) &&
(rover.XCoord <= plateau.Width) &&
(rover.YCoord >= 0) &&
(rover.YCoord <= plateau.Height));
}
public void IsTurnedTest()
{
RoverModel rover = null;
rover = new AlphaRover();
int roverOne = rover.AddRover(101, 2, 3, 'e');
int areaOne = rover.AddArea(102, 0, 0, 5, 5);
int roverFromNorth = rover.AddRover(102, 4, 4, 'N');
int roverTrunFromWest = rover.AddRover(103, 5, 5, 'W');
int areaIntoRover = rover.AddRoverIntoArea(roverOne, areaOne);
bool isTurneLeft = rover.IsTurned(rover.GetRover(roverOne), 'L');
bool isAnyUnexpectedChar = rover.IsTurned(rover.GetRover(roverOne), 'M');
bool isTurneRight = rover.IsTurned(rover.GetRover(roverOne), 'R');
bool isTurnedFromNorth = rover.IsTurned(rover.GetRover(roverFromNorth), 'l');
bool isContainAnySpecialChar = rover.IsTurned(rover.GetRover(roverFromNorth), ',');
bool isContainAnyNumber = rover.IsTurned(rover.GetRover(roverFromNorth), '1');
bool isTurnedFromWest = rover.IsTurned(rover.GetRover(roverTrunFromWest), 'r');
Assert.IsTrue(isTurneLeft);
Assert.IsTrue(isTurneRight);
Assert.IsTrue(isTurnedFromNorth);
Assert.IsTrue(isTurnedFromWest);
Assert.IsFalse(isAnyUnexpectedChar);
Assert.IsFalse(isContainAnySpecialChar);
Assert.IsFalse(isContainAnyNumber);
}
public void RoverModelTest_CalculateNewPositions_Errors()
{
var rover = new RoverModel(Container);
rover.StartRover(5, 5, "", "");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(5, 5, " - -", "-('");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(5, 5, "1 1", "MMRM");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(5, 5, "1 1 W", "MMRM");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(5, 5, "1 ", "M");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(0, 0, "1 1 S", "M");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(0, 0, "1 1 S", "M---");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover(0, 0, "1 1111111( S", "M---");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.StartRover('r', 'r', "1 1 W", "MMRM");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.Dispose();
}
/// <summary>
/// İstenilen yönüne göre hareket eylemine yönlendirir.
/// </summary>
/// <param name="rover"></param>
/// <param name="plateau"></param>
/// <returns></returns>
private RoverModel Move(RoverModel rover, PlateauModel plateau)
{
foreach (var movingDirection in rover.Movement.MovementList)
{
switch (movingDirection)
{
case MovementAbility.L:
MoveLeft(rover);
break;
case MovementAbility.R:
MoveRight(rover);
break;
case MovementAbility.M:
MoveStraight(rover, plateau);
break;
default:
throw new InvalidMovementAbilityParamException("Invalid moving key for rover");
}
}
return(rover);
}
//Rover in the plateau checker
private static bool CheckRoverPosition(RoverModel rover)
{
return(rover.Position.PositionX <= rover.Plateau.SizeOfX &&
rover.Position.PositionX >= 0 &&
rover.Position.PositionY <= rover.Plateau.SizeOfY &&
rover.Position.PositionY >= 0);
}
public void PrepareRover(RoverModel model)
{
if (model.ErrorTracer == null)
{
_rover = Rover.CreateRover(this);
_rover.X = model.X;
_rover.Y = model.Y;
_rover.Direction = EnumConvertor.ConvertCharToDirection(model);
_rover.Plateau = _plateaus;
if (model.X < 0 || model.X < 0)
{
_rover.ErrorMessage = MessageConstant.RoverPlateauCoordinateFail;
}
if (model.Plateau.UpperRight < model.X || model.Plateau.LowerLeft < model.X)
{
_rover.ErrorMessage = MessageConstant.RoverPlateauCoordinateFail;
}
if (model.Plateau.UpperRight < model.Y || model.Plateau.LowerLeft < model.Y)
{
_rover.ErrorMessage = MessageConstant.RoverPlateauCoordinateFail;
}
}
}
private static void TurnLeft(RoverModel roverModel)
{
LinkedListNode <string> currentIndex = directions.Find(roverModel.RoverD);
LinkedListNode <string> newDirection = currentIndex.Next ?? currentIndex.List.First;
roverModel.RoverD = newDirection.Value;
}
public RoverModel RoverCurrentPosition(string roverid)
{
char dir = Char.MinValue;
if (_facing == N)
{
dir = 'N';
}
else if (_facing == E)
{
dir = 'E';
}
else if (_facing == S)
{
dir = 'S';
}
else if (_facing == W)
{
dir = 'W';
}
RoverModel roverModel = new RoverModel
{
CurrentDirection = dir.ToString(),
Id = roverid,
CurrentX = _x,
CurrentY = _y
};
return(roverModel);
}
public RoverModel UpdateRover(RoverModel roverModel)
{
//UpdateRover
var getRover = _roverRepository.UpdateRoverInfo(roverModel);
return(getRover);
}
public IHttpActionResult Post([FromBody] RoverDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// convert dto to model
var comps = new List <RoverModel.Coordinate>();
foreach (string coord in dto.Components)
{
comps.Add(RoverModel.ToCoordinate(coord));
}
var model = new RoverModel()
{
GridSize = Convert.ToInt32(dto.GridSize),
RoverPosition = RoverModel.ToCoordinate(dto.RoverPosition),
Components = comps
};
// end convert to model
var roverMovements = RoverService.ProcessRover(model);
return(Ok(roverMovements));
}
public static Compass ConvertCharToDirection(RoverModel model)
{
Compass direction = Compass.North;
switch (Char.ToUpper(model.Direction))
{
case 'N':
direction = Compass.North;
break;
case 'E':
direction = Compass.East;
break;
case 'W':
direction = Compass.West;
break;
case 'S':
direction = Compass.South;
break;
default:
model.ErrorTracer = MessageConstant.WrongInput;
break;
}
return(direction);
}
public IActionResult Post(RoverModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.RoverId <= 0)
{
return(BadRequest("Id should be a positive integer value."));
}
try
{
var rover = RoverFactory.Create(model.RoverId, model.RoverName, 0, 0, Direction.N);
return(Ok(new { RoverId = rover.Id, RoverName = rover.Name }));
}
catch (System.Exception ex)
{
if (ex.Message == "EXISTS")
{
return(Conflict(new ApiResponse
{
Status = 409,
Message = "Rover already exists, Cannot be created"
}));
}
else
{
return(StatusCode(500));
}
}
}
public IActionResult Post(RoverModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.RoverId <= 0)
{
return(BadRequest(Messages.InvalidId));
}
try
{
var rover = RoverFactory.Create(model.RoverId, model.RoverName, 0, 0, Direction.N);
return(Ok(new { RoverId = rover.Id, RoverName = rover.Name }));
}
catch (System.Exception ex)
{
if (ex.Message == "EXISTS")
{
return(Conflict(new ApiResponse
{
Status = 409,
Message = Messages.RoverAlreadyExist
}));
}
else
{
return(StatusCode(500));
}
}
}
public bool Move(PlateauModel plateau, RoverModel rover)
{
if (!CanItMove(plateau, rover))
{
return(false);
}
switch (rover.Direction)
{
case DirectionEnum.N:
rover.CurrentYCoordinate += 1;
break;
case DirectionEnum.E:
rover.CurrentXCoordinate += 1;
break;
case DirectionEnum.S:
rover.CurrentYCoordinate -= 1;
break;
case DirectionEnum.W:
rover.CurrentXCoordinate -= 1;
break;
}
return(true);
}
public void RoverModelTest_CalculateNewPositions()
{
var rover = new RoverModel(Container);
rover.StartRover(5, 5, "1 1 N", "MMRM");
Assert.AreEqual("2 3 E", rover.CalculateNewPosition());
rover.StartRover(5, 5, "3 5 S", "M");
Assert.AreEqual("3 4 S", rover.CalculateNewPosition());
// keep the same direction as previous when error occurs
// 35S is a wrong position
rover.StartRover(5, 5, "35S", "M");
Assert.AreEqual("3 4 S", rover.CalculateNewPosition());
rover.Dispose();
rover.StartRover(54444444, 123456445, "54443444 123456425 S", "MML");
Assert.AreEqual("54443444 123456423 E", rover.CalculateNewPosition());
rover.Dispose();
rover.StartRover(5, 5, "35S", "M");
Assert.AreEqual("", rover.CalculateNewPosition());
rover.Dispose();
}
/// <summary>
/// A set of numbered components are placed on a grid, a rover is placed on a random grid
/// coordinate and has to pick up the numbered components in ascending order(starting with 1).
/// Once the last component has been picked up the solution is complete.
/// </summary>
/// <returns>Returns a list of movements performed by the rover.</returns>
public IEnumerable <string> ProcessRover(RoverModel model)
{
var movementHistory = new List <string>();
foreach (RoverModel.Coordinate componentPosition in model.Components)
{
var availableCoords = GetAllCoords(model.GridSize, model.RoverPosition);
while (!model.RoverPosition.Equals(componentPosition)) // seek until landing on component
{
RoverModel.Coordinate nextMove = GetNextMove(model.RoverPosition, availableCoords, model.GridSize);
movementHistory.Add(SetDirection(nextMove, model.RoverPosition));
if (availableCoords.Contains(nextMove))
{
availableCoords.Remove(nextMove);
}
model.RoverPosition = nextMove;
}
// landed on component so add pickup to movement
movementHistory.Add("P");
}
return(movementHistory);
}
//Move 1 unit to the selected direction
private static RoverModel MoveRover(RoverModel rover)
{
var cloneRover = rover;
switch (rover.Position.Direction)
{
case DirectionEnum.N:
rover.Position.PositionY++;
break;
case DirectionEnum.S:
rover.Position.PositionY--;
break;
case DirectionEnum.W:
rover.Position.PositionX--;
break;
case DirectionEnum.E:
rover.Position.PositionX++;
break;
default:
throw new InvalidOperationException();
}
if (!CheckRoverPosition(rover))
{
return(cloneRover);
}
return(rover);
}
private static void TurnRight(RoverModel roverModel)
{
LinkedListNode <string> currentIndex = directions.Find(roverModel.RoverD);
LinkedListNode <string> newDirection = currentIndex.Previous ?? currentIndex.List.Last;
roverModel.RoverD = newDirection.Value;
}
public RoverViewModel(MainWindowViewModel mw)
{
Model = new RoverModel
{
roverName = "Phoenix I"
};
mainWindow = mw;
}
/// <summary>
/// Gezicinin plato üzerinde hareketini hesaplar.
/// </summary>
/// <param name="rover"></param>
/// <param name="plateau"></param>
/// <returns></returns>
public RoverModel CalculateRoverMovement(RoverModel rover, PlateauModel plateau)
{
if (rover == null)
{
throw new BadRequestException("Please check your requested Rover Model.");
}
return(Move(rover, plateau));
}
public void MoveRover(RoverModel model)
{
if (model.ErrorTracer == null)
{
var result = _rover.Move(model.Movement.ToUpper());
_rover.ErrorMessage = !result ? MessageConstant.MovementInstructionFail : null;
}
}
public string CalculatePosition(PlateauModel plateau, RoverModel rover, string order)
{
for (int i = 0; i < order.Length; i++)
{
rover = Execute(plateau, rover, order[i]);
}
return($"{rover.XCoord} {rover.YCoord} {rover.Direction}");
}
public RoverViewModel(MainWindowViewModel mw)
{
Model = new RoverModel
{
roverName = "Phoenix I"
};
mainWindow = mw;
}
static void Main(string[] args)
{
Console.WriteLine("Mission started.");
// create service collection
RegisterServices();
var roverService = _serviceProvider.GetService <IRoverService>();
bool IsContinue;
Console.WriteLine("Please enter the upper-right coordinates of the plateau.(Format=X Y)");
Console.WriteLine("Info: Consider that the lower-left coordinates are assumed to be 0,0");
string upperRightCoordinates = Console.ReadLine();
var _plateauCoordinates = upperRightCoordinates.Split(" ");
do
{
Console.WriteLine("Please enter the current coordinates and direction(N/E/S/W). (Format=X Y D)");
string currentCoordinates = Console.ReadLine();
var _currentCoordinates = currentCoordinates.Split(" ");
Enum.TryParse(_currentCoordinates[2], out DirectionEnum _direction);
Console.WriteLine("Please enter the your intsructions. (L=left, R=right, M=Move)");
string command = Console.ReadLine();
var plateau = new PlateauModel(Convert.ToInt32(_plateauCoordinates[0]), Convert.ToInt32(_plateauCoordinates[1]));
var rover = new RoverModel(Convert.ToInt32(_currentCoordinates[0]), Convert.ToInt32(_currentCoordinates[1]), _direction, command);
var response = roverService.Run(plateau, rover);
if (!response.HasError)
{
Console.WriteLine($"Current location info: {response.Data.CurrentXCoordinate} {response.Data.CurrentYCoordinate} {response.Data.Direction}");
Console.WriteLine("Do you want to move new rover? (Y/N)");
string moveNewRover = Console.ReadLine();
if (moveNewRover.ToUpper() == "Y")
{
IsContinue = true;
}
else
{
IsContinue = false;
}
}
else
{
Console.WriteLine($"{response.Errors}");
IsContinue = false;
}
} while (IsContinue);
Console.WriteLine("Mission completed.");
DisposeServices();
}
public IActionResult Put(int roverId, RoverModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var rover = RoverFactory.Update(roverId, model.RoverName);
return(Ok(new { RoverId = rover.Id, RoverName = rover.Name }));
}
public RoverModel UpdateRoverInfo(RoverModel roverModel)
{
using (var db = new LiteDatabase(Connection))
{
var collection = db.GetCollection <RoverModel>("roverModel");
collection.Update(roverModel);
var resultModel = collection.Find(x => x.Id == roverModel.Id).FirstOrDefault();
return(resultModel);
}
}
public RoverViewModel Move([FromBody] RoverModel model)
{
if (_roverCaching.IsItemExists(model.Id))
{
var result = _rover.Process(Get(model.Id), model.MovementInstruction);
_roverCaching.Remove(model.Id);
_roverCaching.SetItem(model.Id, result);
}
return(Get(model.Id));
}
public void RoverFinalPosition_ShouldReturnExpectedValue_WhenInstructionsAreSet()
{
PlateauModel plateau = new PlateauModel(5, 5);
RoverModel rover = new RoverModel(1, 2, "N");
string order = "LMLMLMLMM";
var roverActionService = new RoverActionService();
var actual = roverActionService.CalculatePosition(plateau, rover, order);
Assert.Equal("1 3 N", actual);
}
/// <summary>
/// Sola hareket eylemini sağlar.
/// </summary>
/// <param name="rover"></param>
private void MoveLeft(RoverModel rover)
{
rover.DeploymentPoint.Direction = rover.DeploymentPoint.Direction switch
{
Direction.N => Direction.W,
Direction.W => Direction.S,
Direction.S => Direction.E,
Direction.E => Direction.N,
_ => throw new ArgumentOutOfRangeException(),
};
}
public IActionResult Rename([FromBody] RoverModel model)
{
if (_roverCaching.IsItemExists(model.Id))
{
var roverViewModel = Get(model.Id);
roverViewModel.Name = model.Name;
_roverCaching.Remove(model.Id);
_roverCaching.SetItem(model.Id, roverViewModel);
}
return(NoContent());
}
private static void GetInputForPath(RoverModel rover, IManager manager)
{
do
{
manager.MoveRover(rover);
if (rover.ErrorTracer != null)
{
Console.WriteLine(rover.ErrorTracer);
}
} while (rover.ErrorTracer != null);
}
