kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 08:43:09 +00:00
Code Issues Releases Wiki Activity

Renaming some variables in code

Browse source 
Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.

Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426

No functional change.
This commit is contained in:
Stéphane Nicolet 2018-03-15 10:44:26 +01:00
parent 8ab12c9012
commit 96362fe3df
6 changed files with 47 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
src/evaluate.cpp
View file

@ -163,24 +163,24 @@ namespace {
const Score KingProtector[] = { S(3, 5), S(4, 3), S(3, 0), S(1, -1) };
// Assorted bonuses and penalties
const Score BishopPawns = S( 8, 12);
const Score CloseEnemies = S( 7, 0);
const Score Connectivity = S( 3, 1);
const Score Hanging = S( 52, 30);
const Score HinderPassedPawn = S( 8, 1);
const Score KnightOnQueen = S( 21, 11);
const Score LongRangedBishop = S( 22, 0);
const Score MinorBehindPawn = S( 16, 0);
const Score PawnlessFlank = S( 20, 80);
const Score RookOnPawn = S( 8, 24);
const Score SliderOnQueen = S( 42, 21);
const Score ThreatByPawnPush = S( 47, 26);
const Score ThreatByRank = S( 16, 3);
const Score ThreatBySafePawn = S(175,168);
const Score TrappedBishopA1H1 = S( 50, 50);
const Score TrappedRook = S( 92, 0);
const Score WeakQueen = S( 50, 10);
const Score WeakUnopposedPawn = S( 5, 25);
const Score BishopPawns = S( 8, 12);
const Score CloseEnemies = S( 7, 0);
const Score Connectivity = S( 3, 1);
const Score CorneredBishop = S( 50, 50);
const Score Hanging = S( 52, 30);
const Score HinderPassedPawn = S( 8, 1);
const Score KnightOnQueen = S( 21, 11);
const Score LongDiagonalBishop = S( 22, 0);
const Score MinorBehindPawn = S( 16, 0);
const Score PawnlessFlank = S( 20, 80);
const Score RookOnPawn = S( 8, 24);
const Score SliderOnQueen = S( 42, 21);
const Score ThreatByPawnPush = S( 47, 26);
const Score ThreatByRank = S( 16, 3);
const Score ThreatBySafePawn = S(175,168);
const Score TrappedRook = S( 92, 0);
const Score WeakQueen = S( 50, 10);
const Score WeakUnopposedPawn = S( 5, 25);
#undef S
@ -230,18 +230,18 @@ namespace {
// which attack a square in the kingRing of the enemy king.
int kingAttackersCount[COLOR_NB];
// kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
// given color which attack a square in the kingRing of the enemy king. The
// weights of the individual piece types are given by the elements in the
// KingAttackWeights array.
// kingAttackersWeight[color] is the sum of the "weights" of the pieces of
// the given color which attack a square in the kingRing of the enemy king.
// The weights of the individual piece types are given by the elements in
// the KingAttackWeights array.
int kingAttackersWeight[COLOR_NB];
// kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
// color to squares directly adjacent to the enemy king. Pieces which attack
// more than one square are counted multiple times. For instance, if there is
// kingAttacksCount[color] is the number of attacks by the given color to
// squares directly adjacent to the enemy king. Pieces which attack more
// than one square are counted multiple times. For instance, if there is
// a white knight on g5 and black's king is on g8, this white knight adds 2
// to kingAdjacentZoneAttacksCount[WHITE].
int kingAdjacentZoneAttacksCount[COLOR_NB];
// to kingAttacksCount[WHITE].
int kingAttacksCount[COLOR_NB];
};
@ -276,7 +276,7 @@ namespace {
kingRing[Us] |= shift<Up>(kingRing[Us]);
kingAttackersCount[Them] = popcount(attackedBy[Us][KING] & pe->pawn_attacks(Them));
kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;
}
else
kingRing[Us] = kingAttackersCount[Them] = 0;
@ -316,7 +316,7 @@ namespace {
{
kingAttackersCount[Us]++;
kingAttackersWeight[Us] += KingAttackWeights[Pt];
kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
}
int mob = popcount(b & mobilityArea[Us]);
@ -348,7 +348,7 @@ namespace {
// Bonus for bishop on a long diagonal which can "see" both center squares
if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))
score += LongRangedBishop;
score += LongDiagonalBishop;
}
// An important Chess960 pattern: A cornered bishop blocked by a friendly
@ -360,9 +360,9 @@ namespace {
{
Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
if (pos.piece_on(s + d) == make_piece(Us, PAWN))
score -= !pos.empty(s + d + pawn_push(Us)) ? TrappedBishopA1H1 * 4
: pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
: TrappedBishopA1H1;
score -= !pos.empty(s + d + pawn_push(Us)) ? CorneredBishop * 4
: pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
: CorneredBishop;
}
}
@ -463,7 +463,7 @@ namespace {
pinned = pos.blockers_for_king(Us) & pos.pieces(Us);
kingDanger += kingAttackersCount[Them] * kingAttackersWeight[Them]
+ 102 * kingAdjacentZoneAttacksCount[Them]
+ 102 * kingAttacksCount[Them]
+ 191 * popcount(kingRing[Us] & weak)
+ 143 * popcount(pinned | unsafeChecks)
- 848 * !pos.count<QUEEN>(Them)

4
src/material.cpp
View file

@ -68,7 +68,7 @@ namespace {
&& pos.non_pawn_material(us) >= RookValueMg;
}
bool is_KBPsKs(const Position& pos, Color us) {
bool is_KBPsK(const Position& pos, Color us) {
return pos.non_pawn_material(us) == BishopValueMg
&& pos.count<BISHOP>(us) == 1
&& pos.count<PAWN >(us) >= 1;
@ -165,7 +165,7 @@ Entry* probe(const Position& pos) {
// case we don't return after setting the function.
for (Color c = WHITE; c <= BLACK; ++c)
{
if (is_KBPsKs(pos, c))
if (is_KBPsK(pos, c))
e->scalingFunction[c] = &ScaleKBPsK[c];
else if (is_KQKRPs(pos, c))

6
src/position.cpp
View file

@ -322,8 +322,8 @@ void Position::set_castling_right(Color c, Square rfrom) {
void Position::set_check_info(StateInfo* si) const {
si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinnersForKing[WHITE]);
si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinnersForKing[BLACK]);
si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinners[BLACK]);
si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinners[WHITE]);
Square ksq = square<KING>(~sideToMove);
@ -1037,7 +1037,7 @@ bool Position::see_ge(Move m, Value threshold) const {
// Don't allow pinned pieces to attack (except the king) as long as
// all pinners are on their original square.
if (!(st->pinnersForKing[stm] & ~occupied))
if (!(st->pinners[~stm] & ~occupied))
stmAttackers &= ~st->blockersForKing[stm];
// If stm has no more attackers then give up: stm loses

2
src/position.h
View file

@ -52,7 +52,7 @@ struct StateInfo {
Piece capturedPiece;
StateInfo* previous;
Bitboard blockersForKing[COLOR_NB];
Bitboard pinnersForKing[COLOR_NB];
Bitboard pinners[COLOR_NB];
Bitboard checkSquares[PIECE_TYPE_NB];
};

4
src/psqt.cpp
View file

@ -112,12 +112,12 @@ void init() {
PieceValue[MG][~pc] = PieceValue[MG][pc];
PieceValue[EG][~pc] = PieceValue[EG][pc];
Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
Score score = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
for (Square s = SQ_A1; s <= SQ_H8; ++s)
{
File f = std::min(file_of(s), ~file_of(s));
psq[ pc][ s] = v + Bonus[pc][rank_of(s)][f];
psq[ pc][ s] = score + Bonus[pc][rank_of(s)][f];
psq[~pc][~s] = -psq[pc][s];
}
}

10
src/search.cpp
View file

@ -455,12 +455,12 @@ void Thread::search() {
timeReduction *= 1.25;
// Use part of the gained time from a previous stable move for the current move
double unstablePvFactor = 1.0 + mainThread->bestMoveChanges;
unstablePvFactor *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
double bestMoveInstability = 1.0 + mainThread->bestMoveChanges;
bestMoveInstability *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
// Stop the search if we have only one legal move, or if available time elapsed
if ( rootMoves.size() == 1
|| Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 581)
|| Time.elapsed() > Time.optimum() * bestMoveInstability * improvingFactor / 581)
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
@ -495,7 +495,7 @@ namespace {
if (depth < ONE_PLY)
return qsearch<NT>(pos, ss, alpha, beta);
const bool PvNode = NT == PV;
constexpr bool PvNode = NT == PV;
const bool rootNode = PvNode && ss->ply == 0;
assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE);
@ -1156,7 +1156,7 @@ moves_loop: // When in check, search starts from here
template <NodeType NT>
Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
const bool PvNode = NT == PV;
constexpr bool PvNode = NT == PV;
const bool inCheck = bool(pos.checkers());
assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);