1: /*      $NetBSD: morg.c,v 1.10 2004/01/27 20:30:30 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. Neither the name of the University nor the names of its contributors
   16:  *    may be used to endorse or promote products derived from this software
   17:  *    without specific prior written permission.
   18:  *
   19:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   20:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   23:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29:  * SUCH DAMAGE.
   30:  */
   31: 
   32: #include <sys/cdefs.h>
   33: #ifndef lint
   34: #if 0
   35: static char sccsid[] = "@(#)morg.c      8.1 (Berkeley) 5/31/93";
   36: #else
   37: __RCSID("$NetBSD: morg.c,v 1.10 2004/01/27 20:30:30 jsm Exp $");
   38: #endif
   39: #endif /* not lint */
   40: 
   41: #include "monop.ext"
   42: 
   43: /*
   44:  *      These routines deal with mortgaging.
   45:  */
   46: 
   47: static const char       *names[MAX_PRP+2],
   48:                 *const morg_coms[]    = {
   49:                         "quit",              /*  0 */
   50:                         "print",     /*  1 */
   51:                         "where",     /*  2 */
   52:                         "own holdings",      /*  3 */
   53:                         "holdings",  /*  4 */
   54:                         "mortgage",  /*  5 */
   55:                         "unmortgage",        /*  6 */
   56:                         "buy",               /*  7 */
   57:                         "sell",              /*  8 */
   58:                         "card",              /*  9 */
   59:                         "pay",               /* 10 */
   60:                         "trade",     /* 11 */
   61:                         "resign",    /* 12 */
   62:                         "save game", /* 13 */
   63:                         "restore game",      /* 14 */
   64:                         0
   65:                 };
   66: 
   67: static short    square[MAX_PRP+2];
   68: 
   69: static int      num_good,got_houses;
   70: 
   71: 
   72: static int set_mlist(void);
   73: static void m(int);
   74: static int set_umlist(void);
   75: static void unm(int);
   76: static void fix_ex(int);
   77: 
   78: /*
   79:  *      This routine is the command level response the mortgage command.
   80:  * it gets the list of mortgageable property and asks which are to
   81:  * be mortgaged.
   82:  */
   83: void
   84: mortgage()
   85: {
   86:         int prop;
   87: 
   88:         for (;;) {
   89:                 if (set_mlist() == 0) {
   90:                         if (got_houses)
   91:                                 printf("You can't mortgage property with "
   92:                                     "houses on it.\n");
   93:                         else
   94:                                 printf("You don't have any un-mortgaged "
   95:                                     "property.\n");
   96:                         return;
   97:                 }
   98:                 if (num_good == 1) {
   99:                         printf("Your only mortageable property is %s\n",
  100:                             names[0]);
  101:                         if (getyn("Do you want to mortgage it? ") == 0)
  102:                                 m(square[0]);
  103:                         return;
  104:                 }
  105:                 prop = getinp("Which property do you want to mortgage? ",names);
  106:                 if (prop == num_good)
  107:                         return;
  108:                 m(square[prop]);
  109:                 notify();
  110:         }
  111: }
  112: 
  113: /*
  114:  *      This routine sets up the list of mortgageable property
  115:  */
  116: static int
  117: set_mlist()
  118: {
  119:         OWN *op;
  120: 
  121:         num_good = 0;
  122:         for (op = cur_p->own_list; op; op = op->next)
  123:                 if (!op->sqr->desc->morg) {
  124:                         if (op->sqr->type == PRPTY && op->sqr->desc->houses)
  125:                                 got_houses++;
  126:                         else {
  127:                                 names[num_good] = op->sqr->name;
  128:                                 square[num_good++] = sqnum(op->sqr);
  129:                         }
  130:                 }
  131:         names[num_good++] = "done";
  132:         names[num_good--] = 0;
  133:         return num_good;
  134: }
  135: 
  136: /*
  137:  *      This routine actually mortgages the property.
  138:  */
  139: static void
  140: m(prop)
  141:         int prop;
  142: {
  143:         int price;
  144: 
  145:         price = board[prop].cost/2;
  146:         board[prop].desc->morg = TRUE;
  147:         printf("That got you $%d\n",price);
  148:         cur_p->money += price;
  149: }
  150: 
  151: /*
  152:  *      This routine is the command level repsponse to the unmortgage
  153:  * command.  It gets the list of mortgaged property and asks which are
  154:  * to be unmortgaged.
  155:  */
  156: void
  157: unmortgage() 
  158: {
  159:         int prop;
  160: 
  161:         for (;;) {
  162:                 if (set_umlist() == 0) {
  163:                         printf("You don't have any mortgaged property.\n");
  164:                         return;
  165:                 }
  166:                 if (num_good == 1) {
  167:                         printf("Your only mortaged property is %s\n",names[0]);
  168:                         if (getyn("Do you want to unmortgage it? ") == 0)
  169:                                 unm(square[0]);
  170:                         return;
  171:                 }
  172:                 prop = getinp("Which property do you want to unmortgage? ",
  173:                     names);
  174:                 if (prop == num_good)
  175:                         return;
  176:                 unm(square[prop]);
  177:         }
  178: }
  179: 
  180: /*
  181:  *      This routine sets up the list of mortgaged property
  182:  */
  183: static int
  184: set_umlist()
  185: {
  186:         OWN *op;
  187: 
  188:         num_good = 0;
  189:         for (op = cur_p->own_list; op; op = op->next)
  190:                 if (op->sqr->desc->morg) {
  191:                         names[num_good] = op->sqr->name;
  192:                         square[num_good++] = sqnum(op->sqr);
  193:                 }
  194:         names[num_good++] = "done";
  195:         names[num_good--] = 0;
  196:         return num_good;
  197: }
  198: 
  199: /*
  200:  *      This routine actually unmortgages the property
  201:  */
  202: static void
  203: unm(prop)
  204:         int prop; 
  205: {
  206:         int price;
  207: 
  208:         price = board[prop].cost/2;
  209:         board[prop].desc->morg = FALSE;
  210:         price += price/10;
  211:         printf("That cost you $%d\n",price);
  212:         cur_p->money -= price;
  213:         set_umlist();
  214: }
  215: 
  216: /*
  217:  *      This routine forces the indebted player to fix his
  218:  * financial woes.
  219:  */
  220: void
  221: force_morg()
  222: {
  223:         told_em = fixing = TRUE;
  224:         while (cur_p->money <= 0)
  225:                 fix_ex(getinp("How are you going to fix it up? ",morg_coms));
  226:         fixing = FALSE;
  227: }
  228: 
  229: /*
  230:  *      This routine is a special execute for the force_morg routine
  231:  */
  232: static void
  233: fix_ex(com_num)
  234:         int com_num;
  235: {
  236:         told_em = FALSE;
  237:         (*func[com_num])();
  238:         notify();
  239: }