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 <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 };