1: # include   "monop.ext"
   2: 
   3: /*
   4:  *	This routine deals with buying property, setting all the
   5:  * appropriate flags.
   6:  */
   7: buy(player, sqrp)
   8: reg int     player;
   9: reg SQUARE  *sqrp; {
  10: 
  11:     trading = FALSE;
  12:     sqrp->owner = player;
  13:     add_list(player, &(play[player].own_list), cur_p->loc);
  14: }
  15: /*
  16:  *	This routine adds an item to the list.
  17:  */
  18: add_list(plr, head, op_sqr)
  19: int plr;
  20: OWN **head;
  21: int op_sqr; {
  22: 
  23:     reg int val;
  24:     reg OWN *tp, *last_tp;
  25:     MON *mp;
  26:     OWN *op;
  27: 
  28:     op = calloc(1, sizeof (OWN));
  29:     op->sqr = &board[op_sqr];
  30:     val = value(op->sqr);
  31:     last_tp = NULL;
  32:     for (tp = *head; tp && value(tp->sqr) < val; tp = tp->next)
  33:         if (val == value(tp->sqr)) {
  34:             cfree(op);
  35:             return;
  36:         }
  37:         else
  38:             last_tp = tp;
  39:     op->next = tp;
  40:     if (last_tp != NULL)
  41:         last_tp->next = op;
  42:     else
  43:         *head = op;
  44:     if (!trading)
  45:         set_ownlist(plr);
  46: }
  47: /*
  48:  *	This routine deletes property from the list.
  49:  */
  50: del_list(plr, head, op_sqr)
  51: int plr;
  52: OWN **head;
  53: shrt    op_sqr; {
  54: 
  55:     reg int i;
  56:     reg OWN *op, *last_op;
  57: 
  58:     switch (board[op_sqr].type) {
  59:       case PRPTY:
  60:         board[op_sqr].desc->mon_desc->num_own--;
  61:         break;
  62:       case RR:
  63:         play[plr].num_rr--;
  64:         break;
  65:       case UTIL:
  66:         play[plr].num_util--;
  67:         break;
  68:     }
  69:     last_op = NULL;
  70:     for (op = *head; op; op = op->next)
  71:         if (op->sqr == &board[op_sqr])
  72:             break;
  73:         else
  74:             last_op = op;
  75:     if (last_op == NULL)
  76:         *head = op->next;
  77:     else {
  78:         last_op->next = op->next;
  79:         cfree(op);
  80:     }
  81: }
  82: /*
  83:  *	This routine calculates the value for sorting of the
  84:  * given square.
  85:  */
  86: value(sqp)
  87: reg SQUARE  *sqp; {
  88: 
  89:     reg int sqr;
  90: 
  91:     sqr = sqnum(sqp);
  92:     switch (sqp->type) {
  93:       case SAFE:
  94:         return 0;
  95:       case SPEC:
  96:         return 1;
  97:       case UTIL:
  98:         if (sqr == 12)
  99:             return 2;
 100:         else
 101:             return 3;
 102:       case RR:
 103:         return 4 + sqr/10;
 104:       case PRPTY:
 105:         return 8 + (PROP *)(sqp->desc) - prop;
 106:     }
 107: }
 108: /*
 109:  *	This routine accepts bids for the current peice
 110:  * of property.
 111:  */
 112: bid() {
 113: 
 114:     static bool in[MAX_PL];
 115:     reg int     i, num_in, cur_max;
 116:     char        buf[80];
 117:     int     cur_bid;
 118: 
 119:     printf("\nSo it goes up for auction.  Type your bid after your name\n");
 120:     for (i = 0; i < num_play; i++)
 121:         in[i] = TRUE;
 122:     i = -1;
 123:     cur_max = 0;
 124:     num_in = num_play;
 125:     while (num_in > 1 || (cur_max == 0 && num_in > 0)) {
 126:         i = ++i % num_play;
 127:         if (in[i]) {
 128:             do {
 129:                 sprintf(buf, "%s: ", name_list[i]);
 130:                 cur_bid = get_int(buf);
 131:                 if (cur_bid == 0) {
 132:                     in[i] = FALSE;
 133:                     if (--num_in == 0)
 134:                         break;
 135:                 }
 136:                 else if (cur_bid <= cur_max) {
 137:                     printf("You must bid higher than %d to stay in\n", cur_max);
 138:                     printf("(bid of 0 drops you out)\n");
 139:                 }
 140:             } while (cur_bid != 0 && cur_bid <= cur_max);
 141:             cur_max = (cur_bid ? cur_bid : cur_max);
 142:         }
 143:     }
 144:     if (cur_max != 0) {
 145:         while (!in[i])
 146:             i = ++i % num_play;
 147:         printf("It goes to %s (%d) for $%d\n",play[i].name,i+1,cur_max);
 148:         buy(i, &board[cur_p->loc]);
 149:         play[i].money -= cur_max;
 150:     }
 151:     else
 152:         printf("Nobody seems to want it, so we'll leave it for later\n");
 153: }
 154: /*
 155:  *	This routine calculates the value of the property
 156:  * of given player.
 157:  */
 158: prop_worth(plp)
 159: reg PLAY    *plp; {
 160: 
 161:     reg OWN *op;
 162:     reg int worth;
 163: 
 164:     worth = 0;
 165:     for (op = plp->own_list; op; op = op->next) {
 166:         if (op->sqr->type == PRPTY && op->sqr->desc->monop)
 167:             worth += op->sqr->desc->mon_desc->h_cost * 50 *
 168:                 op->sqr->desc->houses;
 169:         worth += op->sqr->cost;
 170:     }
 171:     return worth;
 172: }

Defined functions

add_list defined in line 18; used 3 times
bid defined in line 112; used 1 times
buy defined in line 7; used 2 times
del_list defined in line 50; used 1 times
value defined in line 86; used 3 times
Last modified: 1982-06-09
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 1410
Valid CSS Valid XHTML 1.0 Strict