opelly/Stockfish
1
0
Fork 0
mirror of https://github.com/opelly27/Stockfish.git synced 2026-05-20 06:17:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Big assorted spelling fixes

Browse Source 
No functional change.
This commit is contained in:
Richard Lloyd
2013-12-02 19:04:09 +01:00
committed by Marco Costalba
parent 500b9b0eb3
commit 13a73f67c0
30 changed files with 265 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/position.cpp
+30 -30
View File
@@ -82,7 +82,7 @@ PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stm
template<> FORCE_INLINE
PieceType min_attacker<KING>(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) {
return KING; // No need to update bitboards, it is the last cycle
return KING; // No need to update bitboards: it is the last cycle
}
} // namespace
@@ -109,9 +109,9 @@ CheckInfo::CheckInfo(const Position& pos) {
/// Position::init() initializes at startup the various arrays used to compute
/// hash keys and the piece square tables. The latter is a two-step operation:
/// First, the white halves of the tables are copied from PSQT[] tables. Second,
/// the black halves of the tables are initialized by flipping and changing the
/// sign of the white scores.
/// Firstly, the white halves of the tables are copied from PSQT[] tables.
/// Secondly, the black halves of the tables are initialized by flipping and
/// changing the sign of the white scores.
void Position::init() {
@@ -155,7 +155,7 @@ void Position::init() {
/// Position::operator=() creates a copy of 'pos'. We want the new born Position
/// object do not depend on any external data so we detach state pointer from
/// object to not depend on any external data so we detach state pointer from
/// the source one.
Position& Position::operator=(const Position& pos) {
@@ -182,11 +182,11 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) {
A FEN string contains six fields separated by a space. The fields are:
1) Piece placement (from white's perspective). Each rank is described, starting
with rank 8 and ending with rank 1; within each rank, the contents of each
with rank 8 and ending with rank 1. Within each rank, the contents of each
square are described from file A through file H. Following the Standard
Algebraic Notation (SAN), each piece is identified by a single letter taken
from the standard English names. White pieces are designated using upper-case
letters ("PNBRQK") while Black take lowercase ("pnbrqk"). Blank squares are
letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are
noted using digits 1 through 8 (the number of blank squares), and "/"
separates ranks.
@@ -324,8 +324,8 @@ void Position::set_castling_flag(Color c, Square rfrom) {
}
/// Position::fen() returns a FEN representation of the position. In case
/// of Chess960 the Shredder-FEN notation is used. Mainly a debugging function.
/// Position::fen() returns a FEN representation of the position. In case of
/// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function.
const string Position::fen() const {
@@ -416,14 +416,14 @@ const string Position::pretty(Move move) const {
/// Position:hidden_checkers() returns a bitboard of all pinned / discovery check
/// pieces, according to the call parameters. Pinned pieces protect our king,
/// pieces, according to the call parameters. Pinned pieces protect our king and
/// discovery check pieces attack the enemy king.
Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
Bitboard b, pinners, result = 0;
// Pinners are sliders that give check when pinned piece is removed
// Pinners are sliders that give check when a pinned piece is removed
pinners = ( (pieces( ROOK, QUEEN) & PseudoAttacks[ROOK ][ksq])
| (pieces(BISHOP, QUEEN) & PseudoAttacks[BISHOP][ksq])) & pieces(c);
@@ -439,7 +439,7 @@ Bitboard Position::hidden_checkers(Square ksq, Color c, Color toMove) const {
/// Position::attackers_to() computes a bitboard of all pieces which attack a
/// given square. Slider attacks use occ bitboard as occupancy.
/// given square. Slider attacks use the occ bitboard to indicate occupancy.
Bitboard Position::attackers_to(Square s, Bitboard occ) const {
@@ -593,8 +593,8 @@ bool Position::pseudo_legal(const Move m) const {
return false;
// Evasions generator already takes care to avoid some kind of illegal moves
// and pl_move_is_legal() relies on this. So we have to take care that the
// same kind of moves are filtered out here.
// and pl_move_is_legal() relies on this. We therefore have to take care that
// the same kind of moves are filtered out here.
if (checkers())
{
if (type_of(pc) != KING)
@@ -629,11 +629,11 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const {
Square to = to_sq(m);
PieceType pt = type_of(piece_on(from));
// Direct check ?
// Is there a direct check ?
if (ci.checkSq[pt] & to)
return true;
// Discovered check ?
// Is there a discovered check ?
if ( unlikely(ci.dcCandidates)
&& (ci.dcCandidates & from)
&& !aligned(from, to, king_square(~sideToMove)))
@@ -652,7 +652,7 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const {
return attacks_bb(Piece(promotion_type(m)), to, pieces() ^ from) & ksq;
// En passant capture with check ? We have already handled the case
// of direct checks and ordinary discovered check, the only case we
// of direct checks and ordinary discovered check, so the only case we
// need to handle is the unusual case of a discovered check through
// the captured pawn.
case ENPASSANT:
@@ -700,7 +700,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
// Copy some fields of old state to our new StateInfo object except the ones
// which are going to be recalculated from scratch anyway, then switch our state
// pointer to point to the new, ready to be updated, state.
// pointer to point to the new (ready to be updated) state.
std::memcpy(&newSt, st, StateCopySize64 * sizeof(uint64_t));
newSt.previous = st;
@@ -709,7 +709,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
// Update side to move
k ^= Zobrist::side;
// Increment ply counters.In particular rule50 will be later reset it to zero
// Increment ply counters.In particular rule50 will be reset to zero later on
// in case of a capture or a pawn move.
++gamePly;
++st->rule50;
@@ -812,7 +812,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
// If the moving piece is a pawn do some special extra work
if (pt == PAWN)
{
// Set en-passant square, only if moved pawn can be captured
// Set en-passant square if the moved pawn can be captured
if ( (int(to) ^ int(from)) == 16
&& (attacks_from<PAWN>(from + pawn_push(us), us) & pieces(them, PAWN)))
{
@@ -860,7 +860,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
// Update the key with the final value
st->key = k;
// Update checkers bitboard, piece must be already moved
// Update checkers bitboard: piece must be already moved
st->checkersBB = 0;
if (moveIsCheck)
@@ -1133,7 +1133,7 @@ void Position::clear() {
/// Position::compute_key() computes the hash key of the position. The hash
/// key is usually updated incrementally as moves are made and unmade, the
/// key is usually updated incrementally as moves are made and unmade. The
/// compute_key() function is only used when a new position is set up, and
/// to verify the correctness of the hash key when running in debug mode.
@@ -1158,8 +1158,8 @@ Key Position::compute_key() const {
/// Position::compute_pawn_key() computes the hash key of the position. The
/// hash key is usually updated incrementally as moves are made and unmade,
/// the compute_pawn_key() function is only used when a new position is set
/// hash key is usually updated incrementally as moves are made and unmade.
/// The compute_pawn_key() function is only used when a new position is set
/// up, and to verify the correctness of the pawn hash key when running in
/// debug mode.
@@ -1178,8 +1178,8 @@ Key Position::compute_pawn_key() const {
/// Position::compute_material_key() computes the hash key of the position.
/// The hash key is usually updated incrementally as moves are made and unmade,
/// the compute_material_key() function is only used when a new position is set
/// The hash key is usually updated incrementally as moves are made and unmade.
/// The compute_material_key() function is only used when a new position is set
/// up, and to verify the correctness of the material hash key when running in
/// debug mode.
@@ -1218,7 +1218,7 @@ Score Position::compute_psq_score() const {
/// Position::compute_non_pawn_material() computes the total non-pawn middle
/// game material value for the given side. Material values are updated
/// incrementally during the search, this function is only used while
/// incrementally during the search. This function is only used when
/// initializing a new Position object.
Value Position::compute_non_pawn_material(Color c) const {
@@ -1233,7 +1233,7 @@ Value Position::compute_non_pawn_material(Color c) const {
/// Position::is_draw() tests whether the position is drawn by material,
/// repetition, or the 50 moves rule. It does not detect stalemates, this
/// repetition, or the 50 moves rule. It does not detect stalemates: this
/// must be done by the search.
bool Position::is_draw() const {
@@ -1268,7 +1268,7 @@ bool Position::is_draw() const {
/// Position::flip() flips position with the white and black sides reversed. This
/// is only useful for debugging especially for finding evaluation symmetry bugs.
/// is only useful for debugging e.g. for finding evaluation symmetry bugs.
static char toggle_case(char c) {
return char(islower(c) ? toupper(c) : tolower(c));
@@ -1305,7 +1305,7 @@ void Position::flip() {
}
/// Position::pos_is_ok() performs some consitency checks for the position object.
/// Position::pos_is_ok() performs some consistency checks for the position object.
/// This is meant to be helpful when debugging.
bool Position::pos_is_ok(int* failedStep) const {