public AlgorithmRunResults GenerateMaze(IMazeCarver maze, MazeGenerationSettings settings)
{
var randomPoint = _randomPointGenerator.RandomPoint(maze.Size);
maze.JumpToPoint(randomPoint);
return(RecursiveBackTracker(maze));
}
public void RunForSettings(MazeGenerationSettings settings, bool parallel = false, int iterations = 100)
{
_outputWriter.Print("Random ");
Settings2.ExtraWalls = WallCarverOption.Random;
var results1 = RunExperiment(settings, iterations, parallel);
_outputWriter.PrintLn("Finshed");
_outputWriter.Print("Dead end ");
Settings2.ExtraWalls = WallCarverOption.DeadEndWithPreferredDirection;
var results2 = RunExperiment(settings, iterations, parallel);
_outputWriter.PrintLn("Finshed");
_outputWriter.Print("Dead end preferred ");
Settings2.ExtraWalls = WallCarverOption.DeadEnd;
var results3 = RunExperiment(settings, iterations, parallel);
_outputWriter.PrintLn("Finshed");
_outputWriter.Print("None ");
Settings2.ExtraWalls = WallCarverOption.None;
var results4 = RunExperiment(settings, iterations, parallel);
_outputWriter.PrintLn("Finshed");
_outputWriter.PrintLn($"Random");
PrintResults(results1);
_outputWriter.PrintLn($"Dead end");
PrintResults(results2);
_outputWriter.PrintLn($"Dead end preferred");
PrintResults(results3);
_outputWriter.PrintLn($"None");
PrintResults(results4);
}
public AlgorithmRunResults GenerateMaze(IMazeCarver maze, MazeGenerationSettings settings)
{
var pointsAndDirections = new List <DirectionAndPoint>();
_mazeHelper.DoForEachPoint(maze.Size, p =>
{
maze.JumpToPoint(p);
var directions = _directions.Where(maze.CanCarveInDirection).ToList();
_arrayHelper.Shuffle(directions);
if (directions.Any())
{
var first = directions.First();
pointsAndDirections.Add(new DirectionAndPoint {
Direction = first, MazePoint = maze.CurrentPoint
});
maze.CarveInDirection(first);
}
});
return(new AlgorithmRunResults
{
Carver = maze,
DirectionsCarvedIn = pointsAndDirections
});
}
public IEnumerable <ValidationResult> ValidateSetting(MazeGenerationSettings settings)
{
if (settings.Algorithm == Algorithm.None)
{
yield return(new ValidationResult(null, false, "An Algorithm Has to be selected for the Maze Generation tool to run."));
}
if (settings.Size.X < 1)
{
yield return(new ValidationResult(null, false, "The X value must be greater than 0"));
}
if (settings.Size.X > 1000)
{
yield return(new ValidationResult(null, false, "The X value must be less than 1000"));
}
if (settings.Size.Y < 1)
{
yield return(new ValidationResult(null, false, "The Y value must be greater than 0"));
}
if (settings.Size.Y > 1000)
{
yield return(new ValidationResult(null, false, "The Y value must be less than 1000"));
}
if (settings.Size.Z < 1)
{
yield return(new ValidationResult(null, false, "The Z value must be greater than 0"));
}
if (settings.Size.Z > 1000)
{
yield return(new ValidationResult(null, false, "The Z value must be less than 1000"));
}
if (settings.Option == MazeType.None)
{
yield return(new ValidationResult(null, false, "A Model Option must be selected"));
}
}
public void InitialiseOver(MazeGenerationSettings specificSettings, MazeGenerationSettings baseSettings)
{
specificSettings.Size = baseSettings.Size ?? new MazeSize();
specificSettings.Option = baseSettings.Option;
specificSettings.Algorithm = baseSettings.Algorithm;
specificSettings.DoorsAtEdge = baseSettings.DoorsAtEdge;
specificSettings.AgentType = baseSettings.AgentType;
}
public IEnumerable <ValidationResult> ValidateSetting(MazeGenerationSettings settings)
{
var results = _baseValidateSettings.ValidateSetting(settings);
foreach (var result in results)
{
yield return(result);
}
}
public AlgorithmRunResults GenerateMaze(IMazeCarver maze, MazeGenerationSettings settings)
{
var growingTreeSettings = settings as GrowingTreeSettings;
if (growingTreeSettings == null)
{
throw new ArgumentException("The correct settings are not present");
}
return(GenerateMaze(maze, growingTreeSettings.Strategies));
}
public IEnumerable <ValidationResult> Validate(MazeGenerationSettings settings)
{
var validatorStrategy = _validators.SingleOrDefault(x => x.AlgorithmType == settings.Algorithm);
if (validatorStrategy != null)
{
return(validatorStrategy.ValidateSetting(settings));
}
else
{
throw new ArgumentException("Unsupported Algorithm Type");
}
}
private MazeResults BuildMaze(MazeGenerationSettings settings)
{
var result = _mazeGenerationFactory.GenerateMaze(settings);
return(new MazeResults
{
ShortestPath = result.HeuristicsResults.ShortestPathResult.ShortestPath,
Stats = result.HeuristicsResults.Stats,
ModelTime = result.ModelTime,
GenerationTime = result.GenerationTime,
DeadEndFillerTime = result.DeadEndFillerTime,
AgentGenerationTime = result.AgentGenerationTime,
HeuristicsTime = result.HeuristicsTime,
TotalTime = result.TotalTime,
TotalCellsFilledIn = result.DeadEndFillerResults.TotalCellsFilledIn
});
}
private ExperimentResult RunExperiment(MazeGenerationSettings settings, int iterations, bool parallel)
{
var batch = iterations / 100;
int count = 0;
List <MazeResults> items = null;
if (parallel)
{
items = GenerateMazesParallel(settings, iterations).Select(x =>
{
count++;
if (count % batch == 0)
{
_outputWriter.Print($"{count/batch}% ");
}
return(x);
}).ToList();
}
else
{
items = GenerateMazes(settings, iterations).Select(x =>
{
count++;
if (count % batch == 0)
{
_outputWriter.Print($"{count / batch}% ");
}
return(x);
}).ToList();
}
var doubleAverageTicks = _arrayHelper.Average(items, x => x.TotalTime.Ticks);
long longAverageTicks = Convert.ToInt64(doubleAverageTicks);
var result = new ExperimentResult
{
AverageShortestPath = _arrayHelper.Average(items, x => x.ShortestPath),
AverageGenerationTime = new TimeSpan(longAverageTicks),
DirectionWeightings = _directionsFlagParser.Directions.ToDictionary(x => x, y => _arrayHelper.Average(items, z => z.Stats.DirectionsUsed[y])),
AverageCellsFilledIn = _arrayHelper.Average(items, x => x.TotalCellsFilledIn)
};
return(result);
}
public AlgorithmRunResults GenerateMaze(IMazeCarver maze, MazeGenerationSettings settings)
{
var pointAndDirection = new List <DirectionAndPoint>();
var randomPoint = _randomPointGenerator.RandomPoint(maze.Size);
maze.JumpToPoint(randomPoint);
var activeCells = new LinkedList <MazePoint>();
activeCells.AddLast(randomPoint);
while (activeCells.Any())
{
var currentPoint = activeCells.Last.Value;
maze.JumpToPoint(currentPoint);
var carvableDirections = maze.CarvableDirections().ToList();
_arrayHelper.Shuffle(carvableDirections);
var carved = false;
foreach (var direction in carvableDirections)
{
maze.JumpInDirection(direction);
var carvedDirections = maze.AlreadyCarvedDirections();
if (!carvedDirections.Any())
{
pointAndDirection.Add(new DirectionAndPoint {
Direction = direction, MazePoint = currentPoint
});
var oppositeDirection = _directionsFlagParser.OppositeDirection(direction);
maze.CarveInDirection(oppositeDirection);
activeCells.AddLast(maze.CurrentPoint);
carved = true;
break;
}
maze.JumpToPoint(currentPoint);
}
if (!carved)
{
activeCells.RemoveLast();
}
}
return(new AlgorithmRunResults
{
Carver = maze,
DirectionsCarvedIn = pointAndDirection
});
}
public void BuildMenu(Transform transform, MazeGenerationSettings existingSettings, Action <MazeGenerationSettings> settingsChanged)
{
_growingTreeSettings = existingSettings as GrowingTreeSettings ?? new GrowingTreeSettings();
_growingTreeSettings.Strategies = _growingTreeSettings.Strategies ?? new List <GrowingTreeStrategy>();
_algorithmSettingsInitialiser.InitialiseOver(_growingTreeSettings, existingSettings);
_growingTreeStrategyStorage.LoadStrategies(_growingTreeSettings.Strategies);
_resourceLoader.InstantiateControl <TextControl>(transform).Initialize("Growing Tree Algorithm Settings");
_resourceLoader.InstantiateControl <TextControl>(transform).Initialize("Cell selection weighting: the action will be randomly chosen ");
_resourceLoader.InstantiateControl <SliderControl>(transform)
.Initialize("Oldest", 0, 10,
_growingTreeStrategyStorage.Get(GrowingTreeStrategy.Oldest),
i => StrategyChanged(GrowingTreeStrategy.Oldest, i, settingsChanged));
_resourceLoader.InstantiateControl <SliderControl>(transform)
.Initialize("Newest", 0, 10,
_growingTreeStrategyStorage.Get(GrowingTreeStrategy.Newest),
i => StrategyChanged(GrowingTreeStrategy.Newest, i, settingsChanged));
_resourceLoader.InstantiateControl <SliderControl>(transform)
.Initialize("Middle", 0, 10,
_growingTreeStrategyStorage.Get(GrowingTreeStrategy.Middle),
i => StrategyChanged(GrowingTreeStrategy.Middle, i, settingsChanged));
_resourceLoader.InstantiateControl <SliderControl>(transform)
.Initialize("Randomness", 0, 10,
_growingTreeStrategyStorage.Get(GrowingTreeStrategy.Random),
i => StrategyChanged(GrowingTreeStrategy.Random, i, settingsChanged));
_resourceLoader.InstantiateControl <SliderControl>(transform)
.Initialize("Random Oldest Half", 0, 10,
_growingTreeStrategyStorage.Get(GrowingTreeStrategy.RandomOldest),
i => StrategyChanged(GrowingTreeStrategy.RandomOldest, i, settingsChanged));
_resourceLoader.InstantiateControl <SliderControl>(transform)
.Initialize("Random Newest Half", 0, 10,
_growingTreeStrategyStorage.Get(GrowingTreeStrategy.RandomNewest),
i => StrategyChanged(GrowingTreeStrategy.RandomNewest, i, settingsChanged));
settingsChanged(GetSettings());
}
public IEnumerable <ValidationResult> ValidateSetting(MazeGenerationSettings settings)
{
var results = _baseValidateSettings.ValidateSetting(settings);
foreach (var result in results)
{
yield return(result);
}
var growingTreeSettings = settings as GrowingTreeSettings;
if (growingTreeSettings == null)
{
throw new ArgumentException("Settings must not be null");
}
if (!growingTreeSettings.Strategies.Any())
{
yield return(new ValidationResult(null, false, "There must be a weighted strategy with a value greater than 0"));
}
}
public IModelBuilder BuildMaze(MazeGenerationSettings settings)
{
var pickType = PickType.Random;
if (settings.DoorsAtEdge)
{
pickType = PickType.RandomEdge;
}
var startPoint = _randomPointGenerator.RandomPoint(settings.Size, pickType);
var endPoint = _randomPointGenerator.RandomPoint(settings.Size, pickType);
while (startPoint.Equals(endPoint))
{
endPoint = _randomPointGenerator.RandomPoint(settings.Size, pickType);
}
var options = new ModelInitialisationOptions
{
Size = settings.Size,
StartPoint = startPoint,
EndPoint = endPoint
};
switch (settings.Option)
{
case MazeType.None:
throw new ArgumentException("Maze Type None is not supported");
case MazeType.UndirectedMaze:
return(new Model2(_parser, _movementHelper, _mazeArrayBuilder).BaseInitialise(options));
case MazeType.DirectedMaze:
return(new Model1(_parser, _movementHelper, _mazeArrayBuilder).BaseInitialise(options));
case MazeType.DictionaryMaze:
return(new Model3(_parser, _pointFactory, _movementHelper).BaseInitialise(options));
default:
throw new ArgumentOutOfRangeException();
}
}
public MazeGenerationResults GenerateMaze(MazeGenerationSettings settings)
{
IMazeCarver carver = null;
var modelBuildTime = _timeRecorder.GetRunningTime(() =>
{
var model = _mazeModelFactory.BuildMaze(settings);
carver = _mazeFactory.GetMazeCarver(model);
});
AlgorithmRunResults results = null;
int extraWallsAdded = 0;
var generationTime = _timeRecorder.GetRunningTime(() =>
{
switch (settings.Algorithm)
{
case Algorithm.None:
throw new ArgumentException("None not supported");
case Algorithm.GrowingTreeAlgorithm:
results = _growingTreeAlgorithm.GenerateMaze(carver, settings);
break;
case Algorithm.RecursiveBacktrackerAlgorithm:
results = _recursiveBacktrackerAlgorithm.GenerateMaze(carver, settings);
break;
case Algorithm.BinaryTreeAlgorithm:
results = _binaryTreeAlgorithm.GenerateMaze(carver, settings);
break;
default:
throw new ArgumentException("Unsupported algorithm type");
}
carver = results.Carver;
extraWallsAdded = _extraWall.Calulate(carver.Size);
_randomCarver.CarveRandomWalls(carver, settings.ExtraWalls, extraWallsAdded);
});
DeadEndFillerResult deadEndFillerResults = null;
var deadEndFillerTime = _timeRecorder.GetRunningTime(() =>
{
deadEndFillerResults = _deadEndFiller.Fill(carver);
});
AgentResults result = null;
var agentGenerationTime = _timeRecorder.GetRunningTime(() =>
{
if (settings.AgentType != AgentType.None)
{
result = _agentFactory.MakeAgent(settings.AgentType).RunAgent(carver);
}
});
HeuristicsResults heuristicsResults = null;
var heuristicsTime = _timeRecorder.GetRunningTime(() =>
{
heuristicsResults = _heuristicsGenerator.GetResults(results);
});
var times = new [] { modelBuildTime, generationTime, deadEndFillerTime, agentGenerationTime, heuristicsTime };
var totalTime = times.Aggregate(new TimeSpan(), (seed, value) => seed.Add(value));
return(new MazeGenerationResults
{
MazeJumper = carver.CarvingFinished(),
HeuristicsResults = heuristicsResults,
DirectionsCarvedIn = results.DirectionsCarvedIn,
DeadEndFillerResults = deadEndFillerResults,
ModelTime = modelBuildTime,
AgentResults = result,
GenerationTime = generationTime,
DeadEndFillerTime = deadEndFillerTime,
AgentGenerationTime = agentGenerationTime,
HeuristicsTime = heuristicsTime,
TotalTime = totalTime
});
}
public ValidationResult ValidateAndProcess(MazeGenerationSettings settings)
{
return(_validationRetriever.GetOverallValidationResult(Validate(settings)));
}
public ExperimentRunner(IMazeGenerationFactory mazeGenerationFactory, IArrayHelper arrayHelper, IOutputWriter outputWriter, IDirectionsFlagParser directionsFlagParser)
{
_mazeGenerationFactory = mazeGenerationFactory;
_arrayHelper = arrayHelper;
_outputWriter = outputWriter;
_directionsFlagParser = directionsFlagParser;
Settings1 = new MazeGenerationSettings
{
Algorithm = Algorithm.BinaryTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = true,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
}
};
Settings2 = new MazeGenerationSettings
{
Algorithm = Algorithm.BinaryTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = false,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
}
};
Settings3 = new MazeGenerationSettings
{
Algorithm = Algorithm.RecursiveBacktrackerAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = true,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
}
};
Settings4 = new MazeGenerationSettings
{
Algorithm = Algorithm.RecursiveBacktrackerAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = false,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
}
};
Settings5 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = true,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Newest
}
};
Settings6 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = false,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Newest
}
};
Settings7 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = true,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Random
}
};
Settings8 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = false,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Random
}
};
Settings9 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = true,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Newest, GrowingTreeStrategy.Newest, GrowingTreeStrategy.Newest, GrowingTreeStrategy.RandomOldest, GrowingTreeStrategy.Middle
}
};
Settings10 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = false,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Newest, GrowingTreeStrategy.Newest, GrowingTreeStrategy.Newest, GrowingTreeStrategy.RandomOldest, GrowingTreeStrategy.Middle
}
};
Settings11 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = true,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Newest, GrowingTreeStrategy.Oldest
}
};
Settings12 = new GrowingTreeSettings
{
Algorithm = Algorithm.GrowingTreeAlgorithm,
AgentType = AgentType.None,
DoorsAtEdge = false,
ExtraWalls = WallCarverOption.Random,
Option = MazeType.DirectedMaze,
Size = new MazeSize {
X = 25, Y = 25, Z = 25
},
Strategies = new List <GrowingTreeStrategy> {
GrowingTreeStrategy.Newest, GrowingTreeStrategy.Oldest
}
};
}
public void BuildMenu(Transform transform, Algorithm algorithm, MazeGenerationSettings existingSettings, Action <MazeGenerationSettings> settingsChanged)
{
transform.Clear();
GetStrategy(algorithm).BuildMenu(transform, existingSettings, settingsChanged);
}
public IEnumerable <ValidationResult> ValidateSetting(MazeGenerationSettings settings)
{
return(_baseValidateSettings.ValidateSetting(settings));
}
private ParallelQuery <MazeResults> GenerateMazesParallel(MazeGenerationSettings settings, int iterations)
{
var itemsToProcess = iterations;
return(Enumerable.Range(0, itemsToProcess).AsParallel().WithDegreeOfParallelism(4).Select(x => BuildMaze(settings)));
}
private IEnumerable <MazeResults> GenerateMazes(MazeGenerationSettings settings, int iterations)
{
var itemsToProcess = iterations;
return(Enumerable.Range(0, itemsToProcess).Select(x => BuildMaze(settings)));
}
public void BuildMenu(Transform transform, MazeGenerationSettings existingSettings, Action <MazeGenerationSettings> settingsChanged)
{
_settings = existingSettings;
}
