/// <summary>
/// Function that solves the maze using the solver.
/// </summary>
public void Solve(IMazeSolver solver, Action <IEnumerable <IMazeCell> > solvedResultCallback)
{
if (solver == null)
{
throw new ArgumentNullException("solver", "Solver cannot be null");
}
if (solvedResultCallback == null)
{
throw new ArgumentNullException("solvedResultCallback", "Please provide a callback action");
}
_logger.LogInformation($"Solve Using: {solver.GetType().Name}");
//calls solver's solve method.
solver.Solve(this, (solvedPath) =>
{
if (solvedPath == null)
{
solvedResultCallback(new List <IMazeCell>(0));//return a empty path if the solver could not solve the maze.
}
else
{
solvedResultCallback(solvedPath);
}
});
}
/// <summary>
/// Complex and memory consuming resources may be prepared before the controller is started.
/// </summary>
public void PrepareForStart()
{
// Prepare the solver.
if (mazeForm != null)
{
solver = SolverFactory.CreateSolver(mazeForm.StrategyName, this.Maze, mazePainter);
}
else
{
solver = SolverFactory.CreateSolver(null, this.Maze, mazePainter);
}
// Prepare the solution path.
solutionPath = SolverFactory.SolutionPath(this.Maze);
// If our Maze has embedded mazes, we need to supply them with embedded solvers.
CreateEmbeddedSolvers();
// Prepare embedded solvers.
foreach (EmbeddedSolverController item in embeddedControllers)
{
item.PrepareForStart();
}
// After all controllers have been created, some resources need to be shared with the master controller.
if (this.Maze.MazeId == MazeSquare.PrimaryMazeId)
{
CoordinateEmbeddedControllers(this);
}
}
public void SF_CreateSolverTest_01()
{
string testObject = "SWA.Ariadne.Logic.SolverFactory.CreateSolver";
Maze maze = NewMaze();
IMazeDrawer mazeDrawer = null;
IMazeSolver actual = SolverFactory.CreateSolver(null, maze, mazeDrawer);
Assert.IsInstanceOfType(actual, typeof(IMazeSolver), testObject + " did not return an instanze of IMazeSolver");
}
public void SF_CreateDefaultSolverTest_01()
{
string testObject = "SWA.Ariadne.Logic.SolverFactory.CreateDefaultSolver";
Maze maze = NewMaze();
IMazeDrawer mazeDrawer = null;
IMazeSolver actual = SolverFactory.CreateDefaultSolver(maze, mazeDrawer);
Assert.IsInstanceOfType(actual, SolverFactory.DefaultStrategy, testObject + " did not return an instance of the default strategy.");
}
public void SF_CreateSolverTest_type_01()
{
string testObject = "SWA.Ariadne.Logic.SolverFactory.CreateSolver(type)";
foreach (Type solverType in SolverFactory.SolverTypes)
{
Maze maze = NewMaze();
IMazeDrawer mazeDrawer = null;
IMazeSolver actual = SWA_Ariadne_Logic_SolverFactoryAccessor.CreateSolver(solverType, maze, mazeDrawer);
Assert.IsInstanceOfType(actual, typeof(IMazeSolver), testObject + " did not return an instanze of IMazeSolver");
Assert.IsInstanceOfType(actual, solverType, testObject + " did not return the given type");
}
}
public void SB_SolveTest_01()
{
string testObject = "SWA.Ariadne.Logic.SolverBase.Solve";
foreach (Type solverType in SolverFactory.SolverTypes)
{
Maze maze = SolverFactoryTest.NewMaze();
IMazeDrawer mazeDrawer = null;
IMazeSolver target = SWA_Ariadne_Logic_SolverFactoryAccessor.CreateSolver(solverType, maze, mazeDrawer);
target.Solve();
Assert.IsTrue(maze.IsSolved, testObject + ": " + target.GetType().Name + " did not solve the maze.");
}
}
private void FillMaze()
{
// Create a maze with fixed layout.
mazeUserControl.Setup(5, 2, 3);
// Draw the maze walls.
mazeUserControl.MazePainter.PaintMaze(null);
// Solve the maze.
IMazeSolver solver = SolverFactory.CreateDefaultSolver(mazeUserControl.Maze, mazeUserControl.MazePainter);
solver.Reset();
solver.Solve();
}
/// <summary>
/// Returns a new MazeSolver of the given Type.
/// </summary>
/// <param name="solverType"></param>
/// <param name="maze"></param>
/// <returns></returns>
private static IMazeSolver CreateSolver(Type solverType, Maze maze, IMazeDrawer mazeDrawer)
{
IMazeSolver result = (IMazeSolver)solverType.GetConstructor(
new Type[2] {
typeof(Maze), typeof(IMazeDrawer)
}).Invoke(
new object[2] {
maze, mazeDrawer
}
);
result.Reset();
return(result);
}
/// <summary>
/// Returns a new MazeSolver.
/// A (reasonably) intelligent strategy is chosen randomly.
/// </summary>
/// <param name="maze"></param>
/// <returns></returns>
private static IMazeSolver CreateSolver(Maze maze, IMazeDrawer mazeDrawer)
{
Random r = SWA.Utilities.RandomFactory.CreateRandom();
while (true)
{
Type t = solverTypes[r.Next(solverTypes.Length)];
bool shouldBeEfficient = (r.Next(2) == 0);
shouldBeEfficient &= RegisteredOptions.GetBoolSetting(RegisteredOptions.OPT_EFFICIENT_SOLVERS);
bool shouldUseHeuristic = (r.Next(2) == 0);
// Note: There is currently no equivaelnt OPT_HEURISTIC_SOLVERS option.
if (t == typeof(RandomWalker))
{
// too dumb
continue;
}
if (t == typeof(MasterSolver))
{
// too smart
continue;
}
IMazeSolver result = CreateSolver(t, maze, mazeDrawer);
if (shouldBeEfficient && HasEfficientVariant(t))
{
result.MakeEfficient();
}
if (shouldUseHeuristic && HasHeuristicVariant(t))
{
result.UseHeuristic();
}
return(result);
}
}
public void SB_OpenWallsTest_01()
{
string testObject = "SWA.Ariadne.Logic.SolverBase.OpenWalls";
MazeSquare sq = new MazeSquare(0, 0);
for (WallPosition wp = WallPosition.WP_MIN; wp <= WallPosition.WP_MAX; wp++)
{
sq[wp] = WallState.WS_CLOSED;
}
Maze maze = new Maze(0, 0);
maze.CreateMaze();
IMazeSolver target = SolverFactory.CreateDefaultSolver(maze, null);
SWA_Ariadne_Logic_SolverBaseAccessor accessor = new SWA_Ariadne_Logic_SolverBaseAccessor(target);
bool notVisitedOnly = false;
List <WallPosition> actual;
actual = accessor.OpenWalls(sq, notVisitedOnly);
Assert.AreEqual(0, actual.Count, testObject + " did not return the expected value.");
}
/// <summary>
/// When the controller is Ready or Finished, memory consuming
/// resources should be deallocated.
/// </summary>
public void ReleaseResources()
{
solver = null;
solutionPath = null;
embeddedControllers.Clear();
}
public MazeGame(IMazeGenerator mazeGenerator, IMazeSolver mazeSolver)
{
_mazeGenerator = mazeGenerator;
_mazeSolver = mazeSolver;
}
public MazeController(IMazeSolver mazeSolver)
{
_mazeSolver = mazeSolver;
}
