games/bs/bs.c

   1 /*
   2  * bs.c - original author: Bruce Holloway
   3  *              salvo option by: Chuck A DeGaul
   4  * with improved user interface, autoconfiguration and code cleanup
   5  *              by Eric S. Raymond <esr@snark.thyrsus.com>
   6  * v1.2 with color support and minor portability fixes, November 1990
   7  * v2.0 featuring strict ANSI/POSIX conformance, November 1993.
   8  *
   9  * $FreeBSD: src/games/bs/bs.c,v 1.9 2000/02/21 03:07:31 billf Exp $
  10  * $DragonFly: src/games/bs/bs.c,v 1.7 2007/04/18 18:32:12 swildner Exp $
  11  */
  12
  13 #include <assert.h>
  14 #include <ctype.h>
  15 #include <ncurses.h>
  16 #include <signal.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <time.h>
  20 #include <unistd.h>
  21
  22 #ifndef A_UNDERLINE     /* BSD curses */
  23 #define beep()  write(1,"\007",1);
  24 #define cbreak  crmode
  25 #define saveterm savetty
  26 #define resetterm resetty
  27 #define nocbreak nocrmode
  28 #define strchr  index
  29 #endif /* !A_UNDERLINE */
  30
  31
  32 /*
  33  * Constants for tuning the random-fire algorithm. It prefers moves that
  34  * diagonal-stripe the board with a stripe separation of srchstep. If
  35  * no such preferred moves are found, srchstep is decremented.
  36  */
  37 #define BEGINSTEP       3       /* initial value of srchstep */
  38
  39 /* miscellaneous constants */
  40 #define SHIPTYPES       5
  41 #define OTHER           (1-turn)
  42 #define PLAYER          0
  43 #define COMPUTER        1
  44 #define MARK_HIT        'H'
  45 #define MARK_MISS       'o'
  46 #define CTRLC           '\003'  /* used as terminate command */
  47 #define FF              '\014'  /* used as redraw command */
  48
  49 /* coordinate handling */
  50 #define BWIDTH          10
  51 #define BDEPTH          10
  52
  53 /* display symbols */
  54 #define SHOWHIT         '*'
  55 #define SHOWSPLASH      ' '
  56 #define IS_SHIP(c)      isupper(c)
  57
  58 /* how to position us on player board */
  59 #define PYBASE  3
  60 #define PXBASE  3
  61 #define PY(y)   (PYBASE + (y))
  62 #define PX(x)   (PXBASE + (x)*3)
  63 #define pgoto(y, x)     move(PY(y), PX(x))
  64
  65 /* how to position us on cpu board */
  66 #define CYBASE  3
  67 #define CXBASE  48
  68 #define CY(y)   (CYBASE + (y))
  69 #define CX(x)   (CXBASE + (x)*3)
  70 #define cgoto(y, x)     move(CY(y), CX(x))
  71
  72 #define ONBOARD(x, y)   (x >= 0 && x < BWIDTH && y >= 0 && y < BDEPTH)
  73
  74 /* other board locations */
  75 #define COLWIDTH        80
  76 #define PROMPTLINE      21                      /* prompt line */
  77 #define SYBASE          CYBASE + BDEPTH + 3     /* move key diagram */
  78 #define SXBASE          63
  79 #define MYBASE          SYBASE - 1              /* diagram caption */
  80 #define MXBASE          64
  81 #define HYBASE          SYBASE - 1              /* help area */
  82 #define HXBASE          0
  83
  84 /* this will need to be changed if BWIDTH changes */
  85 static char numbers[] = "   0  1  2  3  4  5  6  7  8  9";
  86
  87 static char carrier[] = "Aircraft Carrier";
  88 static char battle[] = "Battleship";
  89 static char sub[] = "Submarine";
  90 static char destroy[] = "Destroyer";
  91 static char ptboat[] = "PT Boat";
  92
  93 static char name[40];
  94 static char dftname[] = "stranger";
  95
  96 /* direction constants */
  97 enum directions { E, SE, S, SW, W, NW, N, NE };
  98 static int xincr[8] = {1,  1,  0, -1, -1, -1,  0,  1};
  99 static int yincr[8] = {0,  1,  1,  1,  0, -1, -1, -1};
 100
 101 /* current ship position and direction */
 102 static int curx = (BWIDTH / 2);
 103 static int cury = (BDEPTH / 2);
 104
 105 typedef struct {
 106     char *name;                         /* name of the ship type */
 107     char hits;                          /* how many times has this ship been hit? */
 108     char symbol;                        /* symbol for game purposes */
 109     char length;                        /* length of ship */
 110     char x, y;                          /* coordinates of ship start point */
 111     enum directions dir;        /* direction of `bow' */
 112     bool placed;                        /* has it been placed on the board? */
 113 }
 114 ship_t;
 115
 116 ship_t plyship[SHIPTYPES] =
 117 {
 118     { carrier,  0, 'A', 5, 0, 0, E, FALSE},
 119     { battle,   0, 'B', 4, 0, 0, E, FALSE},
 120     { destroy,  0, 'D', 3, 0, 0, E, FALSE},
 121     { sub,              0, 'S', 3, 0, 0, E, FALSE},
 122     { ptboat,   0, 'P', 2, 0, 0, E, FALSE},
 123 };
 124
 125 ship_t cpuship[SHIPTYPES] =
 126 {
 127     { carrier,  0, 'A', 5, 0, 0, E, FALSE},
 128     { battle,   0, 'B', 4, 0, 0, E, FALSE},
 129     { destroy,  0, 'D', 3, 0, 0, E, FALSE},
 130     { sub,              0, 'S', 3, 0, 0, E, FALSE},
 131     { ptboat,   0, 'P', 2, 0, 0, E, FALSE},
 132 };
 133
 134 /* "Hits" board, and main board. */
 135 static char hits[2][BWIDTH][BDEPTH], board[2][BWIDTH][BDEPTH];
 136
 137 static int turn;                        /* 0=player, 1=computer */
 138 static int plywon=0, cpuwon=0;          /* How many games has each won? */
 139
 140 static int salvo, blitz, closepack;
 141
 142 #define PR      addstr
 143
 144 static bool checkplace (int, ship_t *, int);
 145 static int getcoord (int);
 146 int playagain (void);
 147
 148 /* end the game, either normally or due to signal */
 149 static void
 150 uninitgame(void)
 151 {
 152     clear();
 153     refresh();
 154     resetterm();
 155     echo();
 156     endwin();
 157     exit(0);
 158 }
 159
 160 static void
 161 sighandler(__unused int sig)
 162 {
 163         uninitgame();
 164 }
 165
 166 /* announce which game options are enabled */
 167 static void
 168 announceopts(void)
 169 {
 170     printw("Playing %s game (", (salvo || blitz || closepack) ?
 171                         "optional" : "standard");
 172
 173         if (salvo)
 174             printw("salvo, ");
 175         else
 176             printw("nosalvo, ");
 177
 178         if (blitz)
 179             printw("blitz, ");
 180         else
 181             printw("noblitz, ");
 182
 183         if (closepack)
 184             printw("closepack)");
 185         else
 186             printw("noclosepack)");
 187 }
 188
 189 static void
 190 intro(void)
 191 {
 192     char *tmpname;
 193
 194     srandomdev();
 195
 196     tmpname = getlogin();
 197     signal(SIGINT,sighandler);
 198     signal(SIGINT,sighandler);
 199     signal(SIGIOT,sighandler);          /* for assert(3) */
 200     if(signal(SIGQUIT,SIG_IGN) != SIG_IGN)
 201                 signal(SIGQUIT,sighandler);
 202
 203     if(tmpname != '\0') {
 204                 strcpy(name,tmpname);
 205                 name[0] = toupper(name[0]);
 206     } else {
 207                 strcpy(name,dftname);
 208         }
 209
 210     initscr();
 211 #ifdef KEY_MIN
 212     keypad(stdscr, TRUE);
 213 #endif /* KEY_MIN */
 214     saveterm();
 215     nonl();
 216     cbreak();
 217     noecho();
 218
 219 #ifdef PENGUIN
 220     clear();
 221     mvaddstr(4,29,"Welcome to Battleship!");
 222     move(8,0);
 223     PR("                                                  \\\n");
 224     PR("                           \\                     \\ \\\n");
 225     PR("                          \\ \\                   \\ \\ \\_____________\n");
 226     PR("                         \\ \\ \\_____________      \\ \\/            |\n");
 227     PR("                          \\ \\/             \\      \\/             |\n");
 228     PR("                           \\/               \\_____/              |__\n");
 229     PR("           ________________/                                       |\n");
 230     PR("           \\  S.S. Penguin                                         |\n");
 231     PR("            \\                                                     /\n");
 232     PR("             \\___________________________________________________/\n");
 233
 234     mvaddstr(22,27,"Hit any key to continue..."); refresh();
 235     getch();
 236 #endif /* PENGUIN */
 237
 238 #ifdef A_COLOR
 239     start_color();
 240
 241     init_pair(COLOR_BLACK, COLOR_BLACK, COLOR_BLACK);
 242     init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK);
 243     init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK);
 244     init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK);
 245     init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK);
 246     init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
 247     init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK);
 248     init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK);
 249 #endif /* A_COLOR */
 250
 251 }
 252
 253 /* print a message at the prompt line */
 254 static void
 255 prompt(int n, const char *f, ...)
 256 {
 257     char buf[COLWIDTH + 1];
 258     va_list ap;
 259
 260     va_start(ap, f);
 261     move(PROMPTLINE + n, 0);
 262     clrtoeol();
 263     vsnprintf(buf, COLWIDTH + 1, f, ap);
 264     printw("%s", buf);
 265     refresh();
 266     va_end(ap);
 267 }
 268
 269 static void
 270 error(const char *s)
 271 {
 272     move(PROMPTLINE + 2, 0);
 273     clrtoeol();
 274     if (s) {
 275                 addstr(s);
 276                 beep();
 277     }
 278 }
 279
 280 static void
 281 placeship(int b, ship_t *ss, int vis)
 282 {
 283     int l;
 284
 285     for(l = 0; l < ss->length; ++l) {
 286                 int newx = ss->x + l * xincr[ss->dir];
 287                 int newy = ss->y + l * yincr[ss->dir];
 288
 289                 board[b][newx][newy] = ss->symbol;
 290                 if (vis) {
 291                 pgoto(newy, newx);
 292                 addch((chtype)ss->symbol);
 293                 }
 294     }
 295     ss->hits = 0;
 296 }
 297
 298 static int
 299 rnd(int n)
 300 {
 301     return(random() % n);
 302 }
 303
 304 /* generate a valid random ship placement into px,py */
 305 static void
 306 randomplace(int b, ship_t *ss)
 307 {
 308     do {
 309                 ss->y = rnd(BDEPTH);
 310                 ss->x = rnd(BWIDTH);
 311                 ss->dir = rnd(2) ? E : S;
 312     } while (!checkplace(b, ss, FALSE));
 313 }
 314
 315 static void
 316 initgame(void)
 317 {
 318     int i, j, unplaced;
 319     ship_t *ss;
 320
 321     clear();
 322     mvaddstr(0,35,"BATTLESHIPS");
 323     move(PROMPTLINE + 2, 0);
 324     announceopts();
 325
 326     bzero(board, sizeof(char) * BWIDTH * BDEPTH * 2);
 327     bzero(hits, sizeof(char) * BWIDTH * BDEPTH * 2);
 328     for (i = 0; i < SHIPTYPES; i++) {
 329                 ss = cpuship + i;
 330                 ss->x = ss->y = ss->dir = ss->hits = ss->placed = 0;
 331                 ss = plyship + i;
 332                 ss->x = ss->y = ss->dir = ss->hits = ss->placed = 0;
 333     }
 334
 335     /* draw empty boards */
 336     mvaddstr(PYBASE - 2, PXBASE + 5, "Main Board");
 337     mvaddstr(PYBASE - 1, PXBASE - 3,numbers);
 338     for(i=0; i < BDEPTH; ++i)
 339     {
 340         mvaddch(PYBASE + i, PXBASE - 3, i + 'A');
 341 #ifdef A_COLOR
 342         if (has_colors())
 343             attron(COLOR_PAIR(COLOR_BLUE));
 344 #endif /* A_COLOR */
 345         addch(' ');
 346         for (j = 0; j < BWIDTH; j++)
 347             addstr(" . ");
 348 #ifdef A_COLOR
 349         attrset(0);
 350 #endif /* A_COLOR */
 351         addch(' ');
 352         addch(i + 'A');
 353     }
 354     mvaddstr(PYBASE + BDEPTH, PXBASE - 3,numbers);
 355     mvaddstr(CYBASE - 2, CXBASE + 7,"Hit/Miss Board");
 356     mvaddstr(CYBASE - 1, CXBASE - 3, numbers);
 357     for(i=0; i < BDEPTH; ++i)
 358     {
 359         mvaddch(CYBASE + i, CXBASE - 3, i + 'A');
 360 #ifdef A_COLOR
 361         if (has_colors())
 362             attron(COLOR_PAIR(COLOR_BLUE));
 363 #endif /* A_COLOR */
 364         addch(' ');
 365         for (j = 0; j < BWIDTH; j++)
 366             addstr(" . ");
 367 #ifdef A_COLOR
 368         attrset(0);
 369 #endif /* A_COLOR */
 370         addch(' ');
 371         addch(i + 'A');
 372     }
 373
 374     mvaddstr(CYBASE + BDEPTH,CXBASE - 3,numbers);
 375
 376     mvprintw(HYBASE,  HXBASE,
 377                     "To position your ships: move the cursor to a spot, then");
 378     mvprintw(HYBASE+1,HXBASE,
 379                     "type the first letter of a ship type to select it, then");
 380     mvprintw(HYBASE+2,HXBASE,
 381                     "type a direction ([hjkl] or [4862]), indicating how the");
 382     mvprintw(HYBASE+3,HXBASE,
 383                     "ship should be pointed. You may also type a ship letter");
 384     mvprintw(HYBASE+4,HXBASE,
 385                     "followed by `r' to position it randomly, or type `R' to");
 386     mvprintw(HYBASE+5,HXBASE,
 387                     "place all remaining ships randomly.");
 388
 389     mvaddstr(MYBASE,   MXBASE, "Aiming keys:");
 390     mvaddstr(SYBASE,   SXBASE, "y k u    7 8 9");
 391     mvaddstr(SYBASE+1, SXBASE, " \\|/      \\|/ ");
 392     mvaddstr(SYBASE+2, SXBASE, "h-+-l    4-+-6");
 393     mvaddstr(SYBASE+3, SXBASE, " /|\\      /|\\ ");
 394     mvaddstr(SYBASE+4, SXBASE, "b j n    1 2 3");
 395
 396     /* have the computer place ships */
 397     for(ss = cpuship; ss < cpuship + SHIPTYPES; ss++)
 398     {
 399         randomplace(COMPUTER, ss);
 400         placeship(COMPUTER, ss, FALSE);
 401     }
 402
 403     ss = NULL;
 404     do {
 405         char c, docked[SHIPTYPES + 2], *cp = docked;
 406
 407         /* figure which ships still wait to be placed */
 408         *cp++ = 'R';
 409         for (i = 0; i < SHIPTYPES; i++)
 410             if (!plyship[i].placed)
 411                 *cp++ = plyship[i].symbol;
 412         *cp = '\0';
 413
 414         /* get a command letter */
 415         prompt(1, "Type one of [%s] to pick a ship.", docked+1);
 416         do {
 417             c = getcoord(PLAYER);
 418         } while
 419             (!strchr(docked, c));
 420
 421         if (c == 'R')
 422             ungetch('R');
 423         else
 424         {
 425             /* map that into the corresponding symbol */
 426             for (ss = plyship; ss < plyship + SHIPTYPES; ss++)
 427                 if (ss->symbol == c)
 428                     break;
 429
 430             prompt(1, "Type one of [hjklrR] to place your %s.", ss->name);
 431             pgoto(cury, curx);
 432         }
 433
 434         do {
 435             c = getch();
 436         } while
 437             (!strchr("hjklrR", c) || c == FF);
 438
 439         if (c == FF)
 440         {
 441             clearok(stdscr, TRUE);
 442             refresh();
 443         }
 444         else if (c == 'r')
 445         {
 446             prompt(1, "Random-placing your %s", ss->name);
 447             randomplace(PLAYER, ss);
 448             placeship(PLAYER, ss, TRUE);
 449             error(NULL);
 450             ss->placed = TRUE;
 451         }
 452         else if (c == 'R')
 453         {
 454             prompt(1, "Placing the rest of your fleet at random...");
 455             for (ss = plyship; ss < plyship + SHIPTYPES; ss++)
 456                 if (!ss->placed)
 457                 {
 458                     randomplace(PLAYER, ss);
 459                     placeship(PLAYER, ss, TRUE);
 460                     ss->placed = TRUE;
 461                 }
 462             error(NULL);
 463         }
 464         else if (strchr("hjkl8462", c))
 465         {
 466             ss->x = curx;
 467             ss->y = cury;
 468
 469             switch(c)
 470             {
 471             case 'k': case '8': ss->dir = N; break;
 472             case 'j': case '2': ss->dir = S; break;
 473             case 'h': case '4': ss->dir = W; break;
 474             case 'l': case '6': ss->dir = E; break;
 475             }
 476
 477             if (checkplace(PLAYER, ss, TRUE))
 478             {
 479                 placeship(PLAYER, ss, TRUE);
 480                 error(NULL);
 481                 ss->placed = TRUE;
 482             }
 483         }
 484
 485         for (unplaced = i = 0; i < SHIPTYPES; i++)
 486             unplaced += !plyship[i].placed;
 487     } while
 488         (unplaced);
 489
 490     turn = rnd(2);
 491
 492     mvprintw(HYBASE,  HXBASE,
 493                     "To fire, move the cursor to your chosen aiming point   ");
 494     mvprintw(HYBASE+1,  HXBASE,
 495                     "and strike any key other than a motion key.            ");
 496     mvprintw(HYBASE+2,  HXBASE,
 497                     "                                                       ");
 498     mvprintw(HYBASE+3,  HXBASE,
 499                     "                                                       ");
 500     mvprintw(HYBASE+4,  HXBASE,
 501                     "                                                       ");
 502     mvprintw(HYBASE+5,  HXBASE,
 503                     "                                                       ");
 504
 505     prompt(0, "Press any key to start...");
 506     getch();
 507 }
 508
 509 static int
 510 getcoord(int atcpu)
 511 {
 512     int ny, nx, c;
 513
 514     if (atcpu)
 515         cgoto(cury,curx);
 516     else
 517         pgoto(cury, curx);
 518     refresh();
 519     for (;;)
 520     {
 521         if (atcpu)
 522         {
 523             mvprintw(CYBASE + BDEPTH+1, CXBASE+11, "(%d, %c)", curx, 'A'+cury);
 524             cgoto(cury, curx);
 525         }
 526         else
 527         {
 528             mvprintw(PYBASE + BDEPTH+1, PXBASE+11, "(%d, %c)", curx, 'A'+cury);
 529             pgoto(cury, curx);
 530         }
 531
 532         switch(c = getch())
 533         {
 534         case 'k': case '8':
 535 #ifdef KEY_MIN
 536         case KEY_UP:
 537 #endif /* KEY_MIN */
 538             ny = cury+BDEPTH-1; nx = curx;
 539             break;
 540         case 'j': case '2':
 541 #ifdef KEY_MIN
 542         case KEY_DOWN:
 543 #endif /* KEY_MIN */
 544             ny = cury+1;        nx = curx;
 545             break;
 546         case 'h': case '4':
 547 #ifdef KEY_MIN
 548         case KEY_LEFT:
 549 #endif /* KEY_MIN */
 550             ny = cury;          nx = curx+BWIDTH-1;
 551             break;
 552         case 'l': case '6':
 553 #ifdef KEY_MIN
 554         case KEY_RIGHT:
 555 #endif /* KEY_MIN */
 556             ny = cury;          nx = curx+1;
 557             break;
 558         case 'y': case '7':
 559 #ifdef KEY_MIN
 560         case KEY_A1:
 561 #endif /* KEY_MIN */
 562             ny = cury+BDEPTH-1; nx = curx+BWIDTH-1;
 563             break;
 564         case 'b': case '1':
 565 #ifdef KEY_MIN
 566         case KEY_C1:
 567 #endif /* KEY_MIN */
 568             ny = cury+1;        nx = curx+BWIDTH-1;
 569             break;
 570         case 'u': case '9':
 571 #ifdef KEY_MIN
 572         case KEY_A3:
 573 #endif /* KEY_MIN */
 574             ny = cury+BDEPTH-1; nx = curx+1;
 575             break;
 576         case 'n': case '3':
 577 #ifdef KEY_MIN
 578         case KEY_C3:
 579 #endif /* KEY_MIN */
 580             ny = cury+1;        nx = curx+1;
 581             break;
 582         case FF:
 583             nx = curx; ny = cury;
 584             clearok(stdscr, TRUE);
 585             refresh();
 586             break;
 587         default:
 588             if (atcpu)
 589                 mvaddstr(CYBASE + BDEPTH + 1, CXBASE + 11, "      ");
 590             else
 591                 mvaddstr(PYBASE + BDEPTH + 1, PXBASE + 11, "      ");
 592             return(c);
 593         }
 594
 595         curx = nx % BWIDTH;
 596         cury = ny % BDEPTH;
 597     }
 598 }
 599
 600 /* is this location on the selected zboard adjacent to a ship? */
 601 static int
 602 collidecheck(int b, int y, int x)
 603 {
 604     int collide;
 605
 606     /* anything on the square */
 607     if ((collide = IS_SHIP(board[b][x][y])) != 0)
 608                 return(collide);
 609
 610     /* anything on the neighbors */
 611     if (!closepack) {
 612                 int i;
 613
 614                 for (i = 0; i < 8; i++) {
 615                 int xend, yend;
 616
 617                 yend = y + yincr[i];
 618                 xend = x + xincr[i];
 619                 if (ONBOARD(xend, yend))
 620                         collide += IS_SHIP(board[b][xend][yend]);
 621                 }
 622         }
 623
 624     return(collide);
 625 }
 626
 627 static bool
 628 checkplace(int b, ship_t *ss, int vis)
 629 {
 630     int l, xend, yend;
 631
 632     /* first, check for board edges */
 633     xend = ss->x + (ss->length - 1) * xincr[ss->dir];
 634     yend = ss->y + (ss->length - 1) * yincr[ss->dir];
 635     if (!ONBOARD(xend, yend)) {
 636                 if (vis) {
 637                 switch(rnd(3)) {
 638                         case 0:
 639                                         error("Ship is hanging from the edge of the world");
 640                                         break;
 641                         case 1:
 642                                         error("Try fitting it on the board");
 643                                         break;
 644                         case 2:
 645                                         error("Figure I won't find it if you put it there?");
 646                                         break;
 647                         }
 648             }
 649                 return(0);
 650     }
 651
 652     for(l = 0; l < ss->length; ++l) {
 653                 if(collidecheck(b, ss->y+l*yincr[ss->dir], ss->x+l*xincr[ss->dir])) {
 654                 if (vis) {
 655                                 switch(rnd(3)) {
 656                                 case 0:
 657                                                 error("There's already a ship there");
 658                                                 break;
 659                                 case 1:
 660                                                 error("Collision alert!  Aaaaaagh!");
 661                                                 break;
 662                                 case 2:
 663                                                 error("Er, Admiral, what about the other ship?");
 664                                                 break;
 665                                 }
 666                                 }
 667                 return(FALSE);
 668             }
 669         }
 670     return(TRUE);
 671 }
 672
 673 static int
 674 awinna(void)
 675 {
 676     int i, j;
 677     ship_t *ss;
 678
 679     for(i=0; i<2; ++i)
 680     {
 681         ss = (i) ? cpuship : plyship;
 682         for(j=0; j < SHIPTYPES; ++j, ++ss)
 683             if(ss->length > ss->hits)
 684                 break;
 685         if (j == SHIPTYPES)
 686             return(OTHER);
 687     }
 688     return(-1);
 689 }
 690
 691 /* a hit on the targeted ship */
 692 static ship_t *
 693 hitship(int x, int y)
 694 {
 695     ship_t *sb, *ss;
 696     char sym;
 697     int oldx, oldy;
 698
 699     getyx(stdscr, oldy, oldx);
 700     sb = (turn) ? plyship : cpuship;
 701     if(!(sym = board[OTHER][x][y]))
 702         return(NULL);
 703     for(ss = sb; ss < sb + SHIPTYPES; ++ss)
 704         if(ss->symbol == sym)
 705         {
 706             if (++ss->hits < ss->length) {      /* still afloat? */
 707                         return(NULL);
 708             } else { /* sunk */
 709                 int i, j;
 710
 711                 if (!closepack) {
 712                     for (j = -1; j <= 1; j++) {
 713                                 int bx = ss->x + j * xincr[(ss->dir + 2) % 8];
 714                                 int by = ss->y + j * yincr[(ss->dir + 2) % 8];
 715
 716                                 for (i = -1; i <= ss->length; ++i) {
 717                                 int cx, cy;
 718
 719                                 cx = bx + i * xincr[ss->dir];
 720                                 cy = by + i * yincr[ss->dir];
 721                                 if (ONBOARD(cx, cy)) {
 722                                                 hits[turn][cx][cy] = MARK_MISS;
 723                                                 if (turn % 2 == PLAYER) {
 724                                                 cgoto(cy, cx);
 725 #ifdef A_COLOR
 726                                                 if (has_colors())
 727                                                                 attron(COLOR_PAIR(COLOR_GREEN));
 728 #endif /* A_COLOR */
 729
 730                                                 addch(MARK_MISS);
 731 #ifdef A_COLOR
 732                                                 attrset(0);
 733 #endif /* A_COLOR */
 734                                                 }
 735                                 }
 736                                 }
 737                 }
 738                 }
 739
 740                 for (i = 0; i < ss->length; ++i)
 741                 {
 742                     int dx = ss->x + i * xincr[ss->dir];
 743                     int dy = ss->y + i * yincr[ss->dir];
 744
 745                     hits[turn][dx][dy] = ss->symbol;
 746                     if (turn % 2 == PLAYER)
 747                     {
 748                         cgoto(dy, dx);
 749                         addch(ss->symbol);
 750                     }
 751                 }
 752
 753                 move(oldy, oldx);
 754                 return(ss);
 755             }
 756         }
 757     move(oldy, oldx);
 758     return(NULL);
 759 }
 760
 761 static int
 762 plyturn(void)
 763 {
 764     ship_t *ss;
 765     bool hit;
 766     char const *m;
 767
 768     m = NULL;
 769     prompt(1, "Where do you want to shoot? ");
 770     for (;;)
 771     {
 772         getcoord(COMPUTER);
 773         if (hits[PLAYER][curx][cury])
 774         {
 775             prompt(1, "You shelled this spot already! Try again.");
 776             beep();
 777         }
 778         else
 779             break;
 780     }
 781     hit = IS_SHIP(board[COMPUTER][curx][cury]);
 782     hits[PLAYER][curx][cury] = hit ? MARK_HIT : MARK_MISS;
 783     cgoto(cury, curx);
 784 #ifdef A_COLOR
 785     if (has_colors()) {
 786         if (hit)
 787             attron(COLOR_PAIR(COLOR_RED));
 788         else
 789             attron(COLOR_PAIR(COLOR_GREEN));
 790     }
 791 #endif /* A_COLOR */
 792     addch((chtype)hits[PLAYER][curx][cury]);
 793 #ifdef A_COLOR
 794     attrset(0);
 795 #endif /* A_COLOR */
 796
 797     prompt(1, "You %s.", hit ? "scored a hit" : "missed");
 798     if(hit && (ss = hitship(curx, cury)))
 799     {
 800         switch(rnd(5))
 801         {
 802         case 0:
 803             m = " You sank my %s!";
 804             break;
 805         case 1:
 806             m = " I have this sinking feeling about my %s....";
 807             break;
 808         case 2:
 809             m = " My %s has gone to Davy Jones's locker!";
 810             break;
 811         case 3:
 812             m = " Glub, glub -- my %s is headed for the bottom!";
 813             break;
 814         case 4:
 815             m = " You'll pick up survivors from my %s, I hope...!";
 816             break;
 817         }
 818         printw(m, ss->name);
 819         beep();
 820         return(awinna() == -1);
 821     }
 822     return(hit);
 823 }
 824
 825 static int
 826 sgetc(const char *s)
 827 {
 828     const char *s1;
 829     int ch;
 830
 831     refresh();
 832     for(;;) {
 833                 ch = getch();
 834                 if (islower(ch))
 835                 ch = toupper(ch);
 836
 837                 if (ch == CTRLC)
 838                 uninitgame();
 839
 840                 for (s1=s; *s1 && ch != *s1; ++s1)
 841                 continue;
 842
 843                 if (*s1) {
 844                 addch((chtype)ch);
 845                 refresh();
 846                 return(ch);
 847                 }
 848         }
 849 }
 850
 851 /* random-fire routine -- implements simple diagonal-striping strategy */
 852 static void
 853 randomfire(int *px, int *py)
 854 {
 855     static int turncount = 0;
 856     static int srchstep = BEGINSTEP;
 857     static int huntoffs;                /* Offset on search strategy */
 858     int ypossible[BWIDTH * BDEPTH], xpossible[BWIDTH * BDEPTH], nposs;
 859     int ypreferred[BWIDTH * BDEPTH], xpreferred[BWIDTH * BDEPTH], npref;
 860     int x, y, i;
 861
 862     if (turncount++ == 0)
 863         huntoffs = rnd(srchstep);
 864
 865     /* first, list all possible moves */
 866     nposs = npref = 0;
 867     for (x = 0; x < BWIDTH; x++)
 868         for (y = 0; y < BDEPTH; y++)
 869             if (!hits[COMPUTER][x][y])
 870             {
 871                 xpossible[nposs] = x;
 872                 ypossible[nposs] = y;
 873                 nposs++;
 874                 if (((x+huntoffs) % srchstep) != (y % srchstep))
 875                 {
 876                     xpreferred[npref] = x;
 877                     ypreferred[npref] = y;
 878                     npref++;
 879                 }
 880             }
 881
 882     if (npref)
 883     {
 884         i = rnd(npref);
 885
 886         *px = xpreferred[i];
 887         *py = ypreferred[i];
 888     }
 889     else if (nposs)
 890     {
 891         i = rnd(nposs);
 892
 893         *px = xpossible[i];
 894         *py = ypossible[i];
 895
 896         if (srchstep > 1)
 897             --srchstep;
 898     }
 899     else
 900     {
 901         error("No moves possible?? Help!");
 902         exit(1);
 903         /*NOTREACHED*/
 904     }
 905 }
 906
 907 #define S_MISS  0
 908 #define S_HIT   1
 909 #define S_SUNK  -1
 910
 911 /* fire away at given location */
 912 static bool
 913 cpufire(int x, int y)
 914 {
 915     bool hit, sunk;
 916     ship_t *ss;
 917
 918     ss = NULL;
 919     hits[COMPUTER][x][y] = (hit = (board[PLAYER][x][y])) ? MARK_HIT : MARK_MISS;
 920     mvprintw(PROMPTLINE, 0,
 921         "I shoot at %c%d. I %s!", y + 'A', x, hit ? "hit" : "miss");
 922     ss = hitship(x, y);
 923     sunk = hit && ss;
 924     if (sunk)
 925         printw(" I've sunk your %s", ss->name);
 926     clrtoeol();
 927
 928     pgoto(y, x);
 929 #ifdef A_COLOR
 930     if (has_colors()) {
 931         if (hit)
 932             attron(COLOR_PAIR(COLOR_RED));
 933         else
 934             attron(COLOR_PAIR(COLOR_GREEN));
 935     }
 936 #endif /* A_COLOR */
 937     addch((chtype)(hit ? SHOWHIT : SHOWSPLASH));
 938 #ifdef A_COLOR
 939     attrset(0);
 940 #endif /* A_COLOR */
 941
 942     return(hit ? (sunk ? S_SUNK : S_HIT) : S_MISS);
 943 }
 944
 945 /*
 946  * This code implements a fairly irregular FSM, so please forgive the rampant
 947  * unstructuredness below. The five labels are states which need to be held
 948  * between computer turns.
 949  */
 950 static bool
 951 cputurn(void)
 952 {
 953 #define POSSIBLE(x, y)  (ONBOARD(x, y) && !hits[COMPUTER][x][y])
 954 #define RANDOM_FIRE     0
 955 #define RANDOM_HIT      1
 956 #define HUNT_DIRECT     2
 957 #define FIRST_PASS      3
 958 #define REVERSE_JUMP    4
 959 #define SECOND_PASS     5
 960     static int next = RANDOM_FIRE;
 961     static bool used[4];
 962     static ship_t ts;
 963     int navail, x, y, d, n, hit = S_MISS;
 964
 965     switch(next)
 966     {
 967     case RANDOM_FIRE:   /* last shot was random and missed */
 968     refire:
 969         randomfire(&x, &y);
 970         if (!(hit = cpufire(x, y)))
 971             next = RANDOM_FIRE;
 972         else
 973         {
 974             ts.x = x; ts.y = y;
 975             ts.hits = 1;
 976             next = (hit == S_SUNK) ? RANDOM_FIRE : RANDOM_HIT;
 977         }
 978         break;
 979
 980     case RANDOM_HIT:    /* last shot was random and hit */
 981         used[E/2] = used[S/2] = used[W/2] = used[N/2] = FALSE;
 982         /* FALLTHROUGH */
 983
 984     case HUNT_DIRECT:   /* last shot hit, we're looking for ship's long axis */
 985         for (d = navail = 0; d < 4; d++)
 986         {
 987             x = ts.x + xincr[d*2]; y = ts.y + yincr[d*2];
 988             if (!used[d] && POSSIBLE(x, y))
 989                 navail++;
 990             else
 991                 used[d] = TRUE;
 992         }
 993         if (navail == 0)        /* no valid places for shots adjacent... */
 994             goto refire;        /* ...so we must random-fire */
 995         else
 996         {
 997             for (d = 0, n = rnd(navail) + 1; n; n--)
 998                 while (used[d])
 999                     d++;
1000
1001             assert(d <= 4);
1002
1003             used[d] = FALSE;
1004             x = ts.x + xincr[d*2];
1005             y = ts.y + yincr[d*2];
1006
1007             assert(POSSIBLE(x, y));
1008
1009             if (!(hit = cpufire(x, y)))
1010                 next = HUNT_DIRECT;
1011             else
1012             {
1013                 ts.x = x; ts.y = y; ts.dir = d*2; ts.hits++;
1014                 next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS;
1015             }
1016         }
1017         break;
1018
1019     case FIRST_PASS:    /* we have a start and a direction now */
1020         x = ts.x + xincr[ts.dir];
1021         y = ts.y + yincr[ts.dir];
1022         if (POSSIBLE(x, y) && (hit = cpufire(x, y)))
1023         {
1024             ts.x = x; ts.y = y; ts.hits++;
1025             next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS;
1026         }
1027         else
1028             next = REVERSE_JUMP;
1029         break;
1030
1031     case REVERSE_JUMP:  /* nail down the ship's other end */
1032         d = ts.dir + 4;
1033         x = ts.x + ts.hits * xincr[d];
1034         y = ts.y + ts.hits * yincr[d];
1035         if (POSSIBLE(x, y) && (hit = cpufire(x, y)))
1036         {
1037             ts.x = x; ts.y = y; ts.dir = d; ts.hits++;
1038             next = (hit == S_SUNK) ? RANDOM_FIRE : SECOND_PASS;
1039         }
1040         else
1041             next = RANDOM_FIRE;
1042         break;
1043
1044     case SECOND_PASS:   /* kill squares not caught on first pass */
1045         x = ts.x + xincr[ts.dir];
1046         y = ts.y + yincr[ts.dir];
1047         if (POSSIBLE(x, y) && (hit = cpufire(x, y)))
1048         {
1049             ts.x = x; ts.y = y; ts.hits++;
1050             next = (hit == S_SUNK) ? RANDOM_FIRE: SECOND_PASS;
1051             break;
1052         }
1053         else
1054             next = RANDOM_FIRE;
1055         break;
1056     }
1057
1058     /* check for continuation and/or winner */
1059     if (salvo)
1060     {
1061         refresh();
1062         sleep(1);
1063     }
1064     if (awinna() != -1)
1065         return(FALSE);
1066
1067 #ifdef DEBUG
1068     mvprintw(PROMPTLINE + 2, 0,
1069                     "New state %d, x=%d, y=%d, d=%d",
1070                     next, x, y, d);
1071 #endif /* DEBUG */
1072     return(hit);
1073 }
1074
1075 int
1076 playagain(void)
1077 {
1078     int j;
1079     ship_t *ss;
1080
1081     for (ss = cpuship; ss < cpuship + SHIPTYPES; ss++) {
1082                 for(j = 0; j < ss->length; j++) {
1083                 cgoto(ss->y + j * yincr[ss->dir], ss->x + j * xincr[ss->dir]);
1084                 addch((chtype)ss->symbol);
1085                 }
1086         }
1087
1088     if(awinna()) {
1089                 ++cpuwon;
1090     } else {
1091                 ++plywon;
1092         }
1093
1094     j = 18 + strlen(name);
1095     if(plywon >= 10) {
1096                 ++j;
1097     } else if(cpuwon >= 10) {
1098                 ++j;
1099         }
1100
1101         mvprintw(1,(COLWIDTH-j)/2,
1102                     "%s: %d     Computer: %d",name,plywon,cpuwon);
1103
1104     prompt(2, (awinna()) ? "Want to be humiliated again, %s [yn]? "
1105            : "Going to give me a chance for revenge, %s [yn]? ",name);
1106     return(sgetc("YN") == 'Y');
1107 }
1108
1109 static void
1110 usage(void)
1111 {
1112                 fprintf(stderr, "Usage: battle [-s | -b] [-c]\n");
1113                 fprintf(stderr, "\tWhere the options are:\n");
1114                 fprintf(stderr, "\t-s : salvo     - One shot per ship in play\n");
1115                 fprintf(stderr, "\t-b : blitz     - Fire until you miss\n");
1116                 fprintf(stderr, "\t-c : closepack - Ships may be adjacent\n");
1117                 fprintf(stderr, "Blitz and Salvo are mutually exclusive\n");
1118                 exit(1);
1119 }
1120
1121 static int
1122 scount(int who)
1123 {
1124     int i, shots;
1125     ship_t *sp;
1126
1127     if (who)
1128         sp = cpuship;   /* count cpu shots */
1129     else
1130         sp = plyship;   /* count player shots */
1131
1132     for (i=0, shots = 0; i < SHIPTYPES; i++, sp++)
1133     {
1134         if (sp->hits >= sp->length)
1135             continue;           /* dead ship */
1136         else
1137             shots++;
1138     }
1139     return(shots);
1140 }
1141
1142 int
1143 main(int argc, char **argv)
1144 {
1145         int ch;
1146
1147         /* revoke */
1148         setgid(getgid());
1149
1150         while ((ch = getopt(argc, argv, "bsc")) != -1) {
1151                 switch (ch) {
1152                         case 'b':
1153                                 blitz = 1;
1154                                 break;
1155                         case 's':
1156                                 salvo = 1;
1157                                 break;
1158                         case 'c':
1159                                 closepack = 1;
1160                                 break;
1161                         case '?':
1162                         default:
1163                                 usage();
1164                 }
1165         }
1166         argc -= optind;
1167         argv += optind;
1168
1169         if (blitz && salvo)
1170                 usage();
1171
1172     intro();
1173
1174         do {
1175                 initgame();
1176                 while(awinna() == -1) {
1177                         if (blitz) {
1178                                 while(turn ? cputurn() : plyturn())
1179                                         continue;
1180                         } else if (salvo) {
1181                                 int i;
1182
1183                                 i = scount(turn);
1184                                 while (i--) {
1185                                         if (turn) {
1186                                                 if (cputurn() && awinna() != -1)
1187                                                 i = 0;
1188                                         } else {
1189                                                 if (plyturn() && awinna() != -1)
1190                                                 i = 0;
1191                                         }
1192                                 }
1193                         } else {        /* Normal game */
1194                                 if(turn)
1195                                         cputurn();
1196                                 else
1197                                         plyturn();
1198                         }
1199                         turn = OTHER;
1200                 }
1201         } while (playagain());
1202
1203     uninitgame();
1204     exit(0);
1205 }