ncurses 5.9 - patch 20121208
[ncurses.git] / test / bs.c
index 368abcd8f28d8e24898345966a4d02c985271a0d..f8784853c7620cf233452089adf655d779685b30 100644 (file)
--- a/test/bs.c
+++ b/test/bs.c
@@ -1,3 +1,30 @@
+/****************************************************************************
+ * Copyright (c) 1998-2010,2012 Free Software Foundation, Inc.              *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
 /* 
  * bs.c - original author: Bruce Holloway
  *             salvo option by: Chuck A DeGaul
 /* 
  * bs.c - original author: Bruce Holloway
  *             salvo option by: Chuck A DeGaul
  * v2.0 featuring strict ANSI/POSIX conformance, November 1993.
  * v2.1 with ncurses mouse support, September 1995
  *
  * v2.0 featuring strict ANSI/POSIX conformance, November 1993.
  * v2.1 with ncurses mouse support, September 1995
  *
- * $Id: bs.c,v 1.24 1999/08/21 23:14:38 tom Exp $
+ * $Id: bs.c,v 1.56 2012/12/08 23:35:58 tom Exp $
  */
 
 #include <test.priv.h>
 
  */
 
 #include <test.priv.h>
 
-#include <signal.h>
-#include <ctype.h>
-#include <string.h>
-#include <assert.h>
 #include <time.h>
 
 #ifndef SIGIOT
 #define SIGIOT SIGABRT
 #endif
 
 #include <time.h>
 
 #ifndef SIGIOT
 #define SIGIOT SIGABRT
 #endif
 
-#ifndef A_UNDERLINE    /* BSD curses */
-#define        beep()  write(1,"\007",1);
-#define        cbreak  crmode
-#define        saveterm savetty
-#define        resetterm resetty
-#define        nocbreak nocrmode
-#define strchr index
-#endif /* !A_UNDERLINE */
-
 static int getcoord(int);
 
 /*
 static int getcoord(int);
 
 /*
@@ -57,7 +71,7 @@ static int getcoord(int);
 /* display symbols */
 #define SHOWHIT                '*'
 #define SHOWSPLASH     ' '
 /* display symbols */
 #define SHOWHIT                '*'
 #define SHOWSPLASH     ' '
-#define IS_SHIP(c)     (isupper(c) ? TRUE : FALSE)
+#define IS_SHIP(c)     (isupper(UChar(c)) ? TRUE : FALSE)
 
 /* how to position us on player board */
 #define PYBASE 3
 
 /* how to position us on player board */
 #define PYBASE 3
@@ -79,12 +93,12 @@ static int getcoord(int);
 
 /* other board locations */
 #define COLWIDTH       80
 
 /* other board locations */
 #define COLWIDTH       80
-#define PROMPTLINE     21                      /* prompt line */
+#define PROMPTLINE     21      /* prompt line */
 #define SYBASE         CYBASE + BDEPTH + 3     /* move key diagram */
 #define SXBASE         63
 #define SYBASE         CYBASE + BDEPTH + 3     /* move key diagram */
 #define SXBASE         63
-#define MYBASE         SYBASE - 1              /* diagram caption */
+#define MYBASE         SYBASE - 1      /* diagram caption */
 #define MXBASE         64
 #define MXBASE         64
-#define HYBASE         SYBASE - 1              /* help area */
+#define HYBASE         SYBASE - 1      /* help area */
 #define HXBASE         0
 
 /* this will need to be changed if BWIDTH changes */
 #define HXBASE         0
 
 /* this will need to be changed if BWIDTH changes */
@@ -108,76 +122,77 @@ static char dftname[] = "stranger";
 #define NW     5
 #define N      6
 #define NE     7
 #define NW     5
 #define N      6
 #define NE     7
-static int xincr[8] = {1,  1,  0, -1, -1, -1,  0,  1};
-static int yincr[8] = {0,  1,  1,  1,  0, -1, -1, -1};
+static int xincr[8] =
+{1, 1, 0, -1, -1, -1, 0, 1};
+static int yincr[8] =
+{0, 1, 1, 1, 0, -1, -1, -1};
 
 /* current ship position and direction */
 static int curx = (BWIDTH / 2);
 static int cury = (BDEPTH / 2);
 
 
 /* current ship position and direction */
 static int curx = (BWIDTH / 2);
 static int cury = (BDEPTH / 2);
 
-typedef struct
-{
+typedef struct {
     char *name;                        /* name of the ship type */
     int hits;                  /* how many times has this ship been hit? */
     char symbol;               /* symbol for game purposes */
     int length;                        /* length of ship */
     char *name;                        /* name of the ship type */
     int hits;                  /* how many times has this ship been hit? */
     char symbol;               /* symbol for game purposes */
     int length;                        /* length of ship */
-    char x, y;                 /* coordinates of ship start point */
-    unsigned char dir;         /* direction of `bow' */
+    int x, y;                  /* coordinates of ship start point */
+    int dir;                   /* direction of `bow' */
     bool placed;               /* has it been placed on the board? */
     bool placed;               /* has it been placed on the board? */
-}
-ship_t;
+} ship_t;
 
 
-static bool checkplace(int b, ship_t *ss, int vis);
+static bool checkplace(int b, ship_t * ss, int vis);
 
 #define SHIPIT(name, symbol, length) { name, 0, symbol, length, 0,0, 0, FALSE }
 
 static ship_t plyship[SHIPTYPES] =
 {
 
 #define SHIPIT(name, symbol, length) { name, 0, symbol, length, 0,0, 0, FALSE }
 
 static ship_t plyship[SHIPTYPES] =
 {
-    SHIPIT(carrier,    'A', 5),
-    SHIPIT(battle,     'B', 4),
-    SHIPIT(destroy,    'D', 3),
-    SHIPIT(sub,                'S', 3),
-    SHIPIT(ptboat,     'P', 2),
+    SHIPIT(carrier, 'A', 5),
+    SHIPIT(battle, 'B', 4),
+    SHIPIT(destroy, 'D', 3),
+    SHIPIT(sub, 'S', 3),
+    SHIPIT(ptboat, 'P', 2),
 };
 
 static ship_t cpuship[SHIPTYPES] =
 {
 };
 
 static ship_t cpuship[SHIPTYPES] =
 {
-    SHIPIT(carrier,    'A', 5),
-    SHIPIT(battle,     'B', 4),
-    SHIPIT(destroy,    'D', 3),
-    SHIPIT(sub,                'S', 3),
-    SHIPIT(ptboat,     'P', 2),
+    SHIPIT(carrier, 'A', 5),
+    SHIPIT(battle, 'B', 4),
+    SHIPIT(destroy, 'D', 3),
+    SHIPIT(sub, 'S', 3),
+    SHIPIT(ptboat, 'P', 2),
 };
 
 /* "Hits" board, and main board. */
 static char hits[2][BWIDTH][BDEPTH];
 static char board[2][BWIDTH][BDEPTH];
 
 };
 
 /* "Hits" board, and main board. */
 static char hits[2][BWIDTH][BDEPTH];
 static char board[2][BWIDTH][BDEPTH];
 
-static int turn;                       /* 0=player, 1=computer */
-static int plywon=0, cpuwon=0;         /* How many games has each won? */
+static int turn;               /* 0=player, 1=computer */
+static int plywon = 0, cpuwon = 0;     /* How many games has each won? */
 
 static int salvo, blitz, closepack;
 
 #define        PR      (void)addstr
 
 
 static int salvo, blitz, closepack;
 
 #define        PR      (void)addstr
 
-static RETSIGTYPE uninitgame(int sig)  GCC_NORETURN;
+static RETSIGTYPE uninitgame(int sig) GCC_NORETURN;
 
 
-static RETSIGTYPE uninitgame(int sig GCC_UNUSED)
+static RETSIGTYPE
+uninitgame(int sig GCC_UNUSED)
 /* end the game, either normally or due to signal */
 {
     clear();
 /* end the game, either normally or due to signal */
 {
     clear();
-    (void)refresh();
-    (void)resetterm();
-    (void)echo();
-    (void)endwin();
-    exit(EXIT_FAILURE);
+    (void) refresh();
+    (void) reset_shell_mode();
+    (void) echo();
+    (void) endwin();
+    ExitProgram(sig ? EXIT_FAILURE : EXIT_SUCCESS);
 }
 
 }
 
-static void announceopts(void)
+static void
+announceopts(void)
 /* announce which game options are enabled */
 {
 /* announce which game options are enabled */
 {
-    if (salvo || blitz || closepack)
-    {
+    if (salvo || blitz || closepack) {
        (void) printw("Playing optional game (");
        if (salvo)
            (void) printw("salvo, ");
        (void) printw("Playing optional game (");
        if (salvo)
            (void) printw("salvo, ");
@@ -191,45 +206,37 @@ static void announceopts(void)
            (void) printw("closepack)");
        else
            (void) printw("noclosepack)");
            (void) printw("closepack)");
        else
            (void) printw("noclosepack)");
-    }
-    else
+    } else
        (void) printw(
        (void) printw(
-       "Playing standard game (noblitz, nosalvo, noclosepack)");
+                        "Playing standard game (noblitz, nosalvo, noclosepack)");
 }
 
 }
 
-static void intro(void)
+static void
+intro(void)
 {
     char *tmpname;
 
 {
     char *tmpname;
 
-    srand((unsigned)(time(0L)+getpid()));      /* Kick the random number generator */
+    srand((unsigned) (time(0L) + getpid()));   /* Kick the random number generator */
 
 
-    (void) signal(SIGINT,uninitgame);
-    (void) signal(SIGINT,uninitgame);
-    (void) signal(SIGIOT,uninitgame);          /* for assert(3) */
-    if(signal(SIGQUIT,SIG_IGN) != SIG_IGN)
-       (void)signal(SIGQUIT,uninitgame);
+    CATCHALL(uninitgame);
 
 
-    if((tmpname = getlogin()) != 0)
-    {
-       (void)strcpy(name,tmpname);
-       name[0] = toupper(name[0]);
-    }
-    else
-       (void)strcpy(name,dftname);
+    if ((tmpname = getlogin()) != 0) {
+       (void) strcpy(name, tmpname);
+       name[0] = (char) toupper(UChar(name[0]));
+    } else
+       (void) strcpy(name, dftname);
 
 
-    (void)initscr();
-#ifdef KEY_MIN
+    (void) initscr();
     keypad(stdscr, TRUE);
     keypad(stdscr, TRUE);
-#endif /* KEY_MIN */
-    (void)saveterm();
-    (void)nonl();
-    (void)cbreak();
-    (void)noecho();
+    (void) def_prog_mode();
+    (void) nonl();
+    (void) cbreak();
+    (void) noecho();
 
 #ifdef PENGUIN
 
 #ifdef PENGUIN
-    (void)clear();
-    (void)mvaddstr(4,29,"Welcome to Battleship!");
-    (void)move(8,0);
+    (void) clear();
+    MvAddStr(4, 29, "Welcome to Battleship!");
+    (void) move(8, 0);
     PR("                                                  \\\n");
     PR("                           \\                     \\ \\\n");
     PR("                          \\ \\                   \\ \\ \\_____________\n");
     PR("                                                  \\\n");
     PR("                           \\                     \\ \\\n");
     PR("                          \\ \\                   \\ \\ \\_____________\n");
@@ -241,7 +248,8 @@ static void intro(void)
     PR("            \\                                                     /\n");
     PR("             \\___________________________________________________/\n");
 
     PR("            \\                                                     /\n");
     PR("             \\___________________________________________________/\n");
 
-    (void) mvaddstr(22,27,"Hit any key to continue..."); (void)refresh();
+    MvAddStr(22, 27, "Hit any key to continue...");
+    (void) refresh();
     (void) getch();
 #endif /* PENGUIN */
 
     (void) getch();
 #endif /* PENGUIN */
 
@@ -259,12 +267,13 @@ static void intro(void)
 #endif /* A_COLOR */
 
 #ifdef NCURSES_MOUSE_VERSION
 #endif /* A_COLOR */
 
 #ifdef NCURSES_MOUSE_VERSION
-    (void) mousemask(BUTTON1_CLICKED, (mmask_t *)NULL);
-#endif /* NCURSES_MOUSE_VERSION*/
-}                  
+    (void) mousemask(BUTTON1_CLICKED, (mmask_t *) NULL);
+#endif /* NCURSES_MOUSE_VERSION */
+}
 
 /* VARARGS1 */
 
 /* VARARGS1 */
-static void prompt(int n, NCURSES_CONST char *f, const char *s)
+static void
+prompt(int n, NCURSES_CONST char *f, const char *s)
 /* print a message at the prompt line */
 {
     (void) move(PROMPTLINE + n, 0);
 /* print a message at the prompt line */
 {
     (void) move(PROMPTLINE + n, 0);
@@ -273,158 +282,155 @@ static void prompt(int n, NCURSES_CONST char *f, const char *s)
     (void) refresh();
 }
 
     (void) refresh();
 }
 
-static void error(NCURSES_CONST char *s)
+static void
+error(NCURSES_CONST char *s)
 {
     (void) move(PROMPTLINE + 2, 0);
     (void) clrtoeol();
 {
     (void) move(PROMPTLINE + 2, 0);
     (void) clrtoeol();
-    if (s)
-    {
+    if (s) {
        (void) addstr(s);
        (void) beep();
     }
 }
 
        (void) addstr(s);
        (void) beep();
     }
 }
 
-static void placeship(int b, ship_t *ss, int vis)
+static void
+placeship(int b, ship_t * ss, int vis)
 {
     int l;
 
 {
     int l;
 
-    for(l = 0; l < ss->length; ++l)
-    {
+    for (l = 0; l < ss->length; ++l) {
        int newx = ss->x + l * xincr[ss->dir];
        int newy = ss->y + l * yincr[ss->dir];
 
        board[b][newx][newy] = ss->symbol;
        int newx = ss->x + l * xincr[ss->dir];
        int newy = ss->y + l * yincr[ss->dir];
 
        board[b][newx][newy] = ss->symbol;
-       if (vis)
-       {
+       if (vis) {
            pgoto(newy, newx);
            pgoto(newy, newx);
-           (void) addch((chtype)ss->symbol);
+           (void) addch((chtype) ss->symbol);
        }
     }
     ss->hits = 0;
 }
 
        }
     }
     ss->hits = 0;
 }
 
-static int rnd(int n)
+static int
+rnd(int n)
 {
 {
-    return(((rand() & 0x7FFF) % n));
+    return (((rand() & 0x7FFF) % n));
 }
 
 }
 
-static void randomplace(int b, ship_t *ss)
+static void
+randomplace(int b, ship_t * ss)
 /* generate a valid random ship placement into px,py */
 {
 /* generate a valid random ship placement into px,py */
 {
-    register int bwidth = BWIDTH - ss->length;
-    register int bdepth = BDEPTH - ss->length;
 
     do {
 
     do {
-       ss->y = rnd(bdepth);
-       ss->x = rnd(bwidth);
        ss->dir = rnd(2) ? E : S;
        ss->dir = rnd(2) ? E : S;
+       ss->x = rnd(BWIDTH - (ss->dir == E ? ss->length : 0));
+       ss->y = rnd(BDEPTH - (ss->dir == S ? ss->length : 0));
     } while
        (!checkplace(b, ss, FALSE));
 }
 
     } while
        (!checkplace(b, ss, FALSE));
 }
 
-static void initgame(void)
+static void
+initgame(void)
 {
     int i, j, unplaced;
     ship_t *ss;
 
     (void) clear();
 {
     int i, j, unplaced;
     ship_t *ss;
 
     (void) clear();
-    (void) mvaddstr(0,35,"BATTLESHIPS");
+    MvAddStr(0, 35, "BATTLESHIPS");
     (void) move(PROMPTLINE + 2, 0);
     announceopts();
 
     memset(board, 0, sizeof(char) * BWIDTH * BDEPTH * 2);
     (void) move(PROMPTLINE + 2, 0);
     announceopts();
 
     memset(board, 0, sizeof(char) * BWIDTH * BDEPTH * 2);
-    memset(hits,  0, sizeof(char) * BWIDTH * BDEPTH * 2);
-    for (i = 0; i < SHIPTYPES; i++)
-    {
+    memset(hits, 0, sizeof(char) * BWIDTH * BDEPTH * 2);
+    for (i = 0; i < SHIPTYPES; i++) {
        ss = cpuship + i;
 
        ss->x =
        ss = cpuship + i;
 
        ss->x =
-       ss->y =
-       ss->dir =
-       ss->hits = 0;
+           ss->y =
+           ss->dir =
+           ss->hits = 0;
        ss->placed = FALSE;
 
        ss = plyship + i;
 
        ss->x =
        ss->placed = FALSE;
 
        ss = plyship + i;
 
        ss->x =
-       ss->y =
-       ss->dir =
-       ss->hits = 0;
+           ss->y =
+           ss->dir =
+           ss->hits = 0;
        ss->placed = FALSE;
     }
 
     /* draw empty boards */
        ss->placed = FALSE;
     }
 
     /* draw empty boards */
-    (void) mvaddstr(PYBASE - 2, PXBASE + 5, "Main Board");
-    (void) mvaddstr(PYBASE - 1, PXBASE - 3,numbers);
-    for(i=0; i < BDEPTH; ++i)
-    {
-       (void) mvaddch(PYBASE + i, PXBASE - 3, (chtype)(i + 'A'));
+    MvAddStr(PYBASE - 2, PXBASE + 5, "Main Board");
+    MvAddStr(PYBASE - 1, PXBASE - 3, numbers);
+    for (i = 0; i < BDEPTH; ++i) {
+       MvAddCh(PYBASE + i, PXBASE - 3, (chtype) (i + 'A'));
 #ifdef A_COLOR
        if (has_colors())
 #ifdef A_COLOR
        if (has_colors())
-           attron(COLOR_PAIR(COLOR_BLUE));
+           attron((attr_t) COLOR_PAIR(COLOR_BLUE));
 #endif /* A_COLOR */
        (void) addch(' ');
        for (j = 0; j < BWIDTH; j++)
            (void) addstr(" . ");
 #ifdef A_COLOR
 #endif /* A_COLOR */
        (void) addch(' ');
        for (j = 0; j < BWIDTH; j++)
            (void) addstr(" . ");
 #ifdef A_COLOR
-       attrset(0);
+       (void) attrset(0);
 #endif /* A_COLOR */
        (void) addch(' ');
 #endif /* A_COLOR */
        (void) addch(' ');
-       (void) addch((chtype)(i + 'A'));
+       (void) addch((chtype) (i + 'A'));
     }
     }
-    (void) mvaddstr(PYBASE + BDEPTH, PXBASE - 3,numbers);
-    (void) mvaddstr(CYBASE - 2, CXBASE + 7,"Hit/Miss Board");
-    (void) mvaddstr(CYBASE - 1, CXBASE - 3, numbers);
-    for(i=0; i < BDEPTH; ++i)
-    {
-       (void) mvaddch(CYBASE + i, CXBASE - 3, (chtype)(i + 'A'));
+    MvAddStr(PYBASE + BDEPTH, PXBASE - 3, numbers);
+    MvAddStr(CYBASE - 2, CXBASE + 7, "Hit/Miss Board");
+    MvAddStr(CYBASE - 1, CXBASE - 3, numbers);
+    for (i = 0; i < BDEPTH; ++i) {
+       MvAddCh(CYBASE + i, CXBASE - 3, (chtype) (i + 'A'));
 #ifdef A_COLOR
        if (has_colors())
 #ifdef A_COLOR
        if (has_colors())
-           attron(COLOR_PAIR(COLOR_BLUE));
+           attron((attr_t) COLOR_PAIR(COLOR_BLUE));
 #endif /* A_COLOR */
        (void) addch(' ');
        for (j = 0; j < BWIDTH; j++)
            (void) addstr(" . ");
 #ifdef A_COLOR
 #endif /* A_COLOR */
        (void) addch(' ');
        for (j = 0; j < BWIDTH; j++)
            (void) addstr(" . ");
 #ifdef A_COLOR
-       attrset(0);
+       (void) attrset(0);
 #endif /* A_COLOR */
        (void) addch(' ');
 #endif /* A_COLOR */
        (void) addch(' ');
-       (void) addch((chtype)(i + 'A'));
+       (void) addch((chtype) (i + 'A'));
     }
 
     }
 
-    (void) mvaddstr(CYBASE + BDEPTH,CXBASE - 3,numbers);
-
-    (void) mvprintw(HYBASE,  HXBASE,
-                   "To position your ships: move the cursor to a spot, then");
-    (void) mvprintw(HYBASE+1,HXBASE,
-                   "type the first letter of a ship type to select it, then");
-    (void) mvprintw(HYBASE+2,HXBASE,
-                   "type a direction ([hjkl] or [4862]), indicating how the");
-    (void) mvprintw(HYBASE+3,HXBASE,
-                   "ship should be pointed. You may also type a ship letter");
-    (void) mvprintw(HYBASE+4,HXBASE,
-                   "followed by `r' to position it randomly, or type `R' to");
-    (void) mvprintw(HYBASE+5,HXBASE,
-                   "place all remaining ships randomly.");
-
-    (void) mvaddstr(MYBASE,   MXBASE, "Aiming keys:");
-    (void) mvaddstr(SYBASE,   SXBASE, "y k u    7 8 9");
-    (void) mvaddstr(SYBASE+1, SXBASE, " \\|/      \\|/ ");
-    (void) mvaddstr(SYBASE+2, SXBASE, "h-+-l    4-+-6");
-    (void) mvaddstr(SYBASE+3, SXBASE, " /|\\      /|\\ ");
-    (void) mvaddstr(SYBASE+4, SXBASE, "b j n    1 2 3");
+    MvAddStr(CYBASE + BDEPTH, CXBASE - 3, numbers);
+
+    MvPrintw(HYBASE, HXBASE,
+            "To position your ships: move the cursor to a spot, then");
+    MvPrintw(HYBASE + 1, HXBASE,
+            "type the first letter of a ship type to select it, then");
+    MvPrintw(HYBASE + 2, HXBASE,
+            "type a direction ([hjkl] or [4862]), indicating how the");
+    MvPrintw(HYBASE + 3, HXBASE,
+            "ship should be pointed. You may also type a ship letter");
+    MvPrintw(HYBASE + 4, HXBASE,
+            "followed by `r' to position it randomly, or type `R' to");
+    MvPrintw(HYBASE + 5, HXBASE,
+            "place all remaining ships randomly.");
+
+    MvAddStr(MYBASE, MXBASE, "Aiming keys:");
+    MvAddStr(SYBASE, SXBASE, "y k u    7 8 9");
+    MvAddStr(SYBASE + 1, SXBASE, " \\|/      \\|/ ");
+    MvAddStr(SYBASE + 2, SXBASE, "h-+-l    4-+-6");
+    MvAddStr(SYBASE + 3, SXBASE, " /|\\      /|\\ ");
+    MvAddStr(SYBASE + 4, SXBASE, "b j n    1 2 3");
 
     /* have the computer place ships */
 
     /* have the computer place ships */
-    for(ss = cpuship; ss < cpuship + SHIPTYPES; ss++)
-    {
+    for (ss = cpuship; ss < cpuship + SHIPTYPES; ss++) {
        randomplace(COMPUTER, ss);
        placeship(COMPUTER, ss, FALSE);
     }
 
        randomplace(COMPUTER, ss);
        placeship(COMPUTER, ss, FALSE);
     }
 
-    ss = (ship_t *)NULL;
     do {
        char c, docked[SHIPTYPES + 2], *cp = docked;
 
     do {
        char c, docked[SHIPTYPES + 2], *cp = docked;
 
+       ss = (ship_t *) NULL;
+
        /* figure which ships still wait to be placed */
        *cp++ = 'R';
        for (i = 0; i < SHIPTYPES; i++)
        /* figure which ships still wait to be placed */
        *cp++ = 'R';
        for (i = 0; i < SHIPTYPES; i++)
@@ -433,16 +439,15 @@ static void initgame(void)
        *cp = '\0';
 
        /* get a command letter */
        *cp = '\0';
 
        /* get a command letter */
-       prompt(1, "Type one of [%s] to pick a ship.", docked+1);
+       prompt(1, "Type one of [%s] to pick a ship.", docked + 1);
        do {
        do {
-           c = getcoord(PLAYER);
+           c = (char) getcoord(PLAYER);
        } while
            (!strchr(docked, c));
 
        if (c == 'R')
            (void) ungetch('R');
        } while
            (!strchr(docked, c));
 
        if (c == 'R')
            (void) ungetch('R');
-       else
-       {
+       else {
            /* map that into the corresponding symbol */
            for (ss = plyship; ss < plyship + SHIPTYPES; ss++)
                if (ss->symbol == c)
            /* map that into the corresponding symbol */
            for (ss = plyship; ss < plyship + SHIPTYPES; ss++)
                if (ss->symbol == c)
@@ -453,52 +458,56 @@ static void initgame(void)
        }
 
        do {
        }
 
        do {
-           c = getch();
+           c = (char) getch();
        } while
        } while
-           (!strchr("hjklrR", c) || c == FF);
-
-       if (c == FF)
-       {
-           (void)clearok(stdscr, TRUE);
-           (void)refresh();
-       }
-       else if (c == 'r')
-       {
+           (!(strchr("hjkl8462rR", c) || c == FF));
+
+       if (c == FF) {
+           (void) clearok(stdscr, TRUE);
+           (void) refresh();
+       } else if (ss == 0) {
+           beep();             /* simple to verify, unlikely to happen */
+       } else if (c == 'r') {
            prompt(1, "Random-placing your %s", ss->name);
            randomplace(PLAYER, ss);
            placeship(PLAYER, ss, TRUE);
            prompt(1, "Random-placing your %s", ss->name);
            randomplace(PLAYER, ss);
            placeship(PLAYER, ss, TRUE);
-           error((char *)NULL);
+           error((char *) NULL);
            ss->placed = TRUE;
            ss->placed = TRUE;
-       }           
-       else if (c == 'R')
-       {
+       } else if (c == 'R') {
            prompt(1, "Placing the rest of your fleet at random...", "");
            for (ss = plyship; ss < plyship + SHIPTYPES; ss++)
            prompt(1, "Placing the rest of your fleet at random...", "");
            for (ss = plyship; ss < plyship + SHIPTYPES; ss++)
-               if (!ss->placed)
-               {
+               if (!ss->placed) {
                    randomplace(PLAYER, ss);
                    placeship(PLAYER, ss, TRUE);
                    ss->placed = TRUE;
                }
                    randomplace(PLAYER, ss);
                    placeship(PLAYER, ss, TRUE);
                    ss->placed = TRUE;
                }
-           error((char *)NULL);
-       }           
-       else if (strchr("hjkl8462", c))
-       {
+           error((char *) NULL);
+       } else if (strchr("hjkl8462", c)) {
            ss->x = curx;
            ss->y = cury;
 
            ss->x = curx;
            ss->y = cury;
 
-           switch(c)
-           {
-           case 'k': case '8': ss->dir = N; break;
-           case 'j': case '2': ss->dir = S; break;
-           case 'h': case '4': ss->dir = W; break;
-           case 'l': case '6': ss->dir = E; break;
-           }       
+           switch (c) {
+           case 'k':
+           case '8':
+               ss->dir = N;
+               break;
+           case 'j':
+           case '2':
+               ss->dir = S;
+               break;
+           case 'h':
+           case '4':
+               ss->dir = W;
+               break;
+           case 'l':
+           case '6':
+               ss->dir = E;
+               break;
+           }
 
 
-           if (checkplace(PLAYER, ss, TRUE))
-           {
+           if (checkplace(PLAYER, ss, TRUE)) {
                placeship(PLAYER, ss, TRUE);
                placeship(PLAYER, ss, TRUE);
-               error((char *)NULL);
+               error((char *) NULL);
                ss->placed = TRUE;
            }
        }
                ss->placed = TRUE;
            }
        }
@@ -510,116 +519,112 @@ static void initgame(void)
 
     turn = rnd(2);
 
 
     turn = rnd(2);
 
-    (void) mvprintw(HYBASE,  HXBASE,
-                   "To fire, move the cursor to your chosen aiming point   ");
-    (void) mvprintw(HYBASE+1,  HXBASE,
-                   "and strike any key other than a motion key.            ");
-    (void) mvprintw(HYBASE+2,  HXBASE,
-                   "                                                       ");
-    (void) mvprintw(HYBASE+3,  HXBASE,
-                   "                                                       ");
-    (void) mvprintw(HYBASE+4,  HXBASE,
-                   "                                                       ");
-    (void) mvprintw(HYBASE+5,  HXBASE,
-                   "                                                       ");
+    MvPrintw(HYBASE, HXBASE,
+            "To fire, move the cursor to your chosen aiming point   ");
+    MvPrintw(HYBASE + 1, HXBASE,
+            "and strike any key other than a motion key.            ");
+    MvPrintw(HYBASE + 2, HXBASE,
+            "                                                       ");
+    MvPrintw(HYBASE + 3, HXBASE,
+            "                                                       ");
+    MvPrintw(HYBASE + 4, HXBASE,
+            "                                                       ");
+    MvPrintw(HYBASE + 5, HXBASE,
+            "                                                       ");
 
     (void) prompt(0, "Press any key to start...", "");
     (void) getch();
 }
 
 
     (void) prompt(0, "Press any key to start...", "");
     (void) getch();
 }
 
-static int getcoord(int atcpu)
+static int
+getcoord(int atcpu)
 {
     int ny, nx, c;
 
     if (atcpu)
 {
     int ny, nx, c;
 
     if (atcpu)
-       cgoto(cury,curx);
+       cgoto(cury, curx);
     else
        pgoto(cury, curx);
     else
        pgoto(cury, curx);
-    (void)refresh();
-    for (;;)
-    {
-       if (atcpu)
-       {
-           (void) mvprintw(CYBASE + BDEPTH+1, CXBASE+11, "(%d, %c)", curx, 'A'+cury);
+    (void) refresh();
+    for (;;) {
+       if (atcpu) {
+           MvPrintw(CYBASE + BDEPTH + 1, CXBASE + 11, "(%d, %c)",
+                    curx, 'A' + cury);
            cgoto(cury, curx);
            cgoto(cury, curx);
-       }
-       else
-       {
-           (void) mvprintw(PYBASE + BDEPTH+1, PXBASE+11, "(%d, %c)", curx, 'A'+cury);
+       } else {
+           MvPrintw(PYBASE + BDEPTH + 1, PXBASE + 11, "(%d, %c)",
+                    curx, 'A' + cury);
            pgoto(cury, curx);
        }
 
            pgoto(cury, curx);
        }
 
-       switch(c = getch())
-       {
-       case 'k': case '8':
-#ifdef KEY_MIN
+       switch (c = getch()) {
+       case 'k':
+       case '8':
        case KEY_UP:
        case KEY_UP:
-#endif /* KEY_MIN */
-           ny = cury+BDEPTH-1; nx = curx;
+           ny = cury + BDEPTH - 1;
+           nx = curx;
            break;
            break;
-       case 'j': case '2':
-#ifdef KEY_MIN
+       case 'j':
+       case '2':
        case KEY_DOWN:
        case KEY_DOWN:
-#endif /* KEY_MIN */
-           ny = cury+1;        nx = curx;
+           ny = cury + 1;
+           nx = curx;
            break;
            break;
-       case 'h': case '4':
-#ifdef KEY_MIN
+       case 'h':
+       case '4':
        case KEY_LEFT:
        case KEY_LEFT:
-#endif /* KEY_MIN */
-           ny = cury;          nx = curx+BWIDTH-1;
+           ny = cury;
+           nx = curx + BWIDTH - 1;
            break;
            break;
-       case 'l': case '6':
-#ifdef KEY_MIN
+       case 'l':
+       case '6':
        case KEY_RIGHT:
        case KEY_RIGHT:
-#endif /* KEY_MIN */
-           ny = cury;          nx = curx+1;
+           ny = cury;
+           nx = curx + 1;
            break;
            break;
-       case 'y': case '7':
-#ifdef KEY_MIN
+       case 'y':
+       case '7':
        case KEY_A1:
        case KEY_A1:
-#endif /* KEY_MIN */
-           ny = cury+BDEPTH-1; nx = curx+BWIDTH-1;
+           ny = cury + BDEPTH - 1;
+           nx = curx + BWIDTH - 1;
            break;
            break;
-       case 'b': case '1':
-#ifdef KEY_MIN
+       case 'b':
+       case '1':
        case KEY_C1:
        case KEY_C1:
-#endif /* KEY_MIN */
-           ny = cury+1;        nx = curx+BWIDTH-1;
+           ny = cury + 1;
+           nx = curx + BWIDTH - 1;
            break;
            break;
-       case 'u': case '9':
-#ifdef KEY_MIN
+       case 'u':
+       case '9':
        case KEY_A3:
        case KEY_A3:
-#endif /* KEY_MIN */
-           ny = cury+BDEPTH-1; nx = curx+1;
+           ny = cury + BDEPTH - 1;
+           nx = curx + 1;
            break;
            break;
-       case 'n': case '3':
-#ifdef KEY_MIN
+       case 'n':
+       case '3':
        case KEY_C3:
        case KEY_C3:
-#endif /* KEY_MIN */
-           ny = cury+1;        nx = curx+1;
+           ny = cury + 1;
+           nx = curx + 1;
            break;
        case FF:
            break;
        case FF:
-           nx = curx; ny = cury;
-           (void)clearok(stdscr, TRUE);
-           (void)refresh();
+           nx = curx;
+           ny = cury;
+           (void) clearok(stdscr, TRUE);
+           (void) refresh();
            break;
 #ifdef NCURSES_MOUSE_VERSION
        case KEY_MOUSE:
            {
            break;
 #ifdef NCURSES_MOUSE_VERSION
        case KEY_MOUSE:
            {
-               MEVENT  myevent;
+               MEVENT myevent;
 
                getmouse(&myevent);
                if (atcpu
 
                getmouse(&myevent);
                if (atcpu
-                       && myevent.y >= CY(0) && myevent.y <= CY(BDEPTH)
-                       && myevent.x >= CX(0) && myevent.x <= CX(BDEPTH))
-               {
+                   && myevent.y >= CY(0) && myevent.y <= CY(BDEPTH)
+                   && myevent.x >= CX(0) && myevent.x <= CX(BDEPTH)) {
                    curx = CXINV(myevent.x);
                    cury = CYINV(myevent.y);
                    curx = CXINV(myevent.x);
                    cury = CYINV(myevent.y);
-                   return(' ');
-               }
-               else
-               {
+                   return (' ');
+               } else {
                    beep();
                    continue;
                }
                    beep();
                    continue;
                }
@@ -629,10 +634,10 @@ static int getcoord(int atcpu)
 
        default:
            if (atcpu)
 
        default:
            if (atcpu)
-               (void) mvaddstr(CYBASE + BDEPTH + 1, CXBASE + 11, "      ");
+               MvAddStr(CYBASE + BDEPTH + 1, CXBASE + 11, "      ");
            else
            else
-               (void) mvaddstr(PYBASE + BDEPTH + 1, PXBASE + 11, "      ");
-           return(c);
+               MvAddStr(PYBASE + BDEPTH + 1, PXBASE + 11, "      ");
+           return (c);
        }
 
        curx = nx % BWIDTH;
        }
 
        curx = nx % BWIDTH;
@@ -640,48 +645,46 @@ static int getcoord(int atcpu)
     }
 }
 
     }
 }
 
-static bool collidecheck(int b, int y, int x)
+static bool
+collidecheck(int b, int y, int x)
 /* is this location on the selected zboard adjacent to a ship? */
 {
     bool collide;
 
     /* anything on the square */
     if ((collide = IS_SHIP(board[b][x][y])) != FALSE)
 /* is this location on the selected zboard adjacent to a ship? */
 {
     bool collide;
 
     /* anything on the square */
     if ((collide = IS_SHIP(board[b][x][y])) != FALSE)
-       return(collide);
+       return (collide);
 
     /* anything on the neighbors */
 
     /* anything on the neighbors */
-    if (!closepack)
-    {
+    if (!closepack) {
        int i;
 
        int i;
 
-       for (i = 0; i < 8; i++)
-       {
+       for (i = 0; i < 8; i++) {
            int xend, yend;
 
            yend = y + yincr[i];
            xend = x + xincr[i];
            if (ONBOARD(xend, yend)
            int xend, yend;
 
            yend = y + yincr[i];
            xend = x + xincr[i];
            if (ONBOARD(xend, yend)
-            && IS_SHIP(board[b][xend][yend])) {
+               && IS_SHIP(board[b][xend][yend])) {
                collide = TRUE;
                break;
            }
        }
     }
                collide = TRUE;
                break;
            }
        }
     }
-    return(collide);
+    return (collide);
 }
 
 }
 
-static bool checkplace(int b, ship_t *ss, int vis)
+static bool
+checkplace(int b, ship_t * ss, int vis)
 {
     int l, xend, yend;
 
     /* first, check for board edges */
 {
     int l, xend, yend;
 
     /* first, check for board edges */
-    xend = ss->x + ss->length * xincr[ss->dir];
-    yend = ss->y + ss->length * yincr[ss->dir];
-    if (!ONBOARD(xend, yend))
-    {
+    xend = ss->x + (ss->length - 1) * xincr[ss->dir];
+    yend = ss->y + (ss->length - 1) * yincr[ss->dir];
+    if (!ONBOARD(xend, yend)) {
        if (vis)
        if (vis)
-           switch(rnd(3))
-           {
+           switch (rnd(3)) {
            case 0:
                error("Ship is hanging from the edge of the world");
                break;
            case 0:
                error("Ship is hanging from the edge of the world");
                break;
@@ -692,50 +695,48 @@ static bool checkplace(int b, ship_t *ss, int vis)
                error("Figure I won't find it if you put it there?");
                break;
            }
                error("Figure I won't find it if you put it there?");
                break;
            }
-       return(FALSE);
+       return (FALSE);
     }
 
     }
 
-    for(l = 0; l < ss->length; ++l)
-    {
-       if(collidecheck(b, ss->y+l*yincr[ss->dir], ss->x+l*xincr[ss->dir]))
-       {
+    for (l = 0; l < ss->length; ++l) {
+       if (collidecheck(b, ss->y + l * yincr[ss->dir], ss->x + l * xincr[ss->dir])) {
            if (vis)
            if (vis)
-               switch(rnd(3))
-               {
-                   case 0:
-                       error("There's already a ship there");
-                       break;
-                   case 1:
-                       error("Collision alert!  Aaaaaagh!");
-                       break;
-                   case 2:
-                       error("Er, Admiral, what about the other ship?");
-                       break;
-                   }
-           return(FALSE);
-           }
+               switch (rnd(3)) {
+               case 0:
+                   error("There's already a ship there");
+                   break;
+               case 1:
+                   error("Collision alert!  Aaaaaagh!");
+                   break;
+               case 2:
+                   error("Er, Admiral, what about the other ship?");
+                   break;
+               }
+           return (FALSE);
        }
        }
-    return(TRUE);
+    }
+    return (TRUE);
 }
 
 }
 
-static int awinna(void)
+static int
+awinna(void)
 {
     int i, j;
     ship_t *ss;
 
 {
     int i, j;
     ship_t *ss;
 
-    for(i=0; i<2; ++i)
-    {
+    for (i = 0; i < 2; ++i) {
        ss = (i) ? cpuship : plyship;
        ss = (i) ? cpuship : plyship;
-       for(j=0; j < SHIPTYPES; ++j, ++ss)
-           if(ss->length > ss->hits)
+       for (j = 0; j < SHIPTYPES; ++j, ++ss)
+           if (ss->length > ss->hits)
                break;
        if (j == SHIPTYPES)
                break;
        if (j == SHIPTYPES)
-           return(OTHER);
+           return (OTHER);
     }
     }
-    return(-1);
+    return (-1);
 }
 
 }
 
-static ship_t *hitship(int x, int y)
+static ship_t *
+hitship(int x, int y)
 /* register a hit on the targeted ship */
 {
     ship_t *sb, *ss;
 /* register a hit on the targeted ship */
 {
     ship_t *sb, *ss;
@@ -744,108 +745,109 @@ static ship_t *hitship(int x, int y)
 
     getyx(stdscr, oldy, oldx);
     sb = (turn) ? plyship : cpuship;
 
     getyx(stdscr, oldy, oldx);
     sb = (turn) ? plyship : cpuship;
-    if((sym = board[OTHER][x][y]) == 0)
-       return((ship_t *)NULL);
-    for(ss = sb; ss < sb + SHIPTYPES; ++ss)
-       if(ss->symbol == sym)
-       {
+    if ((sym = board[OTHER][x][y]) == 0)
+       return ((ship_t *) NULL);
+    for (ss = sb; ss < sb + SHIPTYPES; ++ss)
+       if (ss->symbol == sym) {
            if (++ss->hits < ss->length)        /* still afloat? */
            if (++ss->hits < ss->length)        /* still afloat? */
-               return((ship_t *)NULL);
-           else                                /* sunk! */
-           {
+               return ((ship_t *) NULL);
+           else {              /* sunk! */
                int i, j;
 
                if (!closepack)
                int i, j;
 
                if (!closepack)
-                   for (j = -1; j <= 1; j++)
-                   {
+                   for (j = -1; j <= 1; j++) {
                        int bx = ss->x + j * xincr[(ss->dir + 2) % 8];
                        int by = ss->y + j * yincr[(ss->dir + 2) % 8];
 
                        int bx = ss->x + j * xincr[(ss->dir + 2) % 8];
                        int by = ss->y + j * yincr[(ss->dir + 2) % 8];
 
-                       for (i = -1; i <= ss->length; ++i)
-                       {
+                       for (i = -1; i <= ss->length; ++i) {
                            int x1, y1;
                            int x1, y1;
-                           
+
                            x1 = bx + i * xincr[ss->dir];
                            y1 = by + i * yincr[ss->dir];
                            x1 = bx + i * xincr[ss->dir];
                            y1 = by + i * yincr[ss->dir];
-                           if (ONBOARD(x1, y1))
-                           {
+                           if (ONBOARD(x1, y1)) {
                                hits[turn][x1][y1] = MARK_MISS;
                                hits[turn][x1][y1] = MARK_MISS;
-                               if (turn % 2 == PLAYER)
-                               {
+                               if (turn % 2 == PLAYER) {
                                    cgoto(y1, x1);
 #ifdef A_COLOR
                                    if (has_colors())
                                    cgoto(y1, x1);
 #ifdef A_COLOR
                                    if (has_colors())
-                                       attron(COLOR_PAIR(COLOR_GREEN));
+                                       attron((attr_t) COLOR_PAIR(COLOR_GREEN));
 #endif /* A_COLOR */
 #endif /* A_COLOR */
-                                   (void)addch(MARK_MISS);
+                                   (void) addch(MARK_MISS);
 #ifdef A_COLOR
 #ifdef A_COLOR
-                                   attrset(0);
+                                   (void) attrset(0);
 #endif /* A_COLOR */
 #endif /* A_COLOR */
+                               } else {
+                                   pgoto(y1, x1);
+                                   (void) addch(SHOWSPLASH);
                                }
                            }
                        }
                    }
 
                                }
                            }
                        }
                    }
 
-               for (i = 0; i < ss->length; ++i)
-               {
+               for (i = 0; i < ss->length; ++i) {
                    int x1 = ss->x + i * xincr[ss->dir];
                    int y1 = ss->y + i * yincr[ss->dir];
 
                    hits[turn][x1][y1] = ss->symbol;
                    int x1 = ss->x + i * xincr[ss->dir];
                    int y1 = ss->y + i * yincr[ss->dir];
 
                    hits[turn][x1][y1] = ss->symbol;
-                   if (turn % 2 == PLAYER)
-                   {
+                   if (turn % 2 == PLAYER) {
                        cgoto(y1, x1);
                        cgoto(y1, x1);
-                       (void) addch((chtype)(ss->symbol));
+                       (void) addch((chtype) (ss->symbol));
+                   } else {
+                       pgoto(y1, x1);
+#ifdef A_COLOR
+                       if (has_colors())
+                           attron((attr_t) COLOR_PAIR(COLOR_RED));
+#endif /* A_COLOR */
+                       (void) addch(SHOWHIT);
+#ifdef A_COLOR
+                       (void) attrset(0);
+#endif /* A_COLOR */
                    }
                }
 
                (void) move(oldy, oldx);
                    }
                }
 
                (void) move(oldy, oldx);
-               return(ss);
+               return (ss);
            }
        }
     (void) move(oldy, oldx);
            }
        }
     (void) move(oldy, oldx);
-    return((ship_t *)NULL);
+    return ((ship_t *) NULL);
 }
 
 }
 
-static int plyturn(void)
+static bool
+plyturn(void)
 {
     ship_t *ss;
     bool hit;
     NCURSES_CONST char *m = NULL;
 
     prompt(1, "Where do you want to shoot? ", "");
 {
     ship_t *ss;
     bool hit;
     NCURSES_CONST char *m = NULL;
 
     prompt(1, "Where do you want to shoot? ", "");
-    for (;;)
-    {
+    for (;;) {
        (void) getcoord(COMPUTER);
        (void) getcoord(COMPUTER);
-       if (hits[PLAYER][curx][cury])
-       {
+       if (hits[PLAYER][curx][cury]) {
            prompt(1, "You shelled this spot already! Try again.", "");
            beep();
            prompt(1, "You shelled this spot already! Try again.", "");
            beep();
-       }
-       else
+       } else
            break;
     }
     hit = IS_SHIP(board[COMPUTER][curx][cury]);
            break;
     }
     hit = IS_SHIP(board[COMPUTER][curx][cury]);
-    hits[PLAYER][curx][cury] = (hit ? MARK_HIT : MARK_MISS);
+    hits[PLAYER][curx][cury] = (char) (hit ? MARK_HIT : MARK_MISS);
     cgoto(cury, curx);
 #ifdef A_COLOR
     if (has_colors()) {
        if (hit)
     cgoto(cury, curx);
 #ifdef A_COLOR
     if (has_colors()) {
        if (hit)
-           attron(COLOR_PAIR(COLOR_RED));
+           attron((attr_t) COLOR_PAIR(COLOR_RED));
        else
        else
-           attron(COLOR_PAIR(COLOR_GREEN));
+           attron((attr_t) COLOR_PAIR(COLOR_GREEN));
     }
 #endif /* A_COLOR */
     }
 #endif /* A_COLOR */
-    (void) addch((chtype)hits[PLAYER][curx][cury]);
+    (void) addch((chtype) hits[PLAYER][curx][cury]);
 #ifdef A_COLOR
 #ifdef A_COLOR
-    attrset(0);
+    (void) attrset(0);
 #endif /* A_COLOR */
 
     prompt(1, "You %s.", hit ? "scored a hit" : "missed");
 #endif /* A_COLOR */
 
     prompt(1, "You %s.", hit ? "scored a hit" : "missed");
-    if(hit && (ss = hitship(curx, cury)))
-    {
-       switch(rnd(5))
-       {
+    if (hit && (ss = hitship(curx, cury))) {
+       switch (rnd(5)) {
        case 0:
            m = " You sank my %s!";
            break;
        case 0:
            m = " You sank my %s!";
            break;
@@ -862,44 +864,44 @@ static int plyturn(void)
            m = " You'll pick up survivors from my %s, I hope...!";
            break;
        }
            m = " You'll pick up survivors from my %s, I hope...!";
            break;
        }
-       (void)printw(m, ss->name);
-       (void)beep();
-       return(awinna() == -1);
+       if (m != 0) {
+           (void) printw(m, ss->name);
+       }
+       (void) beep();
     }
     return (hit);
 }
 
     }
     return (hit);
 }
 
-static int sgetc(const char *s)
+static int
+sgetc(const char *s)
 {
     const char *s1;
     int ch;
 
 {
     const char *s1;
     int ch;
 
-    (void)refresh();
-    for(;;)
-    {
+    (void) refresh();
+    for (;;) {
        ch = getch();
        if (islower(ch))
            ch = toupper(ch);
        if (ch == CTRLC)
            uninitgame(0);
        ch = getch();
        if (islower(ch))
            ch = toupper(ch);
        if (ch == CTRLC)
            uninitgame(0);
-       for (s1=s; *s1 && ch != *s1; ++s1)
+       for (s1 = s; *s1 && ch != *s1; ++s1)
            continue;
            continue;
-       if (*s1)
-       {
-           (void) addch((chtype)ch);
-           (void)refresh();
-           return(ch);
-           }
+       if (*s1) {
+           (void) addch((chtype) ch);
+           (void) refresh();
+           return (ch);
        }
        }
+    }
 }
 
 }
 
-
-static void randomfire(int *px, int *py)
+static void
+randomfire(int *px, int *py)
 /* random-fire routine -- implements simple diagonal-striping strategy */
 {
     static int turncount = 0;
     static int srchstep = BEGINSTEP;
 /* random-fire routine -- implements simple diagonal-striping strategy */
 {
     static int turncount = 0;
     static int srchstep = BEGINSTEP;
-    static int huntoffs;               /* Offset on search strategy */
+    static int huntoffs;       /* Offset on search strategy */
     int ypossible[BWIDTH * BDEPTH], xpossible[BWIDTH * BDEPTH], nposs;
     int ypreferred[BWIDTH * BDEPTH], xpreferred[BWIDTH * BDEPTH], npref;
     int x, y, i;
     int ypossible[BWIDTH * BDEPTH], xpossible[BWIDTH * BDEPTH], nposs;
     int ypreferred[BWIDTH * BDEPTH], xpreferred[BWIDTH * BDEPTH], npref;
     int x, y, i;
@@ -911,28 +913,23 @@ static void randomfire(int *px, int *py)
     nposs = npref = 0;
     for (x = 0; x < BWIDTH; x++)
        for (y = 0; y < BDEPTH; y++)
     nposs = npref = 0;
     for (x = 0; x < BWIDTH; x++)
        for (y = 0; y < BDEPTH; y++)
-           if (!hits[COMPUTER][x][y])
-           {
+           if (!hits[COMPUTER][x][y]) {
                xpossible[nposs] = x;
                ypossible[nposs] = y;
                nposs++;
                xpossible[nposs] = x;
                ypossible[nposs] = y;
                nposs++;
-               if (((x+huntoffs) % srchstep) != (y % srchstep))
-               {
+               if (((x + huntoffs) % srchstep) != (y % srchstep)) {
                    xpreferred[npref] = x;
                    ypreferred[npref] = y;
                    npref++;
                }
            }
 
                    xpreferred[npref] = x;
                    ypreferred[npref] = y;
                    npref++;
                }
            }
 
-    if (npref)
-    {
+    if (npref) {
        i = rnd(npref);
 
        *px = xpreferred[i];
        *py = ypreferred[i];
        i = rnd(npref);
 
        *px = xpreferred[i];
        *py = ypreferred[i];
-    }
-    else if (nposs)
-    {
+    } else if (nposs) {
        i = rnd(nposs);
 
        *px = xpossible[i];
        i = rnd(nposs);
 
        *px = xpossible[i];
@@ -940,12 +937,10 @@ static void randomfire(int *px, int *py)
 
        if (srchstep > 1)
            --srchstep;
 
        if (srchstep > 1)
            --srchstep;
-    }
-    else
-    {
+    } else {
        error("No moves possible?? Help!");
        error("No moves possible?? Help!");
-       exit(EXIT_FAILURE);
-       /*NOTREACHED*/
+       ExitProgram(EXIT_FAILURE);
+       /*NOTREACHED */
     }
 }
 
     }
 }
 
@@ -953,42 +948,50 @@ static void randomfire(int *px, int *py)
 #define S_HIT  1
 #define S_SUNK -1
 
 #define S_HIT  1
 #define S_SUNK -1
 
-static int cpufire(int x, int y)
+static int
+cpufire(int x, int y)
 /* fire away at given location */
 {
     bool hit, sunk;
     ship_t *ss = NULL;
 
 /* fire away at given location */
 {
     bool hit, sunk;
     ship_t *ss = NULL;
 
-    hits[COMPUTER][x][y] = (hit = (board[PLAYER][x][y])) ? MARK_HIT : MARK_MISS;
-    (void) mvprintw(PROMPTLINE, 0,
-       "I shoot at %c%d. I %s!", y + 'A', x, hit ? "hit" : "miss");
+    hit = board[PLAYER][x][y] ? MARK_HIT : MARK_MISS;
+    hits[COMPUTER][x][y] = (char) hit;
+    MvPrintw(PROMPTLINE, 0,
+            "I shoot at %c%d. I %s!", y + 'A', x, hit ? "hit" :
+            "miss");
     if ((sunk = (hit && (ss = hitship(x, y)))) != 0)
        (void) printw(" I've sunk your %s", ss->name);
     if ((sunk = (hit && (ss = hitship(x, y)))) != 0)
        (void) printw(" I've sunk your %s", ss->name);
-    (void)clrtoeol();
+    (void) clrtoeol();
 
     pgoto(y, x);
 #ifdef A_COLOR
     if (has_colors()) {
        if (hit)
 
     pgoto(y, x);
 #ifdef A_COLOR
     if (has_colors()) {
        if (hit)
-           attron(COLOR_PAIR(COLOR_RED));
+           attron((attr_t) COLOR_PAIR(COLOR_RED));
        else
        else
-           attron(COLOR_PAIR(COLOR_GREEN));
+           attron((attr_t) COLOR_PAIR(COLOR_GREEN));
     }
 #endif /* A_COLOR */
     }
 #endif /* A_COLOR */
-    (void)addch((chtype)(hit ? SHOWHIT : SHOWSPLASH));
+    (void) addch((chtype) (hit ? SHOWHIT : SHOWSPLASH));
 #ifdef A_COLOR
 #ifdef A_COLOR
-    attrset(0);
+    (void) attrset(0);
 #endif /* A_COLOR */
 
 #endif /* A_COLOR */
 
-    return ((hit ? (sunk ? S_SUNK : S_HIT) : S_MISS) ? TRUE : FALSE);
+    return hit ? (sunk ? S_SUNK : S_HIT) : S_MISS;
 }
 
 /*
  * This code implements a fairly irregular FSM, so please forgive the rampant
  * unstructuredness below. The five labels are states which need to be held
  * between computer turns.
 }
 
 /*
  * This code implements a fairly irregular FSM, so please forgive the rampant
  * unstructuredness below. The five labels are states which need to be held
  * between computer turns.
+ *
+ * The FSM is not externally reset to RANDOM_FIRE if the player wins. Instead,
+ * the other states check for "impossible" conditions which signify a new
+ * game, then if found transition to RANDOM_FIRE.
  */
  */
-static bool cputurn(void)
+static bool
+cputurn(void)
 {
 #define POSSIBLE(x, y) (ONBOARD(x, y) && !hits[COMPUTER][x][y])
 #define RANDOM_FIRE    0
 {
 #define POSSIBLE(x, y) (ONBOARD(x, y) && !hits[COMPUTER][x][y])
 #define RANDOM_FIRE    0
@@ -1003,29 +1006,28 @@ static bool cputurn(void)
     int navail, x, y, d, n;
     int hit = S_MISS;
 
     int navail, x, y, d, n;
     int hit = S_MISS;
 
-    switch(next)
-    {
-    case RANDOM_FIRE:  /* last shot was random and missed */
-    refire:
+    switch (next) {
+    case RANDOM_FIRE:          /* last shot was random and missed */
+      refire:
        randomfire(&x, &y);
        if (!(hit = cpufire(x, y)))
            next = RANDOM_FIRE;
        randomfire(&x, &y);
        if (!(hit = cpufire(x, y)))
            next = RANDOM_FIRE;
-       else
-       {
-           ts.x = x; ts.y = y;
+       else {
+           ts.x = x;
+           ts.y = y;
            ts.hits = 1;
            next = (hit == S_SUNK) ? RANDOM_FIRE : RANDOM_HIT;
        }
        break;
 
            ts.hits = 1;
            next = (hit == S_SUNK) ? RANDOM_FIRE : RANDOM_HIT;
        }
        break;
 
-    case RANDOM_HIT:   /* last shot was random and hit */
-       used[E/2] = used[S/2] = used[W/2] = used[N/2] = FALSE;
+    case RANDOM_HIT:           /* last shot was random and hit */
+       used[E / 2] = used[S / 2] = used[W / 2] = used[N / 2] = FALSE;
        /* FALLTHROUGH */
 
        /* FALLTHROUGH */
 
-    case HUNT_DIRECT:  /* last shot hit, we're looking for ship's long axis */
-       for (d = navail = 0; d < 4; d++)
-       {
-           x = ts.x + xincr[d*2]; y = ts.y + yincr[d*2];
+    case HUNT_DIRECT:          /* last shot hit, we're looking for ship's long axis */
+       for (d = navail = 0; d < 4; d++) {
+           x = ts.x + xincr[d * 2];
+           y = ts.y + yincr[d * 2];
            if (!used[d] && POSSIBLE(x, y))
                navail++;
            else
            if (!used[d] && POSSIBLE(x, y))
                navail++;
            else
@@ -1033,126 +1035,125 @@ static bool cputurn(void)
        }
        if (navail == 0)        /* no valid places for shots adjacent... */
            goto refire;        /* ...so we must random-fire */
        }
        if (navail == 0)        /* no valid places for shots adjacent... */
            goto refire;        /* ...so we must random-fire */
-       else
-       {
-           for (d = 0, n = rnd(navail) + 1; n; n--)
-               while (used[d])
-                   d++;
+       else {
+           n = rnd(navail) + 1;
+           for (d = 0; used[d]; d++) ;
+           /* used[d] is first that == 0 */
+           for (; n > 1; n--)
+               while (used[++d]) ;
+           /* used[d] is next that == 0 */
 
 
-           assert(d <= 4);
+           assert(d < 4);
+           assert(used[d] == FALSE);
 
 
-           used[d] = FALSE;
-           x = ts.x + xincr[d*2];
-           y = ts.y + yincr[d*2];
+           used[d] = TRUE;
+           x = ts.x + xincr[d * 2];
+           y = ts.y + yincr[d * 2];
 
            assert(POSSIBLE(x, y));
 
            if (!(hit = cpufire(x, y)))
                next = HUNT_DIRECT;
 
            assert(POSSIBLE(x, y));
 
            if (!(hit = cpufire(x, y)))
                next = HUNT_DIRECT;
-           else
-           {
-               ts.x = x; ts.y = y; ts.dir = d*2; ts.hits++;
+           else {
+               ts.x = x;
+               ts.y = y;
+               ts.dir = d * 2;
+               ts.hits++;
                next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS;
            }
        }
        break;
 
                next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS;
            }
        }
        break;
 
-    case FIRST_PASS:   /* we have a start and a direction now */
+    case FIRST_PASS:           /* we have a start and a direction now */
        x = ts.x + xincr[ts.dir];
        y = ts.y + yincr[ts.dir];
        x = ts.x + xincr[ts.dir];
        y = ts.y + yincr[ts.dir];
-       if (POSSIBLE(x, y) && (hit = cpufire(x, y)))
-       {
-           ts.x = x; ts.y = y; ts.hits++;
+       if (POSSIBLE(x, y) && (hit = cpufire(x, y))) {
+           ts.x = x;
+           ts.y = y;
+           ts.hits++;
            next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS;
            next = (hit == S_SUNK) ? RANDOM_FIRE : FIRST_PASS;
-       }
-       else
+       } else
            next = REVERSE_JUMP;
        break;
 
            next = REVERSE_JUMP;
        break;
 
-    case REVERSE_JUMP: /* nail down the ship's other end */
-       d = ts.dir + 4;
+    case REVERSE_JUMP:         /* nail down the ship's other end */
+       d = (ts.dir + 4) % 8;
        x = ts.x + ts.hits * xincr[d];
        y = ts.y + ts.hits * yincr[d];
        x = ts.x + ts.hits * xincr[d];
        y = ts.y + ts.hits * yincr[d];
-       if (POSSIBLE(x, y) && (hit = cpufire(x, y)))
-       {
-           ts.x = x; ts.y = y; ts.dir = d; ts.hits++;
+       if (POSSIBLE(x, y) && (hit = cpufire(x, y))) {
+           ts.x = x;
+           ts.y = y;
+           ts.dir = d;
+           ts.hits++;
            next = (hit == S_SUNK) ? RANDOM_FIRE : SECOND_PASS;
            next = (hit == S_SUNK) ? RANDOM_FIRE : SECOND_PASS;
-       }
-       else
+       } else
            next = RANDOM_FIRE;
        break;
 
            next = RANDOM_FIRE;
        break;
 
-    case SECOND_PASS:  /* kill squares not caught on first pass */
+    case SECOND_PASS:          /* continue shooting after reversing */
        x = ts.x + xincr[ts.dir];
        y = ts.y + yincr[ts.dir];
        x = ts.x + xincr[ts.dir];
        y = ts.y + yincr[ts.dir];
-       if (POSSIBLE(x, y) && (hit = cpufire(x, y)))
-       {
-           ts.x = x; ts.y = y; ts.hits++;
-           next = (hit == S_SUNK) ? RANDOM_FIRE: SECOND_PASS;
+       if (POSSIBLE(x, y) && (hit = cpufire(x, y))) {
+           ts.x = x;
+           ts.y = y;
+           ts.hits++;
+           next = (hit == S_SUNK) ? RANDOM_FIRE : SECOND_PASS;
            break;
            break;
-       }
-       else
+       } else
            next = RANDOM_FIRE;
        break;
     }
 
            next = RANDOM_FIRE;
        break;
     }
 
-    /* check for continuation and/or winner */
-    if (salvo)
-    {
-       (void)refresh();
-       (void)sleep(1);
+    /* pause between shots in salvo */
+    if (salvo) {
+       (void) refresh();
+       (void) sleep(1);
     }
     }
-    if (awinna() != -1)
-       return(FALSE);
-
 #ifdef DEBUG
 #ifdef DEBUG
-    (void) mvprintw(PROMPTLINE + 2, 0,
-                   "New state %d, x=%d, y=%d, d=%d",
-                   next, x, y, d);
+    MvPrintw(PROMPTLINE + 2, 0,
+            "New state %d, x=%d, y=%d, d=%d",
+            next, x, y, d);
 #endif /* DEBUG */
     return ((hit) ? TRUE : FALSE);
 }
 
 #endif /* DEBUG */
     return ((hit) ? TRUE : FALSE);
 }
 
-static
-int playagain(void)
+static int
+playagain(void)
 {
     int j;
     ship_t *ss;
 
     for (ss = cpuship; ss < cpuship + SHIPTYPES; ss++)
 {
     int j;
     ship_t *ss;
 
     for (ss = cpuship; ss < cpuship + SHIPTYPES; ss++)
-       for(j = 0; j < ss->length; j++)
-       {
+       for (j = 0; j < ss->length; j++) {
            cgoto(ss->y + j * yincr[ss->dir], ss->x + j * xincr[ss->dir]);
            cgoto(ss->y + j * yincr[ss->dir], ss->x + j * xincr[ss->dir]);
-           (void)addch((chtype)ss->symbol);
+           (void) addch((chtype) ss->symbol);
        }
 
        }
 
-    if(awinna())
+    if (awinna())
        ++cpuwon;
     else
        ++plywon;
        ++cpuwon;
     else
        ++plywon;
-    j = 18 + strlen(name);
-    if(plywon >= 10)
+    j = 18 + (int) strlen(name);
+    if (plywon >= 10)
        ++j;
        ++j;
-    if(cpuwon >= 10)
+    if (cpuwon >= 10)
        ++j;
        ++j;
-    (void) mvprintw(1,(COLWIDTH-j)/2,
-                   "%s: %d     Computer: %d",name,plywon,cpuwon);
+    MvPrintw(1, (COLWIDTH - j) / 2,
+            "%s: %d     Computer: %d", name, plywon, cpuwon);
 
 
-    prompt(2, (awinna()) ? "Want to be humiliated again, %s [yn]? "
-          : "Going to give me a chance for revenge, %s [yn]? ",name);
-    return(sgetc("YN") == 'Y');
+    prompt(2, (awinna())? "Want to be humiliated again, %s [yn]? "
+          : "Going to give me a chance for revenge, %s [yn]? ", name);
+    return (sgetc("YN") == 'Y');
 }
 
 }
 
-static void do_options(int c, char *op[])
+static void
+do_options(int c, char *op[])
 {
     register int i;
 
 {
     register int i;
 
-    if (c > 1)
-    {
-       for (i=1; i<c; i++)
-       {
-           switch(op[i][0])
-           {
+    if (c > 1) {
+       for (i = 1; i < c; i++) {
+           switch (op[i][0]) {
            default:
            case '?':
                (void) fprintf(stderr, "Usage: battle [-s | -b] [-c]\n");
            default:
            case '?':
                (void) fprintf(stderr, "Usage: battle [-s | -b] [-c]\n");
@@ -1160,27 +1161,24 @@ static void do_options(int c, char *op[])
                (void) fprintf(stderr, "\t-s : play a salvo game\n");
                (void) fprintf(stderr, "\t-b : play a blitz game\n");
                (void) fprintf(stderr, "\t-c : ships may be adjacent\n");
                (void) fprintf(stderr, "\t-s : play a salvo game\n");
                (void) fprintf(stderr, "\t-b : play a blitz game\n");
                (void) fprintf(stderr, "\t-c : ships may be adjacent\n");
-               exit(EXIT_FAILURE);
+               ExitProgram(EXIT_FAILURE);
                break;
            case '-':
                break;
            case '-':
-               switch(op[i][1])
-               {
+               switch (op[i][1]) {
                case 'b':
                    blitz = 1;
                case 'b':
                    blitz = 1;
-                   if (salvo == 1)
-                   {
+                   if (salvo == 1) {
                        (void) fprintf(stderr,
                        (void) fprintf(stderr,
-                               "Bad Arg: -b and -s are mutually exclusive\n");
-                       exit(EXIT_FAILURE);
+                                      "Bad Arg: -b and -s are mutually exclusive\n");
+                       ExitProgram(EXIT_FAILURE);
                    }
                    break;
                case 's':
                    salvo = 1;
                    }
                    break;
                case 's':
                    salvo = 1;
-                   if (blitz == 1)
-                   {
+                   if (blitz == 1) {
                        (void) fprintf(stderr,
                        (void) fprintf(stderr,
-                               "Bad Arg: -s and -b are mutually exclusive\n");
-                       exit(EXIT_FAILURE);
+                                      "Bad Arg: -s and -b are mutually exclusive\n");
+                       ExitProgram(EXIT_FAILURE);
                    }
                    break;
                case 'c':
                    }
                    break;
                case 'c':
@@ -1188,81 +1186,75 @@ static void do_options(int c, char *op[])
                    break;
                default:
                    (void) fprintf(stderr,
                    break;
                default:
                    (void) fprintf(stderr,
-                           "Bad arg: type \"%s ?\" for usage message\n", op[0]);
-                   exit(EXIT_FAILURE);
+                                  "Bad arg: type \"%s ?\" for usage message\n",
+                                  op[0]);
+                   ExitProgram(EXIT_FAILURE);
                }
            }
        }
     }
 }
 
                }
            }
        }
     }
 }
 
-static int scount(int who)
+static int
+scount(int who)
 {
     register int i, shots;
     register ship_t *sp;
 
     if (who)
 {
     register int i, shots;
     register ship_t *sp;
 
     if (who)
-       sp = cpuship;   /* count cpu shots */
+       sp = cpuship;           /* count cpu shots */
     else
     else
-       sp = plyship;   /* count player shots */
+       sp = plyship;           /* count player shots */
 
 
-    for (i=0, shots = 0; i < SHIPTYPES; i++, sp++)
-    {
+    for (i = 0, shots = 0; i < SHIPTYPES; i++, sp++) {
        if (sp->hits >= sp->length)
            continue;           /* dead ship */
        else
            shots++;
     }
        if (sp->hits >= sp->length)
            continue;           /* dead ship */
        else
            shots++;
     }
-    return(shots);
+    return (shots);
 }
 
 }
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
 {
+    setlocale(LC_ALL, "");
+
     do_options(argc, argv);
 
     intro();
     do {
        initgame();
     do_options(argc, argv);
 
     intro();
     do {
        initgame();
-       while(awinna() == -1)
-       {
-           if (!blitz)
-           {
-               if (!salvo)
-               {
-                   if(turn)
+       while (awinna() == -1) {
+           if (!blitz) {
+               if (!salvo) {
+                   if (turn)
                        (void) cputurn();
                    else
                        (void) plyturn();
                        (void) cputurn();
                    else
                        (void) plyturn();
-               }
-               else
-               {
+               } else {
                    register int i;
 
                    i = scount(turn);
                    register int i;
 
                    i = scount(turn);
-                   while (i--)
-                   {
-                       if (turn)
-                       {
+                   while (i--) {
+                       if (turn) {
                            if (cputurn() && awinna() != -1)
                                i = 0;
                            if (cputurn() && awinna() != -1)
                                i = 0;
-                       }
-                       else
-                       {
+                       } else {
                            if (plyturn() && awinna() != -1)
                                i = 0;
                        }
                    }
                            if (plyturn() && awinna() != -1)
                                i = 0;
                        }
                    }
-               } 
-           }
-           else
-               while(turn ? cputurn() : plyturn())
+               }
+           } else
+               while ((turn ? cputurn() : plyturn()) && awinna() == -1)
                    continue;
            turn = OTHER;
        }
     } while
        (playagain());
     uninitgame(0);
                    continue;
            turn = OTHER;
        }
     } while
        (playagain());
     uninitgame(0);
-    /*NOTREACHED*/
+    /*NOTREACHED */
 }
 
 /* bs.c ends here */
 }
 
 /* bs.c ends here */