games/sail/pl_7.c

   1 /*-
   2  * Copyright (c) 1983, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)pl_7.c   8.1 (Berkeley) 5/31/93
  30  * $FreeBSD: src/games/sail/pl_7.c,v 1.7 1999/11/30 03:49:37 billf Exp $
  31  * $DragonFly: src/games/sail/pl_7.c,v 1.3 2006/09/03 17:33:13 pavalos Exp $
  32  */
  33
  34 #include <sys/ttydefaults.h>
  35 #include <string.h>
  36 #include "player.h"
  37
  38
  39 /*
  40  * Display interface
  41  */
  42
  43 static char sc_hasprompt;
  44 static const char *sc_prompt;
  45 static const char *sc_buf;
  46 static int sc_line;
  47
  48 static void Scroll(void);
  49 static void prompt(const char *, struct ship *);
  50 static void endprompt(char);
  51 static void adjustview(void);
  52
  53 void
  54 initscreen(void)
  55 {
  56         /* initscr() already done in SCREENTEST() */
  57         view_w = newwin(VIEW_Y, VIEW_X, VIEW_T, VIEW_L);
  58         slot_w = newwin(SLOT_Y, SLOT_X, SLOT_T, SLOT_L);
  59         scroll_w = newwin(SCROLL_Y, SCROLL_X, SCROLL_T, SCROLL_L);
  60         stat_w = newwin(STAT_Y, STAT_X, STAT_T, STAT_L);
  61         turn_w = newwin(TURN_Y, TURN_X, TURN_T, TURN_L);
  62         done_curses++;
  63         leaveok(view_w, 1);
  64         leaveok(slot_w, 1);
  65         leaveok(stat_w, 1);
  66         leaveok(turn_w, 1);
  67         noecho();
  68         cbreak();
  69 }
  70
  71 void
  72 cleanupscreen(void)
  73 {
  74         /* alarm already turned off */
  75         if (done_curses) {
  76                 wmove(scroll_w, SCROLL_Y - 1, 0);
  77                 wclrtoeol(scroll_w);
  78                 draw_screen();
  79                 endwin();
  80         }
  81 }
  82
  83 void
  84 newturn(void)
  85 {
  86         repaired = loaded = fired = changed = 0;
  87         movebuf[0] = '\0';
  88
  89         alarm(0);
  90         if (mf->readyL & R_LOADING) {
  91                 if (mf->readyL & R_DOUBLE)
  92                         mf->readyL = R_LOADING;
  93                 else
  94                         mf->readyL = R_LOADED;
  95         }
  96         if (mf->readyR & R_LOADING) {
  97                 if (mf->readyR & R_DOUBLE)
  98                         mf->readyR = R_LOADING;
  99                 else
 100                         mf->readyR = R_LOADED;
 101         }
 102         if (!hasdriver)
 103                 Write(W_DDEAD, SHIP(0), 0, 0, 0, 0);
 104
 105         if (sc_hasprompt) {
 106                 wmove(scroll_w, sc_line, 0);
 107                 wclrtoeol(scroll_w);
 108         }
 109         if (Sync() < 0)
 110                 leave(LEAVE_SYNC);
 111         if (!hasdriver)
 112                 leave(LEAVE_DRIVER);
 113         if (sc_hasprompt)
 114                 wprintw(scroll_w, "%s%s", sc_prompt, sc_buf);
 115
 116         if (turn % 50 == 0)
 117                 Write(W_ALIVE, SHIP(0), 0, 0, 0, 0);
 118         if (mf->FS && (!mc->rig1 || windspeed == 6))
 119                 Write(W_FS, ms, 0, 0, 0, 0);
 120         if (mf->FS == 1)
 121                 Write(W_FS, ms, 2, 0, 0, 0);
 122
 123         if (mf->struck)
 124                 leave(LEAVE_QUIT);
 125         if (mf->captured != 0)
 126                 leave(LEAVE_CAPTURED);
 127         if (windspeed == 7)
 128                 leave(LEAVE_HURRICAN);
 129
 130         adjustview();
 131         draw_screen();
 132
 133         signal(SIGALRM, (sig_t)newturn);
 134         alarm(7);
 135 }
 136
 137 /*VARARGS2*/
 138 void
 139 Signal(const char *fmt, struct ship *ship, ...)
 140 {
 141         va_list ap;
 142         char format[BUFSIZ];
 143
 144         if (!done_curses)
 145                 return;
 146         va_start(ap, ship);
 147         if (*fmt == '\a')
 148                 putchar(*fmt++);
 149         if (ship == NULL)
 150                 vw_printw(scroll_w, fmt, ap);
 151         else {
 152                 fmtship(format, sizeof(format), fmt, ship);
 153                 vw_printw(scroll_w, format, ap);
 154         }
 155         va_end(ap);
 156         Scroll();
 157 }
 158
 159 static void
 160 Scroll(void)
 161 {
 162         if (++sc_line >= SCROLL_Y)
 163                 sc_line = 0;
 164         wmove(scroll_w, sc_line, 0);
 165         wclrtoeol(scroll_w);
 166 }
 167
 168 static void
 169 prompt(const char *p, struct ship *ship)
 170 {
 171         static char buf[60];
 172
 173         if (ship != 0) {
 174                 printf(buf, p, ship->shipname, colours(ship),
 175                         sterncolour(ship));
 176                 p = buf;
 177         }
 178         sc_prompt = p;
 179         sc_buf = "";
 180         sc_hasprompt = 1;
 181         waddstr(scroll_w, p);
 182 }
 183
 184 static void
 185 endprompt(char flag)
 186 {
 187         sc_hasprompt = 0;
 188         if (flag)
 189                 Scroll();
 190 }
 191
 192 int
 193 sgetch(const char *p, struct ship *ship, char flag)
 194 {
 195         int c;
 196
 197         prompt(p, ship);
 198         blockalarm();
 199         wrefresh(scroll_w);
 200         unblockalarm();
 201         while ((c = wgetch(scroll_w)) == EOF)
 202                 ;
 203         if (flag && c >= ' ' && c < 0x7f)
 204                 waddch(scroll_w, c);
 205         endprompt(flag);
 206         return c;
 207 }
 208
 209 void
 210 sgetstr(const char *pr, char *buf, int n)
 211 {
 212         int c;
 213         char *p = buf;
 214
 215         prompt(pr, NULL);
 216         sc_buf = buf;
 217         for (;;) {
 218                 *p = 0;
 219                 blockalarm();
 220                 wrefresh(scroll_w);
 221                 unblockalarm();
 222                 while ((c = wgetch(scroll_w)) == EOF)
 223                         ;
 224                 switch (c) {
 225                 case '\n':
 226                 case '\r':
 227                         endprompt(1);
 228                         return;
 229                 case '\b':
 230                         if (p > buf) {
 231                                 waddstr(scroll_w, "\b \b");
 232                                 p--;
 233                         }
 234                         break;
 235                 default:
 236                         if (c >= ' ' && c < 0x7f && p < buf + n - 1) {
 237                                 *p++ = c;
 238                                 waddch(scroll_w, c);
 239                         } else
 240                                 putchar(CTRL('g'));
 241                 }
 242         }
 243 }
 244
 245 void
 246 draw_screen(void)
 247 {
 248         draw_view();
 249         draw_turn();
 250         draw_stat();
 251         draw_slot();
 252         wrefresh(scroll_w);             /* move the cursor */
 253 }
 254
 255 void
 256 draw_view(void)
 257 {
 258         struct ship *sp;
 259
 260         werase(view_w);
 261         foreachship(sp) {
 262                 if (sp->file->dir
 263                     && sp->file->row > viewrow
 264                     && sp->file->row < viewrow + VIEW_Y
 265                     && sp->file->col > viewcol
 266                     && sp->file->col < viewcol + VIEW_X) {
 267                         wmove(view_w, sp->file->row - viewrow,
 268                                 sp->file->col - viewcol);
 269                         waddch(view_w, colours(sp));
 270                         wmove(view_w,
 271                                 sternrow(sp) - viewrow,
 272                                 sterncol(sp) - viewcol);
 273                         waddch(view_w, sterncolour(sp));
 274                 }
 275         }
 276         wrefresh(view_w);
 277 }
 278
 279 void
 280 draw_turn(void)
 281 {
 282         wmove(turn_w, 0, 0);
 283         wprintw(turn_w, "%cTurn %d", dont_adjust?'*':'-', turn);
 284         wrefresh(turn_w);
 285 }
 286
 287 void
 288 draw_stat(void)
 289 {
 290         wmove(stat_w, STAT_1, 0);
 291         wprintw(stat_w, "Points  %3d\n", mf->points);
 292         wprintw(stat_w, "Fouls    %2d\n", fouled(ms));
 293         wprintw(stat_w, "Grapples %2d\n", grappled(ms));
 294
 295         wmove(stat_w, STAT_2, 0);
 296         wprintw(stat_w, "    0 %c(%c)\n",
 297                 maxmove(ms, winddir + 3, -1) + '0',
 298                 maxmove(ms, winddir + 3, 1) + '0');
 299         waddstr(stat_w, "   \\|/\n");
 300         wprintw(stat_w, "   -^-%c(%c)\n",
 301                 maxmove(ms, winddir + 2, -1) + '0',
 302                 maxmove(ms, winddir + 2, 1) + '0');
 303         waddstr(stat_w, "   /|\\\n");
 304         wprintw(stat_w, "    | %c(%c)\n",
 305                 maxmove(ms, winddir + 1, -1) + '0',
 306                 maxmove(ms, winddir + 1, 1) + '0');
 307         wprintw(stat_w, "   %c(%c)\n",
 308                 maxmove(ms, winddir, -1) + '0',
 309                 maxmove(ms, winddir, 1) + '0');
 310
 311         wmove(stat_w, STAT_3, 0);
 312         wprintw(stat_w, "Load  %c%c %c%c\n",
 313                 loadname[mf->loadL], readyname(mf->readyL),
 314                 loadname[mf->loadR], readyname(mf->readyR));
 315         wprintw(stat_w, "Hull %2d\n", mc->hull);
 316         wprintw(stat_w, "Crew %2d %2d %2d\n",
 317                 mc->crew1, mc->crew2, mc->crew3);
 318         wprintw(stat_w, "Guns %2d %2d\n", mc->gunL, mc->gunR);
 319         wprintw(stat_w, "Carr %2d %2d\n", mc->carL, mc->carR);
 320         wprintw(stat_w, "Rigg %d %d %d ", mc->rig1, mc->rig2, mc->rig3);
 321         if (mc->rig4 < 0)
 322                 waddch(stat_w, '-');
 323         else
 324                 wprintw(stat_w, "%d", mc->rig4);
 325         wrefresh(stat_w);
 326 }
 327
 328 void
 329 draw_slot(void)
 330 {
 331         if (!boarding(ms, 0)) {
 332                 mvwaddstr(slot_w, 0, 0, "   ");
 333                 mvwaddstr(slot_w, 1, 0, "   ");
 334         } else
 335                 mvwaddstr(slot_w, 1, 0, "OBP");
 336         if (!boarding(ms, 1)) {
 337                 mvwaddstr(slot_w, 2, 0, "   ");
 338                 mvwaddstr(slot_w, 3, 0, "   ");
 339         } else
 340                 mvwaddstr(slot_w, 3, 0, "DBP");
 341
 342         wmove(slot_w, SLOT_Y-4, 0);
 343         if (mf->RH)
 344                 wprintw(slot_w, "%dRH", mf->RH);
 345         else
 346                 waddstr(slot_w, "   ");
 347         wmove(slot_w, SLOT_Y-3, 0);
 348         if (mf->RG)
 349                 wprintw(slot_w, "%dRG", mf->RG);
 350         else
 351                 waddstr(slot_w, "   ");
 352         wmove(slot_w, SLOT_Y-2, 0);
 353         if (mf->RR)
 354                 wprintw(slot_w, "%dRR", mf->RR);
 355         else
 356                 waddstr(slot_w, "   ");
 357
 358 #define Y       (SLOT_Y/2)
 359         wmove(slot_w, 7, 1);
 360         wprintw(slot_w,"%d", windspeed);
 361         mvwaddch(slot_w, Y, 0, ' ');
 362         mvwaddch(slot_w, Y, 2, ' ');
 363         mvwaddch(slot_w, Y-1, 0, ' ');
 364         mvwaddch(slot_w, Y-1, 1, ' ');
 365         mvwaddch(slot_w, Y-1, 2, ' ');
 366         mvwaddch(slot_w, Y+1, 0, ' ');
 367         mvwaddch(slot_w, Y+1, 1, ' ');
 368         mvwaddch(slot_w, Y+1, 2, ' ');
 369         wmove(slot_w, Y - dr[winddir], 1 - dc[winddir]);
 370         switch (winddir) {
 371         case 1:
 372         case 5:
 373                 waddch(slot_w, '|');
 374                 break;
 375         case 2:
 376         case 6:
 377                 waddch(slot_w, '/');
 378                 break;
 379         case 3:
 380         case 7:
 381                 waddch(slot_w, '-');
 382                 break;
 383         case 4:
 384         case 8:
 385                 waddch(slot_w, '\\');
 386                 break;
 387         }
 388         mvwaddch(slot_w, Y + dr[winddir], 1 + dc[winddir], '+');
 389         wrefresh(slot_w);
 390 }
 391
 392 void
 393 draw_board(void)
 394 {
 395         int n;
 396
 397         clear();
 398         werase(view_w);
 399         werase(slot_w);
 400         werase(scroll_w);
 401         werase(stat_w);
 402         werase(turn_w);
 403
 404         sc_line = 0;
 405
 406         move(BOX_T, BOX_L);
 407         for (n = 0; n < BOX_X; n++)
 408                 addch('-');
 409         move(BOX_B, BOX_L);
 410         for (n = 0; n < BOX_X; n++)
 411                 addch('-');
 412         for (n = BOX_T+1; n < BOX_B; n++) {
 413                 mvaddch(n, BOX_L, '|');
 414                 mvaddch(n, BOX_R, '|');
 415         }
 416         mvaddch(BOX_T, BOX_L, '+');
 417         mvaddch(BOX_T, BOX_R, '+');
 418         mvaddch(BOX_B, BOX_L, '+');
 419         mvaddch(BOX_B, BOX_R, '+');
 420         refresh();
 421
 422 #define WSaIM "Wooden Ships & Iron Men"
 423         wmove(view_w, 2, (VIEW_X - sizeof WSaIM - 1) / 2);
 424         waddstr(view_w, WSaIM);
 425         wmove(view_w, 4, (VIEW_X - strlen(cc->name)) / 2);
 426         waddstr(view_w, cc->name);
 427         wrefresh(view_w);
 428
 429         move(LINE_T, LINE_L);
 430         printw("Class %d %s (%d guns) '%s' (%c%c)",
 431                 mc->class,
 432                 classname[mc->class],
 433                 mc->guns,
 434                 ms->shipname,
 435                 colours(ms),
 436                 sterncolour(ms));
 437         refresh();
 438 }
 439
 440 void
 441 centerview(void)
 442 {
 443         viewrow = mf->row - VIEW_Y / 2;
 444         viewcol = mf->col - VIEW_X / 2;
 445 }
 446
 447 void
 448 upview(void)
 449 {
 450         viewrow -= VIEW_Y / 3;
 451 }
 452
 453 void
 454 downview(void)
 455 {
 456         viewrow += VIEW_Y / 3;
 457 }
 458
 459 void
 460 leftview(void)
 461 {
 462         viewcol -= VIEW_X / 5;
 463 }
 464
 465 void
 466 rightview(void)
 467 {
 468         viewcol += VIEW_X / 5;
 469 }
 470
 471 static void
 472 adjustview(void)
 473 {
 474         if (dont_adjust)
 475                 return;
 476         if (mf->row < viewrow + VIEW_Y/4)
 477                 viewrow = mf->row - (VIEW_Y - VIEW_Y/4);
 478         else if (mf->row > viewrow + (VIEW_Y - VIEW_Y/4))
 479                 viewrow = mf->row - VIEW_Y/4;
 480         if (mf->col < viewcol + VIEW_X/8)
 481                 viewcol = mf->col - (VIEW_X - VIEW_X/8);
 482         else if (mf->col > viewcol + (VIEW_X - VIEW_X/8))
 483                 viewcol = mf->col - VIEW_X/8;
 484 }