Source:NetHack 5.0.0/src/u init.c

From NetHackWiki
Jump to navigation Jump to search

Below is the full text to u_init.c from the source code of NetHack 5.0.0. To link to a particular line, write [[Source:NetHack 5.0.0/src/u_init.c#line12]], for example.

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.

1. /* NetHack 5.0	u_init.c	$NHDT-Date: 1769398807 2026/01/25 19:40:07 $  $NHDT-Branch: NetHack-3.7 $:$NHDT-Revision: 1.121 $ */
2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3. /*-Copyright (c) Robert Patrick Rankin, 2017. */
4. /* NetHack may be freely redistributed.  See license for details. */
5. 
6. #include "hack.h"
7. 
8. struct trobj {
9.     short trotyp;
10.     schar trspe;
11.     char trclass;
12.     char trquan_min;
13.     char trquan_max;
14.     char trbless;
15. };
16. 
17. staticfn long trquan(const struct trobj *);
18. staticfn struct obj *ini_inv_mkobj_filter(int, boolean);
19. staticfn short ini_inv_obj_substitution(const struct trobj *,
20.                                         struct obj *) NONNULLPTRS;
21. staticfn boolean ini_inv_adjust_obj(const struct trobj *,
22.                                     struct obj *) NONNULLPTRS;
23. staticfn void ini_inv_use_obj(struct obj *) NONNULLARG1;
24. staticfn void ini_inv(const struct trobj *) NONNULLARG1;
25. staticfn void knows_object(int, boolean);
26. staticfn void knows_class(char);
27. staticfn void u_init_role(void);
28. staticfn void u_init_race(void);
29. staticfn void pauper_reinit(void);
30. staticfn const struct def_skill *skills_for_role(void);
31. staticfn void u_init_carry_attr_boost(void);
32. staticfn boolean restricted_spell_discipline(int);
33. 
34. #define UNDEF_TYP 0
35. #define UNDEF_SPE '\177'
36. #define UNDEF_BLESS 2
37. 
38. /*
39.  *      Initial inventory for the various roles.
40.  */
41. 
42. static const struct trobj Archeologist[] = {
43.     /* if adventure has a name...  idea from tan@uvm-gen */
44.     { BULLWHIP, 2, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
45.     { LEATHER_JACKET, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
46.     { FEDORA, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
47.     { FOOD_RATION, 0, FOOD_CLASS, 3, 3, 0 },
48.     { PICK_AXE, UNDEF_SPE, TOOL_CLASS, 1, 1, UNDEF_BLESS },
49.     { TINNING_KIT, UNDEF_SPE, TOOL_CLASS, 1, 1, UNDEF_BLESS },
50.     { TOUCHSTONE, 0, GEM_CLASS, 1, 1, 0 },
51.     { SACK, 0, TOOL_CLASS, 1, 1, 0 },
52.     { 0, 0, 0, 0, 0, 0 }
53. };
54. static const struct trobj Barbarian_0[] = {
55.     { TWO_HANDED_SWORD, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
56.     { AXE, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
57.     { RING_MAIL, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
58.     { FOOD_RATION, 0, FOOD_CLASS, 1, 1, 0 },
59.     { 0, 0, 0, 0, 0, 0 }
60. };
61. static const struct trobj Barbarian_1[] = {
62.     { BATTLE_AXE, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
63.     { SHORT_SWORD, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
64.     { RING_MAIL, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
65.     { FOOD_RATION, 0, FOOD_CLASS, 1, 1, 0 },
66.     { 0, 0, 0, 0, 0, 0 }
67. };
68. static const struct trobj Cave_man[] = {
69.     { CLUB, 1, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
70.     { SLING, 2, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
71.     { FLINT, 0, GEM_CLASS, 10, 20, UNDEF_BLESS },
72.     { ROCK, 0, GEM_CLASS, 3, 3, 0 }, /* yields 18..33 */
73.     { LEATHER_ARMOR, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
74.     { 0, 0, 0, 0, 0, 0 }
75. };
76. static const struct trobj Healer[] = {
77.     { SCALPEL, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
78.     { LEATHER_GLOVES, 1, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
79.     { STETHOSCOPE, 0, TOOL_CLASS, 1, 1, 0 },
80.     { POT_HEALING, 0, POTION_CLASS, 4, 4, UNDEF_BLESS },
81.     { POT_EXTRA_HEALING, 0, POTION_CLASS, 4, 4, UNDEF_BLESS },
82.     { WAN_SLEEP, UNDEF_SPE, WAND_CLASS, 1, 1, UNDEF_BLESS },
83.     /* always blessed, so it's guaranteed readable */
84.     { SPE_HEALING, 0, SPBOOK_CLASS, 1, 1, 1 },
85.     { SPE_EXTRA_HEALING, 0, SPBOOK_CLASS, 1, 1, 1 },
86.     { SPE_STONE_TO_FLESH, 0, SPBOOK_CLASS, 1, 1, 1 },
87.     { APPLE, 0, FOOD_CLASS, 5, 5, 0 },
88.     { 0, 0, 0, 0, 0, 0 }
89. };
90. static const struct trobj Knight[] = {
91.     { LONG_SWORD, 1, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
92.     { LANCE, 1, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
93.     { RING_MAIL, 1, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
94.     { HELMET, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
95.     { SMALL_SHIELD, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
96.     { LEATHER_GLOVES, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
97.     { APPLE, 0, FOOD_CLASS, 10, 10, 0 },
98.     { CARROT, 0, FOOD_CLASS, 10, 10, 0 },
99.     { 0, 0, 0, 0, 0, 0 }
100. };
101. static const struct trobj Monk[] = {
102.     { LEATHER_GLOVES, 2, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
103.     { ROBE, 1, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
104.     { UNDEF_TYP, UNDEF_SPE, SCROLL_CLASS, 1, 1, UNDEF_BLESS },
105.     { POT_HEALING, 0, POTION_CLASS, 3, 3, UNDEF_BLESS },
106.     { FOOD_RATION, 0, FOOD_CLASS, 3, 3, 0 },
107.     { APPLE, 0, FOOD_CLASS, 5, 5, UNDEF_BLESS },
108.     { ORANGE, 0, FOOD_CLASS, 5, 5, UNDEF_BLESS },
109.     /* Yes, we know fortune cookies aren't really from China.  They were
110.        invented by George Jung in Los Angeles, California, USA in 1916. */
111.     { FORTUNE_COOKIE, 0, FOOD_CLASS, 3, 3, UNDEF_BLESS },
112.     { 0, 0, 0, 0, 0, 0 }
113. };
114. static const struct trobj Priest[] = {
115.     { MACE, 1, WEAPON_CLASS, 1, 1, 1 },
116.     { ROBE, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
117.     { SMALL_SHIELD, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
118.     { POT_WATER, 0, POTION_CLASS, 4, 4, 1 }, /* holy water */
119.     { CLOVE_OF_GARLIC, 0, FOOD_CLASS, 1, 1, 0 },
120.     { SPRIG_OF_WOLFSBANE, 0, FOOD_CLASS, 1, 1, 0 },
121.     { UNDEF_TYP, UNDEF_SPE, SPBOOK_CLASS, 2, 2, UNDEF_BLESS },
122.     { 0, 0, 0, 0, 0, 0 }
123. };
124. static const struct trobj Ranger[] = {
125.     { DAGGER, 1, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
126.     { BOW, 1, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
127.     { ARROW, 2, WEAPON_CLASS, 50, 59, UNDEF_BLESS },
128.     { ARROW, 0, WEAPON_CLASS, 30, 39, UNDEF_BLESS },
129.     { CLOAK_OF_DISPLACEMENT, 2, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
130.     { CRAM_RATION, 0, FOOD_CLASS, 4, 4, 0 },
131.     { 0, 0, 0, 0, 0, 0 }
132. };
133. static const struct trobj Rogue[] = {
134.     { SHORT_SWORD, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
135.     { DAGGER, 0, WEAPON_CLASS, 6, 15, 0 },
136.     { LEATHER_ARMOR, 1, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
137.     { POT_SICKNESS, 0, POTION_CLASS, 1, 1, 0 },
138.     { LOCK_PICK, 0, TOOL_CLASS, 1, 1, 0 },
139.     { SACK, 0, TOOL_CLASS, 1, 1, 0 },
140.     { 0, 0, 0, 0, 0, 0 }
141. };
142. static const struct trobj Samurai[] = {
143.     { KATANA, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
144.     { SHORT_SWORD, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS }, /* wakizashi */
145.     { YUMI, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
146.     { YA, 0, WEAPON_CLASS, 26, 45, UNDEF_BLESS },
147.     { SPLINT_MAIL, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
148.     { 0, 0, 0, 0, 0, 0 }
149. };
150. static const struct trobj Tourist[] = {
151.     { DART, 2, WEAPON_CLASS, 21, 40, UNDEF_BLESS },
152.     { UNDEF_TYP, UNDEF_SPE, FOOD_CLASS, 10, 10, 0 },
153.     { POT_EXTRA_HEALING, 0, POTION_CLASS, 2, 2, UNDEF_BLESS },
154.     { SCR_MAGIC_MAPPING, 0, SCROLL_CLASS, 4, 4, UNDEF_BLESS },
155.     { HAWAIIAN_SHIRT, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
156.     { EXPENSIVE_CAMERA, UNDEF_SPE, TOOL_CLASS, 1, 1, 0 },
157.     { CREDIT_CARD, 0, TOOL_CLASS, 1, 1, 0 },
158.     { 0, 0, 0, 0, 0, 0 }
159. };
160. static const struct trobj Valkyrie[] = {
161.     { SPEAR, 1, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
162.     { DAGGER, 0, WEAPON_CLASS, 1, 1, UNDEF_BLESS },
163.     { SMALL_SHIELD, 3, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
164.     { FOOD_RATION, 0, FOOD_CLASS, 1, 1, 0 },
165.     { 0, 0, 0, 0, 0, 0 }
166. };
167. static const struct trobj Wizard[] = {
168.     { QUARTERSTAFF, 1, WEAPON_CLASS, 1, 1, 1 },
169.     { CLOAK_OF_MAGIC_RESISTANCE, 0, ARMOR_CLASS, 1, 1, UNDEF_BLESS },
170.     { UNDEF_TYP, UNDEF_SPE, WAND_CLASS, 1, 1, UNDEF_BLESS },
171.     { UNDEF_TYP, UNDEF_SPE, RING_CLASS, 2, 2, UNDEF_BLESS },
172.     { UNDEF_TYP, UNDEF_SPE, POTION_CLASS, 3, 3, UNDEF_BLESS },
173.     { UNDEF_TYP, UNDEF_SPE, SCROLL_CLASS, 3, 3, UNDEF_BLESS },
174.     { SPE_FORCE_BOLT, 0, SPBOOK_CLASS, 1, 1, 1 },
175.     { UNDEF_TYP, UNDEF_SPE, SPBOOK_CLASS, 1, 1, UNDEF_BLESS },
176.     { MAGIC_MARKER, 19, TOOL_CLASS, 1, 1, 0 }, /* actually spe = 18 + d4 */
177.     { 0, 0, 0, 0, 0, 0 }
178. };
179. 
180. /*
181.  *      Optional extra inventory items.
182.  */
183. 
184. static const struct trobj Healing_book[] =
185.     { { SPE_HEALING, UNDEF_SPE, SPBOOK_CLASS, 1, 1, 1 },
186.       { 0, 0, 0, 0, 0, 0 } };
187. static const struct trobj Protection_book[] =
188.     { { SPE_PROTECTION, UNDEF_SPE, SPBOOK_CLASS, 1, 1, 1 },
189.       { 0, 0, 0, 0, 0, 0 } };
190. static const struct trobj Confuse_monster_book[] =
191.     { { SPE_CONFUSE_MONSTER, UNDEF_SPE, SPBOOK_CLASS, 1, 1, 1 },
192.       { 0, 0, 0, 0, 0, 0 } };
193. static const struct trobj Tinopener[] =
194.     { { TIN_OPENER, 0, TOOL_CLASS, 1, 1, 0 },
195.       { 0, 0, 0, 0, 0, 0 } };
196. static const struct trobj Magicmarker[] =
197.     { { MAGIC_MARKER, 19, TOOL_CLASS, 1, 1, 0 },
198.       { 0, 0, 0, 0, 0, 0 } };
199. static const struct trobj Lamp[] =
200.     { { OIL_LAMP, 1, TOOL_CLASS, 1, 1, 0 },
201.       { 0, 0, 0, 0, 0, 0 } };
202. static const struct trobj Blindfold[] =
203.     { { BLINDFOLD, 0, TOOL_CLASS, 1, 1, 0 },
204.       { 0, 0, 0, 0, 0, 0 } };
205. static const struct trobj Xtra_food[] =
206.     { { UNDEF_TYP, UNDEF_SPE, FOOD_CLASS, 2, 2, 0},
207.       { 0, 0, 0, 0, 0, 0 } };
208. static const struct trobj Leash[] =
209.     { { LEASH, 0, TOOL_CLASS, 1, 1, 0 },
210.       { 0, 0, 0, 0, 0, 0 } };
211. static const struct trobj Towel[] =
212.     { { TOWEL, 0, TOOL_CLASS, 1, 1, 0 },
213.       { 0, 0, 0, 0, 0, 0 } };
214. static const struct trobj Wishing[] =
215.     { { WAN_WISHING, 3, WAND_CLASS, 1, 1, 0 },
216.       { 0, 0, 0, 0, 0, 0 } };
217. static const struct trobj Money[] =
218.     { { GOLD_PIECE, 0, COIN_CLASS, 1, 1, 0 },
219.       { 0, 0, 0, 0, 0, 0 } };
220. 
221. /* race-based substitutions for initial inventory;
222.    the weaker cloak for elven rangers is intentional--they shoot better */
223. static const struct inv_sub {
224.     short race_pm, item_otyp, subs_otyp;
225. } 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_ORC, CRAM_RATION, TRIPE_RATION },
245.     { PM_ORC, LEMBAS_WAFER, TRIPE_RATION },
246.     { PM_DWARF, SPEAR, DWARVISH_SPEAR },
247.     { PM_DWARF, SHORT_SWORD, DWARVISH_SHORT_SWORD },
248.     { PM_DWARF, HELMET, DWARVISH_IRON_HELM },
249.     /* { PM_DWARF, SMALL_SHIELD, DWARVISH_ROUNDSHIELD }, */
250.     /* { PM_DWARF, PICK_AXE, DWARVISH_MATTOCK }, */
251.     { PM_DWARF, LEMBAS_WAFER, CRAM_RATION },
252.     { PM_GNOME, BOW, CROSSBOW },
253.     { PM_GNOME, ARROW, CROSSBOW_BOLT },
254.     { NON_PM, STRANGE_OBJECT, STRANGE_OBJECT }
255. };
256. 
257. static const struct def_skill Skill_A[] = {
258.     { P_DAGGER, P_BASIC },
259.     { P_KNIFE, P_BASIC },
260.     { P_PICK_AXE, P_EXPERT },
261.     { P_SHORT_SWORD, P_BASIC },
262.     { P_SABER, P_EXPERT },
263.     { P_CLUB, P_SKILLED },
264.     { P_QUARTERSTAFF, P_SKILLED },
265.     { P_SLING, P_SKILLED },
266.     { P_DART, P_BASIC },
267.     { P_BOOMERANG, P_EXPERT },
268.     { P_WHIP, P_EXPERT },
269.     { P_UNICORN_HORN, P_SKILLED },
270.     { P_ATTACK_SPELL, P_BASIC },
271.     { P_HEALING_SPELL, P_BASIC },
272.     { P_DIVINATION_SPELL, P_EXPERT },
273.     { P_MATTER_SPELL, P_BASIC },
274.     { P_RIDING, P_BASIC },
275.     { P_TWO_WEAPON_COMBAT, P_BASIC },
276.     { P_BARE_HANDED_COMBAT, P_EXPERT },
277.     { P_NONE, 0 }
278. };
279. static const struct def_skill Skill_B[] = {
280.     { P_DAGGER, P_BASIC },
281.     { P_AXE, P_EXPERT },
282.     { P_PICK_AXE, P_SKILLED },
283.     { P_SHORT_SWORD, P_EXPERT },
284.     { P_BROAD_SWORD, P_SKILLED },
285.     { P_LONG_SWORD, P_SKILLED },
286.     { P_TWO_HANDED_SWORD, P_EXPERT },
287.     { P_SABER, P_SKILLED },
288.     { P_CLUB, P_SKILLED },
289.     { P_MACE, P_SKILLED },
290.     { P_MORNING_STAR, P_SKILLED },
291.     { P_FLAIL, P_BASIC },
292.     { P_HAMMER, P_EXPERT },
293.     { P_QUARTERSTAFF, P_BASIC },
294.     { P_SPEAR, P_SKILLED },
295.     { P_TRIDENT, P_SKILLED },
296.     { P_BOW, P_BASIC },
297.     { P_ATTACK_SPELL, P_BASIC },
298.     { P_ESCAPE_SPELL, P_BASIC }, /* special spell is haste self */
299.     { P_RIDING, P_BASIC },
300.     { P_TWO_WEAPON_COMBAT, P_BASIC },
301.     { P_BARE_HANDED_COMBAT, P_MASTER },
302.     { P_NONE, 0 }
303. };
304. static const struct def_skill Skill_C[] = {
305.     { P_DAGGER, P_BASIC },
306.     { P_KNIFE, P_SKILLED },
307.     { P_AXE, P_SKILLED },
308.     { P_PICK_AXE, P_BASIC },
309.     { P_CLUB, P_EXPERT },
310.     { P_MACE, P_EXPERT },
311.     { P_MORNING_STAR, P_BASIC },
312.     { P_FLAIL, P_SKILLED },
313.     { P_HAMMER, P_SKILLED },
314.     { P_QUARTERSTAFF, P_EXPERT },
315.     { P_POLEARMS, P_SKILLED },
316.     { P_SPEAR, P_EXPERT },
317.     { P_TRIDENT, P_SKILLED },
318.     { P_BOW, P_SKILLED },
319.     { P_SLING, P_EXPERT },
320.     { P_ATTACK_SPELL, P_BASIC },
321.     { P_MATTER_SPELL, P_SKILLED },
322.     { P_BOOMERANG, P_EXPERT },
323.     { P_UNICORN_HORN, P_BASIC },
324.     { P_BARE_HANDED_COMBAT, P_MASTER },
325.     { P_NONE, 0 }
326. };
327. static const struct def_skill Skill_H[] = {
328.     { P_DAGGER, P_SKILLED },
329.     { P_KNIFE, P_EXPERT },
330.     { P_SHORT_SWORD, P_SKILLED },
331.     { P_SABER, P_BASIC },
332.     { P_CLUB, P_SKILLED },
333.     { P_MACE, P_BASIC },
334.     { P_QUARTERSTAFF, P_EXPERT },
335.     { P_POLEARMS, P_BASIC },
336.     { P_SPEAR, P_BASIC },
337.     { P_TRIDENT, P_BASIC },
338.     { P_SLING, P_SKILLED },
339.     { P_DART, P_EXPERT },
340.     { P_SHURIKEN, P_SKILLED },
341.     { P_UNICORN_HORN, P_EXPERT },
342.     { P_HEALING_SPELL, P_EXPERT },
343.     { P_BARE_HANDED_COMBAT, P_BASIC },
344.     { P_NONE, 0 }
345. };
346. static const struct def_skill Skill_K[] = {
347.     { P_DAGGER, P_BASIC },
348.     { P_KNIFE, P_BASIC },
349.     { P_AXE, P_SKILLED },
350.     { P_PICK_AXE, P_BASIC },
351.     { P_SHORT_SWORD, P_SKILLED },
352.     { P_BROAD_SWORD, P_SKILLED },
353.     { P_LONG_SWORD, P_EXPERT },
354.     { P_TWO_HANDED_SWORD, P_SKILLED },
355.     { P_SABER, P_SKILLED },
356.     { P_CLUB, P_BASIC },
357.     { P_MACE, P_SKILLED },
358.     { P_MORNING_STAR, P_SKILLED },
359.     { P_FLAIL, P_BASIC },
360.     { P_HAMMER, P_BASIC },
361.     { P_POLEARMS, P_SKILLED },
362.     { P_SPEAR, P_SKILLED },
363.     { P_TRIDENT, P_BASIC },
364.     { P_LANCE, P_EXPERT },
365.     { P_BOW, P_BASIC },
366.     { P_CROSSBOW, P_SKILLED },
367.     { P_ATTACK_SPELL, P_SKILLED },
368.     { P_HEALING_SPELL, P_SKILLED },
369.     { P_CLERIC_SPELL, P_SKILLED },
370.     { P_RIDING, P_EXPERT },
371.     { P_TWO_WEAPON_COMBAT, P_SKILLED },
372.     { P_BARE_HANDED_COMBAT, P_EXPERT },
373.     { P_NONE, 0 }
374. };
375. static const struct def_skill Skill_Mon[] = {
376.     { P_QUARTERSTAFF, P_BASIC },
377.     { P_SPEAR, P_BASIC },
378.     { P_CROSSBOW, P_BASIC },
379.     { P_SHURIKEN, P_BASIC },
380.     { P_ATTACK_SPELL, P_BASIC },
381.     { P_HEALING_SPELL, P_EXPERT },
382.     { P_DIVINATION_SPELL, P_BASIC },
383.     { P_ENCHANTMENT_SPELL, P_BASIC },
384.     { P_CLERIC_SPELL, P_SKILLED },
385.     { P_ESCAPE_SPELL, P_SKILLED },
386.     { P_MATTER_SPELL, P_BASIC },
387.     { P_MARTIAL_ARTS, P_GRAND_MASTER },
388.     { P_NONE, 0 }
389. };
390. static const struct def_skill Skill_P[] = {
391.     { P_CLUB, P_EXPERT },
392.     { P_MACE, P_EXPERT },
393.     { P_MORNING_STAR, P_EXPERT },
394.     { P_FLAIL, P_EXPERT },
395.     { P_HAMMER, P_EXPERT },
396.     { P_QUARTERSTAFF, P_EXPERT },
397.     { P_POLEARMS, P_SKILLED },
398.     { P_SPEAR, P_SKILLED },
399.     { P_TRIDENT, P_SKILLED },
400.     { P_LANCE, P_BASIC },
401.     { P_BOW, P_BASIC },
402.     { P_SLING, P_BASIC },
403.     { P_CROSSBOW, P_BASIC },
404.     { P_DART, P_BASIC },
405.     { P_SHURIKEN, P_BASIC },
406.     { P_BOOMERANG, P_BASIC },
407.     { P_UNICORN_HORN, P_SKILLED },
408.     { P_HEALING_SPELL, P_EXPERT },
409.     { P_DIVINATION_SPELL, P_EXPERT },
410.     { P_CLERIC_SPELL, P_EXPERT },
411.     { P_BARE_HANDED_COMBAT, P_BASIC },
412.     { P_NONE, 0 }
413. };
414. static const struct def_skill Skill_R[] = {
415.     { P_DAGGER, P_EXPERT },
416.     { P_KNIFE, P_EXPERT },
417.     { P_SHORT_SWORD, P_EXPERT },
418.     { P_BROAD_SWORD, P_SKILLED },
419.     { P_LONG_SWORD, P_SKILLED },
420.     { P_TWO_HANDED_SWORD, P_BASIC },
421.     { P_SABER, P_SKILLED },
422.     { P_CLUB, P_SKILLED },
423.     { P_MACE, P_SKILLED },
424.     { P_MORNING_STAR, P_BASIC },
425.     { P_FLAIL, P_BASIC },
426.     { P_HAMMER, P_BASIC },
427.     { P_POLEARMS, P_BASIC },
428.     { P_SPEAR, P_BASIC },
429.     { P_CROSSBOW, P_EXPERT },
430.     { P_DART, P_EXPERT },
431.     { P_SHURIKEN, P_SKILLED },
432.     { P_DIVINATION_SPELL, P_SKILLED },
433.     { P_ESCAPE_SPELL, P_SKILLED },
434.     { P_MATTER_SPELL, P_SKILLED },
435.     { P_RIDING, P_BASIC },
436.     { P_TWO_WEAPON_COMBAT, P_EXPERT },
437.     { P_BARE_HANDED_COMBAT, P_EXPERT },
438.     { P_NONE, 0 }
439. };
440. static const struct def_skill Skill_Ran[] = {
441.     { P_DAGGER, P_EXPERT },
442.     { P_KNIFE, P_SKILLED },
443.     { P_AXE, P_SKILLED },
444.     { P_PICK_AXE, P_BASIC },
445.     { P_SHORT_SWORD, P_BASIC },
446.     { P_MORNING_STAR, P_BASIC },
447.     { P_FLAIL, P_SKILLED },
448.     { P_HAMMER, P_BASIC },
449.     { P_QUARTERSTAFF, P_BASIC },
450.     { P_POLEARMS, P_SKILLED },
451.     { P_SPEAR, P_EXPERT },
452.     { P_TRIDENT, P_BASIC },
453.     { P_BOW, P_EXPERT },
454.     { P_SLING, P_EXPERT },
455.     { P_CROSSBOW, P_EXPERT },
456.     { P_DART, P_EXPERT },
457.     { P_SHURIKEN, P_SKILLED },
458.     { P_BOOMERANG, P_EXPERT },
459.     { P_WHIP, P_BASIC },
460.     { P_HEALING_SPELL, P_BASIC },
461.     { P_DIVINATION_SPELL, P_EXPERT },
462.     { P_ESCAPE_SPELL, P_BASIC },
463.     { P_RIDING, P_BASIC },
464.     { P_BARE_HANDED_COMBAT, P_BASIC },
465.     { P_NONE, 0 }
466. };
467. static const struct def_skill Skill_S[] = {
468.     { P_DAGGER, P_BASIC },
469.     { P_KNIFE, P_SKILLED },
470.     { P_SHORT_SWORD, P_EXPERT },
471.     { P_BROAD_SWORD, P_SKILLED },
472.     { P_LONG_SWORD, P_EXPERT },
473.     { P_TWO_HANDED_SWORD, P_EXPERT },
474.     { P_SABER, P_BASIC },
475.     { P_FLAIL, P_SKILLED },
476.     { P_QUARTERSTAFF, P_BASIC },
477.     { P_POLEARMS, P_SKILLED },
478.     { P_SPEAR, P_SKILLED },
479.     { P_LANCE, P_SKILLED },
480.     { P_BOW, P_EXPERT },
481.     { P_SHURIKEN, P_EXPERT },
482.     { P_ATTACK_SPELL, P_BASIC },
483.     { P_DIVINATION_SPELL, P_BASIC }, /* special spell is clairvoyance */
484.     { P_CLERIC_SPELL, P_SKILLED },
485.     { P_RIDING, P_SKILLED },
486.     { P_TWO_WEAPON_COMBAT, P_EXPERT },
487.     { P_MARTIAL_ARTS, P_MASTER },
488.     { P_NONE, 0 }
489. };
490. static const struct def_skill Skill_T[] = {
491.     { P_DAGGER, P_EXPERT },
492.     { P_KNIFE, P_SKILLED },
493.     { P_AXE, P_BASIC },
494.     { P_PICK_AXE, P_BASIC },
495.     { P_SHORT_SWORD, P_EXPERT },
496.     { P_BROAD_SWORD, P_BASIC },
497.     { P_LONG_SWORD, P_BASIC },
498.     { P_TWO_HANDED_SWORD, P_BASIC },
499.     { P_SABER, P_SKILLED },
500.     { P_MACE, P_BASIC },
501.     { P_MORNING_STAR, P_BASIC },
502.     { P_FLAIL, P_BASIC },
503.     { P_HAMMER, P_BASIC },
504.     { P_QUARTERSTAFF, P_BASIC },
505.     { P_POLEARMS, P_BASIC },
506.     { P_SPEAR, P_BASIC },
507.     { P_TRIDENT, P_BASIC },
508.     { P_LANCE, P_BASIC },
509.     { P_BOW, P_BASIC },
510.     { P_SLING, P_BASIC },
511.     { P_CROSSBOW, P_BASIC },
512.     { P_DART, P_EXPERT },
513.     { P_SHURIKEN, P_BASIC },
514.     { P_BOOMERANG, P_BASIC },
515.     { P_WHIP, P_BASIC },
516.     { P_UNICORN_HORN, P_SKILLED },
517.     { P_DIVINATION_SPELL, P_BASIC },
518.     { P_ENCHANTMENT_SPELL, P_BASIC },
519.     { P_ESCAPE_SPELL, P_SKILLED },
520.     { P_RIDING, P_BASIC },
521.     { P_TWO_WEAPON_COMBAT, P_SKILLED },
522.     { P_BARE_HANDED_COMBAT, P_SKILLED },
523.     { P_NONE, 0 }
524. };
525. static const struct def_skill Skill_V[] = {
526.     { P_DAGGER, P_EXPERT },
527.     { P_AXE, P_EXPERT },
528.     { P_PICK_AXE, P_SKILLED },
529.     { P_SHORT_SWORD, P_SKILLED },
530.     { P_BROAD_SWORD, P_SKILLED },
531.     { P_LONG_SWORD, P_EXPERT },
532.     { P_TWO_HANDED_SWORD, P_EXPERT },
533.     { P_SABER, P_BASIC },
534.     { P_HAMMER, P_EXPERT },
535.     { P_QUARTERSTAFF, P_BASIC },
536.     { P_POLEARMS, P_SKILLED },
537.     { P_SPEAR, P_EXPERT },
538.     { P_TRIDENT, P_BASIC },
539.     { P_LANCE, P_SKILLED },
540.     { P_SLING, P_BASIC },
541.     { P_ATTACK_SPELL, P_BASIC },
542.     { P_ESCAPE_SPELL, P_BASIC },
543.     { P_RIDING, P_SKILLED },
544.     { P_TWO_WEAPON_COMBAT, P_SKILLED },
545.     { P_BARE_HANDED_COMBAT, P_EXPERT },
546.     { P_NONE, 0 }
547. };
548. static const struct def_skill Skill_W[] = {
549.     { P_DAGGER, P_EXPERT },
550.     { P_KNIFE, P_SKILLED },
551.     { P_AXE, P_SKILLED },
552.     { P_SHORT_SWORD, P_BASIC },
553.     { P_CLUB, P_SKILLED },
554.     { P_MACE, P_BASIC },
555.     { P_QUARTERSTAFF, P_EXPERT },
556.     { P_POLEARMS, P_SKILLED },
557.     { P_SPEAR, P_BASIC },
558.     { P_TRIDENT, P_BASIC },
559.     { P_SLING, P_SKILLED },
560.     { P_DART, P_EXPERT },
561.     { P_SHURIKEN, P_BASIC },
562.     { P_ATTACK_SPELL, P_EXPERT },
563.     { P_HEALING_SPELL, P_SKILLED },
564.     { P_DIVINATION_SPELL, P_EXPERT },
565.     { P_ENCHANTMENT_SPELL, P_SKILLED },
566.     { P_CLERIC_SPELL, P_SKILLED },
567.     { P_ESCAPE_SPELL, P_EXPERT },
568.     { P_MATTER_SPELL, P_EXPERT },
569.     { P_RIDING, P_BASIC },
570.     { P_BARE_HANDED_COMBAT, P_BASIC },
571.     { P_NONE, 0 }
572. };
573. 
574. staticfn void
575. knows_object(int obj, boolean override_pauper)
576. {
577.     if (u.uroleplay.pauper && !override_pauper)
578.         return;
579.     /* mark as known, but not yet encountered */
580.     discover_object(obj, TRUE, FALSE, FALSE);
581. }
582. 
583. /* Know ordinary (non-magical) objects of a certain class,
584.    like all gems except the loadstone and luckstone. */
585. staticfn void
586. knows_class(char sym)
587. {
588.     struct obj odummy, *o;
589.     int ct;
590. 
591.     if (u.uroleplay.pauper)
592.         return;
593. 
594.     odummy = cg.zeroobj;
595.     odummy.oclass = sym;
596.     o = &odummy; /* for use in various obj.h macros */
597. 
598.     /*
599.      * Note:  the exceptions here can be bypassed if necessary by
600.      *        calling knows_object() directly.  So an elven ranger,
601.      *        for example, knows all elven weapons despite the bow,
602.      *        arrow, and spear limitation below.
603.      */
604. 
605.     for (ct = svb.bases[(uchar) sym]; ct < svb.bases[(uchar) sym + 1]; ct++) {
606.         /* not flagged as magic but shouldn't be pre-discovered
607.            (small shields look the same as two types of magical shield;
608.            cornuthaum / dunce cap look the same as each other) */
609.         if (ct == CORNUTHAUM || ct == DUNCE_CAP || ct == SMALL_SHIELD)
610.             continue;
611.         if (sym == WEAPON_CLASS) {
612.             odummy.otyp = ct; /* update 'o' */
613.             /* arbitrary: only knights and samurai recognize polearms */
614.             if ((!Role_if(PM_KNIGHT) && !Role_if(PM_SAMURAI)) && is_pole(o))
615.                 continue;
616.             /* rangers know all launchers (bows, &c), ammo (arrows, &c),
617.                and spears regardless of race/species, but not other weapons */
618.             if (Role_if(PM_RANGER)
619.                 && (!is_launcher(o) && !is_ammo(o) && !is_spear(o)))
620.                 continue;
621.             /* rogues know daggers, regardless of racial variations */
622.             if (Role_if(PM_ROGUE) && (objects[o->otyp].oc_skill != P_DAGGER))
623.                 continue;
624.         }
625. 
626.         if (objects[ct].oc_class == sym && !objects[ct].oc_magic)
627.             knows_object(ct, FALSE);
628.     }
629. }
630. 
631. /* role-specific initializations, mostly inventory
632. 
633.    other things may be initialised here, but the function might run more than
634.    once, so any non-inventory initialisations should be nonrandom and
635.    idempotent (i.e. doing them twice is OK) */
636. staticfn void
637. u_init_role(void)
638. {
639.     int i;
640. 
641.     /* the program used to check moves<=1 && invent==NULL do decide whether
642.        a new game has started, but due to the 'pauper' option/conduct, can't
643.        rely on invent becoming non-Null anymore; instead, initialize moves
644.        to 0 instead of 1, then set it to 1 here, where invent init occurs */
645.     svm.moves = 1L;
646. 
647.     switch (Role_switch) {
648.     /* rn2(100) > 50 necessary for some choices because some
649.      * random number generators are bad enough to seriously
650.      * skew the results if we use rn2(2)...  --KAA
651.      */
652.     case PM_ARCHEOLOGIST:
653.         ini_inv(Archeologist);
654.         if (!rn2(10))
655.             ini_inv(Tinopener);
656.         else if (!rn2(4))
657.             ini_inv(Lamp);
658.         else if (!rn2(5))
659.             ini_inv(Magicmarker);
660.         knows_object(SACK, FALSE);
661.         knows_object(TOUCHSTONE, FALSE); /* FALSE: don't override pauper here,
662.                                           * but TOUCHSTONE will be made known
663.                                           * in pauper_reinit() */
664.         break;
665.     case PM_BARBARIAN:
666.         if (rn2(100) >= 50) { /* see above comment */
667.             ini_inv(Barbarian_0);
668.         } else {
669.             ini_inv(Barbarian_1);
670.         }
671.         if (!rn2(6))
672.             ini_inv(Lamp);
673.         knows_class(WEAPON_CLASS); /* excluding polearms */
674.         knows_class(ARMOR_CLASS);
675.         break;
676.     case PM_CAVE_DWELLER:
677.         ini_inv(Cave_man);
678.         break;
679.     case PM_HEALER:
680.         u.umoney0 = rn1(1000, 1001);
681.         ini_inv(Healer);
682.         if (!rn2(25))
683.             ini_inv(Lamp);
684.         knows_object(POT_FULL_HEALING, FALSE);
685.         break;
686.     case PM_KNIGHT:
687.         ini_inv(Knight);
688.         knows_class(WEAPON_CLASS); /* all weapons */
689.         knows_class(ARMOR_CLASS);
690.         /* give knights chess-like mobility--idea from wooledge@..cwru.edu */
691.         HJumping |= FROMOUTSIDE;
692.         break;
693.     case PM_MONK: {
694.         static const struct trobj *M_spell[] = {
695.             Healing_book, Protection_book, Confuse_monster_book
696.         };
697. 
698.         ini_inv(Monk);
699.         ini_inv(M_spell[rn2(90) / 30]); /* [0..2] */
700.         if (!rn2(4))
701.             ini_inv(Magicmarker);
702.         else if (!rn2(10))
703.             ini_inv(Lamp);
704.         knows_class(ARMOR_CLASS);
705.         /* sufficiently martial-arts oriented item to ignore language issue */
706.         knows_object(SHURIKEN, FALSE);
707.         break;
708.     }
709.     case PM_CLERIC: /* priest/priestess */
710.         ini_inv(Priest);
711.         if (!rn2(5))
712.             ini_inv(Magicmarker);
713.         else if (!rn2(10))
714.             ini_inv(Lamp);
715.         knows_object(POT_WATER, TRUE); /* override pauper */
716.         /* KMH, conduct --
717.          * Some may claim that this isn't agnostic, since they
718.          * are literally "priests" and they have holy water.
719.          * But we don't count it as such.  Purists can always
720.          * avoid playing priests and/or confirm another player's
721.          * role in their YAAP.
722.          */
723.         break;
724.     case PM_RANGER:
725.         ini_inv(Ranger);
726.         knows_class(WEAPON_CLASS); /* bows, arrows, spears only */
727.         break;
728.     case PM_ROGUE:
729.         u.umoney0 = 0;
730.         ini_inv(Rogue);
731.         if (!rn2(5))
732.             ini_inv(Blindfold);
733.         knows_object(SACK, FALSE); /* FALSE: don't override pauper here,
734.                                     * but sack will be made known in
735.                                     * pauper_reinit() */
736.         knows_class(WEAPON_CLASS); /* daggers only */
737.         break;
738.     case PM_SAMURAI:
739.         ini_inv(Samurai);
740.         if (!rn2(5))
741.             ini_inv(Blindfold);
742.         knows_class(WEAPON_CLASS); /* all weapons */
743.         knows_class(ARMOR_CLASS);
744.         /* in order to assist non-Japanese speakers, pre-discover items
745.            that switch to Japanese names when playing as a Samurai */
746.         for (i = MAXOCLASSES; i < NUM_OBJECTS; ++i) {
747.             if (objects[i].oc_magic) /* skip "magic koto" */
748.                 continue;
749.             if (Japanese_item_name(i, (const char *) 0))
750.                 /* we don't override pauper here because that would give
751.                    samarai an advantage of knowing several items in advance */
752.                 knows_object(i, FALSE);
753.         }
754.         break;
755.     case PM_TOURIST:
756.         u.umoney0 = rnd(1000);
757.         ini_inv(Tourist);
758.         if (!rn2(25))
759.             ini_inv(Tinopener);
760.         else if (!rn2(25))
761.             ini_inv(Leash);
762.         else if (!rn2(25))
763.             ini_inv(Towel);
764.         else if (!rn2(20))
765.             ini_inv(Magicmarker);
766.         break;
767.     case PM_VALKYRIE:
768.         ini_inv(Valkyrie);
769.         if (!rn2(6))
770.             ini_inv(Lamp);
771.         knows_class(WEAPON_CLASS); /* excludes polearms */
772.         knows_class(ARMOR_CLASS);
773.         break;
774.     case PM_WIZARD:
775.         ini_inv(Wizard);
776.         if (!rn2(5))
777.             ini_inv(Blindfold);
778.         break;
779. 
780.     default: /* impossible */
781.         break;
782.     }
783. 
784.     gn.nocreate = STRANGE_OBJECT;
785.     gn.nocreate2 = STRANGE_OBJECT;
786.     gn.nocreate3 = STRANGE_OBJECT;
787.     gn.nocreate4 = STRANGE_OBJECT;
788. }
789. 
790. /* race-specific initializations, same restrictions as u_init_role */
791. staticfn void
792. u_init_race(void)
793. {
794.     switch (Race_switch) {
795.     case PM_HUMAN:
796.         /* Nothing special */
797.         break;
798. 
799.     case PM_ELF:
800.         /*
801.          * Elves are people of music and song, or they are warriors.
802.          * Non-warriors get an instrument.  We use a kludge to
803.          * get only non-magic instruments.
804.          */
805.         if (Role_if(PM_CLERIC) || Role_if(PM_WIZARD)) {
806.             static const int trotyp[] =
807.                 { WOODEN_FLUTE, TOOLED_HORN, WOODEN_HARP,
808.                   BELL,         BUGLE,       LEATHER_DRUM };
809.             const struct trobj Instrument[] =
810.                 { { ROLL_FROM(trotyp), 0, TOOL_CLASS, 1, 1, 0 },
811.                   { 0, 0, 0, 0, 0, 0 } };
812.             ini_inv(Instrument);
813.         }
814. 
815.         /* Elves can recognize all elvish objects */
816.         knows_object(ELVEN_SHORT_SWORD, FALSE);
817.         knows_object(ELVEN_ARROW, FALSE);
818.         knows_object(ELVEN_BOW, FALSE);
819.         knows_object(ELVEN_SPEAR, FALSE);
820.         knows_object(ELVEN_DAGGER, FALSE);
821.         knows_object(ELVEN_BROADSWORD, FALSE);
822.         knows_object(ELVEN_MITHRIL_COAT, FALSE);
823.         knows_object(ELVEN_LEATHER_HELM, FALSE);
824.         knows_object(ELVEN_SHIELD, FALSE);
825.         knows_object(ELVEN_BOOTS, FALSE);
826.         knows_object(ELVEN_CLOAK, FALSE);
827.         break;
828. 
829.     case PM_DWARF:
830.         /* Dwarves can recognize all dwarvish objects */
831.         knows_object(DWARVISH_SPEAR, FALSE);
832.         knows_object(DWARVISH_SHORT_SWORD, FALSE);
833.         knows_object(DWARVISH_MATTOCK, FALSE);
834.         knows_object(DWARVISH_IRON_HELM, FALSE);
835.         knows_object(DWARVISH_MITHRIL_COAT, FALSE);
836.         knows_object(DWARVISH_CLOAK, FALSE);
837.         knows_object(DWARVISH_ROUNDSHIELD, FALSE);
838.         break;
839. 
840.     case PM_GNOME:
841.         break;
842. 
843.     case PM_ORC:
844.         /* compensate for generally inferior equipment */
845.         if (!Role_if(PM_WIZARD))
846.             ini_inv(Xtra_food);
847.         /* Orcs can recognize all orcish objects */
848.         knows_object(ORCISH_SHORT_SWORD, FALSE);
849.         knows_object(ORCISH_ARROW, FALSE);
850.         knows_object(ORCISH_BOW, FALSE);
851.         knows_object(ORCISH_SPEAR, FALSE);
852.         knows_object(ORCISH_DAGGER, FALSE);
853.         knows_object(ORCISH_CHAIN_MAIL, FALSE);
854.         knows_object(ORCISH_RING_MAIL, FALSE);
855.         knows_object(ORCISH_HELM, FALSE);
856.         knows_object(ORCISH_SHIELD, FALSE);
857.         knows_object(URUK_HAI_SHIELD, FALSE);
858.         knows_object(ORCISH_CLOAK, FALSE);
859.         break;
860. 
861.     default: /* impossible */
862.         break;
863.     }
864. }
865. 
866. /* for 'pauper' aka 'unprepared'; take away any skills (bare-handed combat,
867.    riding) that are better than unskilled; learn the book (without carrying
868.    it or knowing its spell yet) for some key spells */
869. staticfn void
870. pauper_reinit(void)
871. {
872.     int skill, preknown = STRANGE_OBJECT;
873. 
874.     if (!u.uroleplay.pauper)
875.         return;
876. 
877.     for (skill = 0; skill < P_NUM_SKILLS; skill++)
878.         if (P_SKILL(skill) > P_UNSKILLED) {
879.             P_SKILL(skill) = P_UNSKILLED;
880.             P_ADVANCE(skill) = 0;
881.         }
882.     /* pauper has lost out on initial skills, but provide some unspent skill
883.        credits to make up for that */
884.     u.weapon_slots = 2;
885. 
886.     /* paupers don't know any spells yet, but several roles will recognize
887.        the spellbook for a key spell (not necessarily that role's special
888.        spell); "supply chests" on the first few levels provide a fairly
889.        high chance to find the book; some other roles know a non-book item */
890.     switch (Role_switch) {
891.     case PM_HEALER:
892.         preknown = SPE_HEALING;
893.         break;
894.     case PM_CLERIC:
895.     case PM_KNIGHT:
896.     case PM_MONK:
897.         preknown = SPE_PROTECTION;
898.         break;
899.     case PM_WIZARD:
900.         preknown = SPE_FORCE_BOLT;
901.         break;
902.     case PM_ARCHEOLOGIST:
903.         preknown = TOUCHSTONE;
904.         break;
905.     case PM_CAVE_DWELLER:
906.         preknown = FLINT;
907.         break;
908.     case PM_ROGUE:
909.     case PM_TOURIST:
910.         preknown = SACK;
911.         break;
912.     case PM_SAMURAI:
913.         /* food ration isn't interesting to discover, but put "gunyoki" into
914.            discoveries list for players who might not recognize what it is */
915.         preknown = FOOD_RATION;
916.         break;
917.     default:
918.     case PM_BARBARIAN:
919.     case PM_RANGER:
920.     case PM_VALKYRIE:
921.         break;
922.     }
923.     if (preknown != STRANGE_OBJECT)
924.         knows_object(preknown, TRUE);
925. }
926. 
927. /* boost STR and CON until hero can carry inventory */
928. staticfn void
929. u_init_carry_attr_boost(void)
930. {
931.     /* make sure you can carry all you have - especially for Tourists */
932.     while (inv_weight() > 0) {
933.         if (adjattrib(A_STR, 1, TRUE))
934.             continue;
935.         if (adjattrib(A_CON, 1, TRUE))
936.             continue;
937.         /* only get here when didn't boost strength or constitution */
938.         break;
939.     }
940. }
941. 
942. /* initialise u, except inventory, attributes, skills and discoveries */
943. void
944. u_init_misc(void)
945. {
946.     int i;
947.     struct u_roleplay tmpuroleplay = u.uroleplay; /* set by rcfile options */
948. 
949.     flags.female = flags.initgend;
950.     flags.beginner = TRUE;
951. 
952.     /* zero u, including pointer values --
953.      * necessary when aborting from a failed restore */
954.     (void) memset((genericptr_t) &u, 0, sizeof(u));
955.     u.ustuck = (struct monst *) 0;
956.     (void) memset((genericptr_t) &ubirthday, 0, sizeof(ubirthday));
957.     (void) memset((genericptr_t) &urealtime, 0, sizeof(urealtime));
958. 
959.     u.uroleplay = tmpuroleplay; /* restore options set via rcfile */
960. 
961. #if 0  /* documentation of more zero values as desirable */
962.     u.usick_cause[0] = 0;
963.     u.uluck  = u.moreluck = 0;
964.     uarmu = 0;
965.     uarm = uarmc = uarmh = uarms = uarmg = uarmf = 0;
966.     uwep = uball = uchain = uleft = uright = 0;
967.     uswapwep = uquiver = 0;
968.     u.twoweap = FALSE; /* bypass set_twoweap() */
969.     u.ublessed = 0;                     /* not worthy yet */
970.     u.ugangr   = 0;                     /* gods not angry */
971.     u.ugifts   = 0;                     /* no divine gifts bestowed */
972.     u.uevent.uhand_of_elbereth = 0;
973.     u.uevent.uheard_tune = 0;
974.     u.uevent.uopened_dbridge = 0;
975.     u.uevent.udemigod = 0;              /* not a demi-god yet... */
976.     u.uevent.amulet_wish = 0;
977.     u.udg_cnt = 0;
978.     u.mh = u.mhmax = u.mtimedone = 0;
979.     u.uz.dnum = u.uz0.dnum = 0;
980.     u.utotype = UTOTYPE_NONE;
981. #endif /* 0 */
982. 
983.     u.uz.dlevel = 1;
984.     u.uz0.dlevel = 0;
985.     u.utolev = u.uz;
986. 
987.     u.umoved = FALSE;
988.     u.umortality = 0;
989.     u.ugrave_arise = NON_PM;
990. 
991.     u.umonnum = u.umonster = gu.urole.mnum;
992.     u.ulycn = NON_PM;
993.     set_uasmon();
994. 
995.     u.ulevel = 0; /* set up some of the initial attributes */
996.     u.uhp = u.uhpmax = u.uhppeak = newhp();
997.     u.uen = u.uenmax = u.uenpeak = newpw();
998.     u.uspellprot = 0;
999.     adjabil(0, 1);
1000.     u.ulevel = u.ulevelmax = 1;
1001. 
1002.     init_uhunger();
1003.     for (i = 0; i <= MAXSPELL; i++)
1004.         svs.spl_book[i].sp_id = NO_SPELL;
1005.     u.ublesscnt = 300; /* no prayers just yet */
1006.     u.ualignbase[A_CURRENT] = u.ualignbase[A_ORIGINAL] = u.ualign.type =
1007.         aligns[flags.initalign].value;
1008. 
1009. #if defined(BSD) && !defined(POSIX_TYPES)
1010.     (void) time((long *) &ubirthday);
1011. #else
1012.     (void) time(&ubirthday);
1013. #endif
1014. 
1015.     /*
1016.      *  For now, everyone starts out with a night vision range of 1 and
1017.      *  their xray_range disabled.
1018.      */
1019.     u.nv_range = 1;
1020.     u.xray_range = -1;
1021.     u.unblind_telepat_range = -1;
1022. 
1023.     /* OPTIONS:blind results in permanent blindness (unless overridden
1024.        by the Eyes of the Overworld, which will clear 'u.uroleplay.blind'
1025.        to void the conduct, but will leave the PermaBlind bit set so that
1026.        blindness resumes when the Eyes are removed). */
1027.     if (u.uroleplay.blind)
1028.         HBlinded |= FROMOUTSIDE; /* set PermaBlind */
1029. 
1030.     /* roughly based on distribution in human population */
1031.     u.uhandedness = rn2(10) ? RIGHT_HANDED : LEFT_HANDED;
1032. 
1033.     max_rank_sz(); /* set max str size for class ranks */
1034. 
1035.     return;
1036. }
1037. 
1038. /* the appropriate set of skills for the role */
1039. staticfn const struct def_skill *
1040. skills_for_role(void)
1041. {
1042.     const struct def_skill *skills;
1043. 
1044.     switch (Role_switch) {
1045.     case PM_ARCHEOLOGIST:
1046.         skills = Skill_A;
1047.         break;
1048.     case PM_BARBARIAN:
1049.         skills = Skill_B;
1050.         break;
1051.     case PM_CAVE_DWELLER:
1052.         skills = Skill_C;
1053.         break;
1054.     case PM_HEALER:
1055.         skills = Skill_H;
1056.         break;
1057.     case PM_KNIGHT:
1058.         skills = Skill_K;
1059.         break;
1060.     case PM_MONK:
1061.         skills = Skill_Mon;
1062.         break;
1063.     case PM_CLERIC:
1064.         skills = Skill_P;
1065.         break;
1066.     case PM_RANGER:
1067.         skills = Skill_Ran;
1068.         break;
1069.     case PM_ROGUE:
1070.         skills = Skill_R;
1071.         break;
1072.     case PM_SAMURAI:
1073.         skills = Skill_S;
1074.         break;
1075.     case PM_TOURIST:
1076.         skills = Skill_T;
1077.         break;
1078.     case PM_VALKYRIE:
1079.         skills = Skill_V;
1080.         break;
1081.     case PM_WIZARD:
1082.         skills = Skill_W;
1083.         break;
1084.     default:
1085.         panic("No skills found for role");
1086.         break;
1087.     }
1088. 
1089.     return skills;
1090. }
1091. 
1092. /* skills aren't initialized, so we use the role-specific skill lists */
1093. staticfn boolean
1094. restricted_spell_discipline(int otyp)
1095. {
1096.     const struct def_skill *skills = skills_for_role();
1097.     int this_skill = spell_skilltype(otyp);
1098. 
1099.     while (skills && skills->skill != P_NONE) {
1100.         if (skills->skill == this_skill)
1101.             return FALSE;
1102.         ++skills;
1103.     }
1104.     return TRUE;
1105. }
1106. 
1107. /* randomizes the quantity given a trobj description */
1108. staticfn long
1109. trquan(const struct trobj *trop)
1110. {
1111.     if (!trop->trquan_min)
1112.         return 1;
1113.     return trop->trquan_min + rn2(trop->trquan_max - trop->trquan_min + 1);
1114. }
1115. 
1116. /* create random object of certain class, filtering out too powerful items */
1117. staticfn struct obj *
1118. ini_inv_mkobj_filter(int oclass, boolean got_level1_spellbook)
1119. {
1120.     struct obj *obj;
1121.     int otyp, trycnt = 0;
1122. 
1123.     /*
1124.      * For random objects, do not create certain overly powerful
1125.      * items: wand of wishing, ring of levitation, or the
1126.      * polymorph/polymorph control combination.  Specific objects,
1127.      * i.e. the discovery wishing, are still OK.
1128.      * Also, don't get a couple of really useless items.  (Note:
1129.      * punishment isn't "useless".  Some players who start out with
1130.      * one will immediately read it and use the iron ball as a
1131.      * weapon.)
1132.      */
1133.     obj = mkobj(oclass, FALSE);
1134.     otyp = obj->otyp;
1135. 
1136.     while (otyp == WAN_WISHING || otyp == gn.nocreate
1137.            || otyp == gn.nocreate2 || otyp == gn.nocreate3
1138.            || otyp == gn.nocreate4 || otyp == RIN_LEVITATION
1139.            /* 'useless' items */
1140.            || otyp == POT_HALLUCINATION
1141.            || otyp == POT_ACID
1142.            || otyp == SCR_AMNESIA
1143.            || otyp == SCR_FIRE
1144.            || otyp == SCR_BLANK_PAPER
1145.            || otyp == SPE_BLANK_PAPER
1146.            || otyp == RIN_AGGRAVATE_MONSTER
1147.            || otyp == RIN_HUNGER
1148.            || otyp == WAN_NOTHING
1149.            /* orcs start with poison resistance */
1150.            || (otyp == RIN_POISON_RESISTANCE && Race_if(PM_ORC))
1151.            /* Monks don't use weapons */
1152.            || (otyp == SCR_ENCHANT_WEAPON && Role_if(PM_MONK))
1153.            /* wizard patch -- they already have one */
1154.            || (otyp == SPE_FORCE_BOLT && Role_if(PM_WIZARD))
1155.            /* powerful spells are either useless to
1156.               low level players or unbalancing; also
1157.               spells in restricted skill categories */
1158.            || (obj->oclass == SPBOOK_CLASS
1159.                && (objects[otyp].oc_level > (got_level1_spellbook ? 3 : 1)
1160.                    || restricted_spell_discipline(otyp)))
1161.            || otyp == SPE_NOVEL) {
1162.         dealloc_obj(obj);
1163.         if (++trycnt > 1000) {
1164.             /* This lonely pancake's potential will never be realized.
1165.              * It will exist only as a thought, of something that could have
1166.              * been, but never will be. It will never experience maple syrup
1167.              * oozing into its nooks, or see the delightful expression on
1168.              * someone's face as they are about to let it dance across their
1169.              * taste buds. */
1170.             obj = mksobj(PANCAKE, TRUE, FALSE);
1171.             break;
1172.         }
1173.         obj = mkobj(oclass, FALSE);
1174.         otyp = obj->otyp;
1175.     }
1176.     return obj;
1177. }
1178. 
1179. /* substitute object with something else based on race.
1180.    only changes otyp, and returns it. */
1181. staticfn short
1182. ini_inv_obj_substitution(const struct trobj *trop, struct obj *obj)
1183. {
1184.     if (gu.urace.mnum != PM_HUMAN) {
1185.         int i;
1186. 
1187.         /* substitute race-specific items; this used to be in
1188.            the 'if (otyp != UNDEF_TYP) { }' block above, but then
1189.            substitutions didn't occur for randomly generated items
1190.            (particularly food) which have racial substitutes */
1191.         for (i = 0; inv_subs[i].race_pm != NON_PM; ++i)
1192.             if (inv_subs[i].race_pm == gu.urace.mnum
1193.                 && obj->otyp == inv_subs[i].item_otyp) {
1194.                 debugpline3("ini_inv: substituting %s for %s%s",
1195.                             OBJ_NAME(objects[inv_subs[i].subs_otyp]),
1196.                             (trop->trotyp == UNDEF_TYP) ? "random " : "",
1197.                             OBJ_NAME(objects[obj->otyp]));
1198.                 obj->otyp = inv_subs[i].subs_otyp;
1199.                 break;
1200.             }
1201.     }
1202.     return obj->otyp;
1203. }
1204. 
1205. /* returns: TRUE to stop generating items from this trobj,
1206.    FALSE for normal behaviour */
1207. staticfn boolean
1208. ini_inv_adjust_obj(const struct trobj *trop, struct obj *obj)
1209. {
1210.     boolean stop = FALSE;
1211.     if (trop->trclass == COIN_CLASS) {
1212.         /* no "blessed" or "identified" money */
1213.         obj->quan = u.umoney0;
1214.     } else {
1215.         if (objects[obj->otyp].oc_uses_known)
1216.             obj->known = 1;
1217.         /* not observe_object during startup, that's handled later */
1218.         obj->dknown = obj->bknown = obj->rknown = 1;
1219.         if (Is_container(obj) || obj->otyp == STATUE) {
1220.             obj->cknown = obj->lknown = 1;
1221.             obj->otrapped = 0;
1222.         }
1223.         obj->cursed = 0;
1224.         if (obj->opoisoned && u.ualign.type != A_CHAOTIC)
1225.             obj->opoisoned = 0;
1226.         if (obj->oclass == WEAPON_CLASS || obj->oclass == TOOL_CLASS) {
1227.             obj->quan = trquan(trop);
1228.             stop = TRUE;
1229.         } else if (obj->oclass == GEM_CLASS && is_graystone(obj)
1230.                    && obj->otyp != FLINT) {
1231.             obj->quan = 1L;
1232.         }
1233.         if (trop->trspe != UNDEF_SPE) {
1234.             obj->spe = trop->trspe;
1235.             if (trop->trotyp == MAGIC_MARKER && obj->spe < 96)
1236.                 obj->spe += rn2(4);
1237.         } else {
1238.             /* Don't start with +0 or negative rings */
1239.             if (objects[obj->otyp].oc_class == RING_CLASS
1240.                 && objects[obj->otyp].oc_charged && obj->spe <= 0)
1241.                 obj->spe = rne(3);
1242.         }
1243.         if (trop->trbless != UNDEF_BLESS)
1244.             obj->blessed = trop->trbless;
1245. 
1246.     }
1247.     /* defined after setting otyp+quan + blessedness */
1248.     obj->owt = weight(obj);
1249.     return stop;
1250. }
1251. 
1252. /* initial inventory: wear, wield, learn the spell/obj */
1253. staticfn void
1254. ini_inv_use_obj(struct obj *obj)
1255. {
1256.     /* Make the type known if necessary */
1257.     if (OBJ_DESCR(objects[obj->otyp]) && obj->known)
1258.         discover_object(obj->otyp, TRUE, TRUE, FALSE);
1259.     if (obj->otyp == OIL_LAMP)
1260.         discover_object(POT_OIL, TRUE, TRUE, FALSE);
1261. 
1262.     if (obj->oclass == ARMOR_CLASS) {
1263.         if (is_shield(obj) && !uarms && !(uwep && bimanual(uwep))) {
1264.             /* Prior to 3.6.2 this used to unset uswapwep if it was set,
1265.                but wearing a shield doesn't prevent having an alternate
1266.                weapon ready to swap with the primary; just make sure we
1267.                aren't two-weaponing (academic; no one starts that way) */
1268.             set_twoweap(FALSE); /* u.twoweap = FALSE */
1269.             setworn(obj, W_ARMS);
1270.         } else if (is_helmet(obj) && !uarmh)
1271.             setworn(obj, W_ARMH);
1272.         else if (is_gloves(obj) && !uarmg)
1273.             setworn(obj, W_ARMG);
1274.         else if (is_shirt(obj) && !uarmu)
1275.             setworn(obj, W_ARMU);
1276.         else if (is_cloak(obj) && !uarmc)
1277.             setworn(obj, W_ARMC);
1278.         else if (is_boots(obj) && !uarmf)
1279.             setworn(obj, W_ARMF);
1280.         else if (is_suit(obj) && !uarm)
1281.             setworn(obj, W_ARM);
1282.     }
1283. 
1284.     if (obj->oclass == WEAPON_CLASS || is_weptool(obj)
1285.         || obj->otyp == TIN_OPENER
1286.         || obj->otyp == FLINT || obj->otyp == ROCK) {
1287.         if (is_ammo(obj) || is_missile(obj)) {
1288.             if (!uquiver)
1289.                 setuqwep(obj);
1290.         } else if (!uwep && (!uarms || !bimanual(obj))) {
1291.             setuwep(obj);
1292.         } else if (!uswapwep) {
1293.             setuswapwep(obj);
1294.         }
1295.     }
1296.     if (obj->oclass == SPBOOK_CLASS && obj->otyp != SPE_BLANK_PAPER)
1297.         initialspell(obj);
1298. }
1299. 
1300. staticfn void
1301. ini_inv(const struct trobj *trop)
1302. {
1303.     struct obj *obj;
1304.     int otyp;
1305.     boolean got_sp1 = FALSE; /* got a level 1 spellbook? */
1306.     long quan;
1307. 
1308.     if (u.uroleplay.pauper) /* pauper gets no items */
1309.         return;
1310. 
1311.     quan = trquan(trop);
1312.     while (trop->trclass) {
1313.         otyp = (int) trop->trotyp;
1314.         if (otyp != UNDEF_TYP) {
1315.             obj = mksobj(otyp, TRUE, FALSE);
1316.         } else { /* UNDEF_TYP */
1317.             obj = ini_inv_mkobj_filter(trop->trclass, got_sp1);
1318.             otyp = obj->otyp;
1319.             /* Heavily relies on the facts that 1) we create wands
1320.              * before rings, that 2) we create rings before
1321.              * spellbooks, and that 3) not more than 1 object of a
1322.              * particular symbol is to be prohibited.  (For more
1323.              * objects, we need more nocreate variables...)
1324.              */
1325.             switch (otyp) {
1326.             case WAN_POLYMORPH:
1327.             case RIN_POLYMORPH:
1328.             case POT_POLYMORPH:
1329.                 gn.nocreate = RIN_POLYMORPH_CONTROL;
1330.                 break;
1331.             case RIN_POLYMORPH_CONTROL:
1332.                 gn.nocreate = RIN_POLYMORPH;
1333.                 gn.nocreate2 = SPE_POLYMORPH;
1334.                 gn.nocreate3 = POT_POLYMORPH;
1335.             }
1336.             /* Don't have 2 of the same ring or spellbook */
1337.             if (obj->oclass == RING_CLASS || obj->oclass == SPBOOK_CLASS)
1338.                 gn.nocreate4 = otyp;
1339.         }
1340.         /* Put post-creation object adjustments that don't depend on whether
1341.          * it was UNDEF_TYP or not after this. */
1342. 
1343.         otyp = ini_inv_obj_substitution(trop, obj);
1344.         nhUse(otyp);
1345. 
1346.         /* nudist gets no armor */
1347.         if (u.uroleplay.nudist && obj->oclass == ARMOR_CLASS) {
1348.             dealloc_obj(obj);
1349.             trop++;
1350.             continue;
1351.         }
1352. 
1353.         if (ini_inv_adjust_obj(trop, obj))
1354.             quan = 1;
1355.         obj = addinv(obj);
1356. 
1357.         /* First spellbook should be level 1 - did we get it? */
1358.         if (obj->oclass == SPBOOK_CLASS && objects[obj->otyp].oc_level == 1)
1359.             got_sp1 = TRUE;
1360. 
1361.         if (--quan)
1362.             continue; /* make a similar object */
1363.         trop++;
1364.         quan = trquan(trop);
1365.     }
1366. }
1367. 
1368. /* initialise starting inventory and attributes
1369. 
1370.    this function can be run multiple times and will overwrite the effects of
1371.    previous runs */
1372. void
1373. u_init_inventory_attrs(void)
1374. {
1375.     gl.lastinvnr = 51;
1376.     while (gi.invent)
1377.         useupall(gi.invent);
1378. 
1379.     u.umoney0 = 0;
1380.     u_init_role();
1381.     u_init_race();
1382. 
1383.     if (discover)
1384.         ini_inv(Wishing);
1385. 
1386.     if (u.umoney0)
1387.         ini_inv(Money);
1388.     u.umoney0 += hidden_gold(TRUE); /* in case sack has gold in it */
1389. 
1390.     init_attr(75);    /* init attribute values */
1391.     vary_init_attr(); /* minor variation to attrs */
1392.     u_init_carry_attr_boost();
1393. }
1394. 
1395. /* side effects of starting inventory (e.g. discovering it) and skills (both
1396.    those based on role and those based on starting inventory) */
1397. void
1398. u_init_skills_discoveries(void)
1399. {
1400.     struct obj *otmp;
1401.     for (otmp = gi.invent; otmp; otmp = otmp->nobj)
1402.         ini_inv_use_obj(otmp);
1403. 
1404.     skill_init(skills_for_role());
1405.     if (u.uroleplay.pauper)
1406.         pauper_reinit();
1407. 
1408.     /* If we have at least one spell, force starting Pw to be enough,
1409.        so hero can cast the level 1 spell they should have */
1410.     if (num_spells() && (u.uenmax < SPELL_LEV_PW(1)))
1411.         u.uen = u.uenmax = u.uenpeak = u.ueninc[u.ulevel] = SPELL_LEV_PW(1);
1412. 
1413.     find_ac();     /* get initial ac value */
1414. }
1415. 
1416. #undef UNDEF_TYP
1417. #undef UNDEF_SPE
1418. #undef UNDEF_BLESS
1419. 
1420. /*u_init.c*/