Source:NetHack 3.4.3/src/u init.c

Below is the full text to src/u_init.c from NetHack 3.4.3. To link to a particular line, write [[u_init.c#line123]], for example.

Top of file

1.    /*	SCCS Id: @(#)u_init.c	3.4	2002/10/22	*/
2.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3.    /* NetHack may be freely redistributed.  See license for details. */
4.    

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.

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.   

Initial inventories

24.   /*
25.    *	Initial inventory for the various roles.
26.    */
27.   

Archeologist initial inventory

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.   };

Barbarian initial inventory

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.   };

Caveman initial inventory

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.   };

Healer initial inventory

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.   };

Knight initial inventory

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.   };

Monk initial inventory

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.   };

Priest initial inventory

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.  };

Ranger initial inventory

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.  };

Rogue initial inventory

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.  };

Samurai initial inventory

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.  };

Tourist initial inventory

140.  #ifdef TOURIST
141.  static struct trobj Tourist[] = {
142.  #define T_DARTS		0
143.  	{ DART, 2, WEAPON_CLASS, 25, UNDEF_BLESS },	/* quan is variable */
144.  	{ UNDEF_TYP, UNDEF_SPE, FOOD_CLASS, 10, 0 },
145.  	{ POT_EXTRA_HEALING, 0, POTION_CLASS, 2, UNDEF_BLESS },
146.  	{ SCR_MAGIC_MAPPING, 0, SCROLL_CLASS, 4, UNDEF_BLESS },
147.  	{ HAWAIIAN_SHIRT, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
148.  	{ EXPENSIVE_CAMERA, UNDEF_SPE, TOOL_CLASS, 1, 0 },
149.  	{ CREDIT_CARD, 0, TOOL_CLASS, 1, 0 },
150.  	{ 0, 0, 0, 0, 0 }
151.  };
152.  #endif

Valkyrie initial inventory

153.  static struct trobj Valkyrie[] = {
154.  	{ LONG_SWORD, 1, WEAPON_CLASS, 1, UNDEF_BLESS },
155.  	{ DAGGER, 0, WEAPON_CLASS, 1, UNDEF_BLESS },
156.  	{ SMALL_SHIELD, 3, ARMOR_CLASS, 1, UNDEF_BLESS },
157.  	{ FOOD_RATION, 0, FOOD_CLASS, 1, 0 },
158.  	{ 0, 0, 0, 0, 0 }
159.  };

Wizard initial inventory

160.  static struct trobj Wizard[] = {
161.  #define W_MULTSTART	2
162.  #define W_MULTEND	6
163.  	{ QUARTERSTAFF, 1, WEAPON_CLASS, 1, 1 },
164.  	{ CLOAK_OF_MAGIC_RESISTANCE, 0, ARMOR_CLASS, 1, UNDEF_BLESS },
165.  	{ UNDEF_TYP, UNDEF_SPE, WAND_CLASS, 1, UNDEF_BLESS },
166.  	{ UNDEF_TYP, UNDEF_SPE, RING_CLASS, 2, UNDEF_BLESS },
167.  	{ UNDEF_TYP, UNDEF_SPE, POTION_CLASS, 3, UNDEF_BLESS },
168.  	{ UNDEF_TYP, UNDEF_SPE, SCROLL_CLASS, 3, UNDEF_BLESS },
169.  	{ SPE_FORCE_BOLT, 0, SPBOOK_CLASS, 1, 1 },
170.  	{ UNDEF_TYP, UNDEF_SPE, SPBOOK_CLASS, 1, UNDEF_BLESS },
171.  	{ 0, 0, 0, 0, 0 }
172.  };
173.  

Optional extra inventory items

174.  /*
175.   *	Optional extra inventory items.
176.   */
177.  
178.  static struct trobj Tinopener[] = {
179.  	{ TIN_OPENER, 0, TOOL_CLASS, 1, 0 },
180.  	{ 0, 0, 0, 0, 0 }
181.  };
182.  static struct trobj Magicmarker[] = {
183.  	{ MAGIC_MARKER, UNDEF_SPE, TOOL_CLASS, 1, 0 },
184.  	{ 0, 0, 0, 0, 0 }
185.  };
186.  static struct trobj Lamp[] = {
187.  	{ OIL_LAMP, 1, TOOL_CLASS, 1, 0 },
188.  	{ 0, 0, 0, 0, 0 }
189.  };
190.  static struct trobj Blindfold[] = {
191.  	{ BLINDFOLD, 0, TOOL_CLASS, 1, 0 },
192.  	{ 0, 0, 0, 0, 0 }
193.  };
194.  static struct trobj Instrument[] = {
195.  	{ WOODEN_FLUTE, 0, TOOL_CLASS, 1, 0 },
196.  	{ 0, 0, 0, 0, 0 }
197.  };
198.  static struct trobj Xtra_food[] = {
199.  	{ UNDEF_TYP, UNDEF_SPE, FOOD_CLASS, 2, 0 },
200.  	{ 0, 0, 0, 0, 0 }
201.  };
202.  #ifdef TOURIST
203.  static struct trobj Leash[] = {
204.  	{ LEASH, 0, TOOL_CLASS, 1, 0 },
205.  	{ 0, 0, 0, 0, 0 }
206.  };
207.  static struct trobj Towel[] = {
208.  	{ TOWEL, 0, TOOL_CLASS, 1, 0 },
209.  	{ 0, 0, 0, 0, 0 }
210.  };
211.  #endif	/* TOURIST */
212.  static struct trobj Wishing[] = {
213.  	{ WAN_WISHING, 3, WAND_CLASS, 1, 0 },
214.  	{ 0, 0, 0, 0, 0 }
215.  };
216.  #ifdef GOLDOBJ
217.  static struct trobj Money[] = {
218.  	{ GOLD_PIECE, 0 , COIN_CLASS, 1, 0 },
219.  	{ 0, 0, 0, 0, 0 }
220.  };
221.  #endif
222.  

Race-based substitutions for initial inventory

223.  /* race-based substitutions for initial inventory;
224.     the weaker cloak for elven rangers is intentional--they shoot better */
225.  static struct inv_sub { short race_pm, item_otyp, subs_otyp; } inv_subs[] = {
226.      { PM_ELF,	DAGGER,			ELVEN_DAGGER	      },
227.      { PM_ELF,	SPEAR,			ELVEN_SPEAR	      },
228.      { PM_ELF,	SHORT_SWORD,		ELVEN_SHORT_SWORD     },
229.      { PM_ELF,	BOW,			ELVEN_BOW	      },
230.      { PM_ELF,	ARROW,			ELVEN_ARROW	      },
231.      { PM_ELF,	HELMET,			ELVEN_LEATHER_HELM    },
232.   /* { PM_ELF,	SMALL_SHIELD,		ELVEN_SHIELD	      }, */
233.      { PM_ELF,	CLOAK_OF_DISPLACEMENT,	ELVEN_CLOAK	      },
234.      { PM_ELF,	CRAM_RATION,		LEMBAS_WAFER	      },
235.      { PM_ORC,	DAGGER,			ORCISH_DAGGER	      },
236.      { PM_ORC,	SPEAR,			ORCISH_SPEAR	      },
237.      { PM_ORC,	SHORT_SWORD,		ORCISH_SHORT_SWORD    },
238.      { PM_ORC,	BOW,			ORCISH_BOW	      },
239.      { PM_ORC,	ARROW,			ORCISH_ARROW	      },
240.      { PM_ORC,	HELMET,			ORCISH_HELM	      },
241.      { PM_ORC,	SMALL_SHIELD,		ORCISH_SHIELD	      },
242.      { PM_ORC,	RING_MAIL,		ORCISH_RING_MAIL      },
243.      { PM_ORC,	CHAIN_MAIL,		ORCISH_CHAIN_MAIL     },
244.      { PM_DWARF, SPEAR,			DWARVISH_SPEAR	      },
245.      { PM_DWARF, SHORT_SWORD,		DWARVISH_SHORT_SWORD  },
246.      { PM_DWARF, HELMET,			DWARVISH_IRON_HELM    },
247.   /* { PM_DWARF, SMALL_SHIELD,		DWARVISH_ROUNDSHIELD  }, */
248.   /* { PM_DWARF, PICK_AXE,		DWARVISH_MATTOCK      }, */
249.      { PM_GNOME, BOW,			CROSSBOW	      },
250.      { PM_GNOME, ARROW,			CROSSBOW_BOLT	      },
251.      { NON_PM,	STRANGE_OBJECT,		STRANGE_OBJECT	      }
252.  };
253.  

Maximum skill levels

Archeologist max skill levels

254.  static const struct def_skill Skill_A[] = {
255.      { P_DAGGER, P_BASIC },		{ P_KNIFE,  P_BASIC },
256.      { P_PICK_AXE, P_EXPERT },		{ P_SHORT_SWORD, P_BASIC },
257.      { P_SCIMITAR, P_SKILLED },		{ P_SABER, P_EXPERT },
258.      { P_CLUB, P_SKILLED },		{ P_QUARTERSTAFF, P_SKILLED },
259.      { P_SLING, P_SKILLED },		{ P_DART, P_BASIC },
260.      { P_BOOMERANG, P_EXPERT },		{ P_WHIP, P_EXPERT },
261.      { P_UNICORN_HORN, P_SKILLED },
262.      { P_ATTACK_SPELL, P_BASIC },	{ P_HEALING_SPELL, P_BASIC },
263.      { P_DIVINATION_SPELL, P_EXPERT},	{ P_MATTER_SPELL, P_BASIC},
264.  #ifdef STEED
265.      { P_RIDING, P_BASIC },
266.  #endif
267.      { P_TWO_WEAPON_COMBAT, P_BASIC },
268.      { P_BARE_HANDED_COMBAT, P_EXPERT },
269.      { P_NONE, 0 }
270.  };
271.  

Barbarian max skill levels

272.  static const struct def_skill Skill_B[] = {
273.      { P_DAGGER, P_BASIC },		{ P_AXE, P_EXPERT },
274.      { P_PICK_AXE, P_SKILLED },	{ P_SHORT_SWORD, P_EXPERT },
275.      { P_BROAD_SWORD, P_SKILLED },	{ P_LONG_SWORD, P_SKILLED },
276.      { P_TWO_HANDED_SWORD, P_EXPERT },	{ P_SCIMITAR, P_SKILLED },
277.      { P_SABER, P_BASIC },		{ P_CLUB, P_SKILLED },
278.      { P_MACE, P_SKILLED },		{ P_MORNING_STAR, P_SKILLED },
279.      { P_FLAIL, P_BASIC },		{ P_HAMMER, P_EXPERT },
280.      { P_QUARTERSTAFF, P_BASIC },	{ P_SPEAR, P_SKILLED },
281.      { P_TRIDENT, P_SKILLED },		{ P_BOW, P_BASIC },
282.      { P_ATTACK_SPELL, P_SKILLED },
283.  #ifdef STEED
284.      { P_RIDING, P_BASIC },
285.  #endif
286.      { P_TWO_WEAPON_COMBAT, P_BASIC },
287.      { P_BARE_HANDED_COMBAT, P_MASTER },
288.      { P_NONE, 0 }
289.  };
290.  

Caveman max skill levels

291.  static const struct def_skill Skill_C[] = {
292.      { P_DAGGER, P_BASIC },		{ P_KNIFE,  P_SKILLED },
293.      { P_AXE, P_SKILLED },		{ P_PICK_AXE, P_BASIC },
294.      { P_CLUB, P_EXPERT },		{ P_MACE, P_EXPERT },
295.      { P_MORNING_STAR, P_BASIC },	{ P_FLAIL, P_SKILLED },
296.      { P_HAMMER, P_SKILLED },		{ P_QUARTERSTAFF, P_EXPERT },
297.      { P_POLEARMS, P_SKILLED },		{ P_SPEAR, P_EXPERT },
298.      { P_JAVELIN, P_SKILLED },		{ P_TRIDENT, P_SKILLED },
299.      { P_BOW, P_SKILLED },		{ P_SLING, P_EXPERT },
300.      { P_ATTACK_SPELL, P_BASIC },	{ P_MATTER_SPELL, P_SKILLED },
301.      { P_BOOMERANG, P_EXPERT },		{ P_UNICORN_HORN, P_BASIC },
302.      { P_BARE_HANDED_COMBAT, P_MASTER },
303.      { P_NONE, 0 }
304.  };
305.  

Healer max skill levels

306.  static const struct def_skill Skill_H[] = {
307.      { P_DAGGER, P_SKILLED },		{ P_KNIFE, P_EXPERT },
308.      { P_SHORT_SWORD, P_SKILLED },	{ P_SCIMITAR, P_BASIC },
309.      { P_SABER, P_BASIC },		{ P_CLUB, P_SKILLED },
310.      { P_MACE, P_BASIC },		{ P_QUARTERSTAFF, P_EXPERT },
311.      { P_POLEARMS, P_BASIC },		{ P_SPEAR, P_BASIC },
312.      { P_JAVELIN, P_BASIC },		{ P_TRIDENT, P_BASIC },
313.      { P_SLING, P_SKILLED },		{ P_DART, P_EXPERT },
314.      { P_SHURIKEN, P_SKILLED },		{ P_UNICORN_HORN, P_EXPERT },
315.      { P_HEALING_SPELL, P_EXPERT },
316.      { P_BARE_HANDED_COMBAT, P_BASIC },
317.      { P_NONE, 0 }
318.  };
319.  

Knight max skill levels

320.  static const struct def_skill Skill_K[] = {
321.      { P_DAGGER, P_BASIC },		{ P_KNIFE, P_BASIC },
322.      { P_AXE, P_SKILLED },		{ P_PICK_AXE, P_BASIC },
323.      { P_SHORT_SWORD, P_SKILLED },	{ P_BROAD_SWORD, P_SKILLED },
324.      { P_LONG_SWORD, P_EXPERT },	{ P_TWO_HANDED_SWORD, P_SKILLED },
325.      { P_SCIMITAR, P_BASIC },		{ P_SABER, P_SKILLED },
326.      { P_CLUB, P_BASIC },		{ P_MACE, P_SKILLED },
327.      { P_MORNING_STAR, P_SKILLED },	{ P_FLAIL, P_BASIC },
328.      { P_HAMMER, P_BASIC },		{ P_POLEARMS, P_SKILLED },
329.      { P_SPEAR, P_SKILLED },		{ P_JAVELIN, P_SKILLED },
330.      { P_TRIDENT, P_BASIC },		{ P_LANCE, P_EXPERT },
331.      { P_BOW, P_BASIC },			{ P_CROSSBOW, P_SKILLED },
332.      { P_ATTACK_SPELL, P_SKILLED },	{ P_HEALING_SPELL, P_SKILLED },
333.      { P_CLERIC_SPELL, P_SKILLED },
334.  #ifdef STEED
335.      { P_RIDING, P_EXPERT },
336.  #endif
337.      { P_TWO_WEAPON_COMBAT, P_SKILLED },
338.      { P_BARE_HANDED_COMBAT, P_EXPERT },
339.      { P_NONE, 0 }
340.  };
341.  

Monk max skill levels

342.  static const struct def_skill Skill_Mon[] = {
343.      { P_QUARTERSTAFF, P_BASIC },    { P_SPEAR, P_BASIC },
344.      { P_JAVELIN, P_BASIC },		    { P_CROSSBOW, P_BASIC },
345.      { P_SHURIKEN, P_BASIC },
346.      { P_ATTACK_SPELL, P_BASIC },    { P_HEALING_SPELL, P_EXPERT },
347.      { P_DIVINATION_SPELL, P_BASIC },{ P_ENCHANTMENT_SPELL, P_BASIC },
348.      { P_CLERIC_SPELL, P_SKILLED },  { P_ESCAPE_SPELL, P_BASIC },
349.      { P_MATTER_SPELL, P_BASIC },
350.      { P_MARTIAL_ARTS, P_GRAND_MASTER },
351.      { P_NONE, 0 }
352.  };
353.  

Priest max skill levels

354.  static const struct def_skill Skill_P[] = {
355.      { P_CLUB, P_EXPERT },		{ P_MACE, P_EXPERT },
356.      { P_MORNING_STAR, P_EXPERT },	{ P_FLAIL, P_EXPERT },
357.      { P_HAMMER, P_EXPERT },		{ P_QUARTERSTAFF, P_EXPERT },
358.      { P_POLEARMS, P_SKILLED },		{ P_SPEAR, P_SKILLED },
359.      { P_JAVELIN, P_SKILLED },		{ P_TRIDENT, P_SKILLED },
360.      { P_LANCE, P_BASIC },		{ P_BOW, P_BASIC },
361.      { P_SLING, P_BASIC },		{ P_CROSSBOW, P_BASIC },
362.      { P_DART, P_BASIC },		{ P_SHURIKEN, P_BASIC },
363.      { P_BOOMERANG, P_BASIC },		{ P_UNICORN_HORN, P_SKILLED },
364.      { P_HEALING_SPELL, P_EXPERT },	{ P_DIVINATION_SPELL, P_EXPERT },
365.      { P_CLERIC_SPELL, P_EXPERT },
366.      { P_BARE_HANDED_COMBAT, P_BASIC },
367.      { P_NONE, 0 }
368.  };
369.  

Rogue max skill levels

370.  static const struct def_skill Skill_R[] = {
371.      { P_DAGGER, P_EXPERT },		{ P_KNIFE,  P_EXPERT },
372.      { P_SHORT_SWORD, P_EXPERT },	{ P_BROAD_SWORD, P_SKILLED },
373.      { P_LONG_SWORD, P_SKILLED },	{ P_TWO_HANDED_SWORD, P_BASIC },
374.      { P_SCIMITAR, P_SKILLED },		{ P_SABER, P_SKILLED },
375.      { P_CLUB, P_SKILLED },		{ P_MACE, P_SKILLED },
376.      { P_MORNING_STAR, P_BASIC },	{ P_FLAIL, P_BASIC },
377.      { P_HAMMER, P_BASIC },		{ P_POLEARMS, P_BASIC },
378.      { P_SPEAR, P_BASIC },		{ P_CROSSBOW, P_EXPERT },
379.      { P_DART, P_EXPERT },		{ P_SHURIKEN, P_SKILLED },
380.      { P_DIVINATION_SPELL, P_SKILLED },	{ P_ESCAPE_SPELL, P_SKILLED },
381.      { P_MATTER_SPELL, P_SKILLED },
382.  #ifdef STEED
383.      { P_RIDING, P_BASIC },
384.  #endif
385.      { P_TWO_WEAPON_COMBAT, P_EXPERT },
386.      { P_BARE_HANDED_COMBAT, P_EXPERT },
387.      { P_NONE, 0 }
388.  };
389.  

Ranger max skill levels

390.  static const struct def_skill Skill_Ran[] = {
391.      { P_DAGGER, P_EXPERT },		 { P_KNIFE,  P_SKILLED },
392.      { P_AXE, P_SKILLED },	 { P_PICK_AXE, P_BASIC },
393.      { P_SHORT_SWORD, P_BASIC },	 { P_MORNING_STAR, P_BASIC },
394.      { P_FLAIL, P_SKILLED },	 { P_HAMMER, P_BASIC },
395.      { P_QUARTERSTAFF, P_BASIC }, { P_POLEARMS, P_SKILLED },
396.      { P_SPEAR, P_SKILLED },	 { P_JAVELIN, P_EXPERT },
397.      { P_TRIDENT, P_BASIC },	 { P_BOW, P_EXPERT },
398.      { P_SLING, P_EXPERT },	 { P_CROSSBOW, P_EXPERT },
399.      { P_DART, P_EXPERT },	 { P_SHURIKEN, P_SKILLED },
400.      { P_BOOMERANG, P_EXPERT },	 { P_WHIP, P_BASIC },
401.      { P_HEALING_SPELL, P_BASIC },
402.      { P_DIVINATION_SPELL, P_EXPERT },
403.      { P_ESCAPE_SPELL, P_BASIC },
404.  #ifdef STEED
405.      { P_RIDING, P_BASIC },
406.  #endif
407.      { P_BARE_HANDED_COMBAT, P_BASIC },
408.      { P_NONE, 0 }
409.  };
410.  

Samurai max skill levels

411.  static const struct def_skill Skill_S[] = {
412.      { P_DAGGER, P_BASIC },		{ P_KNIFE,  P_SKILLED },
413.      { P_SHORT_SWORD, P_EXPERT },	{ P_BROAD_SWORD, P_SKILLED },
414.      { P_LONG_SWORD, P_EXPERT },		{ P_TWO_HANDED_SWORD, P_EXPERT },
415.      { P_SCIMITAR, P_BASIC },		{ P_SABER, P_BASIC },
416.      { P_FLAIL, P_SKILLED },		{ P_QUARTERSTAFF, P_BASIC },
417.      { P_POLEARMS, P_SKILLED },		{ P_SPEAR, P_BASIC },
418.      { P_JAVELIN, P_BASIC },		{ P_LANCE, P_SKILLED },
419.      { P_BOW, P_EXPERT },		{ P_SHURIKEN, P_EXPERT },
420.      { P_ATTACK_SPELL, P_SKILLED },	{ P_CLERIC_SPELL, P_SKILLED },
421.  #ifdef STEED
422.      { P_RIDING, P_SKILLED },
423.  #endif
424.      { P_TWO_WEAPON_COMBAT, P_EXPERT },
425.      { P_MARTIAL_ARTS, P_MASTER },
426.      { P_NONE, 0 }
427.  };
428.  

Tourist max skill levels

429.  #ifdef TOURIST
430.  static const struct def_skill Skill_T[] = {
431.      { P_DAGGER, P_EXPERT },		{ P_KNIFE,  P_SKILLED },
432.      { P_AXE, P_BASIC },			{ P_PICK_AXE, P_BASIC },
433.      { P_SHORT_SWORD, P_EXPERT },	{ P_BROAD_SWORD, P_BASIC },
434.      { P_LONG_SWORD, P_BASIC },		{ P_TWO_HANDED_SWORD, P_BASIC },
435.      { P_SCIMITAR, P_SKILLED },		{ P_SABER, P_SKILLED },
436.      { P_MACE, P_BASIC },		{ P_MORNING_STAR, P_BASIC },
437.      { P_FLAIL, P_BASIC },		{ P_HAMMER, P_BASIC },
438.      { P_QUARTERSTAFF, P_BASIC },	{ P_POLEARMS, P_BASIC },
439.      { P_SPEAR, P_BASIC },		{ P_JAVELIN, P_BASIC },
440.      { P_TRIDENT, P_BASIC },		{ P_LANCE, P_BASIC },
441.      { P_BOW, P_BASIC },			{ P_SLING, P_BASIC },
442.      { P_CROSSBOW, P_BASIC },		{ P_DART, P_EXPERT },
443.      { P_SHURIKEN, P_BASIC },		{ P_BOOMERANG, P_BASIC },
444.      { P_WHIP, P_BASIC },		{ P_UNICORN_HORN, P_SKILLED },
445.      { P_DIVINATION_SPELL, P_BASIC },	{ P_ENCHANTMENT_SPELL, P_BASIC },
446.      { P_ESCAPE_SPELL, P_SKILLED },
447.  #ifdef STEED
448.      { P_RIDING, P_BASIC },
449.  #endif
450.      { P_TWO_WEAPON_COMBAT, P_SKILLED },
451.      { P_BARE_HANDED_COMBAT, P_SKILLED },
452.      { P_NONE, 0 }
453.  };
454.  #endif /* TOURIST */
455.  

Valkyrie max skill levels

456.  static const struct def_skill Skill_V[] = {
457.      { P_DAGGER, P_EXPERT },		{ P_AXE, P_EXPERT },
458.      { P_PICK_AXE, P_SKILLED },		{ P_SHORT_SWORD, P_SKILLED },
459.      { P_BROAD_SWORD, P_SKILLED },	{ P_LONG_SWORD, P_EXPERT },
460.      { P_TWO_HANDED_SWORD, P_EXPERT },	{ P_SCIMITAR, P_BASIC },
461.      { P_SABER, P_BASIC },		{ P_HAMMER, P_EXPERT },
462.      { P_QUARTERSTAFF, P_BASIC },	{ P_POLEARMS, P_SKILLED },
463.      { P_SPEAR, P_SKILLED },		{ P_JAVELIN, P_BASIC },
464.      { P_TRIDENT, P_BASIC },		{ P_LANCE, P_SKILLED },
465.      { P_SLING, P_BASIC },
466.      { P_ATTACK_SPELL, P_BASIC },	{ P_ESCAPE_SPELL, P_BASIC },
467.  #ifdef STEED
468.      { P_RIDING, P_SKILLED },
469.  #endif
470.      { P_TWO_WEAPON_COMBAT, P_SKILLED },
471.      { P_BARE_HANDED_COMBAT, P_EXPERT },
472.      { P_NONE, 0 }
473.  };
474.  

Wizard max skill levels

475.  static const struct def_skill Skill_W[] = {
476.      { P_DAGGER, P_EXPERT },		{ P_KNIFE,  P_SKILLED },
477.      { P_AXE, P_SKILLED },		{ P_SHORT_SWORD, P_BASIC },
478.      { P_CLUB, P_SKILLED },		{ P_MACE, P_BASIC },
479.      { P_QUARTERSTAFF, P_EXPERT },	{ P_POLEARMS, P_SKILLED },
480.      { P_SPEAR, P_BASIC },		{ P_JAVELIN, P_BASIC },
481.      { P_TRIDENT, P_BASIC },		{ P_SLING, P_SKILLED },
482.      { P_DART, P_EXPERT },		{ P_SHURIKEN, P_BASIC },
483.      { P_ATTACK_SPELL, P_EXPERT },	{ P_HEALING_SPELL, P_SKILLED },
484.      { P_DIVINATION_SPELL, P_EXPERT },	{ P_ENCHANTMENT_SPELL, P_SKILLED },
485.      { P_CLERIC_SPELL, P_SKILLED },	{ P_ESCAPE_SPELL, P_EXPERT },
486.      { P_MATTER_SPELL, P_EXPERT },
487.  #ifdef STEED
488.      { P_RIDING, P_BASIC },
489.  #endif
490.      { P_BARE_HANDED_COMBAT, P_BASIC },
491.      { P_NONE, 0 }
492.  };
493.  
494.  

knows_object

495.  STATIC_OVL void
496.  knows_object(obj)
497.  register int obj;
498.  {
499.  	discover_object(obj,TRUE,FALSE);
500.  	objects[obj].oc_pre_discovered = 1;	/* not a "discovery" */
501.  }
502.  

knows_class

503.  /* Know ordinary (non-magical) objects of a certain class,
504.   * like all gems except the loadstone and luckstone.
505.   */
506.  STATIC_OVL void
507.  knows_class(sym)
508.  register char sym;
509.  {
510.  	register int ct;
511.  	for (ct = 1; ct < NUM_OBJECTS; ct++)
512.  		if (objects[ct].oc_class == sym && !objects[ct].oc_magic)
513.  			knows_object(ct);
514.  }
515.  

u_init

516.  void
517.  u_init()
518.  {
519.  	register int i;
520.  
521.  	flags.female = flags.initgend;
522.  	flags.beginner = 1;
523.  
524.  	/* zero u, including pointer values --
525.  	 * necessary when aborting from a failed restore */
526.  	(void) memset((genericptr_t)&u, 0, sizeof(u));
527.  	u.ustuck = (struct monst *)0;
528.  
529.  #if 0	/* documentation of more zero values as desirable */
530.  	u.usick_cause[0] = 0;
531.  	u.uluck  = u.moreluck = 0;
532.  # ifdef TOURIST
533.  	uarmu = 0;
534.  # endif
535.  	uarm = uarmc = uarmh = uarms = uarmg = uarmf = 0;
536.  	uwep = uball = uchain = uleft = uright = 0;
537.  	uswapwep = uquiver = 0;
538.  	u.twoweap = 0;
539.  	u.ublessed = 0;				/* not worthy yet */
540.  	u.ugangr   = 0;				/* gods not angry */
541.  	u.ugifts   = 0;				/* no divine gifts bestowed */
542.  # ifdef ELBERETH
543.  	u.uevent.uhand_of_elbereth = 0;
544.  # endif
545.  	u.uevent.uheard_tune = 0;
546.  	u.uevent.uopened_dbridge = 0;
547.  	u.uevent.udemigod = 0;		/* not a demi-god yet... */
548.  	u.udg_cnt = 0;
549.  	u.mh = u.mhmax = u.mtimedone = 0;
550.  	u.uz.dnum = u.uz0.dnum = 0;
551.  	u.utotype = 0;
552.  #endif	/* 0 */
553.  
554.  	u.uz.dlevel = 1;
555.  	u.uz0.dlevel = 0;
556.  	u.utolev = u.uz;
557.  
558.  	u.umoved = FALSE;
559.  	u.umortality = 0;
560.  	u.ugrave_arise = NON_PM;
561.  
562.  	u.umonnum = u.umonster = (flags.female &&
563.  			urole.femalenum != NON_PM) ? urole.femalenum :
564.  			urole.malenum;
565.  	set_uasmon();
566.  
567.  	u.ulevel = 0;	/* set up some of the initial attributes */
568.  	u.uhp = u.uhpmax = newhp();
569.  	u.uenmax = urole.enadv.infix + urace.enadv.infix;
570.  	if (urole.enadv.inrnd > 0)
571.  	    u.uenmax += rnd(urole.enadv.inrnd);
572.  	if (urace.enadv.inrnd > 0)
573.  	    u.uenmax += rnd(urace.enadv.inrnd);
574.  	u.uen = u.uenmax;
575.  	u.uspellprot = 0;
576.  	adjabil(0,1);
577.  	u.ulevel = u.ulevelmax = 1;
578.  
579.  	init_uhunger();
580.  	for (i = 0; i <= MAXSPELL; i++) spl_book[i].sp_id = NO_SPELL;
581.  	u.ublesscnt = 300;			/* no prayers just yet */
582.  	u.ualignbase[A_CURRENT] = u.ualignbase[A_ORIGINAL] = u.ualign.type =
583.  			aligns[flags.initalign].value;
584.  	u.ulycn = NON_PM;
585.  
586.  #if defined(BSD) && !defined(POSIX_TYPES)
587.  	(void) time((long *)&u.ubirthday);
588.  #else
589.  	(void) time(&u.ubirthday);
590.  #endif
591.  
592.  	/*
593.  	 *  For now, everyone starts out with a night vision range of 1 and
594.  	 *  their xray range disabled.
595.  	 */
596.  	u.nv_range   =  1;
597.  	u.xray_range = -1;
598.  
599.  

Role-specific initializations

600.  	/*** Role-specific initializations ***/
601.  	switch (Role_switch) {
602.  	/* rn2(100) > 50 necessary for some choices because some
603.  	 * random number generators are bad enough to seriously
604.  	 * skew the results if we use rn2(2)...  --KAA
605.  	 */

Archeologist initializations

606.  	case PM_ARCHEOLOGIST:
607.  		ini_inv(Archeologist);
608.  		if(!rn2(10)) ini_inv(Tinopener);
609.  		else if(!rn2(4)) ini_inv(Lamp);
610.  		else if(!rn2(10)) ini_inv(Magicmarker);
611.  		knows_object(SACK);
612.  		knows_object(TOUCHSTONE);
613.  		skill_init(Skill_A);
614.  		break;

Barbarian initializations

615.  	case PM_BARBARIAN:
616.  		if (rn2(100) >= 50) {	/* see above comment */
617.  		    Barbarian[B_MAJOR].trotyp = BATTLE_AXE;
618.  		    Barbarian[B_MINOR].trotyp = SHORT_SWORD;
619.  		}
620.  		ini_inv(Barbarian);
621.  		if(!rn2(6)) ini_inv(Lamp);
622.  		knows_class(WEAPON_CLASS);
623.  		knows_class(ARMOR_CLASS);
624.  		skill_init(Skill_B);
625.  		break;

Caveman initializations

626.  	case PM_CAVEMAN:
627.  		Cave_man[C_AMMO].trquan = rn1(11, 10);	/* 10..20 */
628.  		ini_inv(Cave_man);
629.  		skill_init(Skill_C);
630.  		break;

Healer initializations

631.  	case PM_HEALER:
632.  #ifndef GOLDOBJ
633.  		u.ugold = u.ugold0 = rn1(1000, 1001);
634.  #else
635.  		u.umoney0 = rn1(1000, 1001);
636.  #endif
637.  		ini_inv(Healer);
638.  		if(!rn2(25)) ini_inv(Lamp);
639.  		knows_object(POT_FULL_HEALING);
640.  		skill_init(Skill_H);
641.  		break;

Knight initializations

642.  	case PM_KNIGHT:
643.  		ini_inv(Knight);
644.  		knows_class(WEAPON_CLASS);
645.  		knows_class(ARMOR_CLASS);
646.  		/* give knights chess-like mobility
647.  		 * -- idea from wooledge@skybridge.scl.cwru.edu */
648.  		HJumping |= FROMOUTSIDE;
649.  		skill_init(Skill_K);
650.  		break;

Monk initializations

651.  	case PM_MONK:
652.  		switch (rn2(90) / 30) {
653.  		case 0: Monk[M_BOOK].trotyp = SPE_HEALING; break;
654.  		case 1: Monk[M_BOOK].trotyp = SPE_PROTECTION; break;
655.  		case 2: Monk[M_BOOK].trotyp = SPE_SLEEP; break;
656.  		}
657.  		ini_inv(Monk);
658.  		if(!rn2(5)) ini_inv(Magicmarker);
659.  		else if(!rn2(10)) ini_inv(Lamp);
660.  		knows_class(ARMOR_CLASS);
661.  		skill_init(Skill_Mon);
662.  		break;

Priest initializations

663.  	case PM_PRIEST:
664.  		ini_inv(Priest);
665.  		if(!rn2(10)) ini_inv(Magicmarker);
666.  		else if(!rn2(10)) ini_inv(Lamp);
667.  		knows_object(POT_WATER);
668.  		skill_init(Skill_P);
669.  		/* KMH, conduct --
670.  		 * Some may claim that this isn't agnostic, since they
671.  		 * are literally "priests" and they have holy water.
672.  		 * But we don't count it as such.  Purists can always
673.  		 * avoid playing priests and/or confirm another player's
674.  		 * role in their YAAP.
675.  		 */
676.  		break;

Ranger initializations

677.  	case PM_RANGER:
678.  		Ranger[RAN_TWO_ARROWS].trquan = rn1(10, 50);
679.  		Ranger[RAN_ZERO_ARROWS].trquan = rn1(10, 30);
680.  		ini_inv(Ranger);
681.  		skill_init(Skill_Ran);
682.  		break;

Rogue initializations

683.  	case PM_ROGUE:
684.  		Rogue[R_DAGGERS].trquan = rn1(10, 6);
685.  #ifndef GOLDOBJ
686.  		u.ugold = u.ugold0 = 0;
687.  #else
688.  		u.umoney0 = 0;
689.  #endif
690.  		ini_inv(Rogue);
691.  		if(!rn2(5)) ini_inv(Blindfold);
692.  		knows_object(SACK);
693.  		skill_init(Skill_R);
694.  		break;

Samurai initializations

695.  	case PM_SAMURAI:
696.  		Samurai[S_ARROWS].trquan = rn1(20, 26);
697.  		ini_inv(Samurai);
698.  		if(!rn2(5)) ini_inv(Blindfold);
699.  		knows_class(WEAPON_CLASS);
700.  		knows_class(ARMOR_CLASS);
701.  		skill_init(Skill_S);
702.  		break;

Tourist initializations

703.  #ifdef TOURIST
704.  	case PM_TOURIST:
705.  		Tourist[T_DARTS].trquan = rn1(20, 21);
706.  #ifndef GOLDOBJ
707.  		u.ugold = u.ugold0 = rnd(1000);
708.  #else
709.  		u.umoney0 = rnd(1000);
710.  #endif
711.  		ini_inv(Tourist);
712.  		if(!rn2(25)) ini_inv(Tinopener);
713.  		else if(!rn2(25)) ini_inv(Leash);
714.  		else if(!rn2(25)) ini_inv(Towel);
715.  		else if(!rn2(25)) ini_inv(Magicmarker);
716.  		skill_init(Skill_T);
717.  		break;
718.  #endif

Valkyrie initializations

719.  	case PM_VALKYRIE:
720.  		ini_inv(Valkyrie);
721.  		if(!rn2(6)) ini_inv(Lamp);
722.  		knows_class(WEAPON_CLASS);
723.  		knows_class(ARMOR_CLASS);
724.  		skill_init(Skill_V);
725.  		break;

Wizard initializations

726.  	case PM_WIZARD:
727.  		ini_inv(Wizard);
728.  		if(!rn2(5)) ini_inv(Magicmarker);
729.  		if(!rn2(5)) ini_inv(Blindfold);
730.  		skill_init(Skill_W);
731.  		break;
732.  
733.  	default:	/* impossible */
734.  		break;
735.  	}
736.  
737.  

Race-specific initializations

738.  	/*** Race-specific initializations ***/
739.  	switch (Race_switch) {

Human initializations

740.  	case PM_HUMAN:
741.  	    /* Nothing special */
742.  	    break;
743.  

Elf initializations

744.  	case PM_ELF:
745.  	    /*
746.  	     * Elves are people of music and song, or they are warriors.
747.  	     * Non-warriors get an instrument.  We use a kludge to
748.  	     * get only non-magic instruments.
749.  	     */
750.  	    if (Role_if(PM_PRIEST) || Role_if(PM_WIZARD)) {
751.  		static int trotyp[] = {
752.  		    WOODEN_FLUTE, TOOLED_HORN, WOODEN_HARP,
753.  		    BELL, BUGLE, LEATHER_DRUM
754.  		};
755.  		Instrument[0].trotyp = trotyp[rn2(SIZE(trotyp))];
756.  		ini_inv(Instrument);
757.  	    }
758.  
759.  	    /* Elves can recognize all elvish objects */
760.  	    knows_object(ELVEN_SHORT_SWORD);
761.  	    knows_object(ELVEN_ARROW);
762.  	    knows_object(ELVEN_BOW);
763.  	    knows_object(ELVEN_SPEAR);
764.  	    knows_object(ELVEN_DAGGER);
765.  	    knows_object(ELVEN_BROADSWORD);
766.  	    knows_object(ELVEN_MITHRIL_COAT);
767.  	    knows_object(ELVEN_LEATHER_HELM);
768.  	    knows_object(ELVEN_SHIELD);
769.  	    knows_object(ELVEN_BOOTS);
770.  	    knows_object(ELVEN_CLOAK);
771.  	    break;
772.  

Dwarf initializations

773.  	case PM_DWARF:
774.  	    /* Dwarves can recognize all dwarvish objects */
775.  	    knows_object(DWARVISH_SPEAR);
776.  	    knows_object(DWARVISH_SHORT_SWORD);
777.  	    knows_object(DWARVISH_MATTOCK);
778.  	    knows_object(DWARVISH_IRON_HELM);
779.  	    knows_object(DWARVISH_MITHRIL_COAT);
780.  	    knows_object(DWARVISH_CLOAK);
781.  	    knows_object(DWARVISH_ROUNDSHIELD);
782.  	    break;
783.  

Gnome initializations

784.  	case PM_GNOME:
785.  	    break;
786.  

Orc initializations

787.  	case PM_ORC:
788.  	    /* compensate for generally inferior equipment */
789.  	    if (!Role_if(PM_WIZARD))
790.  		ini_inv(Xtra_food);
791.  	    /* Orcs can recognize all orcish objects */
792.  	    knows_object(ORCISH_SHORT_SWORD);
793.  	    knows_object(ORCISH_ARROW);
794.  	    knows_object(ORCISH_BOW);
795.  	    knows_object(ORCISH_SPEAR);
796.  	    knows_object(ORCISH_DAGGER);
797.  	    knows_object(ORCISH_CHAIN_MAIL);
798.  	    knows_object(ORCISH_RING_MAIL);
799.  	    knows_object(ORCISH_HELM);
800.  	    knows_object(ORCISH_SHIELD);
801.  	    knows_object(URUK_HAI_SHIELD);
802.  	    knows_object(ORCISH_CLOAK);
803.  	    break;
804.  
805.  	default:	/* impossible */
806.  		break;
807.  	}
808.  
809.  	if (discover)
810.  		ini_inv(Wishing);
811.  
812.  #ifdef WIZARD
813.  	if (wizard)
814.  		read_wizkit();
815.  #endif
816.  
817.  #ifndef GOLDOBJ
818.  	u.ugold0 += hidden_gold();	/* in case sack has gold in it */
819.  #else
820.  	if (u.umoney0) ini_inv(Money);
821.  	u.umoney0 += hidden_gold();	/* in case sack has gold in it */
822.  #endif
823.  
824.  	find_ac();			/* get initial ac value */
825.  	init_attr(75);			/* init attribute values */
826.  	max_rank_sz();			/* set max str size for class ranks */
827.  /*
828.   *	Do we really need this?
829.   */
830.  	for(i = 0; i < A_MAX; i++)
831.  	    if(!rn2(20)) {
832.  		register int xd = rn2(7) - 2;	/* biased variation */
833.  		(void) adjattrib(i, xd, TRUE);
834.  		if (ABASE(i) < AMAX(i)) AMAX(i) = ABASE(i);
835.  	    }
836.  
837.  	/* make sure you can carry all you have - especially for Tourists */
838.  	while (inv_weight() > 0) {
839.  		if (adjattrib(A_STR, 1, TRUE)) continue;
840.  		if (adjattrib(A_CON, 1, TRUE)) continue;
841.  		/* only get here when didn't boost strength or constitution */
842.  		break;
843.  	}
844.  
845.  	return;
846.  }
847.  

restricted_spell_discipline

848.  /* skills aren't initialized, so we use the role-specific skill lists */
849.  STATIC_OVL boolean
850.  restricted_spell_discipline(otyp)
851.  int otyp;
852.  {
853.      const struct def_skill *skills;
854.      int this_skill = spell_skilltype(otyp);
855.  
856.      switch (Role_switch) {
857.       case PM_ARCHEOLOGIST:	skills = Skill_A; break;
858.       case PM_BARBARIAN:		skills = Skill_B; break;
859.       case PM_CAVEMAN:		skills = Skill_C; break;
860.       case PM_HEALER:		skills = Skill_H; break;
861.       case PM_KNIGHT:		skills = Skill_K; break;
862.       case PM_MONK:		skills = Skill_Mon; break;
863.       case PM_PRIEST:		skills = Skill_P; break;
864.       case PM_RANGER:		skills = Skill_Ran; break;
865.       case PM_ROGUE:		skills = Skill_R; break;
866.       case PM_SAMURAI:		skills = Skill_S; break;
867.  #ifdef TOURIST
868.       case PM_TOURIST:		skills = Skill_T; break;
869.  #endif
870.       case PM_VALKYRIE:		skills = Skill_V; break;
871.       case PM_WIZARD:		skills = Skill_W; break;
872.       default:			skills = 0; break;	/* lint suppression */
873.      }
874.  
875.      while (skills->skill != P_NONE) {
876.  	if (skills->skill == this_skill) return FALSE;
877.  	++skills;
878.      }
879.      return TRUE;
880.  }
881.  

ini_inv

882.  STATIC_OVL void
883.  ini_inv(trop)
884.  register struct trobj *trop;
885.  {
886.  	struct obj *obj;
887.  	int otyp, i;
888.  
889.  	while (trop->trclass) {
890.  		if (trop->trotyp != UNDEF_TYP) {
891.  			otyp = (int)trop->trotyp;
892.  			if (urace.malenum != PM_HUMAN) {
893.  			    /* substitute specific items for generic ones */
894.  			    for (i = 0; inv_subs[i].race_pm != NON_PM; ++i)
895.  				if (inv_subs[i].race_pm == urace.malenum &&
896.  					otyp == inv_subs[i].item_otyp) {
897.  				    otyp = inv_subs[i].subs_otyp;
898.  				    break;
899.  				}
900.  			}
901.  			obj = mksobj(otyp, TRUE, FALSE);
902.  		} else {	/* UNDEF_TYP */
903.  			static NEARDATA short nocreate = STRANGE_OBJECT;
904.  			static NEARDATA short nocreate2 = STRANGE_OBJECT;
905.  			static NEARDATA short nocreate3 = STRANGE_OBJECT;
906.  			static NEARDATA short nocreate4 = STRANGE_OBJECT;
907.  		/*
908.  		 * For random objects, do not create certain overly powerful
909.  		 * items: wand of wishing, ring of levitation, or the
910.  		 * polymorph/polymorph control combination.  Specific objects,
911.  		 * i.e. the discovery wishing, are still OK.
912.  		 * Also, don't get a couple of really useless items.  (Note:
913.  		 * punishment isn't "useless".  Some players who start out with
914.  		 * one will immediately read it and use the iron ball as a
915.  		 * weapon.)
916.  		 */
917.  			obj = mkobj(trop->trclass, FALSE);
918.  			otyp = obj->otyp;
919.  			while (otyp == WAN_WISHING
920.  				|| otyp == nocreate
921.  				|| otyp == nocreate2
922.  				|| otyp == nocreate3
923.  				|| otyp == nocreate4
924.  #ifdef ELBERETH
925.  				|| otyp == RIN_LEVITATION
926.  #endif
927.  				/* 'useless' items */
928.  				|| otyp == POT_HALLUCINATION
929.  				|| otyp == POT_ACID
930.  				|| otyp == SCR_AMNESIA
931.  				|| otyp == SCR_FIRE
932.  				|| otyp == SCR_BLANK_PAPER
933.  				|| otyp == SPE_BLANK_PAPER
934.  				|| otyp == RIN_AGGRAVATE_MONSTER
935.  				|| otyp == RIN_HUNGER
936.  				|| otyp == WAN_NOTHING
937.  				/* Monks don't use weapons */
938.  				|| (otyp == SCR_ENCHANT_WEAPON &&
939.  				    Role_if(PM_MONK))
940.  				/* wizard patch -- they already have one */
941.  				|| (otyp == SPE_FORCE_BOLT &&
942.  				    Role_if(PM_WIZARD))
943.  				/* powerful spells are either useless to
944.  				   low level players or unbalancing; also
945.  				   spells in restricted skill categories */
946.  				|| (obj->oclass == SPBOOK_CLASS &&
947.  				    (objects[otyp].oc_level > 3 ||
948.  				    restricted_spell_discipline(otyp)))
949.  							) {
950.  				dealloc_obj(obj);
951.  				obj = mkobj(trop->trclass, FALSE);
952.  				otyp = obj->otyp;
953.  			}
954.  
955.  			/* Don't start with +0 or negative rings */
956.  			if (objects[otyp].oc_charged && obj->spe <= 0)
957.  				obj->spe = rne(3);
958.  
959.  			/* Heavily relies on the fact that 1) we create wands
960.  			 * before rings, 2) that we create rings before
961.  			 * spellbooks, and that 3) not more than 1 object of a
962.  			 * particular symbol is to be prohibited.  (For more
963.  			 * objects, we need more nocreate variables...)
964.  			 */
965.  			switch (otyp) {
966.  			    case WAN_POLYMORPH:
967.  			    case RIN_POLYMORPH:
968.  			    case POT_POLYMORPH:
969.  				nocreate = RIN_POLYMORPH_CONTROL;
970.  				break;
971.  			    case RIN_POLYMORPH_CONTROL:
972.  				nocreate = RIN_POLYMORPH;
973.  				nocreate2 = SPE_POLYMORPH;
974.  				nocreate3 = POT_POLYMORPH;
975.  			}
976.  			/* Don't have 2 of the same ring or spellbook */
977.  			if (obj->oclass == RING_CLASS ||
978.  			    obj->oclass == SPBOOK_CLASS)
979.  				nocreate4 = otyp;
980.  		}
981.  
982.  #ifdef GOLDOBJ
983.  		if (trop->trclass == COIN_CLASS) {
984.  			/* no "blessed" or "identified" money */
985.  			obj->quan = u.umoney0;
986.  		} else {
987.  #endif
988.  			obj->dknown = obj->bknown = obj->rknown = 1;
989.  			if (objects[otyp].oc_uses_known) obj->known = 1;
990.  			obj->cursed = 0;
991.  			if (obj->opoisoned && u.ualign.type != A_CHAOTIC)
992.  			    obj->opoisoned = 0;
993.  			if (obj->oclass == WEAPON_CLASS ||
994.  				obj->oclass == TOOL_CLASS) {
995.  			    obj->quan = (long) trop->trquan;
996.  			    trop->trquan = 1;
997.  			} else if (obj->oclass == GEM_CLASS &&
998.  				is_graystone(obj) && obj->otyp != FLINT) {
999.  			    obj->quan = 1L;
1000. 			}
1001. 			if (trop->trspe != UNDEF_SPE)
1002. 			    obj->spe = trop->trspe;
1003. 			if (trop->trbless != UNDEF_BLESS)
1004. 			    obj->blessed = trop->trbless;
1005. #ifdef GOLDOBJ
1006. 		}
1007. #endif
1008. 		/* defined after setting otyp+quan + blessedness */
1009. 		obj->owt = weight(obj);
1010. 		obj = addinv(obj);
1011. 
1012. 		/* Make the type known if necessary */
1013. 		if (OBJ_DESCR(objects[otyp]) && obj->known)
1014. 			discover_object(otyp, TRUE, FALSE);
1015. 		if (otyp == OIL_LAMP)
1016. 			discover_object(POT_OIL, TRUE, FALSE);
1017. 
1018. 		if(obj->oclass == ARMOR_CLASS){
1019. 			if (is_shield(obj) && !uarms) {
1020. 				setworn(obj, W_ARMS);
1021. 				if (uswapwep) setuswapwep((struct obj *) 0);
1022. 			} else if (is_helmet(obj) && !uarmh)
1023. 				setworn(obj, W_ARMH);
1024. 			else if (is_gloves(obj) && !uarmg)
1025. 				setworn(obj, W_ARMG);
1026. #ifdef TOURIST
1027. 			else if (is_shirt(obj) && !uarmu)
1028. 				setworn(obj, W_ARMU);
1029. #endif
1030. 			else if (is_cloak(obj) && !uarmc)
1031. 				setworn(obj, W_ARMC);
1032. 			else if (is_boots(obj) && !uarmf)
1033. 				setworn(obj, W_ARMF);
1034. 			else if (is_suit(obj) && !uarm)
1035. 				setworn(obj, W_ARM);
1036. 		}
1037. 
1038. 		if (obj->oclass == WEAPON_CLASS || is_weptool(obj) ||
1039. 			otyp == TIN_OPENER || otyp == FLINT || otyp == ROCK) {
1040. 		    if (is_ammo(obj) || is_missile(obj)) {
1041. 			if (!uquiver) setuqwep(obj);
1042. 		    } else if (!uwep) setuwep(obj);
1043. 		    else if (!uswapwep) setuswapwep(obj);
1044. 		}
1045. 		if (obj->oclass == SPBOOK_CLASS &&
1046. 				obj->otyp != SPE_BLANK_PAPER)
1047. 		    initialspell(obj);
1048. 
1049. #if !defined(PYRAMID_BUG) && !defined(MAC)
1050. 		if(--trop->trquan) continue;	/* make a similar object */
1051. #else
1052. 		if(trop->trquan) {		/* check if zero first */
1053. 			--trop->trquan;
1054. 			if(trop->trquan)
1055. 				continue;	/* make a similar object */
1056. 		}
1057. #endif
1058. 		trop++;
1059. 	}
1060. }
1061. 
1062. /*u_init.c*/