monop/prop.c

   1 /*      $NetBSD: prop.c,v 1.6 1999/09/09 17:27:59 jsm Exp $     */
   2
   3 /*
   4  * Copyright (c) 1980, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *      This product includes software developed by the University of
  18  *      California, Berkeley and its contributors.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 #ifndef lint
  38 #if 0
  39 static char sccsid[] = "@(#)prop.c      8.1 (Berkeley) 5/31/93";
  40 #else
  41 __RCSID("$NetBSD: prop.c,v 1.6 1999/09/09 17:27:59 jsm Exp $");
  42 #endif
  43 #endif /* not lint */
  44
  45 #include <stdlib.h>
  46 #include "monop.ext"
  47
  48 static int value __P((SQUARE *));
  49
  50 /*
  51  *      This routine deals with buying property, setting all the
  52  * appropriate flags.
  53  */
  54 void
  55 buy(player, sqrp)
  56         int player;
  57         SQUARE *sqrp;
  58 {
  59         trading = FALSE;
  60         sqrp->owner = player;
  61         add_list(player, &(play[player].own_list), cur_p->loc);
  62 }
  63
  64 /*
  65  *      This routine adds an item to the list.
  66  */
  67 void
  68 add_list(plr, head, op_sqr)
  69         int plr;
  70         OWN **head;
  71         int op_sqr;
  72 {
  73         int val;
  74         OWN *tp, *last_tp;
  75         OWN *op;
  76
  77         op = (OWN *)calloc(1, sizeof (OWN));
  78         if (op == NULL)
  79                 errx(1, "out of memory");
  80         op->sqr = &board[op_sqr];
  81         val = value(op->sqr);
  82         last_tp = NULL;
  83         for (tp = *head; tp && value(tp->sqr) < val; tp = tp->next)
  84                 if (val == value(tp->sqr)) {
  85                         free(op);
  86                         return;
  87                 }
  88                 else
  89                         last_tp = tp;
  90         op->next = tp;
  91         if (last_tp != NULL)
  92                 last_tp->next = op;
  93         else
  94                 *head = op;
  95         if (!trading)
  96                 set_ownlist(plr);
  97 }
  98
  99 /*
 100  *      This routine deletes property from the list.
 101  */
 102 void
 103 del_list(plr, head, op_sqr)
 104         int plr;
 105         OWN **head;
 106         short op_sqr;
 107 {
 108         OWN *op, *last_op;
 109
 110         switch (board[op_sqr].type) {
 111           case PRPTY:
 112                 board[op_sqr].desc->mon_desc->num_own--;
 113                 break;
 114           case RR:
 115                 play[plr].num_rr--;
 116                 break;
 117           case UTIL:
 118                 play[plr].num_util--;
 119                 break;
 120         }
 121         last_op = NULL;
 122         for (op = *head; op; op = op->next)
 123                 if (op->sqr == &board[op_sqr])
 124                         break;
 125                 else
 126                         last_op = op;
 127         if (last_op == NULL)
 128                 *head = op->next;
 129         else {
 130                 last_op->next = op->next;
 131                 free(op);
 132         }
 133 }
 134
 135 /*
 136  *      This routine calculates the value for sorting of the
 137  * given square.
 138  */
 139 static int
 140 value(sqp)
 141         SQUARE *sqp;
 142 {
 143         int sqr;
 144
 145         sqr = sqnum(sqp);
 146         switch (sqp->type) {
 147           case SAFE:
 148                 return 0;
 149           default:              /* Specials, etc */
 150                 return 1;
 151           case UTIL:
 152                 if (sqr == 12)
 153                         return 2;
 154                 else
 155                         return 3;
 156           case RR:
 157                 return 4 + sqr/10;
 158           case PRPTY:
 159                 return 8 + (sqp->desc) - prop;
 160         }
 161 }
 162
 163 /*
 164  *      This routine accepts bids for the current peice
 165  * of property.
 166  */
 167 void
 168 bid()
 169 {
 170         static bool in[MAX_PL];
 171         int i, num_in, cur_max;
 172         char buf[80];
 173         int cur_bid;
 174
 175         printf("\nSo it goes up for auction.  Type your bid after your name\n");
 176         for (i = 0; i < num_play; i++)
 177                 in[i] = TRUE;
 178         i = -1;
 179         cur_max = 0;
 180         num_in = num_play;
 181         while (num_in > 1 || (cur_max == 0 && num_in > 0)) {
 182                 i = ++i % num_play;
 183                 if (in[i]) {
 184                         do {
 185                                 (void)sprintf(buf, "%s: ", name_list[i]);
 186                                 cur_bid = get_int(buf);
 187                                 if (cur_bid == 0) {
 188                                         in[i] = FALSE;
 189                                         if (--num_in == 0)
 190                                                 break;
 191                                 }
 192                                 else if (cur_bid <= cur_max) {
 193                                         printf("You must bid higher than %d "
 194                                             "to stay in\n", cur_max);
 195                                         printf("(bid of 0 drops you out)\n");
 196                                 }
 197                         } while (cur_bid != 0 && cur_bid <= cur_max);
 198                         cur_max = (cur_bid ? cur_bid : cur_max);
 199                 }
 200         }
 201         if (cur_max != 0) {
 202                 while (!in[i])
 203                         i = ++i % num_play;
 204                 printf("It goes to %s (%d) for $%d\n",play[i].name,i+1,cur_max);
 205                 buy(i, &board[cur_p->loc]);
 206                 play[i].money -= cur_max;
 207         }
 208         else
 209                 printf("Nobody seems to want it, so we'll leave it for "
 210                     "later\n");
 211 }
 212
 213 /*
 214  *      This routine calculates the value of the property
 215  * of given player.
 216  */
 217 int
 218 prop_worth(plp)
 219         PLAY *plp;
 220 {
 221         OWN *op;
 222         int worth;
 223
 224         worth = 0;
 225         for (op = plp->own_list; op; op = op->next) {
 226                 if (op->sqr->type == PRPTY && op->sqr->desc->monop)
 227                         worth += op->sqr->desc->mon_desc->h_cost * 50 *
 228                             op->sqr->desc->houses;
 229                 worth += op->sqr->cost;
 230         }
 231         return worth;
 232 }