/// <summary>
/// Поднятие рабочего органа манипулятора
/// </summary>
/// <param name="time">Время</param>
/// <param name="ZHight">Высота на которую поднимают (Z)</param>
/// <param name="YHight">Координата манипулятора (Y)</param>
/// <param name="x1">Последняя координата контура</param>
/// <param name="y1">Последняя координата контура</param>
/// <param name="Zplot">Высота рабочей области</param>
/// <param name="timeUP">Время подьема</param>
/// <returns></returns>
public static IEnumerable <RobotPosition> Stop(double time, double ZHight, double YHight, double x1, double y1, double Zplot, double timeUP)
{
var aX = (2 * (YHight - y1) / Math.Pow(10, 6)); // ускорение по оси Х
var aY = Math.Abs((2 * (ZHight - Zplot)) / Math.Pow(10, 6)); // ускорение по оси Y
var aZ = (2 * (0 - x1)) / Math.Pow(10, 6) * (-1); // ускорение по оси Z
var a = Zplot;
while (a <= Interpretation.Constants.StartZ)
{
RobotPosition result = new RobotPosition();
result.time = time;
result.z = x1 - (aZ * Math.Pow(timeUP * 1000, 2)) / 2;
result.x = y1 + (aX * Math.Pow(timeUP * 1000, 2)) / 2;
a = Zplot + (aY * Math.Pow((1000 * timeUP), 2)) / 2;
result.y = a;
timeUP = 0.001 + timeUP;
time = 0.001 + time;
a++;
yield return(result);
}
var g = (int)(time + 1);
while (time <= g)
{
RobotPosition result = new RobotPosition();
result.time = time;
result.z = 0;
result.x = YHight;
result.y = ZHight;
time = 0.001 + time;
yield return(result);
}
}
public void ProcessCommand()
{
var rawcommand = _commandReader.GetCommand();
var command = _commandManager.ChooseCommand(rawcommand);
Console.WriteLine($"Valid command received: {command!=null}");
if (command != null)
{
RobotPosition position = null;
var result = command.GetCommandResult(_robot.RobotPosition, out position);
Console.WriteLine($"Command performed by robot: {result}");
if (result)
{
if (command is PlaceCommand || command is LeftCommand || command is RightCommand || command is MoveCommand)
{
_robot.UpdatePosition(position);
}
else if (command is ReportCommand)
{
_reportDisplay.ShowRobot(_robot);
}
}
}
}
public void Command_Manager_should_return_place_command_when_place_0_1_north_is_given()
{
var coordinateValidator = new SurfaceCoordinateValidator();
var directionValidator = new DirectionValidator();
var paramValidator = new CommandParamValidator(coordinateValidator, directionValidator);
var mgr = new CommandManager(paramValidator, null);
PlaceCommand cmd = (PlaceCommand)mgr.ChooseCommand("PLACE 0,1 NORTH");
var coordinate = new SurfaceCoordinate {
X_Position = 0, Y_Position = 1
};
PlaceCommandParam actualParam = (PlaceCommandParam)cmd.CommandParam;
Assert.AreEqual <CommandType>(CommandType.PLACE, actualParam.CommandParamType);
Assert.AreEqual <Direction>(Direction.NORTH, actualParam.Direction);
Assert.AreEqual <SurfaceCoordinate>(coordinate, actualParam.SurfaceCoordinate);
RobotPosition actualPosition = null;
var actual = cmd.GetCommandResult(null, out actualPosition);
Assert.AreEqual <bool>(true, actual);
Assert.AreEqual <Direction>(Direction.NORTH, actualPosition.Direction);
Assert.AreEqual <SurfaceCoordinate>(coordinate, actualPosition.Coordinate);
}
/// <summary>
/// Get the proposed new position for the place command.
/// Does validation check as well
/// </summary>
/// <param name="command">Command to place a toy robot</param>
/// <returns>Proposed position</returns>
private static RobotPosition GetNewPosition(string[] command)
{
if (command.Length < 2)
{
throw new Exception("Missing parameters.");
}
var parameters = command[1].Split(',');
if (parameters.Length < 3)
{
throw new Exception("Missing parameters.");
}
var x = int.Parse(parameters[0]);
var y = int.Parse(parameters[1]);
var f = parameters[2].ToUpper();
var direction = (Direction)Enum.Parse(typeof(Direction), f);
var newPosition = new RobotPosition()
{
X = x,
Y = y,
F = direction
};
return(newPosition);
}
private void HandleRobotCommands(List <RobotCommand> cmdList)
{
int counter = 0;
foreach (var cmd in cmdList)
{
cmd.QueueId = counter;
try
{
Console.WriteLine($"Request command:{cmd.Type}: Direction:{cmd.CurentDirection} request new Position({cmd.MoveTo.X}:{cmd.MoveTo.Y})");
var result = _robotStateMachine.Build(cmd.Type).ProcessState(cmd);
if (result.isSuccess && result.stateResponse != null)
{
_currentPosition = result.stateResponse.CurrentPosition;
Console.WriteLine($"Success! Position was changed to: [{result.stateResponse.CurrentPosition.X}:{result.stateResponse?.CurrentPosition.Y}:{result.stateResponse?.CurrentPosition.Direction}]");
}
else
{
Console.WriteLine($"Position was not changed");
}
}
catch (Exception ex)
{
_log.Exception(ex, $"Robot command critical failure");
Console.WriteLine($"{RobotConstantsValues.CommandFailure}");
}
counter++;
}
}
public RobotLocationService()
{
_currentPosition = new RobotPosition {
X = 0, Y = 0, Direction = Direction.N
};
_workingMatrixSize = new MatrixSize();
}
public RobotPosition NewPosition(int step = 1)
{
var newPosition = new RobotPosition
{
X = this.X,
Y = this.Y,
Direction = this.Direction,
};
if (newPosition.Direction == DirectionEnum.East)
{
newPosition.X += step;
}
else if (newPosition.Direction == DirectionEnum.West)
{
newPosition.X -= step;
}
else if (newPosition.Direction == DirectionEnum.North)
{
newPosition.Y += step;
}
else if (newPosition.Direction == DirectionEnum.South)
{
newPosition.Y -= step;
}
return(newPosition);
}
public void RobotPosition_Constructor_ValidData_ValidPosition()
{
string input = "1,1,WEST";
RobotPosition position = new RobotPosition(input);
Assert.AreEqual(input, position.ToString());
}
private RobotPosition GetExpectedPosition(RobotPosition currentPosition)
{
switch (currentPosition.Facing)
{
case Orientation.NORTH:
if (currentPosition.Y == 3)
{
return(new RobotPosition(currentPosition.X, 4, Orientation.NORTH));
}
break;
case Orientation.EAST:
if (currentPosition.X == 3)
{
return(new RobotPosition(4, currentPosition.Y, Orientation.EAST));
}
break;
case Orientation.SOUTH:
if (currentPosition.Y == 1)
{
return(new RobotPosition(currentPosition.X, 0, Orientation.SOUTH));
}
break;
case Orientation.WEST:
if (currentPosition.X == 1)
{
return(new RobotPosition(0, currentPosition.Y, Orientation.WEST));
}
break;
}
return(currentPosition);
}
/// <summary>
/// Calculates a new position applying one unit move in current direction
/// </summary>
/// <returns>Calculated new position</returns>
private RobotPosition ApplyMove()
{
// initialize
var newPosition = new RobotPosition()
{
X = robotPosition.X,
Y = robotPosition.Y,
F = robotPosition.F
};
if (robotPosition.F == Direction.NORTH)
{
newPosition.Y++;
}
else if (robotPosition.F == Direction.SOUTH)
{
newPosition.Y--;
}
else if (robotPosition.F == Direction.EAST)
{
newPosition.X++;
}
else if (robotPosition.F == Direction.WEST)
{
newPosition.X--;
}
return(newPosition);
}
public void Should_move_up_when_facing_north()
{
var expected = new RobotPosition {X = 0, Y = 1};
_robotMover.Move('N', _currentRobotPosition);
Assert.That(_currentRobotPosition, Is.EqualTo(expected));
}
public void RobotPosition_Constructor_YNegativeInt_GameCommandParameterInvalidException()
{
string input = "1,-2,WEST";
Assert.ThrowsException <GameCommandParameterInvalidException>(() => {
RobotPosition position = new RobotPosition(input);
});
}
public void UpdatePosition(RobotPosition position)
{
if (position.Direction == Direction.UNKNOWN || !_surfaceCoordinateValidator.Validate(position.Coordinate))
{
throw new ArgumentException("Invalid position to update to robot!");
}
_robotPosition = position;
}
public void RobotPosition_Constructor_2Parts_GameCommandParameterInvalidException()
{
string input = "1,1";
Assert.ThrowsException <GameCommandParameterInvalidException>(() => {
RobotPosition position = new RobotPosition(input);
});
}
public void Should_move_right_when_facing_west()
{
var expected = new RobotPosition {X = -1, Y = 0};
_robotMover.Move('W', _currentRobotPosition);
Assert.That(_currentRobotPosition, Is.EqualTo(expected));
}
/// <summary>
/// Places the robot to flat surface.
/// </summary>
/// <returns><c>true</c>, if robot to flat surface was placed, <c>false</c> otherwise.</returns>
/// <param name="expectedPosition">Expected position.</param>
/// <param name="surface">Surface.</param>
public static RobotPosition PlaceRobotToFlatSurface(RobotPosition expectedPosition, Surface surface)
{
if (expectedPosition == null)
{
return(null);
}
return(surface.InBoundary(expectedPosition) ? expectedPosition : null);
}
public void Place(RobotPosition position)
{
this.Position = ControllableResponses.PlaceRobotToFlatSurface(position, _surface);
if (this.Position == null)
{
_exceptionFactory.GenerateSafeException($"the robot cannot place to expected postion");
}
this.Status = RobotStatus.On;
}
public void RobotPositionInputIncorrectFormat(string robotPositionInput)
{
Grid grid = new Grid()
{
GridLimit = new GridPoint(30, 30)
};
RobotPosition robotPosition = _parseInputsService.ParseRobotPosition(robotPositionInput, grid);
Assert.IsNull(robotPosition);
Assert.AreEqual(1, _parseInputsService.ParseMessages.Count);
}
public Robot(string name, RobotPosition position, INavigationService navigationService)
{
if (!navigationService.IsPositionWithinBoundaries(position))
{
throw new ArgumentOutOfRangeException("position", "Starting position is out of bound of the battle area.");
}
currentPosition = position;
this.navigationService = navigationService;
this.name = name;
}
public void Place(RobotPosition newPosition)
{
if (IsValidMove(newPosition))
{
robotPosition = newPosition;
}
else
{
throw new System.Exception(INVALIDPOSITIONERROR);
}
}
public void RobotPosition_TurnClockwise_North1Time_East()
{
string original = $"1,1,{FacingDirection.NORTH.ToString()}";
string expected = $"1,1,{FacingDirection.EAST.ToString()}";
RobotPosition position = new RobotPosition(original);
position.Turn();
RobotPosition expectedPosition = new RobotPosition(expected);
Assert.AreEqual(expectedPosition.ToString(), position.ToString());
}
/// <summary>
/// Rotate90s the degrees to right.
/// </summary>
/// <returns><c>true</c>, if degrees to right was rotate90ed, <c>false</c> otherwise.</returns>
/// <param name="position">Position.</param>
public static bool Rotate90DegreesToRight(RobotPosition position)
{
if (position == null)
{
return(false);
}
// the direction is sequenced in array, so less 1 to turn right
position.Direction = verifyCompassBoundary(Convert.ToInt32(position.Direction) - 1);
return(true);
}
public void RobotPositionInputCorrectlyParsed(string robotPositionInput, int XCoordinateParsed, int YCoordinateParsed, OrientationTypes orientationParsed)
{
Grid grid = new Grid()
{
GridLimit = new GridPoint(50, 50)
};
RobotPosition robotPosition = _parseInputsService.ParseRobotPosition(robotPositionInput, grid);
Assert.AreEqual(XCoordinateParsed, robotPosition.PositionCoordinates.X_Coordinate);
Assert.AreEqual(YCoordinateParsed, robotPosition.PositionCoordinates.Y_Coordinate);
Assert.AreEqual(orientationParsed, robotPosition.RobotOrientation);
}
public void ParseTest(string input, bool successful, RobotPosition expectedPosition)
{
if (successful)
{
var position = RobotPositionParser.Parse(input);
Assert.That(position, Is.EqualTo(expectedPosition));
}
else
{
Assert.Throws <System.ArgumentException>(() => RobotPositionParser.Parse(input));
}
}
public void OutOfBoundTest(Point robotLocation)
{
var alwaysFaileNavigationService = new Mock <INavigationService>();
alwaysFaileNavigationService.Setup(a => a.IsPositionWithinBoundaries(It.IsAny <RobotPosition>())).Returns(false);
var position = new RobotPosition {
Heading = Heading.East, Location = robotLocation
};
Assert.Throws <ArgumentOutOfRangeException>(() => new Robot(It.IsAny <string>(), position, alwaysFaileNavigationService.Object));
}
public RobotCommand ExecuteTurn(RobotCommand command)
{
IsChanged = false;
Moves.Enqueue(command);
NeighborCache.Clear();
switch (command)
{
case RobotCommand.Up:
MoveRobotTo(RobotCommand.Up, RobotPosition.Up());
break;
case RobotCommand.Down:
MoveRobotTo(RobotCommand.Down, RobotPosition.Down());
break;
case RobotCommand.Left:
MoveRobotTo(RobotCommand.Left, RobotPosition.Left());
break;
case RobotCommand.Right:
MoveRobotTo(RobotCommand.Right, RobotPosition.Right());
break;
case RobotCommand.Abort:
State = MapState.Aborted;
Score = AbortScore;
break;
case RobotCommand.Shave:
for (int dy = -1; dy < 2; dy++)
{
for (int dx = -1; dx < 2; dx++)
{
if (Cell.At(RobotPosition.X + dx, RobotPosition.Y + dy).IsBeard())
{
Cell.Set(RobotPosition.X + dx, RobotPosition.Y + dy, CellType.Empty);
IsChanged = true;
}
}
}
break;
}
if (State == MapState.Valid)
{
Score -= 1;
Simulate();
}
return(command);
}
public CleaningPlanResultsDto ExecuteCleaningProcess(RobotDto robotConfiguration)
{
var position = new RobotPosition(robotConfiguration.Start.X, robotConfiguration.Start.Y, robotConfiguration.Start.Facing);
var robot = new Robot(position, robotConfiguration.Battery);
var instructions = new CleaningPlanInstructionsDto
{
Map = robotConfiguration.Map,
Instructions = new Queue <string>(robotConfiguration.Commands)
};
return(robot.ExecuteCleaningPlan(instructions));
}
/// <summary>
/// Validates if the position is a valid robot position
/// </summary>
/// <param name="position">New proposed robot position</param>
/// <returns>Indicates a valid move (true/false)</returns>
private bool IsValidMove(RobotPosition position)
{
if (position.X > SQUARETABLETOPUNIT || position.X < 0)
{
return(false);
}
if (position.Y > SQUARETABLETOPUNIT || position.Y < 0)
{
return(false);
}
return(true);
}
public void Report_console_display_should_report_successfully()
{
var reportDisplay = new ReportConsoleDisplay();
var surfaceCoordinateValidator = new SurfaceCoordinateValidator();
SurfaceCoordinate coordinate = new SurfaceCoordinate()
{
X_Position = 0, Y_Position = 1
};
var pos = new RobotPosition(Direction.NORTH, coordinate);
var robot = new Robot(0, "test", surfaceCoordinateValidator);
robot.UpdatePosition(pos);
reportDisplay.ShowRobot(robot);
}
public virtual void UpdatePositionAndClean(RectangularRoom room, Random random)
{
Position newPos = RobotPosition.GetNewPosition(RobotPosition, Direction, Speed);
if (room.isPositionInRoom(newPos))
{
room.cleanTileAtPosition(RobotPosition);
RobotPosition = newPos;
}
else
{
Direction = random.Next(360); //Robotul schimba directia cand se loveste de perete
}
}
public void Place_command_throw_arguent_exception_for_incorrect_command_param()
{
var originalPos = new SurfaceCoordinate {
X_Position = 0, Y_Position = 0
};
var robotPosition = new RobotPosition(Direction.SOUTH, originalPos);
var validator = new SurfaceCoordinateValidator();
var param = new MoveCommandParam();
var cmd = new PlaceCommand(param, validator);
RobotPosition actualPosition = null;
//var actual = cmd.GetCommandResult(out actualPosition);
Assert.ThrowsException <ArgumentException>(() => cmd.GetCommandResult(null, out actualPosition));
}
public void GameTests_RandomMove_CheckExpectedPosition_Equal(string[] events, string expectedPosition)
{
//int x=0,y=0;
//FacingDirection face=FacingDirection.WEST;
Game game = new Game();
foreach (string gameEvent in events)
{
GameEvent temp = new GameEvent(gameEvent);
game.ReceiveEvent(temp);
}
RobotPosition expectedPos = new RobotPosition(expectedPosition);
Assert.AreEqual(expectedPos.ToString(), game.ReportCurrentPosition());
}
public void Move(char currentHeading, RobotPosition currentRobotPosition)
{
switch (currentHeading) {
case 'N':
currentRobotPosition.Up();
break;
case 'E':
currentRobotPosition.Right();
break;
case 'W':
currentRobotPosition.Left();
break;
case 'S':
currentRobotPosition.Down();
break;
}
}
public void SetUp()
{
_robotMover = new RobotMover();
_currentRobotPosition = new RobotPosition {X = 0, Y = 0};
}
/// <summary>
/// Separate the instructions and arguments from the send argument strings
/// </summary>
/// <param name="command"></param>
/// <param name="args"></param>
/// <returns>string</returns>
public Instruction GetInstruction(string command, ref RobotPosition args)
{
Instruction instruction;
string arguments = "";
string[] separatearguments = command.Split(' ');
if(separatearguments.Length>1)
{
command = separatearguments[0];
arguments = separatearguments[1];
}
command = command.ToUpper();
if (Enum.TryParse<Instruction>(command, true, out instruction))
{
if (instruction == Instruction.Place)
{
if (!ParsePlaceArguments(arguments, ref args))
{
instruction = Instruction.Invalid;
}
}
}
else
{
instruction = Instruction.Invalid;
}
return instruction;
}
/// <summary>
/// Parse arguments received with Place Instruction
/// </summary>
/// <param name="argumentString"></param>
/// <param name="args"></param>
/// <returns>bool</returns>
private bool ParsePlaceArguments(string argumentString, ref RobotPosition args)
{
var arguments = argumentString.Split(',');
int x, y;
FacingDirection facingdirection;
if (arguments.Length == 3 && GetCoordinate(arguments[0], out x) &&
GetCoordinate(arguments[1], out y) && GetFacingDirection(arguments[2], out facingdirection))
{
args = new RobotPosition
{
X = x,
Y = y,
FacingDirection = facingdirection,
};
return true;
}
return false;
}
