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