/// <summary>
/// Strong constuctor, also 'registers' all available stats
/// </summary>
/// <param name="controller"></param>
public SolverStats(SolverController controller)
{
this.controller = controller;
// Register all stats, for easy of use
stats = new List<Statistic>();
stats.Add(CurrentEvalSecs);
stats.Add(EvaluationTime);
stats.Add(EvaluationItterations);
stats.Add(Nodes);
stats.Add(NodesPerSecond);
stats.Add(NodesFwd);
stats.Add(NodesRev);
stats.Add(Duplicates);
stats.Add(DeadNodes);
stats.Add(AvgEvalList);
stats.Add(WeightingMin);
stats.Add(WeightingMax);
stats.Add(WeightingAvg);
stats.Add(HintsUsed);
stats.Add(MaxDepth);
BestNodesFwd = new LinkedList<SolverNode>();
BestNodesRev = new LinkedList<SolverNode>();
}
public void Init(SolverController controller)
{
treeRenderer = new TreeVisualisation(controller.Strategy.EvaluationTree, new RectangleInt(0, 0, 1800, 1800), new SizeInt(8, 8));
treeRenderer.Controller = controller;
treeVis.Visualisation = treeRenderer;
}
public void TestRoom()
{
string[] puzzle = new string[]
{
"~~###########",
"~##.....#..P#",
"###.X.XX#...#",
"#.##X....XX.#",
"#..#..X.#...#",
"######.######",
"#OO.OOX.#$##~",
"#.OO....###~~",
"#..OO#####~~~",
"#########~~~~"
};
SokobanMap map = new SokobanMap();
map.SetFromStrings(puzzle);
PuzzleMap pMap = new PuzzleMap((Puzzle)null);
pMap.Map = map;
SolverController solver = new SolverController(pMap);
solver.Init();
}
public void Build(SolverController controller)
{
AppendHeadingOne("SokoSolve Sokoban Solver Report");
AppendLabel("Generated", DateTime.Now.ToLongDateString());
Append(controller.Stats.GetDisplayData().ToHTML());
}
/// <summary>
/// Strong constructor
/// </summary>
/// <param name="nodes"></param>
/// <param name="cellSize"></param>
public NodeListVisualisation(SolverController controller, List<SolverNode> nodes, SizeInt cellSize)
{
Display = new CommonDisplay(controller);
this.nodes = nodes;
this.cellSize = cellSize;
int maxH = ((nodes.Count + 1)/maxCellWidth+1)*cellSize.Height;
renderCanvas = new RectangleInt(0,0, cellSize.Width*maxCellWidth, maxH);
windowRegion = renderCanvas;
}
public void TestSolverReport()
{
XmlProvider xmlHelper = new XmlProvider();
Library lib = xmlHelper.Load(MakePathUIContent("Libraries\\Sasquatch.ssx"));
List<SolverResult> results = new List<SolverResult>();
SolverController one = new SolverController(lib.Puzzles[0].MasterMap);
results.Add(one.Solve());
SolverController two = new SolverController(lib.Puzzles[1].MasterMap);
results.Add(two.Solve());
SolverResultHTML rpt = new SolverResultHTML(results, null);
rpt.BuildReport();
rpt.Save(@"solver.html");
}
protected SolverResult Solve(SokobanMap puzzle)
{
using (CodeTimer timer = new CodeTimer("TestSolver.Solve(...)"))
{
SolverController controller = new SolverController(puzzle);
try
{
System.Console.WriteLine(puzzle.ToString());
SolverResult results = controller.Solve();
if (results.Exception != null)
{
// Bubble up
throw new Exception("Solver Failed Iternally", results.Exception);
}
if (results.Status == SolverResult.CalculationResult.SolutionFound)
{
// Check that
Assert.IsTrue(results.HasSolution, "State says a solution was found, but none are listed in solutions list");
}
if (results.HasSolution)
{
int cc = 0;
foreach (Solution solution in results.Solutions)
{
string testRes = "Error";
Assert.IsTrue(solution.Test(puzzle, out testRes), testRes);
Console.WriteLine("Testing solution: {0} - {1}", cc, testRes);
cc++;
}
}
return results;
}
finally
{
timer.Stop();
Console.WriteLine(controller.DebugReport.ToString(new DebugReportFormatter()));
System.Console.WriteLine("Total Time: " + timer.Duration(1));
System.Console.WriteLine("---");
}
}
}
public void TestReverseStrategyCoreSimple()
{
CodeTimer timer = new CodeTimer("");
timer.Start();
try
{
SokobanMap map = new SokobanMap();
map.SetFromStrings(new string[]
{
"~##~#####",
"##.##.O.#",
"#.##.XO.#",
"~##.X...#",
"##.XP.###",
"#.X..##~~",
"#OO.##.##",
"#...#~##~",
"#####~#~~"
});
PuzzleMap pMap = new PuzzleMap((Puzzle)null);
pMap.Map = map;
SolverController controller = new SolverController(pMap);
controller.Init();
controller.State = SolverController.States.Running; // Manually set state, as we are not using the controller; but the strategy uses the controller to check if it should exit
ReverseStrategy rev = new ReverseStrategy(controller);
Evaluator<SolverNode> eval = new Evaluator<SolverNode>();
EvalStatus result = eval.Evaluate(rev);
Assert.AreEqual(EvalStatus.CompleteSolution, result, "Should find a solution");
}
finally
{
timer.Stop();
System.Console.WriteLine("Total Time: " + timer.Duration(1));
}
}
/// <summary>
/// Build the result from the completed solver
/// </summary>
/// <param name="controller"></param>
public void Build(SolverController controller)
{
map = controller.Map;
// Build type strong info class
info = new SolverResultInfo();
info.TotalNodes = (int) controller.Stats.Nodes.ValueTotal;
info.TotalSeconds = controller.Stats.EvaluationTime.ValueTotal;
info.Machine = DebugHelper.GetCPUDescription();
info.RatingScore = PuzzleAnalysis.CalcRating(map);
foreach (Statistic stat in controller.Stats.Stats)
{
SolverLabel lb = stat.GetDisplayData();
info.InfoValues.Add(new NameValuePair() {Name = lb.Name, Value = lb.Value});
}
// Build the exit status and summary
if (HasSolution)
{
// General Sucess
status = CalculationResult.SolutionFound;
StringBuilder sb = new StringBuilder();
if (solutions.Count == 1)
{
sb.Append("Solution");
}
else
{
sb.AppendFormat("{0} solutions", solutions.Count);
}
sb.AppendFormat(" in {0} and {1} nodes at {2:0} nodes/s (puzzle score {3})",
StringHelper.ToString(TimeSpan.FromSeconds(info.TotalSeconds)),
info.TotalNodes,
info.TotalNodes/info.TotalSeconds,
info.RatingScore);
summary = sb.ToString();
}
else
{
if (exception != null)
{
status = CalculationResult.Error;
summary = string.Format("Error ({0})", exception.Message);
}
else
{
if (controllerResult == SolverController.States.Cancelled)
{
status = CalculationResult.Cancelled;
summary =
string.Format(" Cancelled after {0} sec and {1} nodes at {2:0} nodes/s (puzzle score {3})",
StringHelper.ToString(TimeSpan.FromSeconds(info.TotalSeconds)),
info.TotalNodes,
info.TotalNodes/info.TotalSeconds,
info.RatingScore);
}
else if (controllerResult == SolverController.States.CompleteNoSolution)
{
status = CalculationResult.NoSolution;
summary = "The puzzle does not have a solution";
}
else
{
status = CalculationResult.GaveUp;
summary = string.Format(
"The solver could not find a within the given constraints. Tried for {0} sec and {1} nodes at {2:0} nodes/s (puzzle score {3})",
StringHelper.ToString(TimeSpan.FromSeconds(info.TotalSeconds)),
info.TotalNodes,
info.TotalNodes/info.TotalSeconds,
info.RatingScore);
}
}
}
}
/// <summary>
/// Strong Construction
/// </summary>
/// <param name="controller"></param>
public StaticAnalysis(SolverController controller)
{
this.controller = controller;
}
public RootPathVisualisation(SizeInt cellSize, SolverController controller)
{
this.cellSize = cellSize;
this.controller = controller;
}
public CommonDisplay(SolverController controller)
{
this.controller = controller;
}
private void SolverSection_Disposed(object sender, EventArgs e)
{
if (worker != null)
{
StopWorker(worker);
}
worker = null;
solver = null;
}
/// <summary>
/// Start the solver (this will always to run with a non UI worker thread)
/// </summary>
private void Solve()
{
try
{
complete = false;
solverEvalStatus = EvalStatus.InProgress;
solver = new SolverController(map);
solver.ExitConditions.StopOnSolution = exitConditions.cbStopOnSolution.Checked;
solver.ExitConditions.MaxDepth = (int)exitConditions.upMaxDepth.Value;
solver.ExitConditions.MaxNodes = (int)exitConditions.upMaxNodes.Value;
solver.ExitConditions.MaxItterations = (int)exitConditions.upMaxItter.Value;
solver.ExitConditions.MaxTimeSecs = (int)(exitConditions.upMaxTime.Value * 60);
solverEvalStatus = solver.Solve();
complete = true;
}
catch (Exception ex)
{
lastException = ex;
}
Invoke(OnComplete); // Set to SolverComplete
}
public override ReturnCodes Execute(ConsoleCommandController controller)
{
if (ArgReport != null)
{
reportFile = File.CreateText(ArgReport);
}
if (!string.IsNullOrEmpty(ArgSolverLibrary))
{
DateTime start = DateTime.Now;
// MODE: Progress + Library
ProgressComponent comp = new ProgressComponent();
Library lib = null;
// It is exists load...
if (File.Exists(ArgSolverLibrary))
{
comp.Load(ArgSolverLibrary);
}
// If a library is specified, merge/add it...
if (!string.IsNullOrEmpty(ArgLibrary))
{
XmlProvider xml = new XmlProvider();
lib = xml.Load(ArgLibrary);
comp.Add(lib);
}
int cc = 0;
foreach (SolverPuzzle item in comp.Items)
{
if (ArgNonSolutionOnly && item.HasSolution)
{
controller.DisplayLable("Skipping solution", item.Name);
cc++;
continue;
}
TimeSpan left = TimeSpan.FromSeconds((double) (comp.Items.Count - cc)*ArgMaxTime);
controller.DisplayLable("Est. Time Left", left.ToString());
controller.DisplayLable("Time Elapsed", (DateTime.Now-start).ToString());
controller.Display("==========================================================================");
controller.Display("");
controller.DisplayLable("Attempt", string.Format("{0}/{1} {2}%, maxtime={3}", cc, comp.Items.Count, cc*100/comp.Items.Count, TimeSpan.FromSeconds(ArgMaxTime)));
controller.DisplayLable("Name", item.Name);
controller.DisplayLable("Rating", string.Format("{0}, size=({1}, {2})", item.Rating, item.Width, item.Height));
controller.Display(StringHelper.Join(item.NormalisedMap, null, Environment.NewLine));
SokobanMap map = new SokobanMap();
map.SetFromStrings(item.NormalisedMap);
using (SolverController ctrl = new SolverController(map))
{
ctrl.ExitConditions.MaxDepth = 1000;
ctrl.ExitConditions.MaxItterations = 10000000;
ctrl.ExitConditions.MaxTimeSecs = (float) ArgMaxTime;
SolverResult res = ctrl.Solve();
if (res.Exception != null)
{
controller.Display(res.Exception);
}
controller.DisplayLable("Result", res.Summary);
comp.Update(res);
}
CheckForceGC();
controller.Display("---------------------------------------------------------------------------");
if (System.Console.KeyAvailable && System.Console.ReadKey().KeyChar == 'Q')
{
controller.Display("BREAK REQUESTED... Exiting");
break;
}
cc++;
}
comp.Save(ArgSolverLibrary);
}
else if (!string.IsNullOrEmpty(ArgLibrary))
{
// MODE: Only Library
XmlProvider xml = new XmlProvider();
Library lib = xml.Load(ArgLibrary);
if (ArgPuzzle == "*")
{
int cc = 0;
foreach (Puzzle puzzle in lib.Puzzles)
{
cc++;
controller.Display("");
controller.DisplayLable("Attempting", string.Format("{0:000} of {1:000}", cc, lib.Puzzles.Count));
SolvePuzzle(puzzle.MasterMap, puzzle.GetDetails().Name);
CheckForceGC();
if (System.Console.KeyAvailable && System.Console.ReadKey().KeyChar == 'Q')
{
controller.Display("BREAK REQUESTED... Exiting");
break;
}
}
}
else
{
Puzzle pux = lib.GetPuzzleByID(ArgPuzzle);
SolvePuzzle(pux.MasterMap, pux.GetDetails().Name);
}
}
if (reportFile != null)
{
reportFile.Close();
reportFile.Dispose();
}
return ReturnCodes.OK;
}
private void SolvePuzzle(PuzzleMap puz, string Name)
{
using (SolverController ctrl = new SolverController(puz))
{
ctrl.ExitConditions.MaxDepth = 1000;
ctrl.ExitConditions.MaxItterations = 10000000;
ctrl.ExitConditions.MaxTimeSecs = (float) ArgMaxTime;
SolverResult res = ctrl.Solve();
if (res.Exception != null)
{
controller.Display(res.Exception);
}
controller.DisplayLable("Name", Name);
controller.DisplayLable("Result", res.StatusString);
controller.DisplayLable("Summary", res.Summary);
controller.DisplayLable("Exit Conditions", ctrl.ExitConditions.ToString());
if (res.HasSolution)
{
controller.DisplayLable("Solution", res.Solutions[0].Steps);
}
if (reportFile != null)
{
reportFile.WriteLine("###########################################################################");
reportFile.WriteLine(string.Format("{0} ===> {1}", Name, res.Summary));
reportFile.WriteLine("###########################################################################");
reportFile.WriteLine(res.Info.ToString());
reportFile.WriteLine(res.DebugReport.ToString(new DebugReportFormatter()));
reportFile.WriteLine("---------------------------------------------------------------------------");
reportFile.WriteLine("");
}
}
}
/// <summary>
/// Strong constuctor
/// </summary>
/// <param name="cellSize"></param>
/// <param name="controller"></param>
public RootPathVisualisation(SizeInt cellSize, SolverController controller)
{
this.cellSize = cellSize;
this.controller = controller;
this.Display = new CommonDisplay(controller);
}
/// <summary>
/// Exit click
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsbExit_Click(object sender, EventArgs e)
{
// Stop anything that has started
tsbStop_Click(sender, e);
if (worker != null)
{
StopWorker(worker);
}
solver = null;
worker = null;
// Set the library
FormMain main = FindForm() as FormMain;
main.Mode = FormMain.Modes.Library;
}
public void Init(SolverController controller)
{
treeRenderer = new TreeVisualisation(controller);
treeRenderer.RenderCanvas = new RectangleInt(0, 0, 1800, 1800);
treeVis.Visualisation = treeRenderer;
}
public TreeVisualisation(SolverController controller)
{
this.controller = controller;
this.tree = controller.Strategy.EvaluationTree;
}
