c717a9f9333130211f5105ef711ad57c8a445fbb
[gnushogi.git] / gnushogi / cursesdsp.c
1 /*
2  * FILE: cursesdsp.c
3  *
4  *     Curses interface for GNU Shogi
5  *
6  * ----------------------------------------------------------------------
7  * Copyright (c) 1993, 1994, 1995 Matthias Mutz
8  * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
9  *
10  * GNU SHOGI is based on GNU CHESS
11  *
12  * Copyright (c) 1988, 1989, 1990 John Stanback
13  * Copyright (c) 1992 Free Software Foundation
14  *
15  * This file is part of GNU SHOGI.
16  *
17  * GNU Shogi is free software; you can redistribute it and/or modify it
18  * under the terms of the GNU General Public License as published by the
19  * Free Software Foundation; either version 3 of the License,
20  * or (at your option) any later version.
21  *
22  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
23  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
24  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
25  * for more details.
26  *
27  * You should have received a copy of the GNU General Public License along
28  * with GNU Shogi; see the file COPYING. If not, see
29  * <http://www.gnu.org/licenses/>.
30  * ----------------------------------------------------------------------
31  */
32
33
34 #include <ctype.h>
35 #include <signal.h>
36 #include <stdio.h>
37
38 #include <sys/param.h>
39 #include <sys/types.h>
40 #include <sys/file.h>
41 #include <curses.h>
42
43 #include "gnushogi.h"
44 #include "cursesdsp.h"
45
46 #define FLUSH_SCANW fflush(stdout), scanw
47
48 int mycnt1, mycnt2;
49
50 #define TAB (58)
51
52 #define VIR_C(s)  ((flag.reverse) ? (NO_COLS - 1 - column(s)) : column(s))
53 #define VIR_R(s)  ((flag.reverse) ? (NO_ROWS - 1 - row(s)) : row(s))
54
55 unsigned short MV[MAXDEPTH];
56 int MSCORE;
57 char *DRAW;
58
59 /* Forward declarations. */
60 /* FIXME: change this name, puh-leeze! */
61
62 static void UpdateCatched(void);
63
64
65 /****************************************
66  * Trivial output functions.
67  ****************************************/
68
69 void
70 ClearEoln(void)
71 {
72     clrtoeol();
73     refresh();
74 }
75
76
77 void
78 Curses_ClearScreen(void)
79 {
80     clear();
81     refresh();
82 }
83
84
85 void
86 ClearMessage(void)
87 {
88     gotoXY(TAB, 6);
89     ClearEoln();
90 }
91
92
93
94 void
95 gotoXY(short x, short y)
96 {
97     move(y - 1, x - 1);
98 }
99
100
101 void
102 Curses_ShowCurrentMove(short pnt, short f, short t)
103 {
104     algbr(f, t, false);
105     gotoXY(TAB, 7);
106     printw("(%2d) %5s ", pnt, mvstr[0]);
107 }
108
109
110 void
111 Curses_ShowDepth(char ch)
112 {
113     gotoXY(TAB, 4);
114     printw(CP[53], Sdepth, ch);   /* Depth = %d%c */
115     ClearEoln();
116 }
117
118
119 void
120 Curses_ShowGameType(void)
121 {
122     if (flag.post)
123     {
124         gotoXY(TAB, 20);
125         printw("%c vs. %c", GameType[black], GameType[white]);
126     }
127 }
128
129
130 void
131 ShowHeader(void)
132 {
133     gotoXY(TAB, 2);
134     printw(CP[69], version, patchlevel);
135 }
136
137
138 void
139 Curses_ShowLine(unsigned short *bstline)
140 {
141 }
142
143
144 void
145 Curses_ShowMessage(char *s)
146 {
147     gotoXY(TAB, 6);
148     printw("%s", s);
149     ClearEoln();
150 }
151
152
153 void
154 Curses_Printf(const char *format, ...)
155 {
156     static char buffer[60];
157     va_list ap;
158     va_start(ap, format);
159     vsnprintf(buffer, sizeof(buffer), format, ap);
160     printw("%s", buffer);
161     va_end(ap);
162 }
163
164
165 void
166 Curses_doRequestInputString(const char* fmt, char* buffer)
167 {
168     FLUSH_SCANW(fmt, buffer);
169 }
170
171
172 void
173 Curses_ShowNodeCnt(long NodeCnt)
174 {
175     gotoXY(TAB, 22);
176     /* printw(CP[90], NodeCnt, (et > 100) ? NodeCnt / (et / 100) : 0); */
177     printw("n = %ld n/s = %ld", 
178            NodeCnt, (et > 100) ? NodeCnt / (et / 100) : 0);
179     ClearEoln();
180 }
181
182
183 void
184 Curses_ShowPatternCount(short side, short n)
185 {
186     if (flag.post)
187     {
188         gotoXY(TAB + 10 + 3 * side, 20);          /* CHECKME */
189
190         if (n >= 0)
191             printw("%3d", n);
192         else
193             printw("   ");
194     }
195 }
196
197
198 void
199 ShowPlayers(void)
200 {
201     gotoXY(5, ((flag.reverse) ? (5 + 2*NO_ROWS) : 2));
202     printw("%s", (computer == white) ? CP[218] : CP[74]);
203     gotoXY(5, ((flag.reverse) ? 2 : (5 + 2*NO_ROWS)));
204     printw("%s", (computer == black) ? CP[218] : CP[74]);
205 }
206
207
208 void
209 ShowPrompt(void)
210 {
211     gotoXY(TAB, 17);
212     printw(CP[121]);     /* Your move is? */
213     ClearEoln();
214 }
215
216
217 void
218 Curses_ShowResponseTime(void)
219 {
220     if (flag.post)
221     {
222         short TCC = TCcount;
223         gotoXY(TAB, 21);
224         /* printw("RT = %ld TCC = %d TCL = %ld EX = %ld ET = %ld TO = %d",
225            ResponseTime, TCC, TCleft, ExtraTime, et, flag.timeout); */
226         printw("%ld, %d, %ld, %ld, %ld, %d",
227                ResponseTime, TCC, TCleft, ExtraTime, et, flag.timeout);
228         ClearEoln();
229     }
230 }
231
232
233 void
234 Curses_ShowResults(short score, unsigned short *bstline, char ch)
235 {
236     unsigned char d, ply;
237
238     if (flag.post)
239     {
240         Curses_ShowDepth(ch);
241         ShowScore(score);
242         d = 7;
243
244         for (ply = 1; bstline[ply] > 0; ply++)
245         {
246             if (ply % 2 == 1)
247             {
248                 gotoXY(TAB, ++d);
249                 ClearEoln();
250             }
251
252             algbr((short) bstline[ply] >> 8, 
253                   (short) bstline[ply] & 0xFF, false);
254             printw("%5s ", mvstr[0]);
255         }
256
257         ClearEoln();
258
259         while (d < 13)
260         {
261             gotoXY(TAB, ++d);
262             ClearEoln();
263         }
264     }
265 }
266
267
268 void
269 ShowScore(short score)
270 {
271     gotoXY(TAB, 5);
272     printw(CP[104], score);
273     ClearEoln();
274 }
275
276
277 void
278 Curses_ShowSidetoMove(void)
279 {
280     gotoXY(TAB, 14);
281     printw("%2d:   %s", 1 + GameCnt / 2, ColorStr[player]);
282     ClearEoln();
283 }
284
285
286 void
287 Curses_ShowStage(void)
288 {
289     gotoXY(TAB, 19);
290     printw("Stage= %2d%c B= %2d W= %2d",
291            stage, flag.tsume?'T':' ', balance[black], balance[white]);
292     ClearEoln();
293 }
294
295
296 /****************************************
297  * End of trivial output routines.
298  ****************************************/
299
300
301 void
302 Curses_Initialize(void)
303 {
304     signal(SIGINT, Curses_Die);
305     signal(SIGQUIT, Curses_Die);
306     initscr();
307     crmode();
308 }
309
310
311 void
312 Curses_ExitShogi(void)
313
314     if (!nolist)
315         ListGame();
316
317     gotoXY(1, 24);
318
319     refresh();
320     nocrmode();
321     endwin();
322
323     exit(0);
324 }
325
326
327
328 void
329 Curses_Die(int sig)
330 {
331     char s[80];
332
333     signal(SIGINT, SIG_IGN);
334     signal(SIGQUIT, SIG_IGN);
335
336     Curses_ShowMessage(CP[31]);     /* Abort? */
337     FLUSH_SCANW("%s", s);
338
339     if (strcmp(s, CP[210]) == 0) /* yes */
340         Curses_ExitShogi();
341
342     signal(SIGINT, Curses_Die);
343     signal(SIGQUIT, Curses_Die);
344 }
345
346
347
348 void
349 Curses_TerminateSearch(int sig)
350 {
351     signal(SIGINT, SIG_IGN);
352     signal(SIGQUIT, SIG_IGN);
353
354     if (!flag.timeout)
355         flag.musttimeout = true;
356
357     Curses_ShowMessage("Terminate Search");
358     flag.bothsides = false;
359     signal(SIGINT, Curses_Die);
360     signal(SIGQUIT, Curses_Die);
361 }
362
363
364
365 void
366 Curses_help(void)
367 {
368     Curses_ClearScreen();
369     /* printw("GNU Shogi ??p? command summary\n"); */
370     printw(CP[40], version, patchlevel);
371     printw("-------------------------------"
372            "---------------------------------\n");
373     /* printw("7g7f      move from 7g to 7f      quit      
374      * Exit Shogi\n"); */
375     printw(CP[158]);
376     /* printw("S6h       move silver to 6h       beep      
377      * turn %s\n", (flag.beep) ? "off" : "on"); */
378     printw(CP[86], (flag.beep) ? CP[92] : CP[93]);
379     /* printw("2d2c+     move to 2c and promote\n"); */
380     printw(CP[128], (flag.material) ? CP[92] : CP[93]);
381     /* printw("P*5e      drop a pawn to 5e       easy      
382      * turn %s\n", (flag.easy) ? "off" : "on"); */
383     printw(CP[173], (flag.easy) ? CP[92] : CP[93]);
384     /* printw("                                  hash      
385      * turn %s\n", (flag.hash) ? "off" : "on"); */
386     printw(CP[174], (flag.hash) ? CP[92] : CP[93]);
387     /* printw("bd        redraw board            reverse   
388      * board display\n"); */
389     printw(CP[130]);
390     /* printw("list      game to shogi.lst       book      
391      * turn %s used %d of %d\n", (Book) ? "off" : "on", book
392       count, booksize); */
393     printw(CP[170], (Book) ? CP[92] : CP[93], bookcount, BOOKSIZE);
394     /* printw("undo      undo last ply           remove    
395      * take back a move\n"); */
396     printw(CP[200]);
397     /* printw("edit      edit board              force     
398      * enter game moves\n"); */
399     printw(CP[153]);
400     /* printw("switch    sides with computer     both      
401      * computer match\n"); */
402     printw(CP[194]);
403     /* printw("black     computer plays black    white     
404      * computer plays white\n"); */
405     printw(CP[202]);
406     /* printw("depth     set search depth        clock     
407      * set time control\n"); */
408     printw(CP[149]);
409     /* printw("hint      suggest a move         post      
410      * turn %s principle variation\n", (flag.post) ? "off" :
411      * "on"); */
412     printw(CP[177], (flag.post) ? CP[92] : CP[93]);
413     /* printw("save      game to file            get       
414      * game from file\n"); */
415     printw(CP[188]);
416     /* printw("random    randomize play          new       
417      * start new game\n"); */
418     printw(CP[181]);
419     gotoXY(10, 20);
420     printw(CP[47], ColorStr[computer]);
421     gotoXY(10, 21);
422     printw(CP[97], ColorStr[opponent]);
423     gotoXY(10, 22);
424     printw(CP[79], MaxResponseTime/100);
425     gotoXY(10, 23);
426     printw(CP[59], (flag.easy) ? CP[93] : CP[92]);
427     gotoXY(25, 23);
428     printw(CP[231], (flag.tsume) ? CP[93] : CP[92]);
429     gotoXY(40, 20);
430     printw(CP[52], MaxSearchDepth);
431     gotoXY(40, 21);
432     printw(CP[100], (dither) ? CP[93] : CP[92]);
433     gotoXY(40, 22);
434     printw(CP[112], (flag.hash) ? CP[93] : CP[92]);
435     gotoXY(40, 23);
436     printw(CP[73]);
437     gotoXY(10, 24);
438     printw(CP[110], (TCflag) ? CP[93] : CP[92],
439            TimeControl.moves[black], 
440            TimeControl.clock[black] / 100, 
441            OperatorTime, MaxSearchDepth);
442
443     refresh();
444
445 #ifdef BOGUS
446     fflush(stdin); /* what is this supposed to do?? */
447 #endif /* BOGUS */
448
449     getchar();
450     Curses_ClearScreen();
451     Curses_UpdateDisplay(0, 0, 1, 0);
452 }
453
454
455 static const short x0[2] = { 54, 2 };
456 static const short y0[2] = { 20, 4 };
457
458
459 /*
460  * Set up a board position. Pieces are entered by typing the piece followed
461  * by the location. For example, N3f will place a knight on square 3f.
462  * P* will put a pawn to the captured pieces.
463  */
464
465 void
466 Curses_EditBoard(void)
467 {
468     short a, c, sq, i;
469     short r = 0;
470     char s[80];
471
472     flag.regularstart = true;
473     Book = BOOKFAIL;
474     Curses_ClearScreen();
475     Curses_UpdateDisplay(0, 0, 1, 0);
476     gotoXY(TAB, 3);
477     printw(CP[29]);
478     gotoXY(TAB, 4);
479     printw(CP[28]);
480     gotoXY(TAB, 5);
481     printw(CP[136]);
482     gotoXY(TAB, 7);
483     printw(CP[64]);
484     a = black;
485
486     do
487     {
488         gotoXY(TAB, 6);
489         printw(CP[60], ColorStr[a]); /* Editing %s */
490         gotoXY(TAB + 24, 7);
491         ClearEoln();
492         FLUSH_SCANW("%s", s);
493
494         if (s[0] == CP[28][0])    /* # */
495         {
496             for (sq = 0; sq < NO_SQUARES; sq++)
497             {
498                 board[sq] = no_piece;
499                 color[sq] = neutral;
500                 DrawPiece(sq);
501             }
502
503             ClearCaptured();
504             UpdateCatched();
505         }
506
507         if (s[0] == CP[136][0])   /* c */
508             a = otherside[a];
509
510         if (s[1] == '*')
511         {
512             for (i = NO_PIECES; i > no_piece; i--)
513             {
514                 if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
515                     break;
516             }
517
518             Captured[a][unpromoted[i]]++;
519             UpdateCatched();
520             c = -1;
521         }
522         else
523         {
524             c = COL_NAME(s[1]);
525             r = ROW_NAME(s[2]);
526         }
527
528         if ((c >= 0) && (c < NO_COLS) && (r >= 0) && (r < NO_ROWS))
529         {
530             sq = locn(r, c);
531
532             for (i = NO_PIECES; i > no_piece; i--)
533             {
534                 if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
535                     break;
536             }
537
538             if (s[3] == '+')
539                 i = promoted[i];
540             else
541                 i = unpromoted[i];
542
543             board[sq] = i;
544             color[sq] = ((board[sq] == no_piece) ? neutral : a);
545             DrawPiece(sq);
546         }
547     }
548     while (s[0] != CP[29][0]);  /* . */
549
550     for (sq = 0; sq < NO_SQUARES; sq++)
551         Mvboard[sq] = ((board[sq] != Stboard[sq]) ? 10 : 0);
552
553     GameCnt = 0;
554     Game50 = 1;
555     ZeroRPT();
556     Sdepth = 0;
557     InitializeStats();
558     Curses_ClearScreen();
559     Curses_UpdateDisplay(0, 0, 1, 0);
560 }
561
562
563
564 static void 
565 UpdateCatched()
566 {
567     short side;
568
569     for (side = black; side <= white; side++)
570     { 
571         short x, y, piece, cside, k;
572
573         cside = flag.reverse ? (side ^ 1) : side;
574         x = x0[cside];
575         y = y0[cside];
576         k = 0;
577
578         for (piece = pawn; piece <= king; piece++)
579         {
580             short n;
581
582             if ((n = Captured[side][piece]))
583             {
584                 gotoXY(x, y); 
585                 printw("%i%c", n, pxx[piece]);
586
587                 if (cside == black) 
588                     y--; 
589                 else 
590                     y++;
591             }
592             else
593             {
594                 k++;
595             }
596         }
597
598         while (k)
599         {
600             k--;
601             gotoXY(x, y);
602             printw("  ");
603
604             if (cside == black) 
605                 y--; 
606             else 
607                 y++;
608         }
609     }
610
611     refresh();
612 }
613
614
615
616 void
617 Curses_SearchStartStuff(short side)
618 {
619     short i;
620
621     signal(SIGINT, Curses_TerminateSearch);
622     signal(SIGQUIT, Curses_TerminateSearch);
623
624     for (i = 4; i < 14; i++)                      /* CHECKME */
625     {
626         gotoXY(TAB, i);
627         ClearEoln();
628     }
629 }
630
631
632
633 void
634 Curses_OutputMove(void)
635 {
636
637     Curses_UpdateDisplay(root->f, root->t, 0, (short) root->flags);
638     gotoXY(TAB, 16);
639
640     if (flag.illegal) 
641     {
642         printw(CP[225]);
643         return;
644     }
645
646     printw(CP[84], mvstr[0]);    /* My move is %s */
647
648     if (flag.beep)
649         putchar(7);
650
651     ClearEoln();
652
653     gotoXY(TAB, 18);
654
655     if (root->flags & draw)
656         printw(CP[58]);
657     else if (root->score == -(SCORE_LIMIT + 999))
658         printw(CP[95]);
659     else if (root->score == SCORE_LIMIT + 998)
660         printw(CP[44]);
661 #ifdef VERYBUGGY
662     else if (root->score < -SCORE_LIMIT)
663         printw(CP[96], SCORE_LIMIT + 999 + root->score - 1);
664     else if (root->score > SCORE_LIMIT)
665         printw(CP[45], SCORE_LIMIT + 998 - root->score - 1);
666 #endif /* VERYBUGGY */
667
668     ClearEoln();
669
670     if (flag.post)
671     {
672         short h, l, t;
673
674         h = TREE;
675         l = 0;
676         t = TREE >> 1;
677
678         while (l != t)
679         {
680             if (Tree[t].f || Tree[t].t)
681                 l = t;
682             else
683                 h = t;
684
685             t = (l + h) >> 1;
686         }
687
688         ShowNodeCnt(NodeCnt);
689         gotoXY(TAB, 23);
690         printw(CP[81], t); /* Max Tree= */
691         ClearEoln();
692     }
693
694     Curses_ShowSidetoMove();
695 }
696
697
698
699 void
700 UpdateClocks(void)
701 {
702     short m, s;
703     long dt;
704
705     if (TCflag)
706     {
707         m = (short) ((dt = (TimeControl.clock[player] - et)) / 6000);
708         s = (short) ((dt - 6000 * (long) m) / 100);
709     }
710     else
711     {
712         m = (short) ((dt = et) / 6000);
713         s = (short) (et - 6000 * (long) m) / 100;
714     }
715
716     if (m < 0)
717         m = 0;
718
719     if (s < 0)
720         s = 0;
721
722     if (player == black)
723         gotoXY(20, (flag.reverse) ? 2 : 23);
724     else
725         gotoXY(20, (flag.reverse) ? 23 : 2);
726
727     /* printw("%d:%02d %ld  ", m, s, dt); */
728     printw("%d:%02d  ", m, s); 
729
730     if (flag.post)
731         ShowNodeCnt(NodeCnt);
732
733     refresh();
734 }
735
736
737
738 void
739 DrawPiece(short sq)
740 {
741     char y;
742     char piece, l, r, p; 
743
744     if (color[sq] == neutral)
745     {
746         l = r = ' ';
747     }
748     else if (flag.reverse ^ (color[sq] == black))
749     {
750         l = '/';
751         r = '\\';
752     } 
753     else
754     {
755         l = '\\', r = '/';
756     }
757
758     piece = board[sq];
759
760     if (is_promoted[(int)piece])
761     {
762         p = '+';
763         y = pxx[unpromoted[(int)piece]];
764     } 
765     else
766     {
767         p = ' ';
768         y = pxx[(int)piece];
769     }
770
771     gotoXY(8 + 5 * VIR_C(sq), 4 + 2 * ((NO_ROWS - 1) - VIR_R(sq)));
772     printw("%c%c%c%c", l, p, y, r);
773 }
774
775
776
777
778 /*
779  * Curses_ShowPostnValue(): must have called ExaminePosition() first
780  */
781
782 void
783 Curses_ShowPostnValue(short sq)
784 {
785     short score;
786
787     gotoXY(4 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq))); /* CHECKME */
788     score = ScorePosition(color[sq]);
789
790     if (color[sq] != neutral)
791 #if defined SAVE_SVALUE
792     {
793         printw("??? ");
794     }
795 #else
796     {
797         printw("%3d ", svalue[sq]);
798     }
799 #endif
800     else
801     {
802         printw("   ");
803     }
804 }
805
806
807
808 void
809 Curses_ShowPostnValues(void)
810 {
811     short sq, score;
812
813     ExaminePosition(opponent);
814
815     for (sq = 0; sq < NO_SQUARES; sq++)
816         Curses_ShowPostnValue(sq);
817
818     score = ScorePosition(opponent);
819     gotoXY(TAB, 5);
820     printw(CP[103], score, 
821            mtl[computer], pscore[computer], GameType[computer],
822            mtl[opponent], pscore[opponent], GameType[opponent]);
823
824     ClearEoln();
825 }
826
827
828
829 void
830 Curses_UpdateDisplay(short f, short t, short redraw, short isspec)
831 {
832     short i, sq, z;
833     int j;
834
835     if (redraw)
836     {
837         ShowHeader();
838         ShowPlayers();
839
840         i = 2;
841         gotoXY(3, ++i);
842
843         printw("    +");
844         for (j=0; j<NO_COLS; j++)
845             printw("----+");
846
847         while (i <= 1 + 2*NO_ROWS)
848         {
849             gotoXY(1, ++i);
850
851             if (flag.reverse)
852                 z = (i / 2) - 1;
853             else
854                 z = NO_ROWS + 2 - ((i + 1) / 2);
855
856             printw("    %c |", ROW_NAME(z+1));
857             for (j=0; j<NO_COLS; j++)
858                 printw("    |");
859
860             gotoXY(3, ++i);
861
862             if (i < 2 + 2*NO_ROWS)
863             {
864                 printw("    +");
865                 for (j=0; j<NO_COLS; j++)
866                     printw("----+");
867             }
868         }
869
870         printw("    +");
871         for (j=0; j<NO_COLS; j++)
872             printw("----+");
873
874         gotoXY(3, 4 + 2*NO_ROWS);
875         printw("    ");
876
877         if (flag.reverse)
878             printw(CP[16]);
879         else
880             printw(CP[15]);
881
882         for (sq = 0; sq < NO_SQUARES; sq++)
883             DrawPiece(sq);
884     }
885     else /* not redraw */
886     {
887         if (f < NO_SQUARES)
888             DrawPiece(f);
889
890         DrawPiece(t & 0x7f);
891     }
892
893     if ((isspec & capture) || (isspec & dropmask) || redraw)
894     {
895         short side;
896
897         for (side = black; side <= white; side++)
898         {
899             short x, y, piece, cside, k;
900             cside = flag.reverse ? (side ^ 1) : side;
901             x = x0[cside];
902             y = y0[cside];
903             k = 0;
904
905             for (piece = pawn; piece <= king; piece++)
906             {
907                 short n;
908
909                 if ((n = Captured[side][piece]))
910                 {
911                     gotoXY(x, y); 
912                     printw("%i%c", n, pxx[piece]);
913
914                     if (cside == black) y--; else y++;
915                 }
916                 else
917                 {
918                     k++;
919                 }
920             }
921
922             while (k)
923             {
924                 k--;
925                 gotoXY(x, y);
926                 printw("  ");
927
928                 if (cside == black) 
929                     y--;
930                 else 
931                     y++;
932             }
933         }
934     }
935
936     refresh();
937 }
938
939
940 extern char *InPtr;
941
942
943 void
944 Curses_ChangeAlphaWindow(void)
945 {
946     Curses_ShowMessage(CP[114]);
947     FLUSH_SCANW("%hd", &WAwindow);
948     Curses_ShowMessage(CP[34]);
949     FLUSH_SCANW("%hd", &BAwindow);
950 }
951
952
953
954 void
955 Curses_ChangeBetaWindow(void)
956 {
957     Curses_ShowMessage(CP[115]);
958     FLUSH_SCANW("%hd", &WBwindow);
959     Curses_ShowMessage(CP[35]);
960     FLUSH_SCANW("%hd", &BBwindow);
961 }
962
963
964
965 void
966 Curses_GiveHint(void)
967 {
968     char s[40];
969
970     if (hint)
971     {
972         algbr((short) (hint >> 8), (short) (hint & 0xFF), false);
973         strcpy(s, CP[198]);  /* try */
974         strcat(s, mvstr[0]);
975         Curses_ShowMessage(s);
976     }
977     else
978     {
979         Curses_ShowMessage(CP[223]);
980     }
981 }
982
983
984
985 void
986 Curses_ChangeSearchDepth(void)
987 {
988     Curses_ShowMessage(CP[150]);
989     FLUSH_SCANW("%hd", &MaxSearchDepth);
990     TCflag = !(MaxSearchDepth > 0);
991 }
992
993
994 void
995 Curses_ChangeHashDepth(void)
996 {
997     Curses_ShowMessage(CP[163]);
998     FLUSH_SCANW("%hd", &HashDepth);
999     Curses_ShowMessage(CP[82]);
1000     FLUSH_SCANW("%hd", &HashMoveLimit);
1001 }
1002
1003
1004 void
1005 Curses_SetContempt(void)
1006 {
1007     Curses_ShowMessage(CP[142]);
1008     FLUSH_SCANW("%hd", &contempt);
1009 }
1010
1011
1012
1013 void
1014 Curses_ChangeXwindow(void)
1015 {
1016     Curses_ShowMessage(CP[208]);
1017     FLUSH_SCANW("%hd", &xwndw);
1018 }
1019
1020
1021
1022 void
1023 Curses_SelectLevel(char *sx)
1024 {
1025     int item;
1026
1027     Curses_ClearScreen();
1028     gotoXY(32, 2);
1029     printw(CP[41], version, patchlevel);
1030     gotoXY(20, 4);
1031     printw(CP[18]);
1032     gotoXY(20, 5);
1033     printw(CP[19]);
1034     gotoXY(20, 6);
1035     printw(CP[20]);
1036     gotoXY(20, 7);
1037     printw(CP[21]);
1038     gotoXY(20, 8);
1039     printw(CP[22]);
1040     gotoXY(20, 9);
1041     printw(CP[23]);
1042     gotoXY(20, 10);
1043     printw(CP[24]);
1044     gotoXY(20, 11);
1045     printw(CP[25]);
1046     gotoXY(20, 12);
1047     printw(CP[26]);
1048     gotoXY(20, 13);
1049     printw(CP[27]);
1050
1051     OperatorTime = 0;
1052     TCmoves = 40;
1053     TCminutes = 5;
1054     TCseconds = 0;
1055
1056     gotoXY(20, 17);
1057     printw(CP[62]);
1058     refresh();
1059     FLUSH_SCANW("%d", &item);
1060
1061     switch(item)
1062     {
1063     case 1:
1064         TCmoves = 40;
1065         TCminutes = 5;
1066         break;
1067
1068     case 2:
1069         TCmoves = 40;
1070         TCminutes = 15;
1071         break;
1072
1073     case 3:
1074         TCmoves = 40;
1075         TCminutes = 30;
1076         break;
1077
1078     case 4:
1079         TCmoves = 80;
1080         TCminutes = 15;
1081         flag.gamein = true;
1082         break;
1083
1084     case 5:
1085         TCmoves = 80;
1086         TCminutes = 30;
1087         flag.gamein = true;
1088         break;
1089
1090     case 6:
1091         TCmoves = 80;
1092         TCminutes = 15;
1093         TCadd = 3000;
1094         flag.gamein = true;
1095         break;
1096
1097     case 7:
1098         TCmoves = 80;
1099         TCminutes = 30;
1100         TCadd = 3000;
1101         break;
1102
1103     case 8:
1104         TCmoves = 1;
1105         TCminutes = 1;
1106         flag.onemove = true;
1107         break;
1108
1109     case 9:
1110         TCmoves = 1;
1111         TCminutes = 15;
1112         flag.onemove = true;
1113         break;
1114
1115     case 10:
1116         TCmoves = 1;
1117         TCminutes = 30;
1118         flag.onemove = true;
1119         break;
1120     }
1121
1122     TCflag = (TCmoves > 0);
1123
1124     TimeControl.clock[black] = TimeControl.clock[white] = 0; 
1125
1126     SetTimeControl();
1127     Curses_ClearScreen();
1128     Curses_UpdateDisplay(0, 0, 1, 0);
1129 }
1130
1131
1132
1133 void
1134 Curses_DoDebug(void)
1135 {
1136     short c, p, sq, tp, tc, tsq, score;
1137     char s[40];
1138
1139     ExaminePosition(opponent);
1140     Curses_ShowMessage(CP[65]);
1141     FLUSH_SCANW("%s", s);
1142     c = neutral;
1143
1144     if ((s[0] == CP[9][0]) || (s[0] == CP[9][1])) /* b B */
1145         c = black;
1146
1147     if ((s[0] == CP[9][2]) || (s[0] == CP[9][3])) /* w W */
1148         c = white;
1149
1150     for (p = king; p > no_piece; p--)
1151     {
1152         if ((s[1] == pxx[p]) || (s[1] == qxx[p]))
1153             break;
1154     }
1155
1156     for (sq = 0; sq < NO_SQUARES; sq++)
1157     {
1158         tp = board[sq];
1159         tc = color[sq];
1160         board[sq] = p;
1161         color[sq] = c;
1162         tsq = PieceList[c][1];
1163         PieceList[c][1] = sq;
1164         Curses_ShowPostnValue(sq);
1165         PieceList[c][1] = tsq;
1166         board[sq] = tp;
1167         color[sq] = tc;
1168     }
1169
1170     score = ScorePosition(opponent);
1171     gotoXY(TAB, 5);
1172     printw(CP[103], score, 
1173            mtl[computer], pscore[computer], GameType[computer],
1174            mtl[opponent], pscore[opponent], GameType[opponent]);
1175
1176     ClearEoln();
1177 }
1178
1179
1180
1181 void
1182 Curses_DoTable(short table[NO_SQUARES])
1183 {
1184     short  sq;
1185     ExaminePosition(opponent);
1186
1187     for (sq = 0; sq < NO_SQUARES; sq++)
1188     {
1189         gotoXY(4 + 5 * VIR_C(sq), 5 + 2 * (7 - VIR_R(sq)));
1190         printw("%3d ", table[sq]);
1191     }
1192
1193
1194
1195