Reserve piece command in protocol specs
[xboard.git] / evalgraph.c
1 /*
2  * evalgraph.c - Evaluation graph back-end part
3  *
4  * Author: Alessandro Scotti (Dec 2005)
5  *
6  * Copyright 2005 Alessandro Scotti
7  *
8  * Enhancments Copyright 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
9  *
10  * ------------------------------------------------------------------------
11  *
12  * GNU XBoard is free software: you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation, either version 3 of the License, or (at
15  * your option) any later version.
16  *
17  * GNU XBoard is distributed in the hope that it will be useful, but
18  * WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20  * General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program. If not, see http://www.gnu.org/licenses/.  *
24  *
25  *------------------------------------------------------------------------
26  ** See the file ChangeLog for a revision history.  */
27
28 // code refactored by HGM to obtain front-end / back-end separation
29
30 #include "config.h"
31
32 #include <stdio.h>
33
34 #if STDC_HEADERS
35 # include <stdlib.h>
36 # include <string.h>
37 #else /* not STDC_HEADERS */
38 # if HAVE_STRING_H
39 #  include <string.h>
40 # else /* not HAVE_STRING_H */
41 #  include <strings.h>
42 # endif /* not HAVE_STRING_H */
43 #endif /* not STDC_HEADERS */
44
45 #include "common.h"
46 #include "frontend.h"
47 #include "backend.h"
48 #include "evalgraph.h"
49
50 /* Module globals */
51 ChessProgramStats_Move * currPvInfo;
52 int currFirst = 0;
53 int currLast = 0;
54 int currCurrent = -1;
55 int range = 1;
56
57 int nWidthPB = 0;
58 int nHeightPB = 0;
59
60 int MarginX = 18;
61 int MarginW = 4;
62 int MarginH = 4;
63
64 // back-end
65 static void
66 DrawLine (int x1, int y1, int x2, int y2, int penType)
67 {
68     DrawSegment( x1, y1, NULL, NULL, PEN_NONE );
69     DrawSegment( x2, y2, NULL, NULL, penType );
70 }
71
72 // back-end
73 static void
74 DrawLineEx (int x1, int y1, int x2, int y2, int penType)
75 {
76     int savX, savY;
77     DrawSegment( x1, y1, &savX, &savY, PEN_NONE );
78     DrawSegment( x2, y2, NULL, NULL, penType );
79     DrawSegment( savX, savY, NULL, NULL, PEN_NONE );
80 }
81
82 // back-end
83 static int
84 GetPvScore (int index)
85 {
86     int score = currPvInfo[ index ].score;
87
88     if( index & 1 ) score = -score; /* Flip score for black */
89
90     return score;
91 }
92
93 char *
94 MakeEvalTitle (char *title)
95 {
96     int score, depth;
97     static char buf[MSG_SIZ];
98
99     if( currCurrent <0 ) return title; // currCurrent = -1 crashed WB on start without ini file!
100     score = currPvInfo[ currCurrent ].score;
101     depth = currPvInfo[ currCurrent ].depth;
102
103     if( depth <=0 ) return title;
104     if( currCurrent & 1 ) score = -score; /* Flip score for black */
105     snprintf(buf, MSG_SIZ, "%s {%d: %s%.2f/%-2d %d}", title, currCurrent/2+1,
106                                 score>0 ? "+" : " ", score/100., depth, (currPvInfo[currCurrent].time+50)/100);
107
108     return buf;
109 }
110
111 // back-end
112 /*
113     For a centipawn value, this function returns the height of the corresponding
114     histogram, centered on the reference axis.
115
116     Note: height can be negative!
117 */
118 static int
119 GetValueY (int value)
120 {
121     if( value < -range*700 ) value = -range*700;
122     if( value > +range*700 ) value = +range*700;
123     if(value > 100*range)  value += (appData.zoom - 1)*100*range; else
124     if(value < -100*range) value -= (appData.zoom - 1)*100*range; else
125         value *= appData.zoom;
126     return (nHeightPB / 2) - (int)(value * (nHeightPB - 2*MarginH) / ((1200. + 200.*appData.zoom)*range));
127 }
128
129 // the brush selection is made part of the DrawLine, by passing a style argument
130 // the wrapper for doing the text output makes this back-end
131 static void
132 DrawAxisSegmentHoriz (int value, Boolean drawValue)
133 {
134     int y = GetValueY( range*value*100 );
135
136     if( drawValue ) {
137         char buf[MSG_SIZ], *b = buf;
138
139         if( value > 0 ) *b++ = '+';
140         sprintf(b, "%d", range*value);
141
142         DrawEvalText(buf, strlen(buf), y);
143     }
144     // [HGM] counts on DrawEvalText to have select transparent background for dotted line!
145     DrawLine( MarginX, y, MarginX + MarginW, y, PEN_BLACK ); // Y-axis tick marks
146     DrawLine( MarginX + MarginW, y, nWidthPB - MarginW, y, PEN_DOTTED ); // hor grid
147 }
148
149 // The DrawLines again must select their own brush.
150 // the initial brush selection is useless? BkMode needed for dotted line and text
151 static void
152 DrawAxis ()
153 {
154     int cy = nHeightPB / 2, space = nHeightPB/(6 + appData.zoom);
155
156     DrawAxisSegmentHoriz( +5, TRUE );
157     DrawAxisSegmentHoriz( +3, space >= 20 );
158     DrawAxisSegmentHoriz( +1, space >= 20 && space*appData.zoom >= 40 );
159     DrawAxisSegmentHoriz(  0, TRUE );
160     DrawAxisSegmentHoriz( -1, space >= 20 && space*appData.zoom >= 40 );
161     DrawAxisSegmentHoriz( -3, space >= 20 );
162     DrawAxisSegmentHoriz( -5, TRUE );
163
164     DrawLine( MarginX + MarginW, cy, nWidthPB - MarginW, cy, PEN_BLACK ); // x-axis
165     DrawLine( MarginX + MarginW, MarginH, MarginX + MarginW, nHeightPB - MarginH, PEN_BLACK ); // y-axis
166 }
167
168 // back-end
169 static void
170 DrawHistogram (int x, int y, int width, int value, int side)
171 {
172     int left, top, right, bottom;
173
174     if( value > -appData.evalThreshold*range && value < +appData.evalThreshold*range ) return;
175
176     left = x;
177     right = left + width + 1;
178
179     if( value > 0 ) {
180         top = GetValueY( value );
181         bottom = y+1;
182     }
183     else {
184         top = y;
185         bottom = GetValueY( value ) + 1;
186     }
187
188
189     if( width == MIN_HIST_WIDTH ) {
190         right--;
191         DrawRectangle( left, top, right, bottom, side, FILLED );
192     }
193     else {
194         DrawRectangle( left, top, right, bottom, side, OPEN );
195     }
196 }
197
198 // back-end
199 static void
200 DrawSeparator (int index, int x)
201 {
202     if( index > 0 ) {
203         if( index == currCurrent ) {
204             DrawLineEx( x, MarginH, x, nHeightPB - MarginH, PEN_BLUEDOTTED );
205         }
206         else if( (index % 20) == 0 ) {
207             DrawLineEx( x, MarginH, x, nHeightPB - MarginH, PEN_DOTTED );
208         }
209     }
210 }
211
212 // made back-end by replacing MoveToEx and LineTo by DrawSegment
213 /* Actually draw histogram as a diagram, cause there's too much data */
214 static void
215 DrawHistogramAsDiagram (int cy, int paint_width, int hist_count)
216 {
217     double step;
218     int i;
219
220     /* Rescale the graph every few moves (as opposed to every move) */
221     hist_count -= hist_count % 8;
222     hist_count += 8;
223     hist_count /= 2;
224
225     step = (double) paint_width / (hist_count + 1);
226
227     for( i=0; i<2; i++ ) {
228         int index = currFirst;
229         int side = (currCurrent + i + 1) & 1; /* Draw current side last */
230         double x = MarginX + MarginW;
231
232         if( (index & 1) != side ) {
233             x += step / 2;
234             index++;
235         }
236
237         DrawSegment( (int) x, cy, NULL, NULL, PEN_NONE );
238
239         index += 2;
240
241         while( index < currLast ) {
242             x += step;
243
244             DrawSeparator( index, (int) x );
245
246             /* Extend line up to current point */
247             if( currPvInfo[index].depth > 0 ) {
248               DrawSegment((int) x, GetValueY( GetPvScore(index) ), NULL, NULL, (side==0 ? PEN_BOLDWHITE: PEN_BOLDBLACK) );
249             }
250
251             index += 2;
252         }
253     }
254 }
255
256 // back-end, delete pen selection
257 static void
258 DrawHistogramFull (int cy, int hist_width, int hist_count)
259 {
260     int i;
261
262 //    SelectObject( hdcPB, GetStockObject(BLACK_PEN) );
263
264     for( i=0; i<hist_count; i++ ) {
265         int index = currFirst + i;
266         int x = MarginX + MarginW + index * hist_width;
267
268         /* Draw a separator every 10 moves */
269         DrawSeparator( index, x );
270
271         /* Draw histogram */
272         if( currPvInfo[i].depth > 0 ) {
273             DrawHistogram( x, cy, hist_width, GetPvScore(index), index & 1 );
274         }
275     }
276 }
277
278 typedef struct {
279     int cy;
280     int hist_width;
281     int hist_count;
282     int paint_width;
283 } VisualizationData;
284
285 // back-end
286 static Boolean
287 InitVisualization (VisualizationData *vd)
288 {
289     Boolean result = FALSE;
290
291     vd->cy = nHeightPB / 2;
292     vd->hist_width = MIN_HIST_WIDTH;
293     vd->hist_count = currLast - currFirst;
294     vd->paint_width = nWidthPB - MarginX - 2*MarginW;
295
296     if( vd->hist_count > 0 ) {
297         result = TRUE;
298
299         /* Compute width */
300         vd->hist_width = vd->paint_width / vd->hist_count;
301
302         if( vd->hist_width > MAX_HIST_WIDTH ) vd->hist_width = MAX_HIST_WIDTH;
303
304         vd->hist_width -= vd->hist_width % 2;
305     }
306
307     return result;
308 }
309
310 // back-end
311 static void
312 DrawHistograms ()
313 {
314     VisualizationData vd;
315
316     if( InitVisualization( &vd ) ) {
317         if( vd.hist_width < MIN_HIST_WIDTH ) {
318             DrawHistogramAsDiagram( vd.cy, vd.paint_width, vd.hist_count );
319         }
320         else {
321             DrawHistogramFull( vd.cy, vd.hist_width, vd.hist_count );
322         }
323     }
324 }
325
326 // back-end
327 int
328 GetMoveIndexFromPoint (int x, int y)
329 {
330     int result = -1;
331     int start_x = MarginX + MarginW;
332     VisualizationData vd;
333
334     if( x >= start_x && InitVisualization( &vd ) ) {
335         /* Almost an hack here... we duplicate some of the paint logic */
336         if( vd.hist_width < MIN_HIST_WIDTH ) {
337             double step;
338
339             vd.hist_count -= vd.hist_count % 8;
340             vd.hist_count += 8;
341             vd.hist_count /= 2;
342
343             step = (double) vd.paint_width / (vd.hist_count + 1);
344             step /= 2;
345
346             result = (int) (0.5 + (double) (x - start_x) / step);
347         }
348         else {
349             result = (x - start_x) / vd.hist_width;
350         }
351     }
352
353     if( result >= currLast ) {
354         result = -1;
355     }
356
357     return result;
358 }
359
360 // init and display part split of so they can be moved to front end
361 void
362 PaintEvalGraph (void)
363 {
364     VariantClass v = gameInfo.variant;
365     range = (gameInfo.holdingsWidth && v != VariantSuper && v != VariantGreat && v != VariantSChess) ? 2 : 1; // [HGM] double range in drop games
366     /* Draw */
367     DrawRectangle(0, 0, nWidthPB, nHeightPB, 2, FILLED);
368     DrawAxis();
369     DrawHistograms();
370 }