Use AM_MAINTAINER_MODE.
[gnushogi.git] / gnushogi / rawdsp.c
1 /*
2  * FILE: rawdsp.c
3  *
4  * ----------------------------------------------------------------------
5  * Copyright (c) 1993, 1994, 1995 Matthias Mutz
6  * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
7  * Copyright (c) 2008, 2013, 2014 Yann Dirson and the Free Software Foundation
8  *
9  * GNU SHOGI is based on GNU CHESS
10  *
11  * Copyright (c) 1988, 1989, 1990 John Stanback
12  * Copyright (c) 1992 Free Software Foundation
13  *
14  * This file is part of GNU SHOGI.
15  *
16  * GNU Shogi is free software; you can redistribute it and/or modify it
17  * under the terms of the GNU General Public License as published by the
18  * Free Software Foundation; either version 3 of the License,
19  * or (at your option) any later version.
20  *
21  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
23  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
24  * for more details.
25  *
26  * You should have received a copy of the GNU General Public License along
27  * with GNU Shogi; see the file COPYING. If not, see
28  * <http://www.gnu.org/licenses/>.
29  * ----------------------------------------------------------------------
30  *
31  */
32
33 #include <ctype.h>
34 #include <signal.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <sys/param.h>
38 #include <sys/types.h>
39 #include <sys/file.h>
40 #ifndef WIN32
41 #include <poll.h>
42 #include <unistd.h>
43 #endif
44
45 #include "gnushogi.h"
46
47 /****************************************
48  * forward declarations
49  ****************************************/
50
51 static void Raw_UpdateDisplay(short f, short t, short redraw, short isspec);
52
53 /****************************************
54  * Trivial output functions.
55  ****************************************/
56
57 static void
58 Raw_ClearScreen(void)
59 {
60     if (!XSHOGI)
61         printf("\n");
62 }
63
64
65 static void
66 Raw_ShowPrompt(void)
67 {
68     if (!XSHOGI)
69         fputs("\nYour move is? ", stdout);
70 }
71
72
73 static void
74 Raw_ShowCurrentMove(short pnt, short f, short t)
75 {
76 }
77
78
79 static void
80 Raw_ShowDepth(char ch)
81 {
82     if (!XSHOGI)
83         printf("Depth= %d%c \n", Sdepth, ch);
84 }
85
86
87 static void
88 Raw_ShowGameType(void)
89 {
90     if (flag.post)
91         printf("%c vs. %c\n", GameType[black], GameType[white]);
92 }
93
94
95 static void
96 Raw_ShowLine(unsigned short *bstline)
97 {
98     int i;
99
100     for (i = 1; bstline[i] > 0; i++)
101     {
102         if ((i > 1) && (i % 8 == 1))
103             printf("\n                          ");
104
105         algbr((short)(bstline[i] >> 8), (short)(bstline[i] & 0xFF), false);
106         printf("%5s ", mvstr[0]);
107     }
108
109     printf("\n");
110 }
111
112
113 static void
114 Raw_ShowMessage(char *s)
115 {
116     if (!XSHOGI)
117         printf("%s\n", s);
118 }
119
120
121 static void
122 Raw_AlwaysShowMessage(const char *format, ...)
123 {
124     va_list ap;
125     va_start(ap, format);
126     vprintf(format, ap);
127     printf("\n");
128     va_end(ap);
129 }
130
131
132 static void
133 Raw_Printf(const char *format, ...)
134 {
135     va_list ap;
136     va_start(ap, format);
137     vprintf(format, ap);
138     va_end(ap);
139 }
140
141
142 static void
143 Raw_doRequestInputString(const char* fmt, char* buffer)
144 {
145     scanf(fmt, buffer);
146 }
147
148
149 static int
150 Raw_GetString(char* sx)
151 {
152     int eof = 0;
153     char *nl;
154     sx[0] = '\0';
155
156     while(!eof && !sx[0])
157         eof = (fgets(sx, 80, stdin) == NULL);
158
159     /* remove any trailing newline */
160     nl = strchr(sx, '\n');
161     if (nl)
162         nl[0] = '\0';
163
164     return eof;
165 }
166
167
168 static void
169 Raw_ShowNodeCnt(long NodeCnt)
170 {
171     printf("Nodes = %ld Nodes/sec = %ld\n",
172            NodeCnt, (((et) ? ((NodeCnt * 100) / et) : 0)));
173 }
174
175
176 static void
177 Raw_ShowPatternCount(short side, short n)
178 {
179     if (flag.post)
180         printf("%s%s matches %d pattern(s)\n", xboard ? "# " : "" , ColorStr[side], n);
181 }
182
183
184 static void
185 Raw_ShowResponseTime(void)
186 {
187 }
188
189
190 static void
191 Raw_ShowResults(short score, unsigned short *bstline, char ch)
192 {
193     if (flag.post && (xboard || !XSHOGI))
194     {
195         ElapsedTime(2);
196         printf("%2d%c %6d %4ld %8ld  ",
197                Sdepth, ch, score, et / 100, NodeCnt);
198         Raw_ShowLine(bstline);
199     }
200 }
201
202
203 static void
204 Raw_ShowSidetoMove(void)
205 {
206 }
207
208
209 static void
210 Raw_ShowStage(void)
211 {
212     printf("stage = %d\n", stage);
213     printf("balance[black] = %d balance[white] = %d\n",
214            balance[black], balance[white]);
215 }
216
217 /****************************************
218  * End of trivial output routines.
219  ****************************************/
220
221 static void
222 Raw_Initialize(void)
223 {
224     mycnt1 = mycnt2 = 0;
225
226     if (XSHOGI)
227     {
228 #ifdef WIN32
229         /* needed because of inconsistency between MSVC run-time system and gcc includes */
230         setbuf(stdout, NULL);
231 #else
232 #ifdef HAVE_SETVBUF
233         setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
234 #else
235 #  ifdef HAVE_SETLINEBUF
236         setlinebuf(stdout);
237 #  else
238 #    error "Need setvbuf() or setlinebuf() to compile gnushogi!"
239 #  endif
240 #endif
241 #endif
242         printf("GNU Shogi %s\n", PACKAGE_VERSION);
243     }
244
245     if (hard_time_limit)
246     {
247         if (!TCflag && (MaxResponseTime == 0))
248             MaxResponseTime = 15L * 100L;
249     }
250 }
251
252
253 static void
254 Raw_ExitShogi(void)
255 {
256     /* CHECKME: what purpose does this next statement serve? */
257     signal(SIGTERM, SIG_IGN);
258
259     if (!nolist)
260         ListGame();
261
262     exit(0);
263 }
264
265
266 static void
267 Raw_TerminateSearch(int sig)
268 {
269 #ifdef INTERRUPT_TEST
270     ElapsedTime(INIT_INTERRUPT_MODE);
271 #endif
272
273     if (!flag.timeout)
274         flag.back = true; /* previous: flag.timeout = true; */
275
276     flag.bothsides = false;
277 }
278
279
280 static void
281 Raw_help(void)
282 {
283     Raw_ClearScreen();
284     printf("GNU Shogi %s command summary\n", PACKAGE_VERSION);
285     printf("----------------------------------------------------------------\n");
286     printf("7g7f      move from 7g to 7f      quit      Exit Shogi\n");
287     printf("S6h       move silver to 6h       beep      turn %s\n",
288            (flag.beep) ? "OFF" : "ON");
289     printf("2d2c+     move to 2c and promote  material  turn %s\n",
290            (flag.material) ? "OFF" : "ON");
291     printf("P*5e      drop pawn to 5e         easy      turn %s\n",
292            (flag.easy) ? "OFF" : "ON");
293     printf("tsume     toggle tsume mode       hash      turn %s\n",
294            (flag.hash) ? "OFF" : "ON");
295     printf("bd        redraw board            reverse   board display\n");
296     printf("list      game to shogi.lst       book      turn %s used %d of %d\n",
297            (Book) ? "OFF" : "ON", bookcount, booksize);
298     printf("undo      undo last ply           remove    take back a move\n");
299     printf("edit      edit board              force     toggle manual move mode\n");
300     printf("switch    sides with computer     both      computer match\n");
301     printf("black     computer plays black    white     computer plays white\n");
302     printf("sd        set search depth        clock     set time control\n");
303     printf("post      principle variation     hint      suggest a move\n");
304     printf("save      game to file            get       game from file\n");
305     printf("xsave     pos. to xshogi file     xget      pos. from xshogi file\n");
306     printf("random    randomize play          new       start new game\n");
307     printf("setup                             first     \n");
308     printf("go        computer plays now      material  turn %s\n",
309            flag.material ? "OFF" : "ON");
310     printf("level     time control            gamein    \n");
311     printf("time      set engine clock        otime     set opponent clock\n");
312     printf("Awindow                           Bwindow     \n");
313     printf("rcptr     turn %3s                bsave     book save\n",
314            flag.rcptr ? "OFF" : "ON ");
315     printf("hashdepth                         hard      turn easy OFF\n");
316     printf("contempt                          xwndw                  \n");
317     printf("rv        turn %3s                coords    turn %s\n",
318            flag.rv ? "OFF" : "ON ", flag.coords ? "OFF" : "ON");
319     printf("stars     turn %3s                moves                  \n",
320            flag.stars ? "OFF" : "ON ");
321     printf("test                              p                      \n");
322     printf("debug                             depth     alias for 'sd'\n");
323     printf("----------------------------------------------------------------\n");
324     printf("Computer: %-12s Opponent:            %s\n",
325            ColorStr[computer], ColorStr[opponent]);
326     printf("Depth:    %-12d Response time:       %ld sec\n",
327            MaxSearchDepth, MaxResponseTime/100);
328     printf("Random:   %-12s Easy mode:           %s\n",
329            (dither) ? "ON" : "OFF", (flag.easy) ? "ON" : "OFF");
330     printf("Beep:     %-12s Transposition file:  %s\n",
331            (flag.beep) ? "ON" : "OFF", (flag.hash) ? "ON" : "OFF");
332     printf("Tsume:    %-12s Force:               %s\n",
333            (flag.tsume) ? "ON" : "OFF", (flag.force) ? "ON" : "OFF");
334     printf("Time Control %s %d moves %ld sec %d add %d depth\n",
335            (TCflag) ? "ON" : "OFF",
336            TimeControl.moves[black], TimeControl.clock[black] / 100,
337            TCadd/100, MaxSearchDepth);
338 }
339
340
341 /*
342  * Set up a board position. Pieces are entered by typing the piece followed
343  * by the location. For example, Nf3 will place a knight on square f3.
344  */
345 static void
346 Raw_EditBoard(void)
347 {
348     short a, r, c, sq, i, found;
349     char s[80];
350
351     flag.regularstart = true;
352     Book = BOOKFAIL;
353     Raw_ClearScreen();
354     Raw_UpdateDisplay(0, 0, 1, 0);
355     printf(".   Exit to main\n");
356     printf("#   Clear board\n");
357     printf("c   Change sides\n");
358     printf("enter piece & location:\n");
359
360     a = black;
361
362     while(1)
363     {
364         scanf("%s", s);
365         found = 0;
366
367         if (s[0] == '.')
368             break;
369
370         if (s[0] == '#')
371         {
372             for (sq = 0; sq < NO_SQUARES; sq++)
373             {
374                 board[sq] = no_piece;
375                 color[sq] = neutral;
376             }
377
378             ClearCaptured();
379             continue;
380         }
381
382         if (s[0] == 'c') {
383             a = otherside[a];
384             continue;
385         }
386
387         if (s[1] == '*')
388         {
389             for (i = pawn; i <= king; i++)
390             {
391                 if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
392                 {
393                     Captured[a][i]++;
394                     found = 1;
395                     break;
396                 }
397             }
398             if (!found)
399                 printf("# Invalid piece type '%c'\n", s[0]);
400             continue;
401         }
402
403         c = COL_NUM(s[1]);
404         r = ROW_NUM(s[2]);
405
406         if ((c < 0) || (c >= NO_COLS) || (r < 0) || (r >= NO_ROWS)) {
407             printf("# Out-of-board position '%c%c'\n", s[1], s[2]);
408             continue;
409         }
410
411         sq = locn(r, c);
412
413         for (i = no_piece; i <= king; i++)
414         {
415             if ((s[0] == pxx[i]) || (s[0] == qxx[i]))
416             {
417                 color[sq] = a;
418                 if (s[3] == '+')
419                     board[sq] = promoted[i];
420                 else
421                     board[sq] = i;
422
423                 found = 1;
424                 break;
425             }
426         }
427
428         if (!found)
429             printf("# Invalid piece type '%c'\n", s[0]);
430     }
431
432     for (sq = 0; sq < NO_SQUARES; sq++)
433         Mvboard[sq] = ((board[sq] != Stboard[sq]) ? 10 : 0);
434
435     GameCnt = 0;
436     Game50 = 1;
437     ZeroRPT();
438     Sdepth = 0;
439     InitializeStats();
440     Raw_ClearScreen();
441     Raw_UpdateDisplay(0, 0, 1, 0);
442 }
443
444
445 /*
446  * Set up a board position.
447  * Nine lines of nine characters are used to setup the board. 9a-1a is the
448  * first line. White pieces are  represented  by  uppercase characters.
449  */
450 static void
451 Raw_SetupBoard(void)
452 {
453     short r, c, sq, i;
454     char ch;
455     char s[80];
456
457     NewGame();
458
459     fgets(s, 80, stdin);            /* skip "setup" command */
460
461     for (r = NO_ROWS - 1; r >= 0; r--)
462     {
463         fgets(s, 80, stdin);
464
465         for (c = 0; c <= (NO_COLS - 1); c++)
466         {
467             ch = s[c];
468             sq = locn(r, c);
469             color[sq] = neutral;
470             board[sq] = no_piece;
471
472             for (i = no_piece; i <= king; i++)
473             {
474                 if (ch == pxx[i])
475                 {
476                     color[sq] = white;
477                     board[sq] = i;
478                     break;
479                 }
480                 else if (ch == qxx[i])
481                 {
482                     color[sq] = black;
483                     board[sq] = i;
484                     break;
485                 }
486             }
487         }
488     }
489
490     for (sq = 0; sq < NO_SQUARES; sq++)
491         Mvboard[sq] = ((board[sq] != Stboard[sq]) ? 10 : 0);
492
493     InitializeStats();
494     Raw_ClearScreen();
495     Raw_UpdateDisplay(0, 0, 1, 0);
496     fputs("Setup successful\n", stdout);
497 }
498
499
500 static void
501 Raw_SearchStartStuff(short side)
502 {
503     if (flag.post)
504     {
505         printf("\nMove# %d    Target = %ld    Clock: %ld\n",
506                GameCnt/2 + 1,
507                ResponseTime, TimeControl.clock[side]);
508     }
509 }
510
511
512 static void
513 Raw_OutputMove(void)
514 {
515     if (flag.illegal)
516     {
517         printf("Illegal position.\n");
518         return;
519     }
520
521     if (mvstr[0][0] == '\0')
522         goto nomove;
523
524     mycnt1++;
525     if (XSHOGI && xboard) /* xboard: print move in XBoard format, with 'move' prefix */
526         printf("move %s\n", mvstr[0]);
527     else if (XSHOGI)
528         /* add remaining time in milliseconds to xshogi */
529         printf("%d. ... %s %ld\n", mycnt1, mvstr[0],
530                (TimeControl.clock[player] - et) * 10);
531     else
532         printf("%d. ... %s\n", mycnt1, mvstr[0]);
533
534  nomove:
535     if ((root->flags & draw) || (root->score == -(SCORE_LIMIT + 999))
536         || (root->score == (SCORE_LIMIT + 998)))
537         goto summary;
538
539     if (flag.post)
540     {
541         short h, l, t;
542
543         h = TREE;
544         l = 0;
545         t = TREE >> 1;
546
547         while (l != t)
548         {
549             if (Tree[t].f || Tree[t].t)
550                 l = t;
551             else
552                 h = t;
553
554             t = (l + h) >> 1;
555         }
556
557         printf("Gen %ld Node %ld Tree %d Eval %ld Rate %ld EC %d/%d RS hi %ld lo %ld \n", GenCnt, NodeCnt, t, EvalNodes,
558                (et > 100) ? (NodeCnt / (et / 100)) : 0,
559                EADD, EGET, reminus, replus);
560
561         printf("Hin/Hout/Tcol/Coll/Fin/Fout = %ld/%ld/%ld/%ld/%ld/%ld\n",
562                HashAdd, HashCnt, THashCol, HashCol, FHashCnt, FHashAdd);
563     }
564
565     Raw_UpdateDisplay(root->f, root->t, 0, root->flags);
566
567     if (!XSHOGI)
568     {
569         printf("My move is: %5s\n", mvstr[0]);
570
571         if (flag.beep)
572             printf("%c", 7);
573     }
574
575  summary:
576     if (root->flags & draw)
577         fputs("Drawn game!\n", stdout);
578     else if (root->score == -(SCORE_LIMIT + 999))
579         printf("%s mates!\n", ColorStr[opponent]);
580     else if (root->score == (SCORE_LIMIT + 998))
581         printf("%s mates!\n", ColorStr[computer]);
582 #ifdef VERYBUGGY
583     else if (!XSHOGI && (root->score < -SCORE_LIMIT))
584         printf("%s%s has a forced mate in %d moves!\n", xboard ? "# " : "",
585                ColorStr[opponent], SCORE_LIMIT + 999 + root->score - 1);
586     else if (!XSHOGI && (root->score > SCORE_LIMIT))
587         printf("%s%s has a forced mate in %d moves!\n", xboard ? "# " : "",
588                ColorStr[computer], SCORE_LIMIT + 998 - root->score - 1);
589 #endif /* VERYBUGGY */
590 }
591
592
593 static void
594 Raw_UpdateClocks(void)
595 {
596 }
597
598
599 static void
600 Raw_UpdateDisplay(short f, short t, short redraw, short isspec)
601 {
602
603     short r, c, l, m;
604
605     if (redraw && !XSHOGI)
606     {
607         printf("\n");
608         r = (short)(TimeControl.clock[black] / 6000);
609         c = (short)((TimeControl.clock[black] % 6000) / 100);
610         l = (short)(TimeControl.clock[white] / 6000);
611         m = (short)((TimeControl.clock[white] % 6000) / 100);
612         printf("Black %d:%02d  White %d:%02d\n", r, c, l, m);
613         printf("\n");
614
615         for (r = (NO_ROWS - 1); r >= 0; r--)
616         {
617             for (c = 0; c <= (NO_COLS - 1); c++)
618             {
619                 char pc;
620                 l = ((flag.reverse)
621                      ? locn((NO_ROWS - 1) - r, (NO_COLS - 1) - c)
622                      : locn(r, c));
623                 pc = (is_promoted[board[l]] ? '+' : ' ');
624
625                 if (color[l] == neutral)
626                     printf(" -");
627                 else if (color[l] == black)
628                     printf("%c%c", pc, qxx[board[l]]);
629                 else
630                     printf("%c%c", pc, pxx[board[l]]);
631             }
632
633             printf("\n");
634         }
635
636         printf("\n");
637         {
638             short side;
639
640             for (side = black; side <= white; side++)
641             {
642                 short piece, c;
643                 printf((side == black)?"black ":"white ");
644
645                 for (piece = pawn; piece <= king; piece++)
646                 {
647                     if ((c = Captured[side][piece]))
648                         printf("%i%c ", c, pxx[piece]);
649                 }
650
651                 printf("\n");
652             }
653         }
654     }
655 }
656
657
658 static void
659 Raw_ChangeAlphaWindow(void)
660 {
661     printf("WAwindow: ");
662     scanf("%hd", &WAwindow);
663     printf("BAwindow: ");
664     scanf("%hd", &BAwindow);
665 }
666
667
668 static void
669 Raw_ChangeBetaWindow(void)
670 {
671     printf("WBwindow: ");
672     scanf("%hd", &WBwindow);
673     printf("BBwindow: ");
674     scanf("%hd", &BBwindow);
675 }
676
677
678 static void
679 Raw_GiveHint(void)
680 {
681     if (hint)
682     {
683         algbr((short) (hint >> 8), (short) (hint & 0xFF), false);
684         printf("Hint: %s\n", mvstr[0]);
685     }
686     else
687         fputs("I have no idea.\n", stdout);
688 }
689
690
691 static void
692 Raw_SelectLevel(char *sx)
693 {
694     /* FIXME: NO_SQUARES is nonsense here */
695     char T[NO_SQUARES + 1], *p;
696
697     strncpy(T, sx, NO_SQUARES);
698     T[NO_SQUARES] = '\0';
699
700
701     if (!xboard) {
702         /* if line empty, ask for input */
703         if (!T[0])
704         {
705             fputs("Enter #moves #minutes: ", stdout);
706             fgets(T, NO_SQUARES + 1, stdin);
707         }
708     
709         /* skip blackspace */
710         for (p = T; *p == ' '; p++) ;
711     
712         /* could be moves or a fischer clock */
713         if (*p == 'f')
714         {
715             /* its a fischer clock game */
716             char *q;
717             p++;
718             TCminutes = (short)strtol(p, &q, 10);
719             TCadd = (short)strtol(q, NULL, 10) *100;
720             TCseconds = 0;
721             TCmoves = 50;
722         }
723         else
724         {
725             /* regular game */
726             char *q;
727             TCadd = 0;
728             TCmoves = (short)strtol(p, &q, 10);
729             TCminutes = (short)strtol(q, &q, 10);
730     
731             if (*q == ':')
732                 TCseconds = (short)strtol(q + 1, (char **) NULL, 10);
733             else
734                 TCseconds = 0;
735     
736     #ifdef OPERATORTIME
737             fputs("Operator time (hundredths) = ", stdout);
738             scanf("%hd", &OperatorTime);
739     #endif
740     
741             if (TCmoves == 0)
742             {
743                 TCflag = false;
744                 MaxResponseTime = TCminutes*60L * 100L + TCseconds * 100L;
745                 TCminutes = TCseconds = 0;
746             }
747             else
748             {
749                 TCflag = true;
750                 MaxResponseTime = 0;
751             }
752         }
753     } else {
754         int min, sec=0, inc, mps;
755         /* parse regular "level MPS TC INC" command of WB protocol */
756         sscanf(sx, "%d %d %d", &mps, &min, &inc) == 3 ||
757         sscanf(sx, "%d %d:%d %d", &mps, &min, &sec, &inc);
758         TCminutes = min; TCseconds = sec;
759         TCadd = inc*100; TCmoves = mps ? mps : 50;
760         MaxResponseTime = 0; TCflag = true;
761     }
762
763     TimeControl.clock[black] = TimeControl.clock[white] = 0;
764     SetTimeControl();
765
766     if (XSHOGI)
767     {
768         printf("Clocks: %ld %ld\n",
769                TimeControl.clock[black] * 10,
770                TimeControl.clock[white] * 10);
771     }
772 }
773
774
775 static void
776 Raw_ChangeSearchDepth(char *sx)
777 {
778     char buf[80+1];
779     strncpy(buf, sx, 80); buf[80] = '\0';
780     /* if line empty, ask for input */
781     if (!buf[0]) {
782         printf("depth = ");
783         fgets(buf, 80+1, stdin);
784     }
785     sscanf(buf, "%hd", &MaxSearchDepth);
786     TCflag = !(MaxSearchDepth > 0);
787 }
788
789
790 static void
791 Raw_ChangeHashDepth(void)
792 {
793     printf("hashdepth = ");
794     scanf("%hd", &HashDepth);
795     printf("MoveLimit = ");
796     scanf("%hd", &HashMoveLimit);
797 }
798
799
800 static void
801 Raw_SetContempt(void)
802 {
803     printf("contempt = ");
804     scanf("%hd", &contempt);
805 }
806
807
808 static void
809 Raw_ChangeXwindow(void)
810 {
811     printf("xwndw = ");
812     scanf("%hd", &xwndw);
813 }
814
815
816 /*
817  * Raw_ShowPostnValue(short sq)
818  * must have called ExaminePosition() first
819  */
820 static void
821 Raw_ShowPostnValue(short sq)
822 {
823     (void) ScorePosition(color[sq]);
824
825     if (color[sq] != neutral)
826     {
827 #if defined SAVE_SVALUE
828         printf("???%c ", (color[sq] == white)?'b':'w');
829 #else
830         printf("%3d%c ", svalue[sq], (color[sq] == white)?'b':'w');
831 #endif
832     }
833     else
834     {
835         printf(" *   ");
836     }
837 }
838
839
840 static void
841 Raw_DoDebug(void)
842 {
843     short c, p, sq, tp, tc, tsq, score, j, k;
844     char s[40];
845
846     ExaminePosition(opponent);
847     Raw_ShowMessage("Enter piece: ");
848     scanf("%s", s);
849     c = neutral;
850
851     if ((s[0] == 'b') || (s[0] == 'B'))
852         c = black;
853
854     if ((s[0] == 'w') || (s[0] == 'W'))
855         c = white;
856
857     for (p = king; p > no_piece; p--)
858     {
859         if ((s[1] == pxx[p]) || (s[1] == qxx[p]))
860             break;
861     }
862
863     if (p > no_piece)
864     {
865         for (j = (NO_ROWS - 1); j >= 0; j--)
866         {
867             for (k = 0; k < (NO_COLS); k++)
868             {
869                 sq = j*(NO_COLS) + k;
870                 tp = board[sq];
871                 tc = color[sq];
872                 board[sq] = p;
873                 color[sq] = c;
874                 tsq = PieceList[c][1];
875                 PieceList[c][1] = sq;
876                 Raw_ShowPostnValue(sq);
877                 PieceList[c][1] = tsq;
878                 board[sq] = tp;
879                 color[sq] = tc;
880             }
881
882             printf("\n");
883         }
884     }
885
886     score = ScorePosition(opponent);
887
888     for (j = (NO_ROWS - 1); j >= 0; j--)
889     {
890         for (k = 0; k < (NO_COLS); k++)
891         {
892             sq = j*(NO_COLS) + k;
893
894             if (color[sq] != neutral)
895             {
896 #if defined SAVE_SVALUE
897                 printf("%?????%c ", (color[sq] == white)?'b':'w');
898 #else
899                 printf("%5d%c ", svalue[sq], (color[sq] == white)?'b':'w');
900 #endif
901             }
902             else
903             {
904                 printf("    *  ");
905             }
906         }
907
908         printf("\n");
909     }
910
911     printf("stage = %d\n", stage);
912     printf("S%d m%d ps%d gt%c m%d ps%d gt%c", score,
913            mtl[computer], pscore[computer], GameType[computer],
914            mtl[opponent], pscore[opponent], GameType[opponent]);
915 }
916
917
918 static void
919 Raw_DoTable(short table[NO_SQUARES])
920 {
921     short  sq, j, k;
922     ExaminePosition(opponent);
923
924     for (j = (NO_ROWS - 1); j >= 0; j--)
925     {
926         for (k = 0; k < NO_COLS; k++)
927         {
928             sq = j*(NO_ROWS) + k;
929             printf("%3d ", table[sq]);
930         }
931
932         printf("\n");
933     }
934 }
935
936
937 static void
938 Raw_ShowPostnValues(void)
939 {
940     short sq, score, j, k;
941     ExaminePosition(opponent);
942
943     for (j = (NO_ROWS - 1); j >= 0; j--)
944     {
945         for (k = 0; k < NO_COLS; k++)
946         {
947             sq = j * NO_COLS + k;
948             Raw_ShowPostnValue(sq);
949         }
950
951         printf("\n");
952     }
953
954     score = ScorePosition(opponent);
955     printf("S%d m%d ps%d gt%c m%d ps%d gt%c", score,
956            mtl[computer], pscore[computer], GameType[computer],
957            mtl[opponent], pscore[opponent], GameType[opponent]);
958     printf("\nhung black %d hung white %d\n", hung[black], hung[white]);
959 }
960
961
962 static void
963 Raw_PollForInput(void)
964 {
965 #ifdef WIN32
966     DWORD cnt;
967     if (!PeekNamedPipe(GetStdHandle(STD_INPUT_HANDLE), NULL, 0, NULL, &cnt, NULL))
968         cnt = 1;
969 #else
970     static struct pollfd pollfds[1] = { [0] = { .fd = STDIN_FILENO,
971                                                 .events = POLLIN } };
972     int cnt = poll(pollfds, sizeof(pollfds)/sizeof(pollfds[0]), 0);
973     if (cnt < 0) {
974         perror("polling standard input");
975         Raw_ExitShogi();
976     }
977 #endif
978     if (cnt) { /* if anything to read, or error occured */
979         if (!flag.timeout)
980             flag.back = true; /* previous: flag.timeout = true; */
981         flag.bothsides = false;
982     }
983 }
984
985 struct display raw_display =
986 {
987     .ChangeAlphaWindow    = Raw_ChangeAlphaWindow,
988     .ChangeBetaWindow     = Raw_ChangeBetaWindow,
989     .ChangeHashDepth      = Raw_ChangeHashDepth,
990     .ChangeSearchDepth    = Raw_ChangeSearchDepth,
991     .ChangeXwindow        = Raw_ChangeXwindow,
992     .ClearScreen          = Raw_ClearScreen,
993     .DoDebug              = Raw_DoDebug,
994     .DoTable              = Raw_DoTable,
995     .EditBoard            = Raw_EditBoard,
996     .ExitShogi            = Raw_ExitShogi,
997     .GiveHint             = Raw_GiveHint,
998     .Initialize           = Raw_Initialize,
999     .ShowNodeCnt          = Raw_ShowNodeCnt,
1000     .OutputMove           = Raw_OutputMove,
1001     .PollForInput         = Raw_PollForInput,
1002     .SetContempt          = Raw_SetContempt,
1003     .SearchStartStuff     = Raw_SearchStartStuff,
1004     .SelectLevel          = Raw_SelectLevel,
1005     .ShowCurrentMove      = Raw_ShowCurrentMove,
1006     .ShowDepth            = Raw_ShowDepth,
1007     .ShowGameType         = Raw_ShowGameType,
1008     .ShowLine             = Raw_ShowLine,
1009     .ShowMessage          = Raw_ShowMessage,
1010     .AlwaysShowMessage    = Raw_AlwaysShowMessage,
1011     .Printf               = Raw_Printf,
1012     .doRequestInputString = Raw_doRequestInputString,
1013     .GetString            = Raw_GetString,
1014     .SetupBoard           = Raw_SetupBoard,
1015     .ShowPatternCount     = Raw_ShowPatternCount,
1016     .ShowPostnValue       = Raw_ShowPostnValue,
1017     .ShowPostnValues      = Raw_ShowPostnValues,
1018     .ShowPrompt           = Raw_ShowPrompt,
1019     .ShowResponseTime     = Raw_ShowResponseTime,
1020     .ShowResults          = Raw_ShowResults,
1021     .ShowSidetoMove       = Raw_ShowSidetoMove,
1022     .ShowStage            = Raw_ShowStage,
1023     .TerminateSearch      = Raw_TerminateSearch,
1024     .UpdateClocks         = Raw_UpdateClocks,
1025     .UpdateDisplay        = Raw_UpdateDisplay,
1026     .help                 = Raw_help,
1027 };