TDE
/
tdegames
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdegames
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '18b5622af4'
${ noResults }
tdegames/kenolaba/Board.cpp

1494 lines
34 KiB
Raw Blame History

/* Class Board
*
* with methods for
* - play/take back moves
* - generate allowed moves
* - calculate rating for position
* - search for best move
*
* Josef Weidendorfer, 28.8.97
*/
#include <stdio.h>
#include <qdatetime.h>
#include <qstrlist.h>
#include <kconfig.h>
#include <krandomsequence.h>
#include "Board.h"
#include "EvalScheme.h"
// #define MYTRACE 1
#if 0
#define CHECK(b) Q_ASSERT(b)
#else
#define CHECK(b)
#endif
static int ratedPositions, wonPositions, searchCalled, moveCount;
static int normalCount, pushCount, outCount, cutoffCount;
/*********************** Class PrincipalVariation *************************/
void PrincipalVariation::clear(int d)
{
int i,j;
for(i=0;i<maxDepth;i++)
for(j=0;j<maxDepth;j++) {
move[i][j].type = Move::none;
}
actMaxDepth = (d<maxDepth) ? d:maxDepth-1;
}
void PrincipalVariation::update(int d, Move& m)
{
int i;
if (d>actMaxDepth) return;
for(i=d+1;i<=actMaxDepth;i++) {
move[d][i]=move[d+1][i];
move[d+1][i].type = Move::none;
}
move[d][d]=m;
}
/****************************** Class Board ****************************/
/* Board for start of a game */
int Board::startBoard[]={
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 1, 1, 1, 1, 1, 10, 10, 10, 10, 10,
10, 1, 1, 1, 1, 1, 1, 10, 10, 10, 10,
10, 0, 0, 1, 1, 1, 0, 0, 10, 10, 10,
10, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10,
10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10,
10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 10,
10, 10, 10, 0, 0, 2, 2, 2, 0, 0, 10,
10, 10, 10, 10, 2, 2, 2, 2, 2, 2, 10,
10, 10, 10, 10, 10, 2, 2, 2, 2, 2, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
/* first centrum of board, then rings around (numbers are indexes) */
int Board::order[]={
60,
61,72,71,59,48,49,
62,73,84,83,82,70,58,47,36,37,38,50,
63,74,85,96,95,94,93,81,69,57,46,35,24,25,26,27,39,51,
64,75,86,97,108,107,106,105,104,92,80,68,56,45,34,23,12,
13,14,15,16,28,40,52 };
/* See EvalScheme.{h|cpp}
*
// Ratings for fields are calculated out of these values
// (see setFieldValues)
int Board::ringValue[] = { 45, 35, 25, 10, 0 };
int Board::ringDiff[] = { 0, 10, 10, 8, 5 };
// Value added to board rating according to the difference of
// stones in game of player1 and player2
int Board::stoneValue[]= { 0,-800,-1800,-3000,-4400,-6000 };
// Default Values for moves values (see Move.h)
int Board::moveValue[]= { 40,30,30, 15,14,13, 5,5,5, 2,2,2, 1 };
// Default Values for inARow values (see Move.h)
int Board::inARowValue[]= { 2, 5, 4, 3 };
*/
int Board::fieldValue[61];
int Board::direction[]= { -11,1,12,11,-1,-12,-11,1 };
Board::Board()
{
clear();
breakOut = bUpdateSpy = false;
spyLevel = 1;
spyDepth = 0;
debug = 0;
realMaxDepth = 1;
_evalScheme = 0;
}
void Board::setEvalScheme(EvalScheme* scheme)
{
if (!scheme)
scheme = new EvalScheme( QString("Default") );
_evalScheme = scheme;
setFieldValues();
}
void Board::setFieldValues()
{
if (!_evalScheme) return;
int i, j = 0, k = 59;
int ringValue[5], ringDiff[5];
for(i=0;i<5;i++) {
ringDiff[i] = _evalScheme->ringDiff(i);
ringValue[i] = _evalScheme->ringValue(i);
if (ringDiff[i]<1) ringDiff[i]=1;
}
fieldValue[0] = ringValue[0];
for(i=1;i<7;i++)
fieldValue[i] = ringValue[1] + ((j+=k) % ringDiff[1]);
for(i=7;i<19;i++)
fieldValue[i] = ringValue[2] + ((j+=k) % ringDiff[2]);
for(i=19;i<37;i++)
fieldValue[i] = ringValue[3] + ((j+=k) % ringDiff[3]);
for(i=37;i<61;i++)
fieldValue[i] = ringValue[4] + ((j+=k) % ringDiff[4]);
}
void Board::begin(int startColor)
{
int i;
for(i=0;i<AllFields;i++)
field[i] = startBoard[i];
storedFirst = storedLast = 0;
color = startColor;
color1Count = color2Count = 14;
random.setSeed(0); // Initialize random sequence
}
void Board::clear()
{
int i;
for(i=0;i<AllFields;i++)
field[i] = (startBoard[i] == out) ? out: free;
storedFirst = storedLast = 0;
color1Count = color2Count = 0;
}
/* generate moves starting at field <startField> */
void Board::generateFieldMoves(int startField, MoveList& list)
{
int d, dir, c, actField;
bool left, right;
int opponent = (color == color1) ? color2 : color1;
Q_ASSERT( field[startField] == color );
/* 6 directions */
for(d=1;d<7;d++) {
dir = direction[d];
/* 2nd field */
c = field[actField = startField+dir];
if (c == free) {
/* (c .) */
list.insert(startField, d, Move::move1);
continue;
}
if (c != color)
continue;
/* 2nd == color */
left = (field[startField+direction[d-1]] == free);
if (left) {
left = (field[actField+direction[d-1]] == free);
if (left)
/* 2 left */
list.insert(startField, d, Move::left2);
}
right = (field[startField+direction[d+1]] == free);
if (right) {
right = (field[actField+direction[d+1]] == free);
if (right)
/* 2 right */
list.insert(startField, d, Move::right2);
}
/* 3rd field */
c = field[actField += dir];
if (c == free) {
/* (c c .) */
list.insert(startField, d, Move::move2);
continue;
}
else if (c == opponent) {
/* 4th field */
c = field[actField += dir];
if (c == free) {
/* (c c o .) */
list.insert(startField, d, Move::push1with2);
}
else if (c == out) {
/* (c c o |) */
list.insert(startField, d, Move::out1with2);
}
continue;
}
if (c != color)
continue;
/* 3nd == color */
if (left) {
if (field[actField+direction[d-1]] == free)
/* 3 left */
list.insert(startField, d, Move::left3);
}
if (right) {
if (field[actField+direction[d+1]] == free)
/* 3 right */
list.insert(startField, d, Move::right3);
}
/* 4th field */
c = field[actField += dir];
if (c == free) {
/* (c c c .) */
list.insert(startField, d, Move::move3);
continue;
}
if (c != opponent)
continue;
/* 4nd == opponent */
/* 5. field */
c = field[actField += dir];
if (c == free) {
/* (c c c o .) */
list.insert(startField, d, Move::push1with3);
continue;
}
else if (c == out) {
/* (c c c o |) */
list.insert(startField, d, Move::out1with3);
continue;
}
if (c != opponent)
continue;
/* 5nd == opponent */
/* 6. field */
c = field[actField += dir];
if (c == free) {
/* (c c c o o .) */
list.insert(startField, d, Move::push2);
}
else if (c == out) {
/* (c c c o o |) */
list.insert(startField, d, Move::out2);
}
}
}
void Board::generateMoves(MoveList& list)
{
int actField, f;
for(f=0;f<RealFields;f++) {
actField = order[f];
if ( field[actField] == color)
generateFieldMoves(actField, list);
}
}
void Board::playMove(const Move& m)
{
int f, dir, dir2;
int opponent = (color == color1) ? color2:color1;
CHECK( isConsistent() );
if (++storedLast == MvsStored) storedLast = 0;
/* Buffer full -> delete oldest entry */
if (storedLast == storedFirst)
if (++storedFirst == MvsStored) storedFirst = 0;
storedMove[storedLast] = m;
f = m.field;
CHECK( (m.type >= 0) && (m.type < Move::none));
CHECK( field[f] == color );
field[f] = free;
dir = direction[m.direction];
switch(m.type) {
case Move::out2: /* (c c c o o |) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == opponent );
CHECK( field[f + 4*dir] == opponent );
CHECK( field[f + 5*dir] == out );
field[f + 3*dir] = color;
break;
case Move::out1with3: /* (c c c o |) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == opponent );
CHECK( field[f + 4*dir] == out );
field[f + 3*dir] = color;
break;
case Move::move3: /* (c c c .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == free );
field[f + 3*dir] = color;
break;
case Move::out1with2: /* (c c o |) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == opponent );
CHECK( field[f + 3*dir] == out );
field[f + 2*dir] = color;
break;
case Move::move2: /* (c c .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == free );
field[f + 2*dir] = color;
break;
case Move::push2: /* (c c c o o .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == opponent );
CHECK( field[f + 4*dir] == opponent );
CHECK( field[f + 5*dir] == free );
field[f + 3*dir] = color;
field[f + 5*dir] = opponent;
break;
case Move::left3:
dir2 = direction[m.direction-1];
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + dir2] == free );
CHECK( field[f + dir+dir2] == free );
CHECK( field[f + 2*dir+dir2] == free );
field[f+dir2] = color;
field[f+=dir] = free;
field[f+dir2] = color;
field[f+=dir] = free;
field[f+dir2] = color;
break;
case Move::right3:
dir2 = direction[m.direction+1];
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + dir2] == free );
CHECK( field[f + dir+dir2] == free );
CHECK( field[f + 2*dir+dir2] == free );
field[f+dir2] = color;
field[f+=dir] = free;
field[f+dir2] = color;
field[f+=dir] = free;
field[f+dir2] = color;
break;
case Move::push1with3: /* (c c c o .) => (. c c c o) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == opponent );
CHECK( field[f + 4*dir] == free );
field[f + 3*dir] = color;
field[f + 4*dir] = opponent;
break;
case Move::push1with2: /* (c c o .) => (. c c o) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == opponent );
CHECK( field[f + 3*dir] == free );
field[f + 2*dir] = color;
field[f + 3*dir] = opponent;
break;
case Move::left2:
dir2 = direction[m.direction-1];
CHECK( field[f + dir] == color );
CHECK( field[f + dir2] == free );
CHECK( field[f + dir+dir2] == free );
field[f+dir2] = color;
field[f+=dir] = free;
field[f+dir2] = color;
break;
case Move::right2:
dir2 = direction[m.direction+1];
CHECK( field[f + dir] == color );
CHECK( field[f + dir2] == free );
CHECK( field[f + dir+dir2] == free );
field[f+dir2] = color;
field[f+=dir] = free;
field[f+dir2] = color;
break;
case Move::move1: /* (c .) => (. c) */
CHECK( field[f + dir] == free );
field[f + dir] = color;
break;
default:
break;
}
if (m.isOutMove()) {
if (color == color1)
color2Count--;
else
color1Count--;
}
/* change actual color */
color = opponent;
CHECK( isConsistent() );
}
bool Board::takeBack()
{
int f, dir, dir2;
int opponent = color;
Move& m = storedMove[storedLast];
CHECK( isConsistent() );
if (storedFirst == storedLast) return false;
/* change actual color */
color = (color == color1) ? color2:color1;
if (m.isOutMove()) {
if (color == color1)
color2Count++;
else
color1Count++;
}
f = m.field;
CHECK( field[f] == free );
field[f] = color;
dir = direction[m.direction];
switch(m.type) {
case Move::out2: /* (. c c c o |) => (c c c o o |) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == color );
CHECK( field[f + 4*dir] == opponent );
CHECK( field[f + 5*dir] == out );
field[f + 3*dir] = opponent;
break;
case Move::out1with3: /* (. c c c |) => (c c c o |) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == color );
CHECK( field[f + 4*dir] == out );
field[f + 3*dir] = opponent;
break;
case Move::move3: /* (. c c c) => (c c c .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == color );
field[f + 3*dir] = free;
break;
case Move::out1with2: /* (. c c | ) => (c c o |) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == out );
field[f + 2*dir] = opponent;
break;
case Move::move2: /* (. c c) => (c c .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
field[f + 2*dir] = free;
break;
case Move::push2: /* (. c c c o o) => (c c c o o .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == color );
CHECK( field[f + 4*dir] == opponent );
CHECK( field[f + 5*dir] == opponent );
field[f + 3*dir] = opponent;
field[f + 5*dir] = free;
break;
case Move::left3:
dir2 = direction[m.direction-1];
CHECK( field[f + dir] == free );
CHECK( field[f + 2*dir] == free );
CHECK( field[f + dir2] == color );
CHECK( field[f + dir+dir2] == color );
CHECK( field[f + 2*dir+dir2] == color );
field[f+dir2] = free;
field[f+=dir] = color;
field[f+dir2] = free;
field[f+=dir] = color;
field[f+dir2] = free;
break;
case Move::right3:
dir2 = direction[m.direction+1];
CHECK( field[f + dir] == free );
CHECK( field[f + 2*dir] == free );
CHECK( field[f + dir2] == color );
CHECK( field[f + dir+dir2] == color );
CHECK( field[f + 2*dir+dir2] == color );
field[f+dir2] = free;
field[f+=dir] = color;
field[f+dir2] = free;
field[f+=dir] = color;
field[f+dir2] = free;
break;
case Move::push1with3: /* (. c c c o) => (c c c o .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == color );
CHECK( field[f + 4*dir] == opponent );
field[f + 3*dir] = opponent;
field[f + 4*dir] = free;
break;
case Move::push1with2: /* (. c c o) => (c c o .) */
CHECK( field[f + dir] == color );
CHECK( field[f + 2*dir] == color );
CHECK( field[f + 3*dir] == opponent );
field[f + 2*dir] = opponent;
field[f + 3*dir] = free;
break;
case Move::left2:
dir2 = direction[m.direction-1];
CHECK( field[f + dir] == free );
CHECK( field[f + dir2] == color );
CHECK( field[f + dir+dir2] == color );
field[f+dir2] = free;
field[f+=dir] = color;
field[f+dir2] = free;
break;
case Move::right2:
dir2 = direction[m.direction+1];
CHECK( field[f + dir] == free );
CHECK( field[f + dir2] == color );
CHECK( field[f + dir+dir2] == color );
field[f+dir2] = free;
field[f+=dir] = color;
field[f+dir2] = free;
break;
case Move::move1: /* (. c) => (c .) */
CHECK( field[f + dir] == color );
field[f + dir] = free;
break;
default:
break;
}
if (--storedLast < 0) storedLast = MvsStored-1;
CHECK( isConsistent() );
return true;
}
int Board::movesStored()
{
int c = storedLast - storedFirst;
if (c<0) c+= MvsStored;
return c;
}
/** countFrom
*
* Used for board evaluation to count allowed move types and
* connectiveness. VERY similar to move generation.
*
* Returns number of found moves
*/
void Board::countFrom(int startField, int color,
MoveTypeCounter& TCounter,
InARowCounter& CCounter)
{
int d, dir, c, actField, c2;
bool left, right;
/* 6 directions */
for(d=1;d<7;d++) {
dir = direction[d];
/* 2nd field */
c = field[actField = startField+dir];
if (c == free) {
TCounter.incr( Move::move1 );
continue;
}
if (c != color)
continue;
/* 2nd == color */
CCounter.incr( InARowCounter::inARow2 );
/* left side move 2 */
left = (field[startField+direction[d-1]] == free);
if (left) {
left = (field[actField+direction[d-1]] == free);
if (left)
TCounter.incr( Move::left2 );
}
/* right side move 2 */
right = (field[startField+direction[d+1]] == free);
if (right) {
right = (field[actField+direction[d+1]] == free);
if (right)
TCounter.incr( Move::right2 );
}
/* 3rd field */
c = field[actField += dir];
if (c == free) {
/* (c c .) */
TCounter.incr( Move::move2 );
continue;
}
else if (c == out) {
continue;
}
else if (c != color) {
/* 4th field */
c = field[actField += dir];
if (c == free) {
/* (c c o .) */
TCounter.incr( Move::push1with2 );
}
else if (c == out) {
/* (c c o |) */
TCounter.incr( Move::out1with2 );
}
continue;
}
/* 3nd == color */
CCounter.incr( InARowCounter::inARow3 );
/* left side move 3 */
if (left) {
left = (field[actField+direction[d-1]] == free);
if (left)
TCounter.incr( Move::left3 );
}
/* right side move 3 */
if (right) {
right = (field[actField+direction[d+1]] == free);
if (right)
TCounter.incr( Move::right3 );
}
/* 4th field */
c = field[actField += dir];
if (c == free) {
/* (c c c .) */
TCounter.incr( Move::move3 );
continue;
}
else if (c == out) {
continue;
}
else if (c != color) {
/* 4nd == opponent */
/* 5. field */
c2 = field[actField += dir];
if (c2 == free) {
/* (c c c o .) */
TCounter.incr( Move::push1with3 );
continue;
}
else if (c2 == out) {
/* (c c c o |) */
TCounter.incr( Move::out1with3 );
continue;
}
if (c2 != c)
continue;
/* 5nd == opponent */
/* 6. field */
c2 = field[actField += dir];
if (c2 == free) {
/* (c c c o o .) */
TCounter.incr( Move::push2 );
}
else if (c2 == out) {
/* (c c c o o |) */
TCounter.incr( Move::out2 );
}
continue;
}
/* 4nd == color */
CCounter.incr( InARowCounter::inARow4 );
/* 5th field */
c = field[actField += dir];
if (c != color)
continue;
/* 4nd == color */
CCounter.incr( InARowCounter::inARow5 );
}
}
/** indent
*
* Internal: for debugging output only
*/
void indent(int d)
{
char tmp[]=" ";
tmp[d*3] = 0;
printf("> %s",tmp);
}
/** validState
*
* Check for a valid board position to play from:
* (1) Number of balls for each color has to be between 9 and 14
* (2) There must be a move possible for actual color
*/
int Board::validState()
{
MoveTypeCounter tc;
InARowCounter cc;
int c1 = 0, c2 = 0;
int i,j, moveCount, res;
for(i=0;i<AllFields;i++) {
j=field[i];
if (j == color1) c1++;
if (j == color2) c2++;
if (j == color)
countFrom( i, color, tc, cc);
}
color1Count = c1;
color2Count = c2;
moveCount = tc.sum();
if (c1==0 && c2==0)
res = empty;
else if (c1>8 && c1<15 && c2>8 && c2<15 && moveCount>0 )
res = valid;
else
res = invalid;
#ifdef MYTRACE
if (spyLevel>2) {
indent(spyDepth);
printf("Valid: %s (Color1 %d, Color2 %d, moveCount of %d: %d)\n",
(res == empty) ? "empty" : (res==valid) ? "valid":"invalid",
c1,c2,color,moveCount);
}
#endif
return res;
}
/* Calculate a evaluation for actual position
*
* A higher value means a better position for opponent
* NB: This means a higher value for better position of
* 'color before last move'
*/
int Board::calcEvaluation()
{
MoveTypeCounter tcColor, tcOpponent;
InARowCounter ccColor, ccOpponent;
int f,i,j;
/* different evaluation types */
int fieldValueSum=0, stoneValueSum=0;
int moveValueSum=0, inARowValueSum=0;
int valueSum;
/* First check simple winner condition */
if (color1Count <9)
valueSum = (color==color1) ? 16000 : -16000;
else if (color2Count <9)
valueSum = (color==color2) ? 16000 : -16000;
else {
/* Calculate fieldValueSum and count move types and connectivity */
for(i=0;i<RealFields;i++) {
j=field[f=order[i]];
if (j == free) continue;
if (j == color) {
countFrom( f, j, tcColor, ccColor );
fieldValueSum -= fieldValue[i];
}
else {
countFrom( f, j, tcOpponent, ccOpponent );
fieldValueSum += fieldValue[i];
}
}
/* If color can't do any moves, opponent wins... */
if (tcColor.sum() == 0)
valueSum = 16000;
else {
for(int t=0;t < Move::typeCount;t++)
moveValueSum += _evalScheme->moveValue(t) *
(tcOpponent.get(t) - tcColor.get(t));
for(int i=0;i < InARowCounter::inARowCount;i++)
inARowValueSum += _evalScheme->inARowValue(i) *
(ccOpponent.get(i) - ccColor.get(i));
if (color == color2)
stoneValueSum = _evalScheme->stoneValue(14 - color1Count) -
_evalScheme->stoneValue(14 - color2Count);
else
stoneValueSum = _evalScheme->stoneValue(14 - color2Count) -
_evalScheme->stoneValue(14 - color1Count);
valueSum = fieldValueSum + moveValueSum +
inARowValueSum + stoneValueSum;
}
}
#ifdef MYTRACE
if (spyLevel>2) {
indent(spyDepth);
printf("Eval %d (field %d, move %d, inARow %d, stone %d)\n",
valueSum, fieldValueSum, moveValueSum,
inARowValueSum, stoneValueSum );
}
#endif
return valueSum;
}
bool Board::isConsistent()
{
int c1 = 0, c2 = 0;
int i,j;
for(i=0;i<RealFields;i++) {
j=field[order[i]];
if (j == color1) c1++;
if (j == color2) c2++;
}
return (color1Count == c1 && color2Count == c2);
}
void Board::changeEvaluation()
{
int i,tmp;
/* innermost ring */
tmp=fieldValue[1];
for(i=1;i<6;i++)
fieldValue[i] = fieldValue[i+1];
fieldValue[6] = tmp;
tmp=fieldValue[7];
for(i=7;i<18;i++)
fieldValue[i] = fieldValue[i+1];
fieldValue[18] = tmp;
tmp=fieldValue[19];
for(i=19;i<36;i++)
fieldValue[i] = fieldValue[i+1];
fieldValue[36] = tmp;
/* the outermost ring */
tmp=fieldValue[37];
for(i=37;i<60;i++)
fieldValue[i] = fieldValue[i+1];
fieldValue[60] = tmp;
}
/*
void Board::showHist()
{
Move m1, m2;
printf("After playing ");
(m1=lastMove()).print();
print();
printf("TakeBack "); m1.print();
takeBack(); print();
printf("TakeBack ");
(m2=lastMove()).print();
takeBack(); print();
printf("Play "); m2.print();
playMove(m2); print();
printf("Play "); m1.print();
playMove(m1); print();
getchar();
}
*/
/*
* We always try the maximize the board value
*/
int Board::search(int depth, int alpha, int beta)
{
int actValue= -14999+depth, value;
Move m;
MoveList list;
bool depthPhase, doDepthSearch;
searchCalled++;
/* We make a depth search for the following move types... */
int maxType = (depth < maxDepth-1) ? Move::maxMoveType() :
(depth < maxDepth) ? Move::maxPushType() :
Move::maxOutType();
generateMoves(list);
#ifdef MYTRACE
int oldRatedPositions;
int oldWonPositions;
int oldSearchCalled;
int oldMoveCount;
int oldNormalCount;
int oldPushCount;
int oldOutCount;
int oldCutoffCount;
spyDepth = depth;
moveCount += list.getLength();
/*
if (spyLevel>1) {
indent(depth);
printf("%s (%6d .. %6d) MaxType %s\n", depth,
(color==color1)?"O":"X", alpha,beta,
(depth < maxDepth-1) ? "Moving" :
(depth < maxDepth)? "Pushing" : "PushOUT" );
}
*/
#endif
/* check for a old best move in main combination */
if (inPrincipalVariation) {
m = pv[depth];
if ((m.type != Move::none) &&
(!list.isElement(m, 0, true)))
m.type = Move::none;
if (m.type == Move::none)
inPrincipalVariation = false;
#ifdef MYTRACE
else {
if (spyLevel>1) {
indent(spyDepth);
printf("Got from pv !\n" );
}
}
#endif
}
// first, play all moves with depth search
depthPhase = true;
while (1) {
// get next move
if (m.type == Move::none) {
if (depthPhase)
depthPhase = list.getNext(m, maxType);
if (!depthPhase)
if (!list.getNext(m, Move::none)) break;
}
// we could start with a non-depth move from principal variation
doDepthSearch = depthPhase && (m.type <= maxType);
#ifdef MYTRACE
if (m.isOutMove()) outCount++;
else if (m.isPushMove()) pushCount++;
else normalCount++;
if (doDepthSearch) {
oldRatedPositions = ratedPositions;
oldWonPositions = wonPositions;
oldSearchCalled = searchCalled;
oldMoveCount = moveCount;
oldNormalCount = normalCount;
oldPushCount = pushCount;
oldOutCount = outCount;
oldCutoffCount = cutoffCount;
if (spyLevel>1) {
indent(spyDepth);
printf("%s [%6d .. %6d] ",
(color==color1)?"O":"X", alpha,beta);
m.print();
printf("\n");
}
#ifdef SPION
if (bUpdateSpy) emit update(depth, 0, m, false);
#endif
}
#endif
playMove(m);
if (!isValid()) {
/* Possibility (1) to win: Ball Count <9 */
value = 14999-depth;
// value = ((depth < maxDepth) ? 15999:14999) - depth;
#ifdef MYTRACE
wonPositions++;
#endif
}
else {
if (doDepthSearch) {
/* opponent searches for his maximum; but we want the
* minimum: so change sign (for alpha/beta window too!)
*/
value = - search(depth+1,-beta,-alpha);
}
else {
ratedPositions++;
value = calcEvaluation();
}
}
takeBack();
/* For GUI response */
if (doDepthSearch && (maxDepth - depth >2))
emit searchBreak();
#ifdef MYTRACE
if (doDepthSearch) {
spyDepth = depth;
if (spyLevel>1) {
indent(spyDepth);
if (oldSearchCalled < searchCalled) {
printf(" %d Calls", searchCalled-oldSearchCalled);
if (cutoffCount>oldCutoffCount)
printf(" (%d Cutoffs)", cutoffCount-oldCutoffCount);
printf(", GenMoves %d (%d/%d/%d played)",
moveCount - oldMoveCount,
normalCount - oldNormalCount,
pushCount-oldPushCount,
outCount-oldOutCount);
printf(", Rate# %d",
ratedPositions+wonPositions
- oldRatedPositions - oldWonPositions);
if (wonPositions > oldWonPositions)
printf(" (%d Won)", wonPositions- oldWonPositions);
printf("\n");
indent(spyDepth);
}
printf(" => Rated %d%s\n",
value,
(value>14900) ? ", WON !":
(value>=beta) ? ", CUTOFF !":
(value>actValue) ? ", Best !": "");
}
}
else {
if (spyLevel>2) {
indent(spyDepth);
printf("%s (%6d .. %6d) %-25s => Rating %6d%s\n",
(color==color1)?"O":"X", alpha,beta,
m.name().latin1(),
value,
(value>14900) ? ", WON !":
(value>=beta) ? ", CUTOFF !":
(value>actValue) ? ", Best !": "");
}
}
if (value>=beta) cutoffCount++;
#endif
#ifdef SPION
if (bUpdateSpy) {
if (value > actValue)
emit updateBest(depth, value, m, value >= beta);
emit update(depth, value, m, true);
}
#endif
if (value > actValue) {
actValue = value;
pv.update(depth, m);
// Only update best move if not stopping search
if (!breakOut && (depth == 0)) {
_bestMove = m;
if (bUpdateSpy) {
emit updateBestMove(m, actValue);
#ifdef MYTRACE
if (spyLevel>0) {
int i;
printf("> New pv (Rating %d):", actValue);
for(i=0;i<=maxDepth;i++) {
printf("\n> D %d: %s",
i, pv[i].name().latin1() );
}
printf("\n>\n");
}
#endif
}
}
if (actValue>14900 || actValue >= beta)
return actValue;
/* maximize alpha */
if (actValue > alpha) alpha = actValue;
}
if (breakOut) depthPhase=false;
m.type = Move::none;
}
return actValue;
}
Move& Board::bestMove()
{
int alpha=-15000,beta=15000;
int nalpha,nbeta, actValue;
if (!_evalScheme) {
// Use default values if not set
setEvalScheme();
}
pv.clear(realMaxDepth);
_bestMove.type = Move::none;
maxDepth=1;
show = false;
breakOut = false;
spyDepth = 0;
if (spyLevel>0)
printf("\n> New Search\n>\n");
/* iterative deepening loop */
do {
if (spyLevel>0)
printf("> MaxDepth: %d\n>\n", maxDepth);
/* searches on same level with different alpha/beta windows */
while(1) {
if (spyLevel>0)
printf("> AB-Window: (%d ... %d)\n>\n", alpha, beta);
nalpha=alpha, nbeta=beta;
inPrincipalVariation = (pv[0].type != Move::none);
/* Statistics */
searchCalled = 0;
moveCount = 0;
ratedPositions = 0;
wonPositions = 0;
normalCount = 0;
pushCount = 0;
outCount = 0;
cutoffCount = 0;
actValue = search(0,alpha,beta);
if (spyLevel>0)
{
int i;
if (spyLevel>1)
printf(">\n");
printf("> Got PV with Rating %d:",actValue);
for(i=0;i<=maxDepth;i++) {
printf("\n> D %d: ", i);
pv[i].print();
}
printf("\n>\n");
printf("> Search called : %6d / %d Cutoffs\n",
searchCalled, cutoffCount);
printf("> Moves generated : %6d / %d Played\n",
moveCount, normalCount+pushCount+outCount);
printf("> Nrml/Push/Out : %6d / %d / %d\n",
normalCount,pushCount,outCount);
printf("> Positions rated : %6d / %d Won\n>\n",
ratedPositions+wonPositions, wonPositions);
}
if (actValue > 14900 || actValue < -14900)
breakOut=true;
/* Don't break out if we haven't found a move */
if (_bestMove.type == Move::none)
breakOut=false;
if (breakOut) break;
// widen alpha-beta window if needed
if (actValue <= nalpha) {
alpha = -15000;
if (beta<15000) beta=actValue+1;
continue;
}
if (actValue >= nbeta) {
if (alpha > -15000) alpha = actValue-1;
beta=15000;
continue;
}
break;
}
/* Window in both directions cause of deepening */
alpha=actValue-200, beta=actValue+200;
if (breakOut) break;
maxDepth++;
}
while(maxDepth <= realMaxDepth);
/* If Spy is On, we want replayable search: don't change rating! */
if (spyLevel==0)
changeEvaluation();
else {
printf(">>> Got Move : ");
pv[0].print();
printf("\n\n");
}
spyDepth = 0;
return _bestMove;
}
Move Board::randomMove()
{
Move m;
MoveList list;
generateMoves(list);
int l = list.getLength();
int j = random.getLong(l) +1;
while(j != 0) {
list.getNext(m, Move::none);
j--;
}
return m;
}
void Board::print(int )
{
int row,i;
char spaces[]=" ";
const char *z[]={". ","O ","X ", "o ", "x "};
printf("\n -----------\n");
for(row=0;row<4;row++) {
printf("%s/ ",spaces+row);
for(i=0;i<5+row;i++) printf("%s",z[field[row*11+12+i]]);
printf("\\\n");
}
printf(" | ");
for(i=0;i<9;i++) printf("%s",z[field[56+i]]);
printf("|\n");
for(row=0;row<4;row++) {
printf("%s\\ ",spaces+3-row);
for(i=0;i<8-row;i++) printf("%s",z[field[68+row*12+i]]);
printf("/\n");
}
printf(" ----------- O: %d X: %d\n",
color1Count, color2Count);
}
QString Board::getASCIIState(int moveNo)
{
QString state, tmp;
int row,i;
char spaces[]=" ";
const char *z[]={". ","O ","X ", "o ", "x "};
state += tmp.sprintf("\n #%-3d ----------- O: %d X: %d\n",
moveNo, color1Count, color2Count);
for(row=0;row<4;row++) {
state += tmp.sprintf("%s/ ",spaces+row);
for(i=0;i<5+row;i++)
state += tmp.sprintf("%s",z[field[row*11+12+i]]);
state += "\\\n";
}
state += " | ";
for(i=0;i<9;i++)
state += tmp.sprintf("%s",z[field[56+i]]);
state += "|\n";
for(row=0;row<4;row++) {
state += tmp.sprintf("%s\\ ",spaces+3-row);
for(i=0;i<8-row;i++)
state += tmp.sprintf("%s",z[field[68+row*12+i]]);
state += "/\n";
}
state += " -----------\n\n";
return state;
}
int Board::setASCIIState(const QString& state)
{
int moveNo=-1, index;
int len = state.length();
int color1Count = 0;
int color2Count = 0;
/* get moveNo if supplied */
if ((index = state.find("#"))>=0)
moveNo = state.mid(index+1,3).toInt();
int f=12, row=0, rowEnd = 17;
char c = ' ';
index=state.find("/");
while(index>=0) {
while(++index<len) {
c = state[index].latin1();
if (c !=' ') break;
}
if (c=='.') field[f++] = 0;
else if (c=='o' || c=='O') {
// printf(".. F %d: O\n", f);
field[f++] = 1;
color1Count++;
}
else if (c=='x' || c=='X') {
// printf(".. F %d: X\n", f);
field[f++] = 2;
color2Count++;
}
else {
if (index >= len) index=-1;
continue;
}
if (f == rowEnd) {
row++;
if (row <4) {
index = state.find("/",index);
f = 12 + row*11;
rowEnd = row*12+17;
}
else if (row==4) {
index = state.find("|",index);
f = 56;
rowEnd = 65;
}
else if (row <9) {
index = state.find("\\",index);
f = 8 + row*12;
rowEnd = 21 + row*11;
}
else
break;
// printf("Row %d: %d - %d, Idx %d\n", row, f, rowEnd, index);
}
}
return moveNo;
}
QString Board::getState(int moveNo)
{
QString state;
QString entry, tmp;
int i;
/* Color + Counts */
state += (char) ('A' + moveNo /25 );
state += (char) ('A' + moveNo %25 );
state += (char) ('A' + color1Count);
state += (char) ('A' + color2Count);
state += (char) ('A' + 4*color + field[order[0]]);
/* Board (field values can be 0-3; 2 fields coded in one char */
for(i=1;i<61;i+=2)
state+= (char) ('A' + 4*field[order[i]] + field[order[i+1]] );
/* -> 35 chars */
return state;
}
int Board::setState(QString& _state)
{
int moveNo;
const char *state = _state.ascii();
if (_state.length() != 35) return 0;
moveNo = 25*(state[0] - 'A') + (state[1] - 'A');
color1Count = state[2] - 'A';
color2Count = state[3] - 'A';
color = (state[4] - 'A') / 4;
field[order[0]] = (state[4] - 'A') %4;
int i = 1;
for(int j = 5; j<35; j++) {
int w = state[j] - 'A';
field[order[i++]] = w/4;
field[order[i++]] = w % 4;
}
return moveNo;
}
void Board::setSpyLevel(int level)
{
spyLevel = level;
}
#include "Board.moc"
View Git Blame Copy Permalink