1 /* $NetBSD: pl_7.c,v 1.42 2011/08/26 06:18:18 dholland Exp $ */ 2 3 /* 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 #ifndef lint 34 #if 0 35 static char sccsid[] = "@(#)pl_7.c 8.1 (Berkeley) 5/31/93"; 36 #else 37 __RCSID("$NetBSD: pl_7.c,v 1.42 2011/08/26 06:18:18 dholland Exp $"); 38 #endif 39 #endif /* not lint */ 40 41 #include <curses.h> 42 #include <err.h> 43 #include <errno.h> 44 #include <signal.h> 45 #include <stdarg.h> 46 #include <stdio.h> 47 #include <stdlib.h> 48 #include <string.h> 49 #include <unistd.h> 50 #include "array.h" 51 #include "extern.h" 52 #include "player.h" 53 #include "display.h" 54 55 /* 56 * Use values above KEY_MAX for custom keycodes. (blymn@ says this is ok) 57 */ 58 #define KEY_ESC(ch) (KEY_MAX+10+ch) 59 60 61 /* 62 * Display interface 63 */ 64 65 static void draw_view(void); 66 static void draw_turn(void); 67 static void draw_stat(void); 68 static void draw_slot(void); 69 static void draw_board(void); 70 71 static struct stringarray *sc_lines; 72 static unsigned sc_scrollup; 73 static bool sc_hasprompt; 74 static bool sc_hideprompt; 75 static const char *sc_prompt; 76 static const char *sc_buf; 77 78 static WINDOW *view_w; 79 static WINDOW *turn_w; 80 static WINDOW *stat_w; 81 static WINDOW *slot_w; 82 static WINDOW *scroll_w; 83 84 static bool obp[3]; 85 static bool dbp[3]; 86 87 int done_curses; 88 static bool ingame; 89 int loaded, fired, changed, repaired; 90 int dont_adjust; 91 static int viewrow, viewcol; 92 char movebuf[sizeof SHIP(0)->file->movebuf]; 93 int player; 94 struct ship *ms; /* memorial structure, &cc->ship[player] */ 95 struct File *mf; /* ms->file */ 96 struct shipspecs *mc; /* ms->specs */ 97 98 //////////////////////////////////////////////////////////// 99 // overall initialization 100 101 static 102 void 103 define_esc_key(int ch) 104 { 105 char seq[3] = { '\x1b', ch, 0 }; 106 107 define_key(seq, KEY_ESC(ch)); 108 } 109 110 void 111 initscreen(void) 112 { 113 int ch; 114 115 sc_lines = stringarray_create(); 116 if (sc_lines == NULL) { 117 err(1, "malloc"); 118 } 119 120 if (signal(SIGTSTP, SIG_DFL) == SIG_ERR) { 121 err(1, "signal(SIGTSTP)"); 122 } 123 124 if (initscr() == NULL) { 125 errx(1, "Can't sail on this terminal."); 126 } 127 if (STAT_R >= COLS || SCROLL_Y <= 0) { 128 errx(1, "Window/terminal not large enough."); 129 } 130 131 view_w = newwin(VIEW_Y, VIEW_X, VIEW_T, VIEW_L); 132 slot_w = newwin(SLOT_Y, SLOT_X, SLOT_T, SLOT_L); 133 scroll_w = newwin(SCROLL_Y, SCROLL_X, SCROLL_T, SCROLL_L); 134 stat_w = newwin(STAT_Y, STAT_X, STAT_T, STAT_L); 135 turn_w = newwin(TURN_Y, TURN_X, TURN_T, TURN_L); 136 137 if (view_w == NULL || 138 slot_w == NULL || 139 scroll_w == NULL || 140 stat_w == NULL || 141 turn_w == NULL) { 142 endwin(); 143 errx(1, "Curses initialization failed."); 144 } 145 146 leaveok(view_w, 1); 147 leaveok(slot_w, 1); 148 leaveok(stat_w, 1); 149 leaveok(turn_w, 1); 150 noecho(); 151 cbreak(); 152 153 /* 154 * Define esc-x keys 155 */ 156 #if 0 157 for (ch = 0; ch < 127; ch++) { 158 if (ch != '[' && ch != 'O') { 159 define_esc_key(ch); 160 } 161 } 162 #else 163 (void)ch; 164 (void)define_esc_key; 165 #endif 166 167 keypad(stdscr, 1); 168 keypad(view_w, 1); 169 keypad(slot_w, 1); 170 keypad(scroll_w, 1); 171 keypad(stat_w, 1); 172 keypad(turn_w, 1); 173 174 done_curses++; 175 } 176 177 void 178 cleanupscreen(void) 179 { 180 /* alarm already turned off */ 181 if (done_curses) { 182 if (ingame) { 183 wmove(scroll_w, SCROLL_Y - 1, 0); 184 wclrtoeol(scroll_w); 185 display_redraw(); 186 } else { 187 move(LINES-1, 0); 188 clrtoeol(); 189 } 190 endwin(); 191 } 192 } 193 194 //////////////////////////////////////////////////////////// 195 // curses utility functions 196 197 /* 198 * fill to eol with spaces 199 * (useful with A_REVERSE since cleartoeol() does not clear to reversed) 200 */ 201 static void 202 filltoeol(void) 203 { 204 int x; 205 206 for (x = getcurx(stdscr); x < COLS; x++) { 207 addch(' '); 208 } 209 } 210 211 /* 212 * Add a maybe-selected string. 213 * 214 * Place strings starting at (Y0, X0); this is string ITEM; CURITEM 215 * is the selected one; WIDTH is the total width. STR is the string. 216 */ 217 static void 218 mvaddselstr(int y, int x0, int item, int curitem, 219 size_t width, const char *str) 220 { 221 size_t i, len; 222 223 len = strlen(str); 224 225 move(y, x0); 226 if (curitem == item) { 227 attron(A_REVERSE); 228 } 229 addstr(str); 230 if (curitem == item) { 231 for (i=len; i<width; i++) { 232 addch(' '); 233 } 234 attroff(A_REVERSE); 235 } 236 } 237 238 /* 239 * Likewise but a printf. 240 */ 241 static void __printflike(6, 7) 242 mvselprintw(int y, int x0, int item, int curitem, 243 size_t width, const char *fmt, ...) 244 { 245 va_list ap; 246 size_t x; 247 248 move(y, x0); 249 if (curitem == item) { 250 attron(A_REVERSE); 251 } 252 va_start(ap, fmt); 253 vw_printw(stdscr, fmt, ap); 254 va_end(ap); 255 if (curitem == item) { 256 for (x = getcurx(stdscr); x < x0 + width; x++) { 257 addch(' '); 258 } 259 attroff(A_REVERSE); 260 } 261 } 262 263 /* 264 * Move up by 1, scrolling if needed. 265 */ 266 static void 267 up(int *posp, int *scrollp) 268 { 269 if (*posp > 0) { 270 (*posp)--; 271 } 272 if (scrollp != NULL) { 273 if (*posp < *scrollp) { 274 *scrollp = *posp; 275 } 276 } 277 } 278 279 /* 280 * Move down by 1, scrolling if needed. MAX is the total number of 281 * items; VISIBLE is the number that can be visible at once. 282 */ 283 static void 284 down(int *posp, int *scrollp, int max, int visible) 285 { 286 if (max > 0 && *posp < max - 1) { 287 (*posp)++; 288 } 289 if (scrollp != NULL) { 290 if (*posp > *scrollp + visible - 1) { 291 *scrollp = *posp - visible + 1; 292 } 293 } 294 } 295 296 /* 297 * Complain briefly. 298 */ 299 static void __printflike(3, 4) 300 oops(int y, int x, const char *fmt, ...) 301 { 302 int oy, ox; 303 va_list ap; 304 305 oy = getcury(stdscr); 306 ox = getcurx(stdscr); 307 move(y, x); 308 va_start(ap, fmt); 309 vw_printw(stdscr, fmt, ap); 310 va_end(ap); 311 move(oy, ox); 312 wrefresh(stdscr); 313 sleep(1); 314 } 315 316 //////////////////////////////////////////////////////////// 317 // scrolling message area 318 319 static void 320 scrollarea_add(const char *text) 321 { 322 char *copy; 323 int errsave; 324 325 copy = strdup(text); 326 if (copy == NULL) { 327 goto nomem; 328 } 329 if (stringarray_add(sc_lines, copy, NULL)) { 330 goto nomem; 331 } 332 return; 333 334 nomem: 335 /* 336 * XXX this should use leave(), but that won't 337 * currently work right. 338 */ 339 errsave = errno; 340 #if 0 341 leave(LEAVE_MALLOC); 342 #else 343 cleanupscreen(); 344 sync_close(!hasdriver); 345 errno = errsave; 346 err(1, "malloc"); 347 #endif 348 } 349 350 static void 351 draw_scroll(void) 352 { 353 unsigned total_lines; 354 unsigned visible_lines; 355 unsigned index_of_top; 356 unsigned index_of_y; 357 unsigned y; 358 unsigned cursorx; 359 360 werase(scroll_w); 361 362 /* XXX: SCROLL_Y and whatnot should be unsigned too */ 363 visible_lines = SCROLL_Y - 1; 364 365 total_lines = stringarray_num(sc_lines); 366 if (total_lines > visible_lines) { 367 index_of_top = total_lines - visible_lines; 368 } else { 369 index_of_top = 0; 370 } 371 if (index_of_top < sc_scrollup) { 372 index_of_top = 0; 373 } else { 374 index_of_top -= sc_scrollup; 375 } 376 377 for (y = 0; y < visible_lines; y++) { 378 index_of_y = index_of_top + y; 379 if (index_of_y >= total_lines) { 380 break; 381 } 382 wmove(scroll_w, y, 0); 383 waddstr(scroll_w, stringarray_get(sc_lines, index_of_y)); 384 } 385 if (sc_hasprompt && !sc_hideprompt) { 386 wmove(scroll_w, SCROLL_Y-1, 0); 387 waddstr(scroll_w, sc_prompt); 388 waddstr(scroll_w, sc_buf); 389 cursorx = strlen(sc_prompt) + strlen(sc_buf); 390 wmove(scroll_w, SCROLL_Y-1, cursorx); 391 } 392 else { 393 wmove(scroll_w, SCROLL_Y-1, 0); 394 } 395 } 396 397 /*VARARGS2*/ 398 void 399 Signal(const char *fmt, struct ship *ship, ...) 400 { 401 va_list ap; 402 char format[BUFSIZ]; 403 char buf[BUFSIZ]; 404 405 if (!done_curses) 406 return; 407 va_start(ap, ship); 408 if (*fmt == '\a') { 409 beep(); 410 fmt++; 411 } 412 fmtship(format, sizeof(format), fmt, ship); 413 vsnprintf(buf, sizeof(buf), format, ap); 414 va_end(ap); 415 scrollarea_add(buf); 416 } 417 418 /*VARARGS2*/ 419 void 420 Msg(const char *fmt, ...) 421 { 422 va_list ap; 423 char buf[BUFSIZ]; 424 425 if (!done_curses) 426 return; 427 va_start(ap, fmt); 428 if (*fmt == '\a') { 429 beep(); 430 fmt++; 431 } 432 vsnprintf(buf, sizeof(buf), fmt, ap); 433 va_end(ap); 434 scrollarea_add(buf); 435 } 436 437 static void 438 prompt(const char *p, struct ship *ship) 439 { 440 static char buf[BUFSIZ]; 441 442 fmtship(buf, sizeof(buf), p, ship); 443 sc_prompt = buf; 444 sc_buf = ""; 445 sc_hasprompt = true; 446 } 447 448 static void 449 endprompt(void) 450 { 451 sc_prompt = NULL; 452 sc_buf = NULL; 453 sc_hasprompt = false; 454 } 455 456 /* 457 * Next two functions called from newturn() to poke display. Shouldn't 458 * exist... XXX 459 */ 460 461 void 462 display_hide_prompt(void) 463 { 464 sc_hideprompt = true; 465 draw_scroll(); 466 wrefresh(scroll_w); 467 } 468 469 void 470 display_reshow_prompt(void) 471 { 472 sc_hideprompt = false; 473 draw_scroll(); 474 wrefresh(scroll_w); 475 } 476 477 478 int 479 sgetch(const char *p, struct ship *ship, int flag) 480 { 481 int c; 482 char input[2]; 483 484 prompt(p, ship); 485 input[0] = '\0'; 486 input[1] = '\0'; 487 sc_buf = input; 488 blockalarm(); 489 draw_scroll(); 490 wrefresh(scroll_w); 491 fflush(stdout); 492 unblockalarm(); 493 while ((c = wgetch(scroll_w)) == EOF) 494 ; 495 if (flag && c >= ' ' && c < 0x7f) { 496 blockalarm(); 497 input[0] = c; 498 draw_scroll(); 499 wrefresh(scroll_w); 500 fflush(stdout); 501 unblockalarm(); 502 } 503 endprompt(); 504 return c; 505 } 506 507 void 508 sgetstr(const char *pr, char *buf, int n) 509 { 510 int c; 511 char *p = buf; 512 513 prompt(pr, (struct ship *)0); 514 sc_buf = buf; 515 for (;;) { 516 *p = 0; 517 blockalarm(); 518 draw_scroll(); 519 wrefresh(scroll_w); 520 fflush(stdout); 521 unblockalarm(); 522 while ((c = wgetch(scroll_w)) == EOF) 523 ; 524 switch (c) { 525 case '\n': 526 case '\r': 527 endprompt(); 528 return; 529 case '\b': 530 if (p > buf) { 531 /*waddstr(scroll_w, "\b \b");*/ 532 p--; 533 } 534 break; 535 default: 536 if (c >= ' ' && c < 0x7f && p < buf + n - 1) { 537 *p++ = c; 538 /*waddch(scroll_w, c);*/ 539 } else 540 beep(); 541 } 542 } 543 } 544 545 //////////////////////////////////////////////////////////// 546 // drawing of other panes 547 548 void 549 display_force_full_redraw(void) 550 { 551 clear(); 552 } 553 554 void 555 display_redraw(void) 556 { 557 draw_board(); 558 draw_view(); 559 draw_turn(); 560 draw_stat(); 561 draw_slot(); 562 draw_scroll(); 563 /* move the cursor */ 564 wrefresh(scroll_w); 565 /* paranoia */ 566 fflush(stdout); 567 } 568 569 static void 570 draw_view(void) 571 { 572 struct ship *sp; 573 574 werase(view_w); 575 foreachship(sp) { 576 if (sp->file->dir 577 && sp->file->row > viewrow 578 && sp->file->row < viewrow + VIEW_Y 579 && sp->file->col > viewcol 580 && sp->file->col < viewcol + VIEW_X) { 581 wmove(view_w, sp->file->row - viewrow, 582 sp->file->col - viewcol); 583 waddch(view_w, colours(sp)); 584 wmove(view_w, 585 sternrow(sp) - viewrow, 586 sterncol(sp) - viewcol); 587 waddch(view_w, sterncolour(sp)); 588 } 589 } 590 wrefresh(view_w); 591 } 592 593 static void 594 draw_turn(void) 595 { 596 wmove(turn_w, 0, 0); 597 wprintw(turn_w, "%cTurn %d", dont_adjust?'*':'-', turn); 598 wrefresh(turn_w); 599 } 600 601 static void 602 draw_stat(void) 603 { 604 wmove(stat_w, STAT_1, 0); 605 wprintw(stat_w, "Points %3d\n", mf->points); 606 wprintw(stat_w, "Fouls %2d\n", fouled(ms)); 607 wprintw(stat_w, "Grapples %2d\n", grappled(ms)); 608 609 wmove(stat_w, STAT_2, 0); 610 wprintw(stat_w, " 0 %c(%c)\n", 611 maxmove(ms, winddir + 3, -1) + '0', 612 maxmove(ms, winddir + 3, 1) + '0'); 613 waddstr(stat_w, " \\|/\n"); 614 wprintw(stat_w, " -^-%c(%c)\n", 615 maxmove(ms, winddir + 2, -1) + '0', 616 maxmove(ms, winddir + 2, 1) + '0'); 617 waddstr(stat_w, " /|\\\n"); 618 wprintw(stat_w, " | %c(%c)\n", 619 maxmove(ms, winddir + 1, -1) + '0', 620 maxmove(ms, winddir + 1, 1) + '0'); 621 wprintw(stat_w, " %c(%c)\n", 622 maxmove(ms, winddir, -1) + '0', 623 maxmove(ms, winddir, 1) + '0'); 624 625 wmove(stat_w, STAT_3, 0); 626 wprintw(stat_w, "Load %c%c %c%c\n", 627 loadname[mf->loadL], readyname(mf->readyL), 628 loadname[mf->loadR], readyname(mf->readyR)); 629 wprintw(stat_w, "Hull %2d\n", mc->hull); 630 wprintw(stat_w, "Crew %2d %2d %2d\n", 631 mc->crew1, mc->crew2, mc->crew3); 632 wprintw(stat_w, "Guns %2d %2d\n", mc->gunL, mc->gunR); 633 wprintw(stat_w, "Carr %2d %2d\n", mc->carL, mc->carR); 634 wprintw(stat_w, "Rigg %d %d %d ", mc->rig1, mc->rig2, mc->rig3); 635 if (mc->rig4 < 0) 636 waddch(stat_w, '-'); 637 else 638 wprintw(stat_w, "%d", mc->rig4); 639 wrefresh(stat_w); 640 } 641 642 void 643 draw_slot(void) 644 { 645 int i; 646 647 if (!boarding(ms, 0)) { 648 mvwaddstr(slot_w, 0, 0, " "); 649 mvwaddstr(slot_w, 1, 0, " "); 650 } else { 651 wmove(slot_w, 0, 0); 652 for (i = 0; i < 3; i++) { 653 waddch(slot_w, obp[i] ? '1'+i : ' '); 654 } 655 mvwaddstr(slot_w, 1, 0, "OBP"); 656 } 657 if (!boarding(ms, 1)) { 658 mvwaddstr(slot_w, 2, 0, " "); 659 mvwaddstr(slot_w, 3, 0, " "); 660 } else { 661 wmove(slot_w, 2, 0); 662 for (i = 0; i < 3; i++) { 663 waddch(slot_w, dbp[i] ? '1'+i : ' '); 664 } 665 mvwaddstr(slot_w, 3, 0, "DBP"); 666 } 667 668 wmove(slot_w, SLOT_Y-4, 0); 669 if (mf->RH) 670 wprintw(slot_w, "%dRH", mf->RH); 671 else 672 waddstr(slot_w, " "); 673 wmove(slot_w, SLOT_Y-3, 0); 674 if (mf->RG) 675 wprintw(slot_w, "%dRG", mf->RG); 676 else 677 waddstr(slot_w, " "); 678 wmove(slot_w, SLOT_Y-2, 0); 679 if (mf->RR) 680 wprintw(slot_w, "%dRR", mf->RR); 681 else 682 waddstr(slot_w, " "); 683 684 #define Y (SLOT_Y/2) 685 wmove(slot_w, 7, 1); 686 wprintw(slot_w,"%d", windspeed); 687 mvwaddch(slot_w, Y, 0, ' '); 688 mvwaddch(slot_w, Y, 2, ' '); 689 mvwaddch(slot_w, Y-1, 0, ' '); 690 mvwaddch(slot_w, Y-1, 1, ' '); 691 mvwaddch(slot_w, Y-1, 2, ' '); 692 mvwaddch(slot_w, Y+1, 0, ' '); 693 mvwaddch(slot_w, Y+1, 1, ' '); 694 mvwaddch(slot_w, Y+1, 2, ' '); 695 wmove(slot_w, Y - dr[winddir], 1 - dc[winddir]); 696 switch (winddir) { 697 case 1: 698 case 5: 699 waddch(slot_w, '|'); 700 break; 701 case 2: 702 case 6: 703 waddch(slot_w, '/'); 704 break; 705 case 3: 706 case 7: 707 waddch(slot_w, '-'); 708 break; 709 case 4: 710 case 8: 711 waddch(slot_w, '\\'); 712 break; 713 } 714 mvwaddch(slot_w, Y + dr[winddir], 1 + dc[winddir], '+'); 715 wrefresh(slot_w); 716 } 717 718 void 719 draw_board(void) 720 { 721 int n; 722 723 erase(); 724 werase(view_w); 725 werase(slot_w); 726 werase(scroll_w); 727 werase(stat_w); 728 werase(turn_w); 729 730 move(BOX_T, BOX_L); 731 for (n = 0; n < BOX_X; n++) 732 addch('-'); 733 move(BOX_B, BOX_L); 734 for (n = 0; n < BOX_X; n++) 735 addch('-'); 736 for (n = BOX_T+1; n < BOX_B; n++) { 737 mvaddch(n, BOX_L, '|'); 738 mvaddch(n, BOX_R, '|'); 739 } 740 mvaddch(BOX_T, BOX_L, '+'); 741 mvaddch(BOX_T, BOX_R, '+'); 742 mvaddch(BOX_B, BOX_L, '+'); 743 mvaddch(BOX_B, BOX_R, '+'); 744 refresh(); 745 746 #if 0 747 #define WSaIM "Wooden Ships & Iron Men" 748 wmove(view_w, 2, (VIEW_X - sizeof WSaIM - 1) / 2); 749 waddstr(view_w, WSaIM); 750 wmove(view_w, 4, (VIEW_X - strlen(cc->name)) / 2); 751 waddstr(view_w, cc->name); 752 wrefresh(view_w); 753 #endif 754 755 move(LINE_T, LINE_L); 756 printw("Class %d %s (%d guns) '%s' (%c%c)", 757 mc->class, 758 classname[mc->class], 759 mc->guns, 760 ms->shipname, 761 colours(ms), 762 sterncolour(ms)); 763 refresh(); 764 } 765 766 void 767 display_set_obp(int which, bool show) 768 { 769 obp[which] = show; 770 } 771 772 void 773 display_set_dbp(int which, bool show) 774 { 775 dbp[which] = show; 776 } 777 778 //////////////////////////////////////////////////////////// 779 // external actions on the display 780 781 void 782 display_scroll_pageup(void) 783 { 784 unsigned total_lines, visible_lines, limit; 785 unsigned pagesize = SCROLL_Y - 2; 786 787 total_lines = stringarray_num(sc_lines); 788 visible_lines = SCROLL_Y - 1; 789 limit = total_lines - visible_lines; 790 791 sc_scrollup += pagesize; 792 if (sc_scrollup > limit) { 793 sc_scrollup = limit; 794 } 795 } 796 797 void 798 display_scroll_pagedown(void) 799 { 800 unsigned pagesize = SCROLL_Y - 2; 801 802 if (sc_scrollup < pagesize) { 803 sc_scrollup = 0; 804 } else { 805 sc_scrollup -= pagesize; 806 } 807 } 808 809 void 810 centerview(void) 811 { 812 viewrow = mf->row - VIEW_Y / 2; 813 viewcol = mf->col - VIEW_X / 2; 814 } 815 816 void 817 upview(void) 818 { 819 viewrow -= VIEW_Y / 3; 820 } 821 822 void 823 downview(void) 824 { 825 viewrow += VIEW_Y / 3; 826 } 827 828 void 829 leftview(void) 830 { 831 viewcol -= VIEW_X / 5; 832 } 833 834 void 835 rightview(void) 836 { 837 viewcol += VIEW_X / 5; 838 } 839 840 /* Called from newturn()... rename? */ 841 void 842 display_adjust_view(void) 843 { 844 if (dont_adjust) 845 return; 846 if (mf->row < viewrow + VIEW_Y/4) 847 viewrow = mf->row - (VIEW_Y - VIEW_Y/4); 848 else if (mf->row > viewrow + (VIEW_Y - VIEW_Y/4)) 849 viewrow = mf->row - VIEW_Y/4; 850 if (mf->col < viewcol + VIEW_X/8) 851 viewcol = mf->col - (VIEW_X - VIEW_X/8); 852 else if (mf->col > viewcol + (VIEW_X - VIEW_X/8)) 853 viewcol = mf->col - VIEW_X/8; 854 } 855 856 //////////////////////////////////////////////////////////// 857 // starting game 858 859 static bool shipselected; 860 static int loadpos; 861 862 static int 863 nextload(int load) 864 { 865 switch (load) { 866 case L_ROUND: return L_GRAPE; 867 case L_GRAPE: return L_CHAIN; 868 case L_CHAIN: return L_DOUBLE; 869 case L_DOUBLE: return L_ROUND; 870 } 871 return L_ROUND; 872 } 873 874 static int 875 loadbychar(int ch) 876 { 877 switch (ch) { 878 case 'r': return L_ROUND; 879 case 'g': return L_GRAPE; 880 case 'c': return L_CHAIN; 881 case 'd': return L_DOUBLE; 882 } 883 return L_ROUND; 884 } 885 886 static const char * 887 loadstr(int load) 888 { 889 switch (load) { 890 case L_ROUND: return "round"; 891 case L_GRAPE: return "grape"; 892 case L_CHAIN: return "chain"; 893 case L_DOUBLE: return "double"; 894 } 895 return "???"; 896 } 897 898 static void 899 displayshiplist(void) 900 { 901 struct ship *sp; 902 int which; 903 904 erase(); 905 906 attron(A_BOLD); 907 mvaddstr(1, 4, cc->name); 908 attroff(A_BOLD); 909 910 which = 0; 911 foreachship(sp) { 912 mvselprintw(which + 3, 4, which, player, 60, 913 " %2d: %-10s %-15s (%-2d pts) %s", 914 sp->file->index, 915 countryname[sp->nationality], 916 sp->shipname, 917 sp->specs->pts, 918 saywhat(sp, 1)); 919 which++; 920 } 921 922 if (!shipselected) { 923 mvaddstr(15, 4, "Choose your ship"); 924 move(player + 3, 63); 925 } else { 926 mvselprintw(15, 4, 0, loadpos, 32, 927 "Initial left broadside: %s", loadstr(mf->loadL)); 928 mvselprintw(16, 4, 1, loadpos, 32, 929 "Initial right broadside: %s", loadstr(mf->loadR)); 930 mvselprintw(17, 4, 2, loadpos, 32, "Set sail"); 931 move(loadpos+15, 35); 932 } 933 934 wrefresh(stdscr); 935 } 936 937 static int 938 pickship(void) 939 { 940 struct File *fp; 941 struct ship *sp; 942 bool done; 943 int ch; 944 945 for (;;) { 946 foreachship(sp) 947 if (sp->file->captain[0] == 0 && !sp->file->struck 948 && sp->file->captured == 0) 949 break; 950 if (sp >= ls) { 951 return -1; 952 } 953 player = sp - SHIP(0); 954 if (randomize) { 955 /* nothing */ 956 } else { 957 done = false; 958 while (!done) { 959 displayshiplist(); 960 961 ch = getch(); 962 switch (ch) { 963 case 12 /*^L*/: 964 clear(); 965 break; 966 case '\r': 967 case '\n': 968 done = true; 969 break; 970 case 7 /*^G*/: 971 case 8 /*^H*/: 972 case 27 /*ESC*/: 973 case 127 /*^?*/: 974 beep(); 975 break; 976 case 16 /*^P*/: 977 case KEY_UP: 978 up(&player, NULL); 979 break; 980 case 14 /*^N*/: 981 case KEY_DOWN: 982 down(&player, NULL, cc->vessels, 983 cc->vessels); 984 break; 985 default: 986 beep(); 987 break; 988 } 989 } 990 } 991 if (player < 0) 992 continue; 993 if (Sync() < 0) 994 leave(LEAVE_SYNC); 995 fp = SHIP(player)->file; 996 if (fp->captain[0] || fp->struck || fp->captured != 0) 997 oops(16, 4, "That ship is taken."); 998 else 999 break; 1000 } 1001 return 0; 1002 } 1003 1004 static void 1005 pickload(void) 1006 { 1007 bool done; 1008 int ch; 1009 1010 mf->loadL = L_ROUND; 1011 mf->loadR = L_ROUND; 1012 1013 loadpos = 0; 1014 done = false; 1015 while (!done) { 1016 displayshiplist(); 1017 1018 ch = getch(); 1019 switch (ch) { 1020 case 12 /*^L*/: 1021 clear(); 1022 break; 1023 case 'r': 1024 case 'g': 1025 case 'c': 1026 case 'd': 1027 switch (loadpos) { 1028 case 0: mf->loadL = loadbychar(ch); break; 1029 case 1: mf->loadR = loadbychar(ch); break; 1030 case 2: beep(); break; 1031 } 1032 break; 1033 case '\r': 1034 case '\n': 1035 switch (loadpos) { 1036 case 0: mf->loadL = nextload(mf->loadL); break; 1037 case 1: mf->loadR = nextload(mf->loadR); break; 1038 case 2: done = true; break; 1039 } 1040 break; 1041 case 7 /*^G*/: 1042 case 8 /*^H*/: 1043 case 27 /*ESC*/: 1044 case 127 /*^?*/: 1045 beep(); 1046 break; 1047 case 16 /*^P*/: 1048 case KEY_UP: 1049 up(&loadpos, NULL); 1050 break; 1051 case 14 /*^N*/: 1052 case KEY_DOWN: 1053 down(&loadpos, NULL, 3, 3); 1054 break; 1055 default: 1056 beep(); 1057 break; 1058 } 1059 } 1060 mf->readyR = R_LOADED|R_INITIAL; 1061 mf->readyL = R_LOADED|R_INITIAL; 1062 } 1063 1064 static void 1065 startgame(void) 1066 { 1067 1068 ingame = true; 1069 shipselected = false; 1070 1071 pl_main_init(); 1072 1073 hasdriver = sync_exists(game); 1074 if (sync_open() < 0) { 1075 oops(21, 10, "syncfile: %s", strerror(errno)); 1076 pl_main_uninit(); 1077 ingame = false; 1078 return; 1079 } 1080 1081 if (hasdriver) { 1082 mvaddstr(21, 10, "Synchronizing with the other players..."); 1083 wrefresh(stdscr); 1084 fflush(stdout); 1085 if (Sync() < 0) 1086 leave(LEAVE_SYNC); 1087 } else { 1088 mvaddstr(21, 10, "Starting driver..."); 1089 wrefresh(stdscr); 1090 fflush(stdout); 1091 startdriver(); 1092 } 1093 1094 if (pickship() < 0) { 1095 oops(21, 10, "All ships taken in that scenario."); 1096 sync_close(0); 1097 people = 0; 1098 pl_main_uninit(); 1099 ingame = false; 1100 return; 1101 } 1102 shipselected = true; 1103 1104 ms = SHIP(player); 1105 mf = ms->file; 1106 mc = ms->specs; 1107 1108 pickload(); 1109 1110 pl_main(); 1111 ingame = false; 1112 } 1113 1114 //////////////////////////////////////////////////////////// 1115 // scenario picker 1116 1117 static int pickerpos; 1118 static int pickerscroll; 1119 1120 static const char * 1121 absdirectionname(int dir) 1122 { 1123 switch (dir) { 1124 case 1: return "South"; 1125 case 2: return "Southwest"; 1126 case 3: return "West"; 1127 case 4: return "Northwest"; 1128 case 5: return "North"; 1129 case 6: return "Northeast"; 1130 case 7: return "East"; 1131 case 8: return "Southeast"; 1132 } 1133 return "?"; 1134 } 1135 1136 static const char * 1137 windname(int wind) 1138 { 1139 switch (wind) { 1140 case 0: return "calm"; 1141 case 1: return "light breeze"; 1142 case 2: return "moderate breeze"; 1143 case 3: return "fresh breeze"; 1144 case 4: return "strong breeze"; 1145 case 5: return "gale"; 1146 case 6: return "full gale"; 1147 case 7: return "hurricane"; 1148 } 1149 return "???"; 1150 } 1151 1152 static const char * 1153 nationalityname(int nationality) 1154 { 1155 switch (nationality) { 1156 case N_A: return "a"; 1157 case N_B: return "b"; 1158 case N_S: return "s"; 1159 case N_F: return "f"; 1160 case N_J: return "j"; 1161 case N_D: return "d"; 1162 case N_K: return "k"; 1163 case N_O: return "o"; 1164 } 1165 return "?"; 1166 } 1167 1168 static void 1169 drawpicker(void) 1170 { 1171 int y, sc, i; 1172 struct ship *ship; 1173 1174 erase(); 1175 1176 mvaddstr(0, 0, "## SHIPS TITLE"); 1177 for (y=1; y<LINES-11; y++) { 1178 sc = (y-1) + pickerscroll; 1179 if (sc < NSCENE) { 1180 mvselprintw(y, 0, sc, pickerpos, 56, 1181 "%-2d %-5d %s", 1182 sc, scene[sc].vessels, scene[sc].name); 1183 } 1184 } 1185 1186 mvprintw(2, 60 + 2, "%s wind", 1187 absdirectionname(scene[pickerpos].winddir)); 1188 mvprintw(3, 60 + 2, "(%s)", 1189 windname(scene[pickerpos].windspeed)); 1190 1191 for (i=0; i<scene[pickerpos].vessels; i++) { 1192 ship = &scene[pickerpos].ship[i]; 1193 mvprintw(LINES-10 + i, 0, 1194 "(%s) %-16s %3d gun %s (%s crew) (%d pts)", 1195 nationalityname(ship->nationality), 1196 ship->shipname, 1197 ship->specs->guns, 1198 shortclassname[ship->specs->class], 1199 qualname[ship->specs->qual], 1200 ship->specs->pts); 1201 } 1202 1203 move(1 + pickerpos - pickerscroll, 55); 1204 wrefresh(stdscr); 1205 } 1206 1207 static int 1208 pickscenario(int initpos) 1209 { 1210 int ch; 1211 1212 pickerpos = initpos; 1213 if (pickerpos < 0) { 1214 pickerpos = 0; 1215 } 1216 1217 while (1) { 1218 drawpicker(); 1219 ch = getch(); 1220 switch (ch) { 1221 case 12 /*^L*/: 1222 clear(); 1223 break; 1224 case '\r': 1225 case '\n': 1226 return pickerpos; 1227 case 7 /*^G*/: 1228 case 8 /*^H*/: 1229 case 27 /*ESC*/: 1230 case 127 /*^?*/: 1231 return initpos; 1232 case 16 /*^P*/: 1233 case KEY_UP: 1234 up(&pickerpos, &pickerscroll); 1235 break; 1236 case 14 /*^N*/: 1237 case KEY_DOWN: 1238 down(&pickerpos, &pickerscroll, NSCENE, LINES-12); 1239 break; 1240 default: 1241 beep(); 1242 break; 1243 } 1244 } 1245 return pickerpos; 1246 } 1247 1248 //////////////////////////////////////////////////////////// 1249 // setup menus 1250 1251 #define MAINITEMS_NUM 5 1252 #define STARTITEMS_NUM 4 1253 #define OPTIONSITEMS_NUM 5 1254 1255 static int mainpos; 1256 static bool connected; 1257 1258 static bool joinactive; 1259 static int joinpos; 1260 static int joinscroll; 1261 static int joinable[NSCENE]; 1262 static int numjoinable; 1263 1264 static bool startactive; 1265 static int startpos; 1266 static int startscenario; 1267 1268 static bool optionsactive; 1269 static int optionspos; 1270 static char o_myname[MAXNAMESIZE]; 1271 static bool o_randomize; 1272 static bool o_longfmt; 1273 static bool o_nobells; 1274 1275 1276 /* 1277 * this and sgetstr() should share code 1278 */ 1279 static void 1280 startup_getstr(int y, int x, char *buf, size_t max) 1281 { 1282 size_t pos = 0; 1283 int ch; 1284 1285 for (;;) { 1286 buf[pos] = 0; 1287 move(y, x); 1288 addstr(buf); 1289 clrtoeol(); 1290 wrefresh(stdscr); 1291 fflush(stdout); 1292 1293 ch = getch(); 1294 switch (ch) { 1295 case '\n': 1296 case '\r': 1297 return; 1298 case '\b': 1299 if (pos > 0) { 1300 /*waddstr(scroll_w, "\b \b");*/ 1301 pos--; 1302 } 1303 break; 1304 default: 1305 if (ch >= ' ' && ch < 0x7f && pos < max - 1) { 1306 buf[pos++] = ch; 1307 } else { 1308 beep(); 1309 } 1310 } 1311 } 1312 } 1313 1314 static void 1315 changename(void) 1316 { 1317 mvaddstr(LINES-2, COLS/2, "Enter your name:"); 1318 startup_getstr(LINES-1, COLS/2, o_myname, sizeof(o_myname)); 1319 } 1320 1321 static void 1322 checkforgames(void) 1323 { 1324 int i; 1325 int prev; 1326 1327 if (numjoinable > 0) { 1328 prev = joinable[joinpos]; 1329 } else { 1330 prev = 0; 1331 } 1332 1333 numjoinable = 0; 1334 for (i = 0; i < NSCENE; i++) { 1335 if (!sync_exists(i)) { 1336 continue; 1337 } 1338 if (i < prev) { 1339 joinpos = numjoinable; 1340 } 1341 joinable[numjoinable++] = i; 1342 } 1343 if (joinpos > numjoinable) { 1344 joinpos = (numjoinable > 0) ? numjoinable - 1 : 0; 1345 } 1346 if (joinscroll > joinpos) { 1347 joinscroll = (joinpos > 0) ? joinpos - 1 : 0; 1348 } 1349 } 1350 1351 static void 1352 drawstartmenus(void) 1353 { 1354 const int mainy0 = 8; 1355 const int mainx0 = 12; 1356 1357 erase(); 1358 1359 mvaddstr(5, 10, "Wooden Ships & Iron Men"); 1360 1361 mvaddselstr(mainy0+0, mainx0, 0, mainpos, 17, "Join a game"); 1362 mvaddselstr(mainy0+1, mainx0, 1, mainpos, 17, "Start a game"); 1363 mvaddselstr(mainy0+2, mainx0, 2, mainpos, 17, "Options"); 1364 mvaddselstr(mainy0+3, mainx0, 3, mainpos, 17, "Show high scores"); 1365 mvaddselstr(mainy0+4, mainx0, 4, mainpos, 17, "Quit"); 1366 1367 mvprintw(15, 10, "Captain %s", myname); 1368 if (connected) { 1369 mvaddstr(16, 10, "Connected via scratch files."); 1370 } else { 1371 mvaddstr(16, 10, "Not connected."); 1372 } 1373 1374 if (joinactive) { 1375 int y0, leavey = 0, i, sc; 1376 1377 mvaddstr(0, COLS/2, "## SHIPS TITLE"); 1378 y0 = 1; 1379 for (i = 0; i < numjoinable; i++) { 1380 if (i >= joinscroll && i < joinscroll + LINES-1) { 1381 move(y0 + i - joinscroll, COLS/2); 1382 if (i == joinpos) { 1383 attron(A_REVERSE); 1384 } 1385 sc = joinable[i]; 1386 printw("%-2d %-5d %s", 1387 sc, scene[sc].vessels, scene[sc].name); 1388 if (i == joinpos) { 1389 filltoeol(); 1390 attroff(A_REVERSE); 1391 leavey = y0 + i - joinscroll; 1392 } 1393 } 1394 } 1395 mvaddstr(19, 10, "(Esc to abort)"); 1396 if (numjoinable > 0) { 1397 mvaddstr(18, 10, "Choose a game to join."); 1398 move(leavey, COLS-1); 1399 } else { 1400 mvaddstr(2, COLS/2, "No games."); 1401 mvaddstr(18, 10, "Press return to refresh."); 1402 } 1403 1404 } else if (startactive) { 1405 const char *name; 1406 1407 mvaddstr(18, 10, "Start a new game"); 1408 mvaddstr(19, 10, "(Esc to abort)"); 1409 mvaddstr(2, COLS/2, "New game"); 1410 1411 name = (startscenario < 0) ? 1412 "not selected" : scene[startscenario].name; 1413 1414 mvselprintw(4, COLS/2, 0, startpos, COLS/2 - 1, 1415 "Scenario: %s", name); 1416 mvaddselstr(5, COLS/2, 1, startpos, COLS/2 - 1, 1417 "Visibility: local"); 1418 mvaddselstr(6, COLS/2, 2, startpos, COLS/2 - 1, 1419 "Password: unset"); 1420 mvaddselstr(7, COLS/2, 3, startpos, COLS/2 - 1, 1421 "Start game"); 1422 move(4+startpos, COLS - 2); 1423 1424 } else if (optionsactive) { 1425 mvaddstr(18, 10, "Adjust options"); 1426 mvaddstr(19, 10, "(Esc to abort)"); 1427 mvaddstr(2, COLS/2, "Adjust options"); 1428 1429 mvselprintw(4, COLS/2, 0, optionspos, COLS/2-1, 1430 "Your name: %s", o_myname); 1431 mvselprintw(5, COLS/2, 1, optionspos, COLS/2-1, 1432 "Auto-pick ships: %s", o_randomize ? "ON" : "off"); 1433 mvselprintw(6, COLS/2, 2, optionspos, COLS/2-1, 1434 "Usernames in scores: %s", 1435 o_longfmt ? "ON" : "off"); 1436 mvselprintw(7, COLS/2, 3, optionspos, COLS/2-1, 1437 "Beeping: %s", o_nobells ? "OFF" : "on"); 1438 mvselprintw(8, COLS/2, 4, optionspos, COLS/2-1, 1439 "Apply changes"); 1440 move(4+optionspos, COLS - 2); 1441 1442 } else { 1443 move(mainy0 + mainpos, mainx0 + 16); 1444 } 1445 1446 wrefresh(stdscr); 1447 fflush(stdout); 1448 } 1449 1450 void 1451 startup(void) 1452 { 1453 int ch; 1454 1455 connected = false; 1456 mainpos = 0; 1457 1458 joinactive = false; 1459 joinpos = 0; 1460 joinscroll = 0; 1461 numjoinable = 0; 1462 1463 startactive = false; 1464 startpos = 0; 1465 startscenario = -1; 1466 1467 optionsactive = false; 1468 optionspos = 0; 1469 1470 while (1) { 1471 if (joinactive) { 1472 checkforgames(); 1473 } 1474 drawstartmenus(); 1475 ch = getch(); 1476 switch (ch) { 1477 case 12 /*^L*/: 1478 clear(); 1479 break; 1480 case '\r': 1481 case '\n': 1482 if (joinactive && numjoinable > 0) { 1483 game = joinable[joinpos]; 1484 startgame(); 1485 joinactive = false; 1486 } else if (startactive) { 1487 switch (startpos) { 1488 case 0: 1489 startscenario = pickscenario(startscenario); 1490 startpos = 3; 1491 break; 1492 case 1: 1493 case 2: 1494 oops(21, 10, "That doesn't work yet."); 1495 break; 1496 case 3: 1497 if (startscenario >= 0) { 1498 game = startscenario; 1499 /* can't do this here yet */ 1500 /*startdriver();*/ 1501 startgame(); 1502 startactive = false; 1503 startscenario = -1; 1504 } else { 1505 oops(21, 10, 1506 "Pick a scenario."); 1507 } 1508 break; 1509 } 1510 } else if (optionsactive) { 1511 switch (optionspos) { 1512 case 0: changename(); break; 1513 case 1: o_randomize = !o_randomize; break; 1514 case 2: o_longfmt = !o_longfmt; break; 1515 case 3: o_nobells = !o_nobells; break; 1516 case 4: 1517 strlcpy(myname, o_myname, 1518 sizeof(myname)); 1519 randomize = o_randomize; 1520 longfmt = o_longfmt; 1521 nobells = o_nobells; 1522 optionsactive = false; 1523 break; 1524 } 1525 } else { 1526 switch (mainpos) { 1527 case 0: joinactive = true; break; 1528 case 1: startactive = true; break; 1529 case 2: 1530 strlcpy(o_myname, myname, 1531 sizeof(o_myname)); 1532 o_randomize = randomize; 1533 o_longfmt = longfmt; 1534 o_nobells = nobells; 1535 optionsactive = true; 1536 break; 1537 case 3: lo_curses(); break; 1538 case 4: return; 1539 } 1540 } 1541 break; 1542 case 7 /*^G*/: 1543 case 8 /*^H*/: 1544 case 27 /*ESC*/: 1545 case 127 /*^?*/: 1546 if (joinactive) { 1547 joinactive = false; 1548 } else if (startactive) { 1549 startactive = false; 1550 } else if (optionsactive) { 1551 optionsactive = false; 1552 } else { 1553 /* nothing */ 1554 } 1555 break; 1556 case 16 /*^P*/: 1557 case KEY_UP: 1558 if (joinactive) { 1559 up(&joinpos, &joinscroll); 1560 } else if (startactive) { 1561 up(&startpos, NULL); 1562 } else if (optionsactive) { 1563 up(&optionspos, NULL); 1564 } else { 1565 up(&mainpos, NULL); 1566 } 1567 break; 1568 case 14 /*^N*/: 1569 case KEY_DOWN: 1570 if (joinactive) { 1571 down(&joinpos, &joinscroll, 1572 numjoinable, LINES-1); 1573 } else if (startactive) { 1574 down(&startpos, NULL, 1575 STARTITEMS_NUM, STARTITEMS_NUM); 1576 } else if (optionsactive) { 1577 down(&optionspos, NULL, 1578 OPTIONSITEMS_NUM, OPTIONSITEMS_NUM); 1579 } else { 1580 down(&mainpos, NULL, 1581 MAINITEMS_NUM, MAINITEMS_NUM); 1582 } 1583 break; 1584 default: 1585 beep(); 1586 break; 1587 } 1588 } 1589 } 1590