src/u_init.c

   1 /* NetHack 3.6  u_init.c        $NHDT-Date: 1446861772 2015/11/07 02:02:52 $  $NHDT-Branch: master $:$NHDT-Revision: 1.35 $ */
   2 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   3 /* NetHack may be freely redistributed.  See license for details. */
   4
   5 #include "hack.h"
   6
   7 struct trobj {
   8     short trotyp;
   9     schar trspe;
  10     char trclass;
  11     Bitfield(trquan, 6);
  12     Bitfield(trbless, 2);
  13 };
  14
  15 STATIC_DCL void FDECL(ini_inv, (struct trobj *));
  16 STATIC_DCL void FDECL(knows_object, (int));
  17 STATIC_DCL void FDECL(knows_class, (CHAR_P));
  18 STATIC_DCL boolean FDECL(restricted_spell_discipline, (int));
  19
  20 #define UNDEF_TYP 0
  21 #define UNDEF_SPE '\177'
  22 #define UNDEF_BLESS 2
  23
  24 /*
  25  *      Initial inventory for the various roles.
  26  */
  27
  28 static struct trobj Archeologist[] = {
  29     /* if adventure has a name...  idea from tan@uvm-gen */
  30     { BULLWHIP, 2, WEAPON_CLASS, 1, UNDEF_BLESS },
  31     { LEATHER_JACKET, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  32     { FEDORA, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  33     { FOOD_RATION, 0, FOOD_CLASS, 3, 0 },
  34     { PICK_AXE, UNDEF_SPE, TOOL_CLASS, 1, UNDEF_BLESS },
  35     { TINNING_KIT, UNDEF_SPE, TOOL_CLASS, 1, UNDEF_BLESS },
  36     { TOUCHSTONE, 0, GEM_CLASS, 1, 0 },
  37     { SACK, 0, TOOL_CLASS, 1, 0 },
  38     { 0, 0, 0, 0, 0 }
  39 };
  40 static struct trobj Barbarian[] = {
  41 #define B_MAJOR 0 /* two-handed sword or battle-axe  */
  42 #define B_MINOR 1 /* matched with axe or short sword */
  43     { TWO_HANDED_SWORD, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
  44     { AXE, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
  45     { RING_MAIL, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  46     { FOOD_RATION, 0, FOOD_CLASS, 1, 0 },
  47     { 0, 0, 0, 0, 0 }
  48 };
  49 static struct trobj Cave_man[] = {
  50 #define C_AMMO 2
  51     { CLUB, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
  52     { SLING, 2, WEAPON_CLASS, 1, UNDEF_BLESS },
  53     { FLINT, 0, GEM_CLASS, 15, UNDEF_BLESS }, /* quan is variable */
  54     { ROCK, 0, GEM_CLASS, 3, 0 },             /* yields 18..33 */
  55     { LEATHER_ARMOR, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  56     { 0, 0, 0, 0, 0 }
  57 };
  58 static struct trobj Healer[] = {
  59     { SCALPEL, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
  60     { LEATHER_GLOVES, 1, ARMOR_CLASS, 1, UNDEF_BLESS },
  61     { STETHOSCOPE, 0, TOOL_CLASS, 1, 0 },
  62     { POT_HEALING, 0, POTION_CLASS, 4, UNDEF_BLESS },
  63     { POT_EXTRA_HEALING, 0, POTION_CLASS, 4, UNDEF_BLESS },
  64     { WAN_SLEEP, UNDEF_SPE, WAND_CLASS, 1, UNDEF_BLESS },
  65     /* always blessed, so it's guaranteed readable */
  66     { SPE_HEALING, 0, SPBOOK_CLASS, 1, 1 },
  67     { SPE_EXTRA_HEALING, 0, SPBOOK_CLASS, 1, 1 },
  68     { SPE_STONE_TO_FLESH, 0, SPBOOK_CLASS, 1, 1 },
  69     { APPLE, 0, FOOD_CLASS, 5, 0 },
  70     { 0, 0, 0, 0, 0 }
  71 };
  72 static struct trobj Knight[] = {
  73     { LONG_SWORD, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
  74     { LANCE, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
  75     { RING_MAIL, 1, ARMOR_CLASS, 1, UNDEF_BLESS },
  76     { HELMET, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  77     { SMALL_SHIELD, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  78     { LEATHER_GLOVES, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
  79     { APPLE, 0, FOOD_CLASS, 10, 0 },
  80     { CARROT, 0, FOOD_CLASS, 10, 0 },
  81     { 0, 0, 0, 0, 0 }
  82 };
  83 static struct trobj Monk[] = {
  84 #define M_BOOK 2
  85     { LEATHER_GLOVES, 2, ARMOR_CLASS, 1, UNDEF_BLESS },
  86     { ROBE, 1, ARMOR_CLASS, 1, UNDEF_BLESS },
  87     { UNDEF_TYP, UNDEF_SPE, SPBOOK_CLASS, 1, 1 },
  88     { UNDEF_TYP, UNDEF_SPE, SCROLL_CLASS, 1, UNDEF_BLESS },
  89     { POT_HEALING, 0, POTION_CLASS, 3, UNDEF_BLESS },
  90     { FOOD_RATION, 0, FOOD_CLASS, 3, 0 },
  91     { APPLE, 0, FOOD_CLASS, 5, UNDEF_BLESS },
  92     { ORANGE, 0, FOOD_CLASS, 5, UNDEF_BLESS },
  93     /* Yes, we know fortune cookies aren't really from China.  They were
  94      * invented by George Jung in Los Angeles, California, USA in 1916.
  95      */
  96     { FORTUNE_COOKIE, 0, FOOD_CLASS, 3, UNDEF_BLESS },
  97     { 0, 0, 0, 0, 0 }
  98 };
  99 static struct trobj Priest[] = {
 100     { MACE, 1, WEAPON_CLASS, 1, 1 },
 101     { ROBE, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
 102     { SMALL_SHIELD, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
 103     { POT_WATER, 0, POTION_CLASS, 4, 1 }, /* holy water */
 104     { CLOVE_OF_GARLIC, 0, FOOD_CLASS, 1, 0 },
 105     { SPRIG_OF_WOLFSBANE, 0, FOOD_CLASS, 1, 0 },
 106     { UNDEF_TYP, UNDEF_SPE, SPBOOK_CLASS, 2, UNDEF_BLESS },
 107     { 0, 0, 0, 0, 0 }
 108 };
 109 static struct trobj Ranger[] = {
 110 #define RAN_BOW 1
 111 #define RAN_TWO_ARROWS 2
 112 #define RAN_ZERO_ARROWS 3
 113     { DAGGER, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
 114     { BOW, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
 115     { ARROW, 2, WEAPON_CLASS, 50, UNDEF_BLESS },
 116     { ARROW, 0, WEAPON_CLASS, 30, UNDEF_BLESS },
 117     { CLOAK_OF_DISPLACEMENT, 2, ARMOR_CLASS, 1, UNDEF_BLESS },
 118     { CRAM_RATION, 0, FOOD_CLASS, 4, 0 },
 119     { 0, 0, 0, 0, 0 }
 120 };
 121 static struct trobj Rogue[] = {
 122 #define R_DAGGERS 1
 123     { SHORT_SWORD, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
 124     { DAGGER, 0, WEAPON_CLASS, 10, 0 }, /* quan is variable */
 125     { LEATHER_ARMOR, 1, ARMOR_CLASS, 1, UNDEF_BLESS },
 126     { POT_SICKNESS, 0, POTION_CLASS, 1, 0 },
 127     { LOCK_PICK, 9, TOOL_CLASS, 1, 0 },
 128     { SACK, 0, TOOL_CLASS, 1, 0 },
 129     { 0, 0, 0, 0, 0 }
 130 };
 131 static struct trobj Samurai[] = {
 132 #define S_ARROWS 3
 133     { KATANA, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
 134     { SHORT_SWORD, 0, WEAPON_CLASS, 1, UNDEF_BLESS }, /* wakizashi */
 135     { YUMI, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
 136     { YA, 0, WEAPON_CLASS, 25, UNDEF_BLESS }, /* variable quan */
 137     { SPLINT_MAIL, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
 138     { 0, 0, 0, 0, 0 }
 139 };
 140 static struct trobj Tourist[] = {
 141 #define T_DARTS 0
 142     { DART, 2, WEAPON_CLASS, 25, UNDEF_BLESS }, /* quan is variable */
 143     { UNDEF_TYP, UNDEF_SPE, FOOD_CLASS, 10, 0 },
 144     { POT_EXTRA_HEALING, 0, POTION_CLASS, 2, UNDEF_BLESS },
 145     { SCR_MAGIC_MAPPING, 0, SCROLL_CLASS, 4, UNDEF_BLESS },
 146     { HAWAIIAN_SHIRT, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
 147     { EXPENSIVE_CAMERA, UNDEF_SPE, TOOL_CLASS, 1, 0 },
 148     { CREDIT_CARD, 0, TOOL_CLASS, 1, 0 },
 149     { 0, 0, 0, 0, 0 }
 150 };
 151 static struct trobj Valkyrie[] = {
 152     { LONG_SWORD, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
 153     { DAGGER, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
 154     { SMALL_SHIELD, 3, ARMOR_CLASS, 1, UNDEF_BLESS },
 155     { FOOD_RATION, 0, FOOD_CLASS, 1, 0 },
 156     { 0, 0, 0, 0, 0 }
 157 };
 158 static struct trobj Wizard[] = {
 159 #define W_MULTSTART 2
 160 #define W_MULTEND 6
 161     { QUARTERSTAFF, 1, WEAPON_CLASS, 1, 1 },
 162     { CLOAK_OF_MAGIC_RESISTANCE, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
 163     { UNDEF_TYP, UNDEF_SPE, WAND_CLASS, 1, UNDEF_BLESS },
 164     { UNDEF_TYP, UNDEF_SPE, RING_CLASS, 2, UNDEF_BLESS },
 165     { UNDEF_TYP, UNDEF_SPE, POTION_CLASS, 3, UNDEF_BLESS },
 166     { UNDEF_TYP, UNDEF_SPE, SCROLL_CLASS, 3, UNDEF_BLESS },
 167     { SPE_FORCE_BOLT, 0, SPBOOK_CLASS, 1, 1 },
 168     { UNDEF_TYP, UNDEF_SPE, SPBOOK_CLASS, 1, UNDEF_BLESS },
 169     { 0, 0, 0, 0, 0 }
 170 };
 171
 172 /*
 173  *      Optional extra inventory items.
 174  */
 175
 176 static struct trobj Tinopener[] = { { TIN_OPENER, 0, TOOL_CLASS, 1, 0 },
 177                                     { 0, 0, 0, 0, 0 } };
 178 static struct trobj Magicmarker[] = { { MAGIC_MARKER, UNDEF_SPE, TOOL_CLASS,
 179                                         1, 0 },
 180                                       { 0, 0, 0, 0, 0 } };
 181 static struct trobj Lamp[] = { { OIL_LAMP, 1, TOOL_CLASS, 1, 0 },
 182                                { 0, 0, 0, 0, 0 } };
 183 static struct trobj Blindfold[] = { { BLINDFOLD, 0, TOOL_CLASS, 1, 0 },
 184                                     { 0, 0, 0, 0, 0 } };
 185 static struct trobj Instrument[] = { { WOODEN_FLUTE, 0, TOOL_CLASS, 1, 0 },
 186                                      { 0, 0, 0, 0, 0 } };
 187 static struct trobj Xtra_food[] = { { UNDEF_TYP, UNDEF_SPE, FOOD_CLASS, 2, 0 },
 188                                     { 0, 0, 0, 0, 0 } };
 189 static struct trobj Leash[] = { { LEASH, 0, TOOL_CLASS, 1, 0 },
 190                                 { 0, 0, 0, 0, 0 } };
 191 static struct trobj Towel[] = { { TOWEL, 0, TOOL_CLASS, 1, 0 },
 192                                 { 0, 0, 0, 0, 0 } };
 193 static struct trobj Wishing[] = { { WAN_WISHING, 3, WAND_CLASS, 1, 0 },
 194                                   { 0, 0, 0, 0, 0 } };
 195 static struct trobj Money[] = { { GOLD_PIECE, 0, COIN_CLASS, 1, 0 },
 196                                 { 0, 0, 0, 0, 0 } };
 197
 198 /* race-based substitutions for initial inventory;
 199    the weaker cloak for elven rangers is intentional--they shoot better */
 200 static struct inv_sub {
 201     short race_pm, item_otyp, subs_otyp;
 202 } inv_subs[] = {
 203     { PM_ELF, DAGGER, ELVEN_DAGGER },
 204     { PM_ELF, SPEAR, ELVEN_SPEAR },
 205     { PM_ELF, SHORT_SWORD, ELVEN_SHORT_SWORD },
 206     { PM_ELF, BOW, ELVEN_BOW },
 207     { PM_ELF, ARROW, ELVEN_ARROW },
 208     { PM_ELF, HELMET, ELVEN_LEATHER_HELM },
 209     /* { PM_ELF, SMALL_SHIELD, ELVEN_SHIELD }, */
 210     { PM_ELF, CLOAK_OF_DISPLACEMENT, ELVEN_CLOAK },
 211     { PM_ELF, CRAM_RATION, LEMBAS_WAFER },
 212     { PM_ORC, DAGGER, ORCISH_DAGGER },
 213     { PM_ORC, SPEAR, ORCISH_SPEAR },
 214     { PM_ORC, SHORT_SWORD, ORCISH_SHORT_SWORD },
 215     { PM_ORC, BOW, ORCISH_BOW },
 216     { PM_ORC, ARROW, ORCISH_ARROW },
 217     { PM_ORC, HELMET, ORCISH_HELM },
 218     { PM_ORC, SMALL_SHIELD, ORCISH_SHIELD },
 219     { PM_ORC, RING_MAIL, ORCISH_RING_MAIL },
 220     { PM_ORC, CHAIN_MAIL, ORCISH_CHAIN_MAIL },
 221     { PM_DWARF, SPEAR, DWARVISH_SPEAR },
 222     { PM_DWARF, SHORT_SWORD, DWARVISH_SHORT_SWORD },
 223     { PM_DWARF, HELMET, DWARVISH_IRON_HELM },
 224     /* { PM_DWARF, SMALL_SHIELD, DWARVISH_ROUNDSHIELD }, */
 225     /* { PM_DWARF, PICK_AXE, DWARVISH_MATTOCK }, */
 226     { PM_GNOME, BOW, CROSSBOW },
 227     { PM_GNOME, ARROW, CROSSBOW_BOLT },
 228     { NON_PM, STRANGE_OBJECT, STRANGE_OBJECT }
 229 };
 230
 231 static const struct def_skill Skill_A[] = {
 232     { P_DAGGER, P_BASIC },
 233     { P_KNIFE, P_BASIC },
 234     { P_PICK_AXE, P_EXPERT },
 235     { P_SHORT_SWORD, P_BASIC },
 236     { P_SCIMITAR, P_SKILLED },
 237     { P_SABER, P_EXPERT },
 238     { P_CLUB, P_SKILLED },
 239     { P_QUARTERSTAFF, P_SKILLED },
 240     { P_SLING, P_SKILLED },
 241     { P_DART, P_BASIC },
 242     { P_BOOMERANG, P_EXPERT },
 243     { P_WHIP, P_EXPERT },
 244     { P_UNICORN_HORN, P_SKILLED },
 245     { P_ATTACK_SPELL, P_BASIC },
 246     { P_HEALING_SPELL, P_BASIC },
 247     { P_DIVINATION_SPELL, P_EXPERT },
 248     { P_MATTER_SPELL, P_BASIC },
 249     { P_RIDING, P_BASIC },
 250     { P_TWO_WEAPON_COMBAT, P_BASIC },
 251     { P_BARE_HANDED_COMBAT, P_EXPERT },
 252     { P_NONE, 0 }
 253 };
 254 static const struct def_skill Skill_B[] = {
 255     { P_DAGGER, P_BASIC },
 256     { P_AXE, P_EXPERT },
 257     { P_PICK_AXE, P_SKILLED },
 258     { P_SHORT_SWORD, P_EXPERT },
 259     { P_BROAD_SWORD, P_SKILLED },
 260     { P_LONG_SWORD, P_SKILLED },
 261     { P_TWO_HANDED_SWORD, P_EXPERT },
 262     { P_SCIMITAR, P_SKILLED },
 263     { P_SABER, P_BASIC },
 264     { P_CLUB, P_SKILLED },
 265     { P_MACE, P_SKILLED },
 266     { P_MORNING_STAR, P_SKILLED },
 267     { P_FLAIL, P_BASIC },
 268     { P_HAMMER, P_EXPERT },
 269     { P_QUARTERSTAFF, P_BASIC },
 270     { P_SPEAR, P_SKILLED },
 271     { P_TRIDENT, P_SKILLED },
 272     { P_BOW, P_BASIC },
 273     { P_ATTACK_SPELL, P_SKILLED },
 274     { P_RIDING, P_BASIC },
 275     { P_TWO_WEAPON_COMBAT, P_BASIC },
 276     { P_BARE_HANDED_COMBAT, P_MASTER },
 277     { P_NONE, 0 }
 278 };
 279 static const struct def_skill Skill_C[] = {
 280     { P_DAGGER, P_BASIC },
 281     { P_KNIFE, P_SKILLED },
 282     { P_AXE, P_SKILLED },
 283     { P_PICK_AXE, P_BASIC },
 284     { P_CLUB, P_EXPERT },
 285     { P_MACE, P_EXPERT },
 286     { P_MORNING_STAR, P_BASIC },
 287     { P_FLAIL, P_SKILLED },
 288     { P_HAMMER, P_SKILLED },
 289     { P_QUARTERSTAFF, P_EXPERT },
 290     { P_POLEARMS, P_SKILLED },
 291     { P_SPEAR, P_EXPERT },
 292     { P_TRIDENT, P_SKILLED },
 293     { P_BOW, P_SKILLED },
 294     { P_SLING, P_EXPERT },
 295     { P_ATTACK_SPELL, P_BASIC },
 296     { P_MATTER_SPELL, P_SKILLED },
 297     { P_BOOMERANG, P_EXPERT },
 298     { P_UNICORN_HORN, P_BASIC },
 299     { P_BARE_HANDED_COMBAT, P_MASTER },
 300     { P_NONE, 0 }
 301 };
 302 static const struct def_skill Skill_H[] = {
 303     { P_DAGGER, P_SKILLED },
 304     { P_KNIFE, P_EXPERT },
 305     { P_SHORT_SWORD, P_SKILLED },
 306     { P_SCIMITAR, P_BASIC },
 307     { P_SABER, P_BASIC },
 308     { P_CLUB, P_SKILLED },
 309     { P_MACE, P_BASIC },
 310     { P_QUARTERSTAFF, P_EXPERT },
 311     { P_POLEARMS, P_BASIC },
 312     { P_SPEAR, P_BASIC },
 313     { P_TRIDENT, P_BASIC },
 314     { P_SLING, P_SKILLED },
 315     { P_DART, P_EXPERT },
 316     { P_SHURIKEN, P_SKILLED },
 317     { P_UNICORN_HORN, P_EXPERT },
 318     { P_HEALING_SPELL, P_EXPERT },
 319     { P_BARE_HANDED_COMBAT, P_BASIC },
 320     { P_NONE, 0 }
 321 };
 322 static const struct def_skill Skill_K[] = {
 323     { P_DAGGER, P_BASIC },
 324     { P_KNIFE, P_BASIC },
 325     { P_AXE, P_SKILLED },
 326     { P_PICK_AXE, P_BASIC },
 327     { P_SHORT_SWORD, P_SKILLED },
 328     { P_BROAD_SWORD, P_SKILLED },
 329     { P_LONG_SWORD, P_EXPERT },
 330     { P_TWO_HANDED_SWORD, P_SKILLED },
 331     { P_SCIMITAR, P_BASIC },
 332     { P_SABER, P_SKILLED },
 333     { P_CLUB, P_BASIC },
 334     { P_MACE, P_SKILLED },
 335     { P_MORNING_STAR, P_SKILLED },
 336     { P_FLAIL, P_BASIC },
 337     { P_HAMMER, P_BASIC },
 338     { P_POLEARMS, P_SKILLED },
 339     { P_SPEAR, P_SKILLED },
 340     { P_TRIDENT, P_BASIC },
 341     { P_LANCE, P_EXPERT },
 342     { P_BOW, P_BASIC },
 343     { P_CROSSBOW, P_SKILLED },
 344     { P_ATTACK_SPELL, P_SKILLED },
 345     { P_HEALING_SPELL, P_SKILLED },
 346     { P_CLERIC_SPELL, P_SKILLED },
 347     { P_RIDING, P_EXPERT },
 348     { P_TWO_WEAPON_COMBAT, P_SKILLED },
 349     { P_BARE_HANDED_COMBAT, P_EXPERT },
 350     { P_NONE, 0 }
 351 };
 352 static const struct def_skill Skill_Mon[] = {
 353     { P_QUARTERSTAFF, P_BASIC },
 354     { P_SPEAR, P_BASIC },
 355     { P_CROSSBOW, P_BASIC },
 356     { P_SHURIKEN, P_BASIC },
 357     { P_ATTACK_SPELL, P_BASIC },
 358     { P_HEALING_SPELL, P_EXPERT },
 359     { P_DIVINATION_SPELL, P_BASIC },
 360     { P_ENCHANTMENT_SPELL, P_BASIC },
 361     { P_CLERIC_SPELL, P_SKILLED },
 362     { P_ESCAPE_SPELL, P_SKILLED },
 363     { P_MATTER_SPELL, P_BASIC },
 364     { P_MARTIAL_ARTS, P_GRAND_MASTER },
 365     { P_NONE, 0 }
 366 };
 367 static const struct def_skill Skill_P[] = {
 368     { P_CLUB, P_EXPERT },
 369     { P_MACE, P_EXPERT },
 370     { P_MORNING_STAR, P_EXPERT },
 371     { P_FLAIL, P_EXPERT },
 372     { P_HAMMER, P_EXPERT },
 373     { P_QUARTERSTAFF, P_EXPERT },
 374     { P_POLEARMS, P_SKILLED },
 375     { P_SPEAR, P_SKILLED },
 376     { P_TRIDENT, P_SKILLED },
 377     { P_LANCE, P_BASIC },
 378     { P_BOW, P_BASIC },
 379     { P_SLING, P_BASIC },
 380     { P_CROSSBOW, P_BASIC },
 381     { P_DART, P_BASIC },
 382     { P_SHURIKEN, P_BASIC },
 383     { P_BOOMERANG, P_BASIC },
 384     { P_UNICORN_HORN, P_SKILLED },
 385     { P_HEALING_SPELL, P_EXPERT },
 386     { P_DIVINATION_SPELL, P_EXPERT },
 387     { P_CLERIC_SPELL, P_EXPERT },
 388     { P_BARE_HANDED_COMBAT, P_BASIC },
 389     { P_NONE, 0 }
 390 };
 391 static const struct def_skill Skill_R[] = {
 392     { P_DAGGER, P_EXPERT },
 393     { P_KNIFE, P_EXPERT },
 394     { P_SHORT_SWORD, P_EXPERT },
 395     { P_BROAD_SWORD, P_SKILLED },
 396     { P_LONG_SWORD, P_SKILLED },
 397     { P_TWO_HANDED_SWORD, P_BASIC },
 398     { P_SCIMITAR, P_SKILLED },
 399     { P_SABER, P_SKILLED },
 400     { P_CLUB, P_SKILLED },
 401     { P_MACE, P_SKILLED },
 402     { P_MORNING_STAR, P_BASIC },
 403     { P_FLAIL, P_BASIC },
 404     { P_HAMMER, P_BASIC },
 405     { P_POLEARMS, P_BASIC },
 406     { P_SPEAR, P_BASIC },
 407     { P_CROSSBOW, P_EXPERT },
 408     { P_DART, P_EXPERT },
 409     { P_SHURIKEN, P_SKILLED },
 410     { P_DIVINATION_SPELL, P_SKILLED },
 411     { P_ESCAPE_SPELL, P_SKILLED },
 412     { P_MATTER_SPELL, P_SKILLED },
 413     { P_RIDING, P_BASIC },
 414     { P_TWO_WEAPON_COMBAT, P_EXPERT },
 415     { P_BARE_HANDED_COMBAT, P_EXPERT },
 416     { P_NONE, 0 }
 417 };
 418 static const struct def_skill Skill_Ran[] = {
 419     { P_DAGGER, P_EXPERT },
 420     { P_KNIFE, P_SKILLED },
 421     { P_AXE, P_SKILLED },
 422     { P_PICK_AXE, P_BASIC },
 423     { P_SHORT_SWORD, P_BASIC },
 424     { P_MORNING_STAR, P_BASIC },
 425     { P_FLAIL, P_SKILLED },
 426     { P_HAMMER, P_BASIC },
 427     { P_QUARTERSTAFF, P_BASIC },
 428     { P_POLEARMS, P_SKILLED },
 429     { P_SPEAR, P_EXPERT },
 430     { P_TRIDENT, P_BASIC },
 431     { P_BOW, P_EXPERT },
 432     { P_SLING, P_EXPERT },
 433     { P_CROSSBOW, P_EXPERT },
 434     { P_DART, P_EXPERT },
 435     { P_SHURIKEN, P_SKILLED },
 436     { P_BOOMERANG, P_EXPERT },
 437     { P_WHIP, P_BASIC },
 438     { P_HEALING_SPELL, P_BASIC },
 439     { P_DIVINATION_SPELL, P_EXPERT },
 440     { P_ESCAPE_SPELL, P_BASIC },
 441     { P_RIDING, P_BASIC },
 442     { P_BARE_HANDED_COMBAT, P_BASIC },
 443     { P_NONE, 0 }
 444 };
 445 static const struct def_skill Skill_S[] = {
 446     { P_DAGGER, P_BASIC },
 447     { P_KNIFE, P_SKILLED },
 448     { P_SHORT_SWORD, P_EXPERT },
 449     { P_BROAD_SWORD, P_SKILLED },
 450     { P_LONG_SWORD, P_EXPERT },
 451     { P_TWO_HANDED_SWORD, P_EXPERT },
 452     { P_SCIMITAR, P_BASIC },
 453     { P_SABER, P_BASIC },
 454     { P_FLAIL, P_SKILLED },
 455     { P_QUARTERSTAFF, P_BASIC },
 456     { P_POLEARMS, P_SKILLED },
 457     { P_SPEAR, P_SKILLED },
 458     { P_LANCE, P_SKILLED },
 459     { P_BOW, P_EXPERT },
 460     { P_SHURIKEN, P_EXPERT },
 461     { P_ATTACK_SPELL, P_SKILLED },
 462     { P_CLERIC_SPELL, P_SKILLED },
 463     { P_RIDING, P_SKILLED },
 464     { P_TWO_WEAPON_COMBAT, P_EXPERT },
 465     { P_MARTIAL_ARTS, P_MASTER },
 466     { P_NONE, 0 }
 467 };
 468 static const struct def_skill Skill_T[] = {
 469     { P_DAGGER, P_EXPERT },
 470     { P_KNIFE, P_SKILLED },
 471     { P_AXE, P_BASIC },
 472     { P_PICK_AXE, P_BASIC },
 473     { P_SHORT_SWORD, P_EXPERT },
 474     { P_BROAD_SWORD, P_BASIC },
 475     { P_LONG_SWORD, P_BASIC },
 476     { P_TWO_HANDED_SWORD, P_BASIC },
 477     { P_SCIMITAR, P_SKILLED },
 478     { P_SABER, P_SKILLED },
 479     { P_MACE, P_BASIC },
 480     { P_MORNING_STAR, P_BASIC },
 481     { P_FLAIL, P_BASIC },
 482     { P_HAMMER, P_BASIC },
 483     { P_QUARTERSTAFF, P_BASIC },
 484     { P_POLEARMS, P_BASIC },
 485     { P_SPEAR, P_BASIC },
 486     { P_TRIDENT, P_BASIC },
 487     { P_LANCE, P_BASIC },
 488     { P_BOW, P_BASIC },
 489     { P_SLING, P_BASIC },
 490     { P_CROSSBOW, P_BASIC },
 491     { P_DART, P_EXPERT },
 492     { P_SHURIKEN, P_BASIC },
 493     { P_BOOMERANG, P_BASIC },
 494     { P_WHIP, P_BASIC },
 495     { P_UNICORN_HORN, P_SKILLED },
 496     { P_DIVINATION_SPELL, P_BASIC },
 497     { P_ENCHANTMENT_SPELL, P_BASIC },
 498     { P_ESCAPE_SPELL, P_SKILLED },
 499     { P_RIDING, P_BASIC },
 500     { P_TWO_WEAPON_COMBAT, P_SKILLED },
 501     { P_BARE_HANDED_COMBAT, P_SKILLED },
 502     { P_NONE, 0 }
 503 };
 504 static const struct def_skill Skill_V[] = {
 505     { P_DAGGER, P_EXPERT },
 506     { P_AXE, P_EXPERT },
 507     { P_PICK_AXE, P_SKILLED },
 508     { P_SHORT_SWORD, P_SKILLED },
 509     { P_BROAD_SWORD, P_SKILLED },
 510     { P_LONG_SWORD, P_EXPERT },
 511     { P_TWO_HANDED_SWORD, P_EXPERT },
 512     { P_SCIMITAR, P_BASIC },
 513     { P_SABER, P_BASIC },
 514     { P_HAMMER, P_EXPERT },
 515     { P_QUARTERSTAFF, P_BASIC },
 516     { P_POLEARMS, P_SKILLED },
 517     { P_SPEAR, P_SKILLED },
 518     { P_TRIDENT, P_BASIC },
 519     { P_LANCE, P_SKILLED },
 520     { P_SLING, P_BASIC },
 521     { P_ATTACK_SPELL, P_BASIC },
 522     { P_ESCAPE_SPELL, P_BASIC },
 523     { P_RIDING, P_SKILLED },
 524     { P_TWO_WEAPON_COMBAT, P_SKILLED },
 525     { P_BARE_HANDED_COMBAT, P_EXPERT },
 526     { P_NONE, 0 }
 527 };
 528 static const struct def_skill Skill_W[] = {
 529     { P_DAGGER, P_EXPERT },
 530     { P_KNIFE, P_SKILLED },
 531     { P_AXE, P_SKILLED },
 532     { P_SHORT_SWORD, P_BASIC },
 533     { P_CLUB, P_SKILLED },
 534     { P_MACE, P_BASIC },
 535     { P_QUARTERSTAFF, P_EXPERT },
 536     { P_POLEARMS, P_SKILLED },
 537     { P_SPEAR, P_BASIC },
 538     { P_TRIDENT, P_BASIC },
 539     { P_SLING, P_SKILLED },
 540     { P_DART, P_EXPERT },
 541     { P_SHURIKEN, P_BASIC },
 542     { P_ATTACK_SPELL, P_EXPERT },
 543     { P_HEALING_SPELL, P_SKILLED },
 544     { P_DIVINATION_SPELL, P_EXPERT },
 545     { P_ENCHANTMENT_SPELL, P_SKILLED },
 546     { P_CLERIC_SPELL, P_SKILLED },
 547     { P_ESCAPE_SPELL, P_EXPERT },
 548     { P_MATTER_SPELL, P_EXPERT },
 549     { P_RIDING, P_BASIC },
 550     { P_BARE_HANDED_COMBAT, P_BASIC },
 551     { P_NONE, 0 }
 552 };
 553
 554 STATIC_OVL void
 555 knows_object(obj)
 556 register int obj;
 557 {
 558     discover_object(obj, TRUE, FALSE);
 559     objects[obj].oc_pre_discovered = 1; /* not a "discovery" */
 560 }
 561
 562 /* Know ordinary (non-magical) objects of a certain class,
 563  * like all gems except the loadstone and luckstone.
 564  */
 565 STATIC_OVL void
 566 knows_class(sym)
 567 register char sym;
 568 {
 569     register int ct;
 570     for (ct = 1; ct < NUM_OBJECTS; ct++)
 571         if (objects[ct].oc_class == sym && !objects[ct].oc_magic)
 572             knows_object(ct);
 573 }
 574
 575 void
 576 u_init()
 577 {
 578     register int i;
 579     struct u_roleplay tmpuroleplay = u.uroleplay; /* set by rcfile options */
 580
 581     flags.female = flags.initgend;
 582     flags.beginner = 1;
 583
 584     /* zero u, including pointer values --
 585      * necessary when aborting from a failed restore */
 586     (void) memset((genericptr_t) &u, 0, sizeof(u));
 587     u.ustuck = (struct monst *) 0;
 588     (void) memset((genericptr_t) &ubirthday, 0, sizeof(ubirthday));
 589     (void) memset((genericptr_t) &urealtime, 0, sizeof(urealtime));
 590
 591     u.uroleplay = tmpuroleplay; /* restore options set via rcfile */
 592
 593 #if 0  /* documentation of more zero values as desirable */
 594     u.usick_cause[0] = 0;
 595     u.uluck  = u.moreluck = 0;
 596     uarmu = 0;
 597     uarm = uarmc = uarmh = uarms = uarmg = uarmf = 0;
 598     uwep = uball = uchain = uleft = uright = 0;
 599     uswapwep = uquiver = 0;
 600     u.twoweap = 0;
 601     u.ublessed = 0;                     /* not worthy yet */
 602     u.ugangr   = 0;                     /* gods not angry */
 603     u.ugifts   = 0;                     /* no divine gifts bestowed */
 604     u.uevent.uhand_of_elbereth = 0;
 605     u.uevent.uheard_tune = 0;
 606     u.uevent.uopened_dbridge = 0;
 607     u.uevent.udemigod = 0;              /* not a demi-god yet... */
 608     u.udg_cnt = 0;
 609     u.mh = u.mhmax = u.mtimedone = 0;
 610     u.uz.dnum = u.uz0.dnum = 0;
 611     u.utotype = 0;
 612 #endif /* 0 */
 613
 614     u.uz.dlevel = 1;
 615     u.uz0.dlevel = 0;
 616     u.utolev = u.uz;
 617
 618     u.umoved = FALSE;
 619     u.umortality = 0;
 620     u.ugrave_arise = NON_PM;
 621
 622     u.umonnum = u.umonster = (flags.female && urole.femalenum != NON_PM)
 623                                  ? urole.femalenum
 624                                  : urole.malenum;
 625     u.ulycn = NON_PM;
 626     set_uasmon();
 627
 628     u.ulevel = 0; /* set up some of the initial attributes */
 629     u.uhp = u.uhpmax = newhp();
 630     u.uen = u.uenmax = newpw();
 631     u.uspellprot = 0;
 632     adjabil(0, 1);
 633     u.ulevel = u.ulevelmax = 1;
 634
 635     init_uhunger();
 636     for (i = 0; i <= MAXSPELL; i++)
 637         spl_book[i].sp_id = NO_SPELL;
 638     u.ublesscnt = 300; /* no prayers just yet */
 639     u.ualignbase[A_CURRENT] = u.ualignbase[A_ORIGINAL] = u.ualign.type =
 640         aligns[flags.initalign].value;
 641
 642 #if defined(BSD) && !defined(POSIX_TYPES)
 643     (void) time((long *) &ubirthday);
 644 #else
 645     (void) time(&ubirthday);
 646 #endif
 647
 648     /*
 649      *  For now, everyone starts out with a night vision range of 1 and
 650      *  their xray range disabled.
 651      */
 652     u.nv_range = 1;
 653     u.xray_range = -1;
 654
 655     /*** Role-specific initializations ***/
 656     switch (Role_switch) {
 657     /* rn2(100) > 50 necessary for some choices because some
 658      * random number generators are bad enough to seriously
 659      * skew the results if we use rn2(2)...  --KAA
 660      */
 661     case PM_ARCHEOLOGIST:
 662         ini_inv(Archeologist);
 663         if (!rn2(10))
 664             ini_inv(Tinopener);
 665         else if (!rn2(4))
 666             ini_inv(Lamp);
 667         else if (!rn2(10))
 668             ini_inv(Magicmarker);
 669         knows_object(SACK);
 670         knows_object(TOUCHSTONE);
 671         skill_init(Skill_A);
 672         break;
 673     case PM_BARBARIAN:
 674         if (rn2(100) >= 50) { /* see above comment */
 675             Barbarian[B_MAJOR].trotyp = BATTLE_AXE;
 676             Barbarian[B_MINOR].trotyp = SHORT_SWORD;
 677         }
 678         ini_inv(Barbarian);
 679         if (!rn2(6))
 680             ini_inv(Lamp);
 681         knows_class(WEAPON_CLASS);
 682         knows_class(ARMOR_CLASS);
 683         skill_init(Skill_B);
 684         break;
 685     case PM_CAVEMAN:
 686         Cave_man[C_AMMO].trquan = rn1(11, 10); /* 10..20 */
 687         ini_inv(Cave_man);
 688         skill_init(Skill_C);
 689         break;
 690     case PM_HEALER:
 691         u.umoney0 = rn1(1000, 1001);
 692         ini_inv(Healer);
 693         if (!rn2(25))
 694             ini_inv(Lamp);
 695         knows_object(POT_FULL_HEALING);
 696         skill_init(Skill_H);
 697         break;
 698     case PM_KNIGHT:
 699         ini_inv(Knight);
 700         knows_class(WEAPON_CLASS);
 701         knows_class(ARMOR_CLASS);
 702         /* give knights chess-like mobility
 703          * -- idea from wooledge@skybridge.scl.cwru.edu */
 704         HJumping |= FROMOUTSIDE;
 705         skill_init(Skill_K);
 706         break;
 707     case PM_MONK:
 708         switch (rn2(90) / 30) {
 709         case 0:
 710             Monk[M_BOOK].trotyp = SPE_HEALING;
 711             break;
 712         case 1:
 713             Monk[M_BOOK].trotyp = SPE_PROTECTION;
 714             break;
 715         case 2:
 716             Monk[M_BOOK].trotyp = SPE_SLEEP;
 717             break;
 718         }
 719         ini_inv(Monk);
 720         if (!rn2(5))
 721             ini_inv(Magicmarker);
 722         else if (!rn2(10))
 723             ini_inv(Lamp);
 724         knows_class(ARMOR_CLASS);
 725         skill_init(Skill_Mon);
 726         break;
 727     case PM_PRIEST:
 728         ini_inv(Priest);
 729         if (!rn2(10))
 730             ini_inv(Magicmarker);
 731         else if (!rn2(10))
 732             ini_inv(Lamp);
 733         knows_object(POT_WATER);
 734         skill_init(Skill_P);
 735         /* KMH, conduct --
 736          * Some may claim that this isn't agnostic, since they
 737          * are literally "priests" and they have holy water.
 738          * But we don't count it as such.  Purists can always
 739          * avoid playing priests and/or confirm another player's
 740          * role in their YAAP.
 741          */
 742         break;
 743     case PM_RANGER:
 744         Ranger[RAN_TWO_ARROWS].trquan = rn1(10, 50);
 745         Ranger[RAN_ZERO_ARROWS].trquan = rn1(10, 30);
 746         ini_inv(Ranger);
 747         skill_init(Skill_Ran);
 748         break;
 749     case PM_ROGUE:
 750         Rogue[R_DAGGERS].trquan = rn1(10, 6);
 751         u.umoney0 = 0;
 752         ini_inv(Rogue);
 753         if (!rn2(5))
 754             ini_inv(Blindfold);
 755         knows_object(SACK);
 756         skill_init(Skill_R);
 757         break;
 758     case PM_SAMURAI:
 759         Samurai[S_ARROWS].trquan = rn1(20, 26);
 760         ini_inv(Samurai);
 761         if (!rn2(5))
 762             ini_inv(Blindfold);
 763         knows_class(WEAPON_CLASS);
 764         knows_class(ARMOR_CLASS);
 765         skill_init(Skill_S);
 766         break;
 767     case PM_TOURIST:
 768         Tourist[T_DARTS].trquan = rn1(20, 21);
 769         u.umoney0 = rnd(1000);
 770         ini_inv(Tourist);
 771         if (!rn2(25))
 772             ini_inv(Tinopener);
 773         else if (!rn2(25))
 774             ini_inv(Leash);
 775         else if (!rn2(25))
 776             ini_inv(Towel);
 777         else if (!rn2(25))
 778             ini_inv(Magicmarker);
 779         skill_init(Skill_T);
 780         break;
 781     case PM_VALKYRIE:
 782         ini_inv(Valkyrie);
 783         if (!rn2(6))
 784             ini_inv(Lamp);
 785         knows_class(WEAPON_CLASS);
 786         knows_class(ARMOR_CLASS);
 787         skill_init(Skill_V);
 788         break;
 789     case PM_WIZARD:
 790         ini_inv(Wizard);
 791         if (!rn2(5))
 792             ini_inv(Magicmarker);
 793         if (!rn2(5))
 794             ini_inv(Blindfold);
 795         skill_init(Skill_W);
 796         break;
 797
 798     default: /* impossible */
 799         break;
 800     }
 801
 802     /*** Race-specific initializations ***/
 803     switch (Race_switch) {
 804     case PM_HUMAN:
 805         /* Nothing special */
 806         break;
 807
 808     case PM_ELF:
 809         /*
 810          * Elves are people of music and song, or they are warriors.
 811          * Non-warriors get an instrument.  We use a kludge to
 812          * get only non-magic instruments.
 813          */
 814         if (Role_if(PM_PRIEST) || Role_if(PM_WIZARD)) {
 815             static int trotyp[] = { WOODEN_FLUTE, TOOLED_HORN, WOODEN_HARP,
 816                                     BELL,         BUGLE,       LEATHER_DRUM };
 817             Instrument[0].trotyp = trotyp[rn2(SIZE(trotyp))];
 818             ini_inv(Instrument);
 819         }
 820
 821         /* Elves can recognize all elvish objects */
 822         knows_object(ELVEN_SHORT_SWORD);
 823         knows_object(ELVEN_ARROW);
 824         knows_object(ELVEN_BOW);
 825         knows_object(ELVEN_SPEAR);
 826         knows_object(ELVEN_DAGGER);
 827         knows_object(ELVEN_BROADSWORD);
 828         knows_object(ELVEN_MITHRIL_COAT);
 829         knows_object(ELVEN_LEATHER_HELM);
 830         knows_object(ELVEN_SHIELD);
 831         knows_object(ELVEN_BOOTS);
 832         knows_object(ELVEN_CLOAK);
 833         break;
 834
 835     case PM_DWARF:
 836         /* Dwarves can recognize all dwarvish objects */
 837         knows_object(DWARVISH_SPEAR);
 838         knows_object(DWARVISH_SHORT_SWORD);
 839         knows_object(DWARVISH_MATTOCK);
 840         knows_object(DWARVISH_IRON_HELM);
 841         knows_object(DWARVISH_MITHRIL_COAT);
 842         knows_object(DWARVISH_CLOAK);
 843         knows_object(DWARVISH_ROUNDSHIELD);
 844         break;
 845
 846     case PM_GNOME:
 847         break;
 848
 849     case PM_ORC:
 850         /* compensate for generally inferior equipment */
 851         if (!Role_if(PM_WIZARD))
 852             ini_inv(Xtra_food);
 853         /* Orcs can recognize all orcish objects */
 854         knows_object(ORCISH_SHORT_SWORD);
 855         knows_object(ORCISH_ARROW);
 856         knows_object(ORCISH_BOW);
 857         knows_object(ORCISH_SPEAR);
 858         knows_object(ORCISH_DAGGER);
 859         knows_object(ORCISH_CHAIN_MAIL);
 860         knows_object(ORCISH_RING_MAIL);
 861         knows_object(ORCISH_HELM);
 862         knows_object(ORCISH_SHIELD);
 863         knows_object(URUK_HAI_SHIELD);
 864         knows_object(ORCISH_CLOAK);
 865         break;
 866
 867     default: /* impossible */
 868         break;
 869     }
 870
 871     if (discover)
 872         ini_inv(Wishing);
 873
 874     if (wizard)
 875         read_wizkit();
 876
 877     if (u.umoney0)
 878         ini_inv(Money);
 879     u.umoney0 += hidden_gold(); /* in case sack has gold in it */
 880
 881     find_ac();     /* get initial ac value */
 882     init_attr(75); /* init attribute values */
 883     max_rank_sz(); /* set max str size for class ranks */
 884     /*
 885      *  Do we really need this?
 886      */
 887     for (i = 0; i < A_MAX; i++)
 888         if (!rn2(20)) {
 889             register int xd = rn2(7) - 2; /* biased variation */
 890
 891             (void) adjattrib(i, xd, TRUE);
 892             if (ABASE(i) < AMAX(i))
 893                 AMAX(i) = ABASE(i);
 894         }
 895
 896     /* make sure you can carry all you have - especially for Tourists */
 897     while (inv_weight() > 0) {
 898         if (adjattrib(A_STR, 1, TRUE))
 899             continue;
 900         if (adjattrib(A_CON, 1, TRUE))
 901             continue;
 902         /* only get here when didn't boost strength or constitution */
 903         break;
 904     }
 905
 906     return;
 907 }
 908
 909 /* skills aren't initialized, so we use the role-specific skill lists */
 910 STATIC_OVL boolean
 911 restricted_spell_discipline(otyp)
 912 int otyp;
 913 {
 914     const struct def_skill *skills;
 915     int this_skill = spell_skilltype(otyp);
 916
 917     switch (Role_switch) {
 918     case PM_ARCHEOLOGIST:
 919         skills = Skill_A;
 920         break;
 921     case PM_BARBARIAN:
 922         skills = Skill_B;
 923         break;
 924     case PM_CAVEMAN:
 925         skills = Skill_C;
 926         break;
 927     case PM_HEALER:
 928         skills = Skill_H;
 929         break;
 930     case PM_KNIGHT:
 931         skills = Skill_K;
 932         break;
 933     case PM_MONK:
 934         skills = Skill_Mon;
 935         break;
 936     case PM_PRIEST:
 937         skills = Skill_P;
 938         break;
 939     case PM_RANGER:
 940         skills = Skill_Ran;
 941         break;
 942     case PM_ROGUE:
 943         skills = Skill_R;
 944         break;
 945     case PM_SAMURAI:
 946         skills = Skill_S;
 947         break;
 948     case PM_TOURIST:
 949         skills = Skill_T;
 950         break;
 951     case PM_VALKYRIE:
 952         skills = Skill_V;
 953         break;
 954     case PM_WIZARD:
 955         skills = Skill_W;
 956         break;
 957     default:
 958         skills = 0; /* lint suppression */
 959         break;
 960     }
 961
 962     while (skills && skills->skill != P_NONE) {
 963         if (skills->skill == this_skill)
 964             return FALSE;
 965         ++skills;
 966     }
 967     return TRUE;
 968 }
 969
 970 STATIC_OVL void
 971 ini_inv(trop)
 972 register struct trobj *trop;
 973 {
 974     struct obj *obj;
 975     int otyp, i;
 976
 977     while (trop->trclass) {
 978         if (trop->trotyp != UNDEF_TYP) {
 979             otyp = (int) trop->trotyp;
 980             if (urace.malenum != PM_HUMAN) {
 981                 /* substitute specific items for generic ones */
 982                 for (i = 0; inv_subs[i].race_pm != NON_PM; ++i)
 983                     if (inv_subs[i].race_pm == urace.malenum
 984                         && otyp == inv_subs[i].item_otyp) {
 985                         otyp = inv_subs[i].subs_otyp;
 986                         break;
 987                     }
 988             }
 989             obj = mksobj(otyp, TRUE, FALSE);
 990         } else { /* UNDEF_TYP */
 991             static NEARDATA short nocreate = STRANGE_OBJECT;
 992             static NEARDATA short nocreate2 = STRANGE_OBJECT;
 993             static NEARDATA short nocreate3 = STRANGE_OBJECT;
 994             static NEARDATA short nocreate4 = STRANGE_OBJECT;
 995             /*
 996              * For random objects, do not create certain overly powerful
 997              * items: wand of wishing, ring of levitation, or the
 998              * polymorph/polymorph control combination.  Specific objects,
 999              * i.e. the discovery wishing, are still OK.
1000              * Also, don't get a couple of really useless items.  (Note:
1001              * punishment isn't "useless".  Some players who start out with
1002              * one will immediately read it and use the iron ball as a
1003              * weapon.)
1004              */
1005             obj = mkobj(trop->trclass, FALSE);
1006             otyp = obj->otyp;
1007             while (otyp == WAN_WISHING || otyp == nocreate
1008                    || otyp == nocreate2 || otyp == nocreate3
1009                    || otyp == nocreate4 || otyp == RIN_LEVITATION
1010                    /* 'useless' items */
1011                    || otyp == POT_HALLUCINATION
1012                    || otyp == POT_ACID
1013                    || otyp == SCR_AMNESIA
1014                    || otyp == SCR_FIRE
1015                    || otyp == SCR_BLANK_PAPER
1016                    || otyp == SPE_BLANK_PAPER
1017                    || otyp == RIN_AGGRAVATE_MONSTER
1018                    || otyp == RIN_HUNGER
1019                    || otyp == WAN_NOTHING
1020                    /* Monks don't use weapons */
1021                    || (otyp == SCR_ENCHANT_WEAPON && Role_if(PM_MONK))
1022                    /* wizard patch -- they already have one */
1023                    || (otyp == SPE_FORCE_BOLT && Role_if(PM_WIZARD))
1024                    /* powerful spells are either useless to
1025                       low level players or unbalancing; also
1026                       spells in restricted skill categories */
1027                    || (obj->oclass == SPBOOK_CLASS
1028                        && (objects[otyp].oc_level > 3
1029                            || restricted_spell_discipline(otyp)))) {
1030                 dealloc_obj(obj);
1031                 obj = mkobj(trop->trclass, FALSE);
1032                 otyp = obj->otyp;
1033             }
1034
1035             /* Don't start with +0 or negative rings */
1036             if (objects[otyp].oc_charged && obj->spe <= 0)
1037                 obj->spe = rne(3);
1038
1039             /* Heavily relies on the fact that 1) we create wands
1040              * before rings, 2) that we create rings before
1041              * spellbooks, and that 3) not more than 1 object of a
1042              * particular symbol is to be prohibited.  (For more
1043              * objects, we need more nocreate variables...)
1044              */
1045             switch (otyp) {
1046             case WAN_POLYMORPH:
1047             case RIN_POLYMORPH:
1048             case POT_POLYMORPH:
1049                 nocreate = RIN_POLYMORPH_CONTROL;
1050                 break;
1051             case RIN_POLYMORPH_CONTROL:
1052                 nocreate = RIN_POLYMORPH;
1053                 nocreate2 = SPE_POLYMORPH;
1054                 nocreate3 = POT_POLYMORPH;
1055             }
1056             /* Don't have 2 of the same ring or spellbook */
1057             if (obj->oclass == RING_CLASS || obj->oclass == SPBOOK_CLASS)
1058                 nocreate4 = otyp;
1059         }
1060
1061         /* nudist gets no armor */
1062         if (u.uroleplay.nudist && obj->oclass == ARMOR_CLASS) {
1063             dealloc_obj(obj);
1064             trop++;
1065             continue;
1066         }
1067
1068         if (trop->trclass == COIN_CLASS) {
1069             /* no "blessed" or "identified" money */
1070             obj->quan = u.umoney0;
1071         } else {
1072             if (objects[otyp].oc_uses_known)
1073                 obj->known = 1;
1074             obj->dknown = obj->bknown = obj->rknown = 1;
1075             if (Is_container(obj) || obj->otyp == STATUE) {
1076                 obj->cknown = obj->lknown = 1;
1077                 obj->otrapped = 0;
1078             }
1079             obj->cursed = 0;
1080             if (obj->opoisoned && u.ualign.type != A_CHAOTIC)
1081                 obj->opoisoned = 0;
1082             if (obj->oclass == WEAPON_CLASS || obj->oclass == TOOL_CLASS) {
1083                 obj->quan = (long) trop->trquan;
1084                 trop->trquan = 1;
1085             } else if (obj->oclass == GEM_CLASS && is_graystone(obj)
1086                        && obj->otyp != FLINT) {
1087                 obj->quan = 1L;
1088             }
1089             if (trop->trspe != UNDEF_SPE)
1090                 obj->spe = trop->trspe;
1091             if (trop->trbless != UNDEF_BLESS)
1092                 obj->blessed = trop->trbless;
1093         }
1094         /* defined after setting otyp+quan + blessedness */
1095         obj->owt = weight(obj);
1096         obj = addinv(obj);
1097
1098         /* Make the type known if necessary */
1099         if (OBJ_DESCR(objects[otyp]) && obj->known)
1100             discover_object(otyp, TRUE, FALSE);
1101         if (otyp == OIL_LAMP)
1102             discover_object(POT_OIL, TRUE, FALSE);
1103
1104         if (obj->oclass == ARMOR_CLASS) {
1105             if (is_shield(obj) && !uarms) {
1106                 setworn(obj, W_ARMS);
1107                 if (uswapwep)
1108                     setuswapwep((struct obj *) 0);
1109             } else if (is_helmet(obj) && !uarmh)
1110                 setworn(obj, W_ARMH);
1111             else if (is_gloves(obj) && !uarmg)
1112                 setworn(obj, W_ARMG);
1113             else if (is_shirt(obj) && !uarmu)
1114                 setworn(obj, W_ARMU);
1115             else if (is_cloak(obj) && !uarmc)
1116                 setworn(obj, W_ARMC);
1117             else if (is_boots(obj) && !uarmf)
1118                 setworn(obj, W_ARMF);
1119             else if (is_suit(obj) && !uarm)
1120                 setworn(obj, W_ARM);
1121         }
1122
1123         if (obj->oclass == WEAPON_CLASS || is_weptool(obj)
1124             || otyp == TIN_OPENER || otyp == FLINT || otyp == ROCK) {
1125             if (is_ammo(obj) || is_missile(obj)) {
1126                 if (!uquiver)
1127                     setuqwep(obj);
1128             } else if (!uwep)
1129                 setuwep(obj);
1130             else if (!uswapwep)
1131                 setuswapwep(obj);
1132         }
1133         if (obj->oclass == SPBOOK_CLASS && obj->otyp != SPE_BLANK_PAPER)
1134             initialspell(obj);
1135
1136 #if !defined(PYRAMID_BUG) && !defined(MAC)
1137         if (--trop->trquan)
1138             continue; /* make a similar object */
1139 #else
1140         if (trop->trquan) { /* check if zero first */
1141             --trop->trquan;
1142             if (trop->trquan)
1143                 continue; /* make a similar object */
1144         }
1145 #endif
1146         trop++;
1147     }
1148 }
1149
1150 /*u_init.c*/