usr/src/games/sail/pl_main.c

/*
 * Copyright (c) 1983 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef lint
static char sccsid[] = "@(#)pl_main.c   5.5 (Berkeley) 2/28/91";
#endif /* not lint */

#include "player.h"
#include <sys/types.h>
#include <sys/wait.h>

void choke(), child();

/*ARGSUSED*/
pl_main()
{

        if (!SCREENTEST()) {
                printf("Can't sail on this terminal.\n");
                exit(1);
        }
        initialize();
        Signal("Aye aye, Sir", (struct ship *)0);
        play();
        return 0;                       /* for lint,  play() never returns */
}

initialize()
{
        register struct File *fp;
        register struct ship *sp;
        char captain[80];
        char message[60];
        int load;
        register int n;
        char *nameptr;
        int nat[NNATION];

        if (game < 0) {
                (void) puts("Choose a scenario:\n");
                (void) puts("\n\tNUMBER\tSHIPS\tIN PLAY\tTITLE");
                for (n = 0; n < NSCENE; n++) {
                        /* ( */
                        printf("\t%d):\t%d\t%s\t%s\n", n, scene[n].vessels,
                                sync_exists(n) ? "YES" : "no",
                                scene[n].name);
                }
reprint:
                printf("\nScenario number? ");
                (void) fflush(stdout);
                (void) scanf("%d", &game);
                while (getchar() != '\n')
                        ;
        }
        if (game < 0 || game >= NSCENE) {
                (void) puts("Very funny.");
                exit(1);
        }
        cc = &scene[game];
        ls = SHIP(cc->vessels);

        for (n = 0; n < NNATION; n++)
                nat[n] = 0;
        foreachship(sp) {
                if (sp->file == NULL &&
                    (sp->file = (struct File *)calloc(1, sizeof (struct File))) == NULL) {
                        (void) puts("OUT OF MEMORY");
                        exit(1);
                }
                sp->file->index = sp - SHIP(0);
                sp->file->stern = nat[sp->nationality]++;
                sp->file->dir = sp->shipdir;
                sp->file->row = sp->shiprow;
                sp->file->col = sp->shipcol;
        }
        windspeed = cc->windspeed;
        winddir = cc->winddir;

        (void) signal(SIGHUP, choke);
        (void) signal(SIGINT, choke);

        hasdriver = sync_exists(game);
        if (sync_open() < 0) {
                perror("sail: syncfile");
                exit(1);
        }

        if (hasdriver) {
                (void) puts("Synchronizing with the other players...");
                (void) fflush(stdout);
                if (Sync() < 0)
                        leave(LEAVE_SYNC);
        }
        for (;;) {
                foreachship(sp)
                        if (sp->file->captain[0] == 0 && !sp->file->struck
                            && sp->file->captured == 0)
                                break;
                if (sp >= ls) {
                        (void) puts("All ships taken in that scenario.");
                        foreachship(sp)
                                free((char *)sp->file);
                        sync_close(0);
                        people = 0;
                        goto reprint;
                }
                if (randomize) {
                        player = sp - SHIP(0);
                } else {
                        printf("%s\n\n", cc->name);
                        foreachship(sp)
                                printf("  %2d:  %-10s %-15s  (%-2d pts)   %s\n",
                                        sp->file->index,
                                        countryname[sp->nationality],
                                        sp->shipname,
                                        sp->specs->pts,
                                        saywhat(sp, 1));
                        printf("\nWhich ship (0-%d)? ", cc->vessels-1);
                        (void) fflush(stdout);
                        if (scanf("%d", &player) != 1 || player < 0
                            || player >= cc->vessels) {
                                while (getchar() != '\n')
                                        ;
                                (void) puts("Say what?");
                                player = -1;
                        } else
                                while (getchar() != '\n')
                                        ;
                }
                if (player < 0)
                        continue;
                if (Sync() < 0)
                        leave(LEAVE_SYNC);
                fp = SHIP(player)->file;
                if (fp->captain[0] || fp->struck || fp->captured != 0)
                        (void) puts("That ship is taken.");
                else
                        break;
        }

        ms = SHIP(player);
        mf = ms->file;
        mc = ms->specs;

        Write(W_BEGIN, ms, 0, 0, 0, 0, 0);
        if (Sync() < 0)
                leave(LEAVE_SYNC);

        (void) signal(SIGCHLD, child);
        if (!hasdriver)
                switch (fork()) {
                case 0:
                        longjmp(restart, MODE_DRIVER);
                        /*NOTREACHED*/
                case -1:
                        perror("fork");
                        leave(LEAVE_FORK);
                        break;
                default:
                        hasdriver++;
                }

        printf("Your ship is the %s, a %d gun %s (%s crew).\n",
                ms->shipname, mc->guns, classname[mc->class],
                qualname[mc->qual]);
        if ((nameptr = (char *) getenv("SAILNAME")) && *nameptr)
                (void) strncpy(captain, nameptr, sizeof captain);
        else {
                (void) printf("Your name, Captain? ");
                (void) fflush(stdout);
                (void) gets(captain);
                if (!*captain)
                        (void) strcpy(captain, "no name");
        }
        captain[sizeof captain - 1] = '\0';
        Write(W_CAPTAIN, ms, 1, (int)captain, 0, 0, 0);
        for (n = 0; n < 2; n++) {
                char buf[10];

                printf("\nInitial broadside %s (grape, chain, round, double): ",
                        n ? "right" : "left");
                (void) fflush(stdout);
                (void) scanf("%s", buf);
                switch (*buf) {
                case 'g':
                        load = L_GRAPE;
                        break;
                case 'c':
                        load = L_CHAIN;
                        break;
                case 'r':
                        load = L_ROUND;
                        break;
                case 'd':
                        load = L_DOUBLE;
                        break;
                default:
                        load = L_ROUND;
                }
                if (n) {
                        mf->loadR = load;
                        mf->readyR = R_LOADED|R_INITIAL;
                } else {
                        mf->loadL = load;
                        mf->readyL = R_LOADED|R_INITIAL;
                }
        }

        initscreen();
        draw_board();
        (void) sprintf(message, "Captain %s assuming command", captain);
        Write(W_SIGNAL, ms, 1, (int)message, 0, 0, 0);
        newturn();
}