1: /*      $NetBSD: pl_main.c,v 1.16 2003/08/07 09:37:44 agc 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_main.c   8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: pl_main.c,v 1.16 2003/08/07 09:37:44 agc Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include <setjmp.h>
   42: #include <signal.h>
   43: #include <stdio.h>
   44: #include <stdlib.h>
   45: #include <string.h>
   46: #include <unistd.h>
   47: #include "extern.h"
   48: #include "player.h"
   49: #include "restart.h"
   50: 
   51: static void     initialize(void);
   52: 
   53: /*ARGSUSED*/
   54: int
   55: pl_main(void)
   56: {
   57: 
   58:         initialize();
   59:         Msg("Aye aye, Sir");
   60:         play();
   61:         return 0;                      /* for lint,  play() never returns */
   62: }
   63: 
   64: static void
   65: initialize(void)
   66: {
   67:         struct File *fp;
   68:         struct ship *sp;
   69:         char captain[80];
   70:         char message[60];
   71:         int load;
   72:         int n;
   73:         char *nameptr;
   74:         int nat[NNATION];
   75: 
   76:         if (game < 0) {
   77:                 puts("Choose a scenario:\n");
   78:                 puts("\n\tNUMBER\tSHIPS\tIN PLAY\tTITLE");
   79:                 for (n = 0; n < NSCENE; n++) {
   80:                         /* ( */
   81:                         printf("\t%d):\t%d\t%s\t%s\n", n, scene[n].vessels,
   82:                                 sync_exists(n) ? "YES" : "no",
   83:                                 scene[n].name);
   84:                 }
   85: reprint:
   86:                 printf("\nScenario number? ");
   87:                 fflush(stdout);
   88:                 scanf("%d", &game);
   89:                 while (getchar() != '\n')
   90:                         ;
   91:         }
   92:         if (game < 0 || game >= NSCENE) {
   93:                 puts("Very funny.");
   94:                 exit(1);
   95:         }
   96:         cc = &scene[game];
   97:         ls = SHIP(cc->vessels);
   98: 
   99:         for (n = 0; n < NNATION; n++)
  100:                 nat[n] = 0;
  101:         foreachship(sp) {
  102:                 if (sp->file == NULL &&
  103:                     (sp->file = (struct File *)calloc(1, sizeof (struct File))) == NULL) {
  104:                         puts("OUT OF MEMORY");
  105:                         exit(1);
  106:                 }
  107:                 sp->file->index = sp - SHIP(0);
  108:                 sp->file->stern = nat[sp->nationality]++;
  109:                 sp->file->dir = sp->shipdir;
  110:                 sp->file->row = sp->shiprow;
  111:                 sp->file->col = sp->shipcol;
  112:         }
  113:         windspeed = cc->windspeed;
  114:         winddir = cc->winddir;
  115: 
  116:         signal(SIGHUP, choke);
  117:         signal(SIGINT, choke);
  118: 
  119:         hasdriver = sync_exists(game);
  120:         if (sync_open() < 0) {
  121:                 perror("sail: syncfile");
  122:                 exit(1);
  123:         }
  124: 
  125:         if (hasdriver) {
  126:                 puts("Synchronizing with the other players...");
  127:                 fflush(stdout);
  128:                 if (Sync() < 0)
  129:                         leave(LEAVE_SYNC);
  130:         }
  131:         for (;;) {
  132:                 foreachship(sp)
  133:                         if (sp->file->captain[0] == 0 && !sp->file->struck
  134:                             && sp->file->captured == 0)
  135:                                 break;
  136:                 if (sp >= ls) {
  137:                         puts("All ships taken in that scenario.");
  138:                         foreachship(sp)
  139:                                 free((char *)sp->file);
  140:                         sync_close(0);
  141:                         people = 0;
  142:                         goto reprint;
  143:                 }
  144:                 if (randomize) {
  145:                         player = sp - SHIP(0);
  146:                 } else {
  147:                         printf("%s\n\n", cc->name);
  148:                         foreachship(sp)
  149:                                 printf("  %2d:  %-10s %-15s  (%-2d pts)   %s\n",
  150:                                         sp->file->index,
  151:                                         countryname[sp->nationality],
  152:                                         sp->shipname,
  153:                                         sp->specs->pts,
  154:                                         saywhat(sp, 1));
  155:                         printf("\nWhich ship (0-%d)? ", cc->vessels-1);
  156:                         fflush(stdout);
  157:                         if (scanf("%d", &player) != 1 || player < 0
  158:                             || player >= cc->vessels) {
  159:                                 while (getchar() != '\n')
  160:                                         ;
  161:                                 puts("Say what?");
  162:                                 player = -1;
  163:                         } else
  164:                                 while (getchar() != '\n')
  165:                                         ;
  166:                 }
  167:                 if (player < 0)
  168:                         continue;
  169:                 if (Sync() < 0)
  170:                         leave(LEAVE_SYNC);
  171:                 fp = SHIP(player)->file;
  172:                 if (fp->captain[0] || fp->struck || fp->captured != 0)
  173:                         puts("That ship is taken.");
  174:                 else
  175:                         break;
  176:         }
  177: 
  178:         ms = SHIP(player);
  179:         mf = ms->file;
  180:         mc = ms->specs;
  181: 
  182:         Write(W_BEGIN, ms, 0, 0, 0, 0);
  183:         if (Sync() < 0)
  184:                 leave(LEAVE_SYNC);
  185: 
  186:         signal(SIGCHLD, child);
  187:         if (!hasdriver)
  188:                 switch (fork()) {
  189:                 case 0:
  190:                         longjmp(restart, MODE_DRIVER);
  191:                         /*NOTREACHED*/
  192:                 case -1:
  193:                         perror("fork");
  194:                         leave(LEAVE_FORK);
  195:                         break;
  196:                 default:
  197:                         hasdriver++;
  198:                 }
  199: 
  200:         printf("Your ship is the %s, a %d gun %s (%s crew).\n",
  201:                 ms->shipname, mc->guns, classname[mc->class],
  202:                 qualname[mc->qual]);
  203:         if ((nameptr = (char *) getenv("SAILNAME")) && *nameptr)
  204:                 strncpy(captain, nameptr, sizeof captain);
  205:         else {
  206:                 printf("Your name, Captain? ");
  207:                 fflush(stdout);
  208:                 fgets(captain, sizeof captain, stdin);
  209:                 if (!*captain)
  210:                         strcpy(captain, "no name");
  211:                 else
  212:                     captain[strlen(captain) - 1] = '\0';
  213:         }
  214:         captain[sizeof captain - 1] = '\0';
  215:         Writestr(W_CAPTAIN, ms, captain);
  216:         for (n = 0; n < 2; n++) {
  217:                 char buf[10];
  218: 
  219:                 printf("\nInitial broadside %s (grape, chain, round, double): ",
  220:                         n ? "right" : "left");
  221:                 fflush(stdout);
  222:                 scanf("%s", buf);
  223:                 switch (*buf) {
  224:                 case 'g':
  225:                         load = L_GRAPE;
  226:                         break;
  227:                 case 'c':
  228:                         load = L_CHAIN;
  229:                         break;
  230:                 case 'r':
  231:                         load = L_ROUND;
  232:                         break;
  233:                 case 'd':
  234:                         load = L_DOUBLE;
  235:                         break;
  236:                 default:
  237:                         load = L_ROUND;
  238:                 }
  239:                 if (n) {
  240:                         mf->loadR = load;
  241:                         mf->readyR = R_LOADED|R_INITIAL;
  242:                 } else {
  243:                         mf->loadL = load;
  244:                         mf->readyL = R_LOADED|R_INITIAL;
  245:                 }
  246:         }
  247: 
  248:         initscreen();
  249:         draw_board();
  250:         snprintf(message, sizeof message, "Captain %s assuming command",
  251:                         captain);
  252:         Writestr(W_SIGNAL, ms, message);
  253:         newturn(0);
  254: }