2021bfd4438b148608a1f5ae983fca686b82a895
[crawl.git] / crawl-ref / source / makeitem.cc
1 /**
2  * @file
3  * @brief Item creation routines.
4 **/
5
6 #include "AppHdr.h"
7
8 #include <algorithm>
9
10 #include "enum.h"
11 #include "externs.h"
12 #include "makeitem.h"
13 #include "message.h"
14
15 #include "artefact.h"
16 #include "colour.h"
17 #include "coord.h"
18 #include "decks.h"
19 #include "describe.h"
20 #include "dungeon.h"
21 #include "env.h"
22 #include "food.h"
23 #include "itemname.h"
24 #include "itemprop.h"
25 #include "items.h"
26 #include "libutil.h"
27 #include "misc.h"
28 #include "mon-util.h"
29 #include "player.h"
30 #include "random.h"
31 #include "spl-book.h"
32 #include "state.h"
33 #include "stuff.h"
34 #include "travel.h"
35
36 static armour_type _get_random_armour_type(int item_level);
37
38 int create_item_named(string name, coord_def p, string *error)
39 {
40     trim_string(name);
41
42     item_list ilist;
43     const string err = ilist.add_item(name, false);
44     if (!err.empty())
45     {
46         if (error)
47             *error = err;
48         return NON_ITEM;
49     }
50
51     item_spec ispec = ilist.get_item(0);
52     int item = dgn_place_item(ispec, you.pos());
53     if (item != NON_ITEM)
54         link_items();
55     else if (error)
56         *error = "Failed to create item '" + name + "'";
57
58     return item;
59 }
60
61 bool got_curare_roll(const int item_level)
62 {
63     return one_chance_in(item_level > 27 ? 6   :
64                          item_level < 2  ? 15  :
65                          (364 - 7 * item_level) / 25);
66 }
67
68 static bool _got_distortion_roll(const int item_level)
69 {
70     return one_chance_in(25);
71 }
72
73 static int _exciting_colour()
74 {
75     switch (random2(3))
76     {
77         case 0:  return YELLOW;
78         case 1:  return LIGHTGREEN;
79         case 2:  return LIGHTRED;
80         default: return LIGHTMAGENTA;
81     }
82 }
83
84 static int _weapon_colour(const item_def &item)
85 {
86     int item_colour = BLACK;
87     // fixed artefacts get predefined colours
88
89     string itname = item.name(DESC_PLAIN);
90     lowercase(itname);
91
92     if (is_artefact(item))
93         return _exciting_colour();
94
95     if (is_demonic(item))
96         return LIGHTRED;
97
98     if (is_range_weapon(item))
99     {
100         switch (range_skill(item))
101         {
102         case SK_BOWS:
103             item_colour = BLUE;
104             break;
105         case SK_CROSSBOWS:
106             item_colour = LIGHTBLUE;
107             break;
108         case SK_THROWING:
109             item_colour = WHITE;
110             break;
111         case SK_SLINGS:
112             item_colour = BROWN;
113             break;
114         default:
115             // huh?
116             item_colour = LIGHTGREEN;
117             break;
118         }
119     }
120     else
121     {
122         switch (weapon_skill(item))
123         {
124         case SK_SHORT_BLADES:
125             item_colour = CYAN;
126             break;
127         case SK_LONG_BLADES:
128             item_colour = LIGHTCYAN;
129             break;
130         case SK_AXES:
131             item_colour = MAGENTA;
132             break;
133         case SK_MACES_FLAILS:
134             item_colour = LIGHTGREY;
135             break;
136         case SK_POLEARMS:
137             item_colour = RED;
138             break;
139         case SK_STAVES:
140             item_colour = GREEN;
141             break;
142         default:
143             // huh?
144             item_colour = LIGHTGREEN;
145             break;
146         }
147     }
148
149     return item_colour;
150 }
151
152 static int _missile_colour(const item_def &item)
153 {
154     int item_colour = BLACK;
155     switch (item.sub_type)
156     {
157     case MI_STONE:
158     case MI_SLING_BULLET:
159         item_colour = BROWN;
160         break;
161     case MI_LARGE_ROCK:
162         item_colour = YELLOW;
163         break;
164     case MI_ARROW:
165         item_colour = BLUE;
166         break;
167     case MI_NEEDLE:
168         item_colour = WHITE;
169         break;
170     case MI_BOLT:
171         item_colour = LIGHTBLUE;
172         break;
173     case MI_DART:
174         item_colour = CYAN;
175         break;
176     case MI_JAVELIN:
177         item_colour = RED;
178         break;
179     case MI_THROWING_NET:
180         item_colour = MAGENTA;
181         break;
182     case MI_TOMAHAWK:
183         item_colour = GREEN;
184         break;
185     case NUM_SPECIAL_MISSILES:
186     case NUM_REAL_SPECIAL_MISSILES:
187         die("invalid missile type");
188     }
189     return item_colour;
190 }
191
192 static int _armour_colour(const item_def &item)
193 {
194     int item_colour = BLACK;
195     string itname = item.name(DESC_PLAIN);
196     lowercase(itname);
197
198     switch (item.sub_type)
199     {
200     case ARM_CLOAK:
201         item_colour = WHITE;
202         break;
203     case ARM_NAGA_BARDING:
204     case ARM_CENTAUR_BARDING:
205         item_colour = GREEN;
206         break;
207     case ARM_ROBE:
208         item_colour = RED;
209         break;
210 #if TAG_MAJOR_VERSION == 34
211     case ARM_CAP:
212 #endif
213     case ARM_HAT:
214     case ARM_HELMET:
215         item_colour = MAGENTA;
216         break;
217     case ARM_BOOTS:
218         item_colour = BLUE;
219         break;
220     case ARM_GLOVES:
221         item_colour = LIGHTBLUE;
222         break;
223     case ARM_LEATHER_ARMOUR:
224         item_colour = BROWN;
225         break;
226     case ARM_ANIMAL_SKIN:
227         item_colour = LIGHTGREY;
228         break;
229     case ARM_CRYSTAL_PLATE_ARMOUR:
230         item_colour = WHITE;
231         break;
232     case ARM_SHIELD:
233     case ARM_LARGE_SHIELD:
234     case ARM_BUCKLER:
235         item_colour = CYAN;
236         break;
237     default:
238         item_colour = LIGHTCYAN;
239         break;
240     }
241
242     return item_colour;
243 }
244
245 void item_colour(item_def &item)
246 {
247     if (is_unrandom_artefact(item) && !is_randapp_artefact(item))
248         return; // unrandarts have already been coloured
249
250     int switchnum = 0;
251     colour_t temp_value;
252
253     switch (item.base_type)
254     {
255     case OBJ_WEAPONS:
256         item.colour = _weapon_colour(item);
257         break;
258
259     case OBJ_MISSILES:
260         item.colour = _missile_colour(item);
261         break;
262
263     case OBJ_ARMOUR:
264         if (is_artefact(item))
265         {
266             item.colour = _exciting_colour();
267             return;
268         }
269
270         switch (item.sub_type)
271         {
272         case ARM_FIRE_DRAGON_HIDE:
273         case ARM_FIRE_DRAGON_ARMOUR:
274             item.colour = mons_class_colour(MONS_FIRE_DRAGON);
275             break;
276         case ARM_TROLL_HIDE:
277         case ARM_TROLL_LEATHER_ARMOUR:
278             item.colour = mons_class_colour(MONS_TROLL);
279             break;
280         case ARM_ICE_DRAGON_HIDE:
281         case ARM_ICE_DRAGON_ARMOUR:
282             item.colour = mons_class_colour(MONS_ICE_DRAGON);
283             break;
284         case ARM_STEAM_DRAGON_HIDE:
285         case ARM_STEAM_DRAGON_ARMOUR:
286             item.colour = mons_class_colour(MONS_STEAM_DRAGON);
287             break;
288         case ARM_MOTTLED_DRAGON_HIDE:
289         case ARM_MOTTLED_DRAGON_ARMOUR:
290             item.colour = mons_class_colour(MONS_MOTTLED_DRAGON);
291             break;
292         case ARM_STORM_DRAGON_HIDE:
293         case ARM_STORM_DRAGON_ARMOUR:
294             item.colour = mons_class_colour(MONS_STORM_DRAGON);
295             break;
296         case ARM_GOLD_DRAGON_HIDE:
297         case ARM_GOLD_DRAGON_ARMOUR:
298             item.colour = mons_class_colour(MONS_GOLDEN_DRAGON);
299             break;
300         case ARM_SWAMP_DRAGON_HIDE:
301         case ARM_SWAMP_DRAGON_ARMOUR:
302             item.colour = mons_class_colour(MONS_SWAMP_DRAGON);
303             break;
304         case ARM_PEARL_DRAGON_HIDE:
305         case ARM_PEARL_DRAGON_ARMOUR:
306             item.colour = mons_class_colour(MONS_PEARL_DRAGON);
307             break;
308         default:
309             item.colour = _armour_colour(item);
310             break;
311         }
312         break;
313
314     case OBJ_WANDS:
315         item.special = you.item_description[IDESC_WANDS][item.sub_type];
316
317         switch (item.special % NDSC_WAND_PRI)
318         {
319         case 0:         //"iron wand"
320             item.colour = CYAN;
321             break;
322         case 1:         //"brass wand"
323         case 5:         //"gold wand"
324             item.colour = YELLOW;
325             break;
326         case 2:         //"bone wand"
327         case 8:         //"ivory wand"
328         case 9:         //"glass wand"
329         case 10:        //"lead wand"
330         default:
331             item.colour = LIGHTGREY;
332             break;
333         case 3:         //"wooden wand"
334         case 4:         //"copper wand"
335         case 7:         //"bronze wand"
336             item.colour = BROWN;
337             break;
338         case 6:         //"silver wand"
339             item.colour = WHITE;
340             break;
341         case 11:        //"fluorescent wand"
342             item.colour = LIGHTGREEN;
343             break;
344         }
345
346         break;
347
348     case OBJ_POTIONS:
349         item.plus = you.item_description[IDESC_POTIONS][item.sub_type];
350
351         switch (item.plus % NDSC_POT_PRI)
352         {
353         case 0:         //"clear potion"
354         case 2:         //"black potion"
355         default:
356             item.colour = LIGHTGREY;
357             break;
358         case 1:         //"blue potion"
359         case 7:         //"inky potion"
360             item.colour = BLUE;
361             break;
362         case 3:         //"silvery potion"
363         case 13:        //"white potion"
364             item.colour = WHITE;
365             break;
366         case 4:         //"cyan potion"
367             item.colour = CYAN;
368             break;
369         case 5:         //"purple potion"
370             item.colour = MAGENTA;
371             break;
372         case 6:         //"orange potion"
373             item.colour = LIGHTRED;
374             break;
375         case 8:         //"red potion"
376             item.colour = RED;
377             break;
378         case 9:         //"yellow potion"
379             item.colour = YELLOW;
380             break;
381         case 10:        //"green potion"
382             item.colour = GREEN;
383             break;
384         case 11:        //"brown potion"
385             item.colour = BROWN;
386             break;
387         case 12:        //"pink potion"
388             item.colour = LIGHTMAGENTA;
389             break;
390         }
391         break;
392
393     case OBJ_FOOD:
394         switch (item.sub_type)
395         {
396         case FOOD_BEEF_JERKY:
397         case FOOD_BREAD_RATION:
398         case FOOD_LYCHEE:
399         case FOOD_MEAT_RATION:
400         case FOOD_RAMBUTAN:
401         case FOOD_SAUSAGE:
402         case FOOD_SULTANA:
403             item.colour = BROWN;
404             break;
405         case FOOD_BANANA:
406         case FOOD_CHEESE:
407         case FOOD_HONEYCOMB:
408         case FOOD_LEMON:
409         case FOOD_PIZZA:
410         case FOOD_ROYAL_JELLY:
411             item.colour = YELLOW;
412             break;
413         case FOOD_PEAR:
414             item.colour = LIGHTGREEN;
415             break;
416         case FOOD_CHOKO:
417         case FOOD_SNOZZCUMBER:
418             item.colour = GREEN;
419             break;
420         case FOOD_APRICOT:
421         case FOOD_ORANGE:
422             item.colour = LIGHTRED;
423             break;
424         case FOOD_STRAWBERRY:
425             item.colour = RED;
426             break;
427         case FOOD_APPLE:
428             item.colour = (coinflip() ? RED : GREEN);
429             break;
430         case FOOD_GRAPE:
431             item.colour = (coinflip() ? MAGENTA : GREEN);
432             break;
433         case FOOD_CHUNK:
434             // Set the appropriate colour of the meat:
435             temp_value  = mons_class_colour(item.mon_type);
436             item.colour = (temp_value == BLACK) ? LIGHTRED : temp_value;
437             break;
438         default:
439             item.colour = BROWN;
440         }
441         break;
442
443     case OBJ_JEWELLERY:
444         // unrandarts have already been coloured
445         if (is_unrandom_artefact(item))
446             break;
447         //randarts are bright, normal jewellery is dark
448         else if (is_random_artefact(item))
449         {
450             item.colour = random_range(LIGHTBLUE, WHITE);
451             break;
452         }
453
454         item.colour  = BROWN;
455         item.special = you.item_description[IDESC_RINGS][item.sub_type];
456
457         switchnum = item.special % NDSC_JEWEL_PRI;
458
459         switch (switchnum)
460         {
461         case 0:                 // "wooden ring"
462         case 2:                 // "golden ring"
463         case 6:                 // "brass ring"
464         case 7:                 // "copper ring"
465         case 25:                // "gilded ring"
466         case 27:                // "bronze ring"
467             item.colour = BROWN;
468             break;
469         case 1:                 // "silver ring"
470         case 8:                 // "granite ring"
471         case 9:                 // "ivory ring"
472         case 15:                // "bone ring"
473         case 16:                // "diamond ring"
474         case 20:                // "opal ring"
475         case 21:                // "pearl ring"
476         case 26:                // "onyx ring"
477             item.colour = LIGHTGREY;
478             break;
479         case 3:                 // "iron ring"
480         case 4:                 // "steel ring"
481         case 13:                // "glass ring"
482             item.colour = CYAN;
483             break;
484         case 5:                 // "tourmaline ring"
485         case 22:                // "coral ring"
486             item.colour = MAGENTA;
487             break;
488         case 10:                // "ruby ring"
489         case 19:                // "garnet ring"
490             item.colour = RED;
491             break;
492         case 11:                // "marble ring"
493         case 12:                // "jade ring"
494         case 14:                // "agate ring"
495         case 17:                // "emerald ring"
496         case 18:                // "peridot ring"
497             item.colour = GREEN;
498             break;
499         case 23:                // "sapphire ring"
500         case 24:                // "cabochon ring"
501         case 28:                // "moonstone ring"
502             item.colour = BLUE;
503             break;
504         }
505
506         if (item.sub_type >= AMU_FIRST_AMULET)
507         {
508             switch (switchnum)
509             {
510             case 0:             // "zirconium amulet"
511             case 9:             // "ivory amulet"
512             case 10:            // "bone amulet"
513             case 11:            // "platinum amulet"
514             case 16:            // "pearl amulet"
515             case 20:            // "diamond amulet"
516             case 24:            // "silver amulet"
517                 item.colour = LIGHTGREY;
518                 break;
519             case 1:             // "sapphire amulet"
520             case 17:            // "blue amulet"
521             case 26:            // "lapis lazuli amulet"
522                 item.colour = BLUE;
523                 break;
524             case 2:             // "golden amulet"
525             case 5:             // "bronze amulet"
526             case 6:             // "brass amulet"
527             case 7:             // "copper amulet"
528                 item.colour = BROWN;
529                 break;
530             case 3:             // "emerald amulet"
531             case 12:            // "jade amulet"
532             case 18:            // "peridot amulet"
533             case 21:            // "malachite amulet"
534             case 25:            // "soapstone amulet"
535             case 28:            // "beryl amulet"
536                 item.colour = GREEN;
537                 break;
538             case 4:             // "garnet amulet"
539             case 8:             // "ruby amulet"
540             case 19:            // "jasper amulet"
541             case 15:            // "cameo amulet"
542                 item.colour = RED;
543                 break;
544             case 22:            // "steel amulet"
545             case 23:            // "cabochon amulet"
546             case 27:            // "filigree amulet"
547                 item.colour = CYAN;
548                 break;
549             case 13:            // "fluorescent amulet"
550             case 14:            // "crystal amulet"
551                 item.colour = MAGENTA;
552             }
553         }
554
555         break;
556
557     case OBJ_SCROLLS:
558         item.colour  = LIGHTGREY;
559         item.special = you.item_description[IDESC_SCROLLS][item.sub_type];
560         item.plus = you.item_description[IDESC_SCROLLS_II][item.sub_type];
561         break;
562
563     case OBJ_BOOKS:
564         if (item.sub_type == BOOK_MANUAL)
565         {
566             item.colour = WHITE;
567             break;
568         }
569         switch (item.special % NDSC_BOOK_PRI)
570         {
571         case 0:
572         case 1:
573         default:
574             do item.colour = random_colour();
575                 while (item.colour == DARKGREY || item.colour == WHITE);
576             break;
577         case 2:
578             item.colour = BROWN;
579             break;
580         case 3:
581             item.colour = CYAN;
582             break;
583         case 4:
584             item.colour = LIGHTGREY;
585             break;
586         }
587         break;
588
589     case OBJ_RODS:
590         item.colour = YELLOW;
591         break;
592
593     case OBJ_STAVES:
594         item.colour  = BROWN;
595         item.special = you.item_description[IDESC_STAVES][item.sub_type];
596         break;
597
598     case OBJ_ORBS:
599         item.colour = ETC_MUTAGENIC;
600         break;
601
602     case OBJ_MISCELLANY:
603         if (is_deck(item))
604             break;
605
606         switch (item.sub_type)
607         {
608         case MISC_LANTERN_OF_SHADOWS:
609             item.colour = BLUE;
610             break;
611
612         // GREEN is for plain decks
613
614         case MISC_FAN_OF_GALES:
615             item.colour = CYAN;
616             break;
617
618 #if TAG_MAJOR_VERSION == 34
619         case MISC_BOTTLED_EFREET:
620             item.colour = RED;
621             break;
622 #endif
623
624         // MAGENTA is for ornate decks
625
626         case MISC_STONE_OF_TREMORS:
627             item.colour = BROWN;
628             break;
629
630         case MISC_DISC_OF_STORMS:
631             item.colour = LIGHTGREY;
632             break;
633
634         case MISC_PHIAL_OF_FLOODS:
635             item.colour = LIGHTBLUE;
636             break;
637
638         case MISC_BOX_OF_BEASTS:
639             item.colour = LIGHTGREEN; // ugh, but we're out of other options
640             break;
641
642         case MISC_CRYSTAL_BALL_OF_ENERGY:
643             item.colour = LIGHTCYAN;
644             break;
645
646         case MISC_HORN_OF_GERYON:
647             item.colour = LIGHTRED;
648             break;
649
650         case MISC_LAMP_OF_FIRE:
651             item.colour = YELLOW;
652             break;
653
654         case MISC_SACK_OF_SPIDERS:
655             item.colour = WHITE;
656             break;
657
658         case MISC_RUNE_OF_ZOT:
659             switch (item.plus)
660             {
661             case RUNE_DIS:                      // iron
662                 item.colour = ETC_IRON;
663                 break;
664
665             case RUNE_COCYTUS:                  // icy
666                 item.colour = ETC_ICE;
667                 break;
668
669             case RUNE_TARTARUS:                 // bone
670             case RUNE_SPIDER:
671                 item.colour = ETC_BONE;
672                 break;
673
674             case RUNE_SLIME:                    // slimy
675                 item.colour = ETC_SLIME;
676                 break;
677
678             case RUNE_SNAKE:                    // serpentine
679                 item.colour = ETC_POISON;
680                 break;
681
682             case RUNE_ELF:                      // elven
683                 item.colour = ETC_ELVEN;
684                 break;
685
686             case RUNE_VAULTS:                   // silver
687                 item.colour = ETC_SILVER;
688                 break;
689
690             case RUNE_TOMB:                     // golden
691                 item.colour = ETC_GOLD;
692                 break;
693
694             case RUNE_SWAMP:                    // decaying
695                 item.colour = ETC_DECAY;
696                 break;
697
698             case RUNE_SHOALS:                   // barnacled
699                 item.colour = ETC_WATER;
700                 break;
701
702             // This one is hardly unique, but colour isn't used for
703             // stacking, so we don't have to worry too much about this.
704             // - bwr
705             case RUNE_DEMONIC:                  // random Pandemonium lords
706             {
707                 const element_type types[] =
708                     {ETC_EARTH, ETC_ELECTRICITY, ETC_ENCHANT, ETC_HEAL,
709                      ETC_BLOOD, ETC_DEATH, ETC_UNHOLY, ETC_VEHUMET, ETC_BEOGH,
710                      ETC_CRYSTAL, ETC_SMOKE, ETC_DWARVEN, ETC_ORCISH, ETC_FLASH,
711                      ETC_KRAKEN};
712
713                 item.colour = RANDOM_ELEMENT(types);
714                 item.special = random_int();
715                 break;
716             }
717
718             case RUNE_ABYSSAL:
719                 item.colour = ETC_RANDOM;
720                 break;
721
722             case RUNE_MNOLEG:                   // glowing
723                 item.colour = ETC_MUTAGENIC;
724                 break;
725
726             case RUNE_LOM_LOBON:                // magical
727                 item.colour = ETC_MAGIC;
728                 break;
729
730             case RUNE_CEREBOV:                  // fiery
731                 item.colour = ETC_FIRE;
732                 break;
733
734             case RUNE_GEHENNA:                  // obsidian
735             case RUNE_GLOORX_VLOQ:              // dark
736             default:
737                 item.colour = ETC_DARK;
738                 break;
739             }
740             break;
741
742 #if TAG_MAJOR_VERSION == 34
743         case MISC_BUGGY_EBONY_CASKET:
744             item.colour = DARKGREY;
745             break;
746 #endif
747
748         case MISC_QUAD_DAMAGE:
749             item.colour = ETC_DARK;
750             break;
751
752         default:
753             item.colour = LIGHTGREEN;
754             break;
755         }
756         break;
757
758     case OBJ_CORPSES:
759         // Set the appropriate colour of the body:
760         temp_value  = mons_class_colour(item.mon_type);
761         item.colour = (temp_value == BLACK) ? LIGHTRED : temp_value;
762         break;
763
764     case OBJ_GOLD:
765         item.colour = YELLOW;
766         break;
767     default:
768         break;
769     }
770
771     // Compute random tile choice.
772     item.rnd = random2(256);
773 }
774
775 // Does Xom consider an item boring?
776 static bool _is_boring_item(int type, int sub_type)
777 {
778     switch (type)
779     {
780     case OBJ_POTIONS:
781         return sub_type == POT_CURE_MUTATION;
782     case OBJ_SCROLLS:
783         // These scrolls increase knowledge and thus reduce risk.
784         switch (sub_type)
785         {
786         case SCR_REMOVE_CURSE:
787         case SCR_IDENTIFY:
788         case SCR_MAGIC_MAPPING:
789             return true;
790         default:
791             break;
792         }
793         break;
794     case OBJ_JEWELLERY:
795         return sub_type == RING_TELEPORT_CONTROL
796                || sub_type == AMU_RESIST_MUTATION;
797     default:
798         break;
799     }
800     return false;
801 }
802
803 static weapon_type _determine_weapon_subtype(int item_level)
804 {
805     weapon_type rc = WPN_UNKNOWN;
806
807     const weapon_type common_subtypes[] =
808     {
809         WPN_SLING,
810         WPN_SPEAR,
811         WPN_HAND_AXE,
812         WPN_MACE,
813         WPN_DAGGER, WPN_DAGGER,
814         WPN_CLUB,
815         WPN_WHIP,
816         WPN_SHORT_SWORD
817     };
818
819     const weapon_type good_common_subtypes[] =
820     {
821         WPN_QUARTERSTAFF,
822         WPN_FALCHION,
823         WPN_LONG_SWORD,
824         WPN_WAR_AXE,
825         WPN_TRIDENT,
826         WPN_FLAIL,
827         WPN_CUTLASS,
828     };
829
830     const weapon_type rare_subtypes[] =
831     {
832         WPN_LAJATANG,
833         WPN_DEMON_WHIP,
834         WPN_DEMON_BLADE,
835         WPN_DEMON_TRIDENT,
836         WPN_BASTARD_SWORD,
837         WPN_EVENINGSTAR,
838         WPN_EXECUTIONERS_AXE,
839         WPN_QUICK_BLADE,
840         WPN_CLAYMORE,
841     };
842
843     if (item_level > 6 && one_chance_in(30)
844         && x_chance_in_y(10 + item_level, 100))
845     {
846         rc = RANDOM_ELEMENT(rare_subtypes);
847     }
848     else if (x_chance_in_y(20 - item_level, 20))
849         if (x_chance_in_y(7, item_level+7))
850             rc = RANDOM_ELEMENT(common_subtypes);
851         else
852             rc = RANDOM_ELEMENT(good_common_subtypes);
853     else
854     {
855         // Pick a weapon based on rarity.
856         while (true)
857         {
858             const int wpntype = random2(NUM_WEAPONS);
859
860             if (x_chance_in_y(weapon_rarity(wpntype), 10))
861             {
862                 rc = static_cast<weapon_type>(wpntype);
863                 break;
864             }
865         }
866     }
867     return rc;
868 }
869
870 static bool _try_make_item_unrand(item_def& item, int force_type)
871 {
872     if (player_in_branch(BRANCH_PANDEMONIUM))
873         return false;
874
875     int idx = find_okay_unrandart(item.base_type, force_type,
876                                   player_in_branch(BRANCH_ABYSS));
877
878     if (idx != -1 && make_item_unrandart(item, idx))
879         return true;
880
881     return false;
882 }
883
884 // Return whether we made an artefact.
885 static bool _try_make_weapon_artefact(item_def& item, int force_type,
886                                       int item_level, bool force_randart = false)
887 {
888     if (item_level > 2 && x_chance_in_y(101 + item_level * 3, 4000)
889         || force_randart)
890     {
891         // Make a randart or unrandart.
892
893         // 1 in 20 randarts are unrandarts.
894         if (one_chance_in(item_level == MAKE_GOOD_ITEM ? 7 : 20)
895             && !force_randart)
896         {
897             if (_try_make_item_unrand(item, force_type))
898                 return true;
899         }
900
901         // Small clubs are never randarts.
902         if (item.sub_type == WPN_CLUB)
903             return false;
904
905         // The rest are normal randarts.
906         make_item_randart(item);
907         // Mean enchantment +6.
908         item.plus  = 12 - biased_random2(7,2) - biased_random2(7,2) - biased_random2(7,2);
909         item.plus2 = 12 - biased_random2(7,2) - biased_random2(7,2) - biased_random2(7,2);
910
911         if (one_chance_in(5))
912         {
913             do_curse_item(item);
914             item.plus  = 3 - random2(6);
915             item.plus2 = 3 - random2(6);
916         }
917         else if ((item.plus < 0
918                   || item.plus2 < 0 && item.sub_type != WPN_BLOWGUN)
919                  && !one_chance_in(3))
920         {
921             do_curse_item(item);
922         }
923
924         // No to-dam enchantment on blowguns.
925         if (item.sub_type == WPN_BLOWGUN)
926             item.plus2 = 0;
927
928         if (get_weapon_brand(item) == SPWPN_HOLY_WRATH)
929             item.flags &= (~ISFLAG_CURSED);
930         return true;
931     }
932
933     return false;
934 }
935
936 static brand_type _determine_weapon_brand(const item_def& item, int item_level)
937 {
938     // Forced ego.
939     if (item.special != 0)
940         return static_cast<brand_type>(item.special);
941
942     const bool force_good = item_level >= MAKE_GIFT_ITEM;
943     const int tries       = force_good ? 5 : 1;
944     brand_type rc         = SPWPN_NORMAL;
945
946     for (int count = 0; count < tries && rc == SPWPN_NORMAL; ++count)
947     {
948         if (!force_good && !is_demonic(item)
949             && !x_chance_in_y(101 + item_level, 300))
950         {
951             continue;
952         }
953
954         // We are not guaranteed to have a special set by the end of
955         // this.
956         switch (item.sub_type)
957         {
958         case WPN_EVENINGSTAR:
959             if (coinflip())
960                 rc = SPWPN_DRAINING;
961             // **** intentional fall through here ****
962         case WPN_MORNINGSTAR:
963             if (one_chance_in(4))
964                 rc = SPWPN_VENOM;
965
966             if (one_chance_in(4))
967                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
968
969             if (one_chance_in(20))
970                 rc = SPWPN_VAMPIRICISM;
971             // **** intentional fall through here ****
972         case WPN_MACE:
973         case WPN_GREAT_MACE:
974         case WPN_FLAIL:
975         case WPN_DIRE_FLAIL:
976         case WPN_HAMMER:
977             if (one_chance_in(25))
978                 rc = SPWPN_ANTIMAGIC;
979
980             if (one_chance_in(25))
981                 rc = SPWPN_PAIN;
982
983             if (_got_distortion_roll(item_level))
984                 rc = SPWPN_DISTORTION;
985
986             if (one_chance_in(3) && (rc == SPWPN_NORMAL || one_chance_in(5)))
987                 rc = SPWPN_VORPAL;
988
989             if (one_chance_in(4))
990                 rc = SPWPN_HOLY_WRATH;
991
992             if (one_chance_in(3))
993                 rc = SPWPN_PROTECTION;
994
995             if (one_chance_in(10))
996                 rc = SPWPN_DRAINING;
997             break;
998
999         case WPN_DAGGER:
1000             if (one_chance_in(10))
1001                 rc = SPWPN_PAIN;
1002
1003             if (one_chance_in(3))
1004                 rc = SPWPN_VENOM;
1005             // **** intentional fall through here ****
1006
1007         case WPN_SHORT_SWORD:
1008         case WPN_CUTLASS:
1009             if (one_chance_in(25))
1010                 rc = SPWPN_ANTIMAGIC;
1011
1012             if (_got_distortion_roll(item_level))
1013                 rc = SPWPN_DISTORTION;
1014
1015             if (one_chance_in(10))
1016                 rc = SPWPN_VAMPIRICISM;
1017
1018             if (one_chance_in(8))
1019                 rc = SPWPN_ELECTROCUTION;
1020
1021             if (one_chance_in(8))
1022                 rc = SPWPN_PROTECTION;
1023
1024             if (one_chance_in(8))
1025                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
1026
1027             if (one_chance_in(12))
1028                 rc = SPWPN_HOLY_WRATH;
1029
1030             if (one_chance_in(8))
1031                 rc = SPWPN_DRAINING;
1032
1033             if (one_chance_in(8))
1034                 rc = SPWPN_SPEED;
1035
1036             if (one_chance_in(6))
1037                 rc = SPWPN_VENOM;
1038             break;
1039
1040         case WPN_FALCHION:
1041         case WPN_LONG_SWORD:
1042             if (one_chance_in(12))
1043                 rc = SPWPN_VENOM;
1044             // **** intentional fall through here ****
1045         case WPN_SCIMITAR:
1046             if (one_chance_in(25))
1047                 rc = SPWPN_PAIN;
1048             // **** intentional fall through here ****
1049         case WPN_GREAT_SWORD:
1050         case WPN_BASTARD_SWORD:
1051         case WPN_CLAYMORE:
1052             if (one_chance_in(25))
1053                 rc = SPWPN_ANTIMAGIC;
1054
1055             if (one_chance_in(10))
1056                 rc = SPWPN_VAMPIRICISM;
1057
1058             if (_got_distortion_roll(item_level))
1059                 rc = SPWPN_DISTORTION;
1060
1061             if (one_chance_in(5))
1062                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
1063
1064             if (one_chance_in(7))
1065                 rc = SPWPN_PROTECTION;
1066
1067             if (one_chance_in(12))
1068                 rc = SPWPN_DRAINING;
1069
1070             if (one_chance_in(7))
1071                 rc = SPWPN_ELECTROCUTION;
1072
1073             if (one_chance_in(4))
1074                 rc = SPWPN_HOLY_WRATH;
1075
1076             if (one_chance_in(4) && (rc == SPWPN_NORMAL || one_chance_in(3)))
1077                 rc = SPWPN_VORPAL;
1078             break;
1079
1080         case WPN_WAR_AXE:
1081         case WPN_BROAD_AXE:
1082         case WPN_BATTLEAXE:
1083         case WPN_EXECUTIONERS_AXE:
1084             if (one_chance_in(25))
1085                 rc = SPWPN_HOLY_WRATH;
1086
1087             if (one_chance_in(14))
1088                 rc = SPWPN_DRAINING;
1089             // **** intentional fall through here ****
1090         case WPN_HAND_AXE:
1091             if (one_chance_in(25))
1092                 rc = SPWPN_ANTIMAGIC;
1093
1094             if (one_chance_in(30))
1095                 rc = SPWPN_PAIN;
1096
1097             if (one_chance_in(10))
1098                 rc = SPWPN_VAMPIRICISM;
1099
1100             if (_got_distortion_roll(item_level))
1101                 rc = SPWPN_DISTORTION;
1102
1103             if (one_chance_in(3) && (rc == SPWPN_NORMAL || one_chance_in(5)))
1104                 rc = SPWPN_VORPAL;
1105
1106             if (one_chance_in(4))
1107                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
1108
1109             if (one_chance_in(8))
1110                 rc = SPWPN_ELECTROCUTION;
1111
1112             if (one_chance_in(12))
1113                 rc = SPWPN_VENOM;
1114             break;
1115
1116         case WPN_WHIP:
1117             if (one_chance_in(25))
1118                 rc = SPWPN_ANTIMAGIC;
1119
1120             if (one_chance_in(12))
1121                 rc = SPWPN_HOLY_WRATH;
1122
1123             if (one_chance_in(10))
1124                 rc = SPWPN_PAIN;
1125
1126             if (_got_distortion_roll(item_level))
1127                 rc = SPWPN_DISTORTION;
1128
1129             if (one_chance_in(10))
1130                 rc = SPWPN_VAMPIRICISM;
1131
1132             if (one_chance_in(8))
1133                 rc = SPWPN_DRAINING;
1134
1135             if (one_chance_in(6))
1136                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
1137
1138             if (one_chance_in(5))
1139                 rc = SPWPN_ELECTROCUTION;
1140
1141             if (one_chance_in(6))
1142                 rc = SPWPN_VENOM;
1143             break;
1144
1145         case WPN_HALBERD:
1146         case WPN_GLAIVE:
1147         case WPN_SCYTHE:
1148         case WPN_TRIDENT:
1149         case WPN_BARDICHE:
1150             if (one_chance_in(30))
1151                 rc = SPWPN_HOLY_WRATH;
1152
1153             if (one_chance_in(4))
1154                 rc = SPWPN_PROTECTION;
1155             // **** intentional fall through here ****
1156         case WPN_SPEAR:
1157             if (one_chance_in(25))
1158                 rc = SPWPN_ANTIMAGIC;
1159
1160             if (one_chance_in(25))
1161                 rc = SPWPN_PAIN;
1162
1163             if (one_chance_in(10))
1164                 rc = SPWPN_VAMPIRICISM;
1165
1166             if (_got_distortion_roll(item_level))
1167                 rc = SPWPN_DISTORTION;
1168
1169             if (one_chance_in(5) && (rc == SPWPN_NORMAL || one_chance_in(6)))
1170                 rc = SPWPN_VORPAL;
1171
1172             if (one_chance_in(6))
1173                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
1174
1175             if (one_chance_in(6))
1176                 rc = SPWPN_VENOM;
1177
1178             if (one_chance_in(5))
1179                 rc = SPWPN_DRAGON_SLAYING;
1180             break;
1181
1182         case WPN_SLING:
1183             if (coinflip())
1184                 break;
1185             // **** possible intentional fall through here ****
1186         case WPN_BOW:
1187         case WPN_LONGBOW:
1188         case WPN_CROSSBOW:
1189         {
1190             const int tmp = random2(1000);
1191             if (tmp < 480)
1192                 rc = SPWPN_FLAME;
1193             else if (tmp < 730)
1194                 rc = SPWPN_FROST;
1195             else if (tmp < 880)
1196                 rc = SPWPN_EVASION;
1197             else if (tmp < 990)
1198                 rc = SPWPN_VORPAL;
1199
1200             break;
1201         }
1202
1203         case WPN_BLOWGUN:
1204             if (one_chance_in(30))
1205                 rc = SPWPN_EVASION;
1206             break;
1207
1208         // Staves
1209         case WPN_QUARTERSTAFF:
1210             if (one_chance_in(30))
1211                 rc = SPWPN_ANTIMAGIC;
1212
1213             if (one_chance_in(30))
1214                 rc = SPWPN_HOLY_WRATH;
1215
1216             if (one_chance_in(30))
1217                 rc = SPWPN_PAIN;
1218
1219             if (_got_distortion_roll(item_level))
1220                 rc = SPWPN_DISTORTION;
1221
1222             if (one_chance_in(10))
1223                 rc = SPWPN_SPEED;
1224
1225             if (one_chance_in(10))
1226                 rc = SPWPN_VORPAL;
1227
1228             if (one_chance_in(10))
1229                 rc = SPWPN_DRAINING;
1230
1231             if (one_chance_in(6))
1232                 rc = SPWPN_PROTECTION;
1233             break;
1234
1235         case WPN_LAJATANG:
1236             if (one_chance_in(8))
1237                 rc = SPWPN_SPEED;
1238             else if (one_chance_in(12))
1239                 rc = SPWPN_PAIN;
1240             else if (_got_distortion_roll(item_level))
1241                 rc = SPWPN_DISTORTION;
1242             else if (one_chance_in(9))
1243                 rc = SPWPN_PROTECTION;
1244             else if (one_chance_in(6))
1245                 rc = SPWPN_ELECTROCUTION;
1246             else if (one_chance_in(5))
1247                 rc = SPWPN_VAMPIRICISM;
1248             else if (one_chance_in(6))
1249                 rc = SPWPN_VENOM;
1250             else if (one_chance_in(8))
1251                 rc = SPWPN_ANTIMAGIC;
1252             break;
1253
1254         case WPN_DEMON_WHIP:
1255         case WPN_DEMON_BLADE:
1256         case WPN_DEMON_TRIDENT:
1257             if (one_chance_in(25))
1258                 rc = SPWPN_ANTIMAGIC;
1259
1260             if (one_chance_in(5))       // 7.3%
1261                 rc = SPWPN_VAMPIRICISM;
1262
1263             if (one_chance_in(10))      // 4.0%
1264                 rc = SPWPN_PAIN;
1265
1266             if (one_chance_in(5))       // 10.2%
1267                 rc = SPWPN_DRAINING;
1268
1269             if (one_chance_in(5))       // 12.8%
1270                 rc = coinflip() ? SPWPN_FLAMING : SPWPN_FREEZING;
1271
1272             if (one_chance_in(5))       // 16%
1273                 rc = SPWPN_ELECTROCUTION;
1274
1275             if (one_chance_in(5))       // 20%
1276                 rc = SPWPN_VENOM;
1277             break;
1278
1279         case WPN_BLESSED_FALCHION:      // special gifts of TSO
1280         case WPN_BLESSED_LONG_SWORD:
1281         case WPN_BLESSED_SCIMITAR:
1282         case WPN_EUDEMON_BLADE:
1283         case WPN_BLESSED_BASTARD_SWORD:
1284         case WPN_BLESSED_GREAT_SWORD:
1285         case WPN_BLESSED_CLAYMORE:
1286         case WPN_SACRED_SCOURGE:
1287         case WPN_TRISHULA:
1288             rc = SPWPN_HOLY_WRATH;
1289             break;
1290
1291         default:
1292             // unlisted weapons have no associated, standard ego-types {dlb}
1293             break;
1294         }
1295     }
1296
1297     ASSERT(is_weapon_brand_ok(item.sub_type, rc, true));
1298     return rc;
1299 }
1300
1301 // Reject brands which are outright bad for the item.  Unorthodox combinations
1302 // are ok, since they can happen on randarts.
1303 bool is_weapon_brand_ok(int type, int brand, bool strict)
1304 {
1305     item_def item;
1306     item.base_type = OBJ_WEAPONS;
1307     item.sub_type = type;
1308
1309     if (brand <= SPWPN_NORMAL)
1310         return true;
1311
1312     if (type == WPN_QUICK_BLADE && brand == SPWPN_SPEED)
1313         return false;
1314
1315     if (weapon_skill(OBJ_WEAPONS, type) != SK_POLEARMS
1316         && brand == SPWPN_DRAGON_SLAYING)
1317     {
1318         return false;
1319     }
1320
1321     if (type == WPN_BLOWGUN)
1322     {
1323         switch ((brand_type)brand)
1324         {
1325         case SPWPN_NORMAL:
1326         case SPWPN_PROTECTION:
1327         case SPWPN_SPEED:
1328         case SPWPN_EVASION:
1329             return true;
1330         default:
1331             return false;
1332         }
1333     }
1334
1335     switch ((brand_type)brand)
1336     {
1337     // Universal brands.
1338     case SPWPN_NORMAL:
1339     case SPWPN_VENOM:
1340     case SPWPN_PROTECTION:
1341     case SPWPN_SPEED:
1342     case SPWPN_VORPAL:
1343     case SPWPN_CHAOS:
1344     case SPWPN_HOLY_WRATH:
1345     case SPWPN_ELECTROCUTION:
1346         break;
1347
1348     // Melee-only brands.
1349     case SPWPN_FLAMING:
1350     case SPWPN_FREEZING:
1351     case SPWPN_DRAGON_SLAYING:
1352     case SPWPN_DRAINING:
1353     case SPWPN_VAMPIRICISM:
1354     case SPWPN_PAIN:
1355     case SPWPN_DISTORTION:
1356     case SPWPN_ANTIMAGIC:
1357     case SPWPN_REAPING:
1358         if (is_range_weapon(item))
1359             return false;
1360         break;
1361
1362     // Ranged-only brands.
1363     case SPWPN_FLAME:
1364     case SPWPN_FROST:
1365     case SPWPN_PENETRATION:
1366     case SPWPN_EVASION:
1367         if (!is_range_weapon(item))
1368             return false;
1369         break;
1370
1371 #if TAG_MAJOR_VERSION == 34
1372     // Removed brands.
1373     case SPWPN_RETURNING:
1374     case SPWPN_REACHING:
1375     case SPWPN_ORC_SLAYING:
1376         return false;
1377 #endif
1378
1379     case SPWPN_ACID:
1380     case SPWPN_CONFUSE:
1381     case SPWPN_FORBID_BRAND:
1382     case SPWPN_DEBUG_RANDART:
1383     case NUM_SPECIAL_WEAPONS:
1384     case NUM_REAL_SPECIAL_WEAPONS:
1385         die("invalid brand %d on weapon %d (%s)", brand, type,
1386             item.name(DESC_PLAIN).c_str());
1387         break;
1388     }
1389
1390     return true;
1391 }
1392
1393 static void _roll_weapon_type(item_def& item, int item_level)
1394 {
1395     int i;
1396     for (i = 0; i < 1000; ++i)
1397     {
1398         item.sub_type = _determine_weapon_subtype(item_level);
1399         if (is_weapon_brand_ok(item.sub_type, item.special, true))
1400             break;
1401     }
1402     if (i == 1000)
1403         item.sub_type = SPWPN_NORMAL; // fall back to no brand
1404 }
1405
1406 static void _generate_weapon_item(item_def& item, bool allow_uniques,
1407                                   int force_type, int item_level)
1408 {
1409     // Determine weapon type.
1410     if (force_type != OBJ_RANDOM)
1411         item.sub_type = force_type;
1412     else
1413         _roll_weapon_type(item, item_level);
1414
1415     // Forced randart.
1416     if (item_level == ISPEC_RANDART)
1417     {
1418         int i;
1419         int ego = item.special;
1420         for (i = 0; i < 100; ++i)
1421             if (_try_make_weapon_artefact(item, force_type, 0, true) && is_artefact(item))
1422             {
1423                 if (ego > SPWPN_NORMAL)
1424                     item.props[ARTEFACT_PROPS_KEY].get_vector()[ARTP_BRAND].get_short() = ego;
1425                 if (randart_is_bad(item)) // recheck, the brand changed
1426                 {
1427                     force_type = item.sub_type;
1428                     item.clear();
1429                     item.base_type = OBJ_WEAPONS;
1430                     item.sub_type = force_type;
1431                     continue;
1432                 }
1433                 return;
1434             }
1435         // fall back to an ordinary item
1436         item_level = MAKE_GOOD_ITEM;
1437     }
1438
1439     // If we make the unique roll, no further generation necessary.
1440     if (allow_uniques
1441         && _try_make_weapon_artefact(item, force_type, item_level))
1442     {
1443         return;
1444     }
1445
1446     ASSERT(!is_artefact(item));
1447
1448     // Artefacts handled, let's make a normal item.
1449     const bool force_good = item_level >= MAKE_GIFT_ITEM;
1450     const bool forced_ego = item.special > 0;
1451     const bool no_brand   = item.special == SPWPN_FORBID_BRAND;
1452
1453     if (no_brand)
1454         set_item_ego_type(item, OBJ_WEAPONS, SPWPN_NORMAL);
1455
1456     // If it's forced to be a good item, reroll the worst weapons.
1457     while (force_good
1458            && force_type == OBJ_RANDOM
1459            && (item.sub_type == WPN_CLUB || item.sub_type == WPN_SLING))
1460     {
1461         _roll_weapon_type(item, item_level);
1462     }
1463
1464     item.plus  = 0;
1465     item.plus2 = 0;
1466
1467     set_equip_race(item, ISFLAG_NO_RACE);
1468
1469     if (item_level < 0)
1470     {
1471         // Thoroughly damaged, could had been good once.
1472         if (!no_brand && (forced_ego || one_chance_in(4)))
1473         {
1474             // Brand is set as for "good" items.
1475             set_item_ego_type(item, OBJ_WEAPONS,
1476                 _determine_weapon_brand(item, 2 + 2 * env.absdepth0));
1477         }
1478         item.plus  -= 1 + random2(3);
1479         item.plus2 -= 1 + random2(3);
1480
1481         if (item_level == ISPEC_BAD)
1482             do_curse_item(item);
1483     }
1484     else if ((force_good || is_demonic(item) || forced_ego
1485                     || x_chance_in_y(51 + item_level, 200))
1486                 && (!item.is_mundane() || force_good))
1487     {
1488         // Make a better item (possibly ego).
1489         if (!no_brand)
1490         {
1491             set_item_ego_type(item, OBJ_WEAPONS,
1492                               _determine_weapon_brand(item, item_level));
1493         }
1494
1495         // if acquired item still not ego... enchant it up a bit.
1496         if (force_good && item.special == SPWPN_NORMAL)
1497         {
1498             item.plus  += 2 + random2(3);
1499             item.plus2 += 2 + random2(3);
1500         }
1501
1502         const int chance = (force_good ? 200 : item_level);
1503
1504         // Odd-looking, but this is how the algorithm compacts {dlb}.
1505         for (int i = 0; i < 4; ++i)
1506         {
1507             item.plus += random2(3);
1508
1509             if (random2(350) > 20 + chance)
1510                 break;
1511         }
1512
1513         // Odd-looking, but this is how the algorithm compacts {dlb}.
1514         for (int i = 0; i < 4; ++i)
1515         {
1516             item.plus2 += random2(3);
1517
1518             if (random2(500) > 50 + chance)
1519                 break;
1520         }
1521     }
1522     else
1523     {
1524         if (one_chance_in(12))
1525         {
1526             // Make a cursed item.
1527             do_curse_item(item);
1528             item.plus  -= random2(4);
1529             item.plus2 -= random2(4);
1530             set_item_ego_type(item, OBJ_WEAPONS, SPWPN_NORMAL);
1531         }
1532     }
1533
1534     // No to-dam enchantment on blowguns.
1535     if (item.sub_type == WPN_BLOWGUN)
1536         item.plus2 = 0;
1537 }
1538
1539 // Current list is based on dpeg's original post to the Wiki, found at the
1540 // page: <http://crawl.develz.org/wiki/doku.php?id=DCSS%3Aissue%3A41>.
1541 // Remember to update the code in is_missile_brand_ok if adding or altering
1542 // brands that are applied to missiles. {due}
1543 static special_missile_type _determine_missile_brand(const item_def& item,
1544                                                      int item_level)
1545 {
1546     // Forced ego.
1547     if (item.special != 0)
1548         return static_cast<special_missile_type>(item.special);
1549
1550     const bool force_good = item_level >= MAKE_GIFT_ITEM;
1551     special_missile_type rc = SPMSL_NORMAL;
1552
1553     // "Normal weight" of SPMSL_NORMAL.
1554     int nw = force_good ? 0 : random2(2000 - 55 * item_level);
1555
1556     switch (item.sub_type)
1557     {
1558     case MI_NEEDLE:
1559         // Curare is special cased, all the others aren't.
1560         if (got_curare_roll(item_level))
1561         {
1562             rc = SPMSL_CURARE;
1563             break;
1564         }
1565
1566         rc = random_choose_weighted(20, SPMSL_SLEEP,
1567                                     20, SPMSL_SLOW,
1568                                     20, SPMSL_CONFUSION,
1569                                     10, SPMSL_PARALYSIS,
1570                                     10, SPMSL_FRENZY,
1571                                     nw, SPMSL_POISONED,
1572                                     0);
1573         break;
1574     case MI_DART:
1575         rc = random_choose_weighted(30, SPMSL_FLAME,
1576                                     30, SPMSL_FROST,
1577                                     20, SPMSL_POISONED,
1578                                     12, SPMSL_SILVER,
1579                                     12, SPMSL_STEEL,
1580                                     12, SPMSL_DISPERSAL,
1581                                     20, SPMSL_EXPLODING,
1582                                     nw, SPMSL_NORMAL,
1583                                     0);
1584         break;
1585     case MI_ARROW:
1586         rc = random_choose_weighted(30, SPMSL_FLAME,
1587                                     30, SPMSL_FROST,
1588                                     20, SPMSL_POISONED,
1589                                     15, SPMSL_DISPERSAL,
1590                                     nw, SPMSL_NORMAL,
1591                                     0);
1592         break;
1593     case MI_BOLT:
1594         rc = random_choose_weighted(30, SPMSL_FLAME,
1595                                     30, SPMSL_FROST,
1596                                     20, SPMSL_POISONED,
1597                                     15, SPMSL_PENETRATION,
1598                                     15, SPMSL_SILVER,
1599                                     10, SPMSL_STEEL,
1600                                     nw, SPMSL_NORMAL,
1601                                     0);
1602         break;
1603     case MI_JAVELIN:
1604         rc = random_choose_weighted(30, SPMSL_RETURNING,
1605                                     32, SPMSL_PENETRATION,
1606                                     32, SPMSL_POISONED,
1607                                     21, SPMSL_STEEL,
1608                                     20, SPMSL_SILVER,
1609                                     nw, SPMSL_NORMAL,
1610                                     0);
1611         break;
1612     case MI_TOMAHAWK:
1613         rc = random_choose_weighted(15, SPMSL_POISONED,
1614                                     10, SPMSL_SILVER,
1615                                     10, SPMSL_STEEL,
1616                                     40, SPMSL_RETURNING,
1617                                     nw, SPMSL_NORMAL,
1618                                     0);
1619         break;
1620     case MI_STONE:
1621         // deliberate fall through
1622     case MI_LARGE_ROCK:
1623         // Stones get no brands. Slings may be branded.
1624         rc = SPMSL_NORMAL;
1625         break;
1626     case MI_SLING_BULLET:
1627         rc = random_choose_weighted(30, SPMSL_FLAME,
1628                                     30, SPMSL_FROST,
1629                                     20, SPMSL_POISONED,
1630                                     15, SPMSL_STEEL,
1631                                     15, SPMSL_SILVER,
1632                                     20, SPMSL_EXPLODING,
1633                                     nw, SPMSL_NORMAL,
1634                                     0);
1635         break;
1636     case MI_THROWING_NET:
1637         rc = random_choose_weighted(30, SPMSL_STEEL,
1638                                     30, SPMSL_SILVER,
1639                                     nw, SPMSL_NORMAL,
1640                                     0);
1641         break;
1642     }
1643
1644     ASSERT(is_missile_brand_ok(item.sub_type, rc, true));
1645
1646     return rc;
1647 }
1648
1649 bool is_missile_brand_ok(int type, int brand, bool strict)
1650 {
1651     // Stones can never be branded.
1652     if ((type == MI_STONE || type == MI_LARGE_ROCK) && brand != SPMSL_NORMAL
1653         && strict)
1654     {
1655         return false;
1656     }
1657
1658     // In contrast, needles should always be branded.
1659     // And all of these brands save poison are unique to needles.
1660     switch (brand)
1661     {
1662     case SPMSL_POISONED:
1663         if (type == MI_NEEDLE)
1664             return true;
1665         break;
1666
1667     case SPMSL_CURARE:
1668     case SPMSL_PARALYSIS:
1669     case SPMSL_SLOW:
1670     case SPMSL_SLEEP:
1671     case SPMSL_CONFUSION:
1672 #if TAG_MAJOR_VERSION == 34
1673     case SPMSL_SICKNESS:
1674 #endif
1675     case SPMSL_FRENZY:
1676         return type == MI_NEEDLE;
1677
1678 #if TAG_MAJOR_VERSION == 34
1679     case SPMSL_BLINDING:
1680         // possible on ex-pies
1681         return type == MI_TOMAHAWK && !strict;
1682 #endif
1683
1684     default:
1685         if (type == MI_NEEDLE)
1686             return false;
1687     }
1688
1689     // Everything else doesn't matter.
1690     if (brand == SPMSL_NORMAL)
1691         return true;
1692
1693     // In non-strict mode, everything other than needles is mostly ok.
1694     if (!strict)
1695         return true;
1696
1697     // Not a missile?
1698     if (type == 0)
1699         return true;
1700
1701     // Specifics
1702     switch (brand)
1703     {
1704     case SPMSL_FLAME:
1705         return type == MI_SLING_BULLET || type == MI_ARROW
1706                || type == MI_BOLT || type == MI_DART;
1707     case SPMSL_FROST:
1708         return type == MI_SLING_BULLET || type == MI_ARROW
1709                || type == MI_BOLT || type == MI_DART;
1710     case SPMSL_POISONED:
1711         return type == MI_SLING_BULLET || type == MI_ARROW
1712                || type == MI_BOLT || type == MI_DART
1713                || type == MI_JAVELIN || type == MI_TOMAHAWK;
1714     case SPMSL_RETURNING:
1715         return type == MI_JAVELIN || type == MI_TOMAHAWK;
1716     case SPMSL_CHAOS:
1717         return type == MI_SLING_BULLET || type == MI_ARROW
1718                || type == MI_BOLT || type == MI_DART || type == MI_TOMAHAWK
1719                || type == MI_JAVELIN || type == MI_THROWING_NET;
1720     case SPMSL_PENETRATION:
1721         return type == MI_JAVELIN || type == MI_BOLT;
1722     case SPMSL_DISPERSAL:
1723         return type == MI_ARROW || type == MI_DART;
1724     case SPMSL_EXPLODING:
1725         return type == MI_SLING_BULLET || type == MI_DART;
1726     case SPMSL_STEEL: // deliberate fall through
1727     case SPMSL_SILVER:
1728         return type == MI_BOLT || type == MI_SLING_BULLET
1729                || type == MI_JAVELIN || type == MI_TOMAHAWK
1730                || type == MI_THROWING_NET;
1731     default: break;
1732     }
1733
1734     // Assume yes, if we've gotten this far.
1735     return false;
1736 }
1737
1738 static void _generate_missile_item(item_def& item, int force_type,
1739                                    int item_level)
1740 {
1741     const bool no_brand = (item.special == SPMSL_FORBID_BRAND);
1742     if (no_brand)
1743         item.special = SPMSL_NORMAL;
1744
1745     item.plus = 0;
1746
1747     if (force_type != OBJ_RANDOM)
1748         item.sub_type = force_type;
1749     else
1750     {
1751         item.sub_type =
1752             random_choose_weighted(30, MI_STONE,
1753                                    20, MI_DART,
1754                                    20, MI_ARROW,
1755                                    12, MI_BOLT,
1756                                    12, MI_SLING_BULLET,
1757                                    10, MI_NEEDLE,
1758                                    3,  MI_TOMAHAWK,
1759                                    2,  MI_JAVELIN,
1760                                    1,  MI_THROWING_NET,
1761                                    1,  MI_LARGE_ROCK,
1762                                    0);
1763     }
1764
1765     // No fancy rocks -- break out before we get to racial/special stuff.
1766     if (item.sub_type == MI_LARGE_ROCK)
1767     {
1768         item.quantity = 2 + random2avg(5,2);
1769         return;
1770     }
1771     else if (item.sub_type == MI_STONE)
1772     {
1773         item.quantity = 1 + random2(7) + random2(10) + random2(12) + random2(10);
1774         return;
1775     }
1776     else if (item.sub_type == MI_THROWING_NET) // no fancy nets, either
1777     {
1778         item.quantity = 1 + one_chance_in(4); // and only one, rarely two
1779         return;
1780     }
1781
1782     set_equip_race(item, ISFLAG_NO_RACE);
1783
1784     if (!no_brand)
1785     {
1786         set_item_ego_type(item, OBJ_MISSILES,
1787                            _determine_missile_brand(item, item_level));
1788     }
1789
1790     // Reduced quantity if special.
1791     if (item.sub_type == MI_JAVELIN || item.sub_type == MI_TOMAHAWK
1792         || (item.sub_type == MI_NEEDLE && get_ammo_brand(item) != SPMSL_POISONED)
1793         || get_ammo_brand(item) == SPMSL_RETURNING
1794         || (item.sub_type == MI_DART && get_ammo_brand(item) == SPMSL_POISONED))
1795     {
1796         item.quantity = random_range(2, 8);
1797     }
1798     else if (get_ammo_brand(item) != SPMSL_NORMAL)
1799         item.quantity = 1 + random2(7) + random2(10) + random2(10);
1800     else
1801         item.quantity = 1 + random2(7) + random2(10) + random2(10) + random2(12);
1802 }
1803
1804 static bool _try_make_armour_artefact(item_def& item, int force_type,
1805                                       int item_level, bool force_randart = false)
1806 {
1807     if (item_level > 2 && x_chance_in_y(101 + item_level * 3, 4000)
1808         || force_randart)
1809     {
1810         // Make a randart or unrandart.
1811
1812         // 1 in 20 randarts are unrandarts.
1813         if (one_chance_in(item_level == MAKE_GOOD_ITEM ? 7 : 20)
1814             && !force_randart)
1815         {
1816             if (_try_make_item_unrand(item, force_type))
1817                 return true;
1818         }
1819
1820         // The rest are normal randarts.
1821
1822         // 10% of boots become barding.
1823         if (item.sub_type == ARM_BOOTS && one_chance_in(10))
1824         {
1825             item.sub_type = coinflip() ? ARM_NAGA_BARDING
1826                                        : ARM_CENTAUR_BARDING;
1827         }
1828         else
1829             hide2armour(item); // No randart hides.
1830
1831         // Needs to be done after the barding chance else we get randart
1832         // bardings named Boots of xy.
1833         make_item_randart(item);
1834
1835         // Determine enchantment and cursedness.
1836         if (one_chance_in(5))
1837         {
1838             do_curse_item(item);
1839             item.plus = -random2(6);
1840         }
1841         else
1842         {
1843             int max_plus = armour_max_enchant(item);
1844             item.plus = random2(max_plus + 1);
1845
1846             if (one_chance_in(5))
1847                 item.plus += random2(max_plus + 6) / 2;
1848
1849             if (one_chance_in(6))
1850                 item.plus -= random2(max_plus + 6);
1851
1852             if (item.plus < 0 && !one_chance_in(3))
1853                 do_curse_item(item);
1854         }
1855
1856         return true;
1857     }
1858
1859     return false;
1860 }
1861
1862 static item_status_flag_type _determine_armour_race(const item_def& item,
1863                                                     int item_race)
1864 {
1865     item_status_flag_type rc = ISFLAG_NO_RACE;
1866
1867     if (item.sub_type > ARM_MAX_RACIAL)
1868         return rc;
1869
1870     switch (item_race)
1871     {
1872     case MAKE_ITEM_ELVEN:
1873         rc = ISFLAG_ELVEN;
1874         break;
1875
1876     case MAKE_ITEM_DWARVEN:
1877         rc = ISFLAG_DWARVEN;
1878         break;
1879
1880     case MAKE_ITEM_ORCISH:
1881         rc = ISFLAG_ORCISH;
1882         break;
1883
1884     case MAKE_ITEM_RANDOM_RACE:
1885         if (coinflip())
1886             break;
1887
1888         switch (item.sub_type)
1889         {
1890         case ARM_BUCKLER:
1891         case ARM_SHIELD:
1892         case ARM_LARGE_SHIELD:
1893             if (one_chance_in(4))
1894                 rc = ISFLAG_ORCISH;
1895             if (one_chance_in(4))
1896                 rc = ISFLAG_ELVEN;
1897             if (one_chance_in(3))
1898                 rc = ISFLAG_DWARVEN;
1899             break;
1900
1901         case ARM_CLOAK:
1902             if (one_chance_in(4))
1903                 rc = ISFLAG_ORCISH;
1904             if (one_chance_in(4))
1905                 rc = ISFLAG_DWARVEN;
1906             if (one_chance_in(4))
1907                 rc = ISFLAG_ELVEN;
1908             break;
1909
1910         case ARM_GLOVES:
1911         case ARM_BOOTS:
1912             if (one_chance_in(4))
1913                 rc = ISFLAG_ORCISH;
1914             if (one_chance_in(4))
1915                 rc = ISFLAG_ELVEN;
1916             if (one_chance_in(6))
1917                 rc = ISFLAG_DWARVEN;
1918             break;
1919
1920         case ARM_HAT:
1921             if (one_chance_in(6))
1922                 rc = ISFLAG_ORCISH;
1923             if (one_chance_in(6))
1924                 rc = ISFLAG_ELVEN;
1925             break;
1926
1927         case ARM_HELMET:
1928             if (one_chance_in(6))
1929                 rc = ISFLAG_ORCISH;
1930             if (one_chance_in(5))
1931                 rc = ISFLAG_DWARVEN;
1932             break;
1933
1934         case ARM_ROBE:
1935             if (one_chance_in(6))
1936                 rc = ISFLAG_ORCISH;
1937             if (one_chance_in(4))
1938                 rc = ISFLAG_ELVEN;
1939             break;
1940
1941         case ARM_LEATHER_ARMOUR:
1942         case ARM_RING_MAIL:
1943         case ARM_SCALE_MAIL:
1944         case ARM_CHAIN_MAIL:
1945         case ARM_PLATE_ARMOUR:
1946             if (item.sub_type <= ARM_CHAIN_MAIL && one_chance_in(6))
1947                 rc = ISFLAG_ELVEN;
1948             if (item.sub_type >= ARM_RING_MAIL && one_chance_in(5))
1949                 rc = ISFLAG_DWARVEN;
1950             if (one_chance_in(5))
1951                 rc = ISFLAG_ORCISH;
1952
1953         default:
1954             break;
1955         }
1956     }
1957
1958     return rc;
1959 }
1960
1961 static special_armour_type _determine_armour_ego(const item_def& item,
1962                                                  int force_type, int item_level)
1963 {
1964     if (item.special != 0)
1965         return static_cast<special_armour_type>(item.special);
1966
1967     special_armour_type rc = SPARM_NORMAL;
1968     switch (item.sub_type)
1969     {
1970     case ARM_SHIELD:
1971     case ARM_LARGE_SHIELD:
1972     case ARM_BUCKLER:
1973         rc = random_choose_weighted(40, SPARM_RESISTANCE,
1974                                    120, SPARM_FIRE_RESISTANCE,
1975                                    120, SPARM_COLD_RESISTANCE,
1976                                    120, SPARM_POISON_RESISTANCE,
1977                                    120, SPARM_POSITIVE_ENERGY,
1978                                    240, SPARM_REFLECTION,
1979                                    480, SPARM_PROTECTION,
1980                                      0);
1981         break;
1982
1983     case ARM_CLOAK:
1984         rc = random_choose(SPARM_POISON_RESISTANCE,
1985                            SPARM_DARKNESS,
1986                            SPARM_MAGIC_RESISTANCE,
1987                            SPARM_PRESERVATION,
1988                            -1);
1989         break;
1990
1991     case ARM_HAT:
1992         if (coinflip())
1993         {
1994             rc = random_choose_weighted(3, SPARM_MAGIC_RESISTANCE,
1995                                         2, SPARM_INTELLIGENCE,
1996                                         2, SPARM_SEE_INVISIBLE,
1997                                         1, SPARM_SPIRIT_SHIELD,
1998                                         0);
1999         }
2000         break;
2001
2002     case ARM_HELMET:
2003         rc = coinflip() ? SPARM_SEE_INVISIBLE : SPARM_INTELLIGENCE;
2004         break;
2005
2006     case ARM_GLOVES:
2007         rc = random_choose(SPARM_DEXTERITY, SPARM_STRENGTH, SPARM_ARCHERY, -1);
2008         break;
2009
2010     case ARM_BOOTS:
2011     case ARM_NAGA_BARDING:
2012     case ARM_CENTAUR_BARDING:
2013     {
2014         const int tmp = random2(800) + 400 * (item.sub_type != ARM_BOOTS);
2015
2016         rc = (tmp < 200) ? SPARM_RUNNING :
2017              (tmp < 400) ? SPARM_JUMPING :
2018              (tmp < 600) ? SPARM_FLYING :
2019              (tmp < 800) ? SPARM_STEALTH :
2020              (tmp < 1000) ? SPARM_COLD_RESISTANCE
2021                           : SPARM_FIRE_RESISTANCE;
2022         break;
2023     }
2024
2025     case ARM_ROBE:
2026         rc = random_choose_weighted(1, SPARM_RESISTANCE,
2027                                     2, SPARM_COLD_RESISTANCE,
2028                                     2, SPARM_FIRE_RESISTANCE,
2029                                     2, SPARM_POSITIVE_ENERGY,
2030                                     4, SPARM_MAGIC_RESISTANCE,
2031                                     4, SPARM_ARCHMAGI,
2032                                     0);
2033
2034         // Only ever generate robes of archmagi for random pieces of armour,
2035         // for whatever reason.
2036         if (rc == SPARM_ARCHMAGI
2037             && (force_type != OBJ_RANDOM || !x_chance_in_y(11 + item_level, 50)))
2038         {
2039             rc = SPARM_NORMAL;
2040         }
2041         break;
2042
2043     default:
2044         if (armour_is_hide(item, true)
2045             || item.sub_type == ARM_ANIMAL_SKIN
2046             || item.sub_type == ARM_CRYSTAL_PLATE_ARMOUR)
2047         {
2048             rc = SPARM_NORMAL;
2049             break;
2050         }
2051
2052         rc = coinflip() ? SPARM_COLD_RESISTANCE : SPARM_FIRE_RESISTANCE;
2053
2054         if (one_chance_in(9))
2055             rc = SPARM_POSITIVE_ENERGY;
2056
2057         if (one_chance_in(5))
2058             rc = SPARM_MAGIC_RESISTANCE;
2059
2060         if (one_chance_in(5))
2061             rc = SPARM_POISON_RESISTANCE;
2062
2063         if (item.sub_type == ARM_PLATE_ARMOUR && one_chance_in(15))
2064             rc = SPARM_PONDEROUSNESS;
2065         break;
2066     }
2067
2068     ASSERT(is_armour_brand_ok(item.sub_type, rc, true));
2069     return rc;
2070 }
2071
2072 bool is_armour_brand_ok(int type, int brand, bool strict)
2073 {
2074     equipment_type slot = get_armour_slot((armour_type)type);
2075
2076     // Currently being too restrictive results in asserts, being too
2077     // permissive will generate such items on "any armour ego:XXX".
2078     // The latter is definitely so much safer -- 1KB
2079     switch ((special_armour_type)brand)
2080     {
2081     case SPARM_FORBID_EGO:
2082     case SPARM_NORMAL:
2083         return true;
2084
2085     case SPARM_FLYING:
2086         if (slot == EQ_BODY_ARMOUR)
2087             return true;
2088         // deliberate fall-through
2089     case SPARM_RUNNING:
2090     case SPARM_STEALTH:
2091     case SPARM_JUMPING:
2092         return slot == EQ_BOOTS;
2093
2094     case SPARM_ARCHMAGI:
2095         return !strict || type == ARM_ROBE;
2096
2097     case SPARM_PONDEROUSNESS:
2098         return true;
2099
2100     case SPARM_PRESERVATION:
2101         if (type == ARM_PLATE_ARMOUR && !strict)
2102             return true;
2103         // deliberate fall-through
2104     case SPARM_DARKNESS:
2105         return slot == EQ_CLOAK;
2106
2107     case SPARM_REFLECTION:
2108     case SPARM_PROTECTION:
2109         return slot == EQ_SHIELD;
2110
2111     case SPARM_STRENGTH:
2112     case SPARM_DEXTERITY:
2113         if (!strict)
2114             return true;
2115         // deliberate fall-through
2116     case SPARM_ARCHERY:
2117         return slot == EQ_GLOVES;
2118
2119     case SPARM_SEE_INVISIBLE:
2120     case SPARM_INTELLIGENCE:
2121         return slot == EQ_HELMET;
2122
2123     case SPARM_FIRE_RESISTANCE:
2124     case SPARM_COLD_RESISTANCE:
2125     case SPARM_RESISTANCE:
2126         if (type == ARM_FIRE_DRAGON_ARMOUR
2127             || type == ARM_ICE_DRAGON_ARMOUR
2128             || type == ARM_GOLD_DRAGON_ARMOUR)
2129         {
2130             return false; // contradictory or redundant
2131         }
2132         return true; // in portal vaults, these can happen on every slot
2133
2134     case SPARM_MAGIC_RESISTANCE:
2135         if (type == ARM_HAT)
2136             return true;
2137         // deliberate fall-through
2138     case SPARM_POISON_RESISTANCE:
2139     case SPARM_POSITIVE_ENERGY:
2140         if (type == ARM_PEARL_DRAGON_ARMOUR && brand == SPARM_POSITIVE_ENERGY)
2141             return false; // contradictory or redundant
2142
2143         return slot == EQ_BODY_ARMOUR || slot == EQ_SHIELD || slot == EQ_CLOAK
2144                || !strict;
2145
2146     case SPARM_SPIRIT_SHIELD:
2147         return type == ARM_HAT ||
2148 #if TAG_MAJOR_VERSION == 34
2149                type == ARM_CAP ||
2150 #endif
2151                slot == EQ_SHIELD || !strict;
2152     case NUM_SPECIAL_ARMOURS:
2153     case NUM_REAL_SPECIAL_ARMOURS:
2154         die("invalid armour brand");
2155     }
2156
2157     return true;
2158 }
2159
2160 static void _generate_armour_item(item_def& item, bool allow_uniques,
2161                                   int force_type, int item_level,
2162                                   int item_race)
2163 {
2164     if (force_type != OBJ_RANDOM)
2165         item.sub_type = force_type;
2166     else
2167     {
2168         int i;
2169         for (i = 0; i < 1000; ++i)
2170         {
2171             item.sub_type = _get_random_armour_type(item_level);
2172             if (is_armour_brand_ok(item.sub_type, item.special, true))
2173                 break;
2174         }
2175     }
2176
2177     // Forced randart.
2178     if (item_level == ISPEC_RANDART)
2179     {
2180         int i;
2181         for (i = 0; i < 100; ++i)
2182         {
2183             if (_try_make_armour_artefact(item, force_type, 0, true)
2184                 && is_artefact(item))
2185             {
2186                 return;
2187             }
2188         }
2189         // fall back to an ordinary item
2190         item_level = MAKE_GOOD_ITEM;
2191     }
2192
2193     if (allow_uniques
2194         && _try_make_armour_artefact(item, force_type, item_level))
2195     {
2196         return;
2197     }
2198
2199     if (item_race == MAKE_ITEM_RANDOM_RACE && item.sub_type == ARM_BOOTS)
2200     {
2201         if (one_chance_in(8))
2202             item.sub_type = ARM_NAGA_BARDING;
2203         else if (one_chance_in(7))
2204             item.sub_type = ARM_CENTAUR_BARDING;
2205     }
2206
2207     set_equip_race(item, _determine_armour_race(item, item_race));
2208
2209     // Dwarven armour is high-quality.
2210     if (get_equip_race(item) == ISFLAG_DWARVEN && coinflip())
2211         item.plus++;
2212
2213     const bool force_good = item_level >= MAKE_GIFT_ITEM;
2214     const bool forced_ego = (item.special > 0);
2215     const bool no_ego     = (item.special == SPARM_FORBID_EGO);
2216
2217     if (no_ego)
2218         item.special = SPARM_NORMAL;
2219
2220     if (item_level < 0)
2221     {
2222         // Thoroughly damaged, could have been good once.
2223         if (!no_ego && (forced_ego || one_chance_in(4)))
2224         {
2225             // Brand is set as for "good" items.
2226             set_item_ego_type(item, OBJ_ARMOUR,
2227                 _determine_armour_ego(item, item.sub_type,
2228                 2 + 2 * env.absdepth0));
2229         }
2230
2231         item.plus -= 1 + random2(3);
2232
2233         if (item_level == ISPEC_BAD)
2234             do_curse_item(item);
2235     }
2236     else if ((forced_ego || item.sub_type == ARM_HAT
2237                     || x_chance_in_y(51 + item_level, 250))
2238                 && !item.is_mundane() || force_good)
2239     {
2240         // Make a good item...
2241         item.plus += random2(3);
2242
2243         if (item.sub_type <= ARM_PLATE_ARMOUR
2244             && x_chance_in_y(21 + item_level, 300))
2245         {
2246             item.plus += random2(3);
2247         }
2248
2249         if (!no_ego
2250             && x_chance_in_y(31 + item_level, 350)
2251             && (force_good
2252                 || forced_ego
2253                 || get_equip_race(item) != ISFLAG_ORCISH
2254                 || item.sub_type <= ARM_PLATE_ARMOUR && coinflip()))
2255         {
2256             // ...an ego item, in fact.
2257             set_item_ego_type(item, OBJ_ARMOUR,
2258                               _determine_armour_ego(item, force_type,
2259                                                     item_level));
2260
2261             if (get_armour_ego_type(item) == SPARM_PONDEROUSNESS)
2262                 item.plus += 3 + random2(8);
2263         }
2264     }
2265     else if (one_chance_in(12))
2266     {
2267         // Make a bad (cursed) item.
2268         do_curse_item(item);
2269
2270         if (one_chance_in(5))
2271             item.plus -= random2(3);
2272
2273         set_item_ego_type(item, OBJ_ARMOUR, SPARM_NORMAL);
2274     }
2275
2276     // Make sure you don't get a hide from acquirement (since that
2277     // would be an enchanted item which somehow didn't get converted
2278     // into armour).
2279     if (force_good)
2280         hide2armour(item);
2281
2282     // Don't overenchant items.
2283     if (item.plus > armour_max_enchant(item))
2284         item.plus = armour_max_enchant(item);
2285
2286     if (armour_is_hide(item))
2287     {
2288         do_uncurse_item(item, false);
2289         item.plus = 0;
2290         set_ident_flags(item, ISFLAG_IDENT_MASK);
2291     }
2292 }
2293
2294 static monster_type _choose_random_monster_corpse()
2295 {
2296     for (int count = 0; count < 1000; ++count)
2297     {
2298         monster_type spc = mons_species(static_cast<monster_type>(
2299                                         random2(NUM_MONSTERS)));
2300         if (mons_class_flag(spc, M_NO_POLY_TO | M_CANT_SPAWN))
2301             continue;
2302         if (mons_weight(spc) > 0)        // drops a corpse
2303             return spc;
2304     }
2305
2306     return MONS_RAT;          // if you can't find anything else...
2307 }
2308
2309 static int _random_wand_subtype()
2310 {
2311     int rc = random2(NUM_WANDS);
2312
2313     // Adjusted distribution here -- bwr
2314     // Wands used to be uniform (5.26% each)
2315     //
2316     // Now:
2317     // hasting, heal wounds                                (1.11% each)
2318     // invisibility, enslavement, fireball, teleportation  (3.74% each)
2319     // others                                              (6.37% each)
2320     if (rc == WAND_INVISIBILITY || rc == WAND_HASTING || rc == WAND_HEAL_WOUNDS
2321         || (rc == WAND_INVISIBILITY || rc == WAND_ENSLAVEMENT
2322             || rc == WAND_FIREBALL || rc == WAND_TELEPORTATION) && coinflip())
2323     {
2324         rc = random2(NUM_WANDS);
2325     }
2326     return rc;
2327 }
2328
2329 bool is_high_tier_wand(int type)
2330 {
2331     switch (type)
2332     {
2333     case WAND_PARALYSIS:
2334     case WAND_FIRE:
2335     case WAND_COLD:
2336     case WAND_LIGHTNING:
2337     case WAND_DRAINING:
2338     case WAND_DISINTEGRATION:
2339         return true;
2340     default:
2341         return false;
2342     }
2343 }
2344
2345 static void _generate_wand_item(item_def& item, int force_type, int item_level)
2346 {
2347     // Determine sub_type.
2348     if (force_type != OBJ_RANDOM)
2349         item.sub_type = force_type;
2350     else
2351     {
2352         do
2353             item.sub_type = _random_wand_subtype();
2354         while (item_level < 2 && is_high_tier_wand(item.sub_type));
2355     }
2356
2357     // Generate charges randomly...
2358     item.plus = random2avg(wand_max_charges(item.sub_type), 3);
2359
2360     // ...but 0 charges is silly
2361     if (item.plus == 0)
2362         item.plus++;
2363
2364     // plus2 tracks how many times the player has zapped it.
2365     // If it is -1, then the player knows it's empty.
2366     // If it is -2, then the player has messed with it somehow
2367     // (presumably by recharging), so don't bother to display
2368     // the count.
2369     item.plus2 = 0;
2370 }
2371
2372 static void _generate_food_item(item_def& item, int force_quant, int force_type)
2373 {
2374     // Determine sub_type:
2375     if (force_type == OBJ_RANDOM)
2376     {
2377         item.sub_type = random_choose_weighted(250, FOOD_MEAT_RATION,
2378                                                 300, FOOD_BREAD_RATION,
2379                                                 100, FOOD_PEAR,
2380                                                 100, FOOD_APPLE,
2381                                                 100, FOOD_CHOKO,
2382                                                  10, FOOD_CHEESE,
2383                                                  10, FOOD_PIZZA,
2384                                                  10, FOOD_SNOZZCUMBER,
2385                                                  10, FOOD_APRICOT,
2386                                                  10, FOOD_ORANGE,
2387                                                  10, FOOD_BANANA,
2388                                                  10, FOOD_STRAWBERRY,
2389                                                  10, FOOD_RAMBUTAN,
2390                                                  10, FOOD_LEMON,
2391                                                  10, FOOD_GRAPE,
2392                                                  10, FOOD_SULTANA,
2393                                                  10, FOOD_LYCHEE,
2394                                                  10, FOOD_BEEF_JERKY,
2395                                                  10, FOOD_SAUSAGE,
2396                                                   5, FOOD_HONEYCOMB,
2397                                                   5, FOOD_ROYAL_JELLY,
2398                                                   0);
2399     }
2400     else
2401         item.sub_type = force_type;
2402
2403     // Happens with ghoul food acquirement -- use place_chunks() outherwise
2404     if (item.sub_type == FOOD_CHUNK)
2405     {
2406         // Set chunk flavour:
2407         item.plus = _choose_random_monster_corpse();
2408         item.orig_monnum = item.plus;
2409         // Set duration.
2410         item.special = (10 + random2(11)) * 10;
2411     }
2412
2413     // Determine quantity.
2414     if (force_quant > 1)
2415         item.quantity = force_quant;
2416     else
2417     {
2418         item.quantity = 1;
2419
2420         if (item.sub_type != FOOD_MEAT_RATION
2421             && item.sub_type != FOOD_BREAD_RATION)
2422         {
2423             if (one_chance_in(80))
2424                 item.quantity += random2(3);
2425
2426             if (item.sub_type == FOOD_STRAWBERRY
2427                 || item.sub_type == FOOD_GRAPE
2428                 || item.sub_type == FOOD_SULTANA)
2429             {
2430                 item.quantity += 3 + random2avg(15,2);
2431             }
2432         }
2433     }
2434 }
2435
2436 static void _generate_potion_item(item_def& item, int force_type,
2437                                   int item_level, int agent)
2438 {
2439     item.quantity = 1;
2440
2441     if (one_chance_in(18))
2442         item.quantity++;
2443
2444     if (one_chance_in(25))
2445         item.quantity++;
2446
2447     if (force_type != OBJ_RANDOM)
2448         item.sub_type = force_type;
2449     else
2450     {
2451         int stype;
2452         int tries = 500;
2453         do
2454         {
2455             // total weight is 10000
2456             stype = random_choose_weighted( 2350, POT_CURING,
2457                                             1160, POT_HEAL_WOUNDS,
2458                                              660, POT_RESTORE_ABILITIES,
2459                                              535, POT_POISON,
2460                                              535, POT_MIGHT,
2461                                              535, POT_AGILITY,
2462                                              535, POT_BRILLIANCE,
2463                                              505, POT_SPEED,
2464                                              280, POT_INVISIBILITY,
2465                                              280, POT_FLIGHT,
2466                                              280, POT_RESISTANCE,
2467                                              280, POT_MAGIC,
2468                                              280, POT_BERSERK_RAGE,
2469                                              270, POT_MUTATION,
2470                                              270, POT_LIGNIFY,
2471                                              270, POT_PARALYSIS,
2472                                              270, POT_CONFUSION,
2473                                              230, POT_DEGENERATION,
2474                                              180, POT_CURE_MUTATION,
2475                                              125, POT_STRONG_POISON,
2476                                               90, POT_BENEFICIAL_MUTATION,
2477                                               60, POT_PORRIDGE,
2478                                               10, POT_EXPERIENCE,
2479                                               10, POT_DECAY,
2480                                                0);
2481         }
2482         while (stype == POT_POISON && item_level < 1
2483                || stype == POT_BERSERK_RAGE && item_level < 2
2484                || stype == POT_STRONG_POISON && item_level < 11
2485                || (agent == GOD_XOM && _is_boring_item(OBJ_POTIONS, stype)
2486                    && --tries > 0));
2487
2488         item.sub_type = stype;
2489     }
2490
2491     if (item.sub_type == POT_BENEFICIAL_MUTATION
2492 #if TAG_MAJOR_VERSION == 34
2493         || item.sub_type == POT_GAIN_STRENGTH
2494         || item.sub_type == POT_GAIN_DEXTERITY
2495         || item.sub_type == POT_GAIN_INTELLIGENCE
2496 #endif
2497         || item.sub_type == POT_EXPERIENCE
2498         || item.sub_type == POT_RESTORE_ABILITIES)
2499     {
2500         item.quantity = 1;
2501     }
2502
2503     if (is_blood_potion(item))
2504         init_stack_blood_potions(item);
2505 }
2506
2507 static void _generate_scroll_item(item_def& item, int force_type,
2508                                   int item_level, int agent)
2509 {
2510     // determine sub_type:
2511     if (force_type != OBJ_RANDOM)
2512         item.sub_type = force_type;
2513     else
2514     {
2515         const int depth_mod = random2(1 + item_level);
2516         int tries = 500;
2517         do
2518         {
2519             // total weight: 7824 if depth_mod < 4,
2520             //               8524 if 4 <= depth_mod < 7,
2521             //               8944 if depth_mod >= 7,
2522             //               and -1133 in sprint
2523             item.sub_type = random_choose_weighted(
2524                 1800, SCR_IDENTIFY,
2525                 1250, SCR_REMOVE_CURSE,
2526                  // [Cha] don't generate teleportation scrolls if in sprint
2527                  802, (crawl_state.game_is_sprint() ? NUM_SCROLLS : SCR_TELEPORTATION),
2528                  331, SCR_FEAR,
2529                  331, SCR_MAGIC_MAPPING,
2530                  331, SCR_FOG,
2531                  331, SCR_RANDOM_USELESSNESS,
2532                  331, SCR_RECHARGING,
2533                  331, SCR_BLINKING,
2534                  331, SCR_ENCHANT_ARMOUR,
2535                  331, SCR_ENCHANT_WEAPON_I,
2536                  331, SCR_ENCHANT_WEAPON_II,
2537                  331, SCR_AMNESIA,
2538                  // [Cha] don't generate noise scrolls if in sprint
2539                  331, (crawl_state.game_is_sprint() ? NUM_SCROLLS : SCR_NOISE),
2540
2541                  331, SCR_IMMOLATION,
2542
2543                  // Medium-level scrolls.
2544                  140, (depth_mod < 4 ? NUM_SCROLLS : SCR_ACQUIREMENT),
2545                  140, (depth_mod < 4 ? NUM_SCROLLS : SCR_ENCHANT_WEAPON_III),
2546                  140, (depth_mod < 4 ? NUM_SCROLLS : SCR_SUMMONING),
2547                  140, (depth_mod < 4 ? NUM_SCROLLS : SCR_SILENCE),
2548                  140, (depth_mod < 4 ? NUM_SCROLLS : SCR_VULNERABILITY),
2549
2550                  // High-level scrolls.
2551                  140, (depth_mod < 7 ? NUM_SCROLLS : SCR_BRAND_WEAPON),
2552                  140, (depth_mod < 7 ? NUM_SCROLLS : SCR_TORMENT),
2553                  140, (depth_mod < 7 ? NUM_SCROLLS : SCR_HOLY_WORD),
2554
2555                  0);
2556         }
2557         while (item.sub_type == NUM_SCROLLS
2558                || agent == GOD_XOM
2559                && _is_boring_item(OBJ_SCROLLS, item.sub_type)
2560                && --tries > 0);
2561     }
2562
2563     // determine quantity
2564     if (item.sub_type == SCR_BRAND_WEAPON
2565         || item.sub_type == SCR_ENCHANT_WEAPON_III
2566         || item.sub_type == SCR_ACQUIREMENT
2567         || item.sub_type == SCR_TORMENT
2568         || item.sub_type == SCR_HOLY_WORD
2569         || item.sub_type == SCR_SILENCE)
2570     {
2571         item.quantity = 1;
2572     }
2573     else
2574     {
2575         if (one_chance_in(24))
2576             item.quantity = (coinflip() ? 2 : 3);
2577         else
2578             item.quantity = 1;
2579     }
2580
2581     item.plus = 0;
2582 }
2583
2584 static void _generate_book_item(item_def& item, bool allow_uniques,
2585                                 int force_type, int item_level)
2586 {
2587     // determine special (description)
2588     item.special = random2(5);
2589
2590     if (one_chance_in(10))
2591         item.special += random2(NDSC_BOOK_SEC) * NDSC_BOOK_PRI;
2592
2593     if (force_type != OBJ_RANDOM)
2594         item.sub_type = force_type;
2595     else
2596     {
2597         do
2598         {
2599             item.sub_type = random2(NUM_FIXED_BOOKS);
2600
2601             if (book_rarity(item.sub_type) != 100
2602                 && one_chance_in(25))
2603             {
2604                 item.sub_type = coinflip() ? BOOK_WIZARDRY : BOOK_POWER;
2605             }
2606
2607             if (!one_chance_in(100)
2608                 && x_chance_in_y(book_rarity(item.sub_type)-1, item_level+1))
2609             {
2610                 // If this book is really rare for this depth, continue trying.
2611                 continue;
2612             }
2613         }
2614         while (book_rarity(item.sub_type) == 100);
2615
2616         // Tome of destruction: rare!
2617         if (item_level > 10 && x_chance_in_y(21 + item_level, 7000))
2618             item.sub_type = BOOK_DESTRUCTION;
2619
2620         // Skill manuals - also rare.
2621         if (item_level > 6 && x_chance_in_y(21 + item_level, 4000))
2622             item.sub_type = BOOK_MANUAL;
2623     }
2624
2625     // Determine which skill for a manual.
2626     if (item.sub_type == BOOK_MANUAL)
2627     {
2628         if (one_chance_in(4))
2629             item.plus = SK_SPELLCASTING + random2(NUM_SKILLS - SK_SPELLCASTING);
2630         else
2631 #if TAG_MAJOR_VERSION == 34
2632         {
2633             item.plus = random2(SK_UNARMED_COMBAT);
2634             if (item.plus == SK_STABBING)
2635                 item.plus = SK_UNARMED_COMBAT;
2636             if (item.plus == SK_TRAPS)
2637                 item.plus = SK_STEALTH;
2638         }
2639 #else
2640             item.plus = random2(SK_UNARMED_COMBAT + 1);
2641 #endif
2642         // Set number of bonus skill points.
2643         item.plus2 = random_range(2000, 3000);
2644     }
2645
2646     // Manuals and books of destruction are rare enough without replacing
2647     // them with randart books.
2648     if (item.sub_type == BOOK_MANUAL || item.sub_type == BOOK_DESTRUCTION)
2649         return;
2650
2651     // Only randomly generate randart books for OBJ_RANDOM, since randart
2652     // spellbooks aren't merely of-the-same-type-but-better, but
2653     // have an entirely different set of spells.
2654     if (allow_uniques && item_level > 2 && force_type == OBJ_RANDOM
2655         && x_chance_in_y(101 + item_level * 3, 4000))
2656     {
2657         int choice = random_choose_weighted(
2658             58, BOOK_RANDART_THEME,
2659              2, BOOK_RANDART_LEVEL, // 1/30
2660              0);
2661
2662         item.sub_type = choice;
2663     }
2664
2665     if (item.sub_type == BOOK_RANDART_THEME)
2666         make_book_theme_randart(item, 0, 0, 5 + coinflip(), 20);
2667     else if (item.sub_type == BOOK_RANDART_LEVEL)
2668     {
2669         int max_level  = min(9, max(1, item_level / 3));
2670         int spl_level  = random_range(1, max_level);
2671         make_book_level_randart(item, spl_level);
2672     }
2673 }
2674
2675 static void _generate_staff_item(item_def& item, bool allow_uniques, int force_type, int item_level)
2676 {
2677     // If we make the unique roll, no further generation necessary.
2678     // Copied unrand code from _try_make_weapon_artefact since randart enhancer staves
2679     // can't happen.
2680     if (allow_uniques
2681         && one_chance_in(item_level == MAKE_GOOD_ITEM ? 27 : 100))
2682     {
2683         // Temporarily fix the base_type to get enhancer staves
2684         item.base_type = OBJ_WEAPONS;
2685         if (_try_make_item_unrand(item, WPN_STAFF))
2686             return;
2687         item.base_type = OBJ_STAVES;
2688     }
2689
2690     if (force_type == OBJ_RANDOM)
2691     {
2692 #if TAG_MAJOR_VERSION == 34
2693         do
2694             item.sub_type = random2(NUM_STAVES);
2695         while (item.sub_type == STAFF_ENCHANTMENT
2696                || item.sub_type == STAFF_CHANNELING);
2697 #else
2698         item.sub_type = random2(NUM_STAVES);
2699 #endif
2700
2701         // staves of energy are 25% less common, wizardry/power
2702         // are more common
2703         if (item.sub_type == STAFF_ENERGY && one_chance_in(4))
2704             item.sub_type = coinflip() ? STAFF_WIZARDRY : STAFF_POWER;
2705     }
2706     else
2707         item.sub_type = force_type;
2708
2709     if (one_chance_in(16))
2710         do_curse_item(item);
2711 }
2712
2713 static void _generate_rod_item(item_def& item, int force_type, int item_level)
2714 {
2715     if (force_type == OBJ_RANDOM)
2716 #if TAG_MAJOR_VERSION == 34
2717     {
2718         do
2719             item.sub_type = random2(NUM_RODS);
2720         while (item.sub_type == ROD_WARDING || item.sub_type == ROD_VENOM);
2721     }
2722 #else
2723         item.sub_type = random2(NUM_RODS);
2724 #endif
2725     else
2726         item.sub_type = force_type;
2727
2728     init_rod_mp(item, -1, item_level);
2729
2730     if (one_chance_in(16))
2731         do_curse_item(item);
2732 }
2733
2734 static bool _try_make_jewellery_unrandart(item_def& item, int force_type,
2735                                           int item_level)
2736 {
2737     int type = (force_type == NUM_RINGS)     ? get_random_ring_type() :
2738                (force_type == NUM_JEWELLERY) ? get_random_amulet_type()
2739                                              : force_type;
2740     if (item_level > 2
2741         && one_chance_in(20)
2742         && x_chance_in_y(101 + item_level * 3, 2000))
2743     {
2744         if (_try_make_item_unrand(item, type))
2745             return true;
2746     }
2747
2748     return false;
2749 }
2750
2751 static int _determine_ring_plus(int subtype)
2752 {
2753     int rc = 0;
2754
2755     switch (subtype)
2756     {
2757     case RING_PROTECTION:
2758     case RING_STRENGTH:
2759     case RING_SLAYING:
2760     case RING_EVASION:
2761     case RING_DEXTERITY:
2762     case RING_INTELLIGENCE:
2763         if (one_chance_in(5))       // 20% of such rings are cursed {dlb}
2764         {
2765             rc = (coinflip() ? -2 : -3);
2766
2767             if (one_chance_in(3))
2768                 rc -= random2(4);
2769         }
2770         else
2771             rc = 1 + (one_chance_in(3) ? random2(3) : random2avg(6, 2));
2772         break;
2773
2774     default:
2775         break;
2776     }
2777     return rc;
2778 }
2779
2780 static void _generate_jewellery_item(item_def& item, bool allow_uniques,
2781                                      int force_type, int item_level,
2782                                      int agent)
2783 {
2784     if (allow_uniques && item_level != ISPEC_RANDART
2785         && _try_make_jewellery_unrandart(item, force_type, item_level))
2786     {
2787         return;
2788     }
2789
2790     // Determine subtype.
2791     // Note: removed double probability reduction for some subtypes
2792     if (force_type != OBJ_RANDOM
2793         && force_type != NUM_RINGS
2794         && force_type != NUM_JEWELLERY)
2795         item.sub_type = force_type;
2796     else
2797     {
2798         int tries = 500;
2799         do
2800         {
2801             if (force_type == NUM_RINGS)
2802                 item.sub_type = get_random_ring_type();
2803             else if (force_type == NUM_JEWELLERY)
2804                 item.sub_type = get_random_amulet_type();
2805             else
2806                 item.sub_type = (one_chance_in(4) ? get_random_amulet_type()
2807                                                   : get_random_ring_type());
2808         }
2809         while (agent == GOD_XOM
2810                && _is_boring_item(OBJ_JEWELLERY, item.sub_type)
2811                && --tries > 0);
2812     }
2813
2814     // Everything begins as uncursed, unenchanted jewellery {dlb}:
2815     item.plus  = 0;
2816     item.plus2 = 0;
2817
2818     item.plus = _determine_ring_plus(item.sub_type);
2819     if (item.plus < 0)
2820         do_curse_item(item);
2821
2822     if (item.sub_type == RING_SLAYING) // requires plus2 too
2823     {
2824         if (item.cursed() && !one_chance_in(20))
2825         {
2826             item.plus2 = (coinflip() ? -2 : -3);
2827             if (one_chance_in(3))
2828                 item.plus2 -= random2(4);
2829         }
2830         else
2831         {
2832             if (item.plus > 0)
2833             {
2834                 item.plus = 2 + (one_chance_in(3) ? random2(4)
2835                                                   : 1 + random2avg(5, 2));
2836             }
2837             item.plus2 = 2 + (one_chance_in(3) ? random2(4)
2838                                                : 1 + random2avg(5, 2));
2839
2840             if (x_chance_in_y(9, 25))        // 36% of such rings {dlb}
2841             {
2842                 // make "ring of damage"
2843                 do_uncurse_item(item, false);
2844                 item.plus   = 0;
2845                 item.plus2 += 2;
2846             }
2847         }
2848     }
2849
2850     // All jewellery base types should now work. - bwr
2851     if (item_level == ISPEC_RANDART
2852         || allow_uniques && item_level > 2
2853            && x_chance_in_y(101 + item_level * 3, 4000))
2854     {
2855         make_item_randart(item);
2856     }
2857     else if (item.sub_type == RING_HUNGER || item.sub_type == RING_TELEPORTATION
2858              || one_chance_in(50))
2859     {
2860         // Rings of hunger and teleportation are always cursed {dlb}:
2861         do_curse_item(item);
2862     }
2863 }
2864
2865 static void _generate_misc_item(item_def& item, int force_type, int force_ego)
2866 {
2867     if (force_type != OBJ_RANDOM)
2868         item.sub_type = force_type;
2869     else
2870     {
2871         do
2872             item.sub_type = random2(NUM_MISCELLANY);
2873         while
2874             // never randomly generated
2875             (item.sub_type == MISC_RUNE_OF_ZOT
2876              || item.sub_type == MISC_HORN_OF_GERYON
2877              || item.sub_type == MISC_DECK_OF_PUNISHMENT
2878              || item.sub_type == MISC_QUAD_DAMAGE
2879 #if TAG_MAJOR_VERSION == 34
2880              || item.sub_type == MISC_BUGGY_EBONY_CASKET
2881              || item.sub_type == MISC_BOTTLED_EFREET
2882 #endif
2883              // Nemelex' decks are rare in the dungeon.
2884              || (item.sub_type == MISC_DECK_OF_ESCAPE
2885                     || item.sub_type == MISC_DECK_OF_DESTRUCTION
2886                     || item.sub_type == MISC_DECK_OF_SUMMONING
2887                     || item.sub_type == MISC_DECK_OF_WONDERS)
2888                  && !one_chance_in(5));
2889     }
2890
2891     // Pick number of beasts in the box
2892     if (item.sub_type == MISC_BOX_OF_BEASTS)
2893         item.plus = random_range(5, 15, 2);
2894
2895     // Spider sack charges
2896     if (item.sub_type == MISC_SACK_OF_SPIDERS)
2897         item.plus = random_range(5, 15, 2);
2898
2899     if (is_deck(item))
2900     {
2901         item.plus = 4 + random2(10);
2902         if (force_ego >= DECK_RARITY_COMMON && force_ego <= DECK_RARITY_LEGENDARY)
2903             item.special = force_ego;
2904         else
2905         {
2906             item.special = random_choose_weighted(8, DECK_RARITY_LEGENDARY,
2907                                                  20, DECK_RARITY_RARE,
2908                                                  72, DECK_RARITY_COMMON,
2909                                                   0);
2910         }
2911         init_deck(item);
2912     }
2913 }
2914
2915 // Returns item slot or NON_ITEM if it fails.
2916 int items(bool allow_uniques,
2917           object_class_type force_class, // desired OBJECTS class {dlb}
2918           int force_type,          // desired SUBTYPE - enum varies by OBJ
2919           bool dont_place,         // don't randomly place item on level
2920           int item_level,          // level of the item, can differ from global
2921           int item_race,           // weapon / armour racial categories
2922                                    // item_race also gives type of rune!
2923           uint32_t mapmask,
2924           int force_ego,           // desired ego/brand
2925           int agent,               // acquirement agent, if not -1
2926           bool mundane)            // no plusses
2927 {
2928     ASSERT(force_ego <= 0
2929            || force_class == OBJ_WEAPONS
2930            || force_class == OBJ_ARMOUR
2931            || force_class == OBJ_MISSILES
2932            || force_class == OBJ_MISCELLANY
2933               && force_type >= MISC_FIRST_DECK
2934               && force_type <= MISC_LAST_DECK);
2935
2936     // Find an empty slot for the item (with culling if required).
2937     int p = get_mitm_slot(10);
2938     if (p == NON_ITEM)
2939         return NON_ITEM;
2940
2941     item_def& item(mitm[p]);
2942
2943     const bool force_good = item_level >= MAKE_GIFT_ITEM;
2944
2945     if (force_ego != 0)
2946         allow_uniques = false;
2947
2948     item.special = force_ego;
2949
2950     // cap item_level unless an acquirement-level item {dlb}:
2951     if (item_level > 50 && !force_good)
2952         item_level = 50;
2953
2954     // determine base_type for item generated {dlb}:
2955     if (force_class != OBJ_RANDOM)
2956     {
2957         ASSERT(force_class < NUM_OBJECT_CLASSES);
2958         item.base_type = force_class;
2959     }
2960     else
2961     {
2962         ASSERT(force_type == OBJ_RANDOM);
2963         item.base_type = random_choose_weighted(
2964                                      1, OBJ_RODS,
2965                                      9, OBJ_STAVES,
2966                                     30, OBJ_BOOKS,
2967                                     50, OBJ_JEWELLERY,
2968                                     70, OBJ_WANDS,
2969                                    140, OBJ_FOOD,
2970                                    200, OBJ_ARMOUR,
2971                                    200, OBJ_WEAPONS,
2972                                    200, OBJ_POTIONS,
2973                                    300, OBJ_MISSILES,
2974                                    360, OBJ_SCROLLS,
2975                                    400, OBJ_GOLD,
2976                                      0);
2977
2978         // misc items placement wholly dependent upon current depth {dlb}:
2979         if (item_level > 7 && x_chance_in_y(21 + item_level, 3500))
2980             item.base_type = OBJ_MISCELLANY;
2981
2982         if (item_level < 7
2983             && (item.base_type == OBJ_BOOKS
2984                 || item.base_type == OBJ_STAVES
2985                 || item.base_type == OBJ_RODS
2986                 || item.base_type == OBJ_WANDS)
2987             && random2(7) >= item_level)
2988         {
2989             item.base_type = coinflip() ? OBJ_POTIONS : OBJ_SCROLLS;
2990         }
2991     }
2992
2993     ASSERT(force_type == OBJ_RANDOM
2994            || item.base_type == OBJ_JEWELLERY && force_type == NUM_JEWELLERY
2995            || force_type < get_max_subtype(item.base_type));
2996
2997     item.quantity = 1;          // generally the case
2998
2999     // make_item_randart() might do things differently based upon the
3000     // acquirement agent, especially for god gifts.
3001     if (agent != -1 && !is_stackable_item(item))
3002         origin_acquired(item, agent);
3003
3004     if (force_ego < SP_FORBID_EGO)
3005     {
3006         force_ego = -force_ego;
3007         if (get_unique_item_status(force_ego) == UNIQ_NOT_EXISTS)
3008         {
3009             make_item_unrandart(mitm[p], force_ego);
3010             ASSERT(mitm[p].is_valid());
3011             return p;
3012         }
3013         // the base item otherwise
3014         item.special = SPWPN_NORMAL;
3015         force_ego = 0;
3016     }
3017
3018     // Determine sub_type accordingly. {dlb}
3019     switch (item.base_type)
3020     {
3021     case OBJ_WEAPONS:
3022         _generate_weapon_item(item, allow_uniques, force_type,
3023                               item_level);
3024         break;
3025
3026     case OBJ_MISSILES:
3027         _generate_missile_item(item, force_type, item_level);
3028         break;
3029
3030     case OBJ_ARMOUR:
3031         _generate_armour_item(item, allow_uniques, force_type,
3032                               item_level, item_race);
3033         break;
3034
3035     case OBJ_WANDS:
3036         _generate_wand_item(item, force_type, item_level);
3037         break;
3038
3039     case OBJ_FOOD:
3040         _generate_food_item(item, allow_uniques, force_type);
3041         break;
3042
3043     case OBJ_POTIONS:
3044         _generate_potion_item(item, force_type, item_level, agent);
3045         break;
3046
3047     case OBJ_SCROLLS:
3048         _generate_scroll_item(item, force_type, item_level, agent);
3049         break;
3050
3051     case OBJ_JEWELLERY:
3052         _generate_jewellery_item(item, allow_uniques, force_type, item_level,
3053                                  agent);
3054         break;
3055
3056     case OBJ_BOOKS:
3057         _generate_book_item(item, allow_uniques, force_type, item_level);
3058         break;
3059
3060     case OBJ_STAVES:
3061         _generate_staff_item(item, allow_uniques, force_type, item_level);
3062         break;
3063
3064     case OBJ_RODS:
3065         _generate_rod_item(item, force_type, item_level);
3066         break;
3067
3068     case OBJ_ORBS:              // always forced in current setup {dlb}
3069         item.sub_type = force_type;
3070         break;
3071
3072     case OBJ_MISCELLANY:
3073         _generate_misc_item(item, force_type, force_ego);
3074         break;
3075
3076     // that is, everything turns to gold if not enumerated above, so ... {dlb}
3077     default:
3078         item.base_type = OBJ_GOLD;
3079         if (force_good)
3080             item.quantity = 100 + random2(400);
3081         else
3082             item.quantity = 1 + random2avg(19, 2) + random2(item_level);
3083         break;
3084     }
3085
3086     if (mundane)
3087     {
3088         ASSERT(!is_deck(item));
3089         item.plus    = 0;
3090         item.plus2   = 0;
3091         item.special = 0;
3092     }
3093
3094     if (item.base_type == OBJ_WEAPONS
3095           && !is_weapon_brand_ok(item.sub_type, get_weapon_brand(item), false)
3096         || item.base_type == OBJ_ARMOUR
3097           && !is_armour_brand_ok(item.sub_type, get_armour_ego_type(item), false)
3098         || item.base_type == OBJ_MISSILES
3099           && !is_missile_brand_ok(item.sub_type, item.special, false))
3100     {
3101         mprf(MSGCH_ERROR, "Invalid brand on item %s, annulling.",
3102             item.name(DESC_PLAIN, false, true, false, false, ISFLAG_KNOW_PLUSES
3103                       | ISFLAG_KNOW_CURSE).c_str());
3104         item.special = 0;
3105     }
3106
3107     // Colour the item.
3108     item_colour(item);
3109
3110     // Set brand appearance.
3111     item_set_appearance(item);
3112
3113     if (dont_place)
3114     {
3115         item.pos.reset();
3116         item.link = NON_ITEM;
3117     }
3118     else
3119     {
3120         coord_def itempos;
3121         bool found = false;
3122         for (int i = 0; i < 500 && !found; ++i)
3123         {
3124             itempos = random_in_bounds();
3125             const monster* mon = monster_at(itempos);
3126             found = grd(itempos) == DNGN_FLOOR
3127                     && !map_masked(itempos, mapmask)
3128                     // oklobs or statues are ok
3129                     && (!mon || !mons_is_firewood(mon));
3130         }
3131         if (!found)
3132         {
3133             // Couldn't find a single good spot!
3134             destroy_item(p);
3135             return NON_ITEM;
3136         }
3137         move_item_to_grid(&p, itempos);
3138     }
3139
3140     // Note that item might be invalidated now, since p could have changed.
3141     ASSERT(mitm[p].is_valid());
3142     return p;
3143 }
3144
3145 void reroll_brand(item_def &item, int item_level)
3146 {
3147     ASSERT(!is_artefact(item));
3148     switch (item.base_type)
3149     {
3150     case OBJ_WEAPONS:
3151         item.special = _determine_weapon_brand(item, item_level);
3152         break;
3153     case OBJ_MISSILES:
3154         item.special = _determine_missile_brand(item, item_level);
3155         break;
3156     case OBJ_ARMOUR:
3157         // Robe of the Archmagi has an ugly hack of unknown purpose,
3158         // as one of side effects it won't ever generate here.
3159         item.special = _determine_armour_ego(item, OBJ_ARMOUR, item_level);
3160         break;
3161     default:
3162         die("can't reroll brands of this type");
3163     }
3164     item_set_appearance(item);
3165 }
3166
3167 static int _roll_rod_enchant(int item_level)
3168 {
3169     int value = 0;
3170
3171     if (one_chance_in(4))
3172         value -= random_range(1, 3);
3173
3174     if (item_level >= MAKE_GIFT_ITEM)
3175         value += 2;
3176
3177     int pr = 20 + item_level * 2;
3178
3179     if (pr > 80)
3180         pr = 80;
3181
3182     while (random2(100) < pr) value++;
3183
3184     return stepdown_value(value, 4, 4, 4, 9);
3185 }
3186
3187 void init_rod_mp(item_def &item, int ncharges, int item_level)
3188 {
3189     ASSERT(item.base_type == OBJ_RODS);
3190
3191     if (ncharges != -1)
3192     {
3193         item.plus2 = ncharges * ROD_CHARGE_MULT;
3194         item.special = 0;
3195     }
3196     else
3197     {
3198         item.plus2 = random_range(9, 14) * ROD_CHARGE_MULT;
3199         item.special = _roll_rod_enchant(item_level);
3200     }
3201
3202     item.plus = item.plus2;
3203 }
3204
3205 static bool _weapon_is_visibly_special(const item_def &item)
3206 {
3207     const int brand = get_weapon_brand(item);
3208     const bool visibly_branded = (brand != SPWPN_NORMAL);
3209
3210     if (get_equip_desc(item) != ISFLAG_NO_DESC)
3211         return false;
3212
3213     if (visibly_branded || is_artefact(item))
3214         return true;
3215
3216     if (item.is_mundane())
3217         return false;
3218
3219     if (x_chance_in_y(item.plus - 2, 3) || x_chance_in_y(item.plus2 - 2, 3))
3220         return true;
3221
3222     if (item.flags & ISFLAG_CURSED && one_chance_in(3))
3223         return true;
3224
3225     return false;
3226 }
3227
3228 static bool _armour_is_visibly_special(const item_def &item)
3229 {
3230     const int brand = get_armour_ego_type(item);
3231     const bool visibly_branded = (brand != SPARM_NORMAL);
3232
3233     if (get_equip_desc(item) != ISFLAG_NO_DESC)
3234         return false;
3235
3236     if (visibly_branded || is_artefact(item))
3237         return true;
3238
3239     if (item.is_mundane())
3240         return false;
3241
3242     if (x_chance_in_y(item.plus - 2, 3))
3243         return true;
3244
3245     if (item.flags & ISFLAG_CURSED && one_chance_in(3))
3246         return true;
3247
3248     return false;
3249 }
3250
3251 jewellery_type get_random_amulet_type()
3252 {
3253 #if TAG_MAJOR_VERSION == 34
3254     int res;
3255     do
3256         res = (AMU_FIRST_AMULET + random2(NUM_JEWELLERY - AMU_FIRST_AMULET));
3257     // Do not generate cFly
3258     while (res == AMU_CONTROLLED_FLIGHT);
3259
3260     return jewellery_type(res);
3261 #else
3262     return static_cast<jewellery_type>(AMU_FIRST_AMULET
3263            + random2(NUM_JEWELLERY - AMU_FIRST_AMULET));
3264 #endif
3265 }
3266
3267 static jewellery_type _get_raw_random_ring_type()
3268 {
3269     jewellery_type ring;
3270     do ring = (jewellery_type)(RING_REGENERATION + random2(NUM_RINGS));
3271         while (ring == RING_TELEPORTATION && crawl_state.game_is_sprint());
3272     return ring;
3273 }
3274
3275 jewellery_type get_random_ring_type()
3276 {
3277     const jewellery_type j = _get_raw_random_ring_type();
3278     // Adjusted distribution here. - bwr
3279     if ((j == RING_INVISIBILITY
3280            || j == RING_REGENERATION
3281            || j == RING_TELEPORT_CONTROL
3282            || j == RING_SLAYING)
3283         && !one_chance_in(3))
3284     {
3285         return _get_raw_random_ring_type();
3286     }
3287
3288     return j;
3289 }
3290
3291 // FIXME: Need to clean up this mess.
3292 static armour_type _get_random_armour_type(int item_level)
3293 {
3294     // Default (lowest-level) armours.
3295     const armour_type defarmours[] = { ARM_ROBE, ARM_LEATHER_ARMOUR,
3296                                        ARM_RING_MAIL };
3297
3298     int armtype = RANDOM_ELEMENT(defarmours);
3299
3300     if (x_chance_in_y(11 + item_level, 35))
3301     {
3302         // Low-level armours.
3303         const armour_type lowarmours[] = { ARM_ROBE, ARM_LEATHER_ARMOUR,
3304                                            ARM_RING_MAIL, ARM_SCALE_MAIL,
3305                                            ARM_CHAIN_MAIL };
3306
3307         armtype = RANDOM_ELEMENT(lowarmours);
3308     }
3309
3310     if (x_chance_in_y(11 + item_level, 60))
3311     {
3312         // Medium-level armours.
3313         const armour_type medarmours[] = { ARM_ROBE, ARM_LEATHER_ARMOUR,
3314                                            ARM_RING_MAIL, ARM_SCALE_MAIL,
3315                                            ARM_CHAIN_MAIL, ARM_PLATE_ARMOUR };
3316
3317         armtype = RANDOM_ELEMENT(medarmours);
3318     }
3319
3320     if (one_chance_in(20) && x_chance_in_y(11 + item_level, 400))
3321     {
3322         // High-level armours, including troll and some dragon armours.
3323         const armour_type hiarmours[] = { ARM_CRYSTAL_PLATE_ARMOUR,
3324                                           ARM_TROLL_HIDE,
3325                                           ARM_TROLL_LEATHER_ARMOUR,
3326                                           ARM_FIRE_DRAGON_HIDE, ARM_FIRE_DRAGON_ARMOUR,
3327                                           ARM_ICE_DRAGON_HIDE,
3328                                           ARM_ICE_DRAGON_ARMOUR };
3329
3330         armtype = RANDOM_ELEMENT(hiarmours);
3331     }
3332
3333     if (one_chance_in(20) && x_chance_in_y(11 + item_level, 500))
3334     {
3335         // Animal skins and high-level armours, including the rest of
3336         // the dragon armours.
3337         const armour_type morehiarmours[] = { ARM_STEAM_DRAGON_HIDE,
3338                                               ARM_STEAM_DRAGON_ARMOUR,
3339                                               ARM_MOTTLED_DRAGON_HIDE,
3340                                               ARM_MOTTLED_DRAGON_ARMOUR,
3341                                               ARM_STORM_DRAGON_HIDE,
3342                                               ARM_STORM_DRAGON_ARMOUR,
3343                                               ARM_GOLD_DRAGON_HIDE,
3344                                               ARM_GOLD_DRAGON_ARMOUR,
3345                                               ARM_SWAMP_DRAGON_HIDE,
3346                                               ARM_SWAMP_DRAGON_ARMOUR,
3347                                               ARM_PEARL_DRAGON_HIDE,
3348                                               ARM_PEARL_DRAGON_ARMOUR, };
3349
3350         armtype = RANDOM_ELEMENT(morehiarmours);
3351
3352         if (one_chance_in(200))
3353             armtype = ARM_CRYSTAL_PLATE_ARMOUR;
3354     }
3355
3356     // Secondary armours.
3357     if (one_chance_in(5))
3358     {
3359         const armour_type secarmours[] = { ARM_SHIELD, ARM_CLOAK, ARM_HELMET,
3360                                            ARM_GLOVES, ARM_BOOTS };
3361
3362         armtype = RANDOM_ELEMENT(secarmours);
3363
3364         if (armtype == ARM_HELMET && one_chance_in(3))
3365         {
3366             const armour_type hats[] = { ARM_HAT, ARM_HELMET };
3367
3368             armtype = RANDOM_ELEMENT(hats);
3369         }
3370         else if (armtype == ARM_SHIELD)
3371         {
3372             armtype = random_choose_weighted(333, ARM_SHIELD,
3373                                              500, ARM_BUCKLER,
3374                                              167, ARM_LARGE_SHIELD,
3375                                                0);
3376         }
3377     }
3378
3379     return static_cast<armour_type>(armtype);
3380 }
3381
3382 // Sets item appearance to match brands, if any.
3383 void item_set_appearance(item_def &item)
3384 {
3385     // Artefact appearance overrides cosmetic flags anyway.
3386     if (is_artefact(item))
3387         return;
3388
3389     if (get_equip_desc(item) != ISFLAG_NO_DESC)
3390         return;
3391
3392     switch (item.base_type)
3393     {
3394     case OBJ_WEAPONS:
3395         if (_weapon_is_visibly_special(item))
3396         {
3397             set_equip_desc(item,
3398                            (coinflip() ? ISFLAG_GLOWING : ISFLAG_RUNED));
3399         }
3400         break;
3401
3402     case OBJ_ARMOUR:
3403         if (_armour_is_visibly_special(item))
3404         {
3405             const item_status_flag_type descs[] = { ISFLAG_GLOWING,
3406                                                     ISFLAG_RUNED,
3407                                                     ISFLAG_EMBROIDERED_SHINY };
3408
3409             set_equip_desc(item, RANDOM_ELEMENT(descs));
3410         }
3411         break;
3412
3413     default:
3414         break;
3415     }
3416 }
3417
3418 void maybe_set_armour_race(item_def &item, int allowed, int num_rolls)
3419 {
3420     ASSERT(item.base_type == OBJ_ARMOUR);
3421
3422     if (!allowed)
3423         return;
3424
3425     while (num_rolls-- > 0)
3426     {
3427         iflags_t irace = 0;
3428         irace = _determine_armour_race(item, MAKE_ITEM_RANDOM_RACE);
3429         if (!(allowed & irace))
3430             continue;
3431         dprf("Extra race roll passed!");
3432         set_equip_race(item, irace);
3433         return;
3434     }
3435 }
3436
3437 #if defined(DEBUG_DIAGNOSTICS) || defined(DEBUG_TESTS)
3438 static int _test_item_level()
3439 {
3440     switch (random2(10))
3441     {
3442     case 0:
3443         return MAKE_GOOD_ITEM;
3444     case 1:
3445         return ISPEC_DAMAGED;
3446     case 2:
3447         return ISPEC_BAD;
3448     case 3:
3449         return ISPEC_RANDART;
3450     default:
3451         return random2(50);
3452     }
3453 }
3454
3455 void makeitem_tests()
3456 {
3457     int i, level;
3458     item_def item;
3459
3460     mpr("Running generate_weapon_item tests.");
3461     for (i = 0; i < 10000; ++i)
3462     {
3463         item.clear();
3464         level = _test_item_level();
3465         item.base_type = OBJ_WEAPONS;
3466         if (coinflip())
3467             item.special = SPWPN_NORMAL;
3468         else
3469             item.special = random2(NUM_REAL_SPECIAL_WEAPONS);
3470 #if TAG_MAJOR_VERSION == 34
3471         if (item.special == SPWPN_ORC_SLAYING
3472             || item.special == SPWPN_REACHING
3473             || item.special == SPWPN_RETURNING
3474             || item.special == SPWPN_CONFUSE)
3475         {
3476             item.special = SPWPN_FORBID_BRAND;
3477         }
3478 #endif
3479         _generate_weapon_item(item,
3480                               coinflip(),
3481                               coinflip() ? OBJ_RANDOM : random2(NUM_WEAPONS),
3482                               level);
3483     }
3484
3485     mpr("Running generate_armour_item tests.");
3486     for (i = 0; i < 10000; ++i)
3487     {
3488         item.clear();
3489         level = _test_item_level();
3490         item.base_type = OBJ_ARMOUR;
3491         if (coinflip())
3492             item.special = SPARM_NORMAL;
3493         else
3494             item.special = random2(NUM_REAL_SPECIAL_ARMOURS);
3495         int type = coinflip() ? OBJ_RANDOM : random2(NUM_ARMOURS);
3496 #if TAG_MAJOR_VERSION == 34
3497         if (type == ARM_CAP)
3498             type = ARM_HAT;
3499 #endif
3500         _generate_armour_item(item,
3501                               coinflip(),
3502                               type,
3503                               level,
3504                               MAKE_ITEM_RANDOM_RACE);
3505     }
3506 }
3507 #endif