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