void DebugAnalysisTest(S_BOARD *pos, S_SEARCHINFO *info) {
FILE *file;
file = fopen("lct2.epd","r");
char lineIn [1024];
info->depth = MAXDEPTH;
info->timeset = TRUE;
int time = 1140000;
if(file == NULL) {
printf("File Not Found\n");
return;
} else {
while(fgets (lineIn , 1024 , file) != NULL) {
info->starttime = GetTimeMs();
info->stoptime = info->starttime + time;
ClearHashTable(pos->HashTable);
ParseFen(lineIn, pos);
printf("\n%s\n",lineIn);
printf("time:%d start:%d stop:%d depth:%d timeset:%d\n",
time,info->starttime,info->stoptime,info->depth,info->timeset);
SearchPosition(pos, info);
memset(&lineIn[0], 0, sizeof(lineIn));
}
}
}
void ComplexMesh::FreeMemory()
{
_Vertices.FreeMemory();
_Triangles.FreeMemory();
_HalfEdges.FreeMemory();
for(UINT i = 0; i < _FullEdges.Length(); i++)
{
delete _FullEdges[i];
}
_FullEdges.FreeMemory();
ClearHashTable();
}
int setoption(char *input, ENGINE_STATE *stat)
{
int val = 0;
if (sscanf(input, "setoption name Hash value %i", &val)) {
DeleteTable(&hash_table);
DeletePawnTable(&pawn_table);
if (AllocPawnTable(&pawn_table, 0.2*val) == 0) return 0;
if (AllocTable(&hash_table, 0.8*val) == 0) return 0;
ClearHashTable(&hash_table);
ClearPawnTable(&pawn_table);
} else if (sscanf(input, "setoption name Contempt value %i", &val)) {
stat->control->contempt = val;
printf("contempt: %i\n", stat->control->contempt);
}
return 1;
}
// Only clear those configs which are not dead
// seems I implemented, but did not used it
// find out if it really works ???
void ResetHashTable()
{
//#ifdef USE_OWN_CACHE
ClearHashTable();
//#else
/* int i;
for (i=0;i<HASHTABLESIZE;i++)
if (hashTable[i])
if (hashTable[i]->status!=STATUS_DEAD)
{
delete hashTable[i];
hashTable[i] = NULL;
usedconfiglength--;
}
solution_count = 0;
solution_length = 0;
#endif*/
}
void InitHashTable(S_HASHTABLE *table, const int MB) {
int HashSize = 0x100000 * MB;
table->numEntries = HashSize / sizeof(S_HASHENTRY);
table->numEntries -= 2;
if(table->pTable!=NULL) {
free(table->pTable);
}
table->pTable = (S_HASHENTRY *) malloc(table->numEntries * sizeof(S_HASHENTRY));
if(table->pTable == NULL) {
printf("Hash Allocation Failed, trying %dMB...\n",MB/2);
InitHashTable(table,MB/2);
} else {
ClearHashTable(table);
printf("HashTable init complete with %d entries\n",table->numEntries);
}
}
int main(int argc, char *argv[])
{
BOARD main_board;
InitBoard(&main_board);
ReadFEN(STARTPOS, &main_board);
CONTROL engine_control;
engine_control.stop = 1;
ENGINE_STATE engine = {&main_board, &engine_control};
if (AllocTable(&hash_table, 0.8*TABLESIZE) == 0) {
printf("Not enough memory\n");
return 1;
}
ClearHashTable(&hash_table);
if (AllocPawnTable(&pawn_table, 0.2*TABLESIZE) == 0) {
printf("Not enough memory\n");
return 1;
}
ClearPawnTable(&pawn_table);
setvbuf(stdin, 0, _IONBF, 0);
setvbuf(stdout, 0, _IONBF, 0);
fflush(NULL);
char input[BUFFER];
while (fgets(input, BUFFER, stdin)) {
if (!Command(input, &engine)) {
break;
}
memset(input, 0, BUFFER);
}
DeleteTable(&hash_table);
DeletePawnTable(&pawn_table);
return 0;
}
void Init()
{
ClearHashTable();
}
// 主搜索函数
int SearchMain ( void ) {
// 特殊情况
MoveSortStruct mvsort;
int nMoveNum = mvsort.InitMove ();
if ( nMoveNum == 0 ) { // 无着法
printf ( "bestmove a0a1 resign\n" );
fflush ( stdout );
return 0;
}
else if ( nMoveNum == 1 ) { // 唯一着法
printf ( "bestmove %s\n", MoveIntToStr(mvsort.move[0]).c_str() );
fflush ( stdout );
return mvsort.move[0];
}
if ( pos.IsDraw() ) { // 和局
printf ( "bestmove a0a1 draw\n" );
fflush ( stdout );
// 注意不要return
}
// 初始化
ClearHistoryTable ();
ClearHashTable ();
ClearHashTableQC ();
InitBeginTime ( SEARCH_TOTAL_TIME );
// 迭代加深搜索
printf("depth time nNode rBeta");
for ( int i = 0; i < 3; i ++ ) {
printf(" bvl[%d] bmv[%d]", i, i);
}
printf("\n");
fflush ( stdout );
int lastbvl[nBest], lastbmv[nBest];
ClearBmvBvl ( lastbmv, lastbvl );
for ( int depth = 1; /*depth <= ?*/; depth ++ ) {
InitBeginTime ( THIS_SEARCH_TIME );
InitSearchStruct ();
SearchAlphaBeta ( depth, - MATE_VALUE, MATE_VALUE );
if ( TimeOut() ) {
CopyBmvBvl ( Search.bmv, Search.bvl, lastbmv, lastbvl );
break;
}
else {
CopyBmvBvl ( lastbmv, lastbvl, Search.bmv, Search.bvl );
}
printf( "%5d %.2fs %7d %2.0f%%", depth, TimeCost(SEARCH_TOTAL_TIME), Search.nNode, 100.0*Search.nBeta/Search.nNode);
for ( int i = 0; i < 3; i ++ ) {
printf(" %6d %s", Search.bvl[i], MoveIntToStr(Search.bmv[i]).c_str());
}
printf("\n");
fflush ( stdout );
if ( Search.bvl[0] <= - BAN_VALUE || Search.bvl[0] >= BAN_VALUE) {
break;
}
if ( Search.bvl[1] <= - BAN_VALUE || Search.bmv[1] == 0 ) {
break;
}
}
printf ( "totaltime: %.2fs\n", TimeCost(SEARCH_TOTAL_TIME) );
fflush ( stdout );
// 输出最优着法
if ( Search.bmv[0] == 0 || Search.bvl[0] <= - BAN_VALUE ) {
printf ( "bestmove a0a1 resign\n" ); // 认输
fflush ( stdout );
return 0;
}
else {
printf ( "bestmove %s\n", MoveIntToStr(Search.bmv[0]).c_str() );
fflush ( stdout );
return Search.bmv[0];
}
}
/* virtual */
OpSyncDataHashedCollection::~OpSyncDataHashedCollection()
{
ClearHashTable();
}
void OpSyncDataHashedCollection::SetOOM()
{
OP_NEW_DBG("OpSyncDataHashedCollection::SetOOM()", "sync");
ClearHashTable();
m_oom = true;
}
int ucinewgame(char *input, ENGINE_STATE *stat)
{
ClearHashTable(&hash_table);
ClearPawnTable(&pawn_table);
return 1;
}
void ComplexMesh::Load(const BaseMesh &Mesh)
{
FreeMemory();
_Vertices.Allocate(Mesh.VertexCount());
_Triangles.Allocate(Mesh.FaceCount());
_HalfEdges.Allocate(Mesh.FaceCount() * 3);
_FullEdges.FreeMemory();
for(UINT i = 0; i < _Vertices.Length(); i++)
{
_Vertices[i].Pos() = Mesh.Vertices()[i].Pos;
_Vertices[i].TexCoords() = Mesh.Vertices()[i].TexCoord;
_Vertices[i].Boundary() = false;
_Vertices[i]._Index = i;
}
InitHashTable(_Vertices.Length());
for(UINT TriangleIndex = 0; TriangleIndex < _Triangles.Length(); TriangleIndex++)
{
Triangle &CurTriangle = _Triangles[TriangleIndex];
UINT LocalIndices[3];
LocalIndices[0] = Mesh.Indices()[TriangleIndex * 3 + 0];
LocalIndices[1] = Mesh.Indices()[TriangleIndex * 3 + 1];
LocalIndices[2] = Mesh.Indices()[TriangleIndex * 3 + 2];
CurTriangle._Index = TriangleIndex;
for(UINT LocalEdgeIndex = 0; LocalEdgeIndex < 3; LocalEdgeIndex++)
{
Vertex *SearchV[2];
CurTriangle._HalfEdges[LocalEdgeIndex] = &_HalfEdges[TriangleIndex * 3 + LocalEdgeIndex];
CurTriangle._Vertices[LocalEdgeIndex] = &_Vertices[LocalIndices[LocalEdgeIndex]];
_HalfEdges[TriangleIndex * 3 + LocalEdgeIndex]._NextEdge = &_HalfEdges[TriangleIndex * 3 + (LocalEdgeIndex + 1) % 3];
SearchV[0] = &_Vertices[LocalIndices[(LocalEdgeIndex + 1) % 3]];
SearchV[1] = &_Vertices[LocalIndices[(LocalEdgeIndex + 2) % 3]];
if(SearchV[0]->Index() > SearchV[1]->Index())
{
Utility::Swap(SearchV[0], SearchV[1]);
}
FullEdge &Target = FindFullEdge(SearchV);
if(Target != FullEdge::NotFound)
{
PersistentAssert(Target.GetTriangle(1) == Triangle::Boundary, "Duplicate edge; 2-manifold criterion violated.");
//PersistentAssert(Target.GetTriangle(1) == Triangle::Boundary,
// String("Duplicate edge; 2-manifold criterion violated: ") + String(SearchV[0]->Index()) + String(", ") + String(SearchV[1]->Index()));
_HalfEdges[TriangleIndex * 3 + LocalEdgeIndex]._AcrossEdge = &Target;
Target._Triangles[1] = &CurTriangle;
}
else
{
FullEdge *NewEdge = new FullEdge;
Assert(NewEdge != NULL, "Out of memory");
NewEdge->_Index = _FullEdges.Length();
NewEdge->_Triangles[0] = &CurTriangle;
NewEdge->_Triangles[1] = &Triangle::Boundary;
NewEdge->_Vertices[0] = SearchV[0];
NewEdge->_Vertices[1] = SearchV[1];
_HalfEdges[TriangleIndex * 3 + LocalEdgeIndex]._AcrossEdge = NewEdge;
_FullEdges.PushEnd(NewEdge);
HashEdge(*NewEdge);
}
}
}
for(UINT TriangleIndex = 0; TriangleIndex < _Triangles.Length(); TriangleIndex++)
{
Triangle &CurTriangle = _Triangles[TriangleIndex];
for(UINT AdjacentTriangleIndex = 0; AdjacentTriangleIndex < 3; AdjacentTriangleIndex++)
{
Triangle &AdjTriangle = CurTriangle.GetNeighboringTriangle(AdjacentTriangleIndex);
}
}
ClearHashTable();
for(UINT i = 0; i < _FullEdges.Length(); i++)
{
if(_FullEdges[i]->Boundary())
{
_FullEdges[i]->GetVertex(0).Boundary() = true;
_FullEdges[i]->GetVertex(1).Boundary() = true;
_FullEdges[i]->OrientMatchingBoundary();
}
}
PrepareTopology();
/*if(!Oriented())
{
Orient();
}
PersistentAssert(Oriented(), "Mesh not oriented");*/
}
void ComplexMesh::InitHashTable(UINT Size)
{
ClearHashTable();
_HashTable.Allocate(Size);
}
