]> git.cameronkatri.com Git - bsdgames-darwin.git/blobdiff - gomoku/bdisp.c
Avoid messing up the display when too many letters are guessed at once.
[bsdgames-darwin.git] / gomoku / bdisp.c
index bcb62c8e3d684c76a01462eb5b96e0eb35565647..db2e74a2235d03f813fd172eecb3150f85b5c872 100644 (file)
@@ -1,5 +1,5 @@
-/* $NetBSD: bdisp.c,v 1.2 1996/12/28 18:56:59 tls Exp $
-*/
+/*     $NetBSD: bdisp.c,v 1.17 2014/03/22 18:58:57 dholland Exp $      */
+
 /*
  * Copyright (c) 1994
  *     The Regents of the University of California.  All rights reserved.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *     This product includes software developed by the University of
- *     California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
+ * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * SUCH DAMAGE.
  */
 
+#include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)bdisp.c    8.2 (Berkeley) 5/3/95";
 #else
-static char rcsid[] = "$NetBSD: bdisp.c,v 1.2 1996/12/28 18:56:59 tls Exp $";
+__RCSID("$NetBSD: bdisp.c,v 1.17 2014/03/22 18:58:57 dholland Exp $");
 #endif
 #endif /* not lint */
 
-#include "gomoku.h"
-#include <stdio.h>
 #include <curses.h>
+#include <string.h>
+#include <stdlib.h>
+#include <err.h>
+#include "gomoku.h"
 
 #define        SCRNH           24              /* assume 24 lines for the moment */
 #define        SCRNW           80              /* assume 80 chars for the moment */
@@ -57,34 +56,49 @@ static      char    pcolor[] = "*O.?";
 /*
  * Initialize screen display.
  */
-cursinit()
+void
+cursinit(void)
 {
 
-       initscr();
+       if (!initscr()) {
+               errx(EXIT_FAILURE, "Couldn't initialize screen");
+       }
+       if ((LINES < SCRNH) || (COLS < SCRNW)) {
+               errx(EXIT_FAILURE, "Screen too small (need %d%xd)",
+                   SCRNW, SCRNH);
+       }
+       keypad(stdscr, TRUE);
+       nonl();
        noecho();
        cbreak();
-       leaveok(stdscr, TRUE);
+       leaveok(stdscr, FALSE);
+
+#if 0 /* no mouse support in netbsd curses yet */
+       mousemask(BUTTON1_CLICKED, NULL);
+#endif
 }
 
 /*
  * Restore screen display.
  */
-cursfini()
+void
+cursfini(void)
 {
 
-       leaveok(stdscr, FALSE);
-       move(23, 0);
+       move(BSZ4, 0);
        clrtoeol();
        refresh();
+       echo();
        endwin();
 }
 
 /*
  * Initialize board display.
  */
-bdisp_init()
+void
+bdisp_init(void)
 {
-       register int i, j;
+       int i, j;
 
        /* top border */
        for (i = 1; i < BSZ1; i++) {
@@ -113,22 +127,31 @@ bdisp_init()
 /*
  * Update who is playing whom.
  */
-bdwho(update)
-       int update;
+void
+bdwho(int update)
 {
-       int i;
-       extern char *plyr[];
+       int i, j;
 
        move(21, 0);
-       clrtoeol();
-       i = 6 - strlen(plyr[BLACK]) / 2;
-       move(21, i > 0 ? i : 0);
-       printw("BLACK/%s", plyr[BLACK]);
-       i = 30 - strlen(plyr[WHITE]) / 2;
-       move(21, i);
-       printw("WHITE/%s", plyr[WHITE]);
-       move(21, 19);
-       addstr(" vs. ");
+        printw("                                              ");
+       i = strlen(plyr[BLACK]);
+       j = strlen(plyr[WHITE]);
+       if (i + j <= 20) {
+               move(21, 10 - (i+j)/2);
+               printw("BLACK/%s (*) vs. WHITE/%s (O)",
+                   plyr[BLACK], plyr[WHITE]);
+       } else {
+               move(21, 0);
+               if (i <= 10) {
+                       j = 20 - i;
+               } else if (j <= 10) {
+                       i = 20 - j;
+               } else {
+                       i = j = 10;
+               }
+               printw("BLACK/%.*s (*) vs. WHITE/%.*s (O)",
+                   i, plyr[BLACK], j, plyr[WHITE]);
+       }
        if (update)
                refresh();
 }
@@ -136,19 +159,20 @@ bdwho(update)
 /*
  * Update the board display after a move.
  */
-bdisp()
+void
+bdisp(void)
 {
-       register int i, j, c;
-       register struct spotstr *sp;
+       int i, j, c;
+       struct spotstr *sp;
 
        for (j = BSZ1; --j > 0; ) {
                for (i = 1; i < BSZ1; i++) {
                        move(BSZ1 - j, 2 * i + 1);
                        sp = &board[i + j * BSZ1];
                        if (debug > 1 && sp->s_occ == EMPTY) {
-                               if (sp->s_flg & IFLAGALL)
+                               if (sp->s_flags & IFLAGALL)
                                        c = '+';
-                               else if (sp->s_flg & CFLAGALL)
+                               else if (sp->s_flags & CFLAGALL)
                                        c = '-';
                                else
                                        c = '.';
@@ -164,11 +188,11 @@ bdisp()
 /*
  * Dump board display to a file.
  */
-bdump(fp)
-       FILE *fp;
+void
+bdump(FILE *fp)
 {
-       register int i, j, c;
-       register struct spotstr *sp;
+       int i, j, c;
+       struct spotstr *sp;
 
        /* top border */
        fprintf(fp, "   A B C D E F G H J K L M N O P Q R S T\n");
@@ -179,9 +203,9 @@ bdump(fp)
                for (i = 1; i < BSZ1; i++) {
                        sp = &board[i + j * BSZ1];
                        if (debug > 1 && sp->s_occ == EMPTY) {
-                               if (sp->s_flg & IFLAGALL)
+                               if (sp->s_flags & IFLAGALL)
                                        c = '+';
-                               else if (sp->s_flg & CFLAGALL)
+                               else if (sp->s_flags & CFLAGALL)
                                        c = '-';
                                else
                                        c = '.';
@@ -202,46 +226,62 @@ bdump(fp)
 /*
  * Display a transcript entry
  */
-dislog(str)
-       char *str;
+void
+dislog(const char *str)
 {
 
        if (++lastline >= SCRNH - 1) {
                /* move 'em up */
                lastline = 1;
        }
-       if (strlen(str) >= SCRNW - 46)
-               str[SCRNW - 46 - 1] = '\0';
-       move(lastline, 46);
-       addstr(str);
+       move(lastline, TRANSCRIPT_COL);
+       addnstr(str, SCRNW - TRANSCRIPT_COL - 1);
        clrtoeol();
-       move(lastline + 1, 46);
+       move(lastline + 1, TRANSCRIPT_COL);
        clrtoeol();
 }
 
 /*
  * Display a question.
  */
-ask(str)
-       char *str;
+
+void
+ask(const char *str)
 {
        int len = strlen(str);
 
-       move(23, 0);
+       move(BSZ4, 0);
        addstr(str);
        clrtoeol();
-       move(23, len);
+       move(BSZ4, len);
        refresh();
 }
 
-getline(buf, size)
-       char *buf;
-       int size;
+int
+get_key(const char *allowed)
+{
+       int ch;
+
+       while (1) {
+               ch = getch();
+               if (allowed != NULL &&
+                   ch != '\0' && strchr(allowed, ch) == NULL) {
+                       beep();
+                       refresh();
+                       continue;
+               }
+               break;
+       }
+       return ch;
+}
+
+int
+get_line(char *buf, int size)
 {
-       register char *cp, *end;
-       register int c;
-       extern int interactive;
+       char *cp, *end;
+       int c;
 
+       c = 0;
        cp = buf;
        end = buf + size - 1;   /* save room for the '\0' */
        while (cp < end && (c = getchar()) != EOF && c != '\n' && c != '\r') {
@@ -279,3 +319,148 @@ getline(buf, size)
        *cp = '\0';
        return(c != EOF);
 }
+
+/*
+ * Decent (n)curses interface for the game, based on Eric S. Raymond's
+ * modifications to the battleship (bs) user interface.
+ */
+int
+get_coord(void)
+{
+       static int curx = BSZ / 2;
+       static int cury = BSZ / 2;
+       int ny, nx, ch;
+
+       BGOTO(cury, curx);
+       refresh();
+       nx = curx;
+       ny = cury;
+       for (;;) {
+               mvprintw(BSZ3, (BSZ -6)/2, "(%c %d) ", 
+                               'A'+ ((curx > 7) ? (curx+1) : curx), cury + 1);
+               BGOTO(cury, curx);
+
+               ch = getch();
+               switch (ch) {
+               case 'k':
+               case '8':
+               case KEY_UP:
+                       nx = curx;
+                       ny = cury + 1;
+                       break;
+               case 'j':
+               case '2':
+               case KEY_DOWN:
+                       nx = curx;
+                       ny = BSZ + cury - 1;
+                       break;
+               case 'h':
+               case '4':
+               case KEY_LEFT:
+                       nx = BSZ + curx - 1;
+                       ny = cury;
+                       break;
+               case 'l':
+               case '6':
+               case KEY_RIGHT:
+                       nx = curx + 1;
+                       ny = cury;
+                       break;
+               case 'y':
+               case '7':
+               case KEY_A1:
+                       nx = BSZ + curx - 1;
+                       ny = cury + 1;
+                       break;
+               case 'b':
+               case '1':
+               case KEY_C1:
+                       nx = BSZ + curx - 1;
+                       ny = BSZ + cury - 1;
+                       break;
+               case 'u':
+               case '9':
+               case KEY_A3:
+                       nx = curx + 1;
+                       ny = cury + 1;
+                       break;
+               case 'n':
+               case '3':
+               case KEY_C3:
+                       nx = curx + 1;
+                       ny = BSZ + cury - 1;
+                       break;
+               case 'K':
+                       nx = curx;
+                       ny = cury + 5;
+                       break;
+               case 'J':
+                       nx = curx;
+                       ny = BSZ + cury - 5;
+                       break;
+               case 'H':
+                       nx = BSZ + curx - 5;
+                       ny = cury;
+                       break;
+               case 'L':
+                       nx = curx + 5;
+                       ny = cury;
+                       break;
+               case 'Y':
+                       nx = BSZ + curx - 5;
+                       ny = cury + 5;
+                       break;
+               case 'B':
+                       nx = BSZ + curx - 5;
+                       ny = BSZ + cury - 5;
+                       break;
+               case 'U':
+                       nx = curx + 5;
+                       ny = cury + 5;
+                       break;
+               case 'N':
+                       nx = curx + 5;
+                       ny = BSZ + cury - 5;
+                       break;
+               case '\f':
+                       nx = curx;
+                       ny = cury;
+                       (void)clearok(stdscr, TRUE);
+                       (void)refresh();
+                       break;
+#if 0 /* notyet */
+               case KEY_MOUSE:
+               {
+                       MEVENT  myevent;
+
+                       getmouse(&myevent);
+                       if (myevent.y >= 1 && myevent.y <= BSZ1 &&
+                           myevent.x >= 3 && myevent.x <= (2 * BSZ + 1)) {
+                               curx = (myevent.x - 3) / 2;
+                               cury = BSZ - myevent.y;
+                               return PT(curx,cury);
+                       } else {
+                               beep();
+                       }
+               }
+               break;
+#endif /* 0 */
+               case 'Q':
+               case 'q':
+                       return RESIGN;
+                       break;
+               case 'S':
+               case 's':
+                       return SAVE;
+                       break;
+               case ' ':
+               case '\r':
+                       (void) mvaddstr(BSZ3, (BSZ -6)/2, "      ");
+                       return PT(curx+1,cury+1);
+                       break;
+       }
+
+       curx = nx % BSZ;
+       cury = ny % BSZ;
+    }
+}