Piece& operator++(Piece& w)
{
if (w<BlackPawn)
return w = Piece(w+1);
else
return w = Empty;
}
void MoveGenEnglish::_find_deep_capture_queen(MoveList& moves, Move& move, int8_t row, int8_t column, bool(&captured)[8][8]) const
{
static constexpr int d_row[4] = { 1, 1, -1, -1 }, d_column[4] = { 1, -1, 1, -1 };
for (size_t dir = 0; dir < 4; ++dir)
{
// In english checkers we can jump only over adjacent pieces
const int r1 = row + d_row[dir], c1 = column + d_column[dir], r2 = r1 + d_row[dir], c2 = c1 + d_column[dir];
if (r2 < 0 || c2 < 0 || r2 > 7 || c2 > 7 || board[r2][c2].get_type() != PT_EMPTY
|| board[r1][c1].get_colour() != opposite(TURN) || captured[r1][c1])
continue;
move.add_step(Position(r2, c2)); // Correct capture-move
move.add_capture(std::make_pair(Position(r1, c1), board[r1][c1]));
const size_t old = moves.size();
captured[r1][c1] = true; // For preventing 'recapturing' piece at (r1; c1) in moves produced by recursive call to this function(next 4 lines)
_find_deep_capture_queen<TURN>(moves, move, r2, c2, captured);
if (old == moves.size()) // If in recursive call we haven't found any move, then 'move' is a final capture and is one of possible captures
{
move.set_become(Piece(TURN == WHITE ? WHITE_QUEEN : BLACK_QUEEN));
moves.emplace(move);
}
captured[r1][c1] = false; // For correct work on next cycles we should clear changes to 'captured' and 'move' variables
move.pop_step();
move.pop_capture();
}
}
void Position::init_make_list()
{
memset(list0, 0, sizeof(list0));
memset(list1, 0, sizeof(list1));
memset(listkn, 0, sizeof(listkn));
memset(handcount, 0, sizeof(handcount));
for (PieceNumber kn = PIECENUMBER_MIN; kn <= PIECENUMBER_MAX; ++kn){
const int kpos = knpos[kn];
const Piece piece = Piece(knkind[kn]);
int count, sq;
switch (kpos) {
case 0:
break;
case 1: // 先手持駒
case 2: // 後手持駒
count = ++handcount[piece];
list0[kn] = NanohaTbl::HandIndex0[piece] + count;
list1[kn] = NanohaTbl::HandIndex1[piece] + count;
listkn[list0[kn]] = kn;
break;
default:
if ((SFU <= piece && piece <= SRY && piece != SOU) ||
(GFU <= piece && piece <= GRY && piece != GOU)) {
sq = conv_z2sq(kpos);
list0[kn] = NanohaTbl::KppIndex0[piece] + sq;
list1[kn] = NanohaTbl::KppIndex1[piece] + Inv(sq);
}
break;
}
}
}
std::string pretty(Move m)
{
if (is_drop(m))
return (pretty(move_to(m)) + pretty2(Piece(move_from(m))) + (pretty_jp ? "打" : "*"));
else
return pretty(move_from(m)) + pretty(move_to(m)) + (is_promote(m) ? (pretty_jp ? "成" : "+") : "");
}
void MovePicker::score_evasions() {
// Try good captures ordered by MVV/LVA, then non-captures if
// destination square is not under attack, ordered by history
// value, and at the end bad-captures and non-captures with a
// negative SEE. This last group is ordered by the SEE score.
Move m;
int seeScore;
// Skip if we don't have at least two moves to order
if (lastMove < moves + 2)
return;
for (MoveStack* cur = moves; cur != lastMove; cur++)
{
m = cur->move;
if ((seeScore = pos.see_sign(m)) < 0)
cur->score = seeScore - History::MaxValue; // Be sure we are at the bottom
else if (pos.is_capture(m))
#if defined(NANOHA)
cur->score = piece_value_midgame(pos.piece_on(move_to(m)))
- type_of(move_piece(m)) + History::MaxValue;
#else
cur->score = piece_value_midgame(pos.piece_on(move_to(m)))
- type_of(pos.piece_on(move_from(m))) + History::MaxValue;
#endif
else
#if defined(NANOHA)
{
Piece piece = is_promotion(m) ? Piece(move_piece(m) | PROMOTED) : move_piece(m);
cur->score = H.value(piece, move_to(m));
}
#else
cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
#endif
}
MoveStack* generate<QUIET_CHECKS>(const Position& pos, MoveStack* mlist) {
assert(!pos.checkers());
CheckInfo ci(pos);
Bitboard dc = ci.dcCandidates;
while (dc)
{
Square from = pop_lsb(&dc);
PieceType pt = type_of(pos.piece_on(from));
if (pt == PAWN)
continue; // Will be generated togheter with direct checks
Bitboard b = pos.attacks_from(Piece(pt), from) & ~pos.pieces();
if (pt == KING)
b &= ~PseudoAttacks[QUEEN][ci.ksq];
SERIALIZE(b);
}
return generate_all<QUIET_CHECKS>(pos, mlist, pos.side_to_move(), ~pos.pieces(), &ci);
}
std::string to_usi_string(Move m)
{
std::stringstream ss;
if (!is_ok(m))
{
ss <<((m == MOVE_RESIGN) ? "resign" :
(m == MOVE_WIN ) ? "win" :
(m == MOVE_NULL ) ? "null" :
(m == MOVE_NONE ) ? "none" :
"");
}
else if (is_drop(m))
{
ss << Piece(move_from(m));
ss << '*';
ss << move_to(m);
}
else {
ss << move_from(m);
ss << move_to(m);
if (is_promote(m))
ss << '+';
}
return ss.str();
}
ExtMove* generate<QUIET_CHECKS>(const Position& pos, ExtMove* moveList) {
assert(!pos.checkers());
Color us = pos.side_to_move();
CheckInfo ci(pos);
Bitboard dc = ci.dcCandidates;
while (dc)
{
Square from = pop_lsb(&dc);
PieceType pt = type_of(pos.piece_on(from));
if (pt == PAWN)
continue; // Will be generated together with direct checks
Bitboard b = pos.attacks_from(Piece(pt), from) & ~pos.pieces();
if (pt == KING)
b &= ~PseudoAttacks[QUEEN][ci.ksq];
while (b)
*moveList++ = make_move(from, pop_lsb(&b));
}
return us == WHITE ? generate_all<WHITE, QUIET_CHECKS>(pos, moveList, ~pos.pieces(), &ci)
: generate_all<BLACK, QUIET_CHECKS>(pos, moveList, ~pos.pieces(), &ci);
}
bool OukBoard::vSetFenString(const QStringList& fen)
{
// At first assume that King and Maiden pieces have moved
m_moveCount[Side::White][King] = 1;
m_moveCount[Side::Black][King] = 1;
m_moveCount[Side::White][Maiden] = 1;
m_moveCount[Side::Black][Maiden] = 1;
// parseCastlingRights is called via vSetFenString of base class
if (!MakrukBoard::vSetFenString(fen))
return false;
// Expect pieces on their initial squares if move counter is zero
const OukPieceType types[2]{King, Maiden};
for (int side = Side::White; side <= Side::Black; side++)
{
for (auto type: types)
{
int index = m_initialSquare[side][type];
if ( m_moveCount[side][type] == 0
&& pieceAt(index) != Piece(Side::Type(side), type))
return false;
}
}
return true;
}
bool Game::is_movable(Cell from, Cell to, bool assume, Piece piece) const {
Element from_element = board[from.get_id()];
Element to_element = board[to.get_id()];
assert(!from_element.is_empty());
if(!assume) {
assert(!from_element.is_unknown());
piece = piece_of(from_element);
}
if(from_element.is_empty() || from_element.is_unknown()) {
return false;
} else if(from.get_type() == Headquarter) {
return false;
} else if(!to_element.is_empty() && to.get_type() == Camp) {
return false;
} else if(piece == Piece(41)) {
return false;
} else if(
!to_element.is_empty()
&& (to_element.get_player() == from_element.get_player())
) {
return false;
} else if(
!to_element.is_empty()
&& (
int(to_element.get_player())
== (from_element.get_player()+2)%4
)
&& !is_1v1()
) {
return false;
} else {
bool occupy_state[4631] = {0};
for(int i=0; i<4631; i++) {
if(is_valid_cell_id(i)) {
occupy_state[i] = !board[i].is_empty();
} // if i is a valid cell id
} // for i in 0..4630
std::list<Cell> route = get_route(
from, to, occupy_state, piece == Piece(32)
);
if(route.empty())
return false;
else
return true;
}
}
Board board_factory_2(){
Board b;
b.set_piece(Piece(6,0), 1, 1);
b.set_piece(Piece(6,0), 2, 3);
b.set_piece(Piece(6,1), 4, 2);
b.set_piece(Piece(6,0), 3, 4);
b.set_piece(Piece(SCOUT,0), 4, 4);
printf("board 2 as viewd by player 0\n");
b.print(0);
printf("board 2 as viewd by player 1\n");
b.print(1);
return b;
}
void PieceTable::init( Size size )
{
mList.clear();
if( size > 0 )
mList.append( Piece(0,size,Piece::OriginalStorage) );
mSize = size;
}
Position Position::emptyPosition()
{
Position position;
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
position.setPieceAt(i, j, Piece());
return position;
}
//getters
Piece Square::getPiece() const {
if(piece != NULL) {
return *piece;
}
else {
//cout << "tried to grab piece from an empty square" << endl;
return Piece(); //this should never happen... always check if empty first
}
}
void CrazyhouseBoard::vUndoMove(const Move& move)
{
int source = move.sourceSquare();
int target = move.targetSquare();
int prom = move.promotion();
Move tmp(move);
if (source != 0 && prom != Piece::NoPiece)
tmp = Move(source, target, promotedPieceType(prom));
WesternBoard::vUndoMove(tmp);
int ctype = captureType(move);
if (ctype != Piece::NoPiece)
removeFromReserve(Piece(sideToMove(), reserveType(ctype)));
else if (source == 0)
addToReserve(Piece(sideToMove(), prom));
}
PromotionDialog::PromotionDialog(QWidget *parent, Color color) :
QDialog(parent),
ui(new Ui::PromotionDialog),
m_index(-1)
{
BoardView view;
view.configure();
ui->setupUi(this);
QPoint pos = mapFromGlobal(QCursor::pos());
move(pos);
int offset = color==White ? 0 : (BlackKing-WhiteKing);
ui->btQueen->setIcon(view.theme().piece(Piece(WhiteQueen+offset)));
ui->btRook->setIcon(view.theme().piece(Piece(WhiteRook+offset)));
ui->btBishop->setIcon(view.theme().piece(Piece(WhiteBishop+offset)));
ui->btKnight->setIcon(view.theme().piece(Piece(WhiteKnight+offset)));
}
const std::forward_list<Piece>& annotation_pieces() {
if (annotation_piece_list == 0) {
annotation_piece_list = new std::forward_list<Piece>();
const char * e = annotations;
while (*e != 0)
annotation_piece_list->emplace_front(Piece(*(e++)));
};
return *annotation_piece_list;
}
bool RockPaperScissors::placePiece(int playerNumber, const Piece& p, int fromRow, int fromColumn, int toRow, int toColumn, int lineNumber, const string& line, Status& currentStatus) {
Cell& fromCell = board[fromRow][fromColumn];
if (currentStatus.getIsPositioningPhase() == true) {
//empty valid cell
if (fromCell.getPlayerOwning() == NO_PLAYER) {
//player has pieces left
if (getNumberOfPiecesLeftToPlace(playerNumber, p) > 0) {
decreasePieceFromStock(playerNumber, p);//reduce 1 piece left for player
increasePieceOnBoard(playerNumber, p);//increase 1 piece on board for player
fromCell.setCell(p, playerNumber);
return true;
}
//illegal - out of pieces
else {
cout << "Player " << playerNumber << " had no more " << p << " pieces at line " << lineNumber + 1 << ":" << endl \
<< line << endl;
currentStatus.setStatus(playerNumber, PossibleStatus::input_File_Error, fromRow, line);
return false;
}
}
//illegal - same place piece
else if (fromCell.getPlayerOwning() == playerNumber) {
cout << "Player " << playerNumber << " tried to place a " << p << " in line " << lineNumber + 1 << ":" << endl \
<< line << endl \
<< "where he already placed there a " << fromCell.getCellPiece() << " before." << endl;
currentStatus.setStatus(playerNumber, PossibleStatus::input_File_Error, lineNumber + 1, line);
return false;
}
//legal place - fight
else {
decreasePieceFromStock(playerNumber, p);//reduce 1 piece from stock
increasePieceOnBoard(playerNumber, p);//increase 1 piece on board
fight(fromRow, fromColumn, p, playerNumber);
return true;
}
}
else {//moving phase
Cell& toCell = board[toRow][toColumn];
const Piece& newP = fromCell.getCellPiece();
//empty destination cell
if (toCell.getPlayerOwning() == NO_PLAYER) {
toCell.setCell(newP, playerNumber); //move piece to destination
fromCell.setCell(Piece()); //remove piece from source cell
}
//legal place - fight
else {
fight(toRow, toColumn, newP, playerNumber);
setPieceAt(fromRow, fromColumn, NO_PLAYER);//remove piece from original cell
}
}
return true;
}
Piece Piece::rotateCCW() const
{
char ndesc[16];
getColumn(3, (char*)ndesc);
getColumn(2, (char*)(ndesc+4));
getColumn(1, (char*)(ndesc+8));
getColumn(0, (char*)(ndesc+12));
return Piece(ndesc, cindex_,
margins_[1], margins_[2], margins_[3], margins_[0]);
}
// Hash key of the FEN
Key Zob::compute_fen_key (const string &fen, bool c960) const
{
if (fen.empty ()) return U64 (0);
Key fen_key = U64 (0);
File king[CLR_NO] = {F_NO};
istringstream sfen (fen);
uint8_t ch;
sfen >> noskipws;
uint32_t idx;
Square s = SQ_A8;
while ((sfen >> ch) && !isspace (ch))
{
if (isdigit (ch))
{
s += Delta (ch - '0'); // Advance the given number of files
}
else if (isalpha (ch) && (idx = CharPiece.find (ch)) != string::npos)
{
Piece p = Piece (idx);
fen_key ^= _.psq_k[_color (p)][_ptype (p)][s];
++s;
}
else if (ch == '/')
{
s += DEL_SS;
}
}
sfen >> ch;
if ('w' == ch) fen_key ^= _.mover_side;
sfen >> ch;
if (c960)
{
while ((sfen >> ch) && !isspace (ch))
{
Color c = isupper (ch) ? WHITE : BLACK;
uint8_t sym = tolower (ch);
if ('a' <= sym && sym <= 'h')
{
fen_key ^= _.castle_right[c][(king[c] < to_file (sym)) ? CS_K : CS_Q];
}
else
{
return U64 (0);
}
}
}
else
{
while ((sfen >> ch) && !isspace (ch))
Player::Player(color c) {
pcolor = c;
Position pos;
std::vector<echelon> qp; //vector for the quantum positions
for (int i=0; i<8; i++) {
qp.push_back(echelon::pawn);
}
qp.push_back(echelon::knight);
qp.push_back(echelon::knight);
qp.push_back(echelon::bishop);
qp.push_back(echelon::bishop);
qp.push_back(echelon::rook);
qp.push_back(echelon::rook);
qp.push_back(echelon::queen);
//random_shuffle sort of sucks :-)
srand(time(0));
if (pcolor == color::white) {
std::random_shuffle(qp.begin(), qp.end());
}
std::random_shuffle(qp.begin(), qp.end());
for (int i=1; i<9; i++) {
pos.rank = (pcolor == color::white)?'2':'7'; //i just love the trinary operator
pos.file = 96+i; //ASCII 'a' == 97. i just love low-level code
pieces.push_back(Piece(pos, echelon::pawn, qp.back()));
qp.pop_back();
}
pos.rank = (pcolor == color::white)?'1':'8';
pos.file='a';
put_qp(pieces, pos, echelon::rook, qp);
pos.file='h';
put_qp(pieces, pos, echelon::rook, qp);
pos.file='b';
put_qp(pieces, pos, echelon::knight, qp);
pos.file='g';
put_qp(pieces, pos, echelon::knight, qp);
pos.file='c';
put_qp(pieces, pos, echelon::bishop, qp);
pos.file='f';
put_qp(pieces, pos, echelon::bishop, qp);
pos.file='d';
put_qp(pieces, pos, echelon::queen, qp);
pos.file='e';
qp.push_back(echelon::king); //heh
put_qp(pieces, pos, echelon::king, qp);
}
QList<Piece> CrazyhouseBoard::reservePieceTypes() const
{
QList<Piece> list;
for (int i = 0; i < 2; i++)
{
for (int type = Pawn; type <= Queen; type++)
list << Piece(Side::Type(i), type);
}
return list;
}
bool is_valid_layout(const Piece *data) {
int count[42] = {0};
for(int i=0; i<25; i++) {
Cell cell = convert_layout_index_to_cell(i);
if( (cell.get_y() == 1 && data[i].get_id() == 0)
|| (cell.get_y() < 5 && data[i].get_id() == 41) ) {
return false;
}
// 計數
count[data[i].get_id()]++;
}
for(int i=0; i<12; i++) {
if(count[PIECES[i]] != NUMBER_OF_PIECES[PIECES[i]])
return false;
}
if(data[convert_cell_to_layout_index(Cell(1,6,2,0))] != Piece(31)
&& data[convert_cell_to_layout_index(Cell(1,6,2,1))] != Piece(31))
return false;
return true;
}
Position Position::defaultPosition() {
static Piece::Type piecesRank[] = {
Piece::Type::Rook,
Piece::Type::Knight,
Piece::Type::Bishop,
Piece::Type::Queen,
Piece::Type::King,
Piece::Type::Bishop,
Piece::Type::Knight,
Piece::Type::Rook
};
Position position;
for (int file = 0; file < 8; file++) {
position.setPieceAt(file, 0, Piece(piecesRank[file], Player::black()));
position.setPieceAt(file, 1, Piece(Piece::Type::Pawn, Player::black()));
position.setPieceAt(file, 6, Piece(Piece::Type::Pawn, Player::white()));
position.setPieceAt(file, 7, Piece(piecesRank[file], Player::white()));
}
return position;
}
Piece Game::piece_of(Element element) const {
assert(!element.is_empty() && !element.is_unknown());
Player player = element.get_player();
/**
* Something Ugly:
* 布局不明的玩家的已知棋子 -> 無司令以致亮出的軍旗
* 對於非一般玩法，該邏輯需要調整
*/
assert(!(layout[player].is_masked() && !show_flag[player]));
if(layout[player].is_masked() && show_flag[player])
return Piece(31);
else
return layout[player].get(element.get_layout_index());
}
std::string Move::toString() const {
std::ostringstream oss;
oss << Square(m.to).toString();
oss << Piece(m.piece).toStringNameOnly();
if (m.promote) {
oss << 'n';
}
if (!m.hand) {
oss << '(' << Square(m.from).toString() << ')';
} else {
oss << "(00)";
}
return oss.str();
}
void MakePieces() {
Piece t = Piece(3, 0.0, 0.0, 0.0);
t.Set(0, 0, true);
t.Set(1, 0, true);
t.Set(2, 0, true);
t.Set(1, 1, true);
t.Set(1, 2, true);
Piece i = Piece(3, 0.0, 0.0, 0.0);
i.Set(0, 0, true);
i.Set(0, 1, true);
i.Set(0, 2, true);
Piece lr = Piece(3, 0.0, 0.0, 0.0);
lr.Set(0, 0, true);
lr.Set(0, 1, true);
lr.Set(0, 2, true);
lr.Set(1, 2, true);
Piece ll = Piece(3, 0.0, 0.0, 0.0);
ll.Set(1, 0, true);
ll.Set(1, 1, true);
ll.Set(1, 2, true);
ll.Set(0, 2, true);
Piece sqr = Piece(2, 0.0, 0.0, 0.0);
sqr.Set(0, 0, true);
sqr.Set(0, 1, true);
sqr.Set(1, 0, true);
sqr.Set(1, 1, true);
Piece zl = Piece(3, 0.0, 0.0, 0.0);
zl.Set(0, 0, true);
zl.Set(0, 1, true);
zl.Set(1, 1, true);
zl.Set(2, 1, true);
Piece zr = Piece(3, 0.0, 0.0, 0.0);
zr.Set(2, 0, true);
zr.Set(1, 0, true);
zr.Set(1, 1, true);
zr.Set(0, 1, true);
pieces.clear();
pieces.push_back(sqr);
pieces.push_back(t);
pieces.push_back(i);
pieces.push_back(lr);
pieces.push_back(ll);
pieces.push_back(zl);
pieces.push_back(zr);
}
void AI::getEnemyTeam(){
enemyTeam.clear();
for(int x=0;x<8;x++){
for(int y=0;y<8;y++){
if (sameTeam(Board->virtualBoard[x][y],ENEMY_TEAM_NUMBER)) {
enemyTeam.push_back(Piece());
if (Board->virtualBoard[x][y] == ENEMY_TEAM_NUMBER+2){
enemyTeam.back().makeKing();
}
enemyTeam.back().x = x;
enemyTeam.back().y = y;
}
}
}
}
std::string Move::toStringCsa() const {
std::ostringstream oss;
Piece piece = Piece(m.piece);
oss << (piece.isBlack() ? "+" : "-");
if (!m.hand) {
oss << Square(m.from).toString();
} else {
oss << "00";
}
oss << Square(m.to).toString();
if (m.promote) {
piece.promote();
}
oss << piece.toStringNameOnly();
return oss.str();
}
void Thread::reset(){
for(int i = 0; i < MAX_SEARCH_PLY; i++)
killer[i][0] = killer[i][1] = MoveNull;
for(Piece p = Piece(PAWN); p<=BK; p++){
for(Square sq_f = A1; sq_f<=H8; sq_f++){
for(Square sq_t = A1; sq_t<=H8; sq_t++){
history[p][sq_f][sq_t] = 0;
his_hit[p][sq_f][sq_t] = 1;
his_tot[p][sq_f][sq_t] = 1;
}
}
}
m_hits = 0;
p_hits = 0;
h_hits = 0;
}
