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

Retire attackedBy[] access functions

Browse source 
Currently are used by evaluation itself and the
whole EvalInfo will be removed from global visibility
by next patch, so no reason to use them.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-08-25 15:28:08 +02:00
parent b196af4dcd
commit fff59319b0
2 changed files with 23 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
src/evaluate.cpp
View file

@ -652,10 +652,10 @@ namespace {
// Find the attacked squares around the king which has no defenders // Find the attacked squares around the king which has no defenders
// apart from the king itself // apart from the king itself
undefended = ei.attacked_by(Them) & ei.attacked_by(Us, KING); undefended = ei.attackedBy[Them][0] & ei.attackedBy[Us][KING];
undefended &= ~( ei.attacked_by(Us, PAWN) | ei.attacked_by(Us, KNIGHT) undefended &= ~( ei.attackedBy[Us][PAWN] | ei.attackedBy[Us][KNIGHT]
| ei.attacked_by(Us, BISHOP) | ei.attacked_by(Us, ROOK) | ei.attackedBy[Us][BISHOP] | ei.attackedBy[Us][ROOK]
| ei.attacked_by(Us, QUEEN)); | ei.attackedBy[Us][QUEEN]);
// Initialize the 'attackUnits' variable, which is used later on as an // Initialize the 'attackUnits' variable, which is used later on as an
// index to the KingDangerTable[] array. The initial value is based on // index to the KingDangerTable[] array. The initial value is based on
@ -669,39 +669,39 @@ namespace {
// Analyse enemy's safe queen contact checks. First find undefended // Analyse enemy's safe queen contact checks. First find undefended
// squares around the king attacked by enemy queen... // squares around the king attacked by enemy queen...
b = undefended & ei.attacked_by(Them, QUEEN) & ~pos.pieces_of_color(Them); b = undefended & ei.attackedBy[Them][QUEEN] & ~pos.pieces_of_color(Them);
if (b) if (b)
{ {
// ...then remove squares not supported by another enemy piece // ...then remove squares not supported by another enemy piece
b &= ( ei.attacked_by(Them, PAWN) | ei.attacked_by(Them, KNIGHT) b &= ( ei.attackedBy[Them][PAWN] | ei.attackedBy[Them][KNIGHT]
| ei.attacked_by(Them, BISHOP) | ei.attacked_by(Them, ROOK)); | ei.attackedBy[Them][BISHOP] | ei.attackedBy[Them][ROOK]);
if (b) if (b)
attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1); attackUnits += QueenContactCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente ? 2 : 1);
} }
// Analyse enemy's safe distance checks for sliders and knights // Analyse enemy's safe distance checks for sliders and knights
safe = ~(pos.pieces_of_color(Them) | ei.attacked_by(Us)); safe = ~(pos.pieces_of_color(Them) | ei.attackedBy[Us][0]);
b1 = pos.attacks_from<ROOK>(ksq) & safe; b1 = pos.attacks_from<ROOK>(ksq) & safe;
b2 = pos.attacks_from<BISHOP>(ksq) & safe; b2 = pos.attacks_from<BISHOP>(ksq) & safe;
// Enemy queen safe checks // Enemy queen safe checks
b = (b1 | b2) & ei.attacked_by(Them, QUEEN); b = (b1 | b2) & ei.attackedBy[Them][QUEEN];
if (b) if (b)
attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b); attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b);
// Enemy rooks safe checks // Enemy rooks safe checks
b = b1 & ei.attacked_by(Them, ROOK); b = b1 & ei.attackedBy[Them][ROOK];
if (b) if (b)
attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b); attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b);
// Enemy bishops safe checks // Enemy bishops safe checks
b = b2 & ei.attacked_by(Them, BISHOP); b = b2 & ei.attackedBy[Them][BISHOP];
if (b) if (b)
attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b); attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b);
// Enemy knights safe checks // Enemy knights safe checks
b = pos.attacks_from<KNIGHT>(ksq) & ei.attacked_by(Them, KNIGHT) & safe; b = pos.attacks_from<KNIGHT>(ksq) & ei.attackedBy[Them][KNIGHT] & safe;
if (b) if (b)
attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b); attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b);
@ -759,7 +759,7 @@ namespace {
if (pos.square_is_empty(blockSq)) if (pos.square_is_empty(blockSq))
{ {
squaresToQueen = squares_in_front_of(Us, s); squaresToQueen = squares_in_front_of(Us, s);
defendedSquares = squaresToQueen & ei.attacked_by(Us); defendedSquares = squaresToQueen & ei.attackedBy[Us][0];
// If there is an enemy rook or queen attacking the pawn from behind, // If there is an enemy rook or queen attacking the pawn from behind,
// add all X-ray attacks by the rook or queen. Otherwise consider only // add all X-ray attacks by the rook or queen. Otherwise consider only
@ -768,7 +768,7 @@ namespace {
&& (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s))) && (squares_behind(Us, s) & pos.pieces(ROOK, QUEEN, Them) & pos.attacks_from<ROOK>(s)))
unsafeSquares = squaresToQueen; unsafeSquares = squaresToQueen;
else else
unsafeSquares = squaresToQueen & (ei.attacked_by(Them) | pos.pieces_of_color(Them)); unsafeSquares = squaresToQueen & (ei.attackedBy[Them][0] | pos.pieces_of_color(Them));
// If there aren't enemy attacks or pieces along the path to queen give // If there aren't enemy attacks or pieces along the path to queen give
// huge bonus. Even bigger if we protect the pawn's path. // huge bonus. Even bigger if we protect the pawn's path.
@ -834,8 +834,8 @@ namespace {
// pawn, or if it is undefended and attacked by an enemy piece. // pawn, or if it is undefended and attacked by an enemy piece.
Bitboard safe = SpaceMask[Us] Bitboard safe = SpaceMask[Us]
& ~pos.pieces(PAWN, Us) & ~pos.pieces(PAWN, Us)
& ~ei.attacked_by(Them, PAWN) & ~ei.attackedBy[Them][PAWN]
& (ei.attacked_by(Us) | ~ei.attacked_by(Them)); & (ei.attackedBy[Us][0] | ~ei.attackedBy[Them][0]);
// Find all squares which are at most three squares behind some friendly pawn // Find all squares which are at most three squares behind some friendly pawn
Bitboard behind = pos.pieces(PAWN, Us); Bitboard behind = pos.pieces(PAWN, Us);

14
src/evaluate.h
View file

@ -42,14 +42,19 @@
/// contents to make intelligent search decisions. /// contents to make intelligent search decisions.
/// ///
/// At the moment, this is not utilized very much: The only part of the /// At the moment, this is not utilized very much: The only part of the
/// EvalInfo object which is used by the search is futilityMargin. /// EvalInfo object which is used by the search is margin.
class Position; class Position;
struct EvalInfo { struct EvalInfo {
// Middle game and endgame evaluations // Middle and end game position's static evaluations
Score value; Score value;
// margin[color] stores the evaluation margins we should consider for
// the given position. This is a kind of uncertainty estimation and
// typically is used by the search for pruning decisions.
Value margin[2];
// Pointers to material and pawn hash table entries // Pointers to material and pawn hash table entries
MaterialInfo* mi; MaterialInfo* mi;
PawnInfo* pi; PawnInfo* pi;
@ -58,8 +63,6 @@ struct EvalInfo {
// attacked by a given color and piece type, attackedBy[color][0] contains // attacked by a given color and piece type, attackedBy[color][0] contains
// all squares attacked by the given color. // all squares attacked by the given color.
Bitboard attackedBy[2][8]; Bitboard attackedBy[2][8];
Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
// kingZone[color] is the zone around the enemy king which is considered // kingZone[color] is the zone around the enemy king which is considered
// by the king safety evaluation. This consists of the squares directly // by the king safety evaluation. This consists of the squares directly
@ -86,9 +89,6 @@ struct EvalInfo {
// king is on g8 and there's a white knight on g5, this knight adds // king is on g8 and there's a white knight on g5, this knight adds
// 2 to kingAdjacentZoneAttacksCount[BLACK]. // 2 to kingAdjacentZoneAttacksCount[BLACK].
int kingAdjacentZoneAttacksCount[2]; int kingAdjacentZoneAttacksCount[2];
// Value of the score margin we should consider for the given color
Value margin[2];
}; };