src/flavor.c

   1 /* Purpose: Object flavor code */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   5  *
   6  * This software may be copied and distributed for educational, research,
   7  * and not for profit purposes provided that this copyright and statement
   8  * are included in all such copies.  Other copyrights may also apply.
   9  */
  10
  11 #include "angband.h"
  12
  13
  14 /*
  15  * Hack -- note that "TERM_MULTI" is now just "TERM_VIOLET".
  16  * We will have to find a cleaner method for "MULTI_HUED" later.
  17  * There were only two multi-hued "flavors" (one potion, one food).
  18  * Plus five multi-hued "base-objects" (3 dragon scales, one blade
  19  * of chaos, and one something else).  See the SHIMMER_OBJECTS code
  20  * in "dungeon.c" and the object color extractor in "cave.c".
  21  */
  22 #define TERM_MULTI      TERM_VIOLET
  23
  24
  25 /*
  26  * Max sizes of the following arrays
  27  */
  28 #define MAX_ROCKS      59       /* Used with rings (min 38) */
  29 #define MAX_AMULETS    26       /* Used with amulets (min 14) */
  30 #define MAX_WOODS      34       /* Used with staffs (min 30) */
  31 #define MAX_METALS     40       /* Used with wands/rods (min 29/29) */
  32 #define MAX_COLORS     70       /* Used with potions (min 60) */
  33 #define MAX_SHROOM     20       /* Used with mushrooms (min 20) */
  34 #define MAX_TITLES     55       /* Used with scrolls (min 48) */
  35 #define MAX_SYLLABLES 164       /* Used with scrolls (see below) */
  36
  37
  38 /*
  39  * Rings (adjectives and colors)
  40  */
  41
  42 static cptr ring_adj[MAX_ROCKS]
  43 #ifndef JP
  44 = {
  45         "Alexandrite", "Amethyst", "Aquamarine", "Azurite", "Beryl",
  46         "Bloodstone", "Calcite", "Carnelian", "Corundum", "Diamond",
  47         "Emerald", "Fluorite", "Garnet", "Granite", "Jade",
  48         "Jasper", "Lapis Lazuli", "Malachite", "Marble", "Moonstone",
  49         "Onyx", "Opal", "Pearl", "Quartz", "Quartzite",
  50         "Rhodonite", "Ruby", "Sapphire", "Tiger Eye", "Topaz",
  51         "Turquoise", "Zircon", "Platinum", "Bronze", "Gold",
  52         "Obsidian", "Silver", "Tortoise Shell", "Mithril", "Jet",
  53         "Engagement", "Adamantite",
  54         "Wire", "Dilithium", "Bone", "Wooden",
  55         "Spikard", "Serpent",   "Wedding", "Double",
  56         "Plain", "Brass",  "Scarab","Shining",
  57         "Rusty","Transparent", "Steel", "Tanzanite",
  58         "Nephrite",
  59 };
  60 #else
  61 = {
  62     "¶âÎÐÀÐ¤Î","¥¢¥á¥¸¥¹¥È¤Î","¥¢¥¯¥¢¥Þ¥ê¥ó¤Î","¤á¤Î¤¦¤Î","ÎÐÃìÀÐ¤Î",
  63     "·ì¶Ì¿ï¤Î","Êý²òÀÐ¤Î","ÀÖ¤á¤Î¤¦¤Î","¹Ë¶Ì¤Î","¥À¥¤¥¢¥â¥ó¥É¤Î",
  64     "¥¨¥á¥é¥ë¥É¤Î","¥Û¥¿¥ëÀÐ¤Î","¥¬¡¼¥Í¥Ã¥È¤Î","¸æ±ÆÀÐ¤Î","¤Ò¤¹¤¤¤Î",
  65     "¥¸¥ã¥¹¥Ñ¡¼¤Î","ÀÄÎÜÍþ¤Î","¥¯¥¸¥ã¥¯ÀÐ¤Î","ÂçÍýÀÐ¤Î","¥à¡¼¥ó¥¹¥È¡¼¥ó¤Î",
  66     "¼Ê¤á¤Î¤¦¤Î","¥ª¥Ñ¡¼¥ë¤Î","¿¿¼î¤Î","¿å¾½¤Î","ÀÐ±Ñ´ä¤Î",
  67     "¥¶¥¯¥íÀÐ¤Î","¥ë¥Ó¡¼¤Î","¥µ¥Õ¥¡¥¤¥¢¤Î","¥¿¥¤¥¬¡¼¥¢¥¤¤Î","¥È¥Ñ¡¼¥º¤Î",
  68     "¥È¥ë¥³ÀÐ¤Î","¥¸¥ë¥³¥ó¤Î","¥×¥é¥Á¥Ê¤Î","¥Ö¥í¥ó¥º¤Î","¶â¤Î",
  69     "¹õÍËÀÐ¤Î","¶ä¤Î","¤Ù¤Ã¹Ã¤Î","¥ß¥¹¥ê¥ë¤Î","¹õ¶Ì¤Î",
  70     "º§Ìó","¥¢¥À¥Þ¥ó¥¿¥¤¥È¤Î",
  71     "¿Ë¶â¤Î","¥Ç¥£¥ê¥·¥¦¥à¤Î","¹ü¤Î","ÌÚ¤Î",
  72     "¥¹¥Ô¥«¤Î" /*nuke me*/ ,"¼Ø¤Î","·ëº§","Æó½Å¤Î",
  73     "¾þ¤ê¤Î¤Ê¤¤","ÀÄÆ¼¤Î","¥¹¥«¥é¥Ù¤Î" ,"µ±¤¯",
  74     "»¬¤Ó¤¿","Æ©ÌÀ¤Ê","¹ÝÅ´¤Î","¥¿¥ó¥¶¥Ê¥¤¥È¤Î",
  75     "Æð¶Ì¤Î",
  76 };
  77 #endif
  78
  79 static byte ring_col[MAX_ROCKS] =
  80 {
  81         TERM_GREEN, TERM_VIOLET, TERM_L_BLUE, TERM_L_BLUE, TERM_L_GREEN,
  82         TERM_RED, TERM_WHITE, TERM_RED, TERM_SLATE, TERM_WHITE,
  83         TERM_GREEN, TERM_L_GREEN, TERM_RED, TERM_L_DARK, TERM_L_GREEN,
  84         TERM_UMBER, TERM_BLUE, TERM_GREEN, TERM_WHITE, TERM_L_WHITE,
  85         TERM_L_RED, TERM_L_WHITE, TERM_WHITE, TERM_L_WHITE, TERM_L_WHITE,
  86         TERM_L_RED, TERM_RED, TERM_BLUE, TERM_YELLOW, TERM_YELLOW,
  87         TERM_L_BLUE, TERM_L_UMBER, TERM_WHITE, TERM_L_UMBER, TERM_YELLOW,
  88         TERM_L_DARK, TERM_L_WHITE, TERM_GREEN, TERM_L_BLUE, TERM_L_DARK,
  89         TERM_YELLOW, TERM_VIOLET,
  90         TERM_UMBER, TERM_L_WHITE, TERM_WHITE, TERM_UMBER,
  91         TERM_BLUE, TERM_GREEN, TERM_YELLOW, TERM_ORANGE,
  92         TERM_YELLOW, TERM_ORANGE, TERM_L_GREEN, TERM_YELLOW,
  93         TERM_RED, TERM_WHITE, TERM_WHITE, TERM_YELLOW,
  94         TERM_GREEN,
  95 };
  96
  97
  98 /*
  99  * Amulets (adjectives and colors)
 100  */
 101 static cptr amulet_adj[MAX_AMULETS]
 102 #ifndef JP
 103 = {
 104         "Amber", "Driftwood", "Coral", "Agate", "Ivory",
 105         "Obsidian", "Bone", "Brass", "Bronze", "Pewter",
 106         "Tortoise Shell", "Golden", "Azure", "Crystal", "Silver",
 107         "Copper", "Swastika", "Platinum","Runed", "Rusty",
 108         "Curved", "Dragon's claw", "Rosary", "Jade", "Mithril",
 109         "Ruby"
 110 };
 111 #else
 112 = {
 113     "àèàá¤Î","Î®ÌÚ¤Î","¥µ¥ó¥´¤Î","¤á¤Î¤¦¤Î","¾Ý²ç¤Î",
 114     "¹õÍËÀÐ¤Î","¹ü¤Î","¿¿ï«¤Î","ÀÄÆ¼¤Î","¤·¤í¤á¤Î",
 115     "¤Ù¤Ã¹Ã¤Î","¶â¤Î","ÎÜÍþ¤Î","¿å¾½¤Î","¶ä¤Î",
 116     "Æ¼¤Î","ÒÄ¤Î", "¥×¥é¥Á¥Ê¤Î", "¥ë¡¼¥ó¤¬¹ï¤Þ¤ì¤¿","»¬¤Ó¤¿",
 117     "¶Ê¤¬¤Ã¤¿", "¥É¥é¥´¥ó¤ÎÄÞ¤Î", "¿ô¼î¤Î", "¤Ò¤¹¤¤¤Î", "¥ß¥¹¥ê¥ë¤Î",
 118     "¥ë¥Ó¡¼¤Î"
 119 };
 120 #endif
 121
 122 static byte amulet_col[MAX_AMULETS] =
 123 {
 124         TERM_YELLOW, TERM_L_UMBER, TERM_WHITE, TERM_L_WHITE, TERM_WHITE,
 125         TERM_L_DARK, TERM_WHITE, TERM_L_UMBER, TERM_L_UMBER, TERM_SLATE,
 126         TERM_GREEN, TERM_YELLOW, TERM_L_BLUE, TERM_L_BLUE, TERM_L_WHITE,
 127         TERM_L_UMBER, TERM_VIOLET, TERM_WHITE, TERM_UMBER, TERM_RED,
 128         TERM_GREEN, TERM_L_GREEN, TERM_L_GREEN, TERM_GREEN, TERM_L_BLUE,
 129         TERM_RED
 130 };
 131
 132
 133 /*
 134  * Staffs (adjectives and colors)
 135  */
 136 static cptr staff_adj[MAX_WOODS]
 137 #ifndef JP
 138 = {
 139         "Aspen", "Balsa", "Banyan", "Birch", "Cedar",
 140         "Cottonwood", "Cypress", "Dogwood", "Elm", "Eucalyptus",
 141         "Hemlock", "Hickory", "Ironwood", "Locust", "Mahogany",
 142         "Maple", "Mulberry", "Oak", "Pine", "Redwood",
 143         "Rosewood", "Spruce", "Sycamore", "Teak", "Walnut",
 144         "Mistletoe", "Hawthorn", "Bamboo", "Silver", "Runed",
 145         "Golden", "Ashen", "Ivory","Gnarled"/*,"Willow"*/
 146 };
 147 #else
 148 = {
 149     "¥Ý¥×¥é¤Î","¥Ð¥ë¥µ¤Î","¥Ð¥ó¥ä¥ó¤Î","¥«¥Ð¤Î","À¾ÍÎ¥¹¥®¤Î",
 150     "ÛØ¤Î","¥¤¥È¥¹¥®¤Î","¥ß¥º¥¤Î","¥Ë¥ì¤Î","¥æ¡¼¥«¥ê¤Î",
 151     "¥Ä¥¬¤Î","¥Ö¥Ê¤Î","¹õÃÉ¤Î","¥¢¥«¥·¥¢¤Î","¥Þ¥Û¥¬¥Ë¡¼¤Î",
 152     "¥«¥¨¥Ç¤Î","¥¯¥ï¤Î","¥«¥·¤Î","¾¾¤Î","¿ù¤Î",
 153     "»çÃÉ¤Î","¥¨¥¾¥Þ¥Ä¤Î","¥¤¥Á¥¸¥¯¤Î","¥Á¡¼¥¯¤Î","¥¯¥ë¥ß¤Î",
 154     "¥ä¥É¥ê¥®¤Î","¥µ¥ó¥¶¥·¤Î","ÃÝ¤Î","¶ä¤Î","¥ë¡¼¥ó¤Î",
 155     "¶â¤Î","¥È¥Í¥ê¥³¤Î", "¾Ý²ç¤Î", "·î·Ë¼ù¤Î"
 156 };
 157 #endif
 158
 159 static byte staff_col[MAX_WOODS] =
 160 {
 161         TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER,
 162         TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER,
 163         TERM_L_UMBER, TERM_L_UMBER, TERM_UMBER, TERM_L_UMBER, TERM_UMBER,
 164         TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_RED,
 165         TERM_RED, TERM_L_UMBER, TERM_L_UMBER, TERM_L_UMBER, TERM_UMBER,
 166         TERM_GREEN, TERM_L_UMBER, TERM_L_UMBER, TERM_L_WHITE, TERM_UMBER,
 167         TERM_YELLOW, TERM_SLATE, TERM_WHITE, TERM_SLATE
 168 };
 169
 170
 171 /*
 172  * Wands (adjectives and colors)
 173  */
 174 static cptr wand_adj[MAX_METALS]
 175 #ifndef JP
 176 = {
 177         "Aluminum", "Cast Iron", "Chromium", "Copper", "Gold",
 178         "Iron", "Magnesium", "Molybdenum", "Nickel", "Rusty",
 179         "Silver", "Steel", "Tin", "Titanium", "Tungsten",
 180         "Zirconium", "Zinc", "Aluminum-Plated", "Copper-Plated", "Gold-Plated",
 181         "Nickel-Plated", "Silver-Plated", "Steel-Plated", "Tin-Plated", "Zinc-Plated",
 182         "Mithril-Plated", "Mithril", "Runed", "Bronze", "Brass",
 183         "Platinum", "Lead","Lead-Plated", "Ivory" , "Adamantite",
 184         "Uridium", "Long", "Short", "Hexagonal", "Carbonized"
 185 };
 186 #else
 187 = {
 188     "¥¢¥ë¥ß¤Î","ÃòÅ´¤Î","¥¯¥í¥à¤Î","Æ¼¤Î","¶â¤Î",
 189     "Å´¤Î","¥Þ¥°¥Í¥·¥¦¥à¤Î","¥â¥ê¥Ö¥Ç¥ó¤Î","¥Ë¥Ã¥±¥ë¤Î","»¬¤Ó¤¿",
 190     "¶ä¤Î","¹ÝÅ´¤Î","¥Ö¥ê¥¤Î","¥Á¥¿¥ó¤Î","¥¿¥ó¥°¥¹¥Æ¥ó¤Î",
 191     "¥¸¥ë¥³¥ó¤Î","°¡±ô¤Î","¥¢¥ë¥ß¥á¥Ã¥¤Î","Æ¼¥á¥Ã¥¤Î","¶â¥á¥Ã¥¤Î",
 192     "ÇòÆ¼¥á¥Ã¥¤Î","¶ä¥á¥Ã¥¤Î","Å´¥á¥Ã¥¤Î","¥¹¥º¥á¥Ã¥¤Î","°¡±ô¥á¥Ã¥¤Î",
 193     "¥ß¥¹¥ê¥ë¥á¥Ã¥¤Î","¥ß¥¹¥ê¥ë¤Î","¥ë¡¼¥ó¤¬¹ï¤Þ¤ì¤¿","ÀÄÆ¼¤Î","¿¿ï«¤Î",
 194     "¥×¥é¥Á¥Ê¤Î","±ô¤Î","±ô¥á¥Ã¥¤Î","¾Ý²ç¤Î","¥¢¥À¥Þ¥ó¥¿¥¤¥È¤Î",
 195     "¥¤¥ê¥Â¥¦¥à¤Î","Ä¹¤¤","Ã»¤¤","Ï»³Ñ·Á¤Î", "ÃºÁÇ¤Î"
 196 };
 197 #endif
 198
 199 static byte wand_col[MAX_METALS] =
 200 {
 201         TERM_L_BLUE, TERM_L_DARK, TERM_WHITE, TERM_L_UMBER, TERM_YELLOW,
 202         TERM_SLATE, TERM_L_WHITE, TERM_L_WHITE, TERM_L_UMBER, TERM_RED,
 203         TERM_L_WHITE, TERM_L_WHITE, TERM_L_WHITE, TERM_WHITE, TERM_WHITE,
 204         TERM_L_WHITE, TERM_L_WHITE, TERM_L_BLUE, TERM_L_UMBER, TERM_YELLOW,
 205         TERM_L_UMBER, TERM_L_WHITE, TERM_L_WHITE, TERM_L_WHITE, TERM_L_WHITE,
 206         TERM_L_BLUE, TERM_L_BLUE, TERM_UMBER, TERM_L_UMBER, TERM_L_UMBER,
 207         TERM_WHITE, TERM_SLATE, TERM_SLATE, TERM_WHITE, TERM_VIOLET,
 208         TERM_L_RED, TERM_L_BLUE, TERM_BLUE, TERM_RED, TERM_L_DARK
 209 };
 210
 211
 212 /*
 213  * Rods (adjectives and colors).
 214  * Efficiency -- copied from wand arrays
 215  */
 216
 217 static cptr rod_adj[MAX_METALS];
 218
 219 static byte rod_col[MAX_METALS];
 220
 221
 222 /*
 223  * Mushrooms (adjectives and colors)
 224  */
 225
 226 static cptr food_adj[MAX_SHROOM]
 227 #ifndef JP
 228 = {
 229         "Blue", "Black", "Black Spotted", "Brown", "Dark Blue",
 230         "Dark Green", "Dark Red", "Yellow", "Furry", "Green",
 231         "Grey", "Light Blue", "Light Green", "Violet", "Red",
 232         "Slimy", "Tan", "White", "White Spotted", "Wrinkled",
 233 };
 234 #else
 235 = {
 236     "ÀÄ¤¤","¹õ¤¤","¹õÈÃ¤Î","Ãã¿§¤Î","·²ÀÄ¤Î",
 237     "¿¼ÎÐ¤Î","¹È¿§¤Î","²«¿§¤¤","ÂÝ¤à¤·¤¿","ÎÐ¤Î",
 238     "¥°¥ì¡¼¤Î","¶õ¿§¤Î","²«ÎÐ¤Î","¥¹¥ß¥ì¿§¤Î","ÀÖ¤¤",
 239     "¤Í¤Ð¤Í¤Ð¤·¤¿","²«³ì¿§¤Î","Çò¤¤","ÇòÈÃ¤Î","¤·¤ï¤·¤ï¤Î",
 240 };
 241 #endif
 242
 243 static byte food_col[MAX_SHROOM] =
 244 {
 245         TERM_BLUE, TERM_L_DARK, TERM_L_DARK, TERM_UMBER, TERM_BLUE,
 246         TERM_GREEN, TERM_RED, TERM_YELLOW, TERM_L_WHITE, TERM_GREEN,
 247         TERM_SLATE, TERM_L_BLUE, TERM_L_GREEN, TERM_VIOLET, TERM_RED,
 248         TERM_SLATE, TERM_L_UMBER, TERM_WHITE, TERM_WHITE, TERM_UMBER
 249 };
 250
 251
 252 /*
 253  * Color adjectives and colors, for potions.
 254  * Hack -- The first four entries are hard-coded.
 255  * (water, apple juice, slime mold juice, something)
 256  */
 257
 258 static cptr potion_adj[MAX_COLORS]
 259 #ifndef JP
 260 = {
 261         "Clear", "Light Brown", "Icky Green", "xxx",
 262         "Azure", "Blue", "Blue Speckled", "Black", "Brown", "Brown Speckled",
 263         "Bubbling", "Chartreuse", "Cloudy", "Copper Speckled", "Crimson", "Cyan",
 264         "Dark Blue", "Dark Green", "Dark Red", "Gold Speckled", "Green",
 265         "Green Speckled", "Grey", "Grey Speckled", "Hazy", "Indigo",
 266         "Light Blue", "Light Green", "Magenta", "Metallic Blue", "Metallic Red",
 267         "Metallic Green", "Metallic Purple", "Misty", "Orange", "Orange Speckled",
 268         "Pink", "Pink Speckled", "Puce", "Purple", "Purple Speckled",
 269         "Red", "Red Speckled", "Silver Speckled", "Smoky", "Tangerine",
 270         "Violet", "Vermilion", "White", "Yellow", "Violet Speckled",
 271         "Pungent", "Clotted Red", "Viscous Pink", "Oily Yellow", "Gloopy Green",
 272         "Shimmering", "Coagulated Crimson", "Yellow Speckled", "Gold",
 273         "Manly", "Stinking", "Oily Black", "Ichor", "Ivory White", "Sky Blue",
 274         "Gray", "Silver", "Bronze", "Flashing",
 275 };
 276 #else
 277 = {
 278     "Æ©ÌÀ¤Ê","ÇöÃã¿§¤Î","¤è¤É¤ó¤ÀÎÐ¤Î","¼¿¹õ¤Î",
 279     "º°ÊË¤Î","ÀÄ¤¤","ÀÄÈÃ¤Î","¹õ¤¤","Ãã¿§¤Î","ÃãÈÃ¤Î",
 280     "Ë¢¤À¤Ã¤¿","Çö²«ÎÐ¿§¤Î","Âù¤Ã¤¿","Æ¼ÈÃ¤Î","¹È¿§¤Î","¥·¥¢¥ó¿§¤Î",
 281     "·²ÀÄ¿§¤Î","¿¼¤¤ÎÐ¤Î","¿¼¤¤ÀÖ¿§¤Î","¶âÈÃ¤Î","ÎÐ¿§¤Î",
 282     "ÎÐÈÃ¤Î","³¥¿§¤Î","³¥ÈÃ¤Î","¤Ü¤ä¤±¤¿¿§¤Î","Íõ¿§¤Î",
 283     "Çö¤¤ÀÄ¿§¤Î","Çö¤¤ÎÐ¿§¤Î","¥Þ¥¼¥ó¥¿¿§¤Î","ÀÄ¤¯µ±¤¯","ÀÖ¤¯µ±¤¯",
 284     "ÎÐ¤Ëµ±¤¯","»ç¤Ëµ±¤¯","Ì¸¾õ¤Î","¥ª¥ì¥ó¥¸¿§¤Î","¥ª¥ì¥ó¥¸ÈÃ¤Î",
 285     "¥Ô¥ó¥¯¿§¤Î","¥Ô¥ó¥¯ÈÃ¤Î","¹õ³ì¿§¤Î","»ç¿§¤Î","¤¦¤¹¤¤»çÈÃ¤Î",
 286     "ÀÖ¤¤","ÀÖÈÃ¤Î","¶äÈÃ¤Î","±ì¤Ã¤¿","Üô¿§¤Î",
 287     "¥¹¥ß¥ì¿§¤Î","¼ë¿§¤Î","Çò¤¤","²«¿§¤¤", "»çÈÃ¤Î",
 288     "»É·ã½¤Î¤¹¤ë","¤è¤É¤ó¤ÀÀÖ¤Î","¥É¥í¥É¥í¤Î","¤Í¤Ð¤Ã¤¿²«¿§¤Î","°ÅÎÐ¿§¤Î",
 289     "µ±¤¯","¤Í¤Ð¤Ã¤¿¿¼¹È¤Î","²«ÈÃ¤Î","¶â¿§¤Î",
 290     "ÃË½¤¤" /*nuke me*/,"°½¤Î¤¹¤ë","¹õÌý¿§¤Î","Ç¾Þù¤Î",
 291     "¾Ý²ç¿§¤Î","¶õ¿§¤Î", "¤Í¤º¤ß¿§¤Î", "¶ä¿§¤Î", "ÀÖÆ¼¿§¤Î",
 292     "¥¥é¥¥é¸÷¤ë"
 293 };
 294 #endif
 295
 296 static byte potion_col[MAX_COLORS] =
 297 {
 298         TERM_WHITE, TERM_L_UMBER, TERM_GREEN, 0,
 299         TERM_L_BLUE, TERM_BLUE, TERM_BLUE, TERM_L_DARK, TERM_UMBER, TERM_UMBER,
 300         TERM_L_WHITE, TERM_L_GREEN, TERM_WHITE, TERM_L_UMBER, TERM_RED, TERM_L_BLUE,
 301         TERM_BLUE, TERM_GREEN, TERM_RED, TERM_YELLOW, TERM_GREEN,
 302         TERM_GREEN, TERM_SLATE, TERM_SLATE, TERM_L_WHITE, TERM_VIOLET,
 303         TERM_L_BLUE, TERM_L_GREEN, TERM_RED, TERM_BLUE, TERM_RED,
 304         TERM_GREEN, TERM_VIOLET, TERM_L_WHITE, TERM_ORANGE, TERM_ORANGE,
 305         TERM_L_RED, TERM_L_RED, TERM_VIOLET, TERM_VIOLET, TERM_VIOLET,
 306         TERM_RED, TERM_RED, TERM_L_WHITE, TERM_L_DARK, TERM_ORANGE,
 307         TERM_VIOLET, TERM_RED, TERM_WHITE, TERM_YELLOW, TERM_VIOLET,
 308         TERM_L_RED, TERM_RED, TERM_L_RED, TERM_YELLOW, TERM_GREEN,
 309         TERM_MULTI, TERM_RED, TERM_YELLOW, TERM_YELLOW,
 310         TERM_L_UMBER, TERM_UMBER, TERM_L_DARK, TERM_RED,
 311         TERM_WHITE, TERM_L_BLUE, TERM_L_WHITE, TERM_WHITE, TERM_RED,
 312         TERM_YELLOW
 313 };
 314
 315
 316 /*
 317  * Syllables for scrolls (must be 1-4 letters each)
 318  */
 319
 320 static cptr syllables[MAX_SYLLABLES]
 321 #ifdef JP
 322 = {
 323         "Å·", "ÃÏ", "Ìµ", "ÍÑ", "°ì", "Åá", "Î¾", "ÃÇ",
 324         "°á", "Ë¥", "Æü", "Àé", "½©", "Ëþ", "¿È", "ÁÏ",
 325         "áØ", "¼·", "Å¾", "È¬", "ÅÝ", "²é", "¿Å",
 326         "¾¨", "ÃÀ", "µ¯", "»à", "²ó", "À¸", "Ê¸",
 327         "Éð", "Æ»", "Îµ", "Æ¬", "¼Ø", "Èø", "Ã±", "Åá", "Ä¾", "Æþ",
 328         "¿Ê", "Âà", "¸Þ", "Â¡", "Ï»", "ç¥", "Âç", "»³", "ÌÄ",
 329         "Æ°", "É÷", "ÎÓ", "²Ð", "Àä", "ÂÎ", "Ì¿", "»Í",
 330         "ÌÌ", "Á¿", "²Î", "´°", "Á´", "·ç", "Ä·", "ÎÂ",
 331         "ìí", "î½", "òµ", "Ì¥", "ò³", "ò´", "½Ä",
 332         "²£", "¿Ô", "¿À", "½Ð", "µ´", "Ë×", "²¹", "¸Î", "ÃÎ",
 333         "¿·", "½Õ", "²Æ", "Åß", "½ã", "¿¿", "¹¤", "¶½",
 334         "Ì£", "ÄÅ", "³Î", "Èæ", "¶ì", "¿´", "»´", "ß¸",
 335         "Ç°", "È¯", "Á°", "Âå", "Ì¤", "Ê¹", "¶õ", "¸å",
 336         "Ú¼", "¶â", "¿¹", "Íå", "Ëü", "¾Ý", "ÊÑ", "²½",
 337         "½½", "Ãæ", "È¬", "¶å", "¿Í", "¿§", "»î", "¹Ô",
 338         "ºø", "¸í", "»ö", "¼Â", "º¬", "µÛ", "¼ý", "¹ç",
 339         "Ê»", "Á´", "¹ñ", "À©", "ÇÆ", "¾Æ", "Æù", "Äê",
 340         "¿©", "¹ü", "²ç", "Ìø", "Èô", "æÆ", "Éõ", "°õ",
 341         "¼À", "Íð", "Éð", "¾", "·Ú", "Ç¦", "·õ", "Ç½",
 342         "À»", "¼Ù", "¼ö", "¼±", "¸¸", "´¶", "ÆÇ", "°Ç",
 343         "Íî", "±¢", "ÍÛ"
 344 };
 345 #else
 346 = {
 347         "a", "ab", "ag", "aks", "ala", "an", "ankh", "app",
 348         "arg", "arze", "ash", "aus", "ban", "bar", "bat", "bek",
 349         "bie", "bin", "bit", "bjor", "blu", "bot", "bu",
 350         "byt", "comp", "con", "cos", "cre", "dalf", "dan",
 351         "den", "der", "doe", "dok", "eep", "el", "eng", "er", "ere", "erk",
 352         "esh", "evs", "fa", "fid", "flit", "for", "fri", "fu", "gan",
 353         "gar", "glen", "gop", "gre", "ha", "he", "hyd", "i",
 354         "ing", "ion", "ip", "ish", "it", "ite", "iv", "jo",
 355         "kho", "kli", "klis", "la", "lech", "man", "mar",
 356         "me", "mi", "mic", "mik", "mon", "mung", "mur", "nag", "nej",
 357         "nelg", "nep", "ner", "nes", "nis", "nih", "nin", "o",
 358         "od", "ood", "org", "orn", "ox", "oxy", "pay", "pet",
 359         "ple", "plu", "po", "pot", "prok", "re", "rea", "rhov",
 360         "ri", "ro", "rog", "rok", "rol", "sa", "san", "sat",
 361         "see", "sef", "seh", "shu", "ski", "sna", "sne", "snik",
 362         "sno", "so", "sol", "sri", "sta", "sun", "ta", "tab",
 363         "tem", "ther", "ti", "tox", "trol", "tue", "turs", "u",
 364         "ulk", "um", "un", "uni", "ur", "val", "viv", "vly",
 365         "vom", "wah", "wed", "werg", "wex", "whon", "wun", "x",
 366         "yerg", "yp", "zun", "tri", "blaa", "jah", "bul", "on",
 367         "foo", "ju", "xuxu"
 368 };
 369 #endif
 370
 371
 372 /*
 373  * Hold the titles of scrolls, 6 to 14 characters each
 374  * Also keep an array of scroll colors (always WHITE for now)
 375  */
 376 static char scroll_adj[MAX_TITLES][16];
 377
 378 static byte scroll_col[MAX_TITLES];
 379
 380
 381 /*
 382  * Certain items, if aware, are known instantly
 383  * This function is used only by "flavor_init()"
 384  */
 385 static bool object_easy_know(int i)
 386 {
 387         object_kind *k_ptr = &k_info[i];
 388
 389         /* Analyze the "tval" */
 390         switch (k_ptr->tval)
 391         {
 392                 /* Spellbooks */
 393                 case TV_LIFE_BOOK:
 394                 case TV_SORCERY_BOOK:
 395                 case TV_NATURE_BOOK:
 396                 case TV_CHAOS_BOOK:
 397                 case TV_DEATH_BOOK:
 398                 case TV_TRUMP_BOOK:
 399                 case TV_ARCANE_BOOK:
 400                 case TV_ENCHANT_BOOK:
 401                 case TV_DAEMON_BOOK:
 402                 case TV_CRUSADE_BOOK:
 403                 case TV_MUSIC_BOOK:
 404                 case TV_HISSATSU_BOOK:
 405                 {
 406                         return (TRUE);
 407                 }
 408
 409                 /* Simple items */
 410                 case TV_FLASK:
 411                 case TV_JUNK:
 412                 case TV_BOTTLE:
 413                 case TV_SKELETON:
 414                 case TV_SPIKE:
 415                 case TV_WHISTLE:
 416                 {
 417                         return (TRUE);
 418                 }
 419
 420                 /* All Food, Potions, Scrolls, Rods */
 421                 case TV_FOOD:
 422                 case TV_POTION:
 423                 case TV_SCROLL:
 424                 case TV_ROD:
 425                 {
 426                         return (TRUE);
 427                 }
 428         }
 429
 430         /* Nope */
 431         return (FALSE);
 432 }
 433
 434
 435 /*
 436  * Certain items have a flavor
 437  * This function is used only by "flavor_init()"
 438  */
 439 static bool object_flavor(int k_idx)
 440 {
 441         object_kind *k_ptr = &k_info[k_idx];
 442
 443         /* Analyze the item */
 444         switch (k_ptr->tval)
 445         {
 446                 case TV_AMULET:
 447                 {
 448                         return (0x80 + amulet_col[k_ptr->sval]);
 449                 }
 450
 451                 case TV_RING:
 452                 {
 453                         return (0x90 + ring_col[k_ptr->sval]);
 454                 }
 455
 456                 case TV_STAFF:
 457                 {
 458                         return (0xA0 + staff_col[k_ptr->sval]);
 459                 }
 460
 461                 case TV_WAND:
 462                 {
 463                         return (0xB0 + wand_col[k_ptr->sval]);
 464                 }
 465
 466                 case TV_ROD:
 467                 {
 468                         return (0xC0 + rod_col[k_ptr->sval]);
 469                 }
 470
 471                 case TV_SCROLL:
 472                 {
 473                         return (0xD0 + scroll_col[k_ptr->sval]);
 474                 }
 475
 476                 case TV_POTION:
 477                 {
 478                         return (0xE0 + potion_col[k_ptr->sval]);
 479                 }
 480
 481                 case TV_FOOD:
 482                 {
 483                         if (k_ptr->sval < SV_FOOD_MIN_FOOD)
 484                         {
 485                                 return (0xF0 + food_col[k_ptr->sval]);
 486                         }
 487
 488                         break;
 489                 }
 490         }
 491
 492         /* No flavor */
 493         return (0);
 494 }
 495
 496
 497 void get_table_name(char *out_string)
 498 {
 499 #ifdef JP
 500         char Syllable[80];
 501         strcpy(out_string, "¡Ø");
 502         get_rnd_line("aname_j.txt", 1, Syllable);
 503         strcat(out_string, Syllable);
 504         get_rnd_line("aname_j.txt", 2, Syllable);
 505         strcat(out_string, Syllable);
 506         strcat(out_string, "¡Ù");
 507 #else
 508         int testcounter = randint1(3) + 1;
 509
 510         strcpy(out_string, "'");
 511
 512         if (randint1(3) == 2)
 513         {
 514                 while (testcounter--)
 515                         strcat(out_string, syllables[randint0(MAX_SYLLABLES)]);
 516         }
 517         else
 518         {
 519                 char Syllable[80];
 520                 testcounter = randint1(2) + 1;
 521                 while (testcounter--)
 522                 {
 523                         (void)get_rnd_line("elvish.txt", 0, Syllable);
 524                         strcat(out_string, Syllable);
 525                 }
 526         }
 527
 528         out_string[1] = toupper(out_string[1]);
 529
 530         strcat(out_string, "'");
 531 #endif
 532
 533
 534         out_string[18] = '\0';
 535
 536         return;
 537 }
 538
 539
 540 /*
 541  * Prepare the "variable" part of the "k_info" array.
 542  *
 543  * The "color"/"metal"/"type" of an item is its "flavor".
 544  * For the most part, flavors are assigned randomly each game.
 545  *
 546  * Initialize descriptions for the "colored" objects, including:
 547  * Rings, Amulets, Staffs, Wands, Rods, Food, Potions, Scrolls.
 548  *
 549  * The first 4 entries for potions are fixed (Water, Apple Juice,
 550  * Slime Mold Juice, Unused Potion).
 551  *
 552  * Scroll titles are always between 6 and 14 letters long.  This is
 553  * ensured because every title is composed of whole words, where every
 554  * word is from 1 to 8 letters long (one or two syllables of 1 to 4
 555  * letters each), and that no scroll is finished until it attempts to
 556  * grow beyond 15 letters.  The first time this can happen is when the
 557  * current title has 6 letters and the new word has 8 letters, which
 558  * would result in a 6 letter scroll title.
 559  *
 560  * Duplicate titles are avoided by requiring that no two scrolls share
 561  * the same first four letters (not the most efficient method, and not
 562  * the least efficient method, but it will always work).
 563  *
 564  * Hack -- make sure everything stays the same for each saved game
 565  * This is accomplished by the use of a saved "random seed", as in
 566  * "town_gen()".  Since no other functions are called while the special
 567  * seed is in effect, so this function is pretty "safe".
 568  *
 569  * Note that the "hacked seed" may provide an RNG with alternating parity!
 570  */
 571 void flavor_init(void)
 572 {
 573         int     i, j;
 574
 575         byte    temp_col;
 576
 577         cptr    temp_adj;
 578
 579
 580         /* Hack -- Use the "simple" RNG */
 581         Rand_quick = TRUE;
 582
 583         /* Hack -- Induce consistant flavors */
 584         Rand_value = seed_flavor;
 585
 586
 587         /* Efficiency -- Rods/Wands share initial array */
 588         for (i = 0; i < MAX_METALS; i++)
 589         {
 590                 rod_adj[i] = wand_adj[i];
 591                 rod_col[i] = wand_col[i];
 592         }
 593
 594
 595         /* Rings have "ring colors" */
 596         for (i = 0; i < MAX_ROCKS; i++)
 597         {
 598                 j = randint0(MAX_ROCKS);
 599                 temp_adj = ring_adj[i];
 600                 ring_adj[i] = ring_adj[j];
 601                 ring_adj[j] = temp_adj;
 602
 603                 temp_col = ring_col[i];
 604                 ring_col[i] = ring_col[j];
 605                 ring_col[j] = temp_col;
 606         }
 607
 608         /* Hack -- The One Ring */
 609 #ifdef JP
 610         ring_adj[SV_RING_POWER] = "¶âÌµ¹¤¤Î";
 611         ring_adj[SV_RING_AHO] = "¶âÍ¹¤¤Î";
 612 #else
 613         ring_adj[SV_RING_POWER] = "Plain Gold";
 614         ring_adj[SV_RING_AHO] = "Plain Goldarn";
 615 #endif
 616
 617         if (!use_graphics)
 618         {
 619                 ring_col[SV_RING_POWER] = TERM_YELLOW;
 620                 ring_col[SV_RING_AHO] = TERM_YELLOW;
 621         }
 622
 623         /* Amulets have "amulet colors" */
 624         for (i = 0; i < MAX_AMULETS; i++)
 625         {
 626                 j = randint0(MAX_AMULETS);
 627                 temp_adj = amulet_adj[i];
 628                 amulet_adj[i] = amulet_adj[j];
 629                 amulet_adj[j] = temp_adj;
 630
 631                 temp_col = amulet_col[i];
 632                 amulet_col[i] = amulet_col[j];
 633                 amulet_col[j] = temp_col;
 634         }
 635
 636         /* Staffs */
 637         for (i = 0; i < MAX_WOODS; i++)
 638         {
 639                 j = randint0(MAX_WOODS);
 640                 temp_adj = staff_adj[i];
 641                 staff_adj[i] = staff_adj[j];
 642                 staff_adj[j] = temp_adj;
 643
 644                 temp_col = staff_col[i];
 645                 staff_col[i] = staff_col[j];
 646                 staff_col[j] = temp_col;
 647         }
 648
 649         /* Wands */
 650         for (i = 0; i < MAX_METALS; i++)
 651         {
 652                 j = randint0(MAX_METALS);
 653                 temp_adj = wand_adj[i];
 654                 wand_adj[i] = wand_adj[j];
 655                 wand_adj[j] = temp_adj;
 656
 657                 temp_col = wand_col[i];
 658                 wand_col[i] = wand_col[j];
 659                 wand_col[j] = temp_col;
 660         }
 661
 662         /* Rods */
 663         for (i = 0; i < MAX_METALS; i++)
 664         {
 665                 j = randint0(MAX_METALS);
 666                 temp_adj = rod_adj[i];
 667                 rod_adj[i] = rod_adj[j];
 668                 rod_adj[j] = temp_adj;
 669
 670                 temp_col = rod_col[i];
 671                 rod_col[i] = rod_col[j];
 672                 rod_col[j] = temp_col;
 673         }
 674
 675         /* Foods (Mushrooms) */
 676         for (i = 0; i < MAX_SHROOM; i++)
 677         {
 678                 j = randint0(MAX_SHROOM);
 679                 temp_adj = food_adj[i];
 680                 food_adj[i] = food_adj[j];
 681                 food_adj[j] = temp_adj;
 682
 683                 temp_col = food_col[i];
 684                 food_col[i] = food_col[j];
 685                 food_col[j] = temp_col;
 686         }
 687
 688         /* Potions */
 689         for (i = 4; i < MAX_COLORS; i++)
 690         {
 691                 j = randint0(MAX_COLORS - 4) + 4;
 692                 temp_adj = potion_adj[i];
 693                 potion_adj[i] = potion_adj[j];
 694                 potion_adj[j] = temp_adj;
 695
 696                 temp_col = potion_col[i];
 697                 potion_col[i] = potion_col[j];
 698                 potion_col[j] = temp_col;
 699         }
 700
 701         /* Scrolls (random titles, always white) */
 702         for (i = 0; i < MAX_TITLES; i++)
 703         {
 704                 /* Get a new title */
 705                 while (TRUE)
 706                 {
 707                         char buf[80];
 708
 709                         bool okay;
 710
 711                         /* Start a new title */
 712                         buf[0] = '\0';
 713
 714                         /* Collect words until done */
 715                         while (1)
 716                         {
 717                                 int q, s;
 718
 719                                 char tmp[80];
 720
 721                                 /* Start a new word */
 722                                 tmp[0] = '\0';
 723
 724                                 /* Choose one or two syllables */
 725                                 s = ((randint0(100) < 30) ? 1 : 2);
 726
 727                                 /* Add a one or two syllable word */
 728                                 for (q = 0; q < s; q++)
 729                                 {
 730                                         /* Add the syllable */
 731                                         strcat(tmp, syllables[randint0(MAX_SYLLABLES)]);
 732                                 }
 733
 734                                 /* Stop before getting too long */
 735                                 if (strlen(buf) + 1 + strlen(tmp) > 15) break;
 736
 737                                 /* Add a space */
 738                                 strcat(buf, " ");
 739
 740                                 /* Add the word */
 741                                 strcat(buf, tmp);
 742                         }
 743
 744                         /* Save the title */
 745                         strcpy(scroll_adj[i], buf+1);
 746
 747                         /* Assume okay */
 748                         okay = TRUE;
 749
 750                         /* Check for "duplicate" scroll titles */
 751                         for (j = 0; j < i; j++)
 752                         {
 753                                 cptr hack1 = scroll_adj[j];
 754                                 cptr hack2 = scroll_adj[i];
 755
 756                                 /* Compare first four characters */
 757                                 if (*hack1++ != *hack2++) continue;
 758                                 if (*hack1++ != *hack2++) continue;
 759                                 if (*hack1++ != *hack2++) continue;
 760                                 if (*hack1++ != *hack2++) continue;
 761
 762                                 /* Not okay */
 763                                 okay = FALSE;
 764
 765                                 /* Stop looking */
 766                                 break;
 767                         }
 768
 769                         /* Break when done */
 770                         if (okay) break;
 771                 }
 772
 773                 /* All scrolls are white */
 774                 scroll_col[i] = TERM_WHITE;
 775         }
 776
 777
 778         /* Hack -- Use the "complex" RNG */
 779         Rand_quick = FALSE;
 780
 781         /* Analyze every object */
 782         for (i = 1; i < max_k_idx; i++)
 783         {
 784                 object_kind *k_ptr = &k_info[i];
 785
 786                 /* Skip "empty" objects */
 787                 if (!k_ptr->name) continue;
 788
 789                 /* Extract "flavor" (if any) */
 790                 k_ptr->flavor = object_flavor(i);
 791
 792                 /* No flavor yields aware */
 793                 if (!k_ptr->flavor) k_ptr->aware = TRUE;
 794
 795                 /* Check for "easily known" */
 796                 k_ptr->easy_know = object_easy_know(i);
 797         }
 798 }
 799
 800
 801 /*
 802  * Print a char "c" into a string "t", as if by sprintf(t, "%c", c),
 803  * and return a pointer to the terminator (t + 1).
 804  */
 805 static char *object_desc_chr(char *t, char c)
 806 {
 807         /* Copy the char */
 808         *t++ = c;
 809
 810         /* Terminate */
 811         *t = '\0';
 812
 813         /* Result */
 814         return (t);
 815 }
 816
 817
 818 /*
 819  * Print a string "s" into a string "t", as if by strcpy(t, s),
 820  * and return a pointer to the terminator.
 821  */
 822 static char *object_desc_str(char *t, cptr s)
 823 {
 824         /* Copy the string */
 825         while (*s) *t++ = *s++;
 826
 827         /* Terminate */
 828         *t = '\0';
 829
 830         /* Result */
 831         return (t);
 832 }
 833
 834
 835
 836 /*
 837  * Print an unsigned number "n" into a string "t", as if by
 838  * sprintf(t, "%u", n), and return a pointer to the terminator.
 839  */
 840 static char *object_desc_num(char *t, uint n)
 841 {
 842         uint p;
 843
 844         /* Find "size" of "n" */
 845         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
 846
 847         /* Dump each digit */
 848         while (p >= 1)
 849         {
 850                 /* Dump the digit */
 851                 *t++ = '0' + n / p;
 852
 853                 /* Remove the digit */
 854                 n = n % p;
 855
 856                 /* Process next digit */
 857                 p = p / 10;
 858         }
 859
 860         /* Terminate */
 861         *t = '\0';
 862
 863         /* Result */
 864         return (t);
 865 }
 866
 867
 868
 869
 870 #ifdef JP
 871 /*
 872  * ÆüËÜ¸ì¤Î¸Ä¿ôÉ½¼¨¥ë¡¼¥Á¥ó
 873  *¡Êcmd1.c ¤ÇÎ®ÍÑ¤¹¤ë¤¿¤á¤Ë object_desc_japanese ¤«¤é°ÜÆ°¤·¤¿¡£¡Ë
 874  */
 875
 876 char *object_desc_kosuu(char *t, object_type *o_ptr)
 877 {
 878     t = object_desc_num(t, o_ptr->number);
 879
 880     switch (o_ptr->tval)
 881     {
 882       case TV_BOLT:
 883       case TV_ARROW:
 884       case TV_POLEARM:
 885       case TV_STAFF:
 886       case TV_WAND:
 887       case TV_ROD:
 888       case TV_DIGGING:
 889       {
 890           t = object_desc_str(t, "ËÜ");
 891           break;
 892       }
 893       case TV_SCROLL:
 894       {
 895           t = object_desc_str(t, "´¬");
 896           break;
 897       }
 898       case TV_POTION:
 899       {
 900           t = object_desc_str(t, "Éþ");
 901           break;
 902       }
 903       case  TV_LIFE_BOOK:
 904       case  TV_SORCERY_BOOK:
 905       case  TV_NATURE_BOOK:
 906       case  TV_CHAOS_BOOK:
 907       case  TV_DEATH_BOOK:
 908       case  TV_TRUMP_BOOK:
 909       case  TV_ARCANE_BOOK:
 910       case  TV_ENCHANT_BOOK:
 911       case  TV_DAEMON_BOOK:
 912       case  TV_CRUSADE_BOOK:
 913       case  TV_MUSIC_BOOK:
 914       case  TV_HISSATSU_BOOK:
 915       {
 916           t = object_desc_str(t, "ºý");
 917           break;
 918       }
 919       case TV_SOFT_ARMOR:
 920       case TV_HARD_ARMOR:
 921       case TV_DRAG_ARMOR:
 922       case TV_CLOAK:
 923       {
 924           t = object_desc_str(t, "Ãå");
 925           break;
 926       }
 927       case TV_SWORD:
 928       case TV_HAFTED:
 929       case TV_BOW:
 930       {
 931           t = object_desc_str(t, "¿¶");
 932           break;
 933       }
 934       case TV_BOOTS:
 935       {
 936           t = object_desc_str(t, "");
 937           break;
 938       }
 939       case TV_CARD:
 940       {
 941           t = object_desc_str(t, "Ëç");
 942           break;
 943       }
 944             /* ¿©¤Ù¤â¤Î by ita */
 945       case TV_FOOD:
 946       {
 947           if(o_ptr->sval == SV_FOOD_JERKY)
 948           {
 949               t = object_desc_str(t, "ÀÚ¤ì");
 950               break;
 951           }
 952       }
 953       default:
 954       {
 955           if (o_ptr->number < 10)
 956           {
 957               t = object_desc_str(t, "¤Ä");
 958           }
 959           else
 960           {
 961               t = object_desc_str(t, "¸Ä");
 962           }
 963           break;
 964       }
 965   }
 966   return (t);
 967 }
 968 #endif
 969
 970 /*
 971  * Print an signed number "v" into a string "t", as if by
 972  * sprintf(t, "%+d", n), and return a pointer to the terminator.
 973  * Note that we always print a sign, either "+" or "-".
 974  */
 975 static char *object_desc_int(char *t, sint v)
 976 {
 977         uint p, n;
 978
 979         /* Negative */
 980         if (v < 0)
 981         {
 982                 /* Take the absolute value */
 983                 n = 0 - v;
 984
 985                 /* Use a "minus" sign */
 986                 *t++ = '-';
 987         }
 988
 989         /* Positive (or zero) */
 990         else
 991         {
 992                 /* Use the actual number */
 993                 n = v;
 994
 995                 /* Use a "plus" sign */
 996                 *t++ = '+';
 997         }
 998
 999         /* Find "size" of "n" */
1000         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
1001
1002         /* Dump each digit */
1003         while (p >= 1)
1004         {
1005                 /* Dump the digit */
1006                 *t++ = '0' + n / p;
1007
1008                 /* Remove the digit */
1009                 n = n % p;
1010
1011                 /* Process next digit */
1012                 p = p / 10;
1013         }
1014
1015         /* Terminate */
1016         *t = '\0';
1017
1018         /* Result */
1019         return (t);
1020 }
1021
1022
1023 /*
1024  * Structs and tables for Auto Inscription for flags
1025  */
1026
1027 typedef struct flag_insc_table
1028 {
1029 #ifdef JP
1030         cptr japanese;
1031 #endif
1032         cptr english;
1033         int flag;
1034         int except_flag;
1035 } flag_insc_table;
1036
1037 #ifdef JP
1038 static flag_insc_table flag_insc_plus[] =
1039 {
1040         { "¹¶", "At", TR_BLOWS, -1 },
1041         { "®", "Sp", TR_SPEED, -1 },
1042         { "ÏÓ", "St", TR_STR, -1 },
1043         { "ÃÎ", "In", TR_INT, -1 },
1044         { "¸", "Wi", TR_WIS, -1 },
1045         { "´ï", "Dx", TR_DEX, -1 },
1046         { "ÂÑ", "Cn", TR_CON, -1 },
1047         { "̥", "Ch", TR_CHR, -1 },
1048         { "ƻ", "Md", TR_MAGIC_MASTERY, -1 },
1049         { "±£", "Sl", TR_STEALTH, -1 },
1050         { "õ", "Sr", TR_SEARCH, -1 },
1051         { "ÀÖ", "If", TR_INFRA, -1 },
1052         { "·¡", "Dg", TR_TUNNEL, -1 },
1053         { NULL, NULL, 0, -1 }
1054 };
1055
1056 static flag_insc_table flag_insc_immune[] =
1057 {
1058         { "»À", "Ac", TR_IM_ACID, -1 },
1059         { "ÅÅ", "El", TR_IM_ELEC, -1 },
1060         { "²Ð", "Fi", TR_IM_FIRE, -1 },
1061         { "Îä", "Co", TR_IM_COLD, -1 },
1062         { NULL, NULL, 0, -1 }
1063 };
1064
1065 static flag_insc_table flag_insc_resistance[] =
1066 {
1067         { "»À", "Ac", TR_RES_ACID, TR_IM_ACID },
1068         { "ÅÅ", "El", TR_RES_ELEC, TR_IM_ELEC },
1069         { "²Ð", "Fi", TR_RES_FIRE, TR_IM_FIRE },
1070         { "Îä", "Co", TR_RES_COLD, TR_IM_COLD },
1071         { "ÆÇ", "Po", TR_RES_POIS, -1 },
1072         { "Á®", "Li", TR_RES_LITE, -1 },
1073         { "°Å", "Dk", TR_RES_DARK, -1 },
1074         { "ÇË", "Sh", TR_RES_SHARDS, -1 },
1075         { "ÌÕ", "Bl", TR_RES_BLIND, -1 },
1076         { "Íð", "Cf", TR_RES_CONF, -1 },
1077         { "¹ì", "So", TR_RES_SOUND, -1 },
1078         { "¹ö", "Nt", TR_RES_NETHER, -1 },
1079         { "°ø", "Nx", TR_RES_NEXUS, -1 },
1080         { "ÆÙ", "Ca", TR_RES_CHAOS, -1 },
1081         { "Îô", "Di", TR_RES_DISEN, -1 },
1082         { "¶²", "Fe", TR_RES_FEAR, -1 },
1083         { NULL, NULL, 0, -1 }
1084 };
1085
1086 static flag_insc_table flag_insc_misc[] =
1087 {
1088         { "ËâÎÏ", "Ma", TR_DEC_MANA, -1 },
1089         { "Åê", "Th", TR_THROW, -1 },
1090         { "ȿ", "Rf", TR_REFLECT, -1 },
1091         { "Ëã", "Fa", TR_FREE_ACT, -1 },
1092         { "»ë", "Si", TR_SEE_INVIS, -1 },
1093         { "·Ð", "Hl", TR_HOLD_LIFE, -1 },
1094         { "ÃÙ", "Sd", TR_SLOW_DIGEST, -1 },
1095         { "³è", "Rg", TR_REGEN, -1 },
1096         { "Éâ", "Lv", TR_FEATHER, -1 },
1097         { "ÌÀ", "Lu", TR_LITE, -1 },
1098         { "·Ù", "Wr", TR_WARNING, -1 },
1099         { "ÇÜ", "Xm", TR_XTRA_MIGHT, -1 },
1100         { "¼Í", "Xs", TR_XTRA_SHOTS, -1 },
1101         { "ÅÜ", "Ag", TR_AGGRAVATE, -1 },
1102         { "½Ë", "Bs", TR_BLESSED, -1 },
1103         { "´÷", "Ty", TR_TY_CURSE, -1 },
1104         { NULL, NULL, 0, -1 }
1105 };
1106
1107 static flag_insc_table flag_insc_aura[] =
1108 {
1109         { "±ê", "F", TR_SH_FIRE, -1 },
1110         { "ÅÅ", "E", TR_SH_ELEC, -1 },
1111         { "Îä", "C", TR_SH_COLD, -1 },
1112         { "Ëâ", "M", TR_NO_MAGIC, -1 },
1113         { "½Ö", "T", TR_NO_TELE, -1 },
1114         { NULL, NULL, 0, -1 }
1115 };
1116
1117 static flag_insc_table flag_insc_brand[] =
1118 {
1119         { "»À", "A", TR_BRAND_ACID, -1 },
1120         { "ÅÅ", "E", TR_BRAND_ELEC, -1 },
1121         { "¾Æ", "F", TR_BRAND_FIRE, -1 },
1122         { "Åà", "Co", TR_BRAND_COLD, -1 },
1123         { "ÆÇ", "P", TR_BRAND_POIS, -1 },
1124         { "ÆÙ", "Ca", TR_CHAOTIC, -1 },
1125         { "µÛ", "V", TR_VAMPIRIC, -1 },
1126         { "¿Ì", "Q", TR_IMPACT, -1 },
1127         { "ÀÚ", "S", TR_VORPAL, -1 },
1128         { "Íý", "M", TR_FORCE_WEAPON, -1 },
1129         { NULL, NULL, 0, -1 }
1130 };
1131
1132 static flag_insc_table flag_insc_kill[] =
1133 {
1134         { "¼Ù", "*", TR_KILL_EVIL, -1 },
1135         { "¿Í", "p", TR_KILL_HUMAN, -1 },
1136         { "ζ", "D", TR_KILL_DRAGON, -1 },
1137         { "¥ª", "o", TR_KILL_ORC, -1 },
1138         { "¥È", "T", TR_KILL_TROLL, -1 },
1139         { "µð", "P", TR_KILL_GIANT, -1 },
1140         { "¥Ç", "U", TR_KILL_DEMON, -1 },
1141         { "»à", "L", TR_KILL_UNDEAD, -1 },
1142         { "ư", "Z", TR_KILL_ANIMAL, -1 },
1143         { NULL, NULL, 0, -1 }
1144 };
1145
1146 static flag_insc_table flag_insc_slay[] =
1147 {
1148         { "¼Ù", "*", TR_SLAY_EVIL, TR_KILL_EVIL },
1149         { "¿Í", "p", TR_SLAY_HUMAN, TR_KILL_HUMAN },
1150         { "ε", "D", TR_SLAY_DRAGON, TR_KILL_DRAGON },
1151         { "¥ª", "o", TR_SLAY_ORC, TR_KILL_ORC },
1152         { "¥È", "T", TR_SLAY_TROLL, TR_KILL_TROLL },
1153         { "µð", "P", TR_SLAY_GIANT, TR_KILL_GIANT },
1154         { "¥Ç", "U", TR_SLAY_DEMON, TR_KILL_DEMON },
1155         { "»à", "L", TR_SLAY_UNDEAD, TR_KILL_UNDEAD },
1156         { "ư", "Z", TR_SLAY_ANIMAL, TR_KILL_ANIMAL },
1157         { NULL, NULL, 0, -1 }
1158 };
1159
1160 static flag_insc_table flag_insc_esp1[] =
1161 {
1162         { "´¶", "Tele", TR_TELEPATHY, -1 },
1163         { "¼Ù", "Evil", TR_ESP_EVIL, -1 },
1164         { "Á±", "Good", TR_ESP_GOOD, -1 },
1165         { "̵", "Nolv", TR_ESP_NONLIVING, -1 },
1166         { "¸Ä", "Uniq", TR_ESP_UNIQUE, -1 },
1167         { NULL, NULL, 0, -1 }
1168 };
1169
1170 static flag_insc_table flag_insc_esp2[] =
1171 {
1172         { "¿Í", "p", TR_ESP_HUMAN, -1 },
1173         { "ε", "D", TR_ESP_DRAGON, -1 },
1174         { "¥ª", "o", TR_ESP_ORC, -1 },
1175         { "¥È", "T", TR_ESP_TROLL, -1 },
1176         { "µð", "P", TR_ESP_GIANT, -1 },
1177         { "¥Ç", "U", TR_ESP_DEMON, -1 },
1178         { "»à", "L", TR_ESP_UNDEAD, -1 },
1179         { "ư", "Z", TR_ESP_ANIMAL, -1 },
1180         { NULL, NULL, 0, -1 }
1181 };
1182
1183 static flag_insc_table flag_insc_sust[] =
1184 {
1185         { "ÏÓ", "St", TR_SUST_STR, -1 },
1186         { "ÃÎ", "In", TR_SUST_INT, -1 },
1187         { "¸", "Wi", TR_SUST_WIS, -1 },
1188         { "´ï", "Dx", TR_SUST_DEX, -1 },
1189         { "ÂÑ", "Cn", TR_SUST_CON, -1 },
1190         { "̥", "Ch", TR_SUST_CHR, -1 },
1191         { NULL, NULL, 0, -1 }
1192 };
1193
1194 #else
1195 static flag_insc_table flag_insc_plus[] =
1196 {
1197         { "At", TR_BLOWS, -1 },
1198         { "Sp", TR_SPEED, -1 },
1199         { "St", TR_STR, -1 },
1200         { "In", TR_INT, -1 },
1201         { "Wi", TR_WIS, -1 },
1202         { "Dx", TR_DEX, -1 },
1203         { "Cn", TR_CON, -1 },
1204         { "Ch", TR_CHR, -1 },
1205         { "Md", TR_MAGIC_MASTERY, -1 },
1206         { "Sl", TR_STEALTH, -1 },
1207         { "Sr", TR_SEARCH, -1 },
1208         { "If", TR_INFRA, -1 },
1209         { "Dg", TR_TUNNEL, -1 },
1210         { NULL, 0, -1 }
1211 };
1212
1213 static flag_insc_table flag_insc_immune[] =
1214 {
1215         { "Ac", TR_IM_ACID, -1 },
1216         { "El", TR_IM_ELEC, -1 },
1217         { "Fi", TR_IM_FIRE, -1 },
1218         { "Co", TR_IM_COLD, -1 },
1219         { NULL, 0, -1 }
1220 };
1221
1222 static flag_insc_table flag_insc_resistance[] =
1223 {
1224         { "Ac", TR_RES_ACID, TR_IM_ACID },
1225         { "El", TR_RES_ELEC, TR_IM_ELEC },
1226         { "Fi", TR_RES_FIRE, TR_IM_FIRE },
1227         { "Co", TR_RES_COLD, TR_IM_COLD },
1228         { "Po", TR_RES_POIS, -1 },
1229         { "Li", TR_RES_LITE, -1 },
1230         { "Dk", TR_RES_DARK, -1 },
1231         { "Sh", TR_RES_SHARDS, -1 },
1232         { "Bl", TR_RES_BLIND, -1 },
1233         { "Cf", TR_RES_CONF, -1 },
1234         { "So", TR_RES_SOUND, -1 },
1235         { "Nt", TR_RES_NETHER, -1 },
1236         { "Nx", TR_RES_NEXUS, -1 },
1237         { "Ca", TR_RES_CHAOS, -1 },
1238         { "Di", TR_RES_DISEN, -1 },
1239         { "Fe", TR_RES_FEAR, -1 },
1240         { NULL, 0, -1 }
1241 };
1242
1243 static flag_insc_table flag_insc_misc[] =
1244 {
1245         { "Ma", TR_DEC_MANA, -1 },
1246         { "Th", TR_THROW, -1 },
1247         { "Rf", TR_REFLECT, -1 },
1248         { "Fa", TR_FREE_ACT, -1 },
1249         { "Si", TR_SEE_INVIS, -1 },
1250         { "Hl", TR_HOLD_LIFE, -1 },
1251         { "Sd", TR_SLOW_DIGEST, -1 },
1252         { "Rg", TR_REGEN, -1 },
1253         { "Lv", TR_FEATHER, -1 },
1254         { "Lu", TR_LITE, -1 },
1255         { "Wr", TR_WARNING, -1 },
1256         { "Xm", TR_XTRA_MIGHT, -1 },
1257         { "Xs", TR_XTRA_SHOTS, -1 },
1258         { "Ag", TR_AGGRAVATE, -1 },
1259         { "Bs", TR_BLESSED, -1 },
1260         { "Ty", TR_TY_CURSE, -1 },
1261         { NULL, 0, -1 }
1262 };
1263
1264 static flag_insc_table flag_insc_aura[] =
1265 {
1266         { "F", TR_SH_FIRE, -1 },
1267         { "E", TR_SH_ELEC, -1 },
1268         { "C", TR_SH_COLD, -1 },
1269         { "M", TR_NO_MAGIC, -1 },
1270         { "T", TR_NO_TELE, -1 },
1271         { NULL, 0, -1 }
1272 };
1273
1274 static flag_insc_table flag_insc_brand[] =
1275 {
1276         { "A", TR_BRAND_ACID, -1 },
1277         { "E", TR_BRAND_ELEC, -1 },
1278         { "F", TR_BRAND_FIRE, -1 },
1279         { "Co", TR_BRAND_COLD, -1 },
1280         { "P", TR_BRAND_POIS, -1 },
1281         { "Ca", TR_CHAOTIC, -1 },
1282         { "V", TR_VAMPIRIC, -1 },
1283         { "Q", TR_IMPACT, -1 },
1284         { "S", TR_VORPAL, -1 },
1285         { "M", TR_FORCE_WEAPON, -1 },
1286         { NULL, 0, -1 }
1287 };
1288
1289 static flag_insc_table flag_insc_kill[] =
1290 {
1291         { "*", TR_KILL_EVIL, -1 },
1292         { "p", TR_KILL_HUMAN, -1 },
1293         { "D", TR_KILL_DRAGON, -1 },
1294         { "o", TR_KILL_ORC, -1 },
1295         { "T", TR_KILL_TROLL, -1 },
1296         { "P", TR_KILL_GIANT, -1 },
1297         { "U", TR_KILL_DEMON, -1 },
1298         { "L", TR_KILL_UNDEAD, -1 },
1299         { "Z", TR_KILL_ANIMAL, -1 },
1300         { NULL, 0, -1 }
1301 };
1302
1303 static flag_insc_table flag_insc_slay[] =
1304 {
1305         { "*", TR_SLAY_EVIL, TR_KILL_EVIL },
1306         { "p", TR_SLAY_HUMAN, TR_KILL_HUMAN },
1307         { "D", TR_SLAY_DRAGON, TR_KILL_DRAGON },
1308         { "o", TR_SLAY_ORC, TR_KILL_ORC },
1309         { "T", TR_SLAY_TROLL, TR_KILL_TROLL },
1310         { "P", TR_SLAY_GIANT, TR_KILL_GIANT },
1311         { "U", TR_SLAY_DEMON, TR_KILL_DEMON },
1312         { "L", TR_SLAY_UNDEAD, TR_KILL_UNDEAD },
1313         { "Z", TR_SLAY_ANIMAL, TR_KILL_ANIMAL },
1314         { NULL, 0, -1 }
1315 };
1316
1317 static flag_insc_table flag_insc_esp1[] =
1318 {
1319         { "Tele", TR_TELEPATHY, -1 },
1320         { "Evil", TR_ESP_EVIL, -1 },
1321         { "Good", TR_ESP_GOOD, -1 },
1322         { "Nolv", TR_ESP_NONLIVING, -1 },
1323         { "Uniq", TR_ESP_UNIQUE, -1 },
1324         { NULL, 0, -1 }
1325 };
1326
1327 static flag_insc_table flag_insc_esp2[] =
1328 {
1329         { "p", TR_ESP_HUMAN, -1 },
1330         { "D", TR_ESP_DRAGON, -1 },
1331         { "o", TR_ESP_ORC, -1 },
1332         { "T", TR_ESP_TROLL, -1 },
1333         { "P", TR_ESP_GIANT, -1 },
1334         { "U", TR_ESP_DEMON, -1 },
1335         { "L", TR_ESP_UNDEAD, -1 },
1336         { "Z", TR_ESP_ANIMAL, -1 },
1337         { NULL, 0, -1 }
1338 };
1339
1340 static flag_insc_table flag_insc_sust[] =
1341 {
1342         { "St", TR_SUST_STR, -1 },
1343         { "In", TR_SUST_INT, -1 },
1344         { "Wi", TR_SUST_WIS, -1 },
1345         { "Dx", TR_SUST_DEX, -1 },
1346         { "Cn", TR_SUST_CON, -1 },
1347         { "Ch", TR_SUST_CHR, -1 },
1348         { NULL, 0, -1 }
1349 };
1350 #endif
1351
1352 /* Simple macro for get_inscription() */
1353 #define ADD_INSC(STR) (void)(ptr = object_desc_str(ptr, (STR)))
1354
1355 /*
1356  *  Helper function for get_inscription()
1357  */
1358 static char *inscribe_flags_aux(flag_insc_table *fi_ptr, u32b flgs[TR_FLAG_SIZE], bool kanji, char *ptr)
1359 {
1360         while (fi_ptr->english)
1361         {
1362                 if (have_flag(flgs, fi_ptr->flag) &&
1363                     (fi_ptr->except_flag == -1 || !have_flag(flgs, fi_ptr->except_flag)))
1364 #ifdef JP
1365                         ADD_INSC(kanji ? fi_ptr->japanese : fi_ptr->english);
1366 #else
1367                         ADD_INSC(fi_ptr->english);
1368 #endif
1369                 fi_ptr++;
1370         }
1371
1372         return ptr;
1373 }
1374
1375
1376 /*
1377  *  Special variation of have_flag for auto-inscription
1378  */
1379 static bool have_flag_of(flag_insc_table *fi_ptr, u32b flgs[TR_FLAG_SIZE])
1380 {
1381         while (fi_ptr->english)
1382         {
1383                 if (have_flag(flgs, fi_ptr->flag) &&
1384                    (fi_ptr->except_flag == -1 || !have_flag(flgs, fi_ptr->except_flag)))
1385                         return (TRUE);
1386                 fi_ptr++;
1387         }
1388
1389         return (FALSE);
1390 }
1391
1392
1393 /*
1394  *  Get object inscription with auto inscription of object flags.
1395  */
1396 static void get_inscription(char *buff, object_type *o_ptr)
1397 {
1398         cptr insc = quark_str(o_ptr->inscription);
1399         char *ptr = buff;
1400         char *prev_ptr = buff;
1401
1402         u32b flgs[TR_FLAG_SIZE];
1403
1404         /* Not fully identified */
1405         if (!(o_ptr->ident & IDENT_MENTAL))
1406         {
1407                 /* Copy until end of line or '#' */
1408                 while (*insc)
1409                 {
1410                         if (*insc == '#') break;
1411 #ifdef JP
1412                         if (iskanji(*insc)) *buff++ = *insc++;
1413 #endif
1414                         *buff++ = *insc++;
1415                 }
1416
1417                 *buff = '\0';
1418                 return;
1419         }
1420
1421         /* Extract the flags */
1422         object_flags(o_ptr, flgs);
1423
1424
1425         *buff = '\0';
1426         for (; *insc; insc++)
1427         {
1428                 bool kanji = FALSE;
1429                 bool all;
1430
1431                 /* Ignore fake artifact inscription */
1432                 if (*insc == '#') break;
1433
1434                 /* {%} will be automatically converted */
1435                 else if ('%' == *insc)
1436                 {
1437                         cptr start_percent = ptr;
1438 #ifdef JP
1439                         if ('%' == insc[1])
1440                         {
1441                                 insc++;
1442                                 kanji = FALSE;
1443                         }
1444                         else
1445                         {
1446                                 kanji = TRUE;
1447                         }
1448 #endif
1449                         if ('a' == insc[1] && 'l' == insc[2] && 'l' == insc[3])
1450                         {
1451                                 all = TRUE;
1452                                 insc += 3;
1453                         }
1454                         else
1455                         {
1456                                 all = FALSE;
1457                         }
1458
1459                         /* check for too long inscription */
1460                         if (ptr >= buff + MAX_NLEN) continue;
1461
1462                         /* Remove obvious flags */
1463                         if (!all)
1464                         {
1465                                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
1466                                 int j;
1467
1468                                 /* Base object */
1469                                 for (j = 0; j < TR_FLAG_SIZE; j++)
1470                                         flgs[j] &= ~k_ptr->flags[j];
1471
1472                                 if (o_ptr->name1)
1473                                 {
1474                                         artifact_type *a_ptr = &a_info[o_ptr->name1];
1475
1476                                         for (j = 0; j < TR_FLAG_SIZE; j++)
1477                                                 flgs[j] &= ~a_ptr->flags[j];
1478                                 }
1479
1480                                 if (o_ptr->name2)
1481                                 {
1482                                         bool teleport = have_flag(flgs, TR_TELEPORT);
1483                                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
1484
1485                                         for (j = 0; j < TR_FLAG_SIZE; j++)
1486                                                 flgs[j] &= ~e_ptr->flags[j];
1487
1488                                         /* Always inscribe {.} for random teleport */
1489                                         if (teleport) add_flag(flgs, TR_TELEPORT);
1490                                 }
1491                         }
1492
1493
1494                         /* Plusses */
1495                         if (have_flag_of(flag_insc_plus, flgs))
1496                         {
1497                                 if (kanji)
1498                                         ADD_INSC("+");
1499                         }
1500                         ptr = inscribe_flags_aux(flag_insc_plus, flgs, kanji, ptr);
1501
1502                         /* Immunity */
1503                         if (have_flag_of(flag_insc_immune, flgs))
1504                         {
1505                                 if (!kanji && ptr != prev_ptr)
1506                                 {
1507                                         ADD_INSC(";");
1508                                         prev_ptr = ptr;
1509                                 }
1510                                 ADD_INSC("*");
1511                         }
1512                         ptr = inscribe_flags_aux(flag_insc_immune, flgs, kanji, ptr);
1513
1514                         /* Resistance */
1515                         if (have_flag_of(flag_insc_resistance, flgs))
1516                         {
1517                                 if (kanji)
1518                                         ADD_INSC("r");
1519                                 else if (ptr != prev_ptr)
1520                                 {
1521                                         ADD_INSC(";");
1522                                         prev_ptr = ptr;
1523                                 }
1524                         }
1525                         ptr = inscribe_flags_aux(flag_insc_resistance, flgs, kanji, ptr);
1526
1527                         /* Misc Ability */
1528                         if (have_flag_of(flag_insc_misc, flgs))
1529                         {
1530                                 if (ptr != prev_ptr)
1531                                 {
1532                                         ADD_INSC(";");
1533                                         prev_ptr = ptr;
1534                                 }
1535                         }
1536                         ptr = inscribe_flags_aux(flag_insc_misc, flgs, kanji, ptr);
1537
1538                         /* Aura */
1539                         if (have_flag_of(flag_insc_aura, flgs))
1540                         {
1541                                 ADD_INSC("[");
1542                         }
1543                         ptr = inscribe_flags_aux(flag_insc_aura, flgs, kanji, ptr);
1544
1545                         /* Brand Weapon */
1546                         if (have_flag_of(flag_insc_brand, flgs))
1547                                 ADD_INSC("|");
1548                         ptr = inscribe_flags_aux(flag_insc_brand, flgs, kanji, ptr);
1549
1550                         /* Kill Weapon */
1551                         if (have_flag_of(flag_insc_kill, flgs))
1552                                 ADD_INSC("/X");
1553                         ptr = inscribe_flags_aux(flag_insc_kill, flgs, kanji, ptr);
1554
1555                         /* Slay Weapon */
1556                         if (have_flag_of(flag_insc_slay, flgs))
1557                                 ADD_INSC("/");
1558                         ptr = inscribe_flags_aux(flag_insc_slay, flgs, kanji, ptr);
1559
1560                         /* Esp */
1561                         if (kanji)
1562                         {
1563                                 if (have_flag_of(flag_insc_esp1, flgs) ||
1564                                     have_flag_of(flag_insc_esp2, flgs))
1565                                         ADD_INSC("~");
1566                                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1567                                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1568                         }
1569                         else
1570                         {
1571                                 if (have_flag_of(flag_insc_esp1, flgs))
1572                                         ADD_INSC("~");
1573                                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1574                                 if (have_flag_of(flag_insc_esp2, flgs))
1575                                         ADD_INSC("~");
1576                                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1577                         }
1578
1579                         /* Random Teleport */
1580                         if (have_flag(flgs, TR_TELEPORT))
1581                         {
1582                                 ADD_INSC(".");
1583                         }
1584
1585                         /* sustain */
1586                         if (have_flag_of(flag_insc_sust, flgs))
1587                         {
1588                                 ADD_INSC("(");
1589                         }
1590                         ptr = inscribe_flags_aux(flag_insc_sust, flgs, kanji, ptr);
1591
1592                         if (ptr == start_percent)
1593                                 ADD_INSC(" ");
1594                 }
1595                 else
1596                 {
1597                         *ptr++ = *insc;
1598                 }
1599         }
1600         *ptr = '\0';
1601 }
1602
1603
1604
1605 /*
1606  * Creates a description of the item "o_ptr", and stores it in "out_val".
1607  *
1608  * One can choose the "verbosity" of the description, including whether
1609  * or not the "number" of items should be described, and how much detail
1610  * should be used when describing the item.
1611  *
1612  * The given "buf" must be MAX_NLEN chars long to hold the longest possible
1613  * description, which can get pretty long, including incriptions, such as:
1614  * "no more Maces of Disruption (Defender) (+10,+10) [+5] (+3 to stealth)".
1615  * Note that the inscription will be clipped to keep the total description
1616  * under MAX_NLEN-1 chars (plus a terminator).
1617  *
1618  * Note the use of "object_desc_num()" and "object_desc_int()" as hyper-efficient,
1619  * portable, versions of some common "sprintf()" commands.
1620  *
1621  * Note that all ego-items (when known) append an "Ego-Item Name", unless
1622  * the item is also an artifact, which should NEVER happen.
1623  *
1624  * Note that all artifacts (when known) append an "Artifact Name", so we
1625  * have special processing for "Specials" (artifact Lites, Rings, Amulets).
1626  * The "Specials" never use "modifiers" if they are "known", since they
1627  * have special "descriptions", such as "The Necklace of the Dwarves".
1628  *
1629  * Special Lite's use the "k_info" base-name (Phial, Star, or Arkenstone),
1630  * plus the artifact name, just like any other artifact, if known.
1631  *
1632  * Special Ring's and Amulet's, if not "aware", use the same code as normal
1633  * rings and amulets, and if "aware", use the "k_info" base-name (Ring or
1634  * Amulet or Necklace).  They will NEVER "append" the "k_info" name.  But,
1635  * they will append the artifact name, just like any artifact, if known.
1636  *
1637  * Hack -- Display "The One Ring" as "a Plain Gold Ring" until aware.
1638  *
1639  * If "pref" then a "numeric" prefix will be pre-pended.
1640  *
1641  * Mode:
1642  *   0 -- The Cloak of Death
1643  *   1 -- The Cloak of Death [1,+3]
1644  *   2 -- The Cloak of Death [1,+3] (+2 to Stealth)
1645  *   3 -- The Cloak of Death [1,+3] (+2 to Stealth) {nifty}
1646  */
1647 void object_desc(char *buf, object_type *o_ptr, int pref, int mode)
1648 {
1649         cptr            basenm, modstr;
1650         int             power, indexx, i;
1651
1652         bool            aware = FALSE;
1653         bool            known = FALSE;
1654
1655         bool            append_name = FALSE;
1656
1657         bool            show_weapon = FALSE;
1658         bool            show_armour = FALSE;
1659
1660         cptr            s, u;
1661         char            *t;
1662
1663         char            p1 = '(', p2 = ')';
1664         char            b1 = '[', b2 = ']';
1665         char            c1 = '{', c2 = '}';
1666
1667         char            tmp_val[MAX_NLEN+160];
1668         char            tmp_val2[MAX_NLEN+10];
1669
1670         u32b flgs[TR_FLAG_SIZE];
1671
1672         object_type     *bow_ptr;
1673
1674
1675         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1676
1677         /* Extract some flags */
1678         object_flags(o_ptr, flgs);
1679
1680         /* See if the object is "aware" */
1681         if (object_aware_p(o_ptr) || (o_ptr->ident & IDENT_MENTAL)) aware = TRUE;
1682
1683         /* See if the object is "known" */
1684         if (object_known_p(o_ptr)) known = TRUE;
1685
1686         /* Hack -- Extract the sub-type "indexx" */
1687         indexx = o_ptr->sval;
1688
1689         /* Extract default "base" string */
1690         basenm = get_object_name(o_ptr);
1691
1692         /* Assume no "modifier" string */
1693         modstr = "";
1694
1695
1696         /* Analyze the object */
1697         switch (o_ptr->tval)
1698         {
1699                 /* Some objects are easy to describe */
1700                 case TV_SKELETON:
1701                 case TV_BOTTLE:
1702                 case TV_JUNK:
1703                 case TV_SPIKE:
1704                 case TV_FLASK:
1705                 case TV_CHEST:
1706                 case TV_WHISTLE:
1707                 {
1708                         break;
1709                 }
1710
1711                 case TV_CAPTURE:
1712                 {
1713                         monster_race *r_ptr = &r_info[o_ptr->pval];
1714
1715                         if (known)
1716                         {
1717                                 if (!o_ptr->pval)
1718                                 {
1719 #ifdef JP
1720                                         modstr = "¡Ê¶õ¡Ë";
1721 #else
1722                                         modstr = " (empty)";
1723 #endif
1724                                 }
1725                                 else
1726                                 {
1727 #ifdef JP
1728                                         sprintf(tmp_val2, "¡Ê%s¡Ë",r_name + r_ptr->name);
1729                                         modstr = tmp_val2;
1730 #else
1731                                         cptr t = r_name + r_ptr->name;
1732
1733                                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1734                                         {
1735                                                 sprintf(tmp_val2, " (%s%s)", (is_a_vowel(*t) ? "an " : "a "), t);
1736
1737                                                 modstr = tmp_val2;
1738                                         }
1739                                         else
1740                                         {
1741                                                 sprintf(tmp_val2, "(%s)", t);
1742
1743                                                 modstr = t;
1744                                         }
1745 #endif
1746                                 }
1747                         }
1748                         break;
1749                 }
1750
1751                 /* Figurines/Statues */
1752                 case TV_FIGURINE:
1753                 case TV_STATUE:
1754                 {
1755                         monster_race *r_ptr = &r_info[o_ptr->pval];
1756
1757 #ifdef JP
1758                         modstr = r_name + r_ptr->name;
1759 #else
1760                         cptr t = r_name + r_ptr->name;
1761
1762                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1763                         {
1764                                 sprintf(tmp_val2, "%s%s", (is_a_vowel(*t) ? "an " : "a "), t);
1765
1766                                 modstr = tmp_val2;
1767                         }
1768                         else
1769                         {
1770                                 modstr = t;
1771                         }
1772 #endif
1773
1774
1775                         break;
1776                 }
1777
1778                 /* Corpses */
1779                 case TV_CORPSE:
1780                 {
1781                         monster_race *r_ptr = &r_info[o_ptr->pval];
1782
1783                         modstr = r_name + r_ptr->name;
1784
1785
1786 #ifdef JP
1787                         sprintf(tmp_val2, "#%s", basenm);
1788 #else
1789                         if (r_ptr->flags1 & RF1_UNIQUE)
1790                         {
1791                                 sprintf(tmp_val2, "& %s %s", basenm, "of #");
1792                         }
1793                         else
1794                         {
1795                                 sprintf(tmp_val2, "& # %s", basenm);
1796                         }
1797 #endif
1798
1799
1800                         basenm = tmp_val2;
1801                         break;
1802                 }
1803
1804                 /* Missiles/ Bows/ Weapons */
1805                 case TV_SHOT:
1806                 case TV_BOLT:
1807                 case TV_ARROW:
1808                 case TV_BOW:
1809                 case TV_HAFTED:
1810                 case TV_POLEARM:
1811                 case TV_SWORD:
1812                 case TV_DIGGING:
1813                 {
1814                         show_weapon = TRUE;
1815                         break;
1816                 }
1817
1818
1819                 /* Armour */
1820                 case TV_BOOTS:
1821                 case TV_GLOVES:
1822                 case TV_CLOAK:
1823                 case TV_CROWN:
1824                 case TV_HELM:
1825                 case TV_SHIELD:
1826                 case TV_SOFT_ARMOR:
1827                 case TV_HARD_ARMOR:
1828                 case TV_DRAG_ARMOR:
1829                 {
1830                         show_armour = TRUE;
1831                         break;
1832                 }
1833
1834
1835                 /* Lites (including a few "Specials") */
1836                 case TV_LITE:
1837                 {
1838                         break;
1839                 }
1840
1841                 /* Amulets (including a few "Specials") */
1842                 case TV_AMULET:
1843                 {
1844                         /* Known artifacts */
1845                         if (artifact_p(o_ptr) && aware) break;
1846
1847                         if ((k_ptr->gen_flags & TRG_INSTA_ART) && aware) break;
1848
1849                         /* Color the object */
1850                         modstr = amulet_adj[indexx];
1851
1852                         if (aware) append_name = TRUE;
1853
1854                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1855 #ifdef JP
1856                                 basenm = aware ? "%¤Î¥¢¥ß¥å¥ì¥Ã¥È" : "¥¢¥ß¥å¥ì¥Ã¥È";
1857                         else
1858                                 basenm = aware ? "#%¤Î¥¢¥ß¥å¥ì¥Ã¥È" : "#¥¢¥ß¥å¥ì¥Ã¥È";
1859 #else
1860                                 basenm = "& Amulet~";
1861                         else
1862                                 basenm = aware ? "& # Amulet~" : "& # Amulet~";
1863 #endif
1864
1865                         break;
1866                 }
1867
1868                 /* Rings (including a few "Specials") */
1869                 case TV_RING:
1870                 {
1871                         /* Known artifacts */
1872                         if (artifact_p(o_ptr) && aware) break;
1873
1874                         if ((k_ptr->gen_flags & TRG_INSTA_ART) && aware) break;
1875
1876                         /* Color the object */
1877                         modstr = ring_adj[indexx];
1878
1879                         if (aware) append_name = TRUE;
1880
1881                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1882 #ifdef JP
1883                                 basenm = aware ? "%¤Î»ØÎØ" : "»ØÎØ";
1884                         else
1885                                 basenm = aware ? "#%¤Î»ØÎØ" : "#»ØÎØ";
1886 #else
1887                                 basenm = "& Ring~";
1888                         else
1889                                 basenm = aware ? "& # Ring~" : "& # Ring~";
1890 #endif
1891
1892                         if (!k_ptr->to_h && !k_ptr->to_d && (o_ptr->to_h || o_ptr->to_d)) show_weapon = TRUE;
1893
1894                         break;
1895                 }
1896
1897                 case TV_CARD:
1898                 {
1899                         break;
1900                 }
1901
1902                 case TV_STAFF:
1903                 {
1904                         /* Color the object */
1905                         modstr = staff_adj[indexx];
1906
1907                         if (aware) append_name = TRUE;
1908                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1909 #ifdef JP
1910                                 basenm = aware ? "%¤Î¾ó" : "¾ó";
1911                         else
1912                                 basenm = aware ? "#%¤Î¾ó" : "#¾ó";
1913 #else
1914                                 basenm = "& Staff~";
1915                         else
1916                                 basenm = aware ? "& # Staff~" : "& # Staff~";
1917 #endif
1918
1919                         break;
1920                 }
1921
1922                 case TV_WAND:
1923                 {
1924                         /* Color the object */
1925                         modstr = wand_adj[indexx];
1926
1927                         if (aware) append_name = TRUE;
1928                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1929 #ifdef JP
1930                                 basenm = aware? "%¤ÎËâË¡ËÀ":"ËâË¡ËÀ";
1931                         else
1932                                 basenm = aware ? "#%¤ÎËâË¡ËÀ" : "#ËâË¡ËÀ";
1933 #else
1934                                 basenm = "& Wand~";
1935                         else
1936                                 basenm = aware ? "& # Wand~" : "& # Wand~";
1937 #endif
1938
1939                         break;
1940                 }
1941
1942                 case TV_ROD:
1943                 {
1944                         /* Color the object */
1945                         modstr = rod_adj[indexx];
1946
1947                         if (aware) append_name = TRUE;
1948                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1949 #ifdef JP
1950                                 basenm = aware? "%¤Î¥í¥Ã¥É":"¥í¥Ã¥É";
1951                         else
1952                                 basenm = aware ? "#%¤Î¥í¥Ã¥É" : "#¥í¥Ã¥É";
1953 #else
1954                                 basenm = "& Rod~";
1955                         else
1956                                 basenm = aware ? "& # Rod~" : "& # Rod~";
1957 #endif
1958
1959                         break;
1960                 }
1961
1962                 case TV_SCROLL:
1963                 {
1964                         /* Color the object */
1965                         modstr = scroll_adj[indexx];
1966                         if (aware) append_name = TRUE;
1967                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1968 #ifdef JP
1969                                 basenm = aware ? "%¤Î´¬Êª" : "´¬Êª";
1970                         else
1971                                 basenm = aware ? "¡Ö#¡×¤È½ñ¤«¤ì¤¿%¤Î´¬Êª" : "¡Ö#¡×¤È½ñ¤«¤ì¤¿´¬Êª";
1972 #else
1973                                 basenm = "& Scroll~";
1974                         else
1975                                 basenm = aware ? "& Scroll~ titled \"#\"" : "& Scroll~ titled \"#\"";
1976 #endif
1977
1978                         break;
1979                 }
1980
1981                 case TV_POTION:
1982                 {
1983                         /* Color the object */
1984                         modstr = potion_adj[indexx];
1985
1986                         if (aware) append_name = TRUE;
1987                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1988 #ifdef JP
1989                                 basenm = aware ? "%¤ÎÌô" : "Ìô";
1990                         else
1991                                 basenm = aware ? "#%¤ÎÌô" : "#Ìô";
1992 #else
1993                                 basenm = "& Potion~";
1994                         else
1995                                 basenm = aware ? "& # Potion~" : "& # Potion~";
1996 #endif
1997
1998                         break;
1999                 }
2000
2001                 case TV_FOOD:
2002                 {
2003                         /* Ordinary food is "boring" */
2004                         if (o_ptr->sval >= SV_FOOD_MIN_FOOD) break;
2005
2006                         /* Color the object */
2007                         modstr = food_adj[indexx];
2008
2009                         if (aware) append_name = TRUE;
2010                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
2011 #ifdef JP
2012                                 basenm = aware ? "%¤Î¥¥Î¥³" : "¥¥Î¥³";
2013                         else
2014                                 basenm = aware ? "#%¤Î¥¥Î¥³" : "#¥¥Î¥³";
2015 #else
2016                                 basenm = "& Mushroom~";
2017                         else
2018                                 basenm = aware ? "& # Mushroom~" : "& # Mushroom~";
2019 #endif
2020
2021                         break;
2022                 }
2023
2024                 case TV_PARCHEMENT:
2025                 {
2026                         modstr = basenm;
2027 #ifdef JP
2028                         basenm = "ÍÓÈé»æ - #";
2029 #else
2030                         basenm = "& Parchement~ - #";
2031 #endif
2032                         break;
2033                 }
2034
2035                 /* Magic Books */
2036                 case TV_LIFE_BOOK:
2037                 {
2038                         modstr = basenm;
2039 #ifdef JP
2040                                 basenm = "À¸Ì¿¤ÎËâË¡½ñ#";
2041 #else
2042                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2043                                 basenm = "& Book~ of Life Magic #";
2044                         else
2045                                 basenm = "& Life Spellbook~ #";
2046 #endif
2047
2048                         break;
2049                 }
2050
2051                 case TV_SORCERY_BOOK:
2052                 {
2053                         modstr = basenm;
2054 #ifdef JP
2055                                 basenm = "Àç½Ñ¤ÎËâË¡½ñ#";
2056 #else
2057                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2058                                 basenm = "& Book~ of Sorcery #";
2059                         else
2060                                 basenm = "& Sorcery Spellbook~ #";
2061 #endif
2062
2063                         break;
2064                 }
2065
2066                 case TV_NATURE_BOOK:
2067                 {
2068                         modstr = basenm;
2069 #ifdef JP
2070                                 basenm = "¼«Á³¤ÎËâË¡½ñ#";
2071 #else
2072                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2073                                 basenm = "& Book~ of Nature Magic #";
2074                         else
2075                                 basenm = "& Nature Spellbook~ #";
2076 #endif
2077
2078                         break;
2079                 }
2080
2081                 case TV_CHAOS_BOOK:
2082                 {
2083                         modstr = basenm;
2084 #ifdef JP
2085                                 basenm = "¥«¥ª¥¹¤ÎËâË¡½ñ#";
2086 #else
2087                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2088                                 basenm = "& Book~ of Chaos Magic #";
2089                         else
2090                                 basenm = "& Chaos Spellbook~ #";
2091 #endif
2092
2093                         break;
2094                 }
2095
2096                 case TV_DEATH_BOOK:
2097                 {
2098                         modstr = basenm;
2099 #ifdef JP
2100                                 basenm = "°Å¹õ¤ÎËâË¡½ñ#";
2101 #else
2102                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2103                                 basenm = "& Book~ of Death Magic #";
2104                         else
2105                                 basenm = "& Death Spellbook~ #";
2106 #endif
2107
2108                         break;
2109                 }
2110
2111                 case TV_TRUMP_BOOK:
2112                 {
2113                         modstr = basenm;
2114 #ifdef JP
2115                                 basenm = "¥È¥é¥ó¥×¤ÎËâË¡½ñ#";
2116 #else
2117                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2118                                 basenm = "& Book~ of Trump Magic #";
2119                         else
2120                                 basenm = "& Trump Spellbook~ #";
2121 #endif
2122
2123                         break;
2124                 }
2125
2126                 case TV_ARCANE_BOOK:
2127                 {
2128                         modstr = basenm;
2129 #ifdef JP
2130                                 basenm = "Èë½Ñ¤ÎËâË¡½ñ#";
2131 #else
2132                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2133                                 basenm = "& Book~ of Arcane Magic #";
2134                         else
2135                                 basenm = "& Arcane Spellbook~ #";
2136 #endif
2137
2138                         break;
2139                 }
2140                 case TV_ENCHANT_BOOK:
2141                 {
2142                         modstr = basenm;
2143 #ifdef JP
2144                                 basenm = "¾¢¤ÎËâË¡½ñ#";
2145 #else
2146                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2147                                 basenm = "& Book~ of Craft Magic #";
2148                         else
2149                                 basenm = "& Craft Spellbook~ #";
2150 #endif
2151
2152                         break;
2153                 }
2154                 case TV_DAEMON_BOOK:
2155                 {
2156                         modstr = basenm;
2157 #ifdef JP
2158                                 basenm = "°Ëâ¤ÎËâË¡½ñ#";
2159 #else
2160                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2161                                 basenm = "& Book~ of Daemon Magic #";
2162                         else
2163                                 basenm = "& Daemon Spellbook~ #";
2164 #endif
2165
2166                         break;
2167                 }
2168                 case TV_CRUSADE_BOOK:
2169                 {
2170                         modstr = basenm;
2171 #ifdef JP
2172                                 basenm = "ÇË¼Ù¤ÎËâË¡½ñ#";
2173 #else
2174                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2175                                 basenm = "& Book~ of Crusade Magic #";
2176                         else
2177                                 basenm = "& Crusade Spellbook~ #";
2178 #endif
2179
2180                         break;
2181                 }
2182                 case TV_MUSIC_BOOK:
2183                 {
2184                         modstr = basenm;
2185 #ifdef JP
2186                                 basenm = "²Î½¸#";
2187 #else
2188                                 basenm = "& Song Book~ #";
2189 #endif
2190
2191                         break;
2192                 }
2193                 case TV_HISSATSU_BOOK:
2194                 {
2195                         modstr = basenm;
2196 #ifdef JP
2197                                 basenm = "& Éð·Ý¤Î½ñ#";
2198 #else
2199                                 basenm = "Book~ of Kendo #";
2200 #endif
2201
2202                         break;
2203                 }
2204
2205
2206
2207                 /* Hack -- Gold/Gems */
2208                 case TV_GOLD:
2209                 {
2210                         strcpy(buf, basenm);
2211                         return;
2212                 }
2213
2214                 /* Used in the "inventory" routine */
2215                 default:
2216                 {
2217 #ifdef JP
2218                         strcpy(buf, "(¤Ê¤·)");
2219 #else
2220                         strcpy(buf, "(nothing)");
2221 #endif
2222
2223                         return;
2224                 }
2225         }
2226
2227         /* Use full name from k_info or a_info */
2228         if (aware && have_flag(flgs, TR_FULL_NAME))
2229         {
2230                 if (known && o_ptr->name1) basenm = a_name + a_info[o_ptr->name1].name;
2231                 else basenm = get_object_name(o_ptr);
2232                 append_name = FALSE;
2233         }
2234
2235         /* Start dumping the result */
2236         t = tmp_val;
2237
2238 #ifdef JP
2239         if (basenm[0] == '&')
2240                 s = basenm + 2;
2241         else
2242                 s = basenm;
2243
2244         /* No prefix */
2245         if (!pref)
2246         {
2247                 /* Nothing */
2248         }
2249         else if (o_ptr->number > 1)
2250         {
2251                 if ( change_numeral == FALSE ){
2252                         t = object_desc_num(t, o_ptr->number);
2253                         if (o_ptr->number > 9)
2254                                 t = object_desc_str(t, "¸Ä¤Î ");
2255                         else
2256                                 t = object_desc_str(t, "¤Ä¤Î ");
2257                 }
2258                 else
2259                 {
2260                         t = object_desc_kosuu(t,o_ptr);
2261                         t = object_desc_str(t, "¤Î ");
2262                 }
2263         }
2264
2265         /* ±Ñ¸ì¤Î¾ì¹ç¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Ï The ¤¬ÉÕ¤¯¤Î¤ÇÊ¬¤«¤ë¤¬
2266          * ÆüËÜ¸ì¤Ç¤ÏÊ¬¤«¤é¤Ê¤¤¤Î¤Ç¥Þ¡¼¥¯¤ò¤Ä¤±¤ë
2267          */
2268         if (known && artifact_p(o_ptr)) t = object_desc_str(t, "¡ú");
2269         else if (known && o_ptr->art_name) t = object_desc_str(t, "¡ù");
2270
2271 #else
2272
2273         /* The object "expects" a "number" */
2274         if (basenm[0] == '&')
2275         {
2276                 /* Skip the ampersand (and space) */
2277                 s = basenm + 2;
2278
2279                 /* No prefix */
2280                 if (!pref)
2281                 {
2282                         /* Nothing */
2283                 }
2284
2285                 /* Hack -- None left */
2286                 else if (o_ptr->number <= 0)
2287                 {
2288                         t = object_desc_str(t, "no more ");
2289                 }
2290
2291                 /* Extract the number */
2292                 else if (o_ptr->number > 1)
2293                 {
2294                         t = object_desc_num(t, o_ptr->number);
2295                         t = object_desc_chr(t, ' ');
2296                 }
2297
2298                 /* Hack -- The only one of its kind */
2299                 else if (known && (artifact_p(o_ptr) || o_ptr->art_name))
2300                 {
2301                         t = object_desc_str(t, "The ");
2302                 }
2303
2304                 /* Unique corpses are unique */
2305                 else if (o_ptr->tval == TV_CORPSE)
2306                 {
2307                         monster_race *r_ptr = &r_info[o_ptr->pval];
2308
2309                         if (r_ptr->flags1 & RF1_UNIQUE)
2310                         {
2311                                 t = object_desc_str(t, "The ");
2312                         }
2313                 }
2314
2315                 /* A single one, with a vowel in the modifier */
2316                 else if ((*s == '#') && (is_a_vowel(modstr[0])))
2317                 {
2318                         t = object_desc_str(t, "an ");
2319                 }
2320
2321                 /* A single one, with a vowel */
2322                 else if (is_a_vowel(*s))
2323                 {
2324                         t = object_desc_str(t, "an ");
2325                 }
2326
2327                 /* A single one, without a vowel */
2328                 else
2329                 {
2330                         t = object_desc_str(t, "a ");
2331                 }
2332         }
2333
2334         /* Hack -- objects that "never" take an article */
2335         else
2336         {
2337                 /* No ampersand */
2338                 s = basenm;
2339
2340                 /* No pref */
2341                 if (!pref)
2342                 {
2343                         /* Nothing */
2344                 }
2345
2346                 /* Hack -- all gone */
2347                 else if (o_ptr->number <= 0)
2348                 {
2349                         t = object_desc_str(t, "no more ");
2350                 }
2351
2352                 /* Prefix a number if required */
2353                 else if (o_ptr->number > 1)
2354                 {
2355                         t = object_desc_num(t, o_ptr->number);
2356                         t = object_desc_chr(t, ' ');
2357                 }
2358
2359                 /* Hack -- The only one of its kind */
2360                 else if (known && (artifact_p(o_ptr) || o_ptr->art_name))
2361                 {
2362                         t = object_desc_str(t, "The ");
2363                 }
2364
2365                 /* Hack -- single items get no prefix */
2366                 else
2367                 {
2368                         /* Nothing */
2369                 }
2370         }
2371 #endif
2372
2373         /* Paranoia -- skip illegal tildes */
2374         /* while (*s == '~') s++; */
2375
2376 #ifdef JP
2377         if ((o_ptr->tval > TV_CAPTURE) && o_ptr->xtra3)
2378         {
2379                 t = object_desc_str(t,format("ÃÃÌê»Õ%s¤Î",player_name));
2380         }
2381
2382         /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¡¢Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤òÉÕ²Ã¤¹¤ë */
2383         if (known) {
2384                 /* ¥é¥ó¥À¥à¡¦¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È */
2385                 if (o_ptr->art_name)
2386                 {       char temp[256];
2387                         strcpy(temp, quark_str(o_ptr->art_name));
2388                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ½é¤ËÉÕ²Ã¤¹¤ë */
2389                         /* ±Ñ¸ìÈÇ¤Î¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤«¤éÍè¤¿ 'of XXX' ¤Ï,¡ÖXXX¤Î¡×¤ÈÉ½¼¨¤¹¤ë */
2390                         if ( strncmp( temp , "of ",3)==0 ) {t=object_desc_str(t,&temp[3]);t=object_desc_str(t,"¤Î");}
2391                         else
2392                         if ( strncmp( temp , "¡Ø" , 2 ) != 0 && temp[0]!='\'')
2393                                 t=object_desc_str(t,  temp);
2394                 }
2395                 /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à */
2396                 else if (o_ptr->name1 && !have_flag(flgs, TR_FULL_NAME)) {
2397                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2398                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ½é¤ËÉÕ²Ã¤¹¤ë */
2399                         if ( strncmp( (a_name + a_ptr->name), "¡Ø" , 2) != 0){
2400                                 t=object_desc_str(t, (a_name + a_ptr->name));
2401                         }
2402                 }
2403                 /* Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à */
2404                 else if (o_ptr->name2) {
2405                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
2406                         t=object_desc_str(t, (e_name + e_ptr->name));
2407                 }
2408         }
2409 #endif
2410         /* Copy the string */
2411         for (; *s; s++)
2412         {
2413                 /* Pluralizer */
2414 #ifdef JP
2415                 if (*s == '#')
2416 #else
2417                 if (*s == '~')
2418                 {
2419                         /* Add a plural if needed */
2420                         if (pref && o_ptr->number != 1)
2421                         {
2422                                 char k = t[-1];
2423
2424                                 /* XXX XXX XXX Mega-Hack */
2425
2426                                 /* Hack -- "Cutlass-es" and "Torch-es" */
2427                                 if ((k == 's') || (k == 'h')) *t++ = 'e';
2428
2429                                 /* Add an 's' */
2430                                 *t++ = 's';
2431                         }
2432                 }
2433
2434                 /* Modifier */
2435                 else if (*s == '#')
2436 #endif
2437
2438                 {
2439                         /* Insert the modifier */
2440                         for (u = modstr; *u; u++) *t++ = *u;
2441                 }
2442
2443 #ifdef JP
2444                 else if (*s == '%')
2445                   /* saigo ¤ÎÂå¤ï¤ê¡£¸úÇ½¤òÉÕ²½¤¹¤ë by ita*/
2446                 {
2447                   modstr=get_object_name(o_ptr);
2448                   for (u = modstr; *u; u++) *t++ = *u;
2449                 }
2450 #endif
2451                 /* Normal */
2452                 else
2453                 {
2454                         /* Copy */
2455                         *t++ = *s;
2456                 }
2457         }
2458
2459         /* Terminate */
2460         *t = '\0';
2461
2462
2463         /* Append the "kind name" to the "base name" */
2464 #ifndef JP
2465         if (append_name)
2466         {
2467                 t = object_desc_str(t, " of ");
2468                 t = object_desc_str(t, get_object_name(o_ptr));
2469         }
2470 #endif
2471
2472
2473 #ifdef JP
2474         /* '¡Ø'¤«¤é»Ï¤Þ¤ëÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ¸å¤ËÉÕ²Ã¤¹¤ë */
2475         if (known) {
2476                 /* ¥é¥ó¥À¥à¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤ÎÌ¾Á°¤Ï¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤ËµÏ¿
2477                    ¤µ¤ì¤ë¤Î¤Ç¡¢±Ñ¸ìÈÇ¤ÎÌ¾Á°¤â¤½¤ì¤é¤·¤¯ÊÑ´¹¤¹¤ë */
2478                 if (o_ptr->art_name)
2479                 {       char temp[256];int itemp;
2480                         strcpy(temp, quark_str(o_ptr->art_name));
2481                         /* MEGA HACK by ita*/
2482                                 if ( strncmp( temp , "¡Ø" , 2 ) == 0 ) t=object_desc_str(t,  temp);else
2483                          if( temp[0]=='\'' ) { itemp=strlen(temp);temp[itemp-1]=0;
2484                          t=object_desc_str(t,"¡Ø");
2485                          t=object_desc_str(t,&temp[1]);
2486                          t=object_desc_str(t,"¡Ù");}
2487
2488                 }
2489                 else if (o_ptr->name1) {
2490                                 artifact_type *a_ptr = &a_info[o_ptr->name1];
2491                                 if ( strncmp( (a_name + a_ptr->name) , "¡Ø" , 2 ) == 0 ){
2492                                         t=object_desc_str(t, (a_name + a_ptr->name));
2493                                 }
2494                 }
2495                 else if (o_ptr->inscription)
2496                 {
2497                         cptr str = quark_str(o_ptr->inscription);
2498
2499                         while(*str)
2500                         {
2501                                 if (iskanji(*str))
2502                                 {
2503                                         str += 2;
2504                                         continue;
2505                                 }
2506                                 if (*str == '#') break;
2507                                 str++;
2508                         }
2509                         if (*str)
2510                         {
2511                                 /* Find the '#' */
2512                                 cptr str = strchr(quark_str(o_ptr->inscription), '#');
2513
2514                                 /* Add the false name */
2515                                 t=object_desc_str(t,"¡Ø");
2516                                 t = object_desc_str(t, &str[1]);
2517                                 t=object_desc_str(t,"¡Ù");
2518                         }
2519                 }
2520         }
2521 #else
2522         if ((o_ptr->tval > TV_CAPTURE) && o_ptr->xtra3)
2523         {
2524                 t = object_desc_str(t,format(" of %s the Smith",player_name));
2525         }
2526
2527         /* Hack -- Append "Artifact" or "Special" names */
2528         if (known && !have_flag(flgs, TR_FULL_NAME))
2529         {
2530                 /* Is it a new random artifact ? */
2531                 if (o_ptr->art_name)
2532                 {
2533                         t = object_desc_chr(t, ' ');
2534
2535                         t = object_desc_str(t, quark_str(o_ptr->art_name));
2536                 }
2537
2538                 /* Grab any artifact name */
2539                 else if (o_ptr->name1)
2540                 {
2541                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2542
2543                         t = object_desc_chr(t, ' ');
2544                         t = object_desc_str(t, (a_name + a_ptr->name));
2545                 }
2546
2547                 /* Grab any ego-item name */
2548                 else
2549                 {
2550                         if (o_ptr->name2)
2551                         {
2552                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
2553
2554                                 t = object_desc_chr(t, ' ');
2555                                 t = object_desc_str(t, (e_name + e_ptr->name));
2556                         }
2557
2558                         if (o_ptr->inscription && strchr(quark_str(o_ptr->inscription), '#'))
2559                         {
2560                                 /* Find the '#' */
2561                                 cptr str = strchr(quark_str(o_ptr->inscription), '#');
2562
2563                                 /* Add the false name */
2564                                 t = object_desc_chr(t, ' ');
2565                                 t = object_desc_str(t, &str[1]);
2566                         }
2567                 }
2568         }
2569 #endif
2570
2571
2572
2573         /* No more details wanted */
2574         if (mode < 1) goto copyback;
2575
2576         /* Hack -- Chests must be described in detail */
2577         if (o_ptr->tval == TV_CHEST)
2578         {
2579                 /* Not searched yet */
2580                 if (!known)
2581                 {
2582                         /* Nothing */
2583                 }
2584
2585                 /* May be "empty" */
2586                 else if (!o_ptr->pval)
2587                 {
2588 #ifdef JP
2589 t = object_desc_str(t, "(¶õ)");
2590 #else
2591                         t = object_desc_str(t, " (empty)");
2592 #endif
2593
2594                 }
2595
2596                 /* May be "disarmed" */
2597                 else if (o_ptr->pval < 0)
2598                 {
2599                         if (chest_traps[0 - o_ptr->pval])
2600                         {
2601 #ifdef JP
2602 t = object_desc_str(t, "(²ò½üºÑ)");
2603 #else
2604                                 t = object_desc_str(t, " (disarmed)");
2605 #endif
2606
2607                         }
2608                         else
2609                         {
2610 #ifdef JP
2611 t = object_desc_str(t, "(Èó»Ü¾û)");
2612 #else
2613                                 t = object_desc_str(t, " (unlocked)");
2614 #endif
2615
2616                         }
2617                 }
2618
2619                 /* Describe the traps, if any */
2620                 else
2621                 {
2622                         /* Describe the traps */
2623                         switch (chest_traps[o_ptr->pval])
2624                         {
2625                                 case 0:
2626                                 {
2627 #ifdef JP
2628 t = object_desc_str(t, "(»Ü¾û)");
2629 #else
2630                                         t = object_desc_str(t, " (Locked)");
2631 #endif
2632
2633                                         break;
2634                                 }
2635                                 case CHEST_LOSE_STR:
2636                                 {
2637 #ifdef JP
2638 t = object_desc_str(t, "(ÆÇ¿Ë)");
2639 #else
2640                                         t = object_desc_str(t, " (Poison Needle)");
2641 #endif
2642
2643                                         break;
2644                                 }
2645                                 case CHEST_LOSE_CON:
2646                                 {
2647 #ifdef JP
2648 t = object_desc_str(t, "(ÆÇ¿Ë)");
2649 #else
2650                                         t = object_desc_str(t, " (Poison Needle)");
2651 #endif
2652
2653                                         break;
2654                                 }
2655                                 case CHEST_POISON:
2656                                 {
2657 #ifdef JP
2658 t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2659 #else
2660                                         t = object_desc_str(t, " (Gas Trap)");
2661 #endif
2662
2663                                         break;
2664                                 }
2665                                 case CHEST_PARALYZE:
2666                                 {
2667 #ifdef JP
2668 t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2669 #else
2670                                         t = object_desc_str(t, " (Gas Trap)");
2671 #endif
2672
2673                                         break;
2674                                 }
2675                                 case CHEST_EXPLODE:
2676                                 {
2677 #ifdef JP
2678 t = object_desc_str(t, "(ÇúÈ¯ÁõÃÖ)");
2679 #else
2680                                         t = object_desc_str(t, " (Explosion Device)");
2681 #endif
2682
2683                                         break;
2684                                 }
2685                                 case CHEST_SUMMON:
2686                                 case CHEST_BIRD_STORM:
2687                                 case CHEST_E_SUMMON:
2688                                 case CHEST_H_SUMMON:
2689                                 {
2690 #ifdef JP
2691 t = object_desc_str(t, "(¾¤´¤Î¥ë¡¼¥ó)");
2692 #else
2693                                         t = object_desc_str(t, " (Summoning Runes)");
2694 #endif
2695
2696                                         break;
2697                                 }
2698                                 case CHEST_RUNES_OF_EVIL:
2699                                 {
2700 #ifdef JP
2701 t = object_desc_str(t, "(¼Ù°¤Ê¥ë¡¼¥ó)");
2702 #else
2703                                         t = object_desc_str(t, " (Gleaming Black Runes)");
2704 #endif
2705
2706                                         break;
2707                                 }
2708                                 case CHEST_ALARM:
2709                                 {
2710 #ifdef JP
2711 t = object_desc_str(t, "(·ÙÊóÁõÃÖ)");
2712 #else
2713                                         t = object_desc_str(t, " (Alarm)");
2714 #endif
2715
2716                                         break;
2717                                 }
2718                                 default:
2719                                 {
2720 #ifdef JP
2721 t = object_desc_str(t, "(¥Þ¥ë¥Á¡¦¥È¥é¥Ã¥×)");
2722 #else
2723                                         t = object_desc_str(t, " (Multiple Traps)");
2724 #endif
2725
2726                                         break;
2727                                 }
2728                         }
2729                 }
2730         }
2731
2732
2733         /* Display the item like a weapon */
2734         if (have_flag(flgs, TR_SHOW_MODS)) show_weapon = TRUE;
2735
2736         /* Display the item like a weapon */
2737         if (o_ptr->to_h && o_ptr->to_d) show_weapon = TRUE;
2738
2739         /* Display the item like armour */
2740         if (o_ptr->ac) show_armour = TRUE;
2741
2742
2743         /* Dump base weapon info */
2744         switch (o_ptr->tval)
2745         {
2746                 /* Missiles and Weapons */
2747                 case TV_SHOT:
2748                 case TV_BOLT:
2749                 case TV_ARROW:
2750                 case TV_HAFTED:
2751                 case TV_POLEARM:
2752                 case TV_SWORD:
2753                 case TV_DIGGING:
2754
2755                 /* Append a "damage" string */
2756                 t = object_desc_chr(t, ' ');
2757                 t = object_desc_chr(t, p1);
2758                 t = object_desc_num(t, o_ptr->dd);
2759                 t = object_desc_chr(t, 'd');
2760                 t = object_desc_num(t, o_ptr->ds);
2761                 t = object_desc_chr(t, p2);
2762
2763                 /* All done */
2764                 break;
2765
2766
2767                 /* Bows get a special "damage string" */
2768                 case TV_BOW:
2769
2770                 /* Mega-Hack -- Extract the "base power" */
2771                 power = (o_ptr->sval % 10);
2772
2773                 /* Apply the "Extra Might" flag */
2774                 if (have_flag(flgs, TR_XTRA_MIGHT)) power++;
2775
2776                 /* Append a special "damage" string */
2777                 t = object_desc_chr(t, ' ');
2778                 t = object_desc_chr(t, p1);
2779                 t = object_desc_chr(t, 'x');
2780                 t = object_desc_num(t, power);
2781                 t = object_desc_chr(t, p2);
2782
2783                 /* All done */
2784                 break;
2785         }
2786
2787
2788         /* Add the weapon bonuses */
2789         if (known)
2790         {
2791                 /* Show the tohit/todam on request */
2792                 if (show_weapon)
2793                 {
2794                         t = object_desc_chr(t, ' ');
2795                         t = object_desc_chr(t, p1);
2796                         t = object_desc_int(t, o_ptr->to_h);
2797                         t = object_desc_chr(t, ',');
2798                         t = object_desc_int(t, o_ptr->to_d);
2799                         t = object_desc_chr(t, p2);
2800                 }
2801
2802                 /* Show the tohit if needed */
2803                 else if (o_ptr->to_h)
2804                 {
2805                         t = object_desc_chr(t, ' ');
2806                         t = object_desc_chr(t, p1);
2807                         t = object_desc_int(t, o_ptr->to_h);
2808                         t = object_desc_chr(t, p2);
2809                 }
2810
2811                 /* Show the todam if needed */
2812                 else if (o_ptr->to_d)
2813                 {
2814                         t = object_desc_chr(t, ' ');
2815                         t = object_desc_chr(t, p1);
2816                         t = object_desc_int(t, o_ptr->to_d);
2817                         t = object_desc_chr(t, p2);
2818                 }
2819         }
2820
2821         bow_ptr = &inventory[INVEN_BOW];
2822
2823         /* if have a firing weapon + ammo matches bow*/
2824         if (bow_ptr->k_idx &&
2825             (((bow_ptr->sval == SV_SLING) && (o_ptr->tval == TV_SHOT)) ||
2826              (((bow_ptr->sval == SV_SHORT_BOW) ||
2827                (bow_ptr->sval == SV_LONG_BOW) ||
2828                (bow_ptr->sval == SV_NAMAKE_BOW)) && (o_ptr->tval == TV_ARROW)) ||
2829              (((bow_ptr->sval == SV_LIGHT_XBOW) ||
2830                (bow_ptr->sval == SV_HEAVY_XBOW)) && (o_ptr->tval == TV_BOLT))))
2831         {
2832                 int avgdam = 10;
2833                 int tmul;
2834                 s16b energy_fire;
2835
2836                 avgdam = o_ptr->dd * (o_ptr->ds + 1) * 10 / 2;
2837
2838                 /* See if the bow is "known" - then set damage bonus*/
2839                 if (object_known_p(bow_ptr))
2840                 {
2841                         avgdam += (bow_ptr->to_d * 10);
2842                 }
2843
2844                 /* effect of ammo */
2845                 if (known) avgdam += (o_ptr->to_d * 10);
2846
2847                 energy_fire = bow_energy(bow_ptr->sval);
2848                 tmul = bow_tmul(bow_ptr->sval);
2849
2850                 /* Get extra "power" from "extra might" */
2851                 if (p_ptr->xtra_might) tmul++;
2852
2853                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
2854
2855                 /* launcher multiplier */
2856                 avgdam *= tmul;
2857                 avgdam /= (100 * 10);
2858                 if (avgdam < 0) avgdam = 0;
2859
2860                 /* display (shot damage/ avg damage) */
2861                 t = object_desc_chr(t, ' ');
2862                 t = object_desc_chr(t, p1);
2863                 t = object_desc_num(t, avgdam);
2864                 t = object_desc_chr(t, '/');
2865
2866                 if (p_ptr->num_fire == 0)
2867                 {
2868                         t = object_desc_chr(t, '0');
2869                 }
2870                 else
2871                 {
2872                         /* calc effects of energy */
2873                         avgdam *= (p_ptr->num_fire * 100);
2874
2875                         avgdam /= energy_fire;
2876
2877                         t = object_desc_num(t, avgdam);
2878                 }
2879
2880                 t = object_desc_chr(t, p2);
2881         }
2882         else if ((p_ptr->pclass == CLASS_NINJA) && (o_ptr->tval == TV_SPIKE))
2883         {
2884                 int avgdam;
2885                 s16b energy_fire;
2886
2887                 if (p_ptr->mighty_throw)
2888                         avgdam =  1 + 3;
2889                 else
2890                         avgdam =  1;
2891                 avgdam += ((p_ptr->lev+30)*(p_ptr->lev+30)-900)/55;
2892
2893                 energy_fire = 100 - p_ptr->lev;
2894
2895                 /* display (shot damage/ avg damage) */
2896                 t = object_desc_chr(t, ' ');
2897                 t = object_desc_chr(t, p1);
2898                 t = object_desc_num(t, avgdam);
2899                 t = object_desc_chr(t, '/');
2900
2901                 /* calc effects of energy */
2902                 avgdam = 100 * avgdam / energy_fire;
2903
2904                 t = object_desc_num(t, avgdam);
2905
2906                 t = object_desc_chr(t, p2);
2907         }
2908
2909
2910         /* Add the armor bonuses */
2911         if (known)
2912         {
2913                 /* Show the armor class info */
2914                 if (show_armour)
2915                 {
2916                         t = object_desc_chr(t, ' ');
2917                         t = object_desc_chr(t, b1);
2918                         t = object_desc_num(t, o_ptr->ac);
2919                         t = object_desc_chr(t, ',');
2920                         t = object_desc_int(t, o_ptr->to_a);
2921                         t = object_desc_chr(t, b2);
2922                 }
2923
2924                 /* No base armor, but does increase armor */
2925                 else if (o_ptr->to_a)
2926                 {
2927                         t = object_desc_chr(t, ' ');
2928                         t = object_desc_chr(t, b1);
2929                         t = object_desc_int(t, o_ptr->to_a);
2930                         t = object_desc_chr(t, b2);
2931                 }
2932         }
2933
2934         /* Hack -- always show base armor */
2935         else if (show_armour)
2936         {
2937                 t = object_desc_chr(t, ' ');
2938                 t = object_desc_chr(t, b1);
2939                 t = object_desc_num(t, o_ptr->ac);
2940                 t = object_desc_chr(t, b2);
2941         }
2942
2943
2944         /* No more details wanted */
2945         if (mode < 2) goto copyback;
2946
2947
2948         /*
2949          * Hack -- Wands and Staffs have charges.  Make certain how many charges
2950          * a stack of staffs really has is clear. -LM-
2951          */
2952         if (known &&
2953             ((o_ptr->tval == TV_STAFF) ||
2954              (o_ptr->tval == TV_WAND)))
2955         {
2956                 /* Dump " (N charges)" */
2957                 t = object_desc_chr(t, ' ');
2958                 t = object_desc_chr(t, p1);
2959
2960                 /* Clear explaination for staffs. */
2961                 if ((o_ptr->tval == TV_STAFF) && (o_ptr->number > 1))
2962                 {
2963                         t = object_desc_num(t, o_ptr->number);
2964                         t = object_desc_str(t, "x ");
2965                 }
2966                 t = object_desc_num(t, o_ptr->pval);
2967 #ifdef JP
2968                 t = object_desc_str(t, "²óÊ¬");
2969 #else
2970                 t = object_desc_str(t, " charge");
2971
2972                 if (o_ptr->pval != 1)
2973                 {
2974                         t = object_desc_chr(t, 's');
2975                 }
2976 #endif
2977
2978
2979                 t = object_desc_chr(t, p2);
2980         }
2981         /* Hack -- Rods have a "charging" indicator.  Now that stacks of rods may
2982          * be in any state of charge or discharge, this now includes a number. -LM-
2983          */
2984         else if (known && (o_ptr->tval == TV_ROD))
2985         {
2986                 /* Hack -- Dump " (# charging)" if relevant */
2987                 if (o_ptr->timeout)
2988                 {
2989                         /* Stacks of rods display an exact count of charging rods. */
2990                         if (o_ptr->number > 1)
2991                         {
2992                                 /* Paranoia. */
2993                                 if (k_ptr->pval == 0) k_ptr->pval = 1;
2994
2995                                 /* Find out how many rods are charging, by dividing
2996                                  * current timeout by each rod's maximum timeout.
2997                                  * Ensure that any remainder is rounded up.  Display
2998                                  * very discharged stacks as merely fully discharged.
2999                                  */
3000                                 power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
3001                                 if (power > o_ptr->number) power = o_ptr->number;
3002
3003                                 /* Display prettily. */
3004                                 t = object_desc_str(t, " (");
3005                                 t = object_desc_num(t, power);
3006 #ifdef JP
3007                                 t = object_desc_str(t, "ËÜ ½¼Å¶Ãæ)");
3008 #else
3009                                 t = object_desc_str(t, " charging)");
3010 #endif
3011
3012                         }
3013
3014                         /* "one Rod of Perception (1 charging)" would look tacky. */
3015                         else
3016                         {
3017 #ifdef JP
3018 t = object_desc_str(t, "(½¼Å¶Ãæ)");
3019 #else
3020                                 t = object_desc_str(t, " (charging)");
3021 #endif
3022
3023                         }
3024                 }
3025         }
3026
3027         /* Dump "pval" flags for wearable items */
3028         if (known && (have_pval_flags(flgs)))
3029         {
3030                 /* Start the display */
3031                 t = object_desc_chr(t, ' ');
3032                 t = object_desc_chr(t, p1);
3033
3034                 /* Dump the "pval" itself */
3035                 t = object_desc_int(t, o_ptr->pval);
3036
3037                 /* Do not display the "pval" flags */
3038                 if (have_flag(flgs, TR_HIDE_TYPE))
3039                 {
3040                         /* Nothing */
3041                 }
3042
3043                 /* Speed */
3044                 else if (have_flag(flgs, TR_SPEED))
3045                 {
3046                         /* Dump " to speed" */
3047 #ifdef JP
3048 t = object_desc_str(t, "²ÃÂ®");
3049 #else
3050                         t = object_desc_str(t, " to speed");
3051 #endif
3052
3053                 }
3054
3055                 /* Attack speed */
3056                 else if (have_flag(flgs, TR_BLOWS))
3057                 {
3058                         /* Add " attack" */
3059 #ifdef JP
3060 t = object_desc_str(t, "¹¶·â");
3061 #else
3062                         t = object_desc_str(t, " attack");
3063
3064                         /* Add "attacks" */
3065                         if (ABS(o_ptr->pval) != 1) t = object_desc_chr(t, 's');
3066 #endif
3067
3068                 }
3069
3070                 /* Stealth */
3071                 else if (have_flag(flgs, TR_STEALTH))
3072                 {
3073                         /* Dump " to stealth" */
3074 #ifdef JP
3075 t = object_desc_str(t, "±£Ì©");
3076 #else
3077                         t = object_desc_str(t, " to stealth");
3078 #endif
3079
3080                 }
3081
3082                 /* Search */
3083                 else if (have_flag(flgs, TR_SEARCH))
3084                 {
3085                         /* Dump " to searching" */
3086 #ifdef JP
3087 t = object_desc_str(t, "Ãµº÷");
3088 #else
3089                         t = object_desc_str(t, " to searching");
3090 #endif
3091
3092                 }
3093
3094                 /* Infravision */
3095                 else if (have_flag(flgs, TR_INFRA))
3096                 {
3097                         /* Dump " to infravision" */
3098 #ifdef JP
3099 t = object_desc_str(t, "ÀÖ³°Àþ»ëÎÏ");
3100 #else
3101                         t = object_desc_str(t, " to infravision");
3102 #endif
3103
3104                 }
3105
3106                 /* Tunneling */
3107                 else if (have_flag(flgs, TR_TUNNEL))
3108                 {
3109                         /* Nothing */
3110                 }
3111
3112                 /* Finish the display */
3113                 t = object_desc_chr(t, p2);
3114         }
3115
3116         /* Hack -- Process Lanterns/Torches */
3117         if (known && (o_ptr->tval == TV_LITE) && (!(artifact_p(o_ptr) || (o_ptr->sval == SV_LITE_FEANOR))))
3118         {
3119                 /* Hack -- Turns of light for normal lites */
3120 #ifdef JP
3121 t = object_desc_str(t, "(");
3122 #else
3123                 t = object_desc_str(t, " (with ");
3124 #endif
3125
3126                 if (o_ptr->name2 == EGO_LITE_LONG) t = object_desc_num(t, o_ptr->xtra4*2);
3127                 else t = object_desc_num(t, o_ptr->xtra4);
3128 #ifdef JP
3129 t = object_desc_str(t, "¥¿¡¼¥ó¤Î¼÷Ì¿)");
3130 #else
3131                 t = object_desc_str(t, " turns of light)");
3132 #endif
3133
3134         }
3135
3136
3137         /* Indicate charging objects, but not rods. */
3138         if (known && o_ptr->timeout && o_ptr->tval != TV_ROD)
3139         {
3140                 /* Hack -- Dump " (charging)" if relevant */
3141 #ifdef JP
3142 t = object_desc_str(t, "(½¼Å¶Ãæ)");
3143 #else
3144                 t = object_desc_str(t, " (charging)");
3145 #endif
3146
3147         }
3148
3149
3150         /* No more details wanted */
3151         if (mode < 3) goto copyback;
3152
3153
3154         /* No inscription yet */
3155         tmp_val2[0] = '\0';
3156
3157         /* Use the game-generated "feeling" otherwise, if available */
3158         if (o_ptr->feeling)
3159         {
3160                 strcpy(tmp_val2, game_inscriptions[o_ptr->feeling]);
3161         }
3162
3163         /* Note "cursed" if the item is known to be cursed */
3164         else if (cursed_p(o_ptr) && (known || (o_ptr->ident & (IDENT_SENSE))))
3165         {
3166 #ifdef JP
3167 strcpy(tmp_val2, "¼ö¤ï¤ì¤Æ¤¤¤ë");
3168 #else
3169                 strcpy(tmp_val2, "cursed");
3170 #endif
3171
3172         }
3173
3174         /* Note "unidentified" if the item is unidentified */
3175         else if ((o_ptr->tval == TV_RING || o_ptr->tval == TV_AMULET
3176                   || o_ptr->tval == TV_LITE || o_ptr->tval == TV_FIGURINE)
3177                  && object_aware_p(o_ptr) && !object_known_p(o_ptr)
3178                  && !((o_ptr->ident)&IDENT_SENSE))
3179         {
3180 #ifdef JP
3181 strcpy(tmp_val2, "Ì¤´ÕÄê");
3182 #else
3183                 strcpy(tmp_val2, "unidentified");
3184 #endif
3185         }
3186
3187         /* Mega-Hack -- note empty wands/staffs */
3188         else if (!known && (o_ptr->ident & (IDENT_EMPTY)))
3189         {
3190 #ifdef JP
3191 strcpy(tmp_val2, "¶õ");
3192 #else
3193                 strcpy(tmp_val2, "empty");
3194 #endif
3195
3196         }
3197
3198         /* Note "tried" if the object has been tested unsuccessfully */
3199         else if (!aware && object_tried_p(o_ptr))
3200         {
3201 #ifdef JP
3202 strcpy(tmp_val2, "Ì¤È½ÌÀ");
3203 #else
3204                 strcpy(tmp_val2, "tried");
3205 #endif
3206
3207         }
3208
3209         /* Use the standard inscription if available */
3210         if (o_ptr->inscription)
3211         {
3212                 char buff[1024];
3213
3214                 if (tmp_val2[0]) strcat(tmp_val2, ", ");
3215
3216                 /* Get inscription and convert {%} */
3217                 get_inscription(buff, o_ptr);
3218
3219                 /* strcat with correct treating of kanji */
3220                 my_strcat(tmp_val2, buff, sizeof(tmp_val2));
3221         }
3222
3223         /* Note the discount, if any */
3224         else if (o_ptr->discount && !(tmp_val2[0]))
3225         {
3226                 (void)object_desc_num(tmp_val2, o_ptr->discount);
3227 #ifdef JP
3228                 strcat(tmp_val2, "%°ú¤");
3229 #else
3230                 strcat(tmp_val2, "% off");
3231 #endif
3232
3233         }
3234
3235         /* Append the inscription, if any */
3236         if (tmp_val2[0])
3237         {
3238                 /* Append the inscription */
3239                 t = object_desc_chr(t, ' ');
3240                 t = object_desc_chr(t, c1);
3241                 t = object_desc_str(t, tmp_val2);
3242                 t = object_desc_chr(t, c2);
3243         }
3244
3245 copyback:
3246         t = tmp_val;
3247         for (i = 0; i < MAX_NLEN-2; i++)
3248         {
3249 #ifdef JP
3250                 if (iskanji(*(t+i)))
3251                 {
3252                         *(buf+i) = *(t+i);
3253                         i++;
3254                 }
3255 #endif
3256                 *(buf+i) = *(t+i);
3257         }
3258         if (i == MAX_NLEN-2)
3259         {
3260 #ifdef JP
3261                 if (iskanji(*(t+i)))
3262                         *(buf+i) = '\0';
3263                 else
3264 #endif
3265                         *(buf+i) = *(t+i);
3266         }
3267         *(buf+MAX_NLEN-1) = '\0';
3268 }
3269