361 lines
11 KiB
C
361 lines
11 KiB
C
/* $NetBSD: monop.c,v 1.27 2012/06/19 05:35:32 dholland Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1980, 1993
|
|
* The 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. 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.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
__COPYRIGHT("@(#) Copyright (c) 1980, 1993\
|
|
The Regents of the University of California. All rights reserved.");
|
|
#endif /* not lint */
|
|
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#)monop.c 8.1 (Berkeley) 5/31/93";
|
|
#else
|
|
__RCSID("$NetBSD: monop.c,v 1.27 2012/06/19 05:35:32 dholland Exp $");
|
|
#endif
|
|
#endif /* not lint */
|
|
|
|
#include <stdio.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <unistd.h>
|
|
#include "deck.h"
|
|
#include "monop.h"
|
|
|
|
int main(int, char *[]);
|
|
static void getplayers(void);
|
|
static void init_players(void);
|
|
static void init_monops(void);
|
|
static void do_quit(int);
|
|
|
|
|
|
bool fixing, /* set if fixing up debt */
|
|
trading, /* set if in process of trading */
|
|
told_em, /* set if told user he's out of debt */
|
|
spec; /* set if moving by card to RR or UTIL */
|
|
|
|
const char *name_list[MAX_PL+2]; /* list of players' names */
|
|
static const char *const comlist[] = { /* list of normal commands */
|
|
"quit", /* 0 */ "print", /* 1 */
|
|
"where", /* 2 */ "own holdings", /* 3 */
|
|
"holdings", /* 4 */ "mortgage", /* 5 */
|
|
"unmortgage", /* 6 */ "buy houses", /* 7 */
|
|
"sell houses", /* 8 */ "card", /* 9 */
|
|
"pay", /* 10 */ "trade", /* 11 */
|
|
"resign", /* 12 */ "save", /* 13 */
|
|
"restore", /* 14 */ "roll", /* 15 */
|
|
"", /* 16 */
|
|
0
|
|
};
|
|
const char *const yncoms[] = { /* list of commands for yes/no answers */
|
|
"yes", /* 0 */ "no", /* 1 */
|
|
"quit", /* 2 */ "print", /* 3 */
|
|
"where", /* 4 */ "own holdings", /* 5 */
|
|
"holdings", /* 6 */
|
|
0
|
|
};
|
|
const char *const lucky_mes[] = { /* "got lucky" messages */
|
|
"You lucky stiff", "You got lucky",
|
|
"What a lucky person!", "You must have a 4-leaf clover",
|
|
"My, my! Aren't we lucky!", "Luck smiles upon you",
|
|
"You got lucky this time", "Lucky person!",
|
|
"Your karma must certainly be together",
|
|
"How beautifully Cosmic", "Wow, you must be really with it"
|
|
/* "I want your autograph", -- Save for later */
|
|
};
|
|
|
|
int player, /* current player number */
|
|
num_play, /* current number of players */
|
|
num_doub, /* # of doubles current player rolled */
|
|
/* # of "got lucky" messages */
|
|
num_luck = sizeof lucky_mes / sizeof (char *);
|
|
|
|
/* list of command functions */
|
|
void (*const func[])(void) = { /* array of function calls for commands */
|
|
quit, /* quit game |* 0 *| */
|
|
printboard, /* print board |* 1 *| */
|
|
where, /* where players are |* 2 *| */
|
|
list, /* own holdings |* 3 *| */
|
|
list_all, /* holdings list |* 4 *| */
|
|
mortgage, /* mortgage property |* 5 *| */
|
|
unmortgage, /* unmortgage property |* 6 *| */
|
|
buy_houses, /* buy houses |* 7 *| */
|
|
sell_houses, /* sell houses |* 8 *| */
|
|
card, /* card for jail |* 9 *| */
|
|
pay, /* pay for jail |* 10 *| */
|
|
trade, /* trade |* 11 *| */
|
|
resign, /* resign |* 12 *| */
|
|
save, /* save game |* 13 *| */
|
|
restore, /* restore game |* 14 *| */
|
|
do_move, /* roll |* 15 *| */
|
|
do_move /* "" |* 16 *| */
|
|
};
|
|
|
|
DECK deck[2]; /* Chance and Community Chest */
|
|
|
|
PLAY *play, /* player structure array ("calloc"ed) */
|
|
*cur_p; /* pointer to current player's struct */
|
|
|
|
static RR_S rr[N_RR]; /* railroad descriptions */
|
|
|
|
static UTIL_S util[2]; /* utility descriptions */
|
|
|
|
#define MONINIT(num_in, h_cost, not_m, mon_n, sq1,sq2,sq3) \
|
|
{0, -1, num_in, 0, h_cost, not_m, mon_n, {sq1,sq2,sq3}, {0,0,0}}
|
|
/* name owner num_own sq */
|
|
|
|
static MON mon[N_MON] = { /* monopoly descriptions */
|
|
/* num_in h_cost not_m mon_n sqnums */
|
|
MONINIT(2, 1, "Purple", "PURPLE", 1,3, 0),
|
|
MONINIT(3, 1, "Lt. Blue", "LT. BLUE", 6,8,9),
|
|
MONINIT(3, 2, "Violet", "VIOLET", 11,13,14),
|
|
MONINIT(3, 2, "Orange", "ORANGE", 16,18,19),
|
|
MONINIT(3, 3, "Red", "RED", 21,23,24),
|
|
MONINIT(3, 3, "Yellow", "YELLOW", 26,27,29),
|
|
MONINIT(3, 4, "Green", "GREEN", 31,32,34),
|
|
MONINIT(2, 4, "Dk. Blue", "DK. BLUE", 37,39, 0),
|
|
};
|
|
#undef MONINIT
|
|
|
|
PROP prop[N_PROP] = { /* typical properties */
|
|
/* morg monop square houses mon_desc rent */
|
|
{0, 0, 1, 0, &mon[0], { 2, 10, 30, 90, 160, 250} },
|
|
{0, 0, 3, 0, &mon[0], { 4, 20, 60, 180, 320, 450} },
|
|
{0, 0, 6, 0, &mon[1], { 6, 30, 90, 270, 400, 550} },
|
|
{0, 0, 7, 0, &mon[1], { 6, 30, 90, 270, 400, 550} },
|
|
{0, 0, 9, 0, &mon[1], { 8, 40,100, 300, 450, 600} },
|
|
{0, 0, 11, 0, &mon[2], {10, 50,150, 450, 625, 750} },
|
|
{0, 0, 13, 0, &mon[2], {10, 50,150, 450, 625, 750} },
|
|
{0, 0, 14, 0, &mon[2], {12, 60,180, 500, 700, 900} },
|
|
{0, 0, 16, 0, &mon[3], {14, 70,200, 550, 750, 950} },
|
|
{0, 0, 17, 0, &mon[3], {14, 70,200, 550, 750, 950} },
|
|
{0, 0, 19, 0, &mon[3], {16, 80,220, 600, 800,1000} },
|
|
{0, 0, 21, 0, &mon[4], {18, 90,250, 700, 875,1050} },
|
|
{0, 0, 23, 0, &mon[4], {18, 90,250, 700, 875,1050} },
|
|
{0, 0, 24, 0, &mon[4], {20,100,300, 750, 925,1100} },
|
|
{0, 0, 26, 0, &mon[5], {22,110,330, 800, 975,1150} },
|
|
{0, 0, 27, 0, &mon[5], {22,110,330, 800, 975,1150} },
|
|
{0, 0, 29, 0, &mon[5], {24,120,360, 850,1025,1200} },
|
|
{0, 0, 31, 0, &mon[6], {26,130,390, 900,1100,1275} },
|
|
{0, 0, 32, 0, &mon[6], {26,130,390, 900,1100,1275} },
|
|
{0, 0, 34, 0, &mon[6], {28,150,450,1000,1200,1400} },
|
|
{0, 0, 37, 0, &mon[7], {35,175,500,1100,1300,1500} },
|
|
{0, 0, 39, 0, &mon[7], {50,200,600,1400,1700,2000} }
|
|
};
|
|
|
|
SQUARE board[N_SQRS+1] = { /* board itself (+1 for Jail) */
|
|
/* name (COLOR) owner type desc cost */
|
|
|
|
{"=== GO ===", -1, SAFE, NULL, 0 },
|
|
{"Mediterranean Ave. (P)", -1, PRPTY, &prop[0], 60 },
|
|
{"Community Chest i", -1, CC, NULL, 0 },
|
|
{"Baltic Ave. (P)", -1, PRPTY, &prop[1], 60 },
|
|
{"Income Tax", -1, INC_TAX, NULL, 0 },
|
|
{"Reading RR", -1, RR, &rr[0], 200 },
|
|
{"Oriental Ave. (L)", -1, PRPTY, &prop[2], 100 },
|
|
{"Chance i", -1, CHANCE, NULL, 0 },
|
|
{"Vermont Ave. (L)", -1, PRPTY, &prop[3], 100 },
|
|
{"Connecticut Ave. (L)", -1, PRPTY, &prop[4], 120 },
|
|
{"Just Visiting", -1, SAFE, NULL, 0 },
|
|
{"St. Charles Pl. (V)", -1, PRPTY, &prop[5], 140 },
|
|
{"Electric Co.", -1, UTIL, &util[0], 150 },
|
|
{"States Ave. (V)", -1, PRPTY, &prop[6], 140 },
|
|
{"Virginia Ave. (V)", -1, PRPTY, &prop[7], 160 },
|
|
{"Pennsylvania RR", -1, RR, &rr[1], 200 },
|
|
{"St. James Pl. (O)", -1, PRPTY, &prop[8], 180 },
|
|
{"Community Chest ii", -1, CC, NULL, 0 },
|
|
{"Tennessee Ave. (O)", -1, PRPTY, &prop[9], 180 },
|
|
{"New York Ave. (O)", -1, PRPTY, &prop[10], 200 },
|
|
{"Free Parking", -1, SAFE, NULL, 0 },
|
|
{"Kentucky Ave. (R)", -1, PRPTY, &prop[11], 220 },
|
|
{"Chance ii", -1, CHANCE, NULL, 0 },
|
|
{"Indiana Ave. (R)", -1, PRPTY, &prop[12], 220 },
|
|
{"Illinois Ave. (R)", -1, PRPTY, &prop[13], 240 },
|
|
{"B&O RR", -1, RR, &rr[2], 200 },
|
|
{"Atlantic Ave. (Y)", -1, PRPTY, &prop[14], 260 },
|
|
{"Ventnor Ave. (Y)", -1, PRPTY, &prop[15], 260 },
|
|
{"Water Works", -1, UTIL, &util[1], 150 },
|
|
{"Marvin Gardens (Y)", -1, PRPTY, &prop[16], 280 },
|
|
{"GO TO JAIL", -1, GOTO_J, NULL, 0 },
|
|
{"Pacific Ave. (G)", -1, PRPTY, &prop[17], 300 },
|
|
{"N. Carolina Ave. (G)", -1, PRPTY, &prop[18], 300 },
|
|
{"Community Chest iii", -1, CC, NULL, 0 },
|
|
{"Pennsylvania Ave. (G)", -1, PRPTY, &prop[19], 320 },
|
|
{"Short Line RR", -1, RR, &rr[3], 200 },
|
|
{"Chance iii", -1, CHANCE, NULL, 0 },
|
|
{"Park Place (D)", -1, PRPTY, &prop[20], 350 },
|
|
{"Luxury Tax", -1, LUX_TAX, NULL, 0 },
|
|
{"Boardwalk (D)", -1, PRPTY, &prop[21], 400 },
|
|
{"JAIL", -1, IN_JAIL, NULL, 0 }
|
|
};
|
|
|
|
|
|
/*
|
|
* This program implements a monopoly game
|
|
*/
|
|
int
|
|
main(int ac, char *av[])
|
|
{
|
|
/* Revoke setgid privileges */
|
|
setgid(getgid());
|
|
|
|
srandom((unsigned long)time(NULL));
|
|
num_luck = sizeof lucky_mes / sizeof (char *);
|
|
init_decks();
|
|
init_monops();
|
|
if (ac > 1) {
|
|
if (rest_f(av[1]) < 0)
|
|
restore();
|
|
}
|
|
else {
|
|
getplayers();
|
|
init_players();
|
|
}
|
|
signal(SIGINT, do_quit);
|
|
for (;;) {
|
|
printf("\n%s (%d) (cash $%d) on %s\n", cur_p->name, player + 1,
|
|
cur_p->money, board[cur_p->loc].name);
|
|
printturn();
|
|
force_morg();
|
|
execute(getinp("-- Command: ", comlist));
|
|
}
|
|
}
|
|
|
|
/*ARGSUSED*/
|
|
static void
|
|
do_quit(int n __unused)
|
|
{
|
|
quit();
|
|
}
|
|
|
|
/*
|
|
* This routine gets the names of the players
|
|
*/
|
|
static void
|
|
getplayers(void)
|
|
{
|
|
int i, j;
|
|
char buf[257];
|
|
|
|
blew_it:
|
|
for (;;) {
|
|
if ((num_play = get_int("How many players? ")) <= 1 ||
|
|
num_play > MAX_PL)
|
|
printf("Sorry. Number must range from 2 to %d\n",
|
|
MAX_PL);
|
|
else
|
|
break;
|
|
}
|
|
cur_p = play = calloc((size_t)num_play, sizeof (PLAY));
|
|
if (play == NULL)
|
|
err(1, NULL);
|
|
for (i = 0; i < num_play; i++) {
|
|
do {
|
|
printf("Player %d's name: ", i + 1);
|
|
fgets(buf, sizeof(buf), stdin);
|
|
if (feof(stdin)) {
|
|
quit();
|
|
}
|
|
buf[strcspn(buf, "\n")] = '\0';
|
|
} while (strlen(buf) == 0);
|
|
name_list[i] = play[i].name = strdup(buf);
|
|
if (name_list[i] == NULL)
|
|
err(1, NULL);
|
|
play[i].money = 1500;
|
|
}
|
|
name_list[i++] = "done";
|
|
name_list[i] = 0;
|
|
for (i = 0; i < num_play; i++)
|
|
for (j = i + 1; j <= num_play; j++)
|
|
if (strcasecmp(name_list[i], name_list[j]) == 0) {
|
|
if (j != num_play)
|
|
printf("Hey!!! Some of those are "
|
|
"IDENTICAL!! Let's try that "
|
|
"again...\n");
|
|
else
|
|
printf("\"done\" is a reserved word. "
|
|
"Please try again\n");
|
|
for (i = 0; i < num_play; i++)
|
|
free(play[i].name);
|
|
free(play);
|
|
goto blew_it;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This routine figures out who goes first
|
|
*/
|
|
static void
|
|
init_players(void)
|
|
{
|
|
int i, rl, cur_max;
|
|
bool over = 0;
|
|
int max_pl = 0;
|
|
|
|
again:
|
|
putchar('\n');
|
|
for (cur_max = i = 0; i < num_play; i++) {
|
|
printf("%s (%d) rolls %d\n", play[i].name, i+1, rl=roll(2, 6));
|
|
if (rl > cur_max) {
|
|
over = FALSE;
|
|
cur_max = rl;
|
|
max_pl = i;
|
|
}
|
|
else if (rl == cur_max)
|
|
over++;
|
|
}
|
|
if (over) {
|
|
printf("%d people rolled the same thing, so we'll try again\n",
|
|
over + 1);
|
|
goto again;
|
|
}
|
|
player = max_pl;
|
|
cur_p = &play[max_pl];
|
|
printf("%s (%d) goes first\n", cur_p->name, max_pl + 1);
|
|
}
|
|
|
|
/*
|
|
* This routine initializes the monopoly structures.
|
|
*/
|
|
static void
|
|
init_monops(void)
|
|
{
|
|
MON *mp;
|
|
int i;
|
|
|
|
for (mp = mon; mp < &mon[N_MON]; mp++) {
|
|
mp->name = mp->not_m;
|
|
for (i = 0; i < mp->num_in; i++)
|
|
mp->sq[i] = &board[mp->sqnums[i]];
|
|
}
|
|
}
|