?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
missing ncurses sources
[tomato.git] / release / src / router / libncurses / test / knight.c
blobd9f81facacec814e13cdb984975523867b7cbc13
1 /****************************************************************************
2 * Copyright (c) 1998-2008,2010 Free Software Foundation, Inc. *
3 * *
4 * Permission is hereby granted, free of charge, to any person obtaining a *
5 * copy of this software and associated documentation files (the *
6 * "Software"), to deal in the Software without restriction, including *
7 * without limitation the rights to use, copy, modify, merge, publish, *
8 * distribute, distribute with modifications, sublicense, and/or sell *
9 * copies of the Software, and to permit persons to whom the Software is *
10 * furnished to do so, subject to the following conditions: *
11 * *
12 * The above copyright notice and this permission notice shall be included *
13 * in all copies or substantial portions of the Software. *
14 * *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
22 * *
23 * Except as contained in this notice, the name(s) of the above copyright *
24 * holders shall not be used in advertising or otherwise to promote the *
25 * sale, use or other dealings in this Software without prior written *
26 * authorization. *
27 ****************************************************************************/
28 /*
29 * Knight's Tour - a brain game
30 *
31 * The original of this game was anonymous. It had an unbelievably bogus
32 * interface, you actually had to enter square coordinates! Redesign by
33 * Eric S. Raymond <esr@snark.thyrsus.com> July 22 1995. Mouse support
34 * added September 20th 1995.
35 *
36 * $Id: knight.c,v 1.31 2010/11/13 20:44:21 tom Exp $
37 */
38
39 #include <test.priv.h>
40
41 /* board size */
42 #define BDEPTH 8
43 #define BWIDTH 8
44
45 /* where to start the instructions */
46 #define INSTRY 2
47 #define INSTRX 35
48
49 /* corner of board */
50 #define BOARDY 2
51 #define BOARDX 0
52
53 /* notification line */
54 #define NOTIFYY 21
55
56 /* virtual color values */
57 #define TRAIL_COLOR 1
58 #define PLUS_COLOR 2
59 #define MINUS_COLOR 3
60
61 #define CX(x) (2 + 4 * (x))
62 #define CY(y) (1 + 2 * (y))
63 #define cellmove(y, x) wmove(boardwin, CY(y), CX(x))
64 #define CXINV(x) (((x) - 1) / 4)
65 #define CYINV(y) (((y) - 2) / 2)
66
67 typedef struct {
68 short x, y;
69 } cell;
70
71 static WINDOW *boardwin; /* the board window */
72 static WINDOW *helpwin; /* the help window */
73 static WINDOW *msgwin; /* the message window */
74 static cell history[BDEPTH * BWIDTH + 1]; /* choice history */
75 static chtype minus = '-'; /* possible-move character */
76 static chtype oldch;
77 static chtype plus = '+'; /* cursor hot-spot character */
78 static chtype trail = '#'; /* trail character */
79 static int movecount; /* count of moves so far */
80 static int trialcount; /* count of trials so far */
81 static short board[BDEPTH][BWIDTH]; /* the squares */
82 /* *INDENT-OFF* */
83 static const struct {
84 int y;
85 int x;
86 } offsets[] = {
87 { 2, 1 },
88 { 1, 2 },
89 { -1, 2 },
90 { -2, 1 },
91 { -2, -1 },
92 { -1, -2 },
93 { 1, -2 },
94 { 2, -1 },
95 };
96 /* *INDENT-ON* */
97
98 static void
99 init_program(void)
100 {
101 setlocale(LC_ALL, "");
102
103 srand((unsigned) getpid());
104 initscr();
105 cbreak(); /* immediate char return */
106 noecho(); /* no immediate echo */
107 boardwin = newwin(BDEPTH * 2 + 1, BWIDTH * 4 + 1, BOARDY, BOARDX);
108 helpwin = newwin(0, 0, INSTRY, INSTRX);
109 msgwin = newwin(1, INSTRX - 1, NOTIFYY, 0);
110 scrollok(msgwin, TRUE);
111 keypad(boardwin, TRUE);
112
113 if (has_colors()) {
114 int bg = COLOR_BLACK;
115
116 start_color();
117 #if HAVE_USE_DEFAULT_COLORS
118 if (use_default_colors() == OK)
119 bg = -1;
120 #endif
121
122 (void) init_pair(TRAIL_COLOR, (short) COLOR_CYAN, (short) bg);
123 (void) init_pair(PLUS_COLOR, (short) COLOR_RED, (short) bg);
124 (void) init_pair(MINUS_COLOR, (short) COLOR_GREEN, (short) bg);
125
126 trail |= COLOR_PAIR(TRAIL_COLOR);
127 plus |= COLOR_PAIR(PLUS_COLOR);
128 minus |= COLOR_PAIR(MINUS_COLOR);
129 }
130 #ifdef NCURSES_MOUSE_VERSION
131 (void) mousemask(BUTTON1_CLICKED, (mmask_t *) NULL);
132 #endif /* NCURSES_MOUSE_VERSION */
133
134 oldch = minus;
135 }
136
137 static void
138 help1(void)
139 /* game explanation -- initial help screen */
140 {
141 (void) waddstr(helpwin, "Knight's move is a solitaire puzzle. Your\n");
142 (void) waddstr(helpwin, "objective is to visit each square of the \n");
143 (void) waddstr(helpwin, "chessboard exactly once by making knight's\n");
144 (void) waddstr(helpwin, "moves (one square right or left followed \n");
145 (void) waddstr(helpwin, "by two squares up or down, or two squares \n");
146 (void) waddstr(helpwin, "right or left followed by one square up or\n");
147 (void) waddstr(helpwin, "down). You may start anywhere.\n\n");
148
149 (void) waddstr(helpwin, "Use arrow keys to move the cursor around.\n");
150 (void) waddstr(helpwin, "When you want to move your knight to the \n");
151 (void) waddstr(helpwin, "cursor location, press <space> or Enter.\n");
152 (void) waddstr(helpwin, "Illegal moves will be rejected with an \n");
153 (void) waddstr(helpwin, "audible beep.\n\n");
154 (void) waddstr(helpwin, "The program will detect if you solve the\n");
155 (void) waddstr(helpwin, "puzzle; also inform you when you run out\n");
156 (void) waddstr(helpwin, "of legal moves.\n\n");
157
158 MvWAddStr(helpwin, NOTIFYY - INSTRY, 0,
159 "Press `?' to go to keystroke help.");
160 }
161
162 static void
163 help2(void)
164 /* keystroke help screen */
165 {
166 (void) waddstr(helpwin, "Possible moves are shown with `-'.\n\n");
167
168 (void) waddstr(helpwin, "You can move around with the arrow keys or\n");
169 (void) waddstr(helpwin, "with the rogue/hack movement keys. Other\n");
170 (void) waddstr(helpwin, "commands allow you to undo moves or redraw.\n");
171 (void) waddstr(helpwin, "Your mouse may work; try left-button to\n");
172 (void) waddstr(helpwin, "move to the square under the pointer.\n\n");
173
174 (void) waddstr(helpwin, "x,q -- exit y k u 7 8 9\n");
175 (void) waddstr(helpwin, "r -- redraw screen \\|/ \\|/ \n");
176 (void) waddstr(helpwin, "bksp -- undo move h-+-l 4-+-6\n");
177 (void) waddstr(helpwin, "a -- autojump /|\\ /|\\ \n");
178 (void) waddstr(helpwin, " b j n 1 2 3\n");
179
180 (void) waddstr(helpwin, "\nYou can place your knight on the selected\n");
181 (void) waddstr(helpwin, "square with spacebar, Enter, or the keypad\n");
182 (void) waddstr(helpwin, "center key. Use F/B to review the path.\n");
183
184 MvWAddStr(helpwin, NOTIFYY - INSTRY, 0,
185 "Press `?' to go to game explanation");
186 }
187
188 static void
189 show_help(bool * keyhelp)
190 {
191 werase(helpwin);
192 if (*keyhelp) {
193 help1();
194 *keyhelp = FALSE;
195 } else {
196 help2();
197 *keyhelp = TRUE;
198 }
199 wrefresh(helpwin);
200 }
201
202 static bool
203 chksqr(int r1, int c1)
204 {
205 if ((r1 < 0) || (r1 > BDEPTH - 1))
206 return (FALSE);
207 if ((c1 < 0) || (c1 > BWIDTH - 1))
208 return (FALSE);
209 return ((!board[r1][c1]) ? TRUE : FALSE);
210 }
211
212 static bool
213 chkmoves(int rw, int col)
214 /* check to see if valid moves are available */
215 {
216 unsigned n;
217
218 for (n = 0; n < SIZEOF(offsets); n++)
219 if (chksqr(rw + offsets[n].y, col + offsets[n].x))
220 return (TRUE);
221 return (FALSE);
222 }
223
224 static void
225 dosquares(void)
226 {
227 int i, j;
228
229 MvAddStr(0, 20, "KNIGHT'S MOVE -- a logical solitaire");
230
231 move(BOARDY, BOARDX);
232 waddch(boardwin, ACS_ULCORNER);
233 for (j = 0; j < 7; j++) {
234 waddch(boardwin, ACS_HLINE);
235 waddch(boardwin, ACS_HLINE);
236 waddch(boardwin, ACS_HLINE);
237 waddch(boardwin, ACS_TTEE);
238 }
239 waddch(boardwin, ACS_HLINE);
240 waddch(boardwin, ACS_HLINE);
241 waddch(boardwin, ACS_HLINE);
242 waddch(boardwin, ACS_URCORNER);
243
244 for (i = 1; i < BDEPTH; i++) {
245 move(BOARDY + i * 2 - 1, BOARDX);
246 waddch(boardwin, ACS_VLINE);
247 for (j = 0; j < BWIDTH; j++) {
248 waddch(boardwin, ' ');
249 waddch(boardwin, ' ');
250 waddch(boardwin, ' ');
251 waddch(boardwin, ACS_VLINE);
252 }
253 move(BOARDY + i * 2, BOARDX);
254 waddch(boardwin, ACS_LTEE);
255 for (j = 0; j < BWIDTH - 1; j++) {
256 waddch(boardwin, ACS_HLINE);
257 waddch(boardwin, ACS_HLINE);
258 waddch(boardwin, ACS_HLINE);
259 waddch(boardwin, ACS_PLUS);
260 }
261 waddch(boardwin, ACS_HLINE);
262 waddch(boardwin, ACS_HLINE);
263 waddch(boardwin, ACS_HLINE);
264 waddch(boardwin, ACS_RTEE);
265 }
266
267 move(BOARDY + i * 2 - 1, BOARDX);
268 waddch(boardwin, ACS_VLINE);
269 for (j = 0; j < BWIDTH; j++) {
270 waddch(boardwin, ' ');
271 waddch(boardwin, ' ');
272 waddch(boardwin, ' ');
273 waddch(boardwin, ACS_VLINE);
274 }
275
276 move(BOARDY + i * 2, BOARDX);
277 waddch(boardwin, ACS_LLCORNER);
278 for (j = 0; j < BWIDTH - 1; j++) {
279 waddch(boardwin, ACS_HLINE);
280 waddch(boardwin, ACS_HLINE);
281 waddch(boardwin, ACS_HLINE);
282 waddch(boardwin, ACS_BTEE);
283 }
284 waddch(boardwin, ACS_HLINE);
285 waddch(boardwin, ACS_HLINE);
286 waddch(boardwin, ACS_HLINE);
287 waddch(boardwin, ACS_LRCORNER);
288 }
289
290 static void
291 mark_possibles(int prow, int pcol, chtype mark)
292 {
293 unsigned n;
294
295 for (n = 0; n < SIZEOF(offsets); n++) {
296 if (chksqr(prow + offsets[n].y, pcol + offsets[n].x)) {
297 cellmove(prow + offsets[n].y, pcol + offsets[n].x);
298 waddch(boardwin, mark);
299 }
300 }
301 }
302
303 static void
304 find_next_move(int *y, int *x)
305 {
306 unsigned j, k;
307 int found = -1;
308 int first = -1;
309 int next = 0;
310 int oldy, oldx;
311 int newy, newx;
312
313 if (movecount > 1) {
314 oldy = history[movecount - 1].y;
315 oldx = history[movecount - 1].x;
316 for (j = 0; j < SIZEOF(offsets) * 2; j++) {
317 k = j % SIZEOF(offsets);
318 newy = oldy + offsets[k].y;
319 newx = oldx + offsets[k].x;
320 if (chksqr(newy, newx)) {
321 if (first < 0)
322 first = (int) k;
323 if (newy == *y
324 && newx == *x) {
325 found = (int) k;
326 } else if (found >= 0) {
327 next = (int) k;
328 break;
329 }
330 }
331 }
332 if (found < 0)
333 next = first;
334 if (next >= 0) {
335 *y = oldy + offsets[next].y;
336 *x = oldx + offsets[next].x;
337 }
338 } else {
339 beep();
340 }
341 }
342
343 static void
344 unmarkcell(int row, int column)
345 {
346 cellmove(row, column);
347 waddch(boardwin, '\b');
348 waddch(boardwin, ' ');
349 waddch(boardwin, minus);
350 waddch(boardwin, ' ');
351 }
352
353 static void
354 markcell(chtype tchar, int row, int column)
355 {
356 cellmove(row, column);
357 waddch(boardwin, '\b');
358 waddch(boardwin, tchar);
359 waddch(boardwin, tchar);
360 waddch(boardwin, tchar);
361 }
362
363 static void
364 drawmove(chtype tchar, int oldy, int oldx, int row, int column)
365 /* place the stars, update board & currents */
366 {
367 if (movecount <= 1) {
368 int i, j;
369
370 for (i = 0; i < BDEPTH; i++) {
371 for (j = 0; j < BWIDTH; j++) {
372 if (movecount == 0) {
373 unmarkcell(i, j);
374 } else {
375 cellmove(i, j);
376 if (winch(boardwin) == minus)
377 waddch(boardwin, movecount ? ' ' : minus);
378 }
379 }
380 }
381 } else {
382 markcell(tchar, oldy, oldx);
383 mark_possibles(oldy, oldx, ' ');
384 }
385
386 if (row >= 0 && column >= 0) {
387 markcell(trail, row, column);
388 mark_possibles(row, column, minus);
389 board[row][column] = TRUE;
390 }
391
392 wprintw(msgwin, "\nMove %d", movecount);
393 if (trialcount != movecount)
394 wprintw(msgwin, " (%d tries)", trialcount);
395 wclrtoeol(msgwin);
396 }
397
398 static int
399 iabs(int num)
400 {
401 if (num < 0)
402 return (-num);
403 else
404 return (num);
405 }
406
407 static bool
408 evalmove(int row, int column)
409 /* evaluate move */
410 {
411 if (movecount == 1)
412 return (TRUE);
413 else if (board[row][column] == TRUE) {
414 waddstr(msgwin, "\nYou've already been there.");
415 return (FALSE);
416 } else {
417 int rdif = iabs(row - history[movecount - 1].y);
418 int cdif = iabs(column - history[movecount - 1].x);
419
420 if (!((rdif == 1) && (cdif == 2)) && !((rdif == 2) && (cdif == 1))) {
421 waddstr(msgwin, "\nThat's not a legal knight's move.");
422 return (FALSE);
423 }
424 }
425
426 return (TRUE);
427 }
428
429 static int
430 completed(void)
431 {
432 int i, j, count = 0;
433
434 for (i = 0; i < BDEPTH; i++)
435 for (j = 0; j < BWIDTH; j++)
436 if (board[i][j] != 0)
437 count += 1;
438 return (count == (BWIDTH * BDEPTH) ? -1 : count);
439 }
440
441 static void
442 no_previous_move(void)
443 {
444 waddstr(msgwin, "\nNo previous move.");
445 beep();
446 }
447
448 static void
449 play(void)
450 /* play the game */
451 {
452 bool keyhelp; /* TRUE if keystroke help is up */
453 int i, j, count;
454 int lastcol = 0; /* last location visited */
455 int lastrow = 0;
456 int ny = 0, nx = 0;
457 int review = 0; /* review history */
458 int rw = 0, col = 0; /* current row and column */
459
460 do {
461 /* clear screen and draw board */
462 werase(boardwin);
463 werase(helpwin);
464 werase(msgwin);
465 dosquares();
466 help1();
467 wnoutrefresh(stdscr);
468 wnoutrefresh(helpwin);
469 wnoutrefresh(msgwin);
470 wnoutrefresh(boardwin);
471 doupdate();
472
473 movecount = 0;
474 for (i = 0; i < BDEPTH; i++) {
475 for (j = 0; j < BWIDTH; j++) {
476 board[i][j] = FALSE;
477 unmarkcell(i, j);
478 }
479 }
480 memset(history, 0, sizeof(history));
481 history[0].y = history[0].x = -1;
482 history[1].y = history[1].x = -1;
483 lastrow = lastcol = -2;
484 movecount = 1;
485 trialcount = 1;
486 keyhelp = FALSE;
487 show_help(&keyhelp);
488
489 for (;;) {
490 if (rw != lastrow || col != lastcol) {
491 if (lastrow >= 0 && lastcol >= 0) {
492 cellmove(lastrow, lastcol);
493 if (board[lastrow][lastcol])
494 waddch(boardwin, trail);
495 else
496 waddch(boardwin, oldch);
497 }
498
499 cellmove(rw, col);
500 oldch = winch(boardwin);
501
502 lastrow = rw;
503 lastcol = col;
504 }
505 cellmove(rw, col);
506 waddch(boardwin, plus);
507 cellmove(rw, col);
508
509 wrefresh(msgwin);
510
511 switch (wgetch(boardwin)) {
512 case 'k':
513 case '8':
514 case KEY_UP:
515 ny = rw + BDEPTH - 1;
516 nx = col;
517 break;
518 case 'j':
519 case '2':
520 case KEY_DOWN:
521 ny = rw + 1;
522 nx = col;
523 break;
524 case 'h':
525 case '4':
526 case KEY_LEFT:
527 ny = rw;
528 nx = col + BWIDTH - 1;
529 break;
530 case 'l':
531 case '6':
532 case KEY_RIGHT:
533 ny = rw;
534 nx = col + 1;
535 break;
536 case 'y':
537 case '7':
538 case KEY_A1:
539 ny = rw + BDEPTH - 1;
540 nx = col + BWIDTH - 1;
541 break;
542 case 'b':
543 case '1':
544 case KEY_C1:
545 ny = rw + 1;
546 nx = col + BWIDTH - 1;
547 break;
548 case 'u':
549 case '9':
550 case KEY_A3:
551 ny = rw + BDEPTH - 1;
552 nx = col + 1;
553 break;
554 case 'n':
555 case '3':
556 case KEY_C3:
557 ny = rw + 1;
558 nx = col + 1;
559 break;
560
561 #ifdef NCURSES_MOUSE_VERSION
562 case KEY_MOUSE:
563 {
564 MEVENT myevent;
565
566 getmouse(&myevent);
567 if (myevent.y >= CY(0) && myevent.y <= CY(BDEPTH)
568 && myevent.x >= CX(0) && myevent.x <= CX(BWIDTH)) {
569 nx = CXINV(myevent.x);
570 ny = CYINV(myevent.y);
571 ungetch('\n');
572 break;
573 } else {
574 beep();
575 continue;
576 }
577 }
578 #endif /* NCURSES_MOUSE_VERSION */
579
580 case KEY_B2:
581 case '\n':
582 case ' ':
583 review = 0;
584 if (evalmove(rw, col)) {
585 drawmove(trail,
586 history[movecount - 1].y,
587 history[movecount - 1].x,
588 rw, col);
589 history[movecount].y = (short) rw;
590 history[movecount].x = (short) col;
591 movecount++;
592 trialcount++;
593
594 if (!chkmoves(rw, col)) {
595 if (completed() < 0) {
596 waddstr(msgwin, "\nYou won.");
597 } else {
598 waddstr(msgwin,
599 "\nNo further moves are possible.");
600 }
601 }
602 } else {
603 beep();
604 }
605 break;
606
607 case KEY_UNDO:
608 case KEY_BACKSPACE:
609 case '\b':
610 review = 0;
611 if (movecount <= 0) {
612 no_previous_move();
613 } else if (movecount <= 1) {
614 ny = history[movecount].y;
615 nx = history[movecount].x;
616 if (nx < 0 || ny < 0) {
617 ny = lastrow;
618 nx = lastcol;
619 }
620 movecount = 0;
621 board[ny][nx] = FALSE;
622 oldch = minus;
623 drawmove(' ', ny, nx, -1, -1);
624 movecount = 1;
625 trialcount = 1;
626 no_previous_move();
627 } else {
628 int oldy = history[movecount - 1].y;
629 int oldx = history[movecount - 1].x;
630
631 if (!board[rw][col]) {
632 cellmove(rw, col);
633 waddch(boardwin, ' ');
634 }
635
636 board[oldy][oldx] = FALSE;
637 --movecount;
638 ny = history[movecount - 1].y;
639 nx = history[movecount - 1].x;
640 if (nx < 0 || ny < 0) {
641 ny = oldy;
642 nx = oldx;
643 }
644 drawmove(' ', oldy, oldx, ny, nx);
645
646 /* avoid problems if we just changed the current cell */
647 cellmove(lastrow, lastcol);
648 oldch = winch(boardwin);
649 }
650 break;
651
652 case 'a':
653 nx = col;
654 ny = rw;
655 find_next_move(&ny, &nx);
656 break;
657
658 case 'F':
659 if (review > 0) {
660 review--;
661 ny = history[movecount - review - 1].y;
662 nx = history[movecount - review - 1].x;
663 } else {
664 beep();
665 }
666 break;
667
668 case 'B':
669 if (review < movecount - 2) {
670 review++;
671 ny = history[movecount - review - 1].y;
672 nx = history[movecount - review - 1].x;
673 } else {
674 beep();
675 }
676 break;
677
678 case KEY_REDO:
679 case '\f':
680 case 'r':
681 clearok(curscr, TRUE);
682 wnoutrefresh(stdscr);
683 wnoutrefresh(boardwin);
684 wnoutrefresh(msgwin);
685 wnoutrefresh(helpwin);
686 doupdate();
687 break;
688
689 case 'q':
690 case 'x':
691 goto dropout;
692
693 case '?':
694 show_help(&keyhelp);
695 break;
696
697 default:
698 beep();
699 break;
700 }
701
702 col = nx % BWIDTH;
703 rw = ny % BDEPTH;
704 }
705
706 dropout:
707 if ((count = completed()) < 0)
708 wprintw(msgwin, "\nYou won. Care to try again? ");
709 else
710 wprintw(msgwin, "\n%d squares filled. Try again? ", count);
711 wclrtoeol(msgwin);
712 } while
713 (tolower(wgetch(msgwin)) == 'y');
714 }
715
716 int
717 main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
718 {
719 init_program();
720
721 play();
722
723 endwin();
724 ExitProgram(EXIT_SUCCESS);
725 }
726
727 /* knight.c ends here */
Tomato firmware and modifications.