along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/Chess/chessTypes.cpp
along dfd1e74548 firs commit
2026-01-23 17:03:45 +08:00

2545 lines
63 KiB
C++
Raw Blame History

/*
----
This file is part of SECONDO.
Copyright (C) 2004, University in Hagen, Department of Computer Science,
Database Systems for New Applications.
SECONDO is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
SECONDO is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with SECONDO; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
----
//paragraph [1] title: [{\Large \bf ] [}]
August 2007. M. Spiekermann. Some bug fixes for bugs recognized using a 64bit linux
platform.
1) Member mpoint in Class Movingchesspiece wasn't initialized correctly.
2) Some moves of the pgn file were not recognized which lead to reading
uninitialized data
3) After fixing 1-2 creating movingpoints from a match fails. Needs still
to be fixed !!!
[1] Datatypes for ChessAlgebra (implementation)
*/
#include <iostream>
#include <string>
#include "chessTypes.h"
using namespace datetime;
using namespace temporalalgebra;
namespace ChessAlgebra {
/*
2 auxiliary functions implementation
*/
/*
compares two MetainfoEntry objects using strcmp on key component, which is
used for sorting metainfos DBArray in class chessgame
*/
int MetainfoEntryCmp( const void *v1, const void *v2 )
{
MetainfoEntry * mi1 = ( MetainfoEntry* ) v1;
MetainfoEntry* mi2 = ( MetainfoEntry* ) v2;
return ( strcmp( mi1->key, mi2->key ) );
}
/*
3 Class implementations
3.1 Class Material
*/
Material::Material() {}
Material::~Material() {}
Material::Material( char wPawn, char wKnight, char wRook,
char wBishop, char wQueen, char wKing,
char bPawn, char bKnight, char bRook,
char bBishop, char bQueen, char bKing ):
IndexableAttribute(true)
{
material[ WHITE_PAWN ] = wPawn;
material[ WHITE_KNIGHT ] = wKnight;
material[ WHITE_ROOK ] = wRook;
material[ WHITE_BISHOP ] = wBishop;
material[ WHITE_QUEEN ] = wQueen;
material[ WHITE_KING ] = wKing;
material[ BLACK_PAWN ] = bPawn;
material[ BLACK_KNIGHT ] = bKnight;
material[ BLACK_ROOK ] = bRook;
material[ BLACK_BISHOP ] = bBishop;
material[ BLACK_QUEEN ] = bQueen;
material[ BLACK_KING ] = bKing;
// calculate white material
char sum = 0;
for ( int i = WHITE_PAWN; i <= WHITE_KING; i++ )
sum += material[ i ];
material[ WHITE_MATERIAL ] = sum;
// calculate black material
sum = 0;
for ( int i = BLACK_PAWN; i <= BLACK_KING; i++ )
sum += material[ i ];
material[ BLACK_MATERIAL ] = sum;
}
Material::Material( char const *mat ):
IndexableAttribute(true)
{
for ( int i = WHITE_PAWN; i <= BLACK_KING; i++ )
material[ i ] = mat[ i ];
SetDefined( true );
// calculate white material
char sum = 0;
for ( int i = WHITE_PAWN; i <= WHITE_KING; i++ )
sum += material[ i ];
material[ WHITE_MATERIAL ] = sum;
// calculate black material
sum = 0;
for ( int i = BLACK_PAWN; i <= BLACK_KING; i++ )
sum += material[ i ];
material[ BLACK_MATERIAL ] = sum;
}
int Material::Compare( const Attribute* arg ) const
{
const Material * mat = ( Material* ) arg;
if ( !IsDefined() && !mat->IsDefined() )
return 0;
if ( !IsDefined() && mat->IsDefined() )
return -1;
if ( IsDefined() && !mat->IsDefined() )
return 1;
// both objects defined, compare material positions
int cmp;
// compare white pawns
cmp = material[ WHITE_PAWN ] - mat->material[ WHITE_PAWN ];
if (cmp != 0)
return cmp;
// compare black pawns
cmp = material[ BLACK_PAWN ] - mat->material[ BLACK_PAWN ];
if (cmp != 0)
return cmp;
// compare white knights
cmp = material[ WHITE_KNIGHT ] - mat->material[ WHITE_KNIGHT ];
if (cmp != 0)
return cmp;
// compare black knights
cmp = material[ BLACK_KNIGHT ] - mat->material[ BLACK_KNIGHT ];
if (cmp != 0)
return cmp;
// compare white bishops
cmp = material[ WHITE_BISHOP ] - mat->material[ WHITE_BISHOP ];
if (cmp != 0)
return cmp;
// compare black bishops
cmp = material[ BLACK_BISHOP ] - mat->material[ BLACK_BISHOP ];
if (cmp != 0)
return cmp;
// compare white rooks
cmp = material[ WHITE_ROOK ] - mat->material[ WHITE_ROOK ];
if (cmp != 0)
return cmp;
// compare black rooks
cmp = material[ BLACK_ROOK ] - mat->material[ BLACK_ROOK ];
if (cmp != 0)
return cmp;
// compare white queens
cmp = material[ WHITE_QUEEN ] - mat->material[ WHITE_QUEEN ];
if (cmp != 0)
return cmp;
// compare black queens
cmp = material[ BLACK_QUEEN ] - mat->material[ BLACK_QUEEN ];
if (cmp != 0)
return cmp;
// Kings should be always 1, so they are not compared.
return 0;
}
int Material::ComparePieceValues( const Attribute* arg ) const
{
const Material* mat = ( Material* ) arg;
if ( !IsDefined() && !mat->IsDefined() )
return 0;
if ( !IsDefined() && mat->IsDefined() )
return -1;
if ( IsDefined() && !mat->IsDefined() )
return 1;
if (PieceValue() < mat->PieceValue())
return -1;
if (PieceValue() > mat->PieceValue())
return 1;
return 0;
}
bool Material::Adjacent( const Attribute *arg ) const
{
//TODO ?
return false;
}
size_t Material::Sizeof() const
{
return sizeof( Material );
}
size_t Material::HashValue() const
{
return material[ BLACK_PAWN ] +
material[ BLACK_KNIGHT ] * 9 +
material[ BLACK_BISHOP ] * 27 +
material[ BLACK_ROOK ] * 81 +
material[ BLACK_QUEEN ] * 243 +
material[ WHITE_PAWN ] * 729 +
material[ WHITE_KNIGHT ] * 2187 +
material[ WHITE_BISHOP ] * 6561 +
material[ WHITE_ROOK ] * 19683 +
material[ WHITE_QUEEN ] * 59049;
}
void Material::CopyFrom( const Attribute* arg )
{
const Material* mat2 = (Material*) arg;
SetDefined( mat2->IsDefined());
for ( int i=0; i<14; i++ )
{
material[ i ] = mat2->material[ i ];
}
}
Material* Material::Clone() const
{
return new Material( *this );
}
void Material::WriteTo( char *dest ) const
{
*dest++ = IsDefined() ? '1' : '0';
for (int i=0; i < 14; i++)
*dest++ = material[ i ];
}
void Material::ReadFrom( const char *src )
{
SetDefined( (*src++ == '1') ? true : false);
for (int i=0; i < 14; i++)
material[ i ] = *src++;
}
SmiSize Material::SizeOfChars() const
{
return 14;
}
int Material::Count ( string type ) const
{
// count all figures
if ( type == "all" )
return ( material[ WHITE_MATERIAL ] + material[ BLACK_MATERIAL ] );
// count all white figures
if ( type == "white" )
return material[ WHITE_MATERIAL ];
// count all black figures
if ( type == "black" )
return material[ BLACK_MATERIAL ];
// search type string and return respective value
for ( int i = WHITE_PAWN; i <= BLACK_KING; i++ )
if ( type == DecodeAgent( i ) )
return material[ i ];
set<char> agents;
map<char, int> str2agent;
str2agent['P'] = WHITE_PAWN;
str2agent['N'] = WHITE_KNIGHT;
str2agent['B'] = WHITE_BISHOP;
str2agent['R'] = WHITE_ROOK;
str2agent['Q'] = WHITE_QUEEN;
str2agent['K'] = WHITE_KING;
str2agent['p'] = BLACK_PAWN;
str2agent['n'] = BLACK_KNIGHT;
str2agent['b'] = BLACK_BISHOP;
str2agent['r'] = BLACK_ROOK;
str2agent['q'] = BLACK_QUEEN;
str2agent['k'] = BLACK_KING;
for ( size_t i = 0; i < type.length(); i++ )
{
agents.insert( type[i] );
}
int sum = 0;
set<char>::iterator it = agents.begin();
for(; it != agents.end(); it++) {
map<char,int>::iterator it2 = str2agent.find( *it );
if ( it2 != str2agent.end() )
sum += material[ it2->second ];
}
return sum;
// unknown type string
return -1;
}
bool Material::IsEqual ( const Material* mat )
{
for ( int i = WHITE_PAWN; i <= BLACK_KING; i++ )
if ( ( material[ i ] != mat->material[ i ] ) )
return false;
return true;
}
int Material::PieceValue() const
{
int value = 0;
for ( int i = WHITE_PAWN; i <= BLACK_KING; i++ )
{
value += material[ i ] * PIECE_WEIGHT[ i ];
}
return value;
}
/*
3.2 Class Move
*/
Move::Move() {}
Move::~Move() {}
Move::Move( int moveNumber,
string agent, string captured,
string startFile, char startRow,
string endFile, char endRow,
bool check ):
IndexableAttribute(true)
{
char agentID = EncodeAgent( agent );
char capturedID = EncodeAgent( captured );
CheckBounds( startFile[ 0 ], startRow );
CheckBounds( endFile[ 0 ], endRow );
this->moveNumber = moveNumber;
this->agentID = agentID;
this->capturedID = capturedID;
this->startFile = startFile[ 0 ];
this->startRow = startRow;
this->endFile = endFile[ 0 ];
this->endRow = endRow;
this->check = check;
SetDefined ( true );
}
Move::Move( int moveNumber,
char agentID, char capturedID,
char startFile, char startRow,
char endFile, char endRow,
bool check ):
IndexableAttribute(true)
{
CheckBounds( startFile, startRow );
CheckBounds( endFile, endRow );
if ( ( agentID < 0 ) || ( agentID > 13 ) )
agentID = UNDEF;
if ( ( capturedID < 0 ) || ( capturedID > 13 ) )
capturedID = UNDEF;
this->moveNumber = moveNumber;
this->agentID = agentID;
this->capturedID = capturedID;
this->startFile = startFile;
this->startRow = startRow;
this->endFile = endFile;
this->endRow = endRow;
this->check = check;
SetDefined ( true );
}
/*
Two moves are equal if they move the same agent from the same
start field to the same end field.
*/
int Move::Compare( const Attribute* arg ) const
{
const Move * move = ( Move* ) arg;
if ( !IsDefined() && !move->IsDefined() )
return 0;
if ( !IsDefined() && move->IsDefined() )
return -1;
if ( IsDefined() && !move->IsDefined() )
return 1;
// both objects defined
int cmp;
// compare startfile
cmp = startFile - move->startFile;
if (cmp != 0)
return cmp;
// compare startrow
cmp = startRow - move->startRow;
if (cmp != 0)
return cmp;
// compare endfile
cmp = endFile - move->endFile;
if (cmp != 0)
return cmp;
// compare endrow
cmp = endRow - move->endRow;
if (cmp != 0)
return cmp;
// compare agentID
cmp = agentID - move->agentID;
if (cmp != 0)
return cmp;
// compare check state
/*
if ( check && !move->check )
return 1;
if ( !check && move->check )
return -1;
*/
return cmp;
}
bool Move::Adjacent( const Attribute *arg ) const
{
return false;
}
size_t Move::Sizeof() const
{
return sizeof( Move );
}
size_t Move::HashValue() const
{
if (IsDefined()) {
return moveNumber + check +
agentID + capturedID +
startFile + startRow +
endFile + endRow;
} else {
return 0;
}
}
void Move::CopyFrom( const Attribute* arg )
{
const Move* move2 = (Move*) arg;
SetDefined(move2->IsDefined());
moveNumber = move2->moveNumber;
agentID = move2->agentID;
capturedID = move2->capturedID;
startFile = move2->startFile;
startRow = move2->startRow;
endFile = move2->endFile;
endRow = move2->endRow;
check = move2->check;
}
Move* Move::Clone() const
{
return new Move( *this );
}
void Move::WriteTo( char *dest ) const
{
*dest++ = IsDefined() ? '1' : '0';
*dest++ = startFile;
*dest++ = startRow;
*dest++ = endFile;
*dest++ = endRow;
*dest++ = agentID;
*dest++ = check ? '1' : '0';
*dest++ = capturedID;
ostringstream tmp;
tmp << moveNumber;
strcpy(dest, tmp.str().c_str() );
}
void Move::ReadFrom( const char *src )
{
SetDefined((*src++ == '1') ? true : false);
startFile = *src++;
startRow = *src++;
endFile = *src++;
endRow = *src++;
agentID = *src++;
check = (*src++ == '1') ? true : false;
capturedID = *src++;
istringstream tmp(src);
tmp >> moveNumber;
}
SmiSize Move::SizeOfChars() const
{
return ( 8 + sizeof(int) );
}
/*
3.2 Class Position
*/
Position::Position() {}
Position::~Position() {}
Position::Position( int moveNumber ):
IndexableAttribute(true)
{
this->moveNumber = moveNumber;
for ( int i = 0; i < 64; i++ )
gamefield[ i ] = NONE;
for ( int i = WHITE_PAWN; i <= BLACK_KING; i++ )
material[ i ] = 0;
SetDefined(true);
}
/*
Two positions are equal, if they have the same pieces at
the same fields.
First the pieces (material) are compared.
Afterwards all 64 fields are compared. If some field of
the local position p1 has a piece but the argument's position p2
does not have a piece on that field then p1 < p2 yields.
*/
int Position::Compare( const Attribute* arg ) const
{
const Position* pos = ( Position* ) arg;
if ( !IsDefined() && !pos->IsDefined() )
return 0;
if ( !IsDefined() && pos->IsDefined() )
return -1;
if ( IsDefined() && !pos->IsDefined() )
return 1;
// both objects defined, compare material positions
int cmp;
// compare white pawns
cmp = material[ WHITE_PAWN ] - pos->material[ WHITE_PAWN ];
if (cmp != 0)
return cmp;
// compare black pawns
cmp = material[ BLACK_PAWN ] - pos->material[ BLACK_PAWN ];
if (cmp != 0)
return cmp;
// compare white knights
cmp = material[ WHITE_KNIGHT ] - pos->material[ WHITE_KNIGHT ];
if (cmp != 0)
return cmp;
// compare black knights
cmp = material[ BLACK_KNIGHT ] - pos->material[ BLACK_KNIGHT ];
if (cmp != 0)
return cmp;
// compare white bishops
cmp = material[ WHITE_BISHOP ] - pos->material[ WHITE_BISHOP ];
if (cmp != 0)
return cmp;
// compare black bishops
cmp = material[ BLACK_BISHOP ] - pos->material[ BLACK_BISHOP ];
if (cmp != 0)
return cmp;
// compare white rooks
cmp = material[ WHITE_ROOK ] - pos->material[ WHITE_ROOK ];
if (cmp != 0)
return cmp;
// compare black rooks
cmp = material[ BLACK_ROOK ] - pos->material[ BLACK_ROOK ];
if (cmp != 0)
return cmp;
// compare white queens
cmp = material[ WHITE_QUEEN ] - pos->material[ WHITE_QUEEN ];
if (cmp != 0)
return cmp;
// compare black queens
cmp = material[ BLACK_QUEEN ] - pos->material[ BLACK_QUEEN ];
if (cmp != 0)
return cmp;
// material is equal in both positions, compare gamefield positions
for ( int i = 0; i < 64; i++ )
{
if ((gamefield[ i ] != NONE) && (pos->gamefield[ i ] == NONE))
return 1;
if ((gamefield[ i ] == NONE) && (pos->gamefield[ i ] != NONE))
return -1;
cmp = (gamefield[ i ] - pos->gamefield[ i ]);
if (cmp != 0)
return cmp;
}
return cmp;
}
int Position::ComparePieceValues( const Attribute* arg ) const
{
const Position* pos = ( Position* ) arg;
if ( !IsDefined() && !pos->IsDefined() )
return 0;
if ( !IsDefined() && pos->IsDefined() )
return -1;
if ( IsDefined() && !pos->IsDefined() )
return 1;
Material localMat ;
GetMaterial(&localMat);
Material argMat;
pos->GetMaterial(&argMat);
if (localMat.PieceValue() < argMat.PieceValue())
return -1;
if (localMat.PieceValue() > argMat.PieceValue())
return 1;
return 0;
}
bool Position::Adjacent( const Attribute *arg ) const
{
//TODO ?
return false;
}
size_t Position::Sizeof() const
{
return sizeof( Position );
}
size_t Position::HashValue() const
{
size_t retval = 0;
if (IsDefined()) {
for(int i = 0; i < 64; i++){
retval += gamefield[ i ];
}
}
return retval;
}
void Position::CopyFrom( const Attribute* arg )
{
const Position* pos2 = (Position*) arg;
SetDefined(pos2->IsDefined());
moveNumber = pos2->moveNumber;
for ( int i=0; i<12; i++ )
{
material[ i ] = pos2->material[ i ];
}
for ( int i=0; i<64; i++ )
{
gamefield[ i ] = pos2->gamefield[ i ];
}
}
Position* Position::Clone() const
{
return new Position ( *this );
}
void Position::WriteTo( char *dest ) const
{
*dest++ = IsDefined() ? '1' : '0';
for (int i=0; i < 64; i++)
*dest++ = gamefield[ i ];
for (int i=0; i < 12; i++)
*dest++ = material[ i ];
ostringstream tmp;
tmp << moveNumber;
strcpy(dest, tmp.str().c_str() );
}
void Position::ReadFrom( const char *src )
{
SetDefined((*src++ == '1') ? true : false);
for (int i=0; i < 64; i++)
gamefield[ i ] = *src++;
for (int i=0; i < 12; i++)
material[ i ] = *src++;
istringstream tmp(src);
tmp >> moveNumber;
}
SmiSize Position::SizeOfChars() const
{
return ( 77 + sizeof(int) );
}
ostream& Position::Print( ostream& os ) const
{
return ( os << *this );
}
ostream& operator <<( ostream& os, const Position& pos )
{
os << "Move number : " << pos.moveNumber << endl;
for ( int i = 7; i >= 0; i-- )
{
for ( int j = 0; j < 8; j++ )
{
os << ( DecodeAgent( pos.gamefield[ ( i * 8 ) + j ] ) ) << " ";
}
os << endl;
}
os << endl << endl;
return os;
}
void Position::Reset()
{
for ( int i = 0; i < 64; i++ )
gamefield[ i ] = NONE;
for ( int i = 0; i < 12; i++ )
material[ i ] = 0;
}
void Position::StartPos()
{
// set empty positions
for ( int i = 16; i < 48; i++ )
gamefield[ i ] = NONE;
// set white and black pawns
for ( int i = 0; i < 8; i++ )
{
gamefield[ 8 + i ] = WHITE_PAWN;
gamefield[ 48 + i ] = BLACK_PAWN;
}
// set white rooks, knights, bishop, king and queen
gamefield[ 0 ] = WHITE_ROOK;
gamefield[ 1 ] = WHITE_KNIGHT;
gamefield[ 2 ] = WHITE_BISHOP;
gamefield[ 3 ] = WHITE_QUEEN;
gamefield[ 4 ] = WHITE_KING;
gamefield[ 5 ] = WHITE_BISHOP;
gamefield[ 6 ] = WHITE_KNIGHT;
gamefield[ 7 ] = WHITE_ROOK;
// set black rooks, knights, bishop, king and queen
gamefield[ 56 ] = BLACK_ROOK;
gamefield[ 57 ] = BLACK_KNIGHT;
gamefield[ 58 ] = BLACK_BISHOP;
gamefield[ 59 ] = BLACK_QUEEN;
gamefield[ 60 ] = BLACK_KING;
gamefield[ 61 ] = BLACK_BISHOP;
gamefield[ 62 ] = BLACK_KNIGHT;
gamefield[ 63 ] = BLACK_ROOK;
// set white material
material[ WHITE_PAWN ] = 8;
material[ WHITE_KNIGHT ] = 2;
material[ WHITE_BISHOP ] = 2;
material[ WHITE_ROOK ] = 2;
material[ WHITE_QUEEN ] = 1;
material[ WHITE_KING ] = 1;
// set black material
material[ BLACK_PAWN ] = 8;
material[ BLACK_KNIGHT ] = 2;
material[ BLACK_BISHOP ] = 2;
material[ BLACK_ROOK ] = 2;
material[ BLACK_QUEEN ] = 1;
material[ BLACK_KING ] = 1;
}
int Position::AddAgent( string agentStr, char file, char row )
{
// encode agent position (file and row will be bound to allowed values)
char pos = EncodePosition( file, row );
// get agentID on agent position
char oldAgentID = ( gamefield[ ( int ) pos ] );
// check, if agent position is empty and return errorcode -1 otherwhise
if ( oldAgentID == NONE )
{
// store agent, if agentStr is valid or return errorcode -2 otherwhise
char agentID = ( ( EncodeAgent( agentStr ) ) );
if ( ( agentID != NONE ) || ( agentID != UNDEF ) )
{
gamefield[ ( int ) pos ] = EncodeAgent( agentStr );
material[ ( int ) EncodeAgent( agentStr ) ] ++;
SetDefined(true);
return 0;
}
else
{
SetDefined(false);
return -2;
}
}
else
{
SetDefined(false);
return -1;
}
}
string Position::GetAgent( char file, char row, bool shortname )
{
char pos = EncodePosition( file, row );
if ( !shortname )
{
return DecodeAgent( ( int ) gamefield[ ( int ) pos ] );
}
else
{
return DecodeAgentShort( ( int ) gamefield[ ( int ) pos ] );
}
}
string Position::GetAgentShort( char file, char row )
{
return GetAgent( file, row, true );
}
void Position::GetMaterial( Material* result ) const
{
for ( int i = WHITE_PAWN; i <= BLACK_KING; i++ )
{
result->material[ i ] = material[ i ];
}
// calculate Count("White")
char sum = 0;
for ( int i = WHITE_PAWN; i <= WHITE_KING; i++ )
sum += material[ i ];
result->material[ WHITE_MATERIAL ] = sum;
// calculate Count("Black")
sum = 0;
for ( int i = BLACK_PAWN; i <= BLACK_KING; i++ )
sum += material[ i ];
result->material[ BLACK_MATERIAL ] = sum;
// test of Material::WriteTo() and Material::ReadTo()
/*
char matStr[result->SizeOfChars()];
result->WriteTo(&matStr[0]);
for ( int i = 0; i < 14; i++ )
{
result->material[ i ] = 0;
}
result->defined = ( false );
result->ReadFrom(&matStr[0]);
*/
}
bool Position::TestField ( string agentStr, char file, int row )
{
char agentPosID = gamefield[ ( int ) EncodePosition( file, row ) ];
char agentID = EncodeAgent( agentStr );
if ( agentID == agentPosID )
return true;
else
return false;
}
void Position::ShowBoard(ostream& os) {
os << endl;
for (int row=8; row > 0; row--) {
os << row;
for (char file='a'; file <= 'h'; file++) {
char agent = gamefield[ ( int ) EncodePosition( file, row ) ];
os << ' ' << DecodeAgentShort(agent);
}
os << endl;
}
os << " a b c d e f g h" << endl;
}
void Position::Range( Position* result, char startfile, char startrow,
char endfile, char endrow )
{
// check gamefields and set them to allowed values, if they are out of bound
CheckBounds( startfile, startrow );
CheckBounds( endfile, endrow );
result->Reset();
for ( int row = startrow; row <= endrow; row++ )
{
for ( char file = startfile; file <= endfile; file++ )
{
int pos = (int) EncodePosition( file, row );
char agentId = gamefield[ pos ];
result->gamefield[ pos ] = agentId;
result->material[ ( int ) agentId ]++;
}
}
result->moveNumber = moveNumber;
result->SetDefined( true );
}
bool Position::IsIncluded( Position * pos )
{
for ( int i = 0; i < 64; i++ )
if ( ( gamefield[ i ] != NONE ) &&
( gamefield[ i ] != pos->gamefield[ i ] ) )
return false;
return true;
}
/*
3.4 Class Chessgame
*/
Chessgame::Chessgame() {}
Chessgame::~Chessgame() {}
Chessgame::Chessgame( int metainfoCnt, int movesCnt ) :
IndexableAttribute(true),
metainfo( metainfoCnt ), moves( movesCnt ), positions( 0 )
{
White[ 0 ] = '\0';
Black[ 0 ] = '\0';
WhiteElo[ 0 ] = '\0';
BlackElo[ 0 ] = '\0';
Event[ 0 ] = '\0';
Site[ 0 ] = '\0';
Date[ 0 ] = '\0';
ECO[ 0 ] = '\0';
Result[ 0 ] = '\0';
}
int Chessgame::Compare( const Attribute* arg ) const
{
const Chessgame * game= ( Chessgame* ) arg;
if ( !IsDefined() && !game->IsDefined() )
return 0;
if ( !IsDefined()&& game->IsDefined())
return -1;
if ( IsDefined()&& !game->IsDefined() )
return 1;
// both objects defined, compare metainfos
int cmp;
// compare Date
cmp = strcmp( Date, game->Date );
if (cmp != 0)
return cmp;
// compare Event
cmp = strcmp( Event, game->Event );
if (cmp != 0)
return cmp;
// compare White
cmp = strcmp( White, game->White );
if (cmp != 0)
return cmp;
// compare Black
cmp = strcmp( Black, game->Black );
if (cmp != 0)
return cmp;
// compare ECO
cmp = strcmp( ECO, game->ECO );
if (cmp != 0)
return cmp;
// compare result
cmp = strcmp( Result, game->Result );
if (cmp != 0)
return cmp;
// compare Site
cmp = strcmp( Site, game->Site );
if (cmp != 0)
return cmp;
// compare WhiteElo
cmp = strcmp( WhiteElo, game->WhiteElo );
if (cmp != 0)
return cmp;
// compare BlackElo
cmp = strcmp( BlackElo, game->BlackElo );
if (cmp != 0)
return cmp;
cmp = ( metainfo.Size() - game->metainfo.Size() );
if (cmp != 0)
return cmp;
// both metainfo DBArrays are of the same size and because they are sorted,
// equal entrys must be on the same position
for (int i = 0; i < metainfo.Size(); i++)
{
MetainfoEntry m1 = GetMetainfoEntry( i );
MetainfoEntry m2 = game->GetMetainfoEntry( i );
// compare key
cmp = strcmp( m1.key, m2.key );
if (cmp != 0)
return cmp;
// compare value
cmp = strcmp( m1.value, m2.value );
if (cmp != 0)
return cmp;
}
// all metainfos are eqaul at this point
// compare move count
cmp = ( moves.Size() - game->moves.Size() );
if (cmp != 0)
return cmp;
for (int i = 0; i < moves.Size(); i++)
{
MoveData m1 = GetMoveData( i );
MoveData m2 = GetMoveData( i );
// compare start-position
cmp = ( m1.GetStartPos() - m2.GetStartPos() );
if (cmp != 0)
return cmp;
// compare end-position
cmp = ( m1.GetEndPos() - m2.GetEndPos() );
if (cmp != 0)
return cmp;
// compare new agent
cmp = ( m1.GetNewAgentID() - m2.GetNewAgentID() );
if (cmp != 0)
return cmp;
}
// both games are equal
return ( 0 );
}
bool Chessgame::Adjacent( const Attribute *arg ) const
{
return false;
}
size_t Chessgame::Sizeof() const
{
return sizeof( Chessgame );
}
size_t Chessgame::HashValue() const
{
size_t retval = 0;
MoveData movedata;
for(int i = 0; i < moves.Size(); i++){
moves.Get(i, movedata);
retval += movedata.IsCheck() +
movedata.GetStartFile() +
movedata.GetStartRow() +
movedata.GetEndFile() +
movedata.GetEndRow();
retval %= 0x8000000;
}
return retval;
}
void Chessgame::CopyFrom( const Attribute* arg )
{
const Chessgame* game2 = (Chessgame*) arg;
SetDefined(game2->IsDefined());
strcpy( White, game2->White );
strcpy( Black, game2->Black );
strcpy( WhiteElo, game2->WhiteElo );
strcpy( BlackElo, game2->BlackElo );
strcpy( Event, game2->Event );
strcpy( Site, game2->Site );
strcpy( Date, game2->Date );
strcpy( ECO, game2->ECO );
strcpy( Result, game2->Result );
metainfo.clean();
for ( int i = 0; i < game2->metainfo.Size(); i++ )
{
MetainfoEntry newentry;
MetainfoEntry entry = game2->GetMetainfoEntry( i + 9 );
// added 9 because 9 metainfo fields are stored seperate datafields
strcpy( newentry.key, entry.key );
strcpy( newentry.value, entry.value );
metainfo.Append( newentry );
}
moves.clean();
for ( int i = 0; i < game2->moves.Size(); i++ )
{
MoveData newmove;
MoveData move = game2->GetMoveData( i );
newmove.startpos = move.startpos;
newmove.endpos = move.endpos;
newmove.newag = move.newag;
newmove.data = move.data;
moves.Append( newmove );
}
positions.clean();
for ( int i = 0; i < game2->positions.Size(); i++ )
{
Position newpos;
Position oldpos = game2->GetPositionData(i);
newpos.CopyFrom( &oldpos );
positions.Append( newpos );
}
}
Chessgame* Chessgame::Clone() const
{
Chessgame * chessgame = new Chessgame( 0, 0 );
strcpy( chessgame->White, White );
strcpy( chessgame->Black, Black );
strcpy( chessgame->WhiteElo, WhiteElo );
strcpy( chessgame->BlackElo, BlackElo );
strcpy( chessgame->Event, Event );
strcpy( chessgame->Site, Site );
strcpy( chessgame->Date, Date );
strcpy( chessgame->ECO, ECO );
strcpy( chessgame->Result, Result );
for ( int i = 0; i < metainfo.Size(); i++ )
chessgame->metainfo.Append( this->GetMetainfoEntry( i + 9 ) );
// added 9 because 9 metainfo fields are stored seperate datafields
for ( int i = 0; i < moves.Size(); i++ )
chessgame->moves.Append( this->GetMoveData( i ) );
for ( int i = 0; i < positions.Size(); i++ )
chessgame->positions.Append( this->GetPositionData( i ) );
return chessgame;
}
void Chessgame::WriteTo( char *dest ) const
{
*dest++ = IsDefined() ? '1' : '0';
strncpy(dest, &White[0], 49);
strncpy(dest, &Black[0], 49);
strncpy(dest, &WhiteElo[0], 6);
strncpy(dest, &BlackElo[0], 6);
strncpy(dest, &Event[0], 49);
strncpy(dest, &Site[0], 49);
strncpy(dest, &Date[0], 11);
strncpy(dest, &ECO[0], 7);
strncpy(dest, &Result[0], 49);
for (int i = 0; i < metainfo.Size(); i++)
{
MetainfoEntry entry;
metainfo.Get( i , entry );
strncpy( dest, entry.key, 13 );
strncpy( dest, entry.value, 49 );
}
for (int i = 0; i < moves.Size(); i++)
{
MoveData move;
moves.Get( i , move );
*dest++ = move.GetStartFile();
*dest++ = move.GetStartRow();
*dest++ = move.GetEndFile();
*dest++ = move.GetEndRow();
const string pgn = this->GetPGN(i + 1);
strncpy(dest, pgn.c_str(), 10);
}
}
void Chessgame::ReadFrom( const char *src )
{
SetDefined((*src++ == '1') ? true : false);
strncpy(&White[0], src, 49);
strncpy(&Black[0], src, 49);
strncpy(&WhiteElo[0], src, 6);
strncpy(&BlackElo[0], src, 6);
strncpy(&Event[0], src, 49);
strncpy(&Site[0], src, 49);
strncpy(&Date[0], src, 11);
strncpy(&ECO[0], src, 7);
strncpy(&Result[0], src, 49);
metainfo.clean();
for (int i = 0; i < metainfo.Size(); i++)
{
MetainfoEntry * entry = new MetainfoEntry();
strncpy( entry->key, src, 13 );
strncpy( entry->value, src, 49 );
metainfo.Append( *entry );
}
positions.clean();
moves.clean();
for (int i = 0; i < moves.Size(); i++)
{
char startfile = *src++;
char startrow = *src++;
char endfile = *src++;
char endrow = *src++;
char pgn[10];
strncpy(&pgn[0], src, 10);
AddMove(startfile, startrow, endfile, endrow, string(pgn));
}
}
SmiSize Chessgame::SizeOfChars() const
{
return ( 234 + (metainfo.Size() * 62) * (moves.Size() * 14));
}
int Chessgame::NumOfFLOBs() const
{
return 3;
}
Flob * Chessgame::GetFLOB( const int i )
{
switch ( i )
{
case 1:
return & metainfo;
case 2:
return &moves;
default:
return &positions;
}
}
void Chessgame::AddMetainfoEntry( string key, string value )
{
int len;
// do not store metainfos with empty keys
if ( key.size() == 0 )
return ;
switch ( key[ 0 ] )
{
case 'W' :
if ( key == "White" )
{
len = value.copy( White, 48, 0 );
White[ len ] = '\0';
return ;
}
else if ( key == "WhiteElo" )
{
len = value.copy( WhiteElo, 5, 0 );
WhiteElo[ len ] = '\0';
return ;
}
break;
case 'B' :
if ( key == "Black" )
{
len = value.copy( Black, 48, 0 );
Black[ len ] = '\0';
return ;
}
else if ( key == "BlackElo" )
{
len = value.copy( BlackElo, 5, 0 );
BlackElo[ len ] = '\0';
return ;
}
break;
case 'E' :
if ( key == "Event" )
{
len = value.copy( Event, 48, 0 );
Event[ len ] = '\0';
return ;
}
else if ( key == "ECO" )
{
len = value.copy( ECO, 6, 0 );
ECO[ len ] = '\0';
return ;
}
break;
case 'R' :
if ( key == "Result" )
{
len = value.copy( Result, 48, 0 );
Result[ len ] = '\0';
return ;
}
break;
case 'S' :
if ( key == "Site" )
{
len = value.copy( Site, 48, 0 );
Site[ len ] = '\0';
return ;
}
break;
case 'D' :
if ( key == "Date" )
{
len = value.copy( Date, 10, 0 );
Date[ len ] = '\0';
return ;
}
break;
}
// key not found, thus tag pair will be stored in DBArrays metainfo
MetainfoEntry * entry = new MetainfoEntry();
// store key
len = key.copy( entry->key, 12, 0 );
entry->key[ len ] = '\0';
// store value
len = value.copy( entry->value, 48, 0 );
entry->value[ len ] = '\0';
// store metainfo entry
metainfo.Append( *entry );
}
void Chessgame::SortMetainfos()
{
metainfo.Sort( &MetainfoEntryCmp );
}
int Chessgame::AddMove( char startfile, char startrow,
char endfile, char endrow,
string pgn )
{
// cout << endl << "pgn Notation: " << pgn << endl;
Position * curpos = GetLastPosition( false );
MoveData * newmove = new MoveData();
newmove->SetStartFile( startfile );
newmove->SetStartRow( startrow );
newmove->SetEndFile( endfile );
newmove->SetEndRow( endrow );
newmove->SetCheck( pgn[ pgn.size() - 1 ] == '+' );
bool castling = false;
// calculate castling state
int startpos = newmove->GetStartPos();
int endpos = newmove->GetEndPos();
if ( ( startpos == 4 )
&& ( endpos == 6 )
&& ( curpos->gamefield[ startpos ] == WHITE_KING ) )
{
newmove->SetCastelling( KINGSIDE_CASTLING );
castling = true;
}
else if ( ( startpos == 4 )
&& ( endpos == 2 )
&& ( curpos->gamefield[ startpos ] == WHITE_KING ) )
{
newmove->SetCastelling( QUEENSIDE_CASTLING );
castling = true;
}
else if ( ( startpos == 60 )
&& ( endpos == 62 )
&& ( curpos->gamefield[ startpos ] == BLACK_KING ) )
{
newmove->SetCastelling( KINGSIDE_CASTLING );
castling = true;
}
else if ( ( startpos == 60 )
&& ( endpos == 58 )
&& ( curpos->gamefield[ startpos ] == BLACK_KING ) )
{
newmove->SetCastelling( QUEENSIDE_CASTLING );
castling = true;
}
string newAgent = DecodeAgent( curpos->gamefield[ startpos ] );
newmove->SetNewAgent( newAgent );
if (castling == false)
{
// White en passant capture
if ( startpos >= 32 && startpos <= 39 &&
( endpos == startpos + 7 || endpos == startpos + 9 ) &&
curpos->gamefield[ startpos ] == WHITE_PAWN &&
curpos->gamefield [ endpos ] == NONE &&
curpos->gamefield [ endpos - 8 ] == BLACK_PAWN )
{
newmove->SetEnPassant( true );
}
// Black en passant capture
else if ( startpos >= 24 && startpos <= 31 &&
( endpos == startpos - 7 || endpos == startpos - 9 ) &&
curpos->gamefield[ startpos ] == BLACK_PAWN &&
curpos->gamefield [ endpos ] == NONE &&
curpos->gamefield [ endpos + 8 ] == WHITE_PAWN )
{
newmove->SetEnPassant( true );
}
else
{
newmove->SetEnPassant( false );
}
string agent = DecodeAgentShort( curpos->gamefield[ startpos ] );
agent[ 0 ] = toupper( agent[ 0 ] );
if ( pgn[ 0 ] == agent[ 0 ] )
newmove->SetOutputAgent( true );
else
newmove->SetOutputAgent( false );
ostringstream endposstr;
endposstr << endfile << ( ( int ) endrow );
size_t pos = pgn.find( endposstr.str() );
bool ok = (pos != string::npos);
if (!ok) {
cout << "Could not find field <" << endposstr.str() << ">"
<< " in move <" << pgn << ">" << endl;
assert(false);
}
/*
ok = (pos > 0);
if (!ok) {
cout << "Found <" << endposstr.str() << ">"
<< "at pos=0 in move <" << pgn << ">" << endl;
assert(false);
}
*/
// check if the move captures an agent and remove the x symbol
if (pos > 0) {
pos--;
if ( pgn[ pos ] == 'x' )
pos--;
}
// check, if start row is contained in pgn notation
if ( pos >= 0 )
{
if ( ( pgn[ pos ] >= '1' ) && ( pgn[ pos ] <= '8' ) )
{
newmove->SetOutputRow( true );
pos--;
}
else
{
newmove->SetOutputRow( false );
}
}
// check, if start file is contained in pgn notation
if ( pos >= 0 )
{
if ( ( pgn[ pos ] >= 'a' ) && ( pgn[ pos ] <= 'h' ) )
{
newmove->SetOutputFile( true );
pos--;
}
else
{
newmove->SetOutputFile( false );
}
}
string newAgent;
pos = pgn.find( "=" );
if ( pos != string::npos )
{
newAgent += ( endrow == 8 ) ? pgn[ pos + 1 ] : tolower( pgn[ pos + 1 ] );
}
else
newAgent = DecodeAgent( curpos->gamefield[ startpos ] );
//cout << pgn << "," << pos << "," << newAgent << "\n";
newmove->SetNewAgent( newAgent );
} // end of !castling
// save move
moves.Append( *newmove );
// save current position after POS_STORE_INTERVALL moves
if ( ( moves.Size() > 0 ) && ( ( moves.Size() % POS_STORE_INTERVALL ) == 0 ) )
positions.Append( *curpos );
return true;
}
void Chessgame::GetMove( Move& result, int moveNumber )
{
if ( moveNumber < 1 )
moveNumber = 1;
else if ( moveNumber > moves.Size() + 1 )
moveNumber = moves.Size() + 1;
MoveData move;
moves.Get( moveNumber - 1, move );
Position* curpos = new Position();
GetPosition( curpos, moveNumber - 1, true, false );
// get captured id
char captured;
if ( !move.EnPassant() )
{
captured = curpos->gamefield [ (int)move.GetEndPos() ];
}
else
{
char agentID = curpos->gamefield [ (int)move.GetStartPos() ];
if ( agentID <= WHITE_KING )
captured = BLACK_PAWN;
else
captured = WHITE_PAWN;
}
// write data to result
result.moveNumber = moveNumber;
result.capturedID = ( captured );
result.agentID = curpos->gamefield [ (int)move.GetStartPos() ];
result.startFile = ( move.GetStartFile() );
result.startRow = ( move.GetStartRow() );
result.endFile = ( move.GetEndFile() );
result.endRow = ( move.GetEndRow() );
result.check = ( move.IsCheck() );
result.SetDefined( true );
// test of Move::WriteTo() and Move::ReadTo()
/*
char moveStr[result->SizeOfChars()];
result->WriteTo(&moveStr[0]);
result->moveNumber = 0;
result->agentID = 0;
result->capturedID = 0;
result->startFile = 'a';
result->startRow = 0;
result->endFile = 'a';
result->endRow = 0;
result->check = false;
result->defined = ( false );
result->ReadFrom(&moveStr[0]);
*/
}
Move Chessgame::GetMove( int moveNumber )
{
Move result;
GetMove( result, moveNumber );
return result;
}
void Chessgame::GetPosition( Position* result, int moveNumber,
bool loadGamefield, bool getMaterial ) const
{
// assertion: ( ( moveNumber >= 0 ) && ( moveNumber <= moves.Size() ) )
result->moveNumber = moveNumber;
int curmove;
// load last stored gamefield bevore moveNumber or initialize a new one
int posnum = ( int ) ( moveNumber / POS_STORE_INTERVALL );
if ( ( posnum == 0 ) || !loadGamefield )
{
result->StartPos();
curmove = 0;
}
else
{
Position pos = GetPositionData( posnum - 1 );
for ( int i = 0; i < 64; i++ )
result->gamefield[ i ] = pos.gamefield[ i ];
curmove = pos.moveNumber;
if ( getMaterial )
for ( int i = 0; i < 12; i++ )
result->material[ i ] = pos.material[ i ];
}
// calculate moves
while ( curmove < moveNumber )
{
MoveData currentMove = GetMoveData( curmove++ );
result->MakeMove(
currentMove.GetStartPos(),
currentMove.GetEndPos(),
currentMove.GetNewAgentID(),
currentMove.GetCastling() );
}
result->SetDefined(IsDefined());
// test of Position::WriteTo() and Position::ReadTo()
/*
char posStr[result->SizeOfChars()];
result->WriteTo(&posStr[0]);
for ( int i = 0; i < 64; i++ )
{
result->gamefield[ i ] = 0;
}
for ( int i = 0; i < 12; i++ )
{
result->material[ i ] = 0;
}
result->defined = ( false );
result->ReadFrom(&posStr[0]);
*/
}
Position* Chessgame::GetPosition( int moveNumber )
{
Position * result = new Position();
GetPosition( result, moveNumber, false );
return result;
}
Position* Chessgame::GetLastPosition( bool loadGamefield )
{
Position * result = new Position();
GetPosition( result, moves.Size(), loadGamefield );
return result;
}
const string Chessgame::GetPGN( int moveNumber ) const
{
if ( moveNumber < 1 )
moveNumber = 1;
else if ( moveNumber > moves.Size() + 1 )
moveNumber = moves.Size() + 1;
string result;
Position* curpos = new Position();
GetPosition( curpos, moveNumber - 1 );
MoveData move;
moves.Get( moveNumber - 1, move );
int startpos = move.GetStartPos();
int endpos = move.GetEndPos();
if ( move.GetCastling() )
{
if ( move.GetCastling() == QUEENSIDE_CASTLING )
result = "O-O-O";
else
result = "O-O";
}
else
{
if ( move.OutputAgent() )
{
string agstr = DecodeAgentShort( curpos->gamefield[ startpos ] );
agstr[ 0 ] = toupper( agstr[ 0 ] );
result += agstr;
}
if ( move.OutputFile() )
{
result += move.GetStartFile();
}
if ( move.OutputRow() )
{
ostringstream row;
row << ( int ) ( move.GetStartRow() );
result += row.str();
}
if ( ( curpos->gamefield[ endpos ] & 0x07 ) != NONE )
{
result += 'x';
}
// append endfile and endrow
result += move.GetEndFile();
ostringstream row;
row << ( int ) ( move.GetEndRow() );
result += row.str();
if ( DecodeAgentShort( curpos->gamefield[ startpos ] ) !=
move.GetNewAgent() )
{
result += '=';
string agstr = move.GetNewAgent();
agstr[ 0 ] = toupper( agstr[ 0 ] );
result += agstr;
}
}
if ( move.IsCheck() )
result += '+';
return result;
}
void Chessgame::GetMetainfoValue( string key, STRING_T* result )
{
if ( key.size() == 0 )
{
string err = "Missing key!";
strcpy ( *result, err.c_str() );
}
if ( isupper( key[ 0 ] ) )
{ // search for pgn-notation key values
switch ( key[ 0 ] )
{
case 'W' :
if ( key == "White" )
{
strcpy ( *result, White );
return ;
}
else if ( key == "WhiteElo" )
{
strcpy ( *result, WhiteElo );
return ;
}
break;
case 'B' :
if ( key == "Black" )
{
strcpy ( *result, Black );
return ;
}
else if ( key == "BlackElo" )
{
strcpy ( *result, BlackElo );
return ;
}
break;
case 'E' :
if ( key == "Event" )
{
strcpy ( *result, Event );
return ;
}
else if ( key == "ECO" )
{
strcpy ( *result, ECO );
return ;
}
break;
case 'S' :
if ( key == "Site" )
{
strcpy ( *result, Site );
return ;
}
break;
case 'D' :
if ( key == "Date" )
{
strcpy ( *result, Date );
return ;
}
break;
case 'R' :
if ( key == "Result" )
{
strcpy ( *result, Result );
return ;
}
break;
}
}
else
{ // search for chessgameAlgebra-notation key values
switch ( key[ 0 ] )
{
case 'n' :
if ( key == "name_w" )
{
strcpy ( *result, White );
return ;
}
else if ( key == "name_b" )
{
strcpy ( *result, Black );
return ;
}
break;
case 'd' :
if ( key == "date" )
{
strcpy ( *result, Date );
return ;
}
break;
case 's' :
if ( key == "site" )
{
strcpy ( *result, Site );
return ;
}
break;
case 'e' :
if ( key == "event" )
{
strcpy ( *result, Event );
return ;
}
else if ( key == "eco_code" )
{
strcpy ( *result, ECO );
return ;
}
break;
case 'r' :
if ( key == "result" )
{
strcpy ( *result, Result );
return ;
}
else if ( key == "rating_w" )
{
strcpy ( *result, WhiteElo );
return ;
}
else if ( key == "rating_b" )
{
strcpy ( *result, BlackElo );
return ;
}
break;
case 'm' :
if ( key == "moves" )
{
sprintf( *result, "%d", moves.Size() );
return ;
}
break;
}
}
// key not found, thus tag pair will be searched in DBArrays metainfo
int len, pos;
// create new MetainfoEntry object as search key
MetainfoEntry * mi_key = new MetainfoEntry();
len = key.copy( mi_key->key, 12, 0 );
mi_key->key[ len ] = '\0';
// search mi_key and copy value to result STRING, if found
if ( metainfo.Find( mi_key, &MetainfoEntryCmp, pos ) )
{
MetainfoEntry entry;
metainfo.Get( pos , entry );
strcpy( *result, ( entry.value ) );
}
else
{
string err = "key " + key + " not found";
strcpy ( *result, err.c_str() );
}
}
MetainfoEntry Chessgame::GetMetainfoEntry( int i ) const
{
int len;
string key, value;
if ( i > GetMetainfoCount() )
{
MetainfoEntry entry;
key = "undef";
value = "undef";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
len = value.copy( entry.value, 48, 0 );
entry.value[ len ] = '\0';
return entry;
}
else if ( i < 9 )
{
MetainfoEntry entry;
switch ( i )
{
case 0:
key = "White";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, White );
break;
case 1:
key = "Black";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, Black );
break;
case 2:
key = "WhiteElo";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, WhiteElo );
break;
case 3:
key = "BlackElo";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, BlackElo );
break;
case 4:
key = "Event";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, Event );
break;
case 5:
key = "Site";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, Site );
break;
case 6:
key = "Date";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, Date );
break;
case 7:
key = "ECO";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, ECO );
break;
case 8:
key = "Result";
len = key.copy( entry.key, 12, 0 );
entry.key[ len ] = '\0';
strcpy ( entry.value, Result );
break;
}
return entry;
}
else
{
MetainfoEntry entry;
metainfo.Get( i - 9, entry );
return entry;
}
}
/*
3.5 Class MovingChessPiece
*/
MovingChessPiece::~MovingChessPiece()
{
//delete moveDuration;
//(&mpoint)->Destroy(); // calls Destroy member function of class Mapping
}
/*
this is the standard constructor used to create each piece's startposition
*/
MovingChessPiece::MovingChessPiece( string k, string file,
int row , const double CreationTime,
const DateTime* movedur ) :
kind( k ),
movedInLastInterval( false ),
startrow( row ),
moveDuration( durationtype ),
startInstant( instanttype ),
endInstant( instanttype ),
iv( startInstant, endInstant, true, true ),
mpoint( 10 ),
upoint( iv, 0, 0, 0, 0 )
{
isWhite = ( kind[ 0 ] == toupper( kind[ 0 ] ) );
startfile = tolower( file[ 0 ] );
actfile = startfile;
actrow = row;
mpoint.Clear();
mpoint.StartBulkLoad();
moveDuration.Equalize(movedur);
startInstant.ReadFrom( CreationTime );
endInstant = startInstant;
upoint.timeInterval.start = startInstant;
upoint.timeInterval.end = endInstant;
x0 = ( double ) ( file[ 0 ] - 'a' + 1 );
y0 = ( double ) row;
if ( (isWhite && (startrow==8)) ||
(!isWhite && (startrow==1)) ) // this was a pawn's promotion
{
x0 += -0.25;
y0 += -0.25;
}
upoint.p0.Set( x0, y0 );
x1 = x0;
y1 = y0;
upoint.p1.Set( x1, y1 );
mpoint.Add( upoint );
upoint.timeInterval.lc = false;
}
/*
extendInterval extends the interval of the newest upoint by the as exttime specified duration.
If the piece wasn't moved in the last half move, the upoint's interval is extended,
otherwise a new upoint is created
*/
void MovingChessPiece::extendInterval(const DateTime* exttime)
{
upoint.timeInterval.start = upoint.timeInterval.end;
// new interval end is specified time later
upoint.timeInterval.end.Add( exttime );
if ( movedInLastInterval ) // if piece was moved in last interval
{
upoint.p0.Set( upoint.p1.GetX(), upoint.p1.GetY() ); // create new UPoint
mpoint.Add( upoint );
}
else mpoint.MergeAdd( upoint ); // otherwise try to extend last UPoint
movedInLastInterval = false;
}
/*
adjustTime extends the interval of the newest upoint to the as parameter specified instant.
If the piece wasn't moved in the last half move, the upoint's interval is extended,
otherwise a new upoint is created
*/
void MovingChessPiece::adjustTime(const Instant newEndInstant)
{
if (upoint.timeInterval.end==newEndInstant) return;
// former interval end is new start
upoint.timeInterval.start = upoint.timeInterval.end;
// new interval end is specified time
upoint.timeInterval.end = newEndInstant;
if ( movedInLastInterval ) // if piece was moved in last interval
{
//cout << "adjust time " << upoint.timeInterval.start
// << " ~ " << upoint.timeInterval.end << endl;
upoint.p0.Set( upoint.p1.GetX(), upoint.p1.GetY() ); // create new UPoint
mpoint.Add( upoint );
}
else mpoint.MergeAdd( upoint ); // otherwise try to extend last UPoint
movedInLastInterval = false;
}
/*
appendMove is the normal function that moves a piece after the normal delay time
*/
void MovingChessPiece::appendMove ( string newfile,
int newrow, bool TargetOffset )
{
// last interval end is new interval start
upoint.timeInterval.start = upoint.timeInterval.end;
upoint.timeInterval.end.Add( &moveDuration );
upoint.p0.Set( upoint.p1.GetX(), upoint.p1.GetY() );
upoint.p1.Set( (double) ( tolower( newfile[0] ) - 'a' + 1 ),
( double ) newrow );
if (TargetOffset) upoint.p1.Set( 0.25+upoint.p1.GetX(),
0.25+upoint.p1.GetY() );
//cout << kind << actfile << actrow << newfile << newrow;
mpoint.Add( upoint );
actfile = tolower( newfile[ 0 ] );
actrow = newrow;
movedInLastInterval = true;
}
/*
applyCastelling moves the rook besides the king after this has moved more than one field away
*/
void MovingChessPiece::applyCastelling ()
{
if ( startfile == "a" ) appendMove( "d", actrow , false);
else appendMove( "f", actrow , false);
}
/*
removePiece removes a captured piece after waiting in place for
the normale delay time
and the duration of the capturing piece's move
*/
void MovingChessPiece::removePiece ()
{
// last interval end is new interval start
upoint.timeInterval.start = upoint.timeInterval.end;
upoint.timeInterval.end.Add( &moveDuration );
upoint.p0.Set( upoint.p1.GetX(), upoint.p1.GetY() );
if ( isWhite ) y1 = -2.0;
else y1 = 2.0;
upoint.p1.Set( ( double ) ( startfile[ 0 ] - 'a' + 1 ),
( double ) startrow + y1 );
mpoint.Add( upoint );
actfile = "";
actrow = 0;
movedInLastInterval = true;
//cout << " x ";
}
/*
centerPiece positions the piece in the center of the field, i.e. to the
nearest integer coordinates; use this function e.g. after the removal of a captured piece
*/
void MovingChessPiece::centerPiece ()
{
upoint.timeInterval.start = upoint.timeInterval.end;
upoint.timeInterval.end.Add( &moveDuration );
upoint.p0.Set( upoint.p1.GetX(), upoint.p1.GetY() );
upoint.p1.Set( floor(upoint.p0.GetX() + 0.5),
floor(upoint.p1.GetY() + 0.5) );
mpoint.Add( upoint );
movedInLastInterval = true;
}
const string MovingChessPiece::getActFile()
{ return actfile;}
const int MovingChessPiece::getActRow()
{ return actrow;}
const string* MovingChessPiece::getKind()
{ return & kind;}
bool* MovingChessPiece::trueIsWhite()
{ return & isWhite;}
MPoint* MovingChessPiece::getMPoint()
{ return & mpoint;}
const double MovingChessPiece::getCurrentTime()
{ return upoint.timeInterval.end.ToDouble();}
void MovingChessPiece::closeMPoint()
{
if ( kind == AGENT_NAMES[ UNDEF ] ) return ;
/*
bool result = true;
const UPoint *lastunit, *unit;
int k = 0, j = 0;
for (k=0;k<i;k++)
{
mpoint.Get(k, unit);
if (unit->IsValid()) coutNewInterval(unit);
else cout << "unit " << k << " in mpoint is invalid";
}
if( i == 1 )
{
mpoint.Get( 0, unit );
result = ( unit->IsValid() );
}
else for( k = 1; k < i; k++ )
{
mpoint.Get( k-1, lastunit );
if( !lastunit->IsValid() )
{
result = false;
j=-1;
break;
}
mpoint.Get( k, unit );
if( !unit->IsValid() )
{
result = false;
break;
}
if( (!lastunit->Disjoint( *unit )) &&
(!lastunit->TU_Adjacent( *unit )) )
{
result = false;
j=1;
break;
}
}
*/
mpoint.EndBulkLoad( true );
}
void MovingChessPiece::coutNewInterval( UPoint* up )
{
cout << "Interval: "
<< up->timeInterval.start.GetHour() << ":"
<< up->timeInterval.start.GetMinute() << ":"
<< up->timeInterval.start.GetSecond() << ":"
<< up->timeInterval.start.GetMillisecond() << " - "
<< up->timeInterval.end.GetHour() << ":"
<< up->timeInterval.end.GetMinute() << ":"
<< up->timeInterval.end.GetSecond() << ":"
<< up->timeInterval.end.GetMillisecond() << endl;
}
void MovingChessPiece::coutNewInterval( const UPoint* up )
{
cout << "Interval: "
<< up->timeInterval.start.GetHour() << ":"
<< up->timeInterval.start.GetMinute() << ":"
<< up->timeInterval.start.GetSecond() << ":"
<< up->timeInterval.start.GetMillisecond() << " " << up->p0 << " - "
<< up->timeInterval.end.GetHour() << ":"
<< up->timeInterval.end.GetMinute() << ":"
<< up->timeInterval.end.GetSecond() << ":"
<< up->timeInterval.end.GetMillisecond() << " " << up->p1 << " " << endl;
}
/*
3.6 Class MovingChessPieces
*/
MovingChessPieces::MovingChessPieces() :
startOfGame(instanttype),
iv(startOfGame, startOfGame, true, true),
upref(iv, 0, 0, 0, 0)
{
waitBeforeMoveDuration = new DateTime ( 0, 2000, durationtype );
moveDuration = new DateTime ( 0, 1000, durationtype );
totalMoveDuration = new DateTime ( 0, 5000, durationtype );
waitAfterMoveDuration = new DateTime ( 0, 1000, durationtype );
startOfGame.Set( 2007, 1, 1, 9, 0, 0, 0 ); // 1.1.2007 9 Uhr
upref.timeInterval.start = startOfGame;
upref.timeInterval.end = startOfGame;
mcp[ 00 ] = new MovingChessPiece( "King", "e", 1 ,
startOfGame.ToDouble() ,
moveDuration );
// King must be first for castelling
mcp[ 01 ] = new MovingChessPiece( "Rook", "a", 1 ,
startOfGame.ToDouble() ,
moveDuration );
// Rooks must be next for castelling
mcp[ 02 ] = new MovingChessPiece( "Rook", "h", 1 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 03 ] = new MovingChessPiece( "Pawn", "a", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 04 ] = new MovingChessPiece( "Pawn", "b", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 05 ] = new MovingChessPiece( "Pawn", "c", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 06 ] = new MovingChessPiece( "Pawn", "d", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 07 ] = new MovingChessPiece( "Pawn", "e", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 8 ] = new MovingChessPiece( "Pawn", "f", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 9 ] = new MovingChessPiece( "Pawn", "g", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 10 ] = new MovingChessPiece( "Pawn", "h", 2 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 11 ] = new MovingChessPiece( "Knight", "b", 1 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 12 ] = new MovingChessPiece( "Knight", "g", 1 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 13 ] = new MovingChessPiece( "Bishop", "c", 1 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 14 ] = new MovingChessPiece( "Bishop", "f", 1 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 15 ] = new MovingChessPiece( "Queen", "d", 1 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 16 ] = new MovingChessPiece( "king", "e", 8 ,
startOfGame.ToDouble() ,
moveDuration );
// king must be first for castling
mcp[ 17 ] = new MovingChessPiece( "rook", "a", 8 ,
startOfGame.ToDouble() ,
moveDuration );
// rooks must be next for castling
mcp[ 18 ] = new MovingChessPiece( "rook", "h", 8 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 19 ] = new MovingChessPiece( "pawn", "a", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 20 ] = new MovingChessPiece( "pawn", "b", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 21 ] = new MovingChessPiece( "pawn", "c", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 22 ] = new MovingChessPiece( "pawn", "d", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 23 ] = new MovingChessPiece( "pawn", "e", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 24 ] = new MovingChessPiece( "pawn", "f", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 25 ] = new MovingChessPiece( "pawn", "g", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 26 ] = new MovingChessPiece( "pawn", "h", 7 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 27 ] = new MovingChessPiece( "knight", "b", 8 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 28 ] = new MovingChessPiece( "knight", "g", 8 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 29 ] = new MovingChessPiece( "bishop", "c", 8 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 30 ] = new MovingChessPiece( "bishop", "f", 8 ,
startOfGame.ToDouble() ,
moveDuration );
mcp[ 31 ] = new MovingChessPiece( "queen", "d", 8 ,
startOfGame.ToDouble() ,
moveDuration );
for ( i = 32;i < 48;i++ ) mcp[ i ] = new MovingChessPiece();
MPointWriteNextCount = 0;
}
MovingChessPieces::~MovingChessPieces()
{
//for ( i = 0;i < 48;i++ ) delete mcp[ i ];
}
void MovingChessPieces::realizeMove( Move* mv, const MoveData* mvdata )
{
//cout << "MovingChessPieces::realizeMove entered" << endl;
//cout << mv->GetMoveNumber() << " - " << mv->GetAgent()<< ": "
// << mv->GetStartFile() << mv->GetStartRow() << "-"
// << mv->GetEndFile() << mv->GetEndRow() << endl;
upref.timeInterval.end.Add(totalMoveDuration);
for ( i = 0;i < 48;i++ )
{
if ( *( mcp[i]->getKind() ) == AGENT_NAMES[ UNDEF ] )
continue; //this mcp wasn't used yet
if ( mcp[i]->getActRow() == mv->GetStartRow() &&
(mcp[i]->getActFile())[0] == tolower((mv->GetStartFile())[0]))
{ // this mcp represents the piece being moved,
// detect if another piece was captured
for ( j = 0;j < 48;j++ )
{
if ( *( mcp[j]->getKind() ) == AGENT_NAMES[ UNDEF ] )
continue; //this mcp wasn't used yet
if ( mcp[j]->getActRow() == mv->GetEndRow() &&
(mcp[j]->getActFile())[0] == tolower((mv->GetEndFile())[0]) )
{
mcp[j]->extendInterval(waitBeforeMoveDuration);
mcp[j]->extendInterval(moveDuration);
mcp[j]->removePiece();
// this mcp represents the piece being captured
break;
}
}
if (j<48)
TargetOffset = true; // another piece was captured, step besides of it
else
TargetOffset = false;
// next lines recognize a pawn's
// promotion when it reaches the other baseline
if ( ( *( mcp[i]->getKind() ) == "Pawn" && mv->GetEndRow() == 8 )
|| ( *( mcp[i]->getKind() ) == "pawn" && mv->GetEndRow() == 1 ) )
{
// remove the pawn
mcp[i]->extendInterval(waitBeforeMoveDuration);
mcp[i]->appendMove( mv->GetEndFile(),
mv->GetEndRow(), TargetOffset );
mcp[i]->removePiece();
// create a new moving piece
// find unused mcp
for ( j = 32;j < 48;j++ ) {
if ( *(mcp[j]->getKind())==AGENT_NAMES[UNDEF] ) break; }
cout << "unused mcp: " << j
<< ", ptr " << (void*) mcp[j] << endl;
delete mcp[j];
mcp[j] = new MovingChessPiece(
AGENT_NAMES[(int)mvdata->GetNewAgentID()],
mv->GetEndFile(), mv->GetEndRow(),
mcp[i]->getCurrentTime() , moveDuration );
mcp[j]->centerPiece(); // and put the officer in the fields's center
}
else
{
// move wasn't pawn's promotion, execute move
mcp[i]->extendInterval(waitBeforeMoveDuration);
mcp[i]->appendMove( mv->GetEndFile() , mv->GetEndRow() , TargetOffset );
if (TargetOffset)
mcp[i]->centerPiece(); // if another piece was captured
// next lines recognize castelling
//if the king was moved over more than one file
if ( ( *( mcp[i]->getKind() ) == "King" ||
*( mcp[i] ->getKind() ) == "king" )
&& ( abs( (mv->GetEndFile())[0] - (mv->GetStartFile())[0] ) > 1 )
)
{ // castelling! look which rook has to move
if ( ( mv->GetEndFile() ) [ 0 ] == 'g' )
j = 2; // white kingside rook
else
j = 1; // white queenside rook
if ( mv->GetStartRow() == 8 )
j += 16; // black rooks
mcp[j]->extendInterval(waitBeforeMoveDuration);
mcp[j]->extendInterval(moveDuration);
mcp[j]->applyCastelling();
}
}
}
}
for ( int i = 0;i < 48;i++ )
{
if (! (*(mcp[i]->getKind()) == AGENT_NAMES[UNDEF]))
mcp[i]->adjustTime(upref.timeInterval.end);
// for mcps representing pieces not moved
}
}
const bool MovingChessPieces::isValid( int i )
{ return !( *( mcp[ i ] ->getKind() ) == AGENT_NAMES[ UNDEF ] ); }
MovingChessPiece* MovingChessPieces::getMovingChessPiece( int i )
{ return mcp[ i ]; }
void MovingChessPieces::incMPointWriteNextCount()
{MPointWriteNextCount++;}
int MovingChessPieces::getMPointWriteNextCount()
{ return MPointWriteNextCount;}
void MovingChessPieces::setTupleTypeRemember( TupleType* tt )
{TupleTypeRemember = tt;}
TupleType* MovingChessPieces::getTupleTypeRemember() {
return TupleTypeRemember;
}
void MovingChessPieces::closeMPoints()
{
//cout << "MovingChessPieces::closeMPoints entered" << endl;
for ( i = 0;i < 48;i++ ) mcp[ i ] ->closeMPoint(); }
} // namespace ChessAlgebra
Reference in New Issue View Git Blame Copy Permalink