X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=9818fdce54c904b3378537b2b0f114caf221a597;hp=63033d80ee5a86a74025c5578ea49325f466bdfe;hb=5dc23121215039938a9ef4e59ae934312774571c;hpb=7dd0c39714cbb6829d7cbf9da36fa46995e7a61e

diff --git a/src/material.cpp b/src/material.cpp
index 63033d80..9818fdce 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
-  Glaurung is distributed in the hope that it will be useful,
+  Stockfish is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
@@ -255,13 +256,13 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
     return mi;
   }
   else if(pos.non_pawn_material(BLACK) == Value(0) &&
-          pos.pawn_count(BLACK) == 0 &&
+          pos.piece_count(BLACK, PAWN) == 0 &&
           pos.non_pawn_material(WHITE) >= RookValueEndgame) {
     mi->evaluationFunction = &EvaluateKXK;
     return mi;
   }
   else if(pos.non_pawn_material(WHITE) == Value(0) &&
-          pos.pawn_count(WHITE) == 0 &&
+          pos.piece_count(WHITE, PAWN) == 0 &&
           pos.non_pawn_material(BLACK) >= RookValueEndgame) {
     mi->evaluationFunction = &EvaluateKKX;
     return mi;
@@ -317,33 +318,33 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
   }
 
   if(pos.non_pawn_material(WHITE) == BishopValueMidgame &&
-     pos.bishop_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
+     pos.piece_count(WHITE, BISHOP) == 1 && pos.piece_count(WHITE, PAWN) >= 1)
     mi->scalingFunction[WHITE] = &ScaleKBPK;
   if(pos.non_pawn_material(BLACK) == BishopValueMidgame &&
-     pos.bishop_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
+     pos.piece_count(BLACK, BISHOP) == 1 && pos.piece_count(BLACK, PAWN) >= 1)
     mi->scalingFunction[BLACK] = &ScaleKKBP;
 
-  if(pos.pawn_count(WHITE) == 0 &&
+  if(pos.piece_count(WHITE, PAWN) == 0 &&
      pos.non_pawn_material(WHITE) == QueenValueMidgame &&
-     pos.queen_count(WHITE) == 1 &&
-     pos.rook_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
+     pos.piece_count(WHITE, QUEEN) == 1 &&
+     pos.piece_count(BLACK, ROOK) == 1 && pos.piece_count(BLACK, PAWN) >= 1)
     mi->scalingFunction[WHITE] = &ScaleKQKRP;
-  else if(pos.pawn_count(BLACK) == 0 &&
+  else if(pos.piece_count(BLACK, PAWN) == 0 &&
           pos.non_pawn_material(BLACK) == QueenValueMidgame &&
-          pos.queen_count(BLACK) == 1 &&
-          pos.rook_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
+          pos.piece_count(BLACK, QUEEN) == 1 &&
+          pos.piece_count(WHITE, ROOK) == 1 && pos.piece_count(WHITE, PAWN) >= 1)
     mi->scalingFunction[BLACK] = &ScaleKRPKQ;
 
   if(pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0)) {
-    if(pos.pawn_count(BLACK) == 0) {
-      assert(pos.pawn_count(WHITE) >= 2);
+    if(pos.piece_count(BLACK, PAWN) == 0) {
+      assert(pos.piece_count(WHITE, PAWN) >= 2);
       mi->scalingFunction[WHITE] = &ScaleKPsK;
     }
-    else if(pos.pawn_count(WHITE) == 0) {
-      assert(pos.pawn_count(BLACK) >= 2);
+    else if(pos.piece_count(WHITE, PAWN) == 0) {
+      assert(pos.piece_count(BLACK, PAWN) >= 2);
       mi->scalingFunction[BLACK] = &ScaleKKPs;
     }
-    else if(pos.pawn_count(WHITE) == 1 && pos.pawn_count(BLACK) == 1) {
+    else if(pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1) {
       mi->scalingFunction[WHITE] = &ScaleKPKPw;
       mi->scalingFunction[BLACK] = &ScaleKPKPb;
     }
@@ -358,7 +359,7 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
   for(c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign) {
 
     // No pawns makes it difficult to win, even with a material advantage:
-    if(pos.pawn_count(c) == 0 &&
+    if(pos.piece_count(c, PAWN) == 0 &&
        pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c))
        <= BishopValueMidgame) {
       if(pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c)))
@@ -366,7 +367,7 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
       else if(pos.non_pawn_material(c) < RookValueMidgame)
         mi->factor[c] = 0;
       else {
-        switch(pos.bishop_count(c)) {
+        switch(pos.piece_count(c, BISHOP)) {
         case 2:
           mi->factor[c] = 32; break;
         case 1:
@@ -378,7 +379,7 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
     }
 
     // Bishop pair:
-    if(pos.bishop_count(c) >= 2) {
+    if(pos.piece_count(c, BISHOP) >= 2) {
       mgValue += sign * BishopPairMidgameBonus;
       egValue += sign * BishopPairEndgameBonus;
     }
@@ -387,12 +388,12 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
     // formula is taken from Larry Kaufman's paper "The Evaluation of Material
     // Imbalances in Chess":
     // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
-    egValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+    mgValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
+    egValue += sign * Value(pos.piece_count(c, KNIGHT)*(pos.piece_count(c, PAWN)-5)*16);
 
     // Redundancy of major pieces, again based on Kaufman's paper:
-    if(pos.rook_count(c) >= 1) {
-      Value v = Value((pos.rook_count(c) - 1) * 32 + pos.queen_count(c) * 16);
+    if(pos.piece_count(c, ROOK) >= 1) {
+      Value v = Value((pos.piece_count(c, ROOK) - 1) * 32 + pos.piece_count(c, QUEEN) * 16);
       mgValue -= sign * v;
       egValue -= sign * v;
     }