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