home *** CD-ROM | disk | FTP | other *** search
/ Hall of Fame / HallofFameCDROM.cdr / proglc / mor4873s.lzh / STORE1.C < prev    next >
C/C++ Source or Header  |  1988-11-01  |  10KB  |  373 lines
  1. #include "constant.h"
  2. #include "config.h"
  3. #include "types.h"
  4. #include "externs.h"
  5.  
  6. #ifdef USG
  7. #include <string.h>
  8. #else
  9. #include <strings.h>
  10. #endif
  11.  
  12. bigint_t search_list(x1, x2)
  13. byteint x1;
  14. int x2;
  15. {
  16.   register int i; bigint_t j;
  17.   register treasure_type *o_ptr;
  18.  
  19.   i = 0;
  20.   j = 0;
  21.   do
  22.     {
  23.       o_ptr = &object_list[i];
  24.       if ((o_ptr->tval == x1) && (o_ptr->subval == x2))
  25.     j = o_ptr->cost;
  26.       i++;
  27.     }
  28.   while ((i != MAX_OBJECTS) && (j <= 0));
  29.   return(j);
  30. }
  31.  
  32.  
  33. /* Returns the value for any given object        -RAK-    */
  34. bigint_t item_value(item)
  35. treasure_type item;
  36. {
  37.   register bigint_t value;
  38.   register treasure_type *i_ptr;
  39.  
  40.   i_ptr = &item;
  41.   value = i_ptr->cost;
  42.   if (((i_ptr->tval >= 20) && (i_ptr->tval <= 23)) ||
  43.       ((i_ptr->tval >= 30) && (i_ptr->tval <= 36)))
  44.     {    /* Weapons and armor    */
  45.       if (index(i_ptr->name, '^') != 0)
  46.     value = search_list(i_ptr->tval, i_ptr->subval) * i_ptr->number;
  47.       else if ((i_ptr->tval >= 20) && (i_ptr->tval <= 23))
  48.     {
  49.       if (i_ptr->tohit < 0)
  50.         value = 0;
  51.       else if (i_ptr->todam < 0)
  52.         value = 0;
  53.       else if (i_ptr->toac < 0)
  54.         value = 0;
  55.       else
  56.         value = (i_ptr->cost+(i_ptr->tohit+i_ptr->todam+i_ptr->toac)*100)*
  57.           i_ptr->number;
  58.     }
  59.       else
  60.     {
  61.       if (i_ptr->toac < 0)
  62.         value = 0;
  63.       else
  64.         value = (i_ptr->cost+i_ptr->toac*100)*i_ptr->number;
  65.     }
  66.     }
  67.   else if ((i_ptr->tval >= 10) && (i_ptr->tval <= 13))
  68.     {    /* Ammo            */
  69.       if (index(i_ptr->name, '^') != 0)
  70.     value = search_list(i_ptr->tval, 1)*i_ptr->number;
  71.       else
  72.     {
  73.       if (i_ptr->tohit < 0)
  74.         value = 0;
  75.       else if (i_ptr->todam < 0)
  76.         value = 0;
  77.       else if (i_ptr->toac < 0)
  78.         value = 0;
  79.       else
  80.         value = (i_ptr->cost+(i_ptr->tohit+i_ptr->todam+i_ptr->toac)*10)*
  81.           i_ptr->number;
  82.     }
  83.     }
  84.   else if ((i_ptr->tval == 70) || (i_ptr->tval == 71) ||
  85.        (i_ptr->tval == 75) || (i_ptr->tval == 76) || (i_ptr->tval == 80))
  86.     {    /* Potions, Scrolls, and Food    */
  87.       if (index(i_ptr->name, '|') != 0)
  88.     switch(i_ptr->tval)
  89.       {
  90.       case 70: case 71: value =  20; break;
  91.       case 75: case 76: value =  20; break;
  92.       case 80:          value =   1; break;
  93.       default:          break;
  94.       }
  95.     }
  96.   else if ((i_ptr->tval == 40) || (i_ptr->tval == 45))
  97.     {    /* Rings and amulets    */
  98.       if (index(i_ptr->name, '|') != 0)
  99.     /* player does not know what type of ring/amulet this is */
  100.     switch(i_ptr->tval)
  101.       {
  102.       case 40: value = 45; break;
  103.       case 45: value = 45; break;
  104.       default: break;
  105.       }
  106.       else if (index(i_ptr->name, '^') != 0)
  107.     /* player knows what type of ring, but does not know whether it is
  108.        cursed or not, if refuse to buy cursed objects here, then
  109.        player can use this to 'identify' cursed objects */
  110.     value = (i_ptr->cost < 0) ? (- i_ptr->cost) : (i_ptr->cost);
  111.     }
  112.   else if ((i_ptr->tval == 55) || (i_ptr->tval == 60) || (i_ptr->tval == 65))
  113.     {    /* Wands rods, and staffs*/
  114.       if (index(i_ptr->name, '|') != 0)
  115.     switch(i_ptr->tval)
  116.       {
  117.       case 55: value = 70; break;
  118.       case 60: value = 60; break;
  119.       case 65: value = 50; break;
  120.       default: break;
  121.       }
  122.       else if (index(i_ptr->name, '^') == 0)
  123.     {
  124.       value = i_ptr->cost + (i_ptr->cost/20.0)*i_ptr->p1;
  125.     }
  126.     }
  127.   return(value);
  128. }
  129.  
  130.  
  131. /* Asking price for an item                -RAK-    */
  132. bigint_t sell_price(snum, max_sell, min_sell, item)
  133. int snum;
  134. bigint_t *max_sell, *min_sell;
  135. treasure_type item;
  136. {
  137.   register bigint_t i;
  138.   register store_type *s_ptr;
  139.  
  140.   s_ptr = &store[snum];
  141.   i = item_value(item);
  142.   if (item.cost > 0)
  143.     {
  144.       i += (i * rgold_adj[owners[s_ptr->owner].owner_race][py.misc.prace]);
  145.       if (i < 1)  i = 1;
  146.       *max_sell = (i * (1+owners[s_ptr->owner].max_inflate));
  147.       *min_sell = (i * (1+owners[s_ptr->owner].min_inflate));
  148.       if (min_sell > max_sell)  min_sell = max_sell;
  149.       return(i);
  150.     }
  151.   else
  152.     {
  153.       *max_sell = 0;
  154.       *min_sell = 0;
  155.       return(i);
  156.     }
  157. }
  158.  
  159.  
  160. /* Check to see if he will be carrying too many objects    -RAK-    */
  161. int store_check_num(store_num)
  162. int store_num;
  163. {
  164.   register int store_check;
  165.   register int i;
  166.   register store_type *s_ptr;
  167.   register treasure_type *i_ptr;
  168.  
  169.   store_check = FALSE;
  170.   s_ptr = &store[store_num];
  171.   if (s_ptr->store_ctr < STORE_INVEN_MAX)
  172.     store_check = TRUE;
  173.   else if ((inventory[INVEN_MAX].subval > 255) &&
  174.        (inventory[INVEN_MAX].subval < 512))
  175.     for (i = 0; i < s_ptr->store_ctr; i++)
  176.       {
  177.     i_ptr = &s_ptr->store_inven[i].sitem;
  178.     if (i_ptr->tval == inventory[INVEN_MAX].tval)
  179.       if (i_ptr->subval == inventory[INVEN_MAX].subval)
  180.         store_check = TRUE;
  181.       }
  182.   return(store_check);
  183. }
  184.  
  185.  
  186. /* Insert INVEN_MAX at given location    */
  187. insert_store(store_num, pos, icost)
  188. register int pos;
  189. int store_num; bigint_t icost;
  190. {
  191.   register int i;
  192.   register store_type *s_ptr;
  193.  
  194.   s_ptr = &store[store_num];
  195.   for (i = s_ptr->store_ctr-1; i >= pos; i--)
  196.     s_ptr->store_inven[i+1] = s_ptr->store_inven[i];
  197.   s_ptr->store_inven[pos].sitem = inventory[INVEN_MAX];
  198.   s_ptr->store_inven[pos].scost = -icost;
  199.   s_ptr->store_ctr++;
  200. }
  201.  
  202.  
  203. /* Add the item in INVEN_MAX to stores inventory.    -RAK-    */
  204. store_carry(store_num, ipos)
  205. int store_num;
  206. int *ipos;
  207. {
  208.   int item_num, item_val;
  209.   register int typ, subt;
  210.   bigint_t icost, dummy; int flag;
  211.   register treasure_type *i_ptr;
  212.   register store_type *s_ptr;
  213.  
  214.   *ipos = 0;
  215.   identify(inventory[INVEN_MAX]);
  216.   known2(inventory[INVEN_MAX].name);
  217.   (void) sell_price(store_num, &icost, &dummy, inventory[INVEN_MAX]);
  218.   if (icost > 0)
  219.     {
  220.       i_ptr = &inventory[INVEN_MAX];
  221.       s_ptr = &store[store_num];
  222.       item_val = 0;
  223.       item_num = i_ptr->number;
  224.       flag = FALSE;
  225.       typ  = i_ptr->tval;
  226.       subt = i_ptr->subval;
  227.       do
  228.     {
  229.       i_ptr = &s_ptr->store_inven[item_val].sitem;
  230.       if (typ == i_ptr->tval)
  231.         {
  232.           if (subt == i_ptr->subval) /* Adds to other item    */
  233.         if (subt > 255)
  234.           {
  235.             if (i_ptr->number < 24)
  236.               i_ptr->number += item_num;
  237.             flag = TRUE;
  238.           }
  239.         }
  240.       else if (typ > i_ptr->tval)
  241.         {        /* Insert into list        */
  242.           insert_store(store_num, item_val, icost);
  243.           flag = TRUE;
  244.           *ipos = item_val;
  245.         }
  246.       item_val++;
  247.     }
  248.       while ((item_val < s_ptr->store_ctr) && (!flag));
  249.       if (!flag)     /* Becomes last item in list    */
  250.     {
  251.       insert_store(store_num, (int)s_ptr->store_ctr, icost);
  252.       *ipos = s_ptr->store_ctr - 1;
  253.     }
  254.     }
  255. }
  256.  
  257. /* Destroy an item in the stores inventory.  Note that if    */
  258. /* "one_of" is false, an entire slot is destroyed    -RAK-    */
  259. store_destroy(store_num, item_val, one_of)
  260. int store_num, item_val;
  261. int one_of;
  262. {
  263.   register int j;
  264.   register store_type *s_ptr;
  265.   register treasure_type *i_ptr;
  266.  
  267.   s_ptr = &store[store_num];
  268.   inventory[INVEN_MAX] = s_ptr->store_inven[item_val].sitem;
  269.   i_ptr = &s_ptr->store_inven[item_val].sitem;
  270.   if ((i_ptr->number > 1) && (i_ptr->subval < 512) && (one_of))
  271.     {
  272.       i_ptr->number--;
  273.       inventory[INVEN_MAX].number = 1;
  274.     }
  275.   else
  276.     {
  277.       for (j = item_val; j < s_ptr->store_ctr-1; j++)
  278.     s_ptr->store_inven[j] = s_ptr->store_inven[j+1];
  279.       s_ptr->store_inven[s_ptr->store_ctr-1].sitem = blank_treasure;
  280.       s_ptr->store_inven[s_ptr->store_ctr-1].scost = 0;
  281.       s_ptr->store_ctr--;
  282.     }
  283. }
  284.  
  285.  
  286. /* Initializes the stores with owners            -RAK-    */
  287. store_init()
  288. {
  289.   register int i, j, k;
  290.   register store_type *s_ptr;
  291.  
  292.   i = MAX_OWNERS / MAX_STORES;
  293.   for (j = 0; j < MAX_STORES; j++)
  294.     {
  295.       s_ptr = &store[j];
  296.       s_ptr->owner = MAX_STORES*(randint(i)-1) + j;
  297.       s_ptr->insult_cur = 0;
  298.       s_ptr->store_open = 0;
  299.       s_ptr->store_ctr  = 0;
  300.       for (k = 0; k < STORE_INVEN_MAX; k++)
  301.     {
  302.       s_ptr->store_inven[k].sitem = blank_treasure;
  303.       s_ptr->store_inven[k].scost = 0;
  304.     }
  305.     }
  306. }
  307.  
  308.  
  309. /* Creates an item and inserts it into store's inven    -RAK-    */
  310. store_create(store_num)
  311. int store_num;
  312. {
  313.   register int i, tries;
  314.   int cur_pos, dummy;
  315.   register store_type *s_ptr;
  316.   register treasure_type *t_ptr;
  317.  
  318.   tries = 0;
  319.   popt(&cur_pos);
  320.   s_ptr = &store[store_num];
  321.   do
  322.     {
  323.       i = store_choice[store_num][randint(STORE_CHOICES)-1];
  324.       /* this index is one more than it should be, so subtract one */
  325.       /* see store_choice in variables.c */
  326.       t_list[cur_pos] = inventory_init[i-1];
  327.       magic_treasure(cur_pos, OBJ_TOWN_LEVEL);
  328.       inventory[INVEN_MAX] = t_list[cur_pos];
  329.       if (store_check_num(store_num))
  330.     {
  331.       t_ptr = &t_list[cur_pos];
  332.       if (t_ptr->cost > 0)     /* Item must be good    */
  333.         if (t_ptr->cost < owners[s_ptr->owner].max_cost)
  334.           {
  335.         store_carry(store_num, &dummy);
  336.         tries = 10;
  337.           }
  338.     }
  339.       tries++;
  340.     }
  341.   while (tries <= 3);
  342.   pusht(cur_pos);
  343. }
  344.  
  345.  
  346. /* Initialize and up-keep the store's inventory.        -RAK-    */
  347. store_maint()
  348. {
  349.   register int i, j;
  350.   register store_type *s_ptr;
  351.  
  352.   for (i = 0; i < MAX_STORES; i++)
  353.     {
  354.       s_ptr = &store[i];
  355.       s_ptr->insult_cur = 0;
  356.       if (s_ptr->store_ctr > STORE_MAX_INVEN)
  357.     for (j = 0; j < (s_ptr->store_ctr-STORE_MAX_INVEN+2); j++)
  358.       store_destroy(i, randint((int)s_ptr->store_ctr)-1, FALSE);
  359.       else if (s_ptr->store_ctr < STORE_MIN_INVEN)
  360.     {
  361.       for (j = 0; j < (STORE_MIN_INVEN-s_ptr->store_ctr+2); j++)
  362.         store_create(i);
  363.     }
  364.       else
  365.     {
  366.       for (j = 0; j < (1+randint(STORE_TURN_AROUND)); j++)
  367.         store_destroy(i, randint((int)s_ptr->store_ctr)-1, TRUE);
  368.       for (j = 0; j < (1+randint(STORE_TURN_AROUND)); j++)
  369.         store_create(i);
  370.     }
  371.     }
  372. }
  373.