sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Importing games/monop

Browse source 
No Minix specific changes needed.

Change-Id: I362b974a95911d26fcd8a4401129ca946179d93c
This commit is contained in:
Thomas Cort 2014-03-16 10:42:24 -04:00 committed by Lionel Sambuc
parent 5f9253d438
commit 0c3cfeffb3
21 changed files with 4167 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
distrib/sets/lists/minix/mi
View file

@ -560,6 +560,7 @@
./usr/games/factor minix-sys ./usr/games/factor minix-sys
./usr/games/fortune minix-sys ./usr/games/fortune minix-sys
./usr/games/hide minix-sys ./usr/games/hide minix-sys
./usr/games/monop minix-sys
./usr/games/morse minix-sys ./usr/games/morse minix-sys
./usr/games/number minix-sys ./usr/games/number minix-sys
./usr/games/pig minix-sys ./usr/games/pig minix-sys
@ -4758,6 +4759,7 @@
./usr/man/man6/bcd.6 minix-sys ./usr/man/man6/bcd.6 minix-sys
./usr/man/man6/factor.6 minix-sys ./usr/man/man6/factor.6 minix-sys
./usr/man/man6/fortune.6 minix-sys ./usr/man/man6/fortune.6 minix-sys
./usr/man/man6/monop.6 minix-sys
./usr/man/man6/morse.6 minix-sys ./usr/man/man6/morse.6 minix-sys
./usr/man/man6/number.6 minix-sys ./usr/man/man6/number.6 minix-sys
./usr/man/man6/pig.6 minix-sys ./usr/man/man6/pig.6 minix-sys

2
games/Makefile
View file

@ -11,7 +11,7 @@ SUBDIR= adventure \
bcd \ bcd \
\ \
factor fortune \ factor fortune \
morse number \ monop morse number \
pig ppt primes pig ppt primes
.if !defined(__MINIX) .if !defined(__MINIX)

12
games/monop/Makefile Normal file
View file

@ -0,0 +1,12 @@
# $NetBSD: Makefile,v 1.30 2008/02/24 02:43:18 dholland Exp $
# @(#)Makefile 8.1 (Berkeley) 5/31/93
.include <bsd.own.mk>
PROG= monop
SRCS= monop.c cards.c execute.c getinp.c houses.c jail.c misc.c \
morg.c print.c prop.c rent.c roll.c spec.c trade.c
MAN= monop.6
HIDEGAME=hidegame
.include <bsd.prog.mk>

397
games/monop/cards.c Normal file
View file

@ -0,0 +1,397 @@
/* $NetBSD: cards.c,v 1.25 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
#if 0
static char sccsid[] = "@(#)cards.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: cards.c,v 1.25 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include <sys/types.h>
#include <sys/endian.h>
#include "monop.h"
#include "deck.h"
/*
* These routine deal with the card decks
*/
static void set_up(DECK *);
static void printmes(const char *text);
#define GOJF 'F' /* char for get-out-of-jail-free cards */
struct cardinfo {
const char *actioncode;
const char *text;
};
static const struct cardinfo cc_cards[] = {
{ "FF",
">> GET OUT OF JAIL FREE <<\n"
"Keep this card until needed or sold\n"
},
{ "++25",
"Receive for Services $25.\n"
},
{ "++200",
"Bank Error in Your Favor.\n"
"Collect $200.\n"
},
{ "++20",
"Income Tax Refund.\n"
"Collect $20.\n"
},
{ "--100",
"Pay Hospital $100\n"
},
{ "++100",
"Life Insurance Matures.\n"
"Collect $100\n"
},
{ "++45",
"From sale of Stock You get $45.\n"
},
{ "TX",
"You are Assessed for street repairs.\n"
"\t$40 per House\n"
"\t$115 per Hotel\n"
},
{ "++100",
"X-mas Fund Matures.\n"
"Collect $100.\n"
},
{ "++11",
"You have won Second Prize in a Beauty Contest\n"
"Collect $11\n"
},
{ "MF0",
"Advance to GO\n"
"(Collect $200)\n"
},
{ "++100",
"You inherit $100\n"
},
{ "--150",
"Pay School Tax of $150.\n"
},
{ "MJ",
"\t\t>> GO TO JAIL <<\n"
"Go Directly to Jail. Do not pass GO Do not collect $200.\n"
},
{ "+A50",
"\t\t>> GRAND OPERA OPENING <<\n"
"Collect $50 from each player for opening night seats.\n"
},
{ "--50",
"Doctor's Fee: Pay $50.\n"
}
};
static const struct cardinfo ch_cards[] = {
{ "FF",
">> GET OUT OF JAIL FREE <<\n"
"Keep this card until needed or sold\n"
},
{ "MR",
"Advance to the nearest Railroad, and pay owner\n"
"Twice the rental to which he is otherwise entitled.\n"
"If Railroad is unowned you may buy it from the bank\n"
},
{ "MU",
"Advance to the nearest Utility.\n"
"If unowned, you may buy it from the bank.\n"
"If owned, throw dice and pay oner a total of ten times\n"
"the amount thrown.\n"
},
{ "MB3",
"Go Back 3 Spaces\n"
},
{ "MR",
"Advance to the nearest Railroad, and pay owner\n"
"Twice the rental to which he is otherwise entitled.\n"
"If Railroad is unowned you may buy it from the bank\n"
},
{ "MJ",
" >> GO DIRECTLY TO JAIL <<\n"
"Do not pass GO, Do not Collect $200.\n"
},
{ "MF5",
"Take a Ride on the Reading.\n"
"If you pass GO, collect $200.\n"
},
{ "MF39",
"Take a Walk on the Board Walk.\n"
" (Advance To Board Walk)\n"
},
{ "MF24",
"Advance to Illinois Ave.\n"
},
{ "MF0",
"Advance to Go\n"
},
{ "MF11",
"Advance to St. Charles Place.\n"
"If you pass GO, collect $200.\n"
},
{ "TX",
"Make general repairs on all of your Property.\n"
"For Each House pay $25.\n"
"For Each Hotel pay $100.\n"
},
{ "-A50",
"You have been elected Chairman of the Board.\n"
"Pay each player $50.\n"
},
{ "--15",
"Pay Poor Tax of $15\n"
},
{ "++50",
"Bank pays you Dividend of $50.\n"
},
{ "++150",
"Your Building and Loan Matures.\n"
"Collect $150.\n"
}
};
/*
* This routine initializes the decks from the data above.
*/
void
init_decks(void)
{
CC_D.info = cc_cards;
CC_D.num_cards = sizeof(cc_cards) / sizeof(cc_cards[0]);
CH_D.info = ch_cards;
CH_D.num_cards = sizeof(ch_cards) / sizeof(ch_cards[0]);
set_up(&CC_D);
set_up(&CH_D);
}
/*
* This routine sets up the offset pointers for the given deck.
*/
static void
set_up(DECK *dp)
{
int r1, r2;
int i;
dp->cards = calloc((size_t)dp->num_cards, sizeof(dp->cards[0]));
if (dp->cards == NULL)
errx(1, "out of memory");
for (i = 0; i < dp->num_cards; i++)
dp->cards[i] = i;
dp->top_card = 0;
dp->gojf_used = FALSE;
for (i = 0; i < dp->num_cards; i++) {
int temp;
r1 = roll(1, dp->num_cards) - 1;
r2 = roll(1, dp->num_cards) - 1;
temp = dp->cards[r2];
dp->cards[r2] = dp->cards[r1];
dp->cards[r1] = temp;
}
}
/*
* This routine draws a card from the given deck
*/
void
get_card(DECK *dp)
{
char type_maj, type_min;
int num;
int i, per_h, per_H, num_h, num_H;
OWN *op;
const struct cardinfo *thiscard;
do {
thiscard = &dp->info[dp->top_card];
type_maj = thiscard->actioncode[0];
dp->top_card = (dp->top_card + 1) % dp->num_cards;
} while (dp->gojf_used && type_maj == GOJF);
type_min = thiscard->actioncode[1];
num = atoi(thiscard->actioncode+2);
printmes(thiscard->text);
switch (type_maj) {
case '+': /* get money */
if (type_min == 'A') {
for (i = 0; i < num_play; i++)
if (i != player)
play[i].money -= num;
num = num * (num_play - 1);
}
cur_p->money += num;
break;
case '-': /* lose money */
if (type_min == 'A') {
for (i = 0; i < num_play; i++)
if (i != player)
play[i].money += num;
num = num * (num_play - 1);
}
cur_p->money -= num;
break;
case 'M': /* move somewhere */
switch (type_min) {
case 'F': /* move forward */
num -= cur_p->loc;
if (num < 0)
num += 40;
break;
case 'J': /* move to jail */
goto_jail();
return;
case 'R': /* move to railroad */
spec = TRUE;
num = (int)((cur_p->loc + 5)/10)*10 + 5 - cur_p->loc;
break;
case 'U': /* move to utility */
spec = TRUE;
if (cur_p->loc >= 12 && cur_p->loc < 28)
num = 28 - cur_p->loc;
else {
num = 12 - cur_p->loc;
if (num < 0)
num += 40;
}
break;
case 'B':
num = -num;
break;
}
move(num);
break;
case 'T': /* tax */
if (dp == &CC_D) {
per_h = 40;
per_H = 115;
}
else {
per_h = 25;
per_H = 100;
}
num_h = num_H = 0;
for (op = cur_p->own_list; op; op = op->next)
if (op->sqr->type == PRPTY) {
if (op->sqr->desc->houses == 5)
++num_H;
else
num_h += op->sqr->desc->houses;
}
num = per_h * num_h + per_H * num_H;
printf(
"You had %d Houses and %d Hotels, so that cost you $%d\n",
num_h, num_H, num);
if (num == 0)
lucky("");
else
cur_p->money -= num;
break;
case GOJF: /* get-out-of-jail-free card */
cur_p->num_gojf++;
dp->gojf_used = TRUE;
break;
}
spec = FALSE;
}
/*
* This routine prints out the message on the card
*/
static void
printmes(const char *text)
{
int i;
printline();
fflush(stdout);
for (i = 0; text[i] != '\0'; i++)
putchar(text[i]);
printline();
fflush(stdout);
}
/*
* This routine returns the players get-out-of-jail-free card
* to the bottom of a deck. XXX currently does not return to the correct
* deck.
*/
void
ret_card(PLAY *plr)
{
char type_maj;
int gojfpos, last_card;
int i;
DECK *dp;
int temp;
plr->num_gojf--;
if (CC_D.gojf_used)
dp = &CC_D;
else
dp = &CH_D;
dp->gojf_used = FALSE;
/* Put at bottom of deck (top_card - 1) and remove it from wherever else
* it used to be.
*/
last_card = dp->top_card - 1;
if (last_card < 0)
last_card += dp->num_cards;
gojfpos = dp->top_card;
do {
gojfpos = (gojfpos + 1) % dp->num_cards;
type_maj = dp->info[gojfpos].actioncode[0];
} while (type_maj != GOJF);
temp = dp->cards[gojfpos];
/* Only one of the next two loops does anything */
for (i = gojfpos - 1; i > last_card; i--)
dp->cards[i + 1] = dp->cards[i];
for (i = gojfpos; i < last_card; i++)
dp->cards[i] = dp->cards[i + 1];
if (gojfpos > last_card) {
dp->cards[dp->top_card] = temp;
dp->top_card++;
dp->top_card %= dp->num_cards;
} else
dp->cards[last_card] = temp;
}

58
games/monop/deck.h Normal file
View file

@ -0,0 +1,58 @@
/* $NetBSD: deck.h,v 1.9 2008/02/24 02:43:18 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.
*
* @(#)deck.h 8.1 (Berkeley) 5/31/93
*/
#include <sys/types.h>
#define bool char
struct cardinfo; /* private to cards.c */
#define CC_D deck[0]
#define CH_D deck[1]
struct dk_st { /* deck description structure */
int num_cards; /* number of cards in deck */
int top_card; /* number of last card picked */
bool gojf_used; /* set if gojf card out of deck */
int *cards; /* which cards (indexes info[]) */
const struct cardinfo *info; /* the static card data */
};
typedef struct dk_st DECK;
extern DECK deck[2];
/* cards.c */
void init_decks(void);
void get_card(DECK *);

761
games/monop/execute.c Normal file
View file

@ -0,0 +1,761 @@
/* $NetBSD: execute.c,v 1.22 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
#if 0
static char sccsid[] = "@(#)execute.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: execute.c,v 1.22 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <time.h>
#include <errno.h>
#include "deck.h"
#include "monop.h"
#define MIN_FORMAT_VERSION 1
#define CUR_FORMAT_VERSION 1
#define MAX_FORMAT_VERSION 1
typedef struct stat STAT;
typedef struct tm TIME;
static char buf[257];
static bool new_play; /* set if move on to new player */
static void show_move(void);
static void restore_reset(void);
static int restore_parseline(char *txt);
static int restore_toplevel_attr(const char *attribute, char *txt);
static int restore_player_attr(const char *attribute, char *txt);
static int restore_deck_attr(const char *attribute, char *txt);
static int restore_square_attr(const char *attribute, char *txt);
static int getnum(const char *what, char *txt, int min, int max, int *ret);
static int getnum_withbrace(const char *what, char *txt, int min, int max,
int *ret);
/*
* This routine executes the given command by index number
*/
void
execute(int com_num)
{
new_play = FALSE; /* new_play is true if fixing */
(*func[com_num])();
notify();
force_morg();
if (new_play)
next_play();
else if (num_doub)
printf("%s rolled doubles. Goes again\n", cur_p->name);
}
/*
* This routine moves a piece around.
*/
void
do_move(void)
{
int r1, r2;
bool was_jail;
new_play = was_jail = FALSE;
printf("roll is %d, %d\n", r1=roll(1, 6), r2=roll(1, 6));
if (cur_p->loc == JAIL) {
was_jail++;
if (!move_jail(r1, r2)) {
new_play++;
goto ret;
}
}
else {
if (r1 == r2 && ++num_doub == 3) {
printf("That's 3 doubles. You go to jail\n");
goto_jail();
new_play++;
goto ret;
}
move(r1+r2);
}
if (r1 != r2 || was_jail)
new_play++;
ret:
return;
}
/*
* This routine moves a normal move
*/
void
move(int rl)
{
int old_loc;
old_loc = cur_p->loc;
cur_p->loc = (cur_p->loc + rl) % N_SQRS;
if (cur_p->loc < old_loc && rl > 0) {
cur_p->money += 200;
printf("You pass %s and get $200\n", board[0].name);
}
show_move();
}
/*
* This routine shows the results of a move
*/
static void
show_move(void)
{
SQUARE *sqp;
sqp = &board[cur_p->loc];
printf("That puts you on %s\n", sqp->name);
switch (sqp->type) {
case SAFE:
printf("That is a safe place\n");
break;
case CC:
cc();
break;
case CHANCE:
chance();
break;
case INC_TAX:
inc_tax();
break;
case GOTO_J:
goto_jail();
break;
case LUX_TAX:
lux_tax();
break;
case PRPTY:
case RR:
case UTIL:
if (sqp->owner < 0) {
printf("That would cost $%d\n", sqp->cost);
if (getyn("Do you want to buy? ") == 0) {
buy(player, sqp);
cur_p->money -= sqp->cost;
}
else if (num_play > 2)
bid();
}
else if (sqp->owner == player)
printf("You own it.\n");
else
rent(sqp);
}
}
/*
* Reset the game state.
*/
static void
reset_game(void)
{
int i;
for (i = 0; i < N_SQRS; i++) {
board[i].owner = -1;
if (board[i].type == PRPTY) {
board[i].desc->morg = 0;
board[i].desc->houses = 0;
} else if (board[i].type == RR || board[i].type == UTIL) {
board[i].desc->morg = 0;
}
}
for (i = 0; i < 2; i++) {
deck[i].top_card = 0;
deck[i].gojf_used = FALSE;
}
if (play) {
for (i = 0; i < num_play; i++) {
free(play[i].name);
play[i].name = NULL;
}
free(play);
play = NULL;
}
for (i = 0; i < MAX_PL+2; i++) {
name_list[i] = NULL;
}
cur_p = NULL;
num_play = 0;
player = 0;
num_doub = 0;
fixing = FALSE;
trading = FALSE;
told_em = FALSE;
spec = FALSE;
}
/*
* This routine saves the current game for use at a later date
*/
void
save(void)
{
char *sp;
FILE *outf;
time_t t;
struct stat sb;
int i, j;
printf("Which file do you wish to save it in? ");
fgets(buf, sizeof(buf), stdin);
if (feof(stdin))
return;
sp = strchr(buf, '\n');
if (sp)
*sp = '\0';
/*
* check for existing files, and confirm overwrite if needed
*/
if (stat(buf, &sb) == 0
&& getyn("File exists. Do you wish to overwrite? ") > 0)
return;
outf = fopen(buf, "w");
if (outf == NULL) {
warn("%s", buf);
return;
}
printf("\"%s\" ", buf);
time(&t); /* get current time */
/* Header */
fprintf(outf, "NetBSD monop format v%d\n", CUR_FORMAT_VERSION);
fprintf(outf, "time %s", ctime(&t)); /* ctime includes a \n */
fprintf(outf, "numplayers %d\n", num_play);
fprintf(outf, "currentplayer %d\n", player);
fprintf(outf, "doubles %d\n", num_doub);
/* Players */
for (i = 0; i < num_play; i++) {
fprintf(outf, "player %d {\n", i);
fprintf(outf, " name %s\n", name_list[i]);
fprintf(outf, " money %d\n", play[i].money);
fprintf(outf, " loc %d\n", play[i].loc);
fprintf(outf, " num_gojf %d\n", play[i].num_gojf);
fprintf(outf, " in_jail %d\n", play[i].in_jail);
fprintf(outf, "}\n");
}
/* Decks */
for (i = 0; i < 2; i++) {
fprintf(outf, "deck %d {\n", i);
fprintf(outf, " numcards %d\n", deck[i].num_cards);
fprintf(outf, " topcard %d\n", deck[i].top_card);
fprintf(outf, " gojf_used %d\n", deck[i].gojf_used);
fprintf(outf, " cards");
for (j = 0; j < deck[i].num_cards; j++)
fprintf(outf, " %d", deck[i].cards[j]);
fprintf(outf, "\n");
fprintf(outf, "}\n");
}
/* Board */
for (i = 0; i < N_SQRS; i++) {
fprintf(outf, "square %d {\n", i);
fprintf(outf, "owner %d\n", board[i].owner);
if (board[i].owner < 0) {
/* nothing */
} else if (board[i].type == PRPTY) {
fprintf(outf, "morg %d\n", board[i].desc->morg);
fprintf(outf, "houses %d\n", board[i].desc->houses);
} else if (board[i].type == RR || board[i].type == UTIL) {
fprintf(outf, "morg %d\n", board[i].desc->morg);
}
fprintf(outf, "}\n");
}
if (ferror(outf) || fflush(outf))
warnx("write error");
fclose(outf);
strcpy(buf, ctime(&t));
for (sp = buf; *sp != '\n'; sp++)
continue;
*sp = '\0';
printf("[%s]\n", buf);
}
/*
* This routine restores an old game from a file
*/
void
restore(void)
{
char *sp;
for (;;) {
printf("Which file do you wish to restore from? ");
fgets(buf, sizeof(buf), stdin);
if (feof(stdin))
return;
sp = strchr(buf, '\n');
if (sp)
*sp = '\0';
if (rest_f(buf) == 0)
break;
}
}
/*
* This does the actual restoring. It returns zero on success,
* and -1 on failure.
*/
int
rest_f(const char *file)
{
char *sp;
FILE *inf;
char xbuf[80];
STAT sbuf;
char readbuf[512];
int ret = 0;
inf = fopen(file, "r");
if (inf == NULL) {
warn("%s", file);
return -1;
}
printf("\"%s\" ", file);
if (fstat(fileno(inf), &sbuf) < 0) {
err(1, "%s: fstat", file);
}
/* Clear the game state to prevent brokenness on misordered files. */
reset_game();
/* Reset the parser */
restore_reset();
/* Note: can't use buf[], file might point at it. (Lame...) */
while (fgets(readbuf, sizeof(readbuf), inf)) {
/*
* The input buffer is long enough to handle anything
* that's supposed to be in the output buffer, so if
* we get a partial line, complain.
*/
sp = strchr(readbuf, '\n');
if (sp == NULL) {
printf("file is corrupt: long lines.\n");
ret = -1;
break;
}
*sp = '\0';
if (restore_parseline(readbuf)) {
ret = -1;
break;
}
}
if (ferror(inf))
warnx("%s: read error", file);
fclose(inf);
if (ret < 0)
return -1;
name_list[num_play] = "done";
if (play == NULL || cur_p == NULL || num_play < 2) {
printf("save file is incomplete.\n");
return -1;
}
/*
* We could at this point crosscheck the following:
* - there are only two GOJF cards floating around
* - total number of houses and hotels does not exceed maximums
* - no props are both built and mortgaged
* but for now we don't.
*/
strcpy(xbuf, ctime(&sbuf.st_mtime));
for (sp = xbuf; *sp != '\n'; sp++)
continue;
*sp = '\0';
printf("[%s]\n", xbuf);
return 0;
}
/*
* State of the restore parser
*/
static int restore_version;
static enum {
RI_NONE,
RI_PLAYER,
RI_DECK,
RI_SQUARE
} restore_item;
static int restore_itemnum;
/*
* Reset the restore parser
*/
static void
restore_reset(void)
{
restore_version = -1;
restore_item = RI_NONE;
restore_itemnum = -1;
}
/*
* Handle one line of the save file
*/
static int
restore_parseline(char *txt)
{
char *attribute;
char *s;
if (restore_version < 0) {
/* Haven't seen the header yet. Demand it right away. */
if (!strncmp(txt, "NetBSD monop format v", 21)) {
return getnum("format version", txt+21,
MIN_FORMAT_VERSION,
MAX_FORMAT_VERSION,
&restore_version);
}
printf("file is not a monop save file.\n");
return -1;
}
/* Check for lines that are right braces. */
if (!strcmp(txt, "}")) {
if (restore_item == RI_NONE) {
printf("mismatched close brace.\n");
return -1;
}
restore_item = RI_NONE;
restore_itemnum = -1;
return 0;
}
/* Any other line must begin with a word, which is the attribute. */
s = txt;
while (*s==' ')
s++;
attribute = s;
s = strchr(attribute, ' ');
if (s == NULL) {
printf("file is corrupt: attribute %s lacks value.\n",
attribute);
return -1;
}
*(s++) = '\0';
while (*s==' ')
s++;
/* keep the remaining text for further handling */
txt = s;
switch (restore_item) {
case RI_NONE:
/* toplevel attributes */
return restore_toplevel_attr(attribute, txt);
case RI_PLAYER:
/* player attributes */
return restore_player_attr(attribute, txt);
case RI_DECK:
/* deck attributes */
return restore_deck_attr(attribute, txt);
case RI_SQUARE:
/* board square attributes */
return restore_square_attr(attribute, txt);
}
/* NOTREACHED */
printf("internal logic error\n");
return -1;
}
static int
restore_toplevel_attr(const char *attribute, char *txt)
{
if (!strcmp(attribute, "time")) {
/* nothing */
} else if (!strcmp(attribute, "numplayers")) {
if (getnum("numplayers", txt, 2, MAX_PL, &num_play) < 0) {
return -1;
}
if (play != NULL) {
printf("numplayers: multiple settings\n");
return -1;
}
play = calloc((size_t)num_play, sizeof(play[0]));
if (play == NULL) {
err(1, "calloc");
}
} else if (!strcmp(attribute, "currentplayer")) {
if (getnum("currentplayer", txt, 0, num_play-1, &player) < 0) {
return -1;
}
if (play == NULL) {
printf("currentplayer: before numplayers\n");
return -1;
}
cur_p = &play[player];
} else if (!strcmp(attribute, "doubles")) {
if (getnum("doubles", txt, 0, 2, &num_doub) < 0) {
return -1;
}
} else if (!strcmp(attribute, "player")) {
if (getnum_withbrace("player", txt, 0, num_play-1,
&restore_itemnum) < 0) {
return -1;
}
restore_item = RI_PLAYER;
} else if (!strcmp(attribute, "deck")) {
if (getnum_withbrace("deck", txt, 0, 1,
&restore_itemnum) < 0) {
return -1;
}
restore_item = RI_DECK;
} else if (!strcmp(attribute, "square")) {
if (getnum_withbrace("square", txt, 0, N_SQRS-1,
&restore_itemnum) < 0) {
return -1;
}
restore_item = RI_SQUARE;
} else {
printf("unknown attribute %s\n", attribute);
return -1;
}
return 0;
}
static int
restore_player_attr(const char *attribute, char *txt)
{
PLAY *pp;
int tmp;
if (play == NULL) {
printf("player came before numplayers.\n");
return -1;
}
pp = &play[restore_itemnum];
if (!strcmp(attribute, "name")) {
if (pp->name != NULL) {
printf("player has multiple names.\n");
return -1;
}
/* XXX should really systematize the max name length */
if (strlen(txt) > 256) {
txt[256] = 0;
}
pp->name = strdup(txt);
if (pp->name == NULL)
err(1, "strdup");
name_list[restore_itemnum] = pp->name;
} else if (!strcmp(attribute, "money")) {
if (getnum(attribute, txt, 0, INT_MAX, &pp->money) < 0) {
return -1;
}
} else if (!strcmp(attribute, "loc")) {
/* note: not N_SQRS-1 */
if (getnum(attribute, txt, 0, N_SQRS, &tmp) < 0) {
return -1;
}
pp->loc = tmp;
} else if (!strcmp(attribute, "num_gojf")) {
if (getnum(attribute, txt, 0, 2, &tmp) < 0) {
return -1;
}
pp->num_gojf = tmp;
} else if (!strcmp(attribute, "in_jail")) {
if (getnum(attribute, txt, 0, 3, &tmp) < 0) {
return -1;
}
pp->in_jail = tmp;
if (pp->in_jail > 0 && pp->loc != JAIL) {
printf("player escaped from jail?\n");
return -1;
}
} else {
printf("unknown attribute %s\n", attribute);
return -1;
}
return 0;
}
static int
restore_deck_attr(const char *attribute, char *txt)
{
int tmp, j;
char *s;
DECK *dp;
dp = &deck[restore_itemnum];
if (!strcmp(attribute, "numcards")) {
if (getnum(attribute, txt, dp->num_cards, dp->num_cards,
&tmp) < 0) {
return -1;
}
} else if (!strcmp(attribute, "topcard")) {
if (getnum(attribute, txt, 0, dp->num_cards,
&dp->top_card) < 0) {
return -1;
}
} else if (!strcmp(attribute, "gojf_used")) {
if (getnum(attribute, txt, 0, 1, &tmp) < 0) {
return -1;
}
dp->gojf_used = tmp;
} else if (!strcmp(attribute, "cards")) {
errno = 0;
s = txt;
for (j = 0; j<dp->num_cards; j++) {
tmp = strtol(s, &s, 10);
if (tmp < 0 || tmp >= dp->num_cards) {
printf("cards: out of range value\n");
return -1;
}
dp->cards[j] = tmp;
}
if (errno) {
printf("cards: invalid values\n");
return -1;
}
} else {
printf("unknown attribute %s\n", attribute);
return -1;
}
return 0;
}
static int
restore_square_attr(const char *attribute, char *txt)
{
SQUARE *sp = &board[restore_itemnum];
int tmp;
if (!strcmp(attribute, "owner")) {
if (getnum(attribute, txt, -1, num_play-1, &tmp) < 0) {
return -1;
}
sp->owner = tmp;
if (tmp >= 0)
add_list(tmp, &play[tmp].own_list, restore_itemnum);
} else if (!strcmp(attribute, "morg")) {
if (sp->type != PRPTY && sp->type != RR && sp->type != UTIL) {
printf("unownable property is mortgaged.\n");
return -1;
}
if (getnum(attribute, txt, 0, 1, &tmp) < 0) {
return -1;
}
sp->desc->morg = tmp;
} else if (!strcmp(attribute, "houses")) {
if (sp->type != PRPTY) {
printf("unbuildable property has houses.\n");
return -1;
}
if (getnum(attribute, txt, 0, 5, &tmp) < 0) {
return -1;
}
sp->desc->houses = tmp;
} else {
printf("unknown attribute %s\n", attribute);
return -1;
}
return 0;
}
static int
getnum(const char *what, char *txt, int min, int max, int *ret)
{
char *s;
long l;
errno = 0;
l = strtol(txt, &s, 10);
if (errno || strlen(s)>0) {
printf("%s: not a number.\n", what);
return -1;
}
if (l < min || l > max) {
printf("%s: out of range.\n", what);
}
*ret = l;
return 0;
}
static int
getnum_withbrace(const char *what, char *txt, int min, int max, int *ret)
{
char *s;
s = strchr(txt, ' ');
if (s == NULL) {
printf("%s: expected open brace\n", what);
return -1;
}
*(s++) = '\0';
while (*s == ' ')
s++;
if (*s != '{') {
printf("%s: expected open brace\n", what);
return -1;
}
if (s[1] != 0) {
printf("%s: garbage after open brace\n", what);
return -1;
}
return getnum(what, txt, min, max, ret);
}

119
games/monop/getinp.c Normal file
View file

@ -0,0 +1,119 @@
/* $NetBSD: getinp.c,v 1.19 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
#if 0
static char sccsid[] = "@(#)getinp.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: getinp.c,v 1.19 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "monop.h"
#define LINE 70
static char buf[257];
static int comp(const char *);
int
getinp(const char *prompt, const char *const lst [])
{
int i, n_match, match = 0;
char *sp;
for (;;) {
printf("%s", prompt);
fgets(buf, sizeof(buf), stdin);
if (feof(stdin)) {
return 0;
}
if (buf[0] == '?' && buf[1] == '\n') {
printf("Valid inputs are: ");
for (i = 0, match = 18; lst[i]; i++) {
if ((match+=(n_match=strlen(lst[i]))) > LINE) {
printf("\n\t");
match = n_match + 8;
}
if (*lst[i] == '\0') {
match += 8;
printf("<RETURN>");
}
else
printf("%s", lst[i]);
if (lst[i+1])
printf(", ");
else
putchar('\n');
match += 2;
}
continue;
}
if ((sp = strchr(buf, '\n')) != NULL)
*sp = '\0';
for (sp = buf; *sp; sp++)
*sp = tolower((unsigned char)*sp);
for (i = n_match = 0; lst[i]; i++)
if (comp(lst[i])) {
n_match++;
match = i;
}
if (n_match == 1)
return match;
else if (buf[0] != '\0')
printf("Illegal response: \"%s\". "
"Use '?' to get list of valid answers\n", buf);
}
}
static int
comp(const char *s1)
{
const char *sp, *tsp;
char c;
if (buf[0] != '\0')
for (sp = buf, tsp = s1; *sp; ) {
c = tolower((unsigned char)*tsp);
tsp++;
if (c != *sp++)
return 0;
}
else if (*s1 != '\0')
return 0;
return 1;
}

387
games/monop/houses.c Normal file
View file

@ -0,0 +1,387 @@
/* $NetBSD: houses.c,v 1.15 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
#if 0
static char sccsid[] = "@(#)houses.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: houses.c,v 1.15 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
static const char *names[N_MON+2];
static char cur_prop[80];
static MON *monops[N_MON];
static void buy_h(MON *);
static void sell_h(MON *);
static void list_cur(MON *);
static int get_avail_houses(void);
static int get_avail_hotels(void);
static bool ready_for_hotels(MON *);
/*
* These routines deal with buying and selling houses
*/
void
buy_houses(void)
{
int num_mon;
MON *mp;
OWN *op;
bool good, got_morg;
int i,p;
over:
num_mon = 0;
good = TRUE;
got_morg = FALSE;
for (op = cur_p->own_list; op && op->sqr->type != PRPTY; op = op->next)
continue;
while (op)
if (op->sqr->desc->monop) {
mp = op->sqr->desc->mon_desc;
names[num_mon] = (monops[num_mon]=mp)->name;
num_mon++;
got_morg = good = FALSE;
for (i = 0; i < mp->num_in; i++) {
if (op->sqr->desc->morg)
got_morg = TRUE;
if (op->sqr->desc->houses != 5)
good = TRUE;
op = op->next;
}
if (!good || got_morg)
--num_mon;
}
else
op = op->next;
if (num_mon == 0) {
if (got_morg)
printf("You can't build on mortgaged monopolies.\n");
else if (!good)
printf("You can't build any more.\n");
else
printf("But you don't have any monopolies!!\n");
return;
}
if (num_mon == 1)
buy_h(monops[0]);
else {
names[num_mon++] = "done";
names[num_mon--] = 0;
if ((p = getinp(
"Which property do you wish to buy houses for? ",
names)) == num_mon)
return;
buy_h(monops[p]);
goto over;
}
}
static void
buy_h(MON *mnp)
{
int i;
MON *mp;
int price;
short input[3], result[3];
int wanted_houses, wanted_hotels;
int total_purchase;
PROP *pp;
int avail_houses, avail_hotels;
bool buying_hotels;
mp = mnp;
price = mp->h_cost * 50;
avail_houses = get_avail_houses();
avail_hotels = get_avail_hotels();
buying_hotels = ready_for_hotels(mnp);
if (avail_houses == 0 && !buying_hotels) {
printf("Building shortage: no houses available.");
return;
}
if (avail_hotels == 0 && buying_hotels) {
printf("Building shortage: no hotels available.");
return;
}
blew_it:
list_cur(mp);
printf("Houses will cost $%d\n", price);
printf("How many houses do you wish to buy for\n");
for (i = 0; i < mp->num_in; i++) {
pp = mp->sq[i]->desc;
over:
if (pp->houses == 5) {
printf("%s (H):\n", mp->sq[i]->name);
input[i] = 0;
result[i] = 5;
continue;
}
(void)snprintf(cur_prop, sizeof(cur_prop), "%s (%d): ",
mp->sq[i]->name, pp->houses);
input[i] = get_int(cur_prop);
result[i] = input[i] + pp->houses;
if (result[i] > 5 || result[i] < 0) {
printf("That's too many. The most you can buy is %d\n",
5 - pp->houses);
goto over;
}
}
if (mp->num_in == 3 &&
(abs(result[0] - result[1]) > 1 ||
abs(result[0] - result[2]) > 1 ||
abs(result[1] - result[2]) > 1)) {
err: printf("That makes the spread too wide. Try again\n");
goto blew_it;
}
else if (mp->num_in == 2 && abs(result[0] - result[1]) > 1)
goto err;
wanted_houses = 0;
wanted_hotels = 0;
total_purchase = 0;
for (i = 0; i < mp->num_in; i++) {
wanted_houses += input[i];
total_purchase += input[i];
if (result[i] == 5 && input[i] > 0) {
wanted_hotels++;
wanted_houses--;
}
}
if (wanted_houses > avail_houses) {
printf("You have asked for %d %s but only %d are available. "
"Try again\n",
wanted_houses, wanted_houses == 1 ? "house" : "houses",
avail_houses);
goto blew_it;
} else if (wanted_hotels > avail_hotels) {
printf("You have asked for %d %s but only %d are available. "
"Try again\n",
wanted_hotels, wanted_hotels == 1 ? "hotel" : "hotels",
avail_hotels);
goto blew_it;
}
if (total_purchase) {
printf("You asked for %d %s and %d %s for $%d\n",
wanted_houses, wanted_houses == 1 ? "house" : "houses",
wanted_hotels, wanted_hotels == 1 ? "hotel" : "hotels",
total_purchase * price);
if (getyn("Is that ok? ") == 0) {
cur_p->money -= total_purchase * price;
for (i = 0; i < mp->num_in; i++)
mp->sq[i]->desc->houses = result[i];
}
}
}
/*
* This routine sells houses.
*/
void
sell_houses(void)
{
int num_mon;
MON *mp;
OWN *op;
bool good;
int p;
over:
num_mon = 0;
good = TRUE;
for (op = cur_p->own_list; op;)
if (op->sqr->type == PRPTY && op->sqr->desc->monop) {
mp = op->sqr->desc->mon_desc;
names[num_mon] = (monops[num_mon]=mp)->name;
num_mon++;
good = 0;
do
if (!good && op->sqr->desc->houses != 0)
good = TRUE;
while (op->next && op->sqr->desc->mon_desc == mp
&& (op = op->next));
if (!good)
--num_mon;
} else
op = op->next;
if (num_mon == 0) {
printf("You don't have any houses to sell!!\n");
return;
}
if (num_mon == 1)
sell_h(monops[0]);
else {
names[num_mon++] = "done";
names[num_mon--] = 0;
if ((p = getinp(
"Which property do you wish to sell houses from? ",
names)) == num_mon)
return;
sell_h(monops[p]);
notify();
goto over;
}
}
static void
sell_h(MON *mnp)
{
int i;
MON *mp;
int price;
short input[3],temp[3];
int tot;
PROP *pp;
mp = mnp;
price = mp->h_cost * 25;
blew_it:
printf("Houses will get you $%d apiece\n", price);
list_cur(mp);
printf("How many houses do you wish to sell from\n");
for (i = 0; i < mp->num_in; i++) {
pp = mp->sq[i]->desc;
over:
if (pp->houses == 0) {
printf("%s (0):\n", mp->sq[i]->name);
input[i] = temp[i] = 0;
continue;
}
if (pp->houses < 5)
(void)snprintf(cur_prop, sizeof(cur_prop), "%s (%d): ",
mp->sq[i]->name,pp->houses);
else
(void)snprintf(cur_prop, sizeof(cur_prop), "%s (H): ",
mp->sq[i]->name);
input[i] = get_int(cur_prop);
temp[i] = pp->houses - input[i];
if (temp[i] < 0) {
printf(
"That's too many. The most you can sell is %d\n",
pp->houses);
goto over;
}
}
if (mp->num_in == 3 && (abs(temp[0] - temp[1]) > 1 ||
abs(temp[0] - temp[2]) > 1 || abs(temp[1] - temp[2]) > 1)) {
err: printf("That makes the spread too wide. Try again\n");
goto blew_it;
}
else if (mp->num_in == 2 && abs(temp[0] - temp[1]) > 1)
goto err;
for (tot = i = 0; i < mp->num_in; i++)
tot += input[i];
if (tot) {
printf("You asked to sell %d house%s for $%d\n", tot,
tot == 1 ? "" : "s", tot * price);
if (getyn("Is that ok? ") == 0) {
cur_p->money += tot * price;
for (tot = i = 0; i < mp->num_in; i++)
mp->sq[i]->desc->houses = temp[i];
}
}
}
static void
list_cur(MON *mp)
{
int i;
SQUARE *sqp;
for (i = 0; i < mp->num_in; i++) {
sqp = mp->sq[i];
if (sqp->desc->houses == 5)
printf("%s (H) ", sqp->name);
else
printf("%s (%d) ", sqp->name, sqp->desc->houses);
}
putchar('\n');
}
static int
get_avail_houses(void)
{
int i, c;
SQUARE *sqp;
c = 0;
for (i = 0; i < N_SQRS; i++) {
sqp = &board[i];
if (sqp->type == PRPTY && sqp->owner >= 0 && sqp->desc->monop) {
if (sqp->desc->houses < 5 && sqp->desc->houses > 0)
c += sqp->desc->houses;
}
}
return(N_HOUSE - c);
}
static int
get_avail_hotels(void)
{
int i, c;
SQUARE *sqp;
c = 0;
for (i = 0; i < N_SQRS; i++) {
sqp = &board[i];
if (sqp->type == PRPTY && sqp->owner >= 0 && sqp->desc->monop) {
if (sqp->desc->houses == 5)
c++;
}
}
return(N_HOTEL - c);
}
/*
* If we can put a hotel on, we can't put any houses on, and if we can
* put houses on, then we can't put a hotel on yet.
*/
static bool
ready_for_hotels(MON *mp)
{
int i;
for (i = 0; i < mp->num_in; i++) {
if (mp->sq[i]->desc->houses < 4)
return(FALSE);
}
return(TRUE);
}

123
games/monop/jail.c Normal file
View file

@ -0,0 +1,123 @@
/* $NetBSD: jail.c,v 1.10 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
#if 0
static char sccsid[] = "@(#)jail.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: jail.c,v 1.10 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
/*
* This routine uses a get-out-of-jail-free card to get the
* player out of jail.
*/
void
card(void)
{
if (cur_p->loc != JAIL) {
printf("But you're not IN Jail\n");
return;
}
if (cur_p->num_gojf == 0) {
printf("But you don't HAVE a get out of jail free card\n");
return;
}
ret_card(cur_p);
cur_p->loc = 10; /* just visiting */
cur_p->in_jail = 0;
}
/*
* This routine deals with paying your way out of jail.
*/
void
pay(void)
{
if (cur_p->loc != JAIL) {
printf("But you're not IN Jail\n");
return;
}
cur_p->loc = 10;
cur_p->money -= 50;
cur_p->in_jail = 0;
printf("That cost you $50\n");
}
/*
* This routine deals with a move in jail
*/
int
move_jail(int r1, int r2)
{
if (r1 != r2) {
printf("Sorry, that doesn't get you out\n");
if (++(cur_p->in_jail) == 3) {
printf("It's your third turn and you didn't roll "
"doubles. You have to pay $50\n");
cur_p->money -= 50;
moveit:
cur_p->loc = 10;
cur_p->in_jail = 0;
move(r1+r2);
r1 = r2 - 1; /* kludge: stop new roll w/doub */
return TRUE;
}
return FALSE;
} else {
printf("Double roll gets you out.\n");
goto moveit;
}
}
void
printturn(void)
{
if (cur_p->loc != JAIL)
return;
printf("(This is your ");
switch (cur_p->in_jail) {
case 0:
printf("1st");
break;
case 1:
printf("2nd");
break;
case 2:
printf("3rd (and final)");
break;
}
printf(" turn in JAIL)\n");
}

299
games/monop/misc.c Normal file
View file

@ -0,0 +1,299 @@
/* $NetBSD: misc.c,v 1.23 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
#if 0
static char sccsid[] = "@(#)misc.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: misc.c,v 1.23 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include <ctype.h>
#include <limits.h>
#include <signal.h>
#include <errno.h>
#include "monop.h"
static void is_monop(MON *, int);
/*
* This routine executes a truncated set of commands until a
* "yes or "no" answer is gotten.
*/
int
getyn(const char *prompt)
{
int com;
for (;;)
if ((com=getinp(prompt, yncoms)) < 2)
return com;
else
(*func[com-2])();
}
/*
* This routine tells the player if he's out of money.
*/
void
notify(void)
{
if (cur_p->money < 0)
printf("That leaves you $%d in debt\n", -cur_p->money);
else if (cur_p->money == 0)
printf("that leaves you broke\n");
else if (fixing && !told_em && cur_p->money > 0) {
printf("-- You are now Solvent ---\n");
told_em = TRUE;
}
}
/*
* This routine switches to the next player
*/
void
next_play(void)
{
player = (player + 1) % num_play;
cur_p = &play[player];
num_doub = 0;
}
/*
* This routine gets an integer from the keyboard after the
* given prompt.
*/
int
get_int(const char *prompt)
{
long num;
char *sp;
char buf[257];
for (;;) {
printf("%s", prompt);
fgets(buf, sizeof(buf), stdin);
/* if stdin is closed we cant really play anymore */
if (feof(stdin))
quit();
sp = strchr(buf, '\n');
if (sp)
*sp = '\0';
errno = 0;
num = strtol(buf, &sp, 10);
if (errno || strlen(sp) > 0 || num < 0 || num >= INT_MAX) {
printf("I can't understand that\n");
continue;
}
return num;
}
}
/*
* This routine sets the monopoly flag from the list given.
*/
void
set_ownlist(int pl)
{
int num; /* general counter */
MON *orig; /* remember starting monop ptr */
OWN *op; /* current owned prop */
OWN *orig_op; /* original prop before loop */
op = play[pl].own_list;
#ifdef DEBUG
printf("op [%p] = play[pl [%d] ].own_list;\n", op, pl);
#endif
while (op) {
#ifdef DEBUG
printf("op->sqr->type = %d\n", op->sqr->type);
#endif
switch (op->sqr->type) {
case UTIL:
#ifdef DEBUG
printf(" case UTIL:\n");
#endif
for (num = 0; op && op->sqr->type == UTIL;
op = op->next)
num++;
play[pl].num_util = num;
#ifdef DEBUG
printf("play[pl].num_util = num [%d];\n", num);
#endif
break;
case RR:
#ifdef DEBUG
printf(" case RR:\n");
#endif
for (num = 0; op && op->sqr->type == RR;
op = op->next) {
#ifdef DEBUG
printf("iter: %d\n", num);
printf("op = %p, op->sqr = %p, "
"op->sqr->type = %d\n", op, op->sqr,
op->sqr->type);
#endif
num++;
}
play[pl].num_rr = num;
#ifdef DEBUG
printf("play[pl].num_rr = num [%d];\n", num);
#endif
break;
case PRPTY:
#ifdef DEBUG
printf(" case PRPTY:\n");
#endif
orig = op->sqr->desc->mon_desc;
orig_op = op;
num = 0;
while (op && op->sqr->desc->mon_desc == orig) {
#ifdef DEBUG
printf("iter: %d\n", num);
#endif
num++;
#ifdef DEBUG
printf("op = op->next ");
#endif
op = op->next;
#ifdef DEBUG
printf("[%p];\n", op);
#endif
}
#ifdef DEBUG
printf("num = %d\n", num);
#endif
if (orig == NULL) {
printf("panic: bad monopoly descriptor: "
"orig = %p\n", orig);
printf("player # %d\n", pl+1);
printhold(pl);
printf("orig_op = %p\n", orig_op);
if (orig_op) {
printf("orig_op->sqr->type = %d (PRPTY)\n",
orig_op->sqr->type);
printf("orig_op->next = %p\n",
orig_op->next);
printf("orig_op->sqr->desc = %p\n",
orig_op->sqr->desc);
}
printf("op = %p\n", op);
if (op) {
printf("op->sqr->type = %d (PRPTY)\n",
op->sqr->type);
printf("op->next = %p\n", op->next);
printf("op->sqr->desc = %p\n",
op->sqr->desc);
}
printf("num = %d\n", num);
exit(1);
}
#ifdef DEBUG
printf("orig->num_in = %d\n", orig->num_in);
#endif
if (num == orig->num_in)
is_monop(orig, pl);
else
is_not_monop(orig);
break;
}
}
}
/*
* This routine sets things up as if it is a new monopoly
*/
static void
is_monop(MON *mp, int pl)
{
int i;
mp->owner = pl;
mp->num_own = mp->num_in;
for (i = 0; i < mp->num_in; i++)
mp->sq[i]->desc->monop = TRUE;
mp->name = mp->mon_n;
}
/*
* This routine sets things up as if it is no longer a monopoly
*/
void
is_not_monop(MON *mp)
{
int i;
mp->owner = -1;
for (i = 0; i < mp->num_in; i++)
mp->sq[i]->desc->monop = FALSE;
mp->name = mp->not_m;
}
/*
* This routine gives a list of the current player's routine
*/
void
list(void)
{
printhold(player);
}
/*
* This routine gives a list of a given players holdings
*/
void
list_all(void)
{
int pl;
while ((pl = getinp("Whose holdings do you want to see? ", name_list))
< num_play)
printhold(pl);
}
/*
* This routine gives the players a chance before it exits.
*/
void
quit(void)
{
putchar('\n');
/* We dont even have a chance to input y/n if stdin is closed */
if (feof(stdin))
exit(0);
if (getyn("Do you all really want to quit? ") == 0)
exit(0);
}

178
games/monop/monop.6 Normal file
View file

@ -0,0 +1,178 @@
.\" $NetBSD: monop.6,v 1.19 2008/02/24 03:50:07 dholland Exp $
.\"
.\" Copyright (c) 1980 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.
.\"
.\" @(#)monop.6 6.5 (Berkeley) 3/25/93
.\"
.Dd February 23, 2008
.Dt MONOP 6
.Os
.Sh NAME
.Nm monop
.Nd Monopoly game
.Sh SYNOPSIS
.Nm
.Op Ar file
.Sh DESCRIPTION
.Nm
is reminiscent of the Parker Brother's game Monopoly, and
monitors a game between 2 to 9 users.
It is assumed that the rules of Monopoly are known.
The game follows the standard rules, with the exception that,
if a property goes up for auction and there are only two solvent players,
no auction is held and the property remains unowned.
.Pp
The game, in effect, lends the player money,
so it is possible to buy something which you cannot afford.
However, as soon as a person goes into debt, he must
.Dq fix the problem ,
i.e., make himself solvent, before play can continue.
If this is not possible, the player's property reverts to his debtee,
either a player or the bank.
A player can resign at any time to any person or the bank,
which puts the property back on the board, unowned.
.Pp
Any time that the response to a question is a
.Em string ,
e.g., a name, place or person, you can type
.Sq Ic \&?
to get a list of valid answers.
It is not possible to input a negative number, nor is it ever necessary.
.Pp
.Em A Summary of Commands :
.Bl -tag -width item
.It Ic quit
quit game: This allows you to quit the game.
It asks you if you're sure.
.It Ic print
print board: This prints out the current board.
The columns have the following meanings (column headings are the same for the
.Ic where ,
.Ic own holdings ,
and
.Ic holdings
commands):
.Pp
.Bl -tag -width indent -compact
.It Name
The first ten characters of the name of the square.
.It Own
The
.Em number
of the owner of the property.
.It Price
The cost of the property (if any).
.It Mg
This field has a
.Sq *
in it if the property is mortgaged.
.It \&#
If the property is a Utility or Railroad, this is the number
of such owned by the owner.
If the property is land, this is the number of houses on it.
.It Rent
Current rent on the property.
If it is not owned, there is no rent.
.El
.It Ic where
where players are: Tells you where all the players are.
A
.Sq *
indicates the current player.
.It Ic own holdings
List your own holdings,
i.e., money, get-out-of-jail-free cards, and property.
.It Ic holdings
holdings list: Look at anyone's holdings.
It will ask you whose holdings you wish to look at.
When you are finished, type
.Sq Ic done .
.It Ic mortgage
mortgage property:
Sets up a list of mortgageable property, and asks which you wish to mortgage.
.It Ic unmortgage
unmortgage property:
Unmortgage mortgaged property.
.It Ic buy
buy houses:
Sets up a list of monopolies on which you can buy houses.
If there is more than one, it asks you which you want to buy for.
It then asks you how many for each piece of property,
giving the current amount in parentheses after the property name.
If you build in an unbalanced manner
(a disparity of more than one house within the same monopoly),
it asks you to re-input things.
.It Ic sell
sell houses:
Sets up a list of monopolies from which you can sell houses.
It operates in an analogous manner to
.Ic buy .
.It Ic card
card for jail:
Use a get-out-of-jail-free card to get out of jail.
If you're not in jail, or you don't have one, it tells you so.
.It Ic pay
pay for jail:
Pay $50 to get out of jail, from whence you are put on Just Visiting.
Difficult to do if you're not there.
.It Ic trade
This allows you to trade with another player.
It asks you whom you wish to trade with,
and then asks you what each wishes to give up.
You can get a summary at the end, and, in all cases,
it asks for confirmation of the trade before doing it.
.It Ic resign
Resign to another player or the bank.
If you resign to the bank, all property reverts to its virgin state,
and get-out-of-jail-free cards revert to the deck.
.It Ic save
save game:
Save the current game in a file for later play.
You can continue play after saving,
either by adding the file in which you saved the game after the
.Nm
command, or by using the
.Ic restore
command (see below).
It will ask you which file you wish to save it in,
and, if the file exists, confirm that you wish to overwrite it.
.It Ic restore
restore game:
Read in a previously saved game from a file.
It leaves the file intact.
.It Ic roll
Roll the dice and move forward to your new location.
If you simply hit the
.Aq RETURN
key instead of a command, it is the same as typing
.Ic roll .
.El
.Sh AUTHORS
.An Ken Arnold
.Sh BUGS
No command can be given an argument instead of a response to a query.

360
games/monop/monop.c Normal file
View file

@ -0,0 +1,360 @@
/* $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]];
}
}

221
games/monop/monop.h Normal file
View file

@ -0,0 +1,221 @@
/* $NetBSD: monop.h,v 1.19 2009/08/12 08:10:49 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.
*
* @(#)monop.h 8.1 (Berkeley) 5/31/93
*/
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define bool char
#define TRUE (1)
#define FALSE (0)
#define N_MON 8 /* number of monopolies */
#define N_PROP 22 /* number of normal property squares */
#define N_RR 4 /* number of railroads */
#define N_UTIL 2 /* number of utilities */
#define N_SQRS 40 /* number of squares on board */
#define MAX_PL 9 /* maximum number of players */
#define MAX_PRP (N_PROP+N_RR+N_UTIL) /* max # ownable property */
#define N_HOUSE 32 /* total number of houses available */
#define N_HOTEL 12 /* total number of hotels available */
/* square type numbers */
#define PRPTY 0 /* normal property */
#define RR 1 /* railroad */
#define UTIL 2 /* water works - electric co */
#define SAFE 3 /* safe spot */
#define CC 4 /* community chest */
#define CHANCE 5 /* chance (surprise!!!) */
#define INC_TAX 6 /* Income tax */
#define GOTO_J 7 /* Go To Jail! */
#define LUX_TAX 8 /* Luxury tax */
#define IN_JAIL 9 /* In jail */
#define JAIL 40 /* JAIL square number */
#define lucky(str) printf("%s%s\n",str,lucky_mes[roll(1,num_luck)-1])
#define printline() printf("------------------------------\n")
#define sqnum(sqp) ((short)(sqp - board))
struct sqr_st { /* structure for square */
const char *name; /* place name */
short owner; /* owner number */
short type; /* place type */
struct prp_st *desc; /* description struct */
int cost; /* cost */
};
typedef struct sqr_st SQUARE;
struct mon_st { /* monopoly description structure */
const char *name; /* monop. name (color) */
short owner; /* owner of monopoly */
short num_in; /* # in monopoly */
short num_own; /* # owned (-1: not poss. monop)*/
short h_cost; /* price of houses */
const char *not_m; /* name if not monopoly */
const char *mon_n; /* name if a monopoly */
unsigned char sqnums[3]; /* Square numbers (used to init)*/
SQUARE *sq[3]; /* list of squares in monop */
};
typedef struct mon_st MON;
/*
* This struct describes a property. For railroads and utilities, only
* the "morg" member is used.
*/
struct prp_st { /* property description structure */
bool morg; /* set if mortgaged */
bool monop; /* set if monopoly */
short square; /* square description */
short houses; /* number of houses */
MON *mon_desc; /* name of color */
int rent[6]; /* rents */
};
struct own_st { /* element in list owned things */
SQUARE *sqr; /* pointer to square */
struct own_st *next; /* next in list */
};
typedef struct own_st OWN;
struct plr_st { /* player description structure */
char *name; /* owner name */
short num_gojf; /* # of get-out-of-jail-free's */
short num_rr; /* # of railroads owned */
short num_util; /* # of water works/elec. co. */
short loc; /* location on board */
short in_jail; /* count of turns in jail */
int money; /* amount of money */
OWN *own_list; /* start of property list */
};
typedef struct plr_st PLAY;
typedef struct prp_st PROP;
typedef struct prp_st RR_S;
typedef struct prp_st UTIL_S;
extern bool trading, spec, fixing, told_em;
extern const char *const yncoms[], *name_list[], *const lucky_mes[];
extern int num_play, player, num_doub, num_luck;
extern void (*const func[])(void);
/*extern MON mon[N_MON];*/
extern PLAY *play, *cur_p;
extern PROP prop[N_PROP];
/*extern RR_S rr[N_RR];*/
extern SQUARE board[N_SQRS + 1];
/*extern UTIL_S util[2];*/
/* cards.c */
void ret_card(PLAY *);
/* execute.c */
void execute(int);
void do_move(void);
void move(int);
void save(void);
void restore(void);
int rest_f(const char *);
/* getinp.c */
int getinp(const char *, const char *const []);
/* houses.c */
void buy_houses(void);
void sell_houses(void);
/* jail.c */
void card(void);
void pay(void);
int move_jail(int, int );
void printturn(void);
/* misc.c */
int getyn(const char *);
void notify(void);
void next_play(void);
int get_int(const char *);
void set_ownlist(int);
void is_not_monop(MON *);
void list(void);
void list_all(void);
void quit(void);
/* morg.c */
void mortgage(void);
void unmortgage(void);
void force_morg(void);
/* print.c */
void printboard(void);
void where(void);
void printsq(int, bool);
void printhold(int);
/* prop.c */
void buy(int, SQUARE *);
void add_list(int, OWN **, int);
void del_list(int, OWN **, short);
void bid(void);
int prop_worth(PLAY *);
/* rent.c */
void rent(SQUARE *);
/* roll.c */
int roll(int, int);
/* spec.c */
void inc_tax(void);
void goto_jail(void);
void lux_tax(void);
void cc(void);
void chance(void);
/* trade.c */
void trade(void);
void resign(void);

229
games/monop/morg.c Normal file
View file

@ -0,0 +1,229 @@
/* $NetBSD: morg.c,v 1.19 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
#if 0
static char sccsid[] = "@(#)morg.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: morg.c,v 1.19 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
/*
* These routines deal with mortgaging.
*/
static const char *names[MAX_PRP+2],
*const morg_coms[] = {
"quit", /* 0 */
"print", /* 1 */
"where", /* 2 */
"own holdings", /* 3 */
"holdings", /* 4 */
"mortgage", /* 5 */
"unmortgage", /* 6 */
"buy", /* 7 */
"sell", /* 8 */
"card", /* 9 */
"pay", /* 10 */
"trade", /* 11 */
"resign", /* 12 */
"save game", /* 13 */
"restore game", /* 14 */
0
};
static short square[MAX_PRP+2];
static int num_good, got_houses;
static int set_mlist(void);
static void m(int);
static int set_umlist(void);
static void unm(int);
/*
* This routine is the command level response the mortgage command.
* it gets the list of mortgageable property and asks which are to
* be mortgaged.
*/
void
mortgage(void)
{
int propnum;
for (;;) {
if (set_mlist() == 0) {
if (got_houses)
printf("You can't mortgage property with "
"houses on it.\n");
else
printf("You don't have any un-mortgaged "
"property.\n");
return;
}
if (num_good == 1) {
printf("Your only mortgageable property is %s\n",
names[0]);
if (getyn("Do you want to mortgage it? ") == 0)
m(square[0]);
return;
}
propnum = getinp("Which property do you want to mortgage? ",
names);
if (propnum == num_good)
return;
m(square[propnum]);
notify();
}
}
/*
* This routine sets up the list of mortgageable property
*/
static int
set_mlist(void)
{
OWN *op;
num_good = 0;
for (op = cur_p->own_list; op; op = op->next)
if (!op->sqr->desc->morg) {
if (op->sqr->type == PRPTY && op->sqr->desc->houses)
got_houses++;
else {
names[num_good] = op->sqr->name;
square[num_good++] = sqnum(op->sqr);
}
}
names[num_good++] = "done";
names[num_good--] = 0;
return num_good;
}
/*
* This routine actually mortgages the property.
*/
static void
m(int propnum)
{
int price;
price = board[propnum].cost/2;
board[propnum].desc->morg = TRUE;
printf("That got you $%d\n",price);
cur_p->money += price;
}
/*
* This routine is the command level repsponse to the unmortgage
* command. It gets the list of mortgaged property and asks which are
* to be unmortgaged.
*/
void
unmortgage(void)
{
int propnum;
for (;;) {
if (set_umlist() == 0) {
printf("You don't have any mortgaged property.\n");
return;
}
if (num_good == 1) {
printf("Your only mortgaged property is %s\n",
names[0]);
if (getyn("Do you want to unmortgage it? ") == 0)
unm(square[0]);
return;
}
propnum = getinp("Which property do you want to unmortgage? ",
names);
if (propnum == num_good)
return;
unm(square[propnum]);
}
}
/*
* This routine sets up the list of mortgaged property
*/
static int
set_umlist(void)
{
OWN *op;
num_good = 0;
for (op = cur_p->own_list; op; op = op->next)
if (op->sqr->desc->morg) {
names[num_good] = op->sqr->name;
square[num_good++] = sqnum(op->sqr);
}
names[num_good++] = "done";
names[num_good--] = 0;
return num_good;
}
/*
* This routine actually unmortgages the property
*/
static void
unm(int propnum)
{
int price;
price = board[propnum].cost/2;
board[propnum].desc->morg = FALSE;
price += price/10;
printf("That cost you $%d\n",price);
cur_p->money -= price;
(void)set_umlist();
}
/*
* This routine forces the indebted player to fix his
* financial woes. It is fine to have $0 but not to be in debt.
*/
void
force_morg(void)
{
told_em = fixing = TRUE;
while (cur_p->money < 0) {
told_em = FALSE;
(*func[(getinp("How are you going to fix it up? ", morg_coms))])();
notify();
}
fixing = FALSE;
}

197
games/monop/print.c Normal file
View file

@ -0,0 +1,197 @@
/* $NetBSD: print.c,v 1.13 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
#if 0
static char sccsid[] = "@(#)print.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: print.c,v 1.13 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
static const char *header = "Name Own Price Mg # Rent";
static void printmorg(const SQUARE *);
/*
* This routine prints out the current board
*/
void
printboard(void)
{
int i;
printf("%s\t%s\n", header, header);
for (i = 0; i < N_SQRS/2; i++) {
printsq(i, FALSE);
putchar('\t');
printsq(i+N_SQRS/2, TRUE);
}
}
/*
* This routine lists where each player is.
*/
void
where(void)
{
int i;
printf("%s Player\n", header);
for (i = 0; i < num_play; i++) {
printsq(play[i].loc, FALSE);
printf(" %s (%d)", play[i].name, i+1);
if (cur_p == &play[i])
printf(" *");
putchar('\n');
}
}
/*
* This routine prints out an individual square
*/
void
printsq(int sqn, bool eoln)
{
int rnt;
PROP *pp;
SQUARE *sqp;
sqp = &board[sqn];
printf("%-10.10s", sqp->name);
switch (sqp->type) {
case SAFE:
case CC:
case CHANCE:
case INC_TAX:
case GOTO_J:
case LUX_TAX:
case IN_JAIL:
if (!eoln)
printf(" ");
break;
case PRPTY:
pp = sqp->desc;
if (sqp->owner < 0) {
printf(" - %-8.8s %3d", pp->mon_desc->name, sqp->cost);
if (!eoln)
printf(" ");
break;
}
printf(" %d %-8.8s %3d", sqp->owner+1, pp->mon_desc->name,
sqp->cost);
printmorg(sqp);
if (pp->monop) {
if (pp->houses < 5)
if (pp->houses > 0)
printf("%d %4d", pp->houses,
pp->rent[pp->houses]);
else
printf("0 %4d", pp->rent[0] * 2);
else
printf("H %4d", pp->rent[5]);
} else
printf(" %4d", pp->rent[0]);
break;
case UTIL:
if (sqp->owner < 0) {
printf(" - 150");
if (!eoln)
printf(" ");
break;
}
printf(" %d 150", sqp->owner+1);
printmorg(sqp);
printf("%d", play[sqp->owner].num_util);
if (!eoln)
printf(" ");
break;
case RR:
if (sqp->owner < 0) {
printf(" - Railroad 200");
if (!eoln)
printf(" ");
break;
}
printf(" %d Railroad 200", sqp->owner+1);
printmorg(sqp);
rnt = 25;
rnt <<= play[sqp->owner].num_rr - 1;
printf("%d %4d", play[sqp->owner].num_rr,
25 << (play[sqp->owner].num_rr - 1));
break;
}
if (eoln)
putchar('\n');
}
/*
* This routine prints out the mortgage flag.
*/
static void
printmorg(const SQUARE *sqp)
{
if (sqp->desc->morg)
printf(" * ");
else
printf(" ");
}
/*
* This routine lists the holdings of the player given
*/
void
printhold(int pl)
{
OWN *op;
PLAY *pp;
pp = &play[pl];
printf("%s's (%d) holdings (Total worth: $%d):\n", name_list[pl],
pl + 1, pp->money + prop_worth(pp));
printf("\t$%d", pp->money);
if (pp->num_gojf) {
printf(", %d get-out-of-jail-free card", pp->num_gojf);
if (pp->num_gojf > 1)
putchar('s');
}
putchar('\n');
if (pp->own_list) {
printf("\t%s\n", header);
for (op = pp->own_list; op; op = op->next) {
putchar('\t');
printsq(sqnum(op->sqr), TRUE);
}
}
}

224
games/monop/prop.c Normal file
View file

@ -0,0 +1,224 @@
/* $NetBSD: prop.c,v 1.20 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
#if 0
static char sccsid[] = "@(#)prop.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: prop.c,v 1.20 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include <stdlib.h>
#include "monop.h"
static int value(SQUARE *);
/*
* This routine deals with buying property, setting all the
* appropriate flags.
*/
void
buy(int playernum, SQUARE *sqrp)
{
trading = FALSE;
sqrp->owner = playernum;
add_list(playernum, &(play[playernum].own_list), cur_p->loc);
}
/*
* This routine adds an item to the list.
*/
void
add_list(int plr, OWN **head, int op_sqr)
{
int val;
OWN *tp, *last_tp;
OWN *op;
op = calloc(1, sizeof (OWN));
if (op == NULL)
errx(1, "out of memory");
op->sqr = &board[op_sqr];
val = value(op->sqr);
last_tp = NULL;
for (tp = *head; tp && value(tp->sqr) < val; tp = tp->next)
if (val == value(tp->sqr)) {
free(op);
return;
}
else
last_tp = tp;
op->next = tp;
if (last_tp != NULL)
last_tp->next = op;
else
*head = op;
if (!trading)
set_ownlist(plr);
}
/*
* This routine deletes property from the list.
*/
void
del_list(int plr, OWN **head, short op_sqr)
{
OWN *op, *last_op;
switch (board[op_sqr].type) {
case PRPTY:
board[op_sqr].desc->mon_desc->num_own--;
break;
case RR:
play[plr].num_rr--;
break;
case UTIL:
play[plr].num_util--;
break;
}
last_op = NULL;
for (op = *head; op; op = op->next)
if (op->sqr == &board[op_sqr])
break;
else
last_op = op;
if (op == NULL)
return;
if (last_op == NULL)
*head = op->next;
else {
last_op->next = op->next;
free(op);
}
}
/*
* This routine calculates the value for sorting of the
* given square.
*/
static int
value(SQUARE *sqp)
{
int sqr;
sqr = sqnum(sqp);
switch (sqp->type) {
case SAFE:
return 0;
default: /* Specials, etc */
return 1;
case UTIL:
if (sqr == 12)
return 2;
else
return 3;
case RR:
return 4 + sqr/10;
case PRPTY:
return 8 + (sqp->desc) - prop;
}
}
/*
* This routine accepts bids for the current piece of property.
*/
void
bid(void)
{
static bool in[MAX_PL];
int i, num_in, cur_max;
char buf[257];
int cur_bid;
printf("\nSo it goes up for auction. Type your bid after your name\n");
for (i = 0; i < num_play; i++)
in[i] = TRUE;
i = -1;
cur_max = 0;
num_in = num_play;
while (num_in > 1 || (cur_max == 0 && num_in > 0)) {
i = (i + 1) % num_play;
if (in[i]) {
do {
(void)snprintf(buf, sizeof(buf), "%s: ",
name_list[i]);
cur_bid = get_int(buf);
if (cur_bid == 0) {
in[i] = FALSE;
if (--num_in == 0)
break;
} else if (cur_bid <= cur_max) {
printf("You must bid higher than %d "
"to stay in\n", cur_max);
printf("(bid of 0 drops you out)\n");
} else if (cur_bid > play[i].money) {
printf("You can't bid more than your cash ($%d)\n",
play[i].money);
cur_bid = -1;
}
} while (cur_bid != 0 && cur_bid <= cur_max);
cur_max = (cur_bid ? cur_bid : cur_max);
}
}
if (cur_max != 0) {
while (!in[i])
i = (i + 1) % num_play;
printf("It goes to %s (%d) for $%d\n",play[i].name,i+1,cur_max);
buy(i, &board[cur_p->loc]);
play[i].money -= cur_max;
}
else
printf("Nobody seems to want it, so we'll leave it for "
"later\n");
}
/*
* This routine calculates the value of the property
* of given player.
*/
int
prop_worth(PLAY *plp)
{
OWN *op;
int worth;
worth = 0;
for (op = plp->own_list; op; op = op->next) {
if (op->sqr->type == PRPTY && op->sqr->desc->monop)
worth += op->sqr->desc->mon_desc->h_cost * 50 *
op->sqr->desc->houses;
worth += op->sqr->cost;
}
return worth;
}

96
games/monop/rent.c Normal file
View file

@ -0,0 +1,96 @@
/* $NetBSD: rent.c,v 1.9 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
#if 0
static char sccsid[] = "@(#)rent.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: rent.c,v 1.9 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
/*
* This routine has the player pay rent
*/
void
rent(SQUARE *sqp)
{
int rnt = 0;
PROP *pp;
PLAY *plp;
plp = &play[sqp->owner];
printf("Owned by %s\n", plp->name);
if (sqp->desc->morg) {
lucky("The thing is mortgaged. ");
return;
}
switch (sqp->type) {
case PRPTY:
pp = sqp->desc;
if (pp->monop)
if (pp->houses == 0)
printf("rent is %d\n", rnt=pp->rent[0] * 2);
else if (pp->houses < 5)
printf("with %d house%s, rent is %d\n",
pp->houses, pp->houses == 1 ? "" : "s",
rnt=pp->rent[pp->houses]);
else
printf("with a hotel, rent is %d\n",
rnt=pp->rent[pp->houses]);
else
printf("rent is %d\n", rnt = pp->rent[0]);
break;
case RR:
rnt = 25;
rnt <<= (plp->num_rr - 1);
if (spec)
rnt <<= 1;
printf("rent is %d\n", rnt);
break;
case UTIL:
rnt = roll(2, 6);
if (plp->num_util == 2 || spec) {
printf("rent is 10 * roll (%d) = %d\n", rnt, rnt * 10);
rnt *= 10;
}
else {
printf("rent is 4 * roll (%d) = %d\n", rnt, rnt * 4);
rnt *= 4;
}
break;
}
cur_p->money -= rnt;
plp->money += rnt;
}

58
games/monop/roll.c Normal file
View file

@ -0,0 +1,58 @@
/* $NetBSD: roll.c,v 1.14 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
#if 0
static char sccsid[] = "@(#)roll.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: roll.c,v 1.14 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include <stdlib.h>
#include "monop.h"
/*
* This routine rolls ndie nside-sided dice.
*/
int
roll(int ndie, int nsides)
{
long tot;
tot = 0;
while (ndie--)
tot += (random() % nsides) + 1;
return (int)tot;
}

115
games/monop/spec.c Normal file
View file

@ -0,0 +1,115 @@
/* $NetBSD: spec.c,v 1.11 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
#if 0
static char sccsid[] = "@(#)spec.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: spec.c,v 1.11 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
#include "deck.h"
static const char *const perc[] = {
"10%", "ten percent", "%", "$200", "200", 0
};
/*
* collect income tax
*/
void
inc_tax(void)
{
int worth, com_num;
com_num = getinp("Do you wish to lose 10% of your total worth or "
"$200? ", perc);
worth = cur_p->money + prop_worth(cur_p);
printf("You were worth $%d", worth);
worth /= 10;
if (com_num > 2) {
if (worth < 200)
printf(". Good try, but not quite.\n");
else if (worth > 200)
lucky(".\nGood guess. ");
cur_p->money -= 200;
}
else {
printf(", so you pay $%d", worth);
if (worth > 200)
printf(" OUCH!!!!.\n");
else if (worth < 200)
lucky("\nGood guess. ");
cur_p->money -= worth;
}
if (worth == 200)
lucky("\nIt makes no difference! ");
}
/*
* move player to jail
*/
void
goto_jail(void)
{
cur_p->loc = JAIL;
}
/*
* landing on luxury tax
*/
void
lux_tax(void)
{
printf("You lose $75\n");
cur_p->money -= 75;
}
/*
* draw community chest card
*/
void
cc(void)
{
get_card(&CC_D);
}
/*
* draw chance card
*/
void
chance(void)
{
get_card(&CH_D);
}

329
games/monop/trade.c Normal file
View file

@ -0,0 +1,329 @@
/* $NetBSD: trade.c,v 1.16 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
#if 0
static char sccsid[] = "@(#)trade.c 8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: trade.c,v 1.16 2012/06/19 05:35:32 dholland Exp $");
#endif
#endif /* not lint */
#include "monop.h"
struct trd_st { /* how much to give to other player */
int trader; /* trader number */
int cash; /* amount of cash */
int gojf; /* # get-out-of-jail-free cards */
OWN *prop_list; /* property list */
};
typedef struct trd_st TRADE;
static const char *plist[MAX_PRP+2];
static int used[MAX_PRP];
static TRADE trades[2];
static void get_list(int, int );
static int set_list(OWN *);
static void summate(void);
static void do_trade(void);
static void move_em(TRADE *, TRADE *);
void
trade(void)
{
int tradee, i;
trading = TRUE;
for (i = 0; i < 2; i++) {
trades[i].cash = 0;
trades[i].gojf = FALSE;
trades[i].prop_list = NULL;
}
over:
if (num_play == 1) {
printf("There ain't no-one around to trade WITH!!\n");
return;
}
if (num_play > 2) {
tradee = getinp("Which player do you wish to trade with? ",
name_list);
if (tradee == num_play)
return;
if (tradee == player) {
printf("You can't trade with yourself!\n");
goto over;
}
}
else
tradee = 1 - player;
get_list(0, player);
get_list(1, tradee);
if (getyn("Do you wish a summary? ") == 0)
summate();
if (getyn("Is the trade ok? ") == 0)
do_trade();
}
/*
* This routine gets the list of things to be trader for the
* player, and puts in the structure given.
*/
static void
get_list(int struct_no, int play_no)
{
int sn, pn;
PLAY *pp;
int numin, propnum, num_prp;
OWN *op;
TRADE *tp;
for (numin = 0; numin < MAX_PRP; numin++)
used[numin] = FALSE;
sn = struct_no, pn = play_no;
pp = &play[pn];
tp = &trades[sn];
tp->trader = pn;
printf("player %s (%d):\n", pp->name, pn+1);
if (pp->own_list) {
numin = set_list(pp->own_list);
for (num_prp = numin; num_prp; ) {
propnum=getinp("Which property do you wish to trade? ",
plist);
if (propnum == numin)
break;
else if (used[propnum])
printf("You've already allocated that.\n");
else {
num_prp--;
used[propnum] = TRUE;
for (op = pp->own_list; propnum--; op = op->next)
continue;
add_list(pn, &(tp->prop_list), sqnum(op->sqr));
}
}
}
if (pp->money > 0) {
printf("You have $%d. ", pp->money);
tp->cash = get_int("How much are you trading? ");
}
if (pp->num_gojf > 0) {
once_more:
printf("You have %d get-out-of-jail-free cards. ",pp->num_gojf);
tp->gojf = get_int("How many are you trading? ");
if (tp->gojf > pp->num_gojf) {
printf("You don't have that many. Try again.\n");
goto once_more;
}
}
}
/*
* This routine sets up the list of tradable property.
*/
static int
set_list(OWN *the_list)
{
int i;
OWN *op;
i = 0;
for (op = the_list; op; op = op->next)
if (!used[i])
plist[i++] = op->sqr->name;
plist[i++] = "done";
plist[i--] = 0;
return i;
}
/*
* This routine summates the trade.
*/
static void
summate(void)
{
bool some;
int i;
TRADE *tp;
OWN *op;
for (i = 0; i < 2; i++) {
tp = &trades[i];
some = FALSE;
printf("Player %s (%d) gives:\n", play[tp->trader].name,
tp->trader+1);
if (tp->cash > 0)
printf("\t$%d\n", tp->cash), some++;
if (tp->gojf > 0)
printf("\t%d get-out-of-jail-free card(s)\n", tp->gojf),
some++;
if (tp->prop_list) {
for (op = tp->prop_list; op; op = op->next)
putchar('\t'), printsq(sqnum(op->sqr), TRUE);
some++;
}
if (!some)
printf("\t-- Nothing --\n");
}
}
/*
* This routine actually executes the trade.
*/
static void
do_trade(void)
{
move_em(&trades[0], &trades[1]);
move_em(&trades[1], &trades[0]);
}
/*
* This routine does a switch from one player to another
*/
static void
move_em(TRADE *from, TRADE *to)
{
PLAY *pl_fr, *pl_to;
OWN *op;
pl_fr = &play[from->trader];
pl_to = &play[to->trader];
pl_fr->money -= from->cash;
pl_to->money += from->cash;
pl_fr->num_gojf -= from->gojf;
pl_to->num_gojf += from->gojf;
for (op = from->prop_list; op; op = op->next) {
add_list(to->trader, &(pl_to->own_list), sqnum(op->sqr));
op->sqr->owner = to->trader;
del_list(from->trader, &(pl_fr->own_list), sqnum(op->sqr));
}
set_ownlist(to->trader);
}
/*
* This routine lets a player resign
*/
void
resign(void)
{
int i, new_own;
OWN *op;
SQUARE *sqp;
if (cur_p->money <= 0) {
switch (board[cur_p->loc].type) {
case UTIL:
case RR:
case PRPTY:
new_own = board[cur_p->loc].owner;
/* If you ran out of money by buying current location */
if (new_own == player)
new_own = num_play;
break;
default: /* Chance, taxes, etc */
new_own = num_play;
break;
}
if (new_own == num_play)
printf("You would resign to the bank\n");
else
printf("You would resign to %s\n", name_list[new_own]);
}
else if (num_play == 1) {
new_own = num_play;
printf("You would resign to the bank\n");
}
else {
name_list[num_play] = "bank";
do {
new_own = getinp("Who do you wish to resign to? ",
name_list);
if (new_own == player)
printf("You can't resign to yourself!!\n");
} while (new_own == player);
name_list[num_play] = "done";
}
if (getyn("Do you really want to resign? ") != 0)
return;
if (num_play == 1) {
printf("Then NOBODY wins (not even YOU!)\n");
exit(0);
}
if (new_own < num_play) { /* resign to player */
printf("resigning to player\n");
trades[0].trader = new_own;
trades[0].cash = trades[0].gojf = 0;
trades[0].prop_list = NULL;
trades[1].trader = player;
trades[1].cash = cur_p->money > 0 ? cur_p->money : 0;
trades[1].gojf = cur_p->num_gojf;
trades[1].prop_list = cur_p->own_list;
do_trade();
}
else { /* resign to bank */
printf("resigning to bank\n");
for (op = cur_p->own_list; op; op = op->next) {
sqp = op->sqr;
sqp->owner = -1;
sqp->desc->morg = FALSE;
if (sqp->type == PRPTY) {
is_not_monop(sqp->desc->mon_desc);
sqp->desc->houses = 0;
}
}
if (cur_p->num_gojf)
ret_card(cur_p);
}
free(play[player].name);
for (i = player; i < num_play; i++) {
name_list[i] = name_list[i+1];
if (i + 1 < num_play)
play[i] = play[i+1];
}
name_list[num_play--] = NULL;
for (i = 0; i < N_SQRS; i++)
if (board[i].owner > player)
--board[i].owner;
player = player == 0 ? num_play - 1 : player - 1;
next_play();
if (num_play < 2) {
printf("\nThen %s WINS!!!!!\n", play[0].name);
printhold(0);
printf("That's a grand worth of $%d.\n",
play[0].money+prop_worth(&play[0]));
exit(0);
}
}

1
releasetools/nbsd_ports
View file

@ -74,6 +74,7 @@
2013/12/1 12:00:00,games/fortune 2013/12/1 12:00:00,games/fortune
2013/12/1 12:00:00,games/Makefile 2013/12/1 12:00:00,games/Makefile
2013/12/1 12:00:00,games/Makefile.inc 2013/12/1 12:00:00,games/Makefile.inc
2013/12/1 12:00:00,games/monop
2013/12/1 12:00:00,games/morse 2013/12/1 12:00:00,games/morse
2013/12/1 12:00:00,games/number 2013/12/1 12:00:00,games/number
2013/12/1 12:00:00,games/pig 2013/12/1 12:00:00,games/pig