Logo Search packages:      
Sourcecode: ncurses version File versions

knight.c

/*
 * Knight's Tour - a brain game
 *
 * The original of this game was anonymous.  It had an unbelievably bogus
 * interface, you actually had to enter square coordinates!  Redesign by
 * Eric S. Raymond <esr@snark.thyrsus.com> July 22 1995.  Mouse support
 * added September 20th 1995.
 *
 * $Id: knight.c,v 1.26 2002/10/19 22:11:24 tom Exp $
 */

#include <test.priv.h>

/* board size */
#define BDEPTH    8
#define BWIDTH    8

/* where to start the instructions */
#define INSTRY    2
#define INSTRX    35

/* corner of board */
#define BOARDY    2
#define BOARDX    0

/* notification line */
#define NOTIFYY   21

/* virtual color values */
#define TRAIL_COLOR     1
#define PLUS_COLOR      2
#define MINUS_COLOR     3

#define CX(x)           (2 + 4 * (x))
#define CY(y)           (1 + 2 * (y))
#define cellmove(y, x)  wmove(boardwin, CY(y), CX(x))
#define CXINV(x)  (((x) - 1) / 4)
#define CYINV(y)  (((y) - 2) / 2)

typedef struct {
    short x, y;
} cell;

static WINDOW *boardwin;      /* the board window */
static WINDOW *helpwin;       /* the help window */
static WINDOW *msgwin;        /* the message window */
static cell history[BDEPTH * BWIDTH + 1]; /* choice history */
static chtype minus = '-';    /* possible-move character */
static chtype oldch;
static chtype plus = '+';     /* cursor hot-spot character */
static chtype trail = '#';    /* trail character */
static int movecount;         /* count of moves so far */
static int trialcount;        /* count of trials so far */
static short board[BDEPTH][BWIDTH]; /* the squares */
/* *INDENT-OFF* */
static const struct {
    int y;
    int x;
} offsets[] = {
    {  2,  1 },
    {  1,  2 },
    { -1,  2 },
    { -2,  1 },
    { -2, -1 },
    { -1, -2 },
    {  1, -2 },
    {  2, -1 },
};
/* *INDENT-ON* */

static void
init_program(void)
{
    setlocale(LC_ALL, "");

    srand((unsigned) getpid());
    initscr();
    cbreak();                 /* immediate char return */
    noecho();                 /* no immediate echo */
    boardwin = newwin(BDEPTH * 2 + 1, BWIDTH * 4 + 1, BOARDY, BOARDX);
    helpwin = newwin(0, 0, INSTRY, INSTRX);
    msgwin = newwin(1, INSTRX - 1, NOTIFYY, 0);
    scrollok(msgwin, TRUE);
    keypad(boardwin, TRUE);

    if (has_colors()) {
      int bg = COLOR_BLACK;

      start_color();
#if HAVE_USE_DEFAULT_COLORS
      if (use_default_colors() == OK)
          bg = -1;
#endif

      (void) init_pair(TRAIL_COLOR, COLOR_CYAN, bg);
      (void) init_pair(PLUS_COLOR, COLOR_RED, bg);
      (void) init_pair(MINUS_COLOR, COLOR_GREEN, bg);

      trail |= COLOR_PAIR(TRAIL_COLOR);
      plus |= COLOR_PAIR(PLUS_COLOR);
      minus |= COLOR_PAIR(MINUS_COLOR);
    }
#ifdef NCURSES_MOUSE_VERSION
    (void) mousemask(BUTTON1_CLICKED, (mmask_t *) NULL);
#endif /* NCURSES_MOUSE_VERSION */

    oldch = minus;
}

static void
help1(void)
/* game explanation -- initial help screen */
{
    (void) waddstr(helpwin, "Knight's move is a solitaire puzzle.  Your\n");
    (void) waddstr(helpwin, "objective is to visit each square of the  \n");
    (void) waddstr(helpwin, "chessboard exactly once by making knight's\n");
    (void) waddstr(helpwin, "moves (one square right or left followed  \n");
    (void) waddstr(helpwin, "by two squares up or down, or two squares \n");
    (void) waddstr(helpwin, "right or left followed by one square up or\n");
    (void) waddstr(helpwin, "down).  You may start anywhere.\n\n");

    (void) waddstr(helpwin, "Use arrow keys to move the cursor around.\n");
    (void) waddstr(helpwin, "When you want to move your knight to the \n");
    (void) waddstr(helpwin, "cursor location, press <space> or Enter.\n");
    (void) waddstr(helpwin, "Illegal moves will be rejected with an  \n");
    (void) waddstr(helpwin, "audible beep.\n\n");
    (void) waddstr(helpwin, "The program will detect if you solve the\n");
    (void) waddstr(helpwin, "puzzle; also inform you when you run out\n");
    (void) waddstr(helpwin, "of legal moves.\n\n");

    (void) mvwaddstr(helpwin, NOTIFYY - INSTRY, 0,
                 "Press `?' to go to keystroke help.");
}

static void
help2(void)
/* keystroke help screen */
{
    (void) waddstr(helpwin, "Possible moves are shown with `-'.\n\n");

    (void) waddstr(helpwin, "You can move around with the arrow keys or\n");
    (void) waddstr(helpwin, "with the rogue/hack movement keys.  Other\n");
    (void) waddstr(helpwin, "commands allow you to undo moves or redraw.\n");
    (void) waddstr(helpwin, "Your mouse may work; try left-button to\n");
    (void) waddstr(helpwin, "move to the square under the pointer.\n\n");

    (void) waddstr(helpwin, "x,q -- exit             y k u    7 8 9\n");
    (void) waddstr(helpwin, "r -- redraw screen       \\|/      \\|/ \n");
    (void) waddstr(helpwin, "bksp -- undo move       h-+-l    4-+-6\n");
    (void) waddstr(helpwin, "a -- autojump            /|\\      /|\\ \n");
    (void) waddstr(helpwin, "                        b j n    1 2 3\n");

    (void) waddstr(helpwin, "\nYou can place your knight on the selected\n");
    (void) waddstr(helpwin, "square with spacebar, Enter, or the keypad\n");
    (void) waddstr(helpwin, "center key.  Use F/B to review the path.\n");

    (void) mvwaddstr(helpwin, NOTIFYY - INSTRY, 0,
                 "Press `?' to go to game explanation");
}

static void
show_help(bool * keyhelp)
{
    werase(helpwin);
    if (*keyhelp) {
      help1();
      *keyhelp = FALSE;
    } else {
      help2();
      *keyhelp = TRUE;
    }
    wrefresh(helpwin);
}

static bool
chksqr(int r1, int c1)
{
    if ((r1 < 0) || (r1 > BDEPTH - 1))
      return (FALSE);
    if ((c1 < 0) || (c1 > BWIDTH - 1))
      return (FALSE);
    return ((!board[r1][c1]) ? TRUE : FALSE);
}

static bool
chkmoves(int rw, int col)
/* check to see if valid moves are available */
{
    unsigned n;

    for (n = 0; n < SIZEOF(offsets); n++)
      if (chksqr(rw + offsets[n].y, col + offsets[n].x))
          return (TRUE);
    return (FALSE);
}

static void
dosquares(void)
{
    int i, j;

    mvaddstr(0, 20, "KNIGHT'S MOVE -- a logical solitaire");

    move(BOARDY, BOARDX);
    waddch(boardwin, ACS_ULCORNER);
    for (j = 0; j < 7; j++) {
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_TTEE);
    }
    waddch(boardwin, ACS_HLINE);
    waddch(boardwin, ACS_HLINE);
    waddch(boardwin, ACS_HLINE);
    waddch(boardwin, ACS_URCORNER);

    for (i = 1; i < BDEPTH; i++) {
      move(BOARDY + i * 2 - 1, BOARDX);
      waddch(boardwin, ACS_VLINE);
      for (j = 0; j < BWIDTH; j++) {
          waddch(boardwin, ' ');
          waddch(boardwin, ' ');
          waddch(boardwin, ' ');
          waddch(boardwin, ACS_VLINE);
      }
      move(BOARDY + i * 2, BOARDX);
      waddch(boardwin, ACS_LTEE);
      for (j = 0; j < BWIDTH - 1; j++) {
          waddch(boardwin, ACS_HLINE);
          waddch(boardwin, ACS_HLINE);
          waddch(boardwin, ACS_HLINE);
          waddch(boardwin, ACS_PLUS);
      }
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_RTEE);
    }

    move(BOARDY + i * 2 - 1, BOARDX);
    waddch(boardwin, ACS_VLINE);
    for (j = 0; j < BWIDTH; j++) {
      waddch(boardwin, ' ');
      waddch(boardwin, ' ');
      waddch(boardwin, ' ');
      waddch(boardwin, ACS_VLINE);
    }

    move(BOARDY + i * 2, BOARDX);
    waddch(boardwin, ACS_LLCORNER);
    for (j = 0; j < BWIDTH - 1; j++) {
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_HLINE);
      waddch(boardwin, ACS_BTEE);
    }
    waddch(boardwin, ACS_HLINE);
    waddch(boardwin, ACS_HLINE);
    waddch(boardwin, ACS_HLINE);
    waddch(boardwin, ACS_LRCORNER);
}

static void
mark_possibles(int prow, int pcol, chtype mark)
{
    unsigned n;

    for (n = 0; n < SIZEOF(offsets); n++) {
      if (chksqr(prow + offsets[n].y, pcol + offsets[n].x)) {
          cellmove(prow + offsets[n].y, pcol + offsets[n].x);
          waddch(boardwin, mark);
      }
    }
}

static void
find_next_move(int *y, int *x)
{
    unsigned j, k;
    int found = -1;
    int first = -1;
    int next = 0;
    int oldy, oldx;
    int newy, newx;

    if (movecount > 1) {
      oldy = history[movecount - 1].y;
      oldx = history[movecount - 1].x;
      for (j = 0; j < SIZEOF(offsets) * 2; j++) {
          k = j % SIZEOF(offsets);
          newy = oldy + offsets[k].y;
          newx = oldx + offsets[k].x;
          if (chksqr(newy, newx)) {
            if (first < 0)
                first = k;
            if (newy == *y
                && newx == *x) {
                found = k;
            } else if (found >= 0) {
                next = k;
                break;
            }
          }
      }
      if (found < 0)
          next = first;
      if (next >= 0) {
          *y = oldy + offsets[next].y;
          *x = oldx + offsets[next].x;
      }
    } else {
      beep();
    }
}

static void
unmarkcell(int row, int column)
{
    cellmove(row, column);
    waddch(boardwin, '\b');
    waddch(boardwin, ' ');
    waddch(boardwin, minus);
    waddch(boardwin, ' ');
}

static void
markcell(chtype tchar, int row, int column)
{
    cellmove(row, column);
    waddch(boardwin, '\b');
    waddch(boardwin, tchar);
    waddch(boardwin, tchar);
    waddch(boardwin, tchar);
}

static void
drawmove(chtype tchar, int oldy, int oldx, int row, int column)
/* place the stars, update board & currents */
{
    if (movecount <= 1) {
      int i, j;

      for (i = 0; i < BDEPTH; i++) {
          for (j = 0; j < BWIDTH; j++) {
            if (movecount == 0) {
                unmarkcell(i, j);
            } else {
                cellmove(i, j);
                if (winch(boardwin) == minus)
                  waddch(boardwin, movecount ? ' ' : minus);
            }
          }
      }
    } else {
      markcell(tchar, oldy, oldx);
      mark_possibles(oldy, oldx, ' ');
    }

    if (row != -1 && column != -1) {
      markcell(trail, row, column);
      mark_possibles(row, column, minus);
      board[row][column] = TRUE;
    }

    wprintw(msgwin, "\nMove %d", movecount);
    if (trialcount != movecount)
      wprintw(msgwin, " (%d tries)", trialcount);
    wclrtoeol(msgwin);
}

static int
iabs(int num)
{
    if (num < 0)
      return (-num);
    else
      return (num);
}

static bool
evalmove(int row, int column)
/* evaluate move */
{
    if (movecount == 1)
      return (TRUE);
    else if (board[row][column] == TRUE) {
      waddstr(msgwin, "\nYou've already been there.");
      return (FALSE);
    } else {
      int rdif = iabs(row - history[movecount - 1].y);
      int cdif = iabs(column - history[movecount - 1].x);

      if (!((rdif == 1) && (cdif == 2)) && !((rdif == 2) && (cdif == 1))) {
          waddstr(msgwin, "\nThat's not a legal knight's move.");
          return (FALSE);
      }
    }

    return (TRUE);
}

static int
completed(void)
{
    int i, j, count = 0;

    for (i = 0; i < BDEPTH; i++)
      for (j = 0; j < BWIDTH; j++)
          if (board[i][j] != 0)
            count += 1;
    return (count == (BWIDTH * BDEPTH) ? -1 : count);
}

static void
no_previous_move(void)
{
    waddstr(msgwin, "\nNo previous move.");
    beep();
}

static void
play(void)
/* play the game */
{
    bool keyhelp;       /* TRUE if keystroke help is up */
    int i, j, count;
    int lastcol = 0;          /* last location visited */
    int lastrow = 0;
    int ny = 0, nx = 0;
    int review = 0;           /* review history */
    int rw = 0, col = 0;      /* current row and column */

    do {
      /* clear screen and draw board */
      werase(boardwin);
      werase(helpwin);
      werase(msgwin);
      dosquares();
      help1();
      wnoutrefresh(stdscr);
      wnoutrefresh(helpwin);
      wnoutrefresh(msgwin);
      wnoutrefresh(boardwin);
      doupdate();

      movecount = 0;
      for (i = 0; i < BDEPTH; i++) {
          for (j = 0; j < BWIDTH; j++) {
            board[i][j] = FALSE;
            unmarkcell(i, j);
          }
      }
      memset(history, 0, sizeof(history));
      history[0].y = history[0].x = -1;
      history[1].y = history[1].x = -1;
      lastrow = lastcol = -2;
      movecount = 1;
      trialcount = 1;
      keyhelp = FALSE;
      show_help(&keyhelp);

      for (;;) {
          if (rw != lastrow || col != lastcol) {
            if (lastrow >= 0 && lastcol >= 0) {
                cellmove(lastrow, lastcol);
                if (board[lastrow][lastcol])
                  waddch(boardwin, trail);
                else
                  waddch(boardwin, oldch);
            }

            cellmove(rw, col);
            oldch = winch(boardwin);

            lastrow = rw;
            lastcol = col;
          }
          cellmove(rw, col);
          waddch(boardwin, plus);
          cellmove(rw, col);

          wrefresh(msgwin);

          switch (wgetch(boardwin)) {
          case 'k':
          case '8':
          case KEY_UP:
            ny = rw + BDEPTH - 1;
            nx = col;
            break;
          case 'j':
          case '2':
          case KEY_DOWN:
            ny = rw + 1;
            nx = col;
            break;
          case 'h':
          case '4':
          case KEY_LEFT:
            ny = rw;
            nx = col + BWIDTH - 1;
            break;
          case 'l':
          case '6':
          case KEY_RIGHT:
            ny = rw;
            nx = col + 1;
            break;
          case 'y':
          case '7':
          case KEY_A1:
            ny = rw + BDEPTH - 1;
            nx = col + BWIDTH - 1;
            break;
          case 'b':
          case '1':
          case KEY_C1:
            ny = rw + 1;
            nx = col + BWIDTH - 1;
            break;
          case 'u':
          case '9':
          case KEY_A3:
            ny = rw + BDEPTH - 1;
            nx = col + 1;
            break;
          case 'n':
          case '3':
          case KEY_C3:
            ny = rw + 1;
            nx = col + 1;
            break;

#ifdef NCURSES_MOUSE_VERSION
          case KEY_MOUSE:
            {
                MEVENT myevent;

                getmouse(&myevent);
                if (myevent.y >= CY(0) && myevent.y <= CY(BDEPTH)
                  && myevent.x >= CX(0) && myevent.x <= CX(BWIDTH)) {
                  nx = CXINV(myevent.x);
                  ny = CYINV(myevent.y);
                  ungetch('\n');
                  break;
                } else {
                  beep();
                  continue;
                }
            }
#endif /* NCURSES_MOUSE_VERSION */

          case KEY_B2:
          case '\n':
          case ' ':
            review = 0;
            if (evalmove(rw, col)) {
                drawmove(trail,
                       history[movecount - 1].y,
                       history[movecount - 1].x,
                       rw, col);
                history[movecount].y = rw;
                history[movecount].x = col;
                movecount++;
                trialcount++;

                if (!chkmoves(rw, col)) {
                  if (completed() < 0) {
                      waddstr(msgwin, "\nYou won.");
                  } else {
                      waddstr(msgwin,
                            "\nNo further moves are possible.");
                  }
                }
            } else {
                beep();
            }
            break;

          case KEY_UNDO:
          case KEY_BACKSPACE:
          case '\b':
            review = 0;
            if (movecount <= 0) {
                no_previous_move();
            } else if (movecount <= 1) {
                ny = history[movecount].y;
                nx = history[movecount].x;
                if (nx < 0 || ny < 0) {
                  ny = lastrow;
                  nx = lastcol;
                }
                movecount = 0;
                board[ny][nx] = FALSE;
                oldch = minus;
                drawmove(' ', ny, nx, -1, -1);
                movecount = 1;
                trialcount = 1;
                no_previous_move();
            } else {
                int oldy = history[movecount - 1].y;
                int oldx = history[movecount - 1].x;

                if (!board[rw][col]) {
                  cellmove(rw, col);
                  waddch(boardwin, ' ');
                }

                board[oldy][oldx] = FALSE;
                --movecount;
                ny = history[movecount - 1].y;
                nx = history[movecount - 1].x;
                if (nx < 0 || ny < 0) {
                  ny = oldy;
                  nx = oldx;
                }
                drawmove(' ', oldy, oldx, ny, nx);

                /* avoid problems if we just changed the current cell */
                cellmove(lastrow, lastcol);
                oldch = winch(boardwin);
            }
            break;

          case 'a':
            nx = col;
            ny = rw;
            find_next_move(&ny, &nx);
            break;

          case 'F':
            if (review > 0) {
                review--;
                ny = history[movecount - review - 1].y;
                nx = history[movecount - review - 1].x;
            } else {
                beep();
            }
            break;

          case 'B':
            if (review < movecount - 2) {
                review++;
                ny = history[movecount - review - 1].y;
                nx = history[movecount - review - 1].x;
            } else {
                beep();
            }
            break;

          case KEY_REDO:
          case '\f':
          case 'r':
            clearok(curscr, TRUE);
            wnoutrefresh(stdscr);
            wnoutrefresh(boardwin);
            wnoutrefresh(msgwin);
            wnoutrefresh(helpwin);
            doupdate();
            break;

          case 'q':
          case 'x':
            goto dropout;

          case '?':
            show_help(&keyhelp);
            break;

          default:
            beep();
            break;
          }

          col = nx % BWIDTH;
          rw = ny % BDEPTH;
      }

      dropout:
      if ((count = completed()) < 0)
          wprintw(msgwin, "\nYou won.  Care to try again? ");
      else
          wprintw(msgwin, "\n%d squares filled.  Try again? ", count);
      wclrtoeol(msgwin);
    } while
      (tolower(wgetch(msgwin)) == 'y');
}

int
main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
{
    init_program();

    play();

    endwin();
    ExitProgram(EXIT_SUCCESS);
}

/* knight.c ends here */

Generated by  Doxygen 1.6.0   Back to index