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