00001 #include "FCCommandLineArguments.h" 00002 #include "FCSFreecellSolvingAlgorithm.h" 00003 #include "FCSOptimizeSolvingAlgorithm.h" 00004 #include "TestSolvingAlgorithms.h" 00005 #include "MainGameFunctions.h" 00006 #include "AFreecellGameBoard.h" 00007 00015 00016 /************************* 00017 Is there a way that I don't have to cast all this structures all of the time? 00018 **************************/ 00019 00020 /************************ 00021 * FREECELL TESTS 00022 *************************/ 00023 /* 00024 // run through each solving algorithm type in debug state type, 00025 // no optimization, avl-tree storage and stack type, on the board in firsttest.txt 00026 static const char * const Test1[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00027 static const char * const Test2[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00028 static const char * const Test3[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00029 static const char * const Test4[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00030 static const char * const Test5[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00031 00032 // run through each solving algorithm type in debug state type, 00033 // optimization on, avl-tree storage and stack type, on the board in firsttest.txt 00034 static const char * const Test6[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00035 static const char * const Test7[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00036 static const char * const Test8[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00037 static const char * const Test9[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00038 static const char * const Test10[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "debug", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00039 00040 // run through each solving algorithm type in debug state type, 00041 // no optimization, avl red-black tree storage and stack type, on the board in firsttest.txt 00042 static const char * const Test11[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00043 static const char * const Test12[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00044 static const char * const Test13[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00045 static const char * const Test14[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00046 static const char * const Test15[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00047 00048 // run through each solving algorithm type in debug state type, 00049 // optimization on, avl red-black tree storage and stack type, on the board in firsttest.txt 00050 static const char * const Test16[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00051 static const char * const Test17[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00052 static const char * const Test18[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00053 static const char * const Test19[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00054 static const char * const Test20[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "debug", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00055 00056 // run through each solving algorithm type in debug state type, 00057 // no optimization, red-black tree storage and stack type, on the board in firsttest.txt 00058 static const char * const Test21[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "debug", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00059 static const char * const Test22[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "debug", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00060 static const char * const Test23[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "debug", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00061 static const char * const Test24[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "debug", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00062 static const char * const Test25[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "debug", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00063 00064 // run through each solving algorithm type in debug state type, 00065 // optimization on, red-black tree storage and stack type, on the board in firsttest.txt 00066 static const char * const Test26[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "debug", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00067 static const char * const Test27[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "debug", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00068 static const char * const Test28[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "debug", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00069 static const char * const Test29[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "debug", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00070 static const char * const Test30[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "debug", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00071 00072 // run through each solving algorithm type in debug state type, 00073 // no optimization, glib tree storage type, on the board in firsttest.txt 00074 static const char * const Test31[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00075 static const char * const Test32[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00076 static const char * const Test33[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00077 static const char * const Test34[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00078 static const char * const Test35[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00079 00080 // run through each solving algorithm type in debug state type, 00081 // optimization on, glib tree storage and stack type, on the board in firsttest.txt 00082 static const char * const Test36[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00083 static const char * const Test37[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00084 static const char * const Test38[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00085 static const char * const Test39[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00086 static const char * const Test40[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "debug", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00087 00088 // run through each solving algorithm type in debug state type, 00089 // no optimization, glib hash storage and stack type, on the board in firsttest.txt 00090 static const char * const Test41[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00091 static const char * const Test42[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00092 static const char * const Test43[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00093 static const char * const Test44[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00094 static const char * const Test45[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00095 00096 // run through each solving algorithm type in debug state type, 00097 // optimization on, glib hash storage and stack type, on the board in firsttest.txt 00098 static const char * const Test46[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00099 static const char * const Test47[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00100 static const char * const Test48[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00101 static const char * const Test49[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00102 static const char * const Test50[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "debug", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00103 00104 // run through each solving algorithm type in debug state type, 00105 // no optimization, internal storage and stack type, on the board in firsttest.txt 00106 static const char * const Test51[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00107 static const char * const Test52[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00108 static const char * const Test53[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00109 static const char * const Test54[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00110 static const char * const Test55[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00111 00112 // run through each solving algorithm type in debug state type, 00113 // optimization on, internal storage and stack type, on the board in firsttest.txt 00114 static const char * const Test56[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00115 static const char * const Test57[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00116 static const char * const Test58[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00117 static const char * const Test59[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00118 static const char * const Test60[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "debug", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00119 00120 00121 00122 // run through each solving algorithm type in compact state type, 00123 // no optimization, avl-tree storage and stack type, on the board in firsttest.txt 00124 static const char * const Test101[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-me", "dfs", "-g", "freecell", "firsttest.txt", ""}; 00125 static const char * const Test102[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", ""}; 00126 static const char * const Test103[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", ""}; 00127 static const char * const Test104[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-me", "a-star", "-g", "freecell", "firsttest.txt", ""}; 00128 static const char * const Test105[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-me", "bfs", "-g", "freecell", "firsttest.txt", ""}; 00129 00130 // run through each solving algorithm type in compact state type, 00131 // optimization on, avl-tree storage and stack type, on the board in firsttest.txt 00132 static const char * const Test106[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", ""}; 00133 static const char * const Test107[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", ""}; 00134 static const char * const Test108[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", ""}; 00135 static const char * const Test109[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", ""}; 00136 static const char * const Test110[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "compact", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", ""}; 00137 00138 // run through each solving algorithm type in compact state type, 00139 // no optimization, avl red-black tree storage and stack type, on the board in firsttest.txt 00140 static const char * const Test111[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00141 static const char * const Test112[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00142 static const char * const Test113[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00143 static const char * const Test114[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00144 static const char * const Test115[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00145 00146 // run through each solving algorithm type in compact state type, 00147 // optimization on, avl red-black tree storage and stack type, on the board in firsttest.txt 00148 static const char * const Test116[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00149 static const char * const Test117[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00150 static const char * const Test118[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00151 static const char * const Test119[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00152 static const char * const Test120[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "compact", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00153 00154 // run through each solving algorithm type in compact state type, 00155 // no optimization, red-black tree storage and stack type, on the board in firsttest.txt 00156 static const char * const Test121[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "compact", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00157 static const char * const Test122[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "compact", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00158 static const char * const Test123[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "compact", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00159 static const char * const Test124[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "compact", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00160 static const char * const Test125[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "compact", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00161 00162 // run through each solving algorithm type in compact state type, 00163 // optimization on, red-black tree storage and stack type, on the board in firsttest.txt 00164 static const char * const Test126[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "compact", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00165 static const char * const Test127[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "compact", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00166 static const char * const Test128[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "compact", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00167 static const char * const Test129[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "compact", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00168 static const char * const Test130[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "compact", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00169 00170 // run through each solving algorithm type in compact state type, 00171 // no optimization, glib tree storage type, on the board in firsttest.txt 00172 static const char * const Test131[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00173 static const char * const Test132[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00174 static const char * const Test133[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00175 static const char * const Test134[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00176 static const char * const Test135[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00177 00178 // run through each solving algorithm type in compact state type, 00179 // optimization on, glib tree storage and stack type, on the board in firsttest.txt 00180 static const char * const Test136[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00181 static const char * const Test137[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00182 static const char * const Test138[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00183 static const char * const Test139[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00184 static const char * const Test140[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "compact", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00185 00186 // run through each solving algorithm type in compact state type, 00187 // no optimization, glib hash storage and stack type, on the board in firsttest.txt 00188 static const char * const Test141[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00189 static const char * const Test142[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00190 static const char * const Test143[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00191 static const char * const Test144[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00192 static const char * const Test145[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00193 00194 // run through each solving algorithm type in compact state type, 00195 // optimization on, glib hash storage and stack type, on the board in firsttest.txt 00196 static const char * const Test146[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00197 static const char * const Test147[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00198 static const char * const Test148[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00199 static const char * const Test149[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00200 static const char * const Test150[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "compact", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00201 00202 // run through each solving algorithm type in compact state type, 00203 // no optimization, internal storage and stack type, on the board in firsttest.txt 00204 static const char * const Test151[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00205 static const char * const Test152[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00206 static const char * const Test153[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00207 static const char * const Test154[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00208 static const char * const Test155[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00209 00210 // run through each solving algorithm type in compact state type, 00211 // optimization on, internal storage and stack type, on the board in firsttest.txt 00212 static const char * const Test156[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00213 static const char * const Test157[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00214 static const char * const Test158[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00215 static const char * const Test159[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00216 static const char * const Test160[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "compact", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00217 00218 00219 00220 // run through each solving algorithm type in indirect state type, 00221 // no optimization, avl-tree storage and stack type, on the board in firsttest.txt 00222 static const char * const Test201[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00223 static const char * const Test202[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00224 static const char * const Test203[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00225 static const char * const Test204[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00226 static const char * const Test205[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00227 00228 // run through each solving algorithm type in indirect state type, 00229 // optimization on, avl-tree storage and stack type, on the board in firsttest.txt 00230 static const char * const Test206[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00231 static const char * const Test207[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00232 static const char * const Test208[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00233 static const char * const Test209[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00234 static const char * const Test210[] = { "", "-sam", "-s", "-dd", "-stsr", "avl", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00235 00236 // run through each solving algorithm type in indirect state type, 00237 // no optimization, avl red-black tree storage and stack type, on the board in firsttest.txt 00238 static const char * const Test211[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00239 static const char * const Test212[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00240 static const char * const Test213[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00241 static const char * const Test214[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00242 static const char * const Test215[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00243 00244 // run through each solving algorithm type in indirect state type, 00245 // optimization on, avl red-black tree storage and stack type, on the board in firsttest.txt 00246 static const char * const Test216[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00247 static const char * const Test217[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00248 static const char * const Test218[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00249 static const char * const Test219[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00250 static const char * const Test220[] = { "", "-sam", "-s", "-dd", "-stsr", "avl_rb", "-sksr", "avl_rb", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00251 00252 // run through each solving algorithm type in indirect state type, 00253 // no optimization, red-black tree storage and stack type, on the board in firsttest.txt 00254 static const char * const Test221[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00255 static const char * const Test222[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00256 static const char * const Test223[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00257 static const char * const Test224[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00258 static const char * const Test225[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "red_black", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00259 00260 // run through each solving algorithm type in indirect state type, 00261 // optimization on, red-black tree storage and stack type, on the board in firsttest.txt 00262 static const char * const Test226[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00263 static const char * const Test227[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00264 static const char * const Test228[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00265 static const char * const Test229[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00266 static const char * const Test230[] = { "", "-sam", "-s", "-dd", "-stsr", "red_black", "-sksr", "avl", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00267 00268 // run through each solving algorithm type in indirect state type, 00269 // no optimization, glib tree storage type, on the board in firsttest.txt 00270 static const char * const Test231[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00271 static const char * const Test232[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00272 static const char * const Test233[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00273 static const char * const Test234[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00274 static const char * const Test235[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00275 00276 // run through each solving algorithm type in indirect state type, 00277 // optimization on, glib tree storage and stack type, on the board in firsttest.txt 00278 static const char * const Test236[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00279 static const char * const Test237[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00280 static const char * const Test238[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00281 static const char * const Test239[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00282 static const char * const Test240[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_tree", "-sksr", "glib_tree", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00283 00284 // run through each solving algorithm type in indirect state type, 00285 // no optimization, glib hash storage and stack type, on the board in firsttest.txt 00286 static const char * const Test241[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00287 static const char * const Test242[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00288 static const char * const Test243[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00289 static const char * const Test244[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00290 static const char * const Test245[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00291 00292 // run through each solving algorithm type in indirect state type, 00293 // optimization on, glib hash storage and stack type, on the board in firsttest.txt 00294 static const char * const Test246[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00295 static const char * const Test247[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00296 static const char * const Test248[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00297 static const char * const Test249[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00298 static const char * const Test250[] = { "", "-sam", "-s", "-dd", "-stsr", "glib_hash", "-sksr", "glib_hash", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00299 00300 // run through each solving algorithm type in indirect state type, 00301 // no optimization, internal storage and stack type, on the board in firsttest.txt 00302 static const char * const Test251[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00303 static const char * const Test252[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00304 static const char * const Test253[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00305 static const char * const Test254[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00306 static const char * const Test255[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00307 00308 // run through each solving algorithm type in indirect state type, 00309 // optimization on, internal storage and stack type, on the board in firsttest.txt 00310 static const char * const Test256[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00311 static const char * const Test257[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00312 static const char * const Test258[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00313 static const char * const Test259[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00314 static const char * const Test260[] = { "", "-sam", "-s", "-dd", "-stsr", "internal", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00315 00316 // run through each solving algorithm type in indirect state type, 00317 // no optimization, internal storage and stack type, on the board in firsttest.txt 00318 static const char * const Test261[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00319 static const char * const Test262[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00320 static const char * const Test263[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00321 static const char * const Test264[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00322 static const char * const Test265[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00323 00324 // run through each solving algorithm type in indirect state type, 00325 // optimization on, internal storage and stack type, on the board in firsttest.txt 00326 static const char * const Test266[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "dfs", "-g", "freecell", "firsttest.txt", NULL}; 00327 static const char * const Test267[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "soft-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00328 static const char * const Test268[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "random-dfs", "-g", "freecell", "firsttest.txt", NULL}; 00329 static const char * const Test269[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "a-star", "-g", "freecell", "firsttest.txt", NULL}; 00330 static const char * const Test270[] = { "", "-sam", "-s", "-dd", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "bfs", "-g", "freecell", "firsttest.txt", NULL}; 00331 00332 00333 00334 // All the tests run 00335 // Right now, I'm commenting out BFS Tests becuase they take too long with Freecell 00336 static const char** const AllTests[] = 00337 { 00338 //this is here so test number and array offset match 00339 NULL 00340 ,(const char **const)Test1 00341 ,(const char **const)Test2 00342 ,(const char **const)Test3 00343 ,(const char **const)Test4 00344 // ,(const char **const)Test5 00345 ,(const char **const)Test6 00346 ,(const char **const)Test7 00347 ,(const char **const)Test8 00348 ,(const char **const)Test9 00349 // ,(const char **const)Test10 00350 ,(const char **const)Test11 00351 ,(const char **const)Test12 00352 ,(const char **const)Test13 00353 ,(const char **const)Test14 00354 // ,(const char **const)Test15 00355 ,(const char **const)Test16 00356 ,(const char **const)Test17 00357 ,(const char **const)Test18 00358 ,(const char **const)Test19 00359 // ,(const char **const)Test20 00360 ,(const char **const)Test21 00361 ,(const char **const)Test22 00362 ,(const char **const)Test23 00363 ,(const char **const)Test24 00364 // ,(const char **const)Test25 00365 ,(const char **const)Test26 00366 ,(const char **const)Test27 00367 ,(const char **const)Test28 00368 ,(const char **const)Test29 00369 // ,(const char **const)Test30 00370 ,(const char **const)Test31 00371 ,(const char **const)Test32 00372 ,(const char **const)Test33 00373 ,(const char **const)Test34 00374 // ,(const char **const)Test35 00375 ,(const char **const)Test36 00376 ,(const char **const)Test37 00377 ,(const char **const)Test38 00378 ,(const char **const)Test39 00379 // ,(const char **const)Test40 00380 ,(const char **const)Test41 00381 ,(const char **const)Test42 00382 ,(const char **const)Test43 00383 ,(const char **const)Test44 00384 // ,(const char **const)Test45 00385 ,(const char **const)Test46 00386 ,(const char **const)Test47 00387 ,(const char **const)Test48 00388 ,(const char **const)Test49 00389 // ,(const char **const)Test50 00390 ,(const char **const)Test51 00391 ,(const char **const)Test52 00392 ,(const char **const)Test53 00393 ,(const char **const)Test54 00394 // ,(const char **const)Test55 00395 ,(const char **const)Test56 00396 ,(const char **const)Test57 00397 ,(const char **const)Test58 00398 ,(const char **const)Test59 00399 // ,(const char **const)Test60 00400 00401 00402 ,(const char **const)Test101 00403 ,(const char **const)Test102 00404 ,(const char **const)Test103 00405 ,(const char **const)Test104 00406 // ,(const char **const)Test105 00407 ,(const char **const)Test106 00408 ,(const char **const)Test107 00409 ,(const char **const)Test108 00410 ,(const char **const)Test109 00411 // ,(const char **const)Test110 00412 ,(const char **const)Test111 00413 ,(const char **const)Test112 00414 ,(const char **const)Test113 00415 ,(const char **const)Test114 00416 // ,(const char **const)Test115 00417 ,(const char **const)Test116 00418 ,(const char **const)Test117 00419 ,(const char **const)Test118 00420 ,(const char **const)Test119 00421 // ,(const char **const)Test120 00422 ,(const char **const)Test121 00423 ,(const char **const)Test122 00424 ,(const char **const)Test123 00425 ,(const char **const)Test124 00426 // ,(const char **const)Test125 00427 ,(const char **const)Test126 00428 ,(const char **const)Test127 00429 ,(const char **const)Test128 00430 ,(const char **const)Test129 00431 // ,(const char **const)Test130 00432 ,(const char **const)Test131 00433 ,(const char **const)Test132 00434 ,(const char **const)Test133 00435 ,(const char **const)Test134 00436 // ,(const char **const)Test135 00437 ,(const char **const)Test136 00438 ,(const char **const)Test137 00439 ,(const char **const)Test138 00440 ,(const char **const)Test139 00441 // ,(const char **const)Test140 00442 ,(const char **const)Test141 00443 ,(const char **const)Test142 00444 ,(const char **const)Test143 00445 ,(const char **const)Test144 00446 // ,(const char **const)Test145 00447 ,(const char **const)Test146 00448 ,(const char **const)Test147 00449 ,(const char **const)Test148 00450 ,(const char **const)Test149 00451 // ,(const char **const)Test150 00452 ,(const char **const)Test151 00453 ,(const char **const)Test152 00454 ,(const char **const)Test153 00455 ,(const char **const)Test154 00456 // ,(const char **const)Test155 00457 ,(const char **const)Test156 00458 ,(const char **const)Test157 00459 ,(const char **const)Test158 00460 ,(const char **const)Test159 00461 // ,(const char **const)Test160 00462 00463 00464 ,(const char **const)Test201 00465 ,(const char **const)Test202 00466 ,(const char **const)Test203 00467 ,(const char **const)Test204 00468 // ,(const char **const)Test205 00469 ,(const char **const)Test206 00470 ,(const char **const)Test207 00471 ,(const char **const)Test208 00472 ,(const char **const)Test209 00473 // ,(const char **const)Test210 00474 ,(const char **const)Test211 00475 ,(const char **const)Test212 00476 ,(const char **const)Test213 00477 ,(const char **const)Test214 00478 // ,(const char **const)Test215 00479 ,(const char **const)Test216 00480 ,(const char **const)Test217 00481 ,(const char **const)Test218 00482 ,(const char **const)Test219 00483 // ,(const char **const)Test220 00484 ,(const char **const)Test221 00485 ,(const char **const)Test222 00486 ,(const char **const)Test223 00487 ,(const char **const)Test224 00488 // ,(const char **const)Test225 00489 ,(const char **const)Test226 00490 ,(const char **const)Test227 00491 ,(const char **const)Test228 00492 ,(const char **const)Test229 00493 // ,(const char **const)Test230 00494 ,(const char **const)Test231 00495 ,(const char **const)Test232 00496 ,(const char **const)Test233 00497 ,(const char **const)Test234 00498 // ,(const char **const)Test235 00499 ,(const char **const)Test236 00500 ,(const char **const)Test237 00501 ,(const char **const)Test238 00502 ,(const char **const)Test239 00503 // ,(const char **const)Test240 00504 ,(const char **const)Test241 00505 ,(const char **const)Test242 00506 ,(const char **const)Test243 00507 ,(const char **const)Test244 00508 // ,(const char **const)Test245 00509 ,(const char **const)Test246 00510 ,(const char **const)Test247 00511 ,(const char **const)Test248 00512 ,(const char **const)Test249 00513 // ,(const char **const)Test250 00514 ,(const char **const)Test251 00515 ,(const char **const)Test252 00516 ,(const char **const)Test253 00517 ,(const char **const)Test254 00518 // ,(const char **const)Test255 00519 ,(const char **const)Test256 00520 ,(const char **const)Test257 00521 ,(const char **const)Test258 00522 ,(const char **const)Test259 00523 // ,(const char **const)Test260 00524 }; 00525 00526 void TestAllSolvingAlgorithms() 00527 { 00528 FCSFreecellSolvingAlgorithm* SolvingAlgorithm = NULL; 00529 FCCommandLineArguments *CommandLineArguments; 00530 FCSStateWithLocations *InitialState, 00531 *DuplicateInitialState; 00532 FCSStateSolvingReturnCodes SolveValue; 00533 int Count; 00534 00535 for (int i = 1;i<(sizeof(AllTests)/sizeof(char*));i++) 00536 { 00537 Count = 0; 00538 while (AllTests[i][Count] != NULL) 00539 Count++; 00540 00541 CommandLineArguments = new FCCommandLineArguments(); 00542 00543 if (!CommandLineArguments->Parse(Count, (char**)AllTests[i])) 00544 { 00545 cout << "Couldn't parse test parameters!" << endl; 00546 return; 00547 } 00548 00549 if (!CommandLineArguments->Verify()) 00550 { 00551 cout << "Couldn't verify test parameters!" << endl; 00552 return; 00553 } 00554 00555 SolvingAlgorithm = FCSFreecellSolvingAlgorithm::Create(CommandLineArguments); 00556 00557 InitialState = CommandLineArguments->GetInitialState(); 00558 00559 DuplicateInitialState = CreateStateWithLocations(); 00560 DuplicateInitialState->Copy(InitialState); 00561 00562 InitialState->CanonizeState(CommandLineArguments->GetNumberOfFreecells(), 00563 CommandLineArguments->GetNumberOfStacks()); 00564 00565 if (InitialState != NULL) 00566 { 00567 SolveValue = SolvingAlgorithm->Solve(InitialState, 0); 00568 } 00569 00570 while (SolveValue == FCS_STATE_SUSPEND_PROCESS) 00571 { 00572 SolvingAlgorithm->IncreaseMaxNumberOfCheckedStates(); 00573 SolveValue = SolvingAlgorithm->Resume(0); 00574 } 00575 if (SolveValue == FCS_STATE_WAS_SOLVED) 00576 { 00577 cout << "This game is solveable." << endl; 00578 if (CommandLineArguments->GetOptimizeSolution()) 00579 { 00580 cout << "Now trying to optimize solution." << endl; 00581 00582 SolvingAlgorithm->CleanData(); 00583 FCSOptimizeSolvingAlgorithm<FCSFreecellSolvingAlgorithm>* OptimizeSolution; 00584 OptimizeSolution = new FCSOptimizeSolvingAlgorithm<FCSFreecellSolvingAlgorithm>(SolvingAlgorithm); 00585 OptimizeSolution->Solve(InitialState, 0); 00586 OptimizeSolution->TraceSolution(); 00587 OptimizeSolution->ShowSolution(InitialState, DuplicateInitialState); 00588 delete OptimizeSolution; 00589 } 00590 else 00591 { 00592 SolvingAlgorithm->TraceSolution(); 00593 SolvingAlgorithm->ShowSolution(InitialState, DuplicateInitialState); 00594 } 00595 }a 00596 else 00597 { 00598 cout << "I could not solve this game." << endl; 00599 } 00600 00601 cout << "Total number of states checked is " << SolvingAlgorithm->GetNumberOfCheckedStates() << "." << endl; 00602 cout << "This scan generated " << SolvingAlgorithm->GetNumberOfStatesInCollection() << " states." << endl << endl; 00603 cout << endl << "TEST DONE!" << endl << endl; 00604 00605 delete InitialState; 00606 DuplicateInitialState->CleanState(); 00607 delete DuplicateInitialState; 00608 delete SolvingAlgorithm; 00609 delete CommandLineArguments; 00610 } 00611 } 00612 */ 00613 static const char * const AllGames[] = { /*"freecell", "simple_simon",*/ "klondike"}; 00614 /* 00615 "bakers_dozen", "bakers_game", "beleaguered_castle", "casino_klondike", "citadel", "cruel", 00616 "der_katzenschwanz", "der_katz", "die_schlange", "eight_off", "fan", "forecell", "freecell", 00617 "gnome_freecell", "good_measure", "gypsy", "kings_only_bakers_game", "klondike", "klondike_by_threes", 00618 "ko_bakers_game", "microsoft_freecell", "pysol_bakers_game", "pysol_beleaguered_castle", 00619 "pysol_casino_klondike", "pysol_eight_off", "pysol_freecell", "pysol_kings_only_bakers_game", 00620 "pysol_klondike", "pysol_klondike_by_threes", "pysol_ko_bakers_game", "pysol_relaxed_freecell", 00621 "pysol_relaxed_seahaven", "pysol_relaxed_seahaven_towers", "pysol_seahaven", "pysol_seahaven_towers", 00622 "pysol_streets_and_alleys", "pysol_thumb_and_pouch", "pysol_vegas_klondike", "relaxed_freecell", 00623 "relaxed_seahaven_towers", "relaxed_seahaven", "seahaven_towers", "simple_simon", "small_harp", 00624 "streets_and_alleys", "thumb_and_pouch", "vegas_klondike", "yukon", "whitehead", 00625 */ 00626 //static const char * const GameParameters[] = { "", "-stsr", "indirect", "-sksr", "internal", "-st", "indirect", "-opt", "-me", "dfs", "-g", "gamestring123456789012345678901234567890", "GameBoardTest.txt"}; 00627 00629 #define NUMBER_OF_COMMAND_LINE_PARAMETERS 16 00630 00631 #define MAX_LENGTH_OF_COMMAND_LINE_PARAMETER 40 00632 00633 #define TEST_GAME_START 1 00634 00635 #define TEST_GAME_END 1001 00636 00637 void TestEachGame() 00638 { 00639 AFreecellGameBoard* GameBoard; 00640 char GameBoardString[500]; 00641 char** GameParameters; 00642 FCSFreecellSolvingAlgorithm* SolvingAlgorithm = NULL; 00643 FCSSimpleSimonSolvingAlgorithm* SimpleSimonSolvingAlgorithm = NULL; 00644 FCSTalonSolvingAlgorithm* TalonSolvingAlgorithm = NULL; 00645 FCCommandLineArguments* CommandLineArguments; 00646 FCSStateWithLocations *InitialState, 00647 *DuplicateInitialState; 00648 FCSStateSolvingReturnCodes SolveValue; 00649 FCSPresetID GamePreset; 00650 ofstream Write; 00651 int i; 00652 int NumberOfUnsolvableGames = 0; 00653 00654 //create "command-line" 00655 GameParameters = new char*[NUMBER_OF_COMMAND_LINE_PARAMETERS]; 00656 for (i = 0; i < NUMBER_OF_COMMAND_LINE_PARAMETERS; i++) 00657 GameParameters[i] = new char[MAX_LENGTH_OF_COMMAND_LINE_PARAMETER]; 00658 strcpy(GameParameters[0], ""); 00659 strcpy(GameParameters[1], "-stsr"); 00660 strcpy(GameParameters[2], "indirect"); 00661 strcpy(GameParameters[3], "-sksr"); 00662 strcpy(GameParameters[4], "internal"); 00663 strcpy(GameParameters[5], "-st"); 00664 strcpy(GameParameters[6], "indirect"); 00665 strcpy(GameParameters[7], "-opt"); 00666 strcpy(GameParameters[8], "-me"); 00667 strcpy(GameParameters[9], "a-star"); 00668 strcpy(GameParameters[10], "-g"); 00669 strcpy(GameParameters[11], ""); 00670 strcpy(GameParameters[12], "-mi"); 00671 strcpy(GameParameters[13], "10000"); 00672 00673 strcpy(GameParameters[14], "GameBoardTest.txt"); 00674 00675 //Number of games to play 00676 for (int Seed = TEST_GAME_START; Seed < TEST_GAME_END; Seed++) 00677 { 00678 //run through all the games 00679 for (int Game = 0; Game < (sizeof(AllGames)/sizeof(char*)); Game++) 00680 { 00681 00682 cout << endl << "Game: " << AllGames[Game] << "\tSeed: " << Seed << endl << endl; 00683 00684 //Create the game board 00685 GameBoard = CreateAFreecellGameBoard((char*)AllGames[Game], false); 00686 GameBoardString[0] = NULL; 00687 GameBoard->Shuffle(Seed); 00688 GameBoard->Deal(GameBoardString); 00689 Write.open("GameBoardTest.txt"); 00690 Write << GameBoardString << endl; 00691 Write.close(); 00692 00693 //modify "command-line" to account for the game 00694 strcpy((char*)GameParameters[11], (char*)AllGames[Game]); 00695 00696 //modify commandline to reset game parameters 00697 strcpy(GameParameters[12], "-mi"); 00698 strcpy(GameParameters[13], "10000"); 00699 00700 strcpy(GameParameters[14], "GameBoardTest.txt"); 00701 00702 CommandLineArguments = new FCCommandLineArguments(); 00703 00704 if (!CommandLineArguments->Parse(15, GameParameters)) 00705 { 00706 cerr << "Couldn't solve " << AllGames[Game] << " board# " << Seed << endl 00707 << "Command line didn't parse." << endl; 00708 break; 00709 } 00710 if (!CommandLineArguments->Verify()) 00711 { 00712 cerr << "Couldn't solve " << AllGames[Game] << " board# " << Seed << endl 00713 << "Command line didn't verify." << endl; 00714 break; 00715 } 00716 00717 //first try to solve the game using a-star 00718 GamePreset = FCSPresetName::GetPresetID(CommandLineArguments->GetGameName()); 00719 MainCreate(GamePreset, CommandLineArguments, 00720 &SolvingAlgorithm, &SimpleSimonSolvingAlgorithm, &TalonSolvingAlgorithm); 00721 InitialState = CommandLineArguments->GetInitialState(); 00722 DuplicateInitialState = CreateStateWithLocations(); 00723 DuplicateInitialState->Copy(InitialState); 00724 InitialState->CanonizeState(CommandLineArguments->GetNumberOfFreecells(), 00725 CommandLineArguments->GetNumberOfStacks()); 00726 00727 if (InitialState != NULL) 00728 { 00729 SolveValue = MainSolve(GamePreset, InitialState, 00730 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00731 } 00732 00733 if (SolveValue == FCS_STATE_IS_NOT_SOLVEABLE) 00734 { 00735 cout << "This game is not solveable." << endl; 00736 NumberOfUnsolvableGames++; 00737 } 00738 else if (SolveValue != FCS_STATE_WAS_SOLVED) 00739 { 00740 //now try to solve the game using dfs 00741 DuplicateInitialState->CleanState(); 00742 delete DuplicateInitialState; 00743 00744 delete InitialState; 00745 delete SolvingAlgorithm; 00746 delete SimpleSimonSolvingAlgorithm; 00747 delete TalonSolvingAlgorithm; 00748 delete CommandLineArguments; 00749 00750 //change solving method to dfs 00751 strcpy(GameParameters[9], "dfs"); 00752 00753 //reparse commandline 00754 CommandLineArguments = new FCCommandLineArguments(); 00755 00756 if (!CommandLineArguments->Parse(15, GameParameters)) 00757 { 00758 cerr << "Couldn't solve " << AllGames[Game] << " board# " << Seed << endl 00759 << "Command line didn't parse." << endl; 00760 break; 00761 } 00762 if (!CommandLineArguments->Verify()) 00763 { 00764 cerr << "Couldn't solve " << AllGames[Game] << " board# " << Seed << endl 00765 << "Command line didn't verify." << endl; 00766 break; 00767 } 00768 00769 MainCreate(GamePreset, CommandLineArguments, 00770 &SolvingAlgorithm, &SimpleSimonSolvingAlgorithm, &TalonSolvingAlgorithm); 00771 InitialState = CommandLineArguments->GetInitialState(); 00772 DuplicateInitialState = CreateStateWithLocations(); 00773 DuplicateInitialState->Copy(InitialState); 00774 InitialState->CanonizeState(CommandLineArguments->GetNumberOfFreecells(), 00775 CommandLineArguments->GetNumberOfStacks()); 00776 00777 if (InitialState != NULL) 00778 { 00779 SolveValue = MainSolve(GamePreset, InitialState, 00780 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00781 } 00782 00783 if (SolveValue == FCS_STATE_IS_NOT_SOLVEABLE) 00784 { 00785 cout << "This game is not solveable." << endl; 00786 NumberOfUnsolvableGames++; 00787 } 00788 else if (SolveValue != FCS_STATE_WAS_SOLVED) 00789 { 00790 //try a-star again, but don't put a higher limit on the iterations 00791 DuplicateInitialState->CleanState(); 00792 delete DuplicateInitialState; 00793 00794 delete InitialState; 00795 delete SolvingAlgorithm; 00796 delete SimpleSimonSolvingAlgorithm; 00797 delete TalonSolvingAlgorithm; 00798 delete CommandLineArguments; 00799 00800 //change solving method to back to a-star 00801 strcpy(GameParameters[9], "a-star"); 00802 //up the limit of iterations 00803 strcpy(GameParameters[13], "500000"); 00804 00805 //reparse commandline 00806 CommandLineArguments = new FCCommandLineArguments(); 00807 00808 if (!CommandLineArguments->Parse(15, GameParameters)) 00809 { 00810 cerr << "Couldn't solve " << AllGames[Game] << " board# " << Seed << endl 00811 << "Command line didn't parse." << endl; 00812 break; 00813 } 00814 if (!CommandLineArguments->Verify()) 00815 { 00816 cerr << "Couldn't solve " << AllGames[Game] << " board# " << Seed << endl 00817 << "Command line didn't verify." << endl; 00818 break; 00819 } 00820 00821 MainCreate(GamePreset, CommandLineArguments, 00822 &SolvingAlgorithm, &SimpleSimonSolvingAlgorithm, &TalonSolvingAlgorithm); 00823 InitialState = CommandLineArguments->GetInitialState(); 00824 DuplicateInitialState = CreateStateWithLocations(); 00825 DuplicateInitialState->Copy(InitialState); 00826 InitialState->CanonizeState(CommandLineArguments->GetNumberOfFreecells(), 00827 CommandLineArguments->GetNumberOfStacks()); 00828 00829 if (InitialState != NULL) 00830 { 00831 SolveValue = MainSolve(GamePreset, InitialState, 00832 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00833 } 00834 00835 if (SolveValue != FCS_STATE_WAS_SOLVED) 00836 { 00837 cout << "This game is not solveable." << endl; 00838 NumberOfUnsolvableGames++; 00839 } 00840 else 00841 { 00842 cout << "This game is solveable." << endl; 00843 if (CommandLineArguments->GetOptimizeSolution()) 00844 { 00845 cout << "Now trying to optimize solution." << endl; 00846 MainOptimize(GamePreset, InitialState, DuplicateInitialState, 00847 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00848 } 00849 else 00850 { 00851 MainSolution(GamePreset, InitialState, DuplicateInitialState, 00852 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00853 } 00854 } 00855 } 00856 else 00857 { 00858 cout << "This game is solveable." << endl; 00859 if (CommandLineArguments->GetOptimizeSolution()) 00860 { 00861 cout << "Now trying to optimize solution." << endl; 00862 MainOptimize(GamePreset, InitialState, DuplicateInitialState, 00863 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00864 } 00865 else 00866 { 00867 MainSolution(GamePreset, InitialState, DuplicateInitialState, 00868 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00869 } 00870 } 00871 } 00872 else 00873 { 00874 cout << "This game is solveable." << endl; 00875 if (CommandLineArguments->GetOptimizeSolution()) 00876 { 00877 cout << "Now trying to optimize solution." << endl; 00878 MainOptimize(GamePreset, InitialState, DuplicateInitialState, 00879 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00880 } 00881 else 00882 { 00883 MainSolution(GamePreset, InitialState, DuplicateInitialState, 00884 SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00885 } 00886 } 00887 00888 MainStats(GamePreset, SolvingAlgorithm, SimpleSimonSolvingAlgorithm, TalonSolvingAlgorithm); 00889 00890 DuplicateInitialState->CleanState(); 00891 delete DuplicateInitialState; 00892 00893 delete InitialState; 00894 delete SolvingAlgorithm; 00895 delete SimpleSimonSolvingAlgorithm; 00896 delete TalonSolvingAlgorithm; 00897 delete CommandLineArguments; 00898 00899 delete GameBoard; 00900 } 00901 } 00902 00903 cout << endl << "Number of unsolvable games: " << NumberOfUnsolvableGames << endl; 00904 00905 //delete "command-line" 00906 for (i = 0; i < NUMBER_OF_COMMAND_LINE_PARAMETERS; i++) 00907 delete [] GameParameters[i]; 00908 delete [] GameParameters; 00909 00910 }
1.4.4