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; }