public static bool CanRobotMoveForward(AlgorithmEssentials inAlgorithmEssentials, bool inCanReUseVisitedCells)
{
if (inCanReUseVisitedCells)
{
return(!inAlgorithmEssentials.Robot.IsObstacle());
}
else
{
return((!inAlgorithmEssentials.Robot.IsObstacle()) && (!inAlgorithmEssentials.RobotVisitMonitor.IsFrontCellVisited()));
}
}
public static void MoveForward(AlgorithmEssentials inAlgorithmEssentials)
{
inAlgorithmEssentials.Robot.Walk();
if (inAlgorithmEssentials.Robot.X > inAlgorithmEssentials.Room.MaxCoOrdinate.X)
{
inAlgorithmEssentials.Room.MaxCoOrdinate.X = inAlgorithmEssentials.Robot.X;
}
if (inAlgorithmEssentials.Robot.Y > inAlgorithmEssentials.Room.MaxCoOrdinate.Y)
{
inAlgorithmEssentials.Room.MaxCoOrdinate.Y = inAlgorithmEssentials.Robot.Y;
}
inAlgorithmEssentials.RobotVisitMonitor.AddCurrentPositionToVisitList();
inAlgorithmEssentials.RobotVisitMonitor.AddToRobotPath("Move Forward");
}
public static void TurnToFaceUp(AlgorithmEssentials inAlgorithmEssentials)
{
// Turn to the top side.
switch (inAlgorithmEssentials.Robot.FaceTo)
{
case 0:
RobotUtility.TurnLeft(inAlgorithmEssentials);
break;
case 1:
RobotUtility.TurnRight(inAlgorithmEssentials);
RobotUtility.TurnRight(inAlgorithmEssentials);
break;
case 2:
RobotUtility.TurnRight(inAlgorithmEssentials);
break;
}
}
static void Main(string[] args)
{
// Define the min and max co-ordinate for the room
CoOrdinate currentRoom = new CoOrdinate(1, 5);
// Create the Robot
RobotHardware.IHardwareRobot cleaningRobot = new RobotHardware.Hardware(currentRoom.X, currentRoom.Y);
// Create the required robot visit monitor. Current visit monitor can print the robot path to console
IRobotVisitMonitor robotVisitMonitor = RobotVisitMonitorFactory.CreateRobotVisitMonitor(
RobotVisitMonitorType.RobotVisitMonitorWithConsoleOutput, cleaningRobot);
// Create a simple room
Room room = new SimpleRoom();
// Create the algorithm essentials with the above robot, visit monitor and room.
AlgorithmEssentials algorithmEssentials = new AlgorithmEssentials(room, cleaningRobot, robotVisitMonitor);
// Ask the CleaningAlgorithmFactory to create the CleaningAlgorithm instance by passing the required
// required CleaningAlgorithmType
CleaningAlgorithm cleaningAlgorithm = CleaningAlgorithmFactory.CreateCleaningAlgorithm(
CleaningAlgorithmType.CircularCleaningAlgorithm, algorithmEssentials);
// Ask the ReturnAlgorithmFactory to create the ReturnAlgorithm instance by passing the required
// required ReturnAlgorithmType
ReturnAlgorithm returnAlgorithm = ReturnAlgorithmFactory.CreateReturnAlgorithm(
ReturnAlgorithmType.SimpleReturnAlgorithm, algorithmEssentials);
// Create a CleaningManager to manage the cleaning and returning process
CleaningManager manager = new CleaningManager(cleaningAlgorithm, returnAlgorithm);
bool overallOperationStatus = manager.Clean();
Console.WriteLine("Cleaning Status : {0}", manager.GetCleanStatus());
Console.WriteLine("Return Status : {0}", manager.GetReturnStatus());
robotVisitMonitor.PrintRobotPath();
Console.ReadKey();
}
public static CleaningAlgorithm CreateCleaningAlgorithm(CleaningAlgorithmType inAlgorithmType, AlgorithmEssentials inAlgorithmEssentials)
{
CleaningAlgorithm cleaningAlgorithm;
switch (inAlgorithmType)
{
case CleaningAlgorithmType.CircularCleaningAlgorithm:
{
cleaningAlgorithm = new CircularCleaningAlgorithm(inAlgorithmEssentials,
HandlerContainerFactory.CreateHandlerContainer(HandlerContainerType.CircularCleaningAlgorithm, inAlgorithmEssentials));
break;
}
default:
cleaningAlgorithm = null;
break;
}
return(cleaningAlgorithm);
}
public SimpleReturnAlgorithm(AlgorithmEssentials inAlgorithmEssentials, HandlerContainer inHandlerManager)
{
_algorithmEssentials = inAlgorithmEssentials;
_handlerManager = inHandlerManager;
}
public static ReturnAlgorithm CreateReturnAlgorithm(ReturnAlgorithmType inReturnAlgorithm, AlgorithmEssentials inAlgorithmEssentials)
{
ReturnAlgorithm returnAlgorithm;
switch (inReturnAlgorithm)
{
case ReturnAlgorithmType.SimpleReturnAlgorithm:
{
returnAlgorithm = new SimpleReturnAlgorithm(inAlgorithmEssentials,
HandlerContainerFactory.CreateHandlerContainer(HandlerContainerType.SimpleReturnAlgorithm, inAlgorithmEssentials));
break;
}
default:
returnAlgorithm = null;
break;
}
return(returnAlgorithm);
}
public static void TurnLeft(AlgorithmEssentials inAlgorithmEssentials)
{
inAlgorithmEssentials.Robot.TurnLeft();
inAlgorithmEssentials.RobotVisitMonitor.AddToRobotPath("Turn Left");
}
public ForwardMovementHandler(AlgorithmEssentials inAlgorithmEssentials, bool inCanReUseVisitedCells = false)
{
_algorithmEssentials = inAlgorithmEssentials;
_canReUseVisitedCells = inCanReUseVisitedCells;
}
public CircularCleaningAlgorithm(AlgorithmEssentials inAlgorithmEssentials, HandlerContainer inHandlerManager)
{
_algorithmEssentials = inAlgorithmEssentials;
_handlerManager = inHandlerManager;
}
public static HandlerContainer CreateHandlerContainer(HandlerContainerType inHandlerType, AlgorithmEssentials inAlgorithmEssentials)
{
HandlerContainer handlerManager;
switch (inHandlerType)
{
case HandlerContainerType.CircularCleaningAlgorithm:
{
ForwardMovementHandler initialHandler = new ForwardMovementHandler(inAlgorithmEssentials);
ObstacleHandler firstObstacleHandler = new ObstacleHandler(inAlgorithmEssentials);
ObstacleHandler secondObstacleHandler = new ObstacleHandler(inAlgorithmEssentials);
ObstacleHandler thirdObstacleHandler = new ObstacleHandler(inAlgorithmEssentials);
initialHandler.SetNextMovementHandler(firstObstacleHandler);
firstObstacleHandler.SetNextMovementHandler(secondObstacleHandler);
secondObstacleHandler.SetNextMovementHandler(thirdObstacleHandler);
thirdObstacleHandler.SetNextMovementHandler(null);
handlerManager = new HandlerContainer(initialHandler);
break;
}
case HandlerContainerType.SimpleReturnAlgorithm:
{
ForwardMovementHandler returnInitialHandler = new ForwardMovementHandler(inAlgorithmEssentials, true);
ObstacleHandler returnFirstObstacleHandler = new ObstacleHandler(inAlgorithmEssentials, true);
returnInitialHandler.SetNextMovementHandler(returnFirstObstacleHandler);
handlerManager = new HandlerContainer(returnInitialHandler);
break;
}
default:
handlerManager = null;
break;
}
return(handlerManager);
}
public ObstacleHandler(AlgorithmEssentials inAlgorithmEssentials, bool inCanReUseVisitedCells = false)
{
_algorithmEssentials = inAlgorithmEssentials;
_canReUseVisitedCells = inCanReUseVisitedCells;
}
