1: /*      $NetBSD: monop.c,v 1.15 2004/01/27 20:30:30 jsm Exp $        */
    2: 
    3: /*
    4:  * Copyright (c) 1980, 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: __COPYRIGHT("@(#) Copyright (c) 1980, 1993\n\
   35:         The Regents of the University of California.  All rights reserved.\n");
   36: #endif /* not lint */
   37: 
   38: #ifndef lint
   39: #if 0
   40: static char sccsid[] = "@(#)monop.c     8.1 (Berkeley) 5/31/93";
   41: #else
   42: __RCSID("$NetBSD: monop.c,v 1.15 2004/01/27 20:30:30 jsm Exp $");
   43: #endif
   44: #endif /* not lint */
   45: 
   46: #include <stdio.h>
   47: #include <signal.h>
   48: #include <stdlib.h>
   49: #include <unistd.h>
   50: #include "monop.def"
   51: 
   52: int main(int, char *[]);
   53: static void getplayers(void);
   54: static void init_players(void);
   55: static void init_monops(void);
   56: static void do_quit(int);
   57: void *heapstart;
   58: 
   59: /*
   60:  *      This program implements a monopoly game
   61:  */
   62: int
   63: main(ac, av)
   64:         int ac;
   65:         char *av[];
   66: {
   67:         /* Revoke setgid privileges */
   68:         setregid(getgid(), getgid());
   69: 
   70:         srand(getpid());
   71:         heapstart = sbrk(0);
   72:         if (ac > 1) {
   73:                 if (!rest_f(av[1]))
   74:                         restore();
   75:         }
   76:         else {
   77:                 getplayers();
   78:                 init_players();
   79:                 init_monops();
   80:         }
   81:         num_luck = sizeof lucky_mes / sizeof (char *);
   82:         init_decks();
   83:         signal(SIGINT, do_quit);
   84:         for (;;) {
   85:                 printf("\n%s (%d) (cash $%d) on %s\n", cur_p->name, player + 1,
   86:                         cur_p->money, board[cur_p->loc].name);
   87:                 printturn();
   88:                 force_morg();
   89:                 execute(getinp("-- Command: ", comlist));
   90:         }
   91: }
   92: 
   93: /*ARGSUSED*/
   94: static void
   95: do_quit(n)
   96:         int n __attribute__((__unused__));
   97: {
   98:         quit();
   99: }
  100: 
  101: /*
  102:  *      This routine gets the names of the players
  103:  */
  104: static void
  105: getplayers()
  106: {
  107:         char *sp;
  108:         int i, j;
  109:         char buf[257];
  110: 
  111: blew_it:
  112:         for (;;) {
  113:                 if ((num_play=get_int("How many players? ")) <= 0 ||
  114:                     num_play > MAX_PL)
  115:                         printf("Sorry. Number must range from 1 to 9\n");
  116:                 else
  117:                         break;
  118:         }
  119:         cur_p = play = (PLAY *) calloc(num_play, sizeof (PLAY));
  120:         if (play == NULL)
  121:                 err(1, NULL);
  122:         for (i = 0; i < num_play; i++) {
  123: over:
  124:                 printf("Player %d's name: ", i + 1);
  125:                 for (sp = buf; (*sp=getchar()) != '\n'; sp++)
  126:                         continue;
  127:                 if (sp == buf)
  128:                         goto over;
  129:                 *sp++ = '\0';
  130:                 name_list[i] = play[i].name = (char *)calloc(1, sp - buf);
  131:                 if (name_list[i] == NULL)
  132:                         err(1, NULL);
  133:                 strcpy(play[i].name, buf);
  134:                 play[i].money = 1500;
  135:         }
  136:         name_list[i++] = "done";
  137:         name_list[i] = 0;
  138:         for (i = 0; i < num_play; i++)
  139:                 for (j = i + 1; j < num_play; j++)
  140:                         if (strcasecmp(name_list[i], name_list[j]) == 0) {
  141:                                 if (i != num_play - 1)
  142:                                         printf("Hey!!! Some of those are "
  143:                                             "IDENTICAL!!  Let's try that "
  144:                                             "again....\n");
  145:                                 else
  146:                                         printf("\"done\" is a reserved word.  "
  147:                                             "Please try again\n");
  148:                                 for (i = 0; i < num_play; i++)
  149:                                         free(play[i].name);
  150:                                 free(play);
  151:                                 goto blew_it;
  152:                         }
  153: }
  154: 
  155: /*
  156:  *      This routine figures out who goes first
  157:  */
  158: static void
  159: init_players()
  160: {
  161:         int i, rl, cur_max;
  162:         bool over = 0;
  163:         int max_pl = 0;
  164: 
  165: again:
  166:         putchar('\n');
  167:         for (cur_max = i = 0; i < num_play; i++) {
  168:                 printf("%s (%d) rolls %d\n", play[i].name, i+1, rl=roll(2, 6));
  169:                 if (rl > cur_max) {
  170:                         over = FALSE;
  171:                         cur_max = rl;
  172:                         max_pl = i;
  173:                 }
  174:                 else if (rl == cur_max)
  175:                         over++;
  176:         }
  177:         if (over) {
  178:                 printf("%d people rolled the same thing, so we'll try again\n",
  179:                     over + 1);
  180:                 goto again;
  181:         }
  182:         player = max_pl;
  183:         cur_p = &play[max_pl];
  184:         printf("%s (%d) goes first\n", cur_p->name, max_pl + 1);
  185: }
  186: 
  187: /*
  188:  *      This routine initializes the monopoly structures.
  189:  */
  190: static void
  191: init_monops() 
  192: {
  193:         MON *mp;
  194:         int i;
  195: 
  196:         for (mp = mon; mp < &mon[N_MON]; mp++) {
  197:                 mp->name = mp->not_m;
  198:                 for (i = 0; i < mp->num_in; i++)
  199:                         mp->sq[i] = &board[mp->sqnums[i]];
  200:         }
  201: }