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