Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10 5/3/83; site cmu-cs-cad.ARPA
Path: utzoo!watmath!clyde!burl!ulysses!allegra!mit-eddie!godot!harvard!seismo!rochester!cmu-cs-pt!cmu-cs-cad!mlm
From: mlm@cmu-cs-cad.ARPA (Michael Mauldin)
Newsgroups: net.sources
Subject: Rog-O-Matic XIV (part 08 of 10)
Message-ID: <271@cmu-cs-cad.ARPA>
Date: Fri, 1-Feb-85 11:32:08 EST
Article-I.D.: cmu-cs-c.271
Posted: Fri Feb  1 11:32:08 1985
Date-Received: Sun, 3-Feb-85 09:32:24 EST
Organization: Carnegie-Mellon University, CS/RI
Lines: 1463

#!/bin/sh
#
# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# @ Here is part of your new automatic Rogue player, Rog-O-Matic XIV! @
# @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
# 
#     [Note: this is a Beta-Test release of version XIV, and almost
#      certainly contains bugs.  A new version will be made available
#      soon.  If you experience any problems with this version, please
#      contact Michael Mauldin as soon as possible, so your input can be
#      included in the new release]
# 
# Rog-O-Matic XIV is shipped via mail in pieces, files rgm14.01, rgm14.02,
# ..., rgm14.nn.  Each piece contains some number of smaller files. To
# retrieve them, run each file through the shell 'sh', as follows:
# 
# 	sh <rgm14.01
# 	sh <rgm14.02
# 	     ...
# 	sh <rgm14.nn
# 
# or do it all at once:
# 
# 	cat rgm14.* | sh
# 
# The README file contains all necessary information to edit the "install.h"
# file, after which "make" will build the rogomatic and player binary files.
# Please note that file 'Bugreport' contains modifications you may wish to
# make to the code BEFORE you compile it.  You can safely install ALL of
# them; depending on your version of Rogue, you may HAVE to install SOME of
# them.
# 
# Rog-O-Matic is copyrighted, but permission is given to copy and modify the
# source provided that (1) it is not used for profit (2) all authorship and
# copyright notices remain intact and (3) any person or site with a copy has
# notified Michael Mauldin either by electronic mail or US Post that they
# have Rog-O-Matic XIV.
# 
# We would appreciate hearing about any interesting additions or modifi-
# cations, and would especially like to know how well the program plays
# against your Rogue.  And we really, really want to know if Rog-O-Matic
# becomes a "Total Winner" against Rogue 5.2 or Rogue 5.3 again.
# 
# 				Michael Mauldin (Fuzzy)
# 				Department of Computer Science
# 				Carnegie-Mellon University
# 				Pittsburgh, PA  15213
# 				(412) 578-3065,  mauldin@cmu-cs-a.arpa
#
echo 'Start of Rog-O-Matic XIV, part 08 of 10:'
echo 'x - arms.c'
sed 's/^X//' > arms.c << '/'
X/*
X * arms.c: Rog-O-Matic XIV (CMU) Thu Jan 31 15:46:02 1985 - mlm
X * Copyright (C) 1985 by A. Appel, G. Jacobson, L. Hamey, and M. Mauldin
X * 
X * This file contains all utility functions which exist for armor, 
X * weapons and rings.
X */
X
X# include <curses.h>
X# include "types.h"
X# include "globals.h"
X
X/*
X * havearmor: Return Kth best armor. K should be in the range 1 to invcount.
X *            If K is greater than the number of pieces of armor we have,
X *            then NONE is returned.  Will not return cursed armor or
X *	      armor worse than wearing nothing.
X */
X
X# define swap(x,y) {t=(x); (x)=(y); (y)=t;}
X
Xint havearmor (k, print, rustproof)
X{ register int i, j, w, t, n=0;
X  int armind[MAXINV], armval[MAXINV];
X
X  /* Sort armor by armor class (best first) */
X  for (i=0; i<invcount; ++i)
X  { if (inven[i].count && inven[i].type == armor &&
X        ! (rustproof && willrust (i)))
X    { n++;
X      w = armorclass (i);
X      for (j = n-1; j > 0 && w <= armval[j-1]; j--)
X      { swap (armind[j], armind[j-1]);
X        swap (armval[j], armval[j-1]);
X      }
X      armind[j] = i;
X      armval[j] = w;
X    }
X  }
X
X  /* Put protected sets of armor with equal ACs first.  DR UTexas 19 Jan 84 */
X  for (j = n-1; j > 0; j--)
X  { if (armval[j] == armval[j-1])
X    { i = armind[j];
X      w = armind[j-1];
X      if (!itemis (w, PROTECTED) && itemis (i, PROTECTED))
X        swap (armind[j], armind[j-1]);
X    }
X  }
X
X  if (print)
X  { mvaddstr (1, 0, "Current Armor Rankings");
X    for (i = 0; i<n; i++)
X      mvprintw (i+3, 8, "%2d: %3d %s", i+1, armval[i], itemstr (armind[i]));
X  }
X
X  /* Any uncursed, useful armor at or beyond position k? */
X  for (i=k; i <= n; i++)
X    if (!itemis ((j = armind[i-1]), CURSED) && armval[j] < 10) return (j);
X  
X  /* Return the kth best, even though it is cursed or useless */
X  return ((k <= n) ? armind[k-1] : NONE);
X}
X
X/*
X * armorclass: Given the index of a piece of armor, return the armor
X * class. Assume modifiers of +2 for unknown armor when we have scrolls
X * of remove curse and -2 for when we don't have a remove curse.
X */
X
Xarmorclass (i)
Xint i;
X{ int class;
X
X  if (inven[i].type != armor)
X    return (1000);
X    
X  if (stlmatch (inven[i].str, "leather"))        class = 8;
X  else if (stlmatch (inven[i].str, "ring"))      class = 7;
X  else if (stlmatch (inven[i].str, "studded"))   class = 7;
X  else if (stlmatch (inven[i].str, "scale"))     class = 6;
X  else if (stlmatch (inven[i].str, "chain"))     class = 5;
X  else if (stlmatch (inven[i].str, "splint"))    class = 4;
X  else if (stlmatch (inven[i].str, "banded"))    class = 4;
X  else if (stlmatch (inven[i].str, "plate"))     class = 3;
X  else                                           class = 1000;
X
X  /* Know the modifier exactly */
X  if (inven[i].phit != UNKNOWN)
X    class -= inven[i].phit;
X
X  /* Can remove curse, so assume it is +2 armor */
X  else if (havenamed (scroll, "remove curse") != NONE)
X    class -= 2;
X
X  /* Can't remove curse, assume it is -2 armor */
X  else
X    class += 2;
X
X  return (class);
X}
X
X/*
X * haveweapon: Return Kth best weapon. K should be in the range 1 to invcount.
X *             If K is greater than the number of weapons we have,
X *             then NONE is returned.
X */
X
Xint haveweapon (k, print)
X{ register int i, j, w, t, n=0;
X  int weapind[MAXINV], weapval[MAXINV];
X  for (i=0; i<invcount; ++i)
X    if (inven[i].count && (w = weaponclass (i)) > 0)
X    { n++;
X      for (j = n-1; j > 0 && w >= weapval[j-1]; j--)
X      { swap (weapind[j], weapind[j-1]);
X        swap (weapval[j], weapval[j-1]);
X      }
X      weapind[j] = i;
X      weapval[j] = w;
X    }
X
X    /*
X     * Put enchanted weapons above unenchanted ones if the weapon
X     * ratings are equal.  DR UTexas 25 Jan 84 
X     */
X
X    for (j = n-1; j > 0; j--)
X    { if (weapval[j] == weapval[j-1])
X      { i = weapind[j];
X        w = weapind[j-1];
X        if (!itemis (w, ENCHANTED) && itemis (i, ENCHANTED) &&
X            !itemis (w, KNOWN) && !itemis (i, KNOWN))
X        { swap (weapind[j], weapind[j-1]); }
X      }
X    }
X
X  if (print)
X  { mvaddstr (1, 0, "Current Weapon Rankings");
X    for (i = 0; i<n; i++)
X      mvprintw (i+3, 8, "%2d: %5d %s", i+1, weapval[i], itemstr (weapind[i]));
X  }
X
X  return ((k <= n) ? weapind[k-1] : NONE);
X}
X
X/*
X * weaponclass: Given the index of a weapon, return the weapon class. 
X *              This is the average damage done + 3/2 the plus to
X *              hit, multiplied by 10. Magic arrows are given very
X *              high numbers.
X */
X
Xweaponclass (i)
Xint i;
X{ int class, hitplus = 0, damplus = 0;
X
X  /* Swords and maces are always valid weapons */   
X  if (inven[i].type == hitter)
X    ;
X  /* Under special circumstances, arrows are valid weapons (Hee hee) */
X  else if (cheat && inven[i].type == missile &&
X           stlmatch (inven[i].str, "arrow"))
X    ;
X  /* Not a valid weapon */
X  else
X    return (0);
X
X  /* 
X   * Set the basic expected damage done by the weapon. 
X   */
X    
X  if (stlmatch (inven[i].str, "mace"))
X    class =  50;
X  else if (stlmatch (inven[i].str, "two handed sword"))
X    class = (version < RV52A) ? 105 : 100;
X  else if (stlmatch (inven[i].str, "long sword"))
X    class =  (version < RV52A) ? 55 : 75;
X  else if (stlmatch (inven[i].str, "arrow"))
X    class =  10;
X  else
X    class =   0;
X
X  /* Know the modifier exactly */
X  if (inven[i].phit != UNKNOWN)
X  { hitplus += inven[i].phit;
X
X    if (inven[i].pdam != UNKNOWN)
X      damplus = inven[i].pdam; 
X  }
X
X  /* 
X   * Strategy for "Magic Arrows". These are single arrows when
X   * we are cheating. Since arrows normally come in clumps, and
X   * since we have never (in cheat mode) thrown any, then a
X   * single arrow must have come from a trap, and until it fails
X   * to kill something, we assume it is a valuable arrow.
X   */
X
X  else if (cheat && version <= RV36B && usingarrow && goodarrow > 20 &&
X           i == currentweapon)
X    return (1800);
X
X  else if (cheat && version <= RV36B && stlmatch (inven[i].str, "arrow") &&
X           inven[i].count == 1 && !itemis (i, WORTHLESS) && 
X           (!badarrow || i != currentweapon))
X  { hitplus = 50;  damplus = 50; }
X
X  hitplus = (hitplus < 100) ? hitplus : 100;
X  damplus = (damplus < 200) ? damplus : 200;
X
X  return (class + 12*hitplus + 10*damplus);
X}
X
X/*
X * havering: Return Kth best ring. K should be in the range 1 to invcount.
X *           If K is greater than the number of rings we have,
X *           then NONE is returned.
X */
X
Xint havering (k, print)
X{ register int i, j, r, t, n=0;
X  int ringind[MAXINV], ringval[MAXINV];
X  for (i=0; i<invcount; ++i)
X    if (inven[i].count && (r = ringclass (i)) > 0)
X    { n++;
X      for (j = n-1; j > 0 && r >= ringval[j-1]; j--)
X      { swap (ringind[j], ringind[j-1]);
X        swap (ringval[j], ringval[j-1]);
X      }
X      ringind[j] = i;
X      ringval[j] = r;
X    }
X
X  if (print)
X  { mvaddstr (1, 0, "Current Ring Rankings");
X    for (i = 0; i<n; i++)
X      mvprintw (i+3, 8, "%2d: %5d  %s", i+1, ringval[i], itemstr (ringind[i]));
X  }
X
X  /* 
X   * Since rings are class [1-1000] if we don't want to wear them,
X   * return the ring index only if its value is greater than 1000.
X   */
X
X  return ((k <= n && ringval[k-1] > 1000) ? ringind[k-1] : NONE);
X}
X
X/*
X * ringclass: Given the index of a ring, return the ring class. 
X *            This is a subjective measure of how much good it
X *            would do us to wear this ring. Values of [1-1000] indicates
X *            that we should not wear this ring at all. A value of 0
X *            indicates a worthless ring. This routine uses the amount
X *            of food available to decide how valuable rings are.
X *            Worth evaluates the value of a ring by subtracting 1000 if
X *            the ringclass is over 1000 to decide how valuable the ring
X *            is, so we add 1000 to indicate that the ring should be worn
X *            and try to assign values from 0 to 999 to determine the
X *            value of the ring.
X */
X
Xringclass (i)
Xint i;
X{ int class = 0, magicplus = 0;
X
X  if (inven[i].type != ring)
X    return (0);
X
X  /* Get the magic plus */
X  if (inven[i].phit != UNKNOWN)
X  { magicplus = inven[i].phit;
X  }
X
X  /* A ring of protection */
X  if (stlmatch (inven[i].str, "protection"))
X  { if (magicplus > 0) class = (havefood (1) ? 1000 : 0) + 450; }
X
X  /* A ring of add strength */
X  else if (stlmatch (inven[i].str, "add strength"))
X  { if (itemis (i, INUSE) && magicplus > 0)
X    { if (hitbonus (Str) == hitbonus (Str - magicplus * 100) &&
X          damagebonus (Str) == damagebonus (Str - magicplus * 100))
X        class = 400;
X      else
X        class = (havefood (1) ? 1000 : 0) + 400;
X    }
X    else if (magicplus > 0)
X    { if (hitbonus (Str) == hitbonus (Str + magicplus * 100) &&
X          damagebonus (Str) == damagebonus (Str + magicplus * 100))
X        class = 400;
X      else
X        class = (havefood (1) ? 1000 : 0) + 400;
X    }
X  }
X
X  /* A ring of sustain strength */
X  else if (stlmatch (inven[i].str, "sustain strength"))
X  { 
X    /* A second ring of sustain strength is useless */
X    if (!itemis (i, INUSE) && wearing ("sustain strength") != NONE)
X      class = 0;
X
X    else
X      class = (havefood (3) ? 1000 : 0) + 
X              (Level > 12 ? 150 : 
X               Str > 2000 ? 700 :
X               Str > 1600 ? Str - 1200 :
X                            100);
X  }
X
X  /* A ring of searching */
X  else if (stlmatch (inven[i].str, "searching"))
X  { class = (havefood (0) ? 1000 : 0) + 250; }
X
X  /* A ring of see invisible */
X  else if (stlmatch (inven[i].str, "see invisible"))
X  { 
X    /* A second ring of see invisible is useless */
X    if (!itemis (i, INUSE) && wearing ("see invisible") != NONE)
X      class = 0;
X
X    /* 
X     * If we are beingstalked and we are wearing this ring, then
X     * we should take it off and put it on to set the Rogue CANSEE
X     * bit, which can be unset by a second ring of see invisible or
X     * by a see invisible potion wearing off.				MLM
X     */
X
X    else if (itemis (i, INUSE) && beingstalked)
X      class = 800;
X
X    /*
X     * When we put the ring on, keep its importance high for 20
X     * turns, just in case the beast comes back to haunt us.		MLM
X     */
X
X    else
X      class = (beingstalked || turns - putonseeinv < 20) ? 1999 :
X              ((havefood (0) && Level > 15 && Level < 26) ? 1000 : 0) + 300;  }
X
X  /* A ring of adornment */
X  else if (stlmatch (inven[i].str, "adornment"))
X  { class = 0; }
X
X  /* A ring of aggravate monster */
X  else if (stlmatch (inven[i].str, "aggravate monster"))
X  { class = 0; }
X
X  /* A ring of dexterity */
X  else if (stlmatch (inven[i].str, "dexterity"))
X  { if (magicplus > 0) class = (havefood (0) ? 1000 : 0) + 475; }
X
X  /* A ring of increase damage */
X  else if (stlmatch (inven[i].str, "increase damage"))
X  { if (magicplus > 0) class = (havefood (0) ? 1000 : 0) + 500; }
X
X  /* A ring of regeneration */
X  else if (stlmatch (inven[i].str, "regeneration"))
X  {
X    /* Analysis indicates that rings of regenerate DO NOT hold back   */
X    /* the character after any level. They each add one hit point per */
X    /* turn of rest regardless of your level!			MLM   */
X
X    class = 50*(Hpmax-Hp-Explev) + 500; }
X
X  /* A ring of slow digestion */
X  else if (stlmatch (inven[i].str, "slow digestion"))
X  { 
X    /* A second ring of slow digestion is not too useful */
X    if (havefood (0) && !itemis (i, INUSE) &&
X	wearing ("slow digestion") != NONE)
X      class = 1001;
X
X    else
X    { class =	havefood (3) ?	1100 :
X		havefood (2) ?	1300 :
X		havefood (1) ?	1500 :
X		havefood (0) ?	1900 :
X				1999 ;
X    }
X  }
X
X  /* A ring of teleportation */
X  else if (stlmatch (inven[i].str, "telportation") || 
X           stlmatch (inven[i].str, "teleportation"))
X  { class = 0; }
X
X  /* A ring of stealth */
X  else if (stlmatch (inven[i].str, "stealth"))
X  {
X    /* A second ring of stealth is useless */
X    if (!itemis (i, INUSE) && wearing ("stealth") != NONE)
X      class = 0;
X
X    else
X    { class = (havefood (1) ? 1000 : 0) + 
X             (Level > 17 ? 850 : Level > 12 ? 700 : 300);
X    }
X  }
X
X  /* A ring of maintain armor */
X  else if (stlmatch (inven[i].str, "maintain armor"))
X  { int bestarm, nextarm, armdiff;
X
X    /* No rust monsters yet or cursed armor */
X    if (Level < 9 || cursedarmor) return (900);
X    
X    /* Past the rust monsters */
X    else if (Level > 18) return (300);
X
X    /* A second ring of maintain armor is useless */
X    else if (!itemis (i, INUSE) && wearing ("maintain armor") != NONE)
X      class = 0;
X
X    else
X    { bestarm = havearmor (1, NOPRINT, ANY);
X      nextarm = havearmor (1, NOPRINT, RUSTPROOF);
X
X      if (bestarm < 0)                       /* No armor to protect */
X        return (700);
X
X      else if (!willrust (bestarm))	     /* Armor wont rust anyway */
X        return (0);
X
X      else if (nextarm < 0)	             /* Naked is AC 10 */
X        armdiff = 10 - armorclass (bestarm);
X
X      else			             /* Get difference in classes */
X        armdiff = armorclass (nextarm) -
X		  armorclass (bestarm);
X
X      class = (havefood (1) ? 1000 : 0) +
X              200 * armdiff;
X    }
X  }
X
X  /* Not a known ring, forget it */
X  else
X    return (0);
X
X  /* A magical plus is worth 100 */
X  return (class + 100*magicplus);
X}
X
X/*
X * havebow: Return Kth best thrower. K should be in the range 1 to invcount.
X *          If K is greater than the number of weapons we have,
X *          then NONE is returned.
X */
X
Xint havebow (k, print)
X{ register int i, j, w, t, n=0;
X  int bowind[MAXINV], bowval[MAXINV];
X  for (i=0; i<invcount; ++i)
X    if (inven[i].count && (w = bowclass (i)) > 0)
X    { n++;
X      for (j = n-1; j > 0 && w >= bowval[j-1]; j--)
X      { swap (bowind[j], bowind[j-1]);
X        swap (bowval[j], bowval[j-1]);
X      }
X      bowind[j] = i;
X      bowval[j] = w;
X    }
X
X  if (print)
X  { mvaddstr (1, 0, "Current Bow Rankings");
X    for (i = 0; i<n; i++)
X      mvprintw (i+3, 8, "%2d: %5d %s", i+1, bowval[i], itemstr (bowind[i]));
X  }
X
X  return ((k <= n) ? bowind[k-1] : NONE);
X}
X
X/*
X * bowclass: Given the index of a bow, return the bow class. 
X *           This is the average damage done + 6/5 the plus to
X *           hit, multiplied by 10.
X */
X
Xbowclass (i)
Xint i;
X{ int class, hitplus = 0, damplus = 0;
X
X  if (inven[i].type == thrower &&
X      stlmatch (inven[i].str, "short bow") &&
X      havemult (missile, "arrow", 5) != NONE)
X    class =  35;
X  else
X    return (0);
X
X  /* Find the modifiers */
X  if (inven[i].phit != UNKNOWN)
X  { hitplus += inven[i].phit;
X
X    if (inven[i].pdam != UNKNOWN)
X      damplus = inven[i].pdam; 
X  }
X
X  return (class + 12*hitplus + 10*damplus);
X}
X
X/*
X * havemissile: Return best missile. Dont consider arrows if we
X * are cheating.  Consider arrows first if we are wielding our bow.
X */
X
Xint havemissile ()
X{ register int i, fewest = 9999, obj = NONE;
X
X  if (wielding (thrower))	/* Wielding bow, use arrows */
X  { for (i=0; i<invcount; ++i)
X      if (inven[i].count > 0 && inven[i].count < fewest &&
X          inven[i].type == missile && stlmatch(inven[i].str,"arrow"))
X      { obj = i; fewest = inven[i].count; }
X  }
X
X  if (obj < 0)			/* Not wielding bow or no arrows */
X  { for (i=0; i<invcount; ++i)
X      if (inven[i].count > 0 &&
X	  inven[i].count < fewest &&
X	  !itemis (i, INUSE) &&
X          (inven[i].type == missile ||
X           stlmatch(inven[i].str,"spear") || 
X           stlmatch(inven[i].str,"dagger") || 
X           stlmatch(inven[i].str,"mace") && inven[i].phit <= 0 || 
X           stlmatch(inven[i].str,"long sword") && inven[i].phit < 0))
X      { obj = i; fewest = inven[i].count; }
X  }
X
X  if (obj != NONE)
X    dwait (D_BATTLE, "Havemissile returns (%s", itemstr (obj));
X  else
X    dwait (D_BATTLE, "Havemissile fails");
X
X  return (obj);
X}
X
X/*
X * havearrow: return the index of any arrow which has count 1.
X */
X
Xhavearrow ()
X{ int arr;
X
X  for (arr = 0; arr<invcount; arr++)
X    if (inven[arr].type == missile &&
X        inven[arr].count == 1 &&
X        stlmatch(inven[arr].str,"arrow"))
X      return (arr);
X
X  return (NONE);
X}
X
X/*
X * plusweapon: we just enchanted our current weapon.
X *             Do a picky identify to try to find its plusses.
X */
X
Xplusweapon ()
X{
X  cursedweapon = 0;
X  newweapon = 1;
X  forget (currentweapon, CURSED);
X  usesynch = 0;
X}
X
X/* 
X * hitbonus: Return the bonus to hit.
X */
X
Xhitbonus (strength)
Xint strength;
X{ int bonus = 0;
X  
X  if (strength < 700) bonus = strength/100 - 7;
X
X  else if (version > RV36B)
X  { if (strength < 1700) bonus = 0;
X    else if (strength < 2100) bonus = 1;
X    else if (strength < 3100) bonus = 2;
X    else bonus = 3;    
X  }
X
X  else 
X  { if (strength < 1700) bonus = 0;
X    else if (strength < 1851) bonus = 1;
X    else if (strength < 1900) bonus = 2;
X    else bonus = 3;    
X  }
X
X  return (bonus);
X}
X
X/* 
X * damagebonus: bonus = the damage bonus.
X */
X
Xdamagebonus (strength)
Xint strength;
X{ int bonus = 0;
X
X  if (strength < 700) bonus = strength/100 - 7;
X
X  else  if (version > RV36B)
X  { if (strength < 1600) bonus = 0;
X    else if (strength < 1800) bonus = 1;
X    else if (strength < 1900) bonus = 2;
X    else if (strength < 2100) bonus = 3;
X    else if (strength < 2200) bonus = 4;
X    else if (strength < 1600) bonus = 5;
X    else bonus = 6;
X  }
X
X  else 
X  { if (strength < 1600) bonus = 0;
X    else if (strength < 1800) bonus = 1;
X    else if (strength < 1801) bonus = 2;
X    else if (strength < 1876) bonus = 3;
X    else if (strength < 1891) bonus = 4;
X    else if (strength < 1900) bonus = 5;
X    else bonus = 6;    
X  }
X
X  return (bonus);
X}
X
X/* 
X * setbonuses: Set global hit and damage pluses.
X */
X
Xsetbonuses ()
X{
X  /* Set global Hit bonus */
X  gplushit = hitbonus (Str);
X
X  if (leftring != NONE && stlmatch (inven[leftring].str, "dexterity") &&
X      inven[leftring].phit != UNKNOWN)
X   gplushit += inven[leftring].phit;
X
X  if (rightring != NONE && stlmatch (inven[rightring].str, "dexterity") &&
X      inven[rightring].phit != UNKNOWN)
X   gplushit += inven[rightring].phit;
X
X  /* Set global Damage Bonus */
X  gplusdam = damagebonus (Str);
X
X  if (leftring != NONE && stlmatch (inven[leftring].str, "add damage") &&
X      inven[leftring].pdam != UNKNOWN)
X   gplusdam += inven[leftring].pdam;
X
X  if (rightring != NONE && stlmatch (inven[rightring].str, "add damage") &&
X      inven[rightring].pdam != UNKNOWN)
X   gplusdam += inven[rightring].pdam;
X
X  /* Set bonuses for weapons */
X  wplushit = gplushit;
X  wplusdam = gplusdam;
X
X  if (currentweapon != NONE)
X  { if (inven[currentweapon].phit != UNKNOWN)
X      wplushit += inven[currentweapon].phit;
X
X    if (inven[currentweapon].pdam != UNKNOWN)
X      wplusdam += inven[currentweapon].pdam;
X  }
X}
/
echo 'x - globals.h'
sed 's/^X//' > globals.h << '/'
X/*
X * globals.h: Rog-O-Matic XIV (CMU) Thu Jan 31 18:12:50 1985 - mlm
X * Copyright (C) 1985 by A. Appel, G. Jacobson, L. Hamey, and M. Mauldin
X *
X * Global variables
X */
X
X/* global files */
Xextern FILE *frogue,*trogue;	/* From Rogue, To Rogue */
Xextern FILE *fecho;		/* Rogomatic score file */
Xextern FILE *logfile;		/* Rogomatic score file */
Xextern FILE *realstdout;	/* Real stdout when in terse or emacs mode */
Xextern FILE *snapshot;		/* File for snapshot command */
XFILE *wopen();			/* Open a file for world access */
X
X/* global characters and strings */
Xextern char afterid;		/* Index of object after identify */
Xextern char *genocide;		/* List of monsters to genocide */
Xextern char genocided[];	/* List of monsters genocided */
Xextern char lastcmd[];		/* Copy of last command sent to Rogue */
Xextern char lastname[];		/* Name of last potion/scroll/wand */
Xextern char nextid;		/* Next object to identify */
Xextern char ourkiller[];	/* What was listed on the tombstone */
Xextern char *parmstr;		/* Pointer to argument space */
Xextern char queue[];		/* stuff to be sent to Rogue */
Xextern char *roguename;		/* Name we are playing under */
Xextern char screen[24][80];	/* characters drawn by Rogue */
Xextern char sumline[];		/* Summation line */
Xextern char *termination;	/* Latin verb for how we died */
Xextern char versionstr[];	/* Version of Rogue we are playing */
X
X/* character and string functions */
Xextern char getlogtoken(), *getname(), *itemstr();
Xextern char logchar(), *monname(), *realname();
X
X/* double precision floating point functions */
Xdouble prob(), mean(), stdev();	/* For stats.c */
X
X/* global integers */
Xextern int aggravated;		/* True if we aggravated this level */
Xextern int agoalr,agoalc;	/* where we killed a monster */
Xextern int ammo;		/* Number of missiles in pack */
Xextern int arglen;		/* Length of argument space */
Xextern int arrowshot;		/* True if trap fired at us this round */
Xextern int atrow,atcol;		/* where is the '@'? (us) */
Xextern int atrow0,atcol0;	/* where was the '@' last time */
Xextern int attempt;		/* # times have we explored this level */
Xextern int badarrow;		/* True if we missed with this arrow */
Xextern int beingheld;		/* True if being held by a fungus */
Xextern int beingstalked;	/* True if an Invisible Stalker is around */
Xextern int blinded;		/* True if blinded */
Xextern int blindir;		/* Last direction we moved when blind */
Xextern int cancelled;		/* Turns till use cancellation again */
Xextern int cecho;		/* Last message type to logfile */
Xextern int cheat;		/* True ==> cheat to win */
Xextern int checkrange;		/* True ==> check range */
Xextern int chicken;		/* True ==> test run away code */
Xextern int compression;		/* True ==> move multiple squares */
Xextern int confused;		/* True if confused */
Xextern int cosmic;		/* True if hallucinating */
Xextern int currentarmor;	/* Index of our armor */
Xextern int currentweapon;	/* Index of our weapon */
Xextern int cursedarmor;		/* True if armor is cursed */
Xextern int cursedweapon;	/* True if weapon if cursed */
Xextern int darkdir;		/* Direction of arrow in dark room */
Xextern int darkturns;		/* # arrows left to fire in dark room */
Xextern int debugging;		/* Debugging options in effect */
Xextern int didreadmap;		/* Last magically mapped level */
Xextern int doorlist[], *newdoors; /* Holds r,c of new doors found */
Xextern int doublehasted;	/* True if double hasted (3.6 only) */
Xextern int droppedscare;	/* Number of scare mon. on this level */
Xextern int emacs;		/* True if in emacs mode */
Xextern int exploredlevel;	/* We completely explored this level */
Xextern int floating;		/* True if we are levitating */
Xextern int foughtmonster;	/* True if we recently fought a monster */
Xextern int foundarrowtrap;	/* Well, did we? */
Xextern int foundtrapdoor;	/* Well, did we? */
Xextern int goalr,goalc;		/* where are we trying to go */
Xextern int goodarrow;		/* Number of times we killed in one blow */
Xextern int goodweapon;		/* Used for two-handed sword */
Xextern int gplusdam;		/* Global damage bonus */
Xextern int gplushit;		/* Global hit bonus */
Xextern int hasted;		/* True if hasted */
Xextern int head,tail;		/* endpoints of circular queue */
Xextern int hitstokill;		/* Number of hits to kill last monster */
Xextern int interrupted;		/* True if at commandtop from onintr() */
Xextern int knowident;		/* Found an identify scroll? */
Xextern int larder;		/* Number of foods left */
Xextern int lastate;		/* Time we last ate */
Xextern int lastdamage;		/* Amount of last hit by a monster */
Xextern int lastdrop;		/* What did we last try to drop */
Xextern int lastfoodlevel;	/* Last food found */
Xextern int lastmonster;		/* Last monster we tried to hit */
Xextern int lastobj;		/* What did we last try to use */
Xextern int lastwand;		/* Index of last wand */
Xextern int leftring;		/* Index of our left ring */
Xextern int logdigested;		/* True if game log has been read by replay */
Xextern int logging;		/* True if logging game */
Xextern int lyinginwait;		/* Did we lie in wait last turn? */
Xextern int maxobj;		/* How much can we carry */
Xextern int missedstairs;	/* True if we missed the stairs */
Xextern int morecount;		/* Number of messages since last command */
Xextern int msgonscreen;		/* There is a rogomatic msg on the screen */
Xextern int newarmor;		/* True if our armor status has changed */
Xextern int newring;		/* True if our ring status has changed */
Xextern int newweapon;		/* True if our weapon status has changed */
Xextern int nohalf;		/* True if no halftime show */
Xextern int noterm;		/* True if no human watching */
Xextern int objcount;		/* Number of objects */
Xextern int ourscore;		/* Our score when we died/quit */
Xextern int playing;		/* True if still playing the game */
Xextern int poorarrow;		/* # Times we failed to kill in one blow */
Xextern int protected;		/* True if we protected our armor */
Xextern int putonseeinv;		/* Time when last put on see invisible ring */
Xextern int quitat;		/* Score we are trying to beat */
Xextern int redhands;		/* True if our hands are red */
Xextern int replaying;		/* True if replaying old game */
Xextern int revvideo;		/* True if in rev. video mode */
Xextern int rightring;		/* Index of our right ring */
Xextern int rogpid;		/* Process id of Rogue process */
Xextern int room[];		/* Flags for each room */
Xextern int row,col;		/* where is the cursor? */
Xextern int scrmap[24][80];	/* attribute flags for squares */
Xextern int slowed;		/* True if we recently slowed a monster */
Xextern int stairrow,staircol;	/* Where is the staircase */
Xextern int teleported;		/* times teleported on this level */
Xextern int terse;		/* True if in terse mode */
Xextern int transparent;		/* True ==> user mode */
Xextern int trapc;		/* Col of last trap */
Xextern int trapr;		/* Row of last trap */
Xextern int urocnt;		/* Un-identified Rogue Object count */
Xextern int usesynch;		/* Have we finished using something? */
Xextern int usingarrow;		/* True if wielding an arrow from a trap */
Xextern int version;		/* From types.h, set by getrougeversion */
Xextern int wplusdam;		/* Weapon damage bonus */
Xextern int wplushit;		/* Weapon hit bonus */
Xextern int zone;		/* Current zone (0 to 8) */
Xextern int zonemap[9][9];	/* Connectivity map */
X
X/* Status line variables */
Xextern int Level,MaxLevel,Gold,Hp,Hpmax,Str,Strmax,Ac,Exp,Explev;
Xextern char Ms[];		/* Msg 'X', 'Hungry', 'Weak', 'Fainting' */
Xextern int turns;		/* Est time in Rogue turns since start */
X
X/* Geometry data */
Xextern int deltc[], deltr[];	/* Displacements for directions */
Xextern int deltrc[];		/* ditto */
Xextern char keydir[];		/* Directions for motion keys */
Xextern int movedir;		/* Which direction did we last move */
Xextern stuff translate[];	/* what Rogue characters represent */
X
X/* Time history */
Xextern timerec timespent[];
X
X/* Objects in pack */
Xextern invrec inven[];	extern int invcount;
X
X/* Stuff on this level */
Xextern stuffrec slist[]; extern int slistlen;
X
X/* Monster on this level */
Xextern monrec mlist[];	extern int mlistlen;
X
Xextern char	killedmonster, targetmonster;
X
X/* Door search variables */
Xextern int	new_mark, new_findroom, new_search, new_stairs, new_arch;
Xextern char	timessearched[24][80], timestosearch;
Xextern int	searchstartr, searchstartc;
Xextern int	reusepsd;
X
X/* Results of last makemove */
Xextern int	ontarget, targetrow, targetcol;
X
X/* Monster attribute and Long term memory arrays */
Xextern attrec monatt[];		/* Monster attributes */
Xextern lrnrec ltm;		/* Long term memory -- general */
Xextern ltmrec monhist[]; 	/* Long term memory -- creatures */
Xextern ltmrec delhist[]; 	/* Long term memory -- changes this game */
Xextern int nextmon;		/* Length of LTM */
Xextern int monindex[];		/* Index into monhist array */
X
X/* Genetic learning arrays */
Xextern int knob[];		/* Knobs */
Xextern int k_srch;		/* Propensity for searching squares */
Xextern int k_door;		/* Propensity for searching doors */
Xextern int k_rest;		/* Propensity for resting */
Xextern int k_arch;		/* Propensity for firing arrows */
Xextern int k_exper;		/* Level on which to experiment with items */
Xextern int k_run;		/* Propensity for retreating */
Xextern int k_wake;		/* Propensity for waking things up */
Xextern int k_food;		/* Propensity for hoarding food (rings) */
/
echo 'x - survival.c'
sed 's/^X//' > survival.c << '/'
X/*
X * survival.c: Rog-O-Matic XIV (CMU) Mon Jan  7 15:22:23 1985 - mlm
X * Copyright (C) 1985 by A. Appel, G. Jacobson, L. Hamey, and M. Mauldin
X *
X * This file contains all of the "Run Away" code.
X * Well, almost all of the run away code.
X * At least I think it has something to do with running away.
X */
X
X# include <stdio.h>
X# include <ctype.h>
X# include <curses.h>
X# include "types.h"
X# include "globals.h"
X
X# define SO	  1
X# define SE	  0
X
X# define highlight(rowcol,stand)		\
X  if (print || debug (D_SCREEN))		\
X  { at((rowcol)/80,(rowcol)%80);		\
X    if (stand) standout ();			\
X    printw("%c",screen[0][rowcol]);		\
X    if (stand) standend ();			\
X    refresh (); }
X
X/*
X * markcycles: evokes fond memories of an earlier time, when Andrew
X * was a hacker who just patched things together until they worked,
X * and used the SHIFT-STOP key to compile things, rather than thinking.
X *
X * markcycles does a depth-first-search of the squares to find loops in
X * the rooms.  All doors on loops are marked RUNOK, and are used by the
X * runaway code.
X */
X
Xmarkcycles (print)
X{ short mark[1920];
X  struct {short where,door,dirs;} st[1000];
X  register int sp,newsquare; int *Scr; int whichdir; int D;
X
X  if (!new_mark) return (0);
X
X  Scr=scrmap[0];
X
X  { register int count=1920; register short *m=mark; while(count--) *m++=0;}
X  sp=1; st[1].where=atrow*80+atcol; st[1].dirs=1; st[1].door=0;
X
X  for (D = 0; D < 8; D += 2)
X  { if ((Scr[newsquare = (st[1].where+deltrc[D^4])]) & CANGO)
X    { if (mark[newsquare])
X      { int stop, i;
X        if (mark[newsquare] < sp)
X          for (stop = st[mark[newsquare]].door,
X                 i = (Scr[st[sp].where] & DOOR) ? sp : st[sp].door;
X               i !=  stop;
X               i =st[i].door)
X          { Scr[st[i].where] |= RUNOK; 
X            highlight (st[i].where, SO) 
X          }
X       }
X       else
X       { sp++; mark[newsquare] = sp;
X         highlight (newsquare, SO)
X         st[sp].where=newsquare;
X         st[sp].dirs=1; st[1].dirs= -1;
X         st[sp].door = (Scr[st[sp-1].where]&DOOR) ? sp-1 : st[sp-1].door;
X       }
X     }
X
X     while (sp > 1)
X     { if ((whichdir=(st[sp].dirs++)<<1)<8)
X       { /* whichdir is 6,2, or 4. */
X         if ((Scr[newsquare= (st[sp].where+deltrc[(whichdir+D)&7])])&CANGO)
X         { if (mark[newsquare])
X           { register int stop,i;
X             if (mark[newsquare]<sp)
X                 for (stop=st[mark[newsquare]].door,
X                 i=(Scr[st[sp].where]&DOOR)?sp:st[sp].door;
X                 i!=stop;
X                 i=st[i].door)
X             { Scr[st[i].where] |= RUNOK;
X               highlight (st[i].where, SO)
X             }
X           }
X           else
X           { sp++; mark[newsquare]=sp;
X             highlight (newsquare, SO)
X             st[sp].where=newsquare;
X             st[sp].dirs=1; D += whichdir+4;
X             st[sp].door = (Scr[st[sp-1].where]&DOOR) ? sp-1 : st[sp-1].door;
X           }
X         }
X       }
X       else
X       { if (! (Scr[st[sp].where] & RUNOK)) highlight (st[sp].where, SE) 
X         sp--;
X         D -= 4+((st[sp].dirs-1)<<1);
X       }
X     }
X  }
X  highlight (st[1].where, SE)
X
X  new_mark = 0;
X  return (1);
X}
X
X/* 
X * Runaway: Panic!
X */
X
Xint runaway ()
X{
X  if (on (SCAREM)) 
X  { dwait (D_BATTLE, "Not running, on scare monster scroll!");
X    return (0);
X  }
X
X  dwait (D_BATTLE | D_SEARCH, "Run away!!!!");
X
X  if (on (STAIRS) && !floating)		/* Go up or down */
X  { if (!goupstairs (RUNNING)) godownstairs (RUNNING); 
X    return (1);
X  }
X
X  if (canrun ())		/* If canrun finds a move, use it */
X    return (followmap (RUNAWAY));
X
X  return (0);			/* Cant run away */  
X}
X
X/*
X * Canrun: set up a move which will get us away from danger.
X */
X
Xint canrun ()
X{ int result, oldcomp = compression;
X  int runinit(), runvalue(), expruninit(), exprunvalue();
X  
X  if (on (STAIRS)) return (1);		/* Can run down stairs */
X
X  compression = 0;			/* Be tense when fleeing */
X  result = (findmove (RUNAWAY, runinit, runvalue, REEVAL) ||
X            findmove (EXPLORERUN, expruninit, exprunvalue, REEVAL));
X
X  compression = oldcomp;
X  return (result);
X}
X
X/*
X * unpin:
X *
X *	"When you're stuck and wriggling on a pin,
X *	 When you're pinned and wriggling on a wall..."
X *
X *		"The Love Song of J. Alfred Prufrock", T.S. Eliot
X */
X
Xint unpin ()
X{ int result, oldcomp = compression;
X  int unpininit (), runvalue (), expunpininit (),
X      exprunvalue (), expunpinvalue ();
X
X  if (on (SCAREM)) 
X  { dwait (D_BATTLE, "Not unpinning, on scare monster scroll!");
X    return (0);
X  }
X
X  if (on (STAIRS) && !floating)
X  { if (!goupstairs (RUNNING)) godownstairs (RUNNING); 
X    return (1);
X  }
X
X  dwait (D_BATTLE, "Pinned!!!!");
X
X  /* currentrectangle ();   // always done after each move of the rogue // */
X
X  compression = 0;	/* Be tense when fleeing */
X  result = (makemove (UNPIN, unpininit, runvalue, REEVAL) ||
X            makemove (UNPINEXP, expunpininit, expunpinvalue, REEVAL));
X
X  compression = oldcomp;
X  return (result);
X}
X
X/*
X * backtodoor: Useful when being ganged up on. Back into the nearest
X *             door.
X */
X
Xint backtodoor (dist)
Xint dist;
X{ int rundoorinit(), rundoorvalue();
X  static int lastcall= -10, stillcount=0, notmoving=0, closest=99;
X  
X  /* 
X   * Keep track of the opponents distance.  If they stop advancing on us,
X   * disable the rule for 10 turns.
X   */
X
X  if (turns-lastcall > 20)
X  { notmoving=0; closest=99; stillcount=0; }
X  else if (dist < closest)
X  { closest=dist; stillcount=0; }
X  else if (++stillcount > 5)
X  { notmoving++; }
X
X  lastcall = turns;
X
X  /* 
X   * Now check whether we try to move back to the door
X   */
X
X  if (notmoving)
X    dwait (D_BATTLE, "backtodoor: monsters not moving");
X  
X  else if (on (SCAREM)) 
X    dwait (D_BATTLE, "Not backing up, on scare monster scroll!");
X
X  else if (dist > 0 && (on (DOOR) || nextto (DOOR, atrow, atcol)))
X    dwait (D_BATTLE, "backtodoor: next to door, have time");
X
X  else if (makemove (RUNTODOOR, rundoorinit, rundoorvalue, REEVAL))
X  { dwait (D_BATTLE, "Back to the door..."); return (1); }
X
X  return (0);
X}
/
echo 'x - types.h'
sed 's/^X//' > types.h << '/'
X/*
X * types.h: Rog-O-Matic XIV (CMU) Wed Jan 30 14:57:17 1985 - mlm
X * Copyright (C) 1985 by A. Appel, G. Jacobson, L. Hamey, and M. Mauldin
X *
X * Miscellaneous Macros and Constants 
X */
X
X/* The unctrl macro for systems where curses doesn't define it */
X
X# ifndef unctrl
Xextern char	*_unctrl[];
X
X# define	unctrl(ch)	(_unctrl[ch & 0177])
X# endif
X
X/* Global Preprocessor constants */
X
X# define ill		";'"
X# define status		"Str:"
X# define MAXATTEMPTS	(10)
X# define ROGQUIT	(-2)
X# define DIED		(1)
X# define FINISHED	(0)
X# define SAVED		(2)
X# define MAXINV		(26)
X# define NONE		(-1)
X# define MAXSTUFF	(30)
X# define MAXMONST	(40)
X# define SAVEARROWS	(30)
X# define NAMSIZ		(64)
X# define MAXLEV		(30)
X# define MAXMON		(128)
X# define SUCCESS	(1)
X# define FAILURE	(0)
X
X# define ISPRT(c)	((c) >= ' ' && (c) <= '~')
X# define GETROGUECHAR	fgetc(frogue)
X# define GETLOGCHAR	fgetc(logfile)
X
X/*
X * Magic numbers for Invisible stalker strategies
X */
X
X# define INVHIT		(1000)
X
X/*
X * Attribute bits for the screen map: If you change this list, be sure
X * to change the flag names at the end of debug.c.   MLM
X */
X
X# define BEEN		(0000000001)
X# define CANGO		(0000000002)
X# define DOOR		(0000000004)
X# define HALL		(0000000010)
X# define PSD		(0000000020)
X# define ROOM		(0000000040)
X# define SAFE		(0000000100)
X# define SEEN		(0000000200)
X# define SEENPOS	(7)
X# define DEADEND	(0000000400)
X# define STUFF		(0000001000)
X# define TRAP		(0000002000)
X# define ARROW		(0000004000)
X# define TRAPDOR	(0000010000)
X# define TELTRAP	(0000020000)
X# define GASTRAP	(0000040000)
X# define BEARTRP	(0000100000)
X# define DARTRAP	(0000200000)
X# define WATERAP	(0000400000)
X# define MONSTER	(0001000000)
X# define WALL		(0002000000)
X# define USELESS	(0004000000)
X# define SCAREM		(0010000000)
X# define STAIRS		(0020000000)
X# define RUNOK		(0040000000)
X# define BOUNDARY	(0100000000)
X# define SLEEPER	(0200000000)
X# define EVERCLR	(0400000000)
X
X# define TOPW		(0)
X# define BOTW		(1)
X# define LEFTW		(2)
X# define RIGHTW		(3)
X# define NOTW		(-1)
X# define DOORW		(-2)
X# define CORNERW	(-3)
X
X# define INFINITY	(10000)
X
X# define NOTAMOVE	(-1)
X
X# define FORCE		(1)
X# define OPTIONAL	(0)
X
X# define NEAR		(0)
X# define HERE		(1)
X
X# define NOPRINT	(0)
X# define DOPRINT	(1)
X
X# define NOTRUNNING	(0)
X# define RUNNING	(1)
X
X# define ANY		(0)
X# define RUSTPROOF	(1)
X
X/* Types of moves planned by makemove */
X# define REUSE		(0)
X# define REEVAL		(1)
X
X# define EXPLORE	(1)
X# define EXPLORERUN	(2)
X# define RUNTODOOR	(3)
X# define RUNAWAY	(4)
X# define SECRETDOOR	(5)
X# define FINDSAFE	(6)
X# define GOTOMOVE	(7)
X# define ATTACKSLEEP	(8)
X# define ARCHERYMOVE	(9)
X# define UNPIN		(10)
X# define UNPINEXP	(11)
X# define EXPLOREROOM	(12)
X# define FINDROOM	(13)
X# define RESTMOVE	(14)
X# define DOWNMOVE	(15)
X# define RUNDOWN	(16)
X# define NUMMOVES	(17)
X
X/* Version numbers */
X# define RV36A		(361)	/* OLDROG: Rogue 3.6 w/o wands */
X# define RV36B		(362)	/* CURROG: Rogue 3.6 with wands */
X# define RV52A		(521)	/* NEWROG: Rogue 5.2 */
X# define RV52B		(522)	/* Rogue 5.2 with maze rooms */
X# define RV53A		(531)	/* Rogue 5.3 new monsters */
X
X/* Ways to spend time */
X
X# define T_OTHER	(0)
X# define T_HANDLING	(1)
X# define T_FIGHTING	(2)
X# define T_RESTING	(3)
X# define T_MOVING	(4)
X# define T_EXPLORING	(5)
X# define T_RUNNING	(6)
X# define T_GROPING	(7)
X# define T_SEARCHING	(8)
X# define T_DOORSRCH	(9)
X# define T_LISTLEN	(10)
X
X/* Bit value for debugging types (for debugging function dwait) */
X
X# define D_FATAL	(00001)
X# define D_ERROR	(00002)
X# define D_WARNING	(00004)
X# define D_INFORM	(00010)
X# define D_SEARCH	(00020)
X# define D_BATTLE	(00040)
X# define D_MESSAGE	(00100)
X# define D_PACK		(00200)
X# define D_CONTROL	(00400)
X# define D_SCREEN	(01000)
X# define D_MONSTER	(02000)
X# define D_SAY		(04000)
X# define D_ALL		(01777)
X# define D_NORMAL	(D_FATAL | D_ERROR)
X
X# define debugon(mask)	(debugging|=(mask))
X# define debugoff(mask)	(debugging&=(~(mask)))
X# define debug(mask)	(debugging&(mask))
X
X/* Parameters for genetic learning, knobs */
X# define K_SRCH		(0)
X# define K_DOOR		(1)
X# define K_REST		(2)
X# define K_ARCH		(3)
X# define K_EXPER	(4)
X# define K_RUN		(5)
X# define K_WAKE		(6)
X# define K_FOOD		(7)
X# define MAXKNOB	(8)
X
X/* Monster attributes */
X# define AWAKE		(1)
X# define ASLEEP		(2)
X# define ALL		(9)
X# define HELD		(10)
X
X/* Constants for handling inventory */
X# define UNKNOWN	-99999
X# define INVMAX		25
X
X/* Pack item attributes  DR UTexas 25 Jan 84 */
X# define KNOWN                 (0000000001)
X# define CURSED                (0000000002)
X# define ENCHANTED             (0000000004)
X# define PROTECTED             (0000000010)
X# define UNCURSED              (0000000020)
X# define INUSE                 (0000000040)
X# define WORTHLESS             (0000000100)
X
X/* Miscellaneous macros */
X
X# define LETTER(i)	((char)((i)+'a'))
X# define DIGIT(c)	((int)((c)-'a'))
X# define OBJECT(c)	DIGIT(c)
X# define ISDIGIT(c)	((c) >= '0' && (c) <= '9')
X# define plural(n)	((n)==1 ? "" : "s")
X# define ordinal(n)	((((n)/10)%10==1) ? "th": \
X			      ((n)%10==1) ? "st": \
X			      ((n)%10==2) ? "nd": \
X			      ((n)%10==3) ? "rd":"th")
X# define ctrl(c)	((c)&037)
X# define ESC		ctrl('[')
X# define NEWLINE	ctrl('J')
X# define abs(a)		((a) >= 0 ? (a) : -(a))
X# define max(a,b)	(((a) > (b)) ? (a) : (b))
X# define min(a,b)	(((a) < (b)) ? (a) : (b))
X# define between(v,a,b)	((v) < (a) ? (a) : (v) > (b) ? (b) : (v))
X# define percent(v,p)	(((v)*(p))/100)
X# define SKIPARG	while (*++(*argv)); --(*argv)
X# define when	        break; case
X# define orwhen	        case
X# define otherwise      break; default
X# define SKIPDIG(s)	while (ISDIGIT(*(s))) (s)++
X# define SKIPCHAR(c,s)	while (*(s)==(c)) (s)++
X# define SKIPTO(c,s)	\
X	{ while (*(s) && *(s)!=(c)) (s)++; if (*(s)==(c)) (s)++; }
X
X/* Utility Macros */
X
X/* onrc - tell if row and col have the proper attributes */
X# define onrc(type,r,c) ((type)&scrmap[r][c])
X
X/* on - tell if current position has correct attributes */
X# define on(type) onrc(type,atrow,atcol)
X
X/* seerc - is this character at row,col */
X# define seerc(ch,r,c) ((ch)==screen[r][c])
X
X/* see - is this character at current position */
X# define see(ch) seerc(atrow,atcol)
X
X/* setrc - set attribute at <r,c> */
X# define setrc(type,r,c) scrmap[r][c]|=(type)
X
X/* set - set attribute at current position */
X# define set(type) setrc(type,atrow,atcol)
X
X/* unsetrc - unset attribute at <r,c> */
X# define unsetrc(type,r,c) scrmap[r][c]&= ~(type)
X
X/* unset - unset attribute at current position */
X# define unset(type) unsetrc(type,atrow,atcol)
X
X/* Direc - give the vector from an xy difference */
X# define direc(r,c) (r>0?(c>0?7:(c<0?5:6)):(r<0?(c>0?1:(c<0?3:2)):(c>0?0:4)))
X
X/* atdrow - gives row of adjacent square given direction */
X# define atdrow(dir) (atrow+deltr[(dir)])
X
X/* atdcol - gives col of adjacent square given direction */
X# define atdcol(dir) (atcol+deltc[(dir)])
X
X/* Define a more mnemonic string comparison */
X# define streq(s1,s2) (strcmp ((s1),(s2)) == 0)
X
X/* Monster value macros */
X# define maxhitchar(m) (cosmic ? Level*3/2+6 : monatt[(m)-'A'].maxdam)
X# define avghitchar(m) (cosmic ? Level*2/3+4 : monatt[(m)-'A'].expdam)
X# define maxhit(m) maxhitchar(mlist[m].chr)
X# define avghit(m) avghitchar(mlist[m].chr)     /* times 10 */
X
X/* Item knowledge macros   DR UTexas 25 Jan 84 */
X
X/* itemis - test pack item for traits */
X# define itemis(obj,trait) ((obj>=0) ? ((trait)&inven[obj].traits) : 0)
X
X/* remember - set traits for pack item */
X# define remember(obj,trait) ((obj>=0) ? (inven[obj].traits|=(trait)) : 0)
X
X/* forget - clear traits for pack item */
X# define forget(obj,trait) ((obj>=0) ? (inven[obj].traits&= ~(trait)) : 0)
X
X/* The types of objects */
Xtypedef enum { strange, food, potion, scroll, wand, ring, hitter,
X               thrower, missile, armor, amulet, gold, none} stuff;
X
Xtypedef struct { int   fail, win; } probability;
X
Xtypedef struct { int   count;
X		 double sum, sumsq, low, high; } statistic;
X
Xtypedef struct { int   scol, srow;
X                 stuff what; } stuffrec;
X
Xtypedef struct { int   mcol, mrow;
X                 char  chr;
X                 int   q; } monrec;
X
Xtypedef struct { int   expdam, maxdam, mtokill; } attrec;
X
Xtypedef struct { int gamecnt, gamesum, inittime, timeswritten; } lrnrec;
X
Xtypedef struct { char m_name[NAMSIZ];
X		 probability wehit, theyhit, arrowhit;
X		 statistic htokill, damage, atokill; } ltmrec;
X
Xtypedef struct { stuff type; 
X                 int   count, phit, pdam, charges, traits;
X		 char  *str;  } invrec;
X
Xtypedef struct { int activity[T_LISTLEN];
X		 int timestamp; } timerec;
/
echo 'Part 08 of Rog-O-Matic XIV complete.'
exit