Update copyright info
[stockfish] / src / endgame.h
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008 Marco Costalba
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10   
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15   
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 #if !defined(ENDGAME_H_INCLUDED)
22 #define ENDGAME_H_INCLUDED
23
24 ////
25 //// Includes
26 ////
27
28 #include "position.h"
29 #include "scale.h"
30 #include "value.h"
31
32
33 ////
34 //// Types
35 ////
36
37 /// Abstract base class for all special endgame evaluation functions:
38
39 class EndgameEvaluationFunction {
40 public:
41   EndgameEvaluationFunction(Color c);
42   virtual ~EndgameEvaluationFunction() { }
43
44   virtual Value apply(const Position &pos) =0;
45
46 protected:
47   Color strongerSide, weakerSide;
48 };
49
50
51 /// Subclasses for various concrete endgames:
52
53 // Generic "mate lone king" eval:
54 class KXKEvaluationFunction : public EndgameEvaluationFunction {
55 public:
56   KXKEvaluationFunction(Color c);
57   Value apply(const Position &pos);
58 };
59
60 // KBN vs K:
61 class KBNKEvaluationFunction : public EndgameEvaluationFunction {
62 public:
63   KBNKEvaluationFunction(Color c);
64   Value apply(const Position &pos);
65 };
66
67 // KP vs K:
68 class KPKEvaluationFunction : public EndgameEvaluationFunction {
69 public:
70   KPKEvaluationFunction(Color c);
71   Value apply(const Position &pos);
72 };
73
74 // KR vs KP:
75 class KRKPEvaluationFunction : public EndgameEvaluationFunction {
76 public:
77   KRKPEvaluationFunction(Color c);
78   Value apply(const Position &pos);
79 };
80
81 // KR vs KB:
82 class KRKBEvaluationFunction : public EndgameEvaluationFunction {
83 public:
84   KRKBEvaluationFunction(Color c);
85   Value apply(const Position &pos);
86 };
87
88 // KR vs KN:
89 class KRKNEvaluationFunction : public EndgameEvaluationFunction {
90 public:
91   KRKNEvaluationFunction(Color c);
92   Value apply(const Position &pos);
93 };
94
95 // KQ vs KR:
96 class KQKREvaluationFunction : public EndgameEvaluationFunction {
97 public:
98   KQKREvaluationFunction(Color c);
99   Value apply(const Position &pos);
100 };
101
102
103 /// Abstract base class for all evaluation scaling functions:
104
105 class ScalingFunction {
106 public:
107   ScalingFunction(Color c);
108   virtual ~ScalingFunction() { }
109
110   virtual ScaleFactor apply(const Position &pos) =0;
111
112 protected:
113   Color strongerSide, weakerSide;
114 };
115
116
117 /// Subclasses for various concrete endgames:
118
119 // KBP vs K:
120 class KBPKScalingFunction : public ScalingFunction {
121 public:
122   KBPKScalingFunction(Color c);
123   ScaleFactor apply(const Position &pos);
124 };
125
126 // KQ vs KRP:
127 class KQKRPScalingFunction: public ScalingFunction {
128 public:
129   KQKRPScalingFunction(Color c);
130   ScaleFactor apply(const Position &pos);
131 };
132
133 // KRP vs KR:
134 class KRPKRScalingFunction : public ScalingFunction {
135 public:
136   KRPKRScalingFunction(Color c);
137   ScaleFactor apply(const Position &pos);
138 };
139
140 // KRPP vs KRP:
141 class KRPPKRPScalingFunction : public ScalingFunction {
142 public:
143   KRPPKRPScalingFunction(Color c);
144   ScaleFactor apply(const Position &pos);
145 };
146
147 // King and pawns vs king:
148 class KPsKScalingFunction : public ScalingFunction {
149 public:
150   KPsKScalingFunction(Color c);
151   ScaleFactor apply(const Position &pos);
152 };
153
154 // KBP vs KB:
155 class KBPKBScalingFunction : public ScalingFunction {
156 public:
157   KBPKBScalingFunction(Color c);
158   ScaleFactor apply(const Position &pos);
159 };
160
161 // KBP vs KN:
162 class KBPKNScalingFunction : public ScalingFunction {
163 public:
164   KBPKNScalingFunction(Color c);
165   ScaleFactor apply(const Position &pos);
166 };
167
168 // KNP vs K:
169 class KNPKScalingFunction : public ScalingFunction {
170 public:
171   KNPKScalingFunction(Color c);
172   ScaleFactor apply(const Position &pos);
173 };
174
175 // KP vs KP:
176 class KPKPScalingFunction : public ScalingFunction {
177 public:
178   KPKPScalingFunction(Color c);
179   ScaleFactor apply(const Position &pos);
180 };
181
182
183 ////
184 //// Constants and variables
185 ////
186
187 // Generic "mate lone king" eval:
188 extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX;
189
190 // KBN vs K:
191 extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN;
192
193 // KP vs K:
194 extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP;
195
196 // KR vs KP:
197 extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR;
198
199 // KR vs KB:
200 extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR;
201
202 // KR vs KN:
203 extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR;
204
205 // KQ vs KR:
206 extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ;
207
208 // KBP vs K:
209 extern KBPKScalingFunction ScaleKBPK, ScaleKKBP;
210
211 // KQ vs KRP:
212 extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ;
213
214 // KRP vs KR:
215 extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP;
216
217 // KRPP vs KRP:
218 extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
219
220 // King and pawns vs king:
221 extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
222
223 // KBP vs KB:
224 extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
225
226 // KBP vs KN:
227 extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
228
229 // KNP vs K:
230 extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
231
232 // KP vs KP:
233 extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
234
235
236 ////
237 //// Prototypes
238 ////
239
240 extern void init_bitbases();
241
242
243 #endif // !defined(ENDGAME_H_INCLUDED)