home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / larn / global.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-03-05  |  15.1 KB  |  622 lines
  1. /*    global.c         Larn is copyrighted 1986 by Noah Morgan.
  2.  *
  3.  *    raiselevel()        subroutine to raise the player one level
  4.  *    loselevel()        subroutine to lower the player by one level
  5.  *    raiseexperience(x)    subroutine to increase experience points
  6.  *    loseexperience(x)    subroutine to lose experience points
  7.  *    losehp(x)            subroutine to remove hit points from the player
  8.  *    losemhp(x)            subroutine to remove max # hit points from the player
  9.  *    raisehp(x)            subroutine to gain hit points
  10.  *    raisemhp(x)            subroutine to gain maximum hit points
  11.  *    losespells(x)        subroutine to lose spells
  12.  *    losemspells(x)        subroutine to lose maximum spells
  13.  *    raisespells(x)        subroutine to gain spells
  14.  *    raisemspells(x)        subroutine to gain maximum spells
  15.  *    recalc()            function to recalculate the armor class of the player
  16.  *    makemonst(lev)        function to return monster number for a randomly selected monster
  17.  *    positionplayer()    function to be sure player is not in a wall
  18.  *    quit()                subroutine to ask if the player really wants to quit
  19.  */
  20.  
  21. #include "header.h"
  22. extern int score[],srcount,dropflag;
  23. extern int random;/*    the random number seed            */
  24. extern short playerx,playery,lastnum;
  25. extern char cheat,level,monstnamelist[];
  26. extern char lastmonst[],*what[],*who[]; 
  27. extern char winner[];
  28. extern char logname[],monstlevel[];
  29. extern char sciv[SCORESIZE+1][26][2],*potionname[],*scrollname[];
  30. /*
  31.     ***********
  32.     RAISE LEVEL
  33.     ***********
  34.     raiselevel()
  35.  
  36.     subroutine to raise the player one level
  37.     uses the skill[] array to find level boundarys
  38.     uses c[EXPERIENCE]  c[LEVEL]
  39.  */
  40. raiselevel()
  41.     {
  42.     if (c[LEVEL] < MAXPLEVEL) raiseexperience((long)(skill[c[LEVEL]]-c[EXPERIENCE]));
  43.     }
  44.  
  45. /*
  46.     ***********
  47.     LOOSE LEVEL
  48.     ***********
  49.     loselevel()
  50.  
  51.     subroutine to lower the players character level by one
  52.  */
  53. loselevel()
  54.     {
  55.     if (c[LEVEL] > 1) loseexperience((long)(c[EXPERIENCE] - skill[c[LEVEL]-1] + 1));
  56.     }
  57.  
  58. /*
  59.     ****************
  60.     RAISE EXPERIENCE
  61.     ****************
  62.     raiseexperience(x)
  63.  
  64.     subroutine to increase experience points
  65.  */
  66. raiseexperience(x)
  67.     register long x;
  68.     {
  69.     register int i,tmp;
  70.     i=c[LEVEL];    c[EXPERIENCE]+=x;
  71.     while (c[EXPERIENCE] >= skill[c[LEVEL]] && (c[LEVEL] < MAXPLEVEL))
  72.         {
  73.         tmp = (c[CONSTITUTION]-c[HARDGAME])>>1;
  74.         c[LEVEL]++;    raisemhp((int)(rnd(3)+rnd((tmp>0)?tmp:1)));
  75.         raisemspells((int)rund(3));
  76.         if (c[LEVEL] < 7-c[HARDGAME]) raisemhp((int)(c[CONSTITUTION]>>2));
  77.         }
  78.     if (c[LEVEL] != i)
  79.         {
  80.         cursors();
  81.         beep(); lprintf("\nWelcome to level %d",(long)c[LEVEL]);    /* if we changed levels    */
  82.         }
  83.     bottomline();
  84.     }
  85.  
  86. /*
  87.     ****************
  88.     LOOSE EXPERIENCE
  89.     ****************
  90.     loseexperience(x)
  91.  
  92.     subroutine to lose experience points
  93.  */
  94. loseexperience(x)
  95.     register long x;
  96.     {
  97.     register int i,tmp;
  98.     i=c[LEVEL];        c[EXPERIENCE]-=x;
  99.     if (c[EXPERIENCE] < 0) c[EXPERIENCE]=0;
  100.     while (c[EXPERIENCE] < skill[c[LEVEL]-1])
  101.         {
  102.         if (--c[LEVEL] <= 1) c[LEVEL]=1;    /*    down one level        */
  103.         tmp = (c[CONSTITUTION]-c[HARDGAME])>>1;    /* lose hpoints */
  104.         losemhp((int)rnd((tmp>0)?tmp:1));    /* lose hpoints */
  105.         if (c[LEVEL] < 7-c[HARDGAME]) losemhp((int)(c[CONSTITUTION]>>2));
  106.         losemspells((int)rund(3));                /*    lose spells        */
  107.         }
  108.     if (i!=c[LEVEL])
  109.         {
  110.         cursors();
  111.         beep(); lprintf("\nYou went down to level %d!",(long)c[LEVEL]);
  112.         }
  113.     bottomline();
  114.     }
  115.  
  116. /*
  117.     ********
  118.     LOOSE HP
  119.     ********
  120.     losehp(x)
  121.     losemhp(x)
  122.  
  123.     subroutine to remove hit points from the player
  124.     warning -- will kill player if hp goes to zero
  125.  */
  126. losehp(x)
  127.     register int x;
  128.     {
  129.     if ((c[HP] -= x) <= 0)
  130.         {
  131.         beep(); lprcat("\n");  nap(3000);  died(lastnum);
  132.         }
  133.     }
  134.  
  135. losemhp(x)
  136.     register int x;
  137.     {
  138.     c[HP] -= x;        if (c[HP] < 1)        c[HP]=1;
  139.     c[HPMAX] -= x;    if (c[HPMAX] < 1)    c[HPMAX]=1;
  140.     }
  141.  
  142. /*
  143.     ********
  144.     RAISE HP
  145.     ********
  146.     raisehp(x)
  147.     raisemhp(x)
  148.  
  149.     subroutine to gain maximum hit points
  150.  */
  151. raisehp(x)
  152.     register int x;
  153.     {
  154.     if ((c[HP] += x) > c[HPMAX]) c[HP] = c[HPMAX];
  155.     }
  156.  
  157. raisemhp(x)
  158.     register int x;
  159.     {
  160.     c[HPMAX] += x;    c[HP] += x;
  161.     }
  162.  
  163. /*
  164.     ************
  165.     RAISE SPELLS
  166.     ************
  167.     raisespells(x)
  168.     raisemspells(x)
  169.  
  170.     subroutine to gain maximum spells
  171.  */
  172. raisespells(x)
  173.     register int x;
  174.     {
  175.     if ((c[SPELLS] += x) > c[SPELLMAX])    c[SPELLS] = c[SPELLMAX];
  176.     }
  177.  
  178. raisemspells(x)
  179.     register int x;
  180.     {
  181.     c[SPELLMAX]+=x; c[SPELLS]+=x;
  182.     }
  183.  
  184. /*
  185.     ************
  186.     LOOSE SPELLS
  187.     ************
  188.     losespells(x)
  189.     losemspells(x)
  190.  
  191.     subroutine to lose maximum spells
  192.  */
  193. losespells(x)
  194.     register int x;
  195.     {
  196.     if ((c[SPELLS] -= x) < 0) c[SPELLS]=0;
  197.     }
  198.  
  199. losemspells(x)
  200.     register int x;
  201.     {
  202.     if ((c[SPELLMAX] -= x) < 0) c[SPELLMAX]=0;
  203.     if ((c[SPELLS] -= x) < 0) c[SPELLS]=0;
  204.     }
  205.  
  206. /*
  207.     makemonst(lev)
  208.         int lev;
  209.  
  210.     function to return monster number for a randomly selected monster
  211.         for the given cave level    
  212.  */
  213. makemonst(lev)
  214.     register int lev;
  215.     {
  216.     register int tmp,x;
  217.     if (lev < 1)    lev = 1;            if (lev > 12)    lev = 12;
  218.     tmp=WATERLORD;
  219.     if (lev < 5)
  220.         while (tmp==WATERLORD) tmp=rnd((x=monstlevel[lev-1])?x:1);
  221.     else while (tmp==WATERLORD)
  222.         tmp=rnd((x=monstlevel[lev-1]-monstlevel[lev-4])?x:1)+monstlevel[lev-4];
  223.  
  224.     while (monster[tmp].genocided && tmp<MAXMONST) tmp++; /* genocided? */
  225.     return(tmp);
  226.     }
  227.  
  228. /*
  229.     positionplayer()
  230.  
  231.     function to be sure player is not in a wall
  232.  */
  233. positionplayer()
  234.     {
  235.     int try;
  236.     try = 2;
  237.     while ((item[playerx][playery] || mitem[playerx][playery]) && (try))
  238.         if (++playerx >= MAXX-1)
  239.             {
  240.             playerx = 1;
  241.             if (++playery >= MAXY-1)
  242.                 {    playery = 1;    --try;    }
  243.             }
  244.     if (try==0)     lprcat("Failure in positionplayer\n");
  245.     }
  246.  
  247. /*
  248.     recalc()    function to recalculate the armor class of the player
  249.  */
  250. recalc()
  251.     {
  252.     register int i,j,k;
  253.     c[AC] = c[MOREDEFENSES];
  254.     if (c[WEAR] >= 0)  
  255.         switch(iven[c[WEAR]])
  256.             {
  257.             case OSHIELD:        c[AC] += 2 + ivenarg[c[WEAR]]; break;
  258.             case OLEATHER:        c[AC] += 2 + ivenarg[c[WEAR]]; break;
  259.             case OSTUDLEATHER:    c[AC] += 3 + ivenarg[c[WEAR]]; break;
  260.             case ORING:            c[AC] += 5 + ivenarg[c[WEAR]]; break;
  261.             case OCHAIN:        c[AC] += 6 + ivenarg[c[WEAR]]; break;
  262.             case OSPLINT:        c[AC] += 7 + ivenarg[c[WEAR]]; break;
  263.             case OPLATE:        c[AC] += 9 + ivenarg[c[WEAR]]; break;
  264.             case OPLATEARMOR:    c[AC] += 10 + ivenarg[c[WEAR]]; break;
  265.             case OSSPLATE:        c[AC] += 12 + ivenarg[c[WEAR]]; break;
  266.             }
  267.  
  268.     if (c[SHIELD] >= 0) if (iven[c[SHIELD]] == OSHIELD) c[AC] += 2 + ivenarg[c[SHIELD]];
  269.     if (c[WIELD] < 0)  c[WCLASS] = 0;  else
  270.         {
  271.         i = ivenarg[c[WIELD]];
  272.         switch(iven[c[WIELD]])
  273.             {
  274.             case ODAGGER:    c[WCLASS] =  3 + i;  break;
  275.             case OBELT:         c[WCLASS] =  7 + i;  break;
  276.             case OSHIELD:     c[WCLASS] =  8 + i;  break;
  277.             case OSPEAR:     c[WCLASS] = 10 + i;  break;
  278.             case OFLAIL:     c[WCLASS] = 14 + i;  break;
  279.             case OBATTLEAXE: c[WCLASS] = 17 + i;  break;
  280.             case OLANCE:     c[WCLASS] = 19 + i;  break;
  281.             case OLONGSWORD: c[WCLASS] = 22 + i;  break;
  282.             case O2SWORD:    c[WCLASS] = 26 + i;  break;
  283.             case OSWORD:     c[WCLASS] = 32 + i;  break;
  284.             case OSWORDofSLASHING: c[WCLASS] = 30 + i; break;
  285.             case OHAMMER:    c[WCLASS] = 35 + i;  break;
  286.             default:         c[WCLASS] = 0;
  287.             }
  288.         }
  289.     c[WCLASS] += c[MOREDAM];
  290.  
  291. /*    now for regeneration abilities based on rings    */
  292.     c[REGEN]=1;        c[ENERGY]=0;
  293.     j=0;  for (k=25; k>0; k--)  if (iven[k]) {j=k; k=0; }
  294.     for (i=0; i<=j; i++)
  295.         {
  296.         switch(iven[i])
  297.             {
  298.             case OPROTRING: c[AC]     += ivenarg[i] + 1;    break;
  299.             case ODAMRING:  c[WCLASS] += ivenarg[i] + 1;    break;
  300.             case OBELT:     c[WCLASS] += ((ivenarg[i]<<1)) + 2;    break;
  301.  
  302.             case OREGENRING:    c[REGEN]  += ivenarg[i] + 1;    break;
  303.             case ORINGOFEXTRA:    c[REGEN]  += 5 * (ivenarg[i]+1); break;
  304.             case OENERGYRING:    c[ENERGY] += ivenarg[i] + 1;    break;
  305.             }
  306.         }
  307.     }
  308.  
  309.  
  310. /*
  311.     quit()
  312.  
  313.     subroutine to ask if the player really wants to quit
  314.  */
  315. quit()
  316.     {
  317.     register int i;
  318.     cursors();    strcpy(lastmonst,"");
  319.     lprcat("\n\nDo you really want to quit?");
  320.     while (1)
  321.         {
  322.         i=getchar();
  323.         if (i == 'y')    { died(300); return; }
  324.         if ((i == 'n') || (i == '\33'))    { lprcat(" no"); lflush(); return; }
  325.         lprcat("\n");  setbold();  lprcat("Yes");  resetbold();  lprcat(" or ");
  326.         setbold();  lprcat("No");  resetbold();  lprcat(" please?   Do you want to quit? ");
  327.         }    
  328.     }
  329.  
  330. /*
  331.     function to ask --more-- then the user must enter a space
  332.  */
  333. more()
  334.     {
  335.     lprcat("\n  --- press ");  standout("space");  lprcat(" to continue --- ");
  336.     while (getchar() != ' ');
  337.     }
  338.  
  339. /*
  340.     function to put something in the players inventory
  341.     returns 0 if success, 1 if a failure
  342.  */
  343. take(itm,arg)
  344.     int itm,arg;
  345.     {
  346.     register int i,limit;
  347. /*    cursors(); */
  348.     if ((limit = 15+(c[LEVEL]>>1)) > 26)  limit=26;
  349.     for (i=0; i<limit; i++)
  350.         if (iven[i]==0)
  351.             {
  352.             iven[i] = itm;  ivenarg[i] = arg;  limit=0;
  353.             switch(itm)
  354.                 {
  355.                 case OPROTRING:    case ODAMRING: case OBELT: limit=1;  break;
  356.                 case ODEXRING:        c[DEXTERITY] += ivenarg[i]+1; limit=1;    break;
  357.                 case OSTRRING:        c[STREXTRA]  += ivenarg[i]+1;    limit=1; break;
  358.                 case OCLEVERRING:    c[INTELLIGENCE] += ivenarg[i]+1;  limit=1; break;
  359.                 case OHAMMER:        c[DEXTERITY] += 10;    c[STREXTRA]+=10;
  360.                                     c[INTELLIGENCE]-=10;    limit=1;     break;
  361.  
  362.                 case OORBOFDRAGON:    c[SLAYING]++;        break;
  363.                 case OSPIRITSCARAB: c[NEGATESPIRIT]++;    break;
  364.                 case OCUBEofUNDEAD: c[CUBEofUNDEAD]++;    break;
  365.                 case ONOTHEFT:        c[NOTHEFT]++;        break;
  366.                 case OSWORDofSLASHING:    c[DEXTERITY] +=5;    limit=1; break;
  367.                 };
  368.             lprcat("\nYou pick up:"); srcount=0;  show3(i);
  369.             if (limit) bottomline();  return(0);
  370.             }
  371.     lprcat("\nYou can't carry anything else");  return(1);
  372.     }
  373.  
  374. /*
  375.     subroutine to drop an object  returns 1 if something there already else 0
  376.  */
  377. drop_object(k)
  378.     int k;
  379.     {
  380.     int itm;
  381.     if ((k<0) || (k>25)) return(0);
  382.     itm = iven[k];    cursors();
  383.     if (itm==0) { lprintf("\nYou don't have item %c! ",k+'a'); return(1); }
  384.     if (item[playerx][playery])
  385.         { beep(); lprcat("\nThere's something here already"); return(1); }
  386.     if (playery==MAXY-1 && playerx==33) return(1); /* not in entrance */
  387.     item[playerx][playery] = itm;
  388.     iarg[playerx][playery] = ivenarg[k];
  389.     srcount=0; lprcat("\n  You drop:"); show3(k); /* show what item you dropped*/
  390.     know[playerx][playery] = 0;  iven[k]=0; 
  391.     if (c[WIELD]==k) c[WIELD]= -1;        if (c[WEAR]==k)  c[WEAR] = -1;
  392.     if (c[SHIELD]==k) c[SHIELD]= -1;
  393.     adjustcvalues(itm,ivenarg[k]);
  394.     dropflag=1; /* say dropped an item so wont ask to pick it up right away */
  395.     return(0);
  396.     }
  397.  
  398. /*
  399.     function to enchant armor player is currently wearing
  400.  */
  401. enchantarmor()
  402.     {
  403.     register int tmp;
  404.     if (c[WEAR]<0) { if (c[SHIELD] < 0)
  405.         { cursors(); beep(); lprcat("\nYou feel a sense of loss"); return; }
  406.                     else { tmp=iven[c[SHIELD]]; if (tmp != OSCROLL) if (tmp != OPOTION) { ivenarg[c[SHIELD]]++; bottomline(); } } }
  407.     tmp = iven[c[WEAR]];
  408.     if (tmp!=OSCROLL) if (tmp!=OPOTION)  { ivenarg[c[WEAR]]++;  bottomline(); }
  409.     }
  410.  
  411. /*
  412.     function to enchant a weapon presently being wielded
  413.  */
  414. enchweapon()
  415.     {
  416.     register int tmp;
  417.     if (c[WIELD]<0)
  418.         { cursors(); beep(); lprcat("\nYou feel a sense of loss"); return; }
  419.     tmp = iven[c[WIELD]];
  420.     if (tmp!=OSCROLL) if (tmp!=OPOTION)
  421.         { ivenarg[c[WIELD]]++;
  422.           if (tmp==OCLEVERRING) c[INTELLIGENCE]++;  else
  423.           if (tmp==OSTRRING)    c[STREXTRA]++;  else
  424.           if (tmp==ODEXRING)    c[DEXTERITY]++;          bottomline(); }
  425.     }
  426.  
  427. /*
  428.     routine to tell if player can carry one more thing
  429.     returns 1 if pockets are full, else 0
  430.  */
  431. pocketfull()
  432.     {
  433.     register int i,limit; 
  434.     if ((limit = 15+(c[LEVEL]>>1)) > 26)  limit=26;
  435.     for (i=0; i<limit; i++) if (iven[i]==0) return(0);
  436.     return(1);
  437.     }
  438.  
  439. /*
  440.     function to return 1 if a monster is next to the player else returns 0
  441.  */
  442. nearbymonst()
  443.     {
  444.     register int tmp,tmp2;
  445.     for (tmp=playerx-1; tmp<playerx+2; tmp++)
  446.         for (tmp2=playery-1; tmp2<playery+2; tmp2++)
  447.             if (mitem[tmp][tmp2]) return(1); /* if monster nearby */
  448.     return(0);
  449.     }
  450.  
  451. /*
  452.     function to steal an item from the players pockets
  453.     returns 1 if steals something else returns 0
  454.  */
  455. stealsomething()
  456.     {
  457.     register int i,j;
  458.     j=100;
  459.     while (1)
  460.         {
  461.         i=rund(26);
  462.         if (iven[i]) if (c[WEAR]!=i) if (c[WIELD]!=i) if (c[SHIELD]!=i)
  463.             {
  464.             srcount=0; show3(i);
  465.             adjustcvalues(iven[i],ivenarg[i]);  iven[i]=0; return(1);
  466.             }
  467.         if (--j <= 0) return(0);
  468.         }
  469.     }
  470.  
  471. /*
  472.     function to return 1 is player carrys nothing else return 0
  473.  */
  474. emptyhanded()
  475.     {
  476.     register int i;
  477.     for (i=0; i<26; i++)
  478.         if (iven[i]) if (i!=c[WIELD]) if (i!=c[WEAR]) if (i!=c[SHIELD]) return(0);
  479.     return(1);
  480.     }
  481.  
  482. /*
  483.     function to create a gem on a square near the player
  484.  */
  485. creategem()
  486.     {
  487.     register int i,j;
  488.     switch(rnd(4))
  489.         {
  490.         case 1:     i=ODIAMOND;    j=50;    break;
  491.         case 2:     i=ORUBY;        j=40;    break;
  492.         case 3:     i=OEMERALD;    j=30;    break;
  493.         default: i=OSAPPHIRE;    j=20;    break;
  494.         };
  495.     createitem(i,rnd(j)+j/10);
  496.     }
  497.  
  498. /*
  499.     function to change character levels as needed when dropping an object
  500.     that affects these characteristics
  501.  */
  502. adjustcvalues(itm,arg)
  503.     int itm,arg;
  504.     {
  505.     register int flag;
  506.     flag=0;
  507.     switch(itm)
  508.         {
  509.         case ODEXRING:    c[DEXTERITY] -= arg+1;  flag=1; break;
  510.         case OSTRRING:    c[STREXTRA]  -= arg+1;  flag=1; break;
  511.         case OCLEVERRING: c[INTELLIGENCE] -= arg+1;  flag=1; break;
  512.         case OHAMMER:    c[DEXTERITY] -= 10;    c[STREXTRA] -= 10;
  513.                         c[INTELLIGENCE] += 10; flag=1; break;
  514.         case OSWORDofSLASHING:    c[DEXTERITY] -= 5;    flag=1; break;
  515.         case OORBOFDRAGON:        --c[SLAYING];        return;
  516.         case OSPIRITSCARAB:        --c[NEGATESPIRIT];    return;
  517.         case OCUBEofUNDEAD:        --c[CUBEofUNDEAD];    return;
  518.         case ONOTHEFT:            --c[NOTHEFT];         return;
  519.         case OLANCE:        c[LANCEDEATH]=0;    return;
  520.         case OPOTION:    case OSCROLL:    return;
  521.  
  522.         default:    flag=1;
  523.         };
  524.     if (flag) bottomline();
  525.     }
  526.  
  527. /*
  528.     function to read a string from token input "string"
  529.     returns a pointer to the string
  530.  */
  531. gettokstr(str)
  532.     register char *str;
  533.     {
  534.     register int i,j;
  535.     i=50;
  536.     while ((getchar() != '"') && (--i > 0));
  537.     i=36;
  538.     while (--i > 0)
  539.         {
  540.         if ((j=getchar()) != '"') *str++ = j;  else i=0;
  541.         }
  542.     *str = 0;
  543.     i=50;
  544.     if (j != '"') while ((getchar() != '"') && (--i > 0)); /* if end due to too long, then find closing quote */
  545.     }
  546.  
  547. /*
  548.     function to ask user for a password (no echo)
  549.     returns 1 if entered correctly, 0 if not
  550.  */
  551. static char gpwbuf[33];
  552. getpassword()
  553.     {
  554.     register int i,j;
  555.     register char *gpwp;
  556.     extern char *password;
  557.     scbr();    /*    system("stty -echo cbreak"); */
  558.     gpwp = gpwbuf;    lprcat("\nEnter Password: "); lflush();
  559.     i = strlen(password);
  560.     for (j=0; j<i; j++) read(0,gpwp++,1);      gpwbuf[i]=0;
  561.     sncbr(); /* system("stty echo -cbreak"); */
  562.     if (strcmp(gpwbuf,password) != 0)
  563.         {    lprcat("\nSorry\n");  lflush(); return(0);    }
  564.     else  return(1);
  565.     }
  566.  
  567. /*
  568.     subroutine to get a yes or no response from the user
  569.     returns y or n
  570.  */
  571. getyn()
  572.     {
  573.     register int i;
  574.     i=0; while (i!='y' && i!='n' && i!='\33') i=getchar();
  575.     return(i);
  576.     }
  577.  
  578. /*
  579.     function to calculate the pack weight of the player
  580.     returns the number of pounds the player is carrying
  581.  */
  582. packweight()
  583.     {
  584.     register int i,j,k;
  585.     k=c[GOLD]/1000; j=25;  while ((iven[j]==0) && (j>0)) --j;
  586.     for (i=0; i<=j; i++)
  587.         switch(iven[i])
  588.             {
  589.             case 0:                                                break;
  590.             case OSSPLATE:   case OPLATEARMOR:        k += 40;    break;
  591.             case OPLATE:                            k += 35;    break;
  592.             case OHAMMER:                            k += 30;    break;
  593.             case OSPLINT:                            k += 26;    break;
  594.             case OSWORDofSLASHING:    case OCHAIN:
  595.             case OBATTLEAXE:           case O2SWORD:    k += 23;    break;
  596.             case OLONGSWORD:           case OSWORD:
  597.             case ORING:                case OFLAIL:    k += 20;    break;
  598.             case OLANCE:         case OSTUDLEATHER:    k += 15;    break;
  599.             case OLEATHER:           case OSPEAR:    k += 8;        break;
  600.             case OORBOFDRAGON:       case OBELT:        k += 4;        break;
  601.             case OSHIELD:                            k += 7;        break;
  602.             case OCHEST:        k += 30 + ivenarg[i];            break;
  603.             default:                                k++;
  604.             };
  605.     return(k);
  606.     }
  607.  
  608. #ifndef MACRORND
  609.     /* macros to generate random numbers   1<=rnd(N)<=N   0<=rund(N)<=N-1 */
  610. rnd(x)
  611.     int x;
  612.     {
  613.     return((((randx=randx*1103515245+12345)>>7)%(x))+1);
  614.     }
  615.  
  616. rund(x)
  617.     int x;
  618.     {
  619.     return((((randx=randx*1103515245+12345)>>7)%(x))  );
  620.     }
  621. #endif MACRORND
  622.