gomoku/main.c

   1 /*      $NetBSD: main.c,v 1.27 2016/06/12 02:15:26 dholland Exp $       */
   2
   3 /*
   4  * Copyright (c) 1994
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Ralph Campbell.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include <sys/cdefs.h>
  36 #ifndef lint
  37 __COPYRIGHT("@(#) Copyright (c) 1994\
  38  The Regents of the University of California.  All rights reserved.");
  39 #endif /* not lint */
  40
  41 #ifndef lint
  42 #if 0
  43 static char sccsid[] = "@(#)main.c      8.4 (Berkeley) 5/4/95";
  44 #else
  45 __RCSID("$NetBSD: main.c,v 1.27 2016/06/12 02:15:26 dholland Exp $");
  46 #endif
  47 #endif /* not lint */
  48
  49 #include <curses.h>
  50 #include <err.h>
  51 #include <limits.h>
  52 #include <signal.h>
  53 #include <stdarg.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <time.h>
  57 #include <unistd.h>
  58
  59 #include "gomoku.h"
  60
  61 #define USER    0               /* get input from standard input */
  62 #define PROGRAM 1               /* get input from program */
  63 #define INPUTF  2               /* get input from a file */
  64
  65 #define LOGIN_NAME_MAX 73
  66
  67 int     interactive = 1;        /* true if interactive */
  68 int     debug;                  /* true if debugging */
  69 static int test;                /* both moves come from 1: input, 2: computer */
  70 static char *prog;              /* name of program */
  71 static char user[LOGIN_NAME_MAX]; /* name of player */
  72 static FILE *debugfp;           /* file for debug output */
  73 static FILE *inputfp;           /* file for debug input */
  74
  75 const char      pdir[4]         = "-\\|/";
  76
  77 struct  spotstr board[BAREA];           /* info for board */
  78 struct  combostr frames[FAREA];         /* storage for all frames */
  79 struct  combostr *sortframes[2];        /* sorted list of non-empty frames */
  80 u_char  overlap[FAREA * FAREA];         /* true if frame [a][b] overlap */
  81 short   intersect[FAREA * FAREA];       /* frame [a][b] intersection */
  82 int     movelog[BSZ * BSZ];             /* log of all the moves */
  83 int     movenum;                        /* current move number */
  84 const char      *plyr[2];                       /* who's who */
  85
  86 static int readinput(FILE *);
  87 static void misclog(const char *, ...) __printflike(1, 2);
  88 static void quit(void) __dead;
  89 static void quitsig(int) __dead;
  90
  91 int
  92 main(int argc, char **argv)
  93 {
  94         char buf[128];
  95         char fname[PATH_MAX];
  96         char *tmp;
  97         int color, curmove, i, ch;
  98         int input[2];
  99
 100         /* Revoke setgid privileges */
 101         setgid(getgid());
 102
 103         tmp = getlogin();
 104         if (tmp) {
 105                 strlcpy(user, tmp, sizeof(user));
 106         } else {
 107                 strcpy(user, "you");
 108         }
 109
 110         color = curmove = 0;
 111
 112         prog = strrchr(argv[0], '/');
 113         if (prog)
 114                 prog++;
 115         else
 116                 prog = argv[0];
 117
 118         while ((ch = getopt(argc, argv, "bcdD:u")) != -1) {
 119                 switch (ch) {
 120                 case 'b':       /* background */
 121                         interactive = 0;
 122                         break;
 123                 case 'd':       /* debugging */
 124                         debug++;
 125                         break;
 126                 case 'D':       /* log debug output to file */
 127                         if ((debugfp = fopen(optarg, "w")) == NULL)
 128                                 err(1, "%s", optarg);
 129                         break;
 130                 case 'u':       /* testing: user versus user */
 131                         test = 1;
 132                         break;
 133                 case 'c':       /* testing: computer versus computer */
 134                         test = 2;
 135                         break;
 136                 }
 137         }
 138         argc -= optind;
 139         argv += optind;
 140         if (argc) {
 141                 if ((inputfp = fopen(*argv, "r")) == NULL)
 142                         err(1, "%s", *argv);
 143         }
 144
 145         if (!debug)
 146                 srandom(time(0));
 147         if (interactive)
 148                 cursinit();             /* initialize curses */
 149 again:
 150         bdinit(board);                  /* initialize board contents */
 151
 152         if (interactive) {
 153                 plyr[BLACK] = plyr[WHITE] = "???";
 154                 bdisp_init();           /* initialize display of board */
 155 #ifdef DEBUG
 156                 signal(SIGINT, whatsup);
 157 #else
 158                 signal(SIGINT, quitsig);
 159 #endif
 160
 161                 if (inputfp == NULL && test == 0) {
 162                         move(BSZ3, 0);
 163                         printw("Black moves first. ");
 164                         ask("(B)lack or (W)hite? ");
 165                         for (;;) {
 166                                 ch = get_key(NULL);
 167                                 if (ch == 'b' || ch == 'B') {
 168                                         color = BLACK;
 169                                         break;
 170                                 }
 171                                 if (ch == 'w' || ch == 'W') {
 172                                         color = WHITE;
 173                                         break;
 174                                 }
 175                                 if (ch == 'q' || ch == 'Q') {
 176                                         quit();
 177                                 }
 178                                 beep();
 179                                 ask("Please choose (B)lack or (W)hite: ");
 180                         }
 181                         move(BSZ3, 0);
 182                         clrtoeol();
 183                 }
 184         } else {
 185                 setbuf(stdout, 0);
 186                 get_line(buf, sizeof(buf));
 187                 if (strcmp(buf, "black") == 0)
 188                         color = BLACK;
 189                 else if (strcmp(buf, "white") == 0)
 190                         color = WHITE;
 191                 else {
 192                         panic("Huh?  Expected `black' or `white', got `%s'\n",
 193                             buf);
 194                 }
 195         }
 196
 197         if (inputfp) {
 198                 input[BLACK] = INPUTF;
 199                 input[WHITE] = INPUTF;
 200         } else {
 201                 switch (test) {
 202                 case 0: /* user versus program */
 203                         input[color] = USER;
 204                         input[!color] = PROGRAM;
 205                         break;
 206
 207                 case 1: /* user versus user */
 208                         input[BLACK] = USER;
 209                         input[WHITE] = USER;
 210                         break;
 211
 212                 case 2: /* program versus program */
 213                         input[BLACK] = PROGRAM;
 214                         input[WHITE] = PROGRAM;
 215                         break;
 216                 }
 217         }
 218         if (interactive) {
 219                 plyr[BLACK] = input[BLACK] == USER ? user : prog;
 220                 plyr[WHITE] = input[WHITE] == USER ? user : prog;
 221                 bdwho(1);
 222         }
 223
 224         for (color = BLACK; ; color = !color) {
 225         top:
 226                 switch (input[color]) {
 227                 case INPUTF: /* input comes from a file */
 228                         curmove = readinput(inputfp);
 229                         if (curmove != ILLEGAL)
 230                                 break;
 231                         switch (test) {
 232                         case 0: /* user versus program */
 233                                 input[color] = USER;
 234                                 input[!color] = PROGRAM;
 235                                 break;
 236
 237                         case 1: /* user versus user */
 238                                 input[BLACK] = USER;
 239                                 input[WHITE] = USER;
 240                                 break;
 241
 242                         case 2: /* program versus program */
 243                                 input[BLACK] = PROGRAM;
 244                                 input[WHITE] = PROGRAM;
 245                                 break;
 246                         }
 247                         plyr[BLACK] = input[BLACK] == USER ? user : prog;
 248                         plyr[WHITE] = input[WHITE] == USER ? user : prog;
 249                         bdwho(1);
 250                         goto top;
 251
 252                 case USER: /* input comes from standard input */
 253                 getinput:
 254                         if (interactive) {
 255                                 ask("Select move, (S)ave or (Q)uit.");
 256                                 curmove = get_coord();
 257                                 if (curmove == SAVE) {
 258                                         FILE *fp;
 259
 260                                         ask("Save file name? ");
 261                                         (void)get_line(fname, sizeof(fname));
 262                                         if ((fp = fopen(fname, "w")) == NULL) {
 263                                                 misclog("cannot create save file");
 264                                                 goto getinput;
 265                                         }
 266                                         for (i = 0; i < movenum - 1; i++)
 267                                                 fprintf(fp, "%s\n",
 268                                                         stoc(movelog[i]));
 269                                         fclose(fp);
 270                                         goto getinput;
 271                                 }
 272                                 if (curmove != RESIGN &&
 273                                     board[curmove].s_occ != EMPTY) {
 274                                         /*misclog("Illegal move");*/
 275                                         beep();
 276                                         goto getinput;
 277                                 }
 278                         } else {
 279                                 if (!get_line(buf, sizeof(buf))) {
 280                                         curmove = RESIGN;
 281                                         break;
 282                                 }
 283                                 if (buf[0] == '\0')
 284                                         goto getinput;
 285                                 curmove = ctos(buf);
 286                         }
 287                         break;
 288
 289                 case PROGRAM: /* input comes from the program */
 290                         if (interactive)
 291                                 ask("Thinking...");
 292                         curmove = pickmove(color);
 293                         break;
 294                 }
 295                 if (interactive) {
 296                         misclog("%3d%s%-6s", movenum, color ? "        " : " ",
 297                             stoc(curmove));
 298                 }
 299                 if ((i = makemove(color, curmove)) != MOVEOK)
 300                         break;
 301                 if (interactive)
 302                         bdisp();
 303         }
 304         if (interactive) {
 305                 move(BSZ3, 0);
 306                 switch (i) {
 307                 case WIN:
 308                         if (input[color] == PROGRAM)
 309                                 addstr("Ha ha, I won");
 310                         else if (input[0] == USER && input[1] == USER)
 311                                 addstr("Well, you won (and lost)");
 312                         else
 313                                 addstr("Rats! you won");
 314                         break;
 315                 case TIE:
 316                         addstr("Wow! It's a tie");
 317                         break;
 318                 case ILLEGAL:
 319                         addstr("Illegal move");
 320                         break;
 321                 }
 322                 clrtoeol();
 323                 bdisp();
 324                 if (i != RESIGN) {
 325                 replay:
 326                         ask("Play again? ");
 327                         ch = get_key("YyNnQqSs");
 328                         if (ch == 'Y' || ch == 'y')
 329                                 goto again;
 330                         if (ch == 'S') {
 331                                 FILE *fp;
 332
 333                                 ask("Save file name? ");
 334                                 (void)get_line(fname, sizeof(fname));
 335                                 if ((fp = fopen(fname, "w")) == NULL) {
 336                                         misclog("cannot create save file");
 337                                         goto replay;
 338                                 }
 339                                 for (i = 0; i < movenum - 1; i++)
 340                                         fprintf(fp, "%s\n",
 341                                                 stoc(movelog[i]));
 342                                 fclose(fp);
 343                                 goto replay;
 344                         }
 345                 }
 346         }
 347         quit();
 348         /* NOTREACHED */
 349         return(0);
 350 }
 351
 352 static int
 353 readinput(FILE *fp)
 354 {
 355         int c;
 356         char buf[128];
 357         size_t pos;
 358
 359         pos = 0;
 360         while ((c = getc(fp)) != EOF && c != '\n' && pos < sizeof(buf) - 1)
 361                 buf[pos++] = c;
 362         buf[pos] = '\0';
 363         return ctos(buf);
 364 }
 365
 366 #ifdef DEBUG
 367 /*
 368  * Handle strange situations.
 369  */
 370 void
 371 whatsup(int signum)
 372 {
 373         int i, n, s1, s2, d1, d2;
 374         struct spotstr *sp;
 375         FILE *fp;
 376         char *str;
 377         struct elist *ep;
 378         struct combostr *cbp;
 379         char input[128];
 380         char tmp[128];
 381
 382         if (!interactive)
 383                 quit();
 384 top:
 385         ask("debug command: ");
 386         if (!get_line(input, sizeof(input)))
 387                 quit();
 388         switch (*input) {
 389         case '\0':
 390                 goto top;
 391         case 'q':               /* conservative quit */
 392                 quit();
 393         case 'd':               /* set debug level */
 394                 debug = input[1] - '0';
 395                 debuglog("Debug set to %d", debug);
 396                 sleep(1);
 397         case 'c':
 398                 break;
 399         case 'b':               /* back up a move */
 400                 if (movenum > 1) {
 401                         movenum--;
 402                         board[movelog[movenum - 1]].s_occ = EMPTY;
 403                         bdisp();
 404                 }
 405                 goto top;
 406         case 's':               /* suggest a move */
 407                 i = input[1] == 'b' ? BLACK : WHITE;
 408                 debuglog("suggest %c %s", i == BLACK ? 'B' : 'W',
 409                         stoc(pickmove(i)));
 410                 goto top;
 411         case 'f':               /* go forward a move */
 412                 board[movelog[movenum - 1]].s_occ = movenum & 1 ? BLACK : WHITE;
 413                 movenum++;
 414                 bdisp();
 415                 goto top;
 416         case 'l':               /* print move history */
 417                 if (input[1] == '\0') {
 418                         for (i = 0; i < movenum - 1; i++)
 419                                 debuglog("%s", stoc(movelog[i]));
 420                         goto top;
 421                 }
 422                 if ((fp = fopen(input + 1, "w")) == NULL)
 423                         goto top;
 424                 for (i = 0; i < movenum - 1; i++) {
 425                         fprintf(fp, "%s", stoc(movelog[i]));
 426                         if (++i < movenum - 1)
 427                                 fprintf(fp, " %s\n", stoc(movelog[i]));
 428                         else
 429                                 fputc('\n', fp);
 430                 }
 431                 bdump(fp);
 432                 fclose(fp);
 433                 goto top;
 434         case 'o':
 435                 /* avoid use w/o initialization on invalid input */
 436                 d1 = s1 = 0;
 437
 438                 n = 0;
 439                 for (str = input + 1; *str; str++)
 440                         if (*str == ',') {
 441                                 for (d1 = 0; d1 < 4; d1++)
 442                                         if (str[-1] == pdir[d1])
 443                                                 break;
 444                                 str[-1] = '\0';
 445                                 sp = &board[s1 = ctos(input + 1)];
 446                                 n = (sp->s_frame[d1] - frames) * FAREA;
 447                                 *str++ = '\0';
 448                                 break;
 449                         }
 450                 sp = &board[s2 = ctos(str)];
 451                 while (*str)
 452                         str++;
 453                 for (d2 = 0; d2 < 4; d2++)
 454                         if (str[-1] == pdir[d2])
 455                                 break;
 456                 n += sp->s_frame[d2] - frames;
 457                 debuglog("overlap %s%c,%s%c = %x", stoc(s1), pdir[d1],
 458                     stoc(s2), pdir[d2], overlap[n]);
 459                 goto top;
 460         case 'p':
 461                 sp = &board[i = ctos(input + 1)];
 462                 debuglog("V %s %x/%d %d %x/%d %d %d %x", stoc(i),
 463                         sp->s_combo[BLACK].s, sp->s_level[BLACK],
 464                         sp->s_nforce[BLACK],
 465                         sp->s_combo[WHITE].s, sp->s_level[WHITE],
 466                         sp->s_nforce[WHITE], sp->s_wval, sp->s_flags);
 467                 debuglog("FB %s %x %x %x %x", stoc(i),
 468                         sp->s_fval[BLACK][0].s, sp->s_fval[BLACK][1].s,
 469                         sp->s_fval[BLACK][2].s, sp->s_fval[BLACK][3].s);
 470                 debuglog("FW %s %x %x %x %x", stoc(i),
 471                         sp->s_fval[WHITE][0].s, sp->s_fval[WHITE][1].s,
 472                         sp->s_fval[WHITE][2].s, sp->s_fval[WHITE][3].s);
 473                 goto top;
 474         case 'e':       /* e {b|w} [0-9] spot */
 475                 str = input + 1;
 476                 if (*str >= '0' && *str <= '9')
 477                         n = *str++ - '0';
 478                 else
 479                         n = 0;
 480                 sp = &board[i = ctos(str)];
 481                 for (ep = sp->s_empty; ep; ep = ep->e_next) {
 482                         cbp = ep->e_combo;
 483                         if (n) {
 484                                 if (cbp->c_nframes > n)
 485                                         continue;
 486                                 if (cbp->c_nframes != n)
 487                                         break;
 488                         }
 489                         printcombo(cbp, tmp, sizeof(tmp));
 490                         debuglog("%s", tmp);
 491                 }
 492                 goto top;
 493         default:
 494                 debuglog("Options are:");
 495                 debuglog("q    - quit");
 496                 debuglog("c    - continue");
 497                 debuglog("d#   - set debug level to #");
 498                 debuglog("p#   - print values at #");
 499                 goto top;
 500         }
 501 }
 502 #endif /* DEBUG */
 503
 504 /*
 505  * Display debug info.
 506  */
 507 void
 508 debuglog(const char *fmt, ...)
 509 {
 510         va_list ap;
 511         char buf[128];
 512
 513         va_start(ap, fmt);
 514         vsnprintf(buf, sizeof(buf), fmt, ap);
 515         va_end(ap);
 516
 517         if (debugfp)
 518                 fprintf(debugfp, "%s\n", buf);
 519         if (interactive)
 520                 dislog(buf);
 521         else
 522                 fprintf(stderr, "%s\n", buf);
 523 }
 524
 525 static void
 526 misclog(const char *fmt, ...)
 527 {
 528         va_list ap;
 529         char buf[128];
 530
 531         va_start(ap, fmt);
 532         vsnprintf(buf, sizeof(buf), fmt, ap);
 533         va_end(ap);
 534
 535         if (debugfp)
 536                 fprintf(debugfp, "%s\n", buf);
 537         if (interactive)
 538                 dislog(buf);
 539         else
 540                 printf("%s\n", buf);
 541 }
 542
 543 static void
 544 quit(void)
 545 {
 546         if (interactive) {
 547                 bdisp();                /* show final board */
 548                 cursfini();
 549         }
 550         exit(0);
 551 }
 552
 553 static void
 554 quitsig(int dummy __unused)
 555 {
 556         quit();
 557 }
 558
 559 /*
 560  * Die gracefully.
 561  */
 562 void
 563 panic(const char *fmt, ...)
 564 {
 565         va_list ap;
 566
 567         if (interactive) {
 568                 bdisp();
 569                 cursfini();
 570         }
 571
 572         fprintf(stderr, "%s: ", prog);
 573         va_start(ap, fmt);
 574         vfprintf(stderr, fmt, ap);
 575         va_end(ap);
 576         fprintf(stderr, "\n");
 577
 578         fputs("I resign\n", stdout);
 579         exit(1);
 580 }