/**
@brief 한수 뒤로 물리기
@date 2014-03-19
*/
void CTable::BackPiece()
{
if (m_state != GAME)
m_state = GAME;
if (!m_table.blacks.empty())
{
SetPiece(m_table.blacks.back(), EMPTY);
m_table.blacks.pop_back();
}
if (!m_table.whites.empty())
{
SetPiece(m_table.whites.back(), EMPTY);
m_table.whites.pop_back();
}
}
/**
@brief 다음 돌은 인공지능이 알아서 놓는다. 기본적으로 white 로 한다.
흰색돌이 이기면 0
흑돌이 이기면 1을 리턴한다.
종료상태가 아니라면 -1을 리턴한다.
@date 2014-03-16
*/
int CTable::NextAIStep(const PIECE pieceType) //pieceType=WHITE
{
if (ai::IsGameComplete(m_table, OppositePiece(pieceType)))
{
m_state = (pieceType==WHITE)? WIN_BLACK : WIN_WHITE;
return -1;
}
bool err;
CHECK_TIME_START;
{
Pos pos;
m_state = ai::SearchBestLocation(m_table, pieceType, pos);
if (GAME == m_state)
SetPiece(pos, pieceType);
}
CHECK_TIME_END(m_procTime, err);
if (ai::IsGameComplete(m_table, pieceType))
{
m_state = (pieceType==WHITE)? WIN_WHITE : WIN_BLACK;
}
return -1;
}
void Test_CPUTurn (game_state_t * game)
{
//put a piece in position
position_t pos;
char identity;
pos = Position ('d', 4);
identity = WHITE_M;
SetPiece(pos, identity, game);
piece_t piece1 ;
piece1.identity = identity;
piece1.position = pos;
pos = Position ('c', 5);
identity = BLACK_M;
SetPiece(pos, identity, game);
piece_t piece2 ;
piece2.identity = identity;
piece2.position = pos;
pos = Position ('d', 2);
identity = WHITE_K;
SetPiece(pos, identity, game);
piece_t piece3 ;
piece3.identity = identity;
piece3.position = pos;
//b,2
pos = Position ('b', 2);
identity = WHITE_K;
SetPiece(pos, identity, game);
PrintBoard(game);
CPUTurn(game);
}
//---------------------------------------------------------------------------
void __fastcall TFormSummaryRep::SetColumns()
{
int Year_B = StrToInt(DT_Beg.FormatString("yyyy"));
int Mont_B = StrToInt(DT_Beg.FormatString("m"));
int Year_E = StrToInt(DT_End.FormatString("yyyy"));
int Mont_E = StrToInt(DT_End.FormatString("m"));
int N_Columns = (Year_E - Year_B)*2014 + Mont_E - Mont_B;
TDBGridColumnsEh* Columns = DBGridEh1->Columns;
int N_Mon = Mont_B + 1;
int Year_C = Year_B;
for (int i = 1; i < 13; ++i) {
if (N_Mon == 14) {
++Year_C;
N_Mon = 2;
}
AnsiString S = MonList[N_Mon];
if (S.Length() <= 6) {
S = " " + S + " ";
}
Columns->Items[i]->Title->Caption = S + " " + IntToStr(Year_C);
Columns->Items[i]->Visible = (i < N_Columns + 2);
++N_Mon;
}
Columns->Items[13]->Visible = N_Columns > 0;
Columns = DBGridEh2->Columns;
N_Mon = Mont_B + 1;
Year_C = Year_B;
for (int i = 1; i < 13; ++i) {
if (N_Mon == 14) {
++Year_C;
N_Mon = 2;
}
for (int j = 0; j < 3; j++) {
int N_Col = i*3 + j - 1;
AnsiString S = Columns->Items[N_Col]->Title->Caption;
Columns->Items[N_Col]->Title->Caption = SetPiece(S,MonList[N_Mon] + " " + IntToStr(Year_C),"|",1);
Columns->Items[N_Col]->Visible = (i < N_Columns + 2);
}
++N_Mon;
}
Columns->Items[38]->Visible = N_Columns > 0;
Columns->Items[39]->Visible = N_Columns > 0;
Columns->Items[40]->Visible = N_Columns > 0;
}
std::pair<Vec2,int> MiniMax(Board& board, unsigned int depth, bool myturn,bool pass) {
Piece nowpiece = myturn ? (mypiece == Piece::black ? Piece::black : Piece::white) : (mypiece == Piece::black ? Piece::white : Piece::black);
if (depth == 0)
if (myturn)
return std::make_pair(BestN(board, nowpiece), EvaluationMap1[BestN(board, nowpiece).x][BestN(board, nowpiece).y]);
else
return std::make_pair(BestN(board, nowpiece, -1), EvaluationMap1[BestN(board, nowpiece, -1).x][BestN(board, nowpiece, -1).y]);
if (!board.IsAllSetAble(nowpiece)){
if (pass){
if (myturn)
return std::make_pair(BestN(board, nowpiece), EvaluationMap1[BestN(board, nowpiece).x][BestN(board, nowpiece).y]);
else
return std::make_pair(BestN(board, nowpiece, -1), EvaluationMap1[BestN(board, nowpiece, -1).x][BestN(board, nowpiece, -1).y]);
}
else{
return MiniMax(board, depth - 1, !myturn, true);
}
}
auto where_=board.WhereSetAble(nowpiece);
auto SetAble = std::vector<std::pair<Vec2,int>>(where_.size());
for (int i = 0; i < where_.size();i++){
SetAble[i].first = where_[i];
auto board_ = board;
board_.SetPiece(SetAble[i].first, nowpiece);
SetAble[i].second=MiniMax(board_, depth - 1, !myturn,false).second;
}
std::sort(SetAble.begin(), SetAble.end(), [](std::pair<Vec2, int> p1, std::pair<Vec2, int> p2){
return p1.second < p2.second;
});
if (myturn)
return SetAble[SetAble.size() - 1];
else
return SetAble[0];
}
void ChessBoard::SetPiece(const QPoint & pos, const PiecesManager::PiecesTypes piece)
{
SetPiece(pos.y(), pos.x(), piece);
}
bool SetFen(ChessPosition * board, string fen)
{
InitializeBoard(board);
ASSERT(fen.length() > 10);
vector<string> tokens;
Tokenize(fen, tokens, " ");
int index = 0;
int col = 0;
int row = 0;
do {
switch (tokens[0][index]) {
case 'K': SetPiece(board, WK, MakeSquare(row, col)); col++; break;
case 'Q': SetPiece(board, WQ, MakeSquare(row, col)); col++; break;
case 'R': SetPiece(board, WR, MakeSquare(row, col)); col++; break;
case 'B': SetPiece(board, WB, MakeSquare(row, col)); col++; break;
case 'N': SetPiece(board, WN, MakeSquare(row, col)); col++; break;
case 'P': SetPiece(board, WP, MakeSquare(row, col)); col++; break;
case 'k': SetPiece(board, BK, MakeSquare(row, col)); col++; break;
case 'q': SetPiece(board, BQ, MakeSquare(row, col)); col++; break;
case 'r': SetPiece(board, BR, MakeSquare(row, col)); col++; break;
case 'b': SetPiece(board, BB, MakeSquare(row, col)); col++; break;
case 'n': SetPiece(board, BN, MakeSquare(row, col)); col++; break;
case 'p': SetPiece(board, BP, MakeSquare(row, col)); col++; break;
case '/': row++; col = 0; break;
case '1': col += 1; break;
case '2': col += 2; break;
case '3': col += 3; break;
case '4': col += 4; break;
case '5': col += 5; break;
case '6': col += 6; break;
case '7': col += 7; break;
case '8': col += 8; break;
};
index++;
} while (index < tokens[0].length());
if (tokens[1] == "w")
board->sideToMove = WHITE;
else
{
HASH_SIDE();
board->sideToMove = BLACK;
}
index = 0;
do {
switch (tokens[2][index]) {
case 'K': board->castlingprivileges |= WHITESHORT; break;
case 'Q': board->castlingprivileges |= WHITELONG; break;
case 'k': board->castlingprivileges |= BLACKSHORT; break;
case 'q': board->castlingprivileges |= BLACKLONG; break;
}
index++;
} while (index < tokens[2].length());
HASH_CASTLE();
//en passant quare
if (tokens[3] == "-")
board->enpassantsquare = INVALID;
else{
board->enpassantsquare = MakeSquareFromString(tokens[3]);
HASH_EP(board->enpassantsquare, board->sideToMove)
}
// 50 move rule counter
if (tokens[4] == "-")
board->fiftymoverule = 0;
else
board->fiftymoverule = MakeInt(tokens[5]);
//move number
board->Movenum = MakeInt(tokens[5]);
HASH_MOVENUM();
ASSERT(isBoardOK(board));
return true;
}
