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 #ifndef JP
1656         bool            append_name = FALSE;
1657 #endif
1658
1659         bool            show_weapon = FALSE;
1660         bool            show_armour = FALSE;
1661
1662         cptr            s, u;
1663         char            *t;
1664
1665         char            p1 = '(', p2 = ')';
1666         char            b1 = '[', b2 = ']';
1667         char            c1 = '{', c2 = '}';
1668
1669         char            tmp_val[MAX_NLEN+160];
1670         char            tmp_val2[MAX_NLEN+10];
1671
1672         u32b flgs[TR_FLAG_SIZE];
1673
1674         object_type     *bow_ptr;
1675
1676
1677         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1678
1679         /* Extract some flags */
1680         object_flags(o_ptr, flgs);
1681
1682         /* See if the object is "aware" */
1683         if (object_aware_p(o_ptr) || (o_ptr->ident & IDENT_MENTAL)) aware = TRUE;
1684
1685         /* See if the object is "known" */
1686         if (object_known_p(o_ptr)) known = TRUE;
1687
1688         /* Hack -- Extract the sub-type "indexx" */
1689         indexx = o_ptr->sval;
1690
1691         /* Extract default "base" string */
1692         basenm = get_object_name(o_ptr);
1693
1694         /* Assume no "modifier" string */
1695         modstr = "";
1696
1697
1698         /* Analyze the object */
1699         switch (o_ptr->tval)
1700         {
1701                 /* Some objects are easy to describe */
1702                 case TV_SKELETON:
1703                 case TV_BOTTLE:
1704                 case TV_JUNK:
1705                 case TV_SPIKE:
1706                 case TV_FLASK:
1707                 case TV_CHEST:
1708                 case TV_WHISTLE:
1709                 {
1710                         break;
1711                 }
1712
1713                 case TV_CAPTURE:
1714                 {
1715                         monster_race *r_ptr = &r_info[o_ptr->pval];
1716
1717                         if (known)
1718                         {
1719                                 if (!o_ptr->pval)
1720                                 {
1721 #ifdef JP
1722                                         modstr = "¡Ê¶õ¡Ë";
1723 #else
1724                                         modstr = " (empty)";
1725 #endif
1726                                 }
1727                                 else
1728                                 {
1729 #ifdef JP
1730                                         sprintf(tmp_val2, "¡Ê%s¡Ë",r_name + r_ptr->name);
1731                                         modstr = tmp_val2;
1732 #else
1733                                         cptr t = r_name + r_ptr->name;
1734
1735                                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1736                                         {
1737                                                 sprintf(tmp_val2, " (%s%s)", (is_a_vowel(*t) ? "an " : "a "), t);
1738
1739                                                 modstr = tmp_val2;
1740                                         }
1741                                         else
1742                                         {
1743                                                 sprintf(tmp_val2, "(%s)", t);
1744
1745                                                 modstr = t;
1746                                         }
1747 #endif
1748                                 }
1749                         }
1750                         break;
1751                 }
1752
1753                 /* Figurines/Statues */
1754                 case TV_FIGURINE:
1755                 case TV_STATUE:
1756                 {
1757                         monster_race *r_ptr = &r_info[o_ptr->pval];
1758
1759 #ifdef JP
1760                         modstr = r_name + r_ptr->name;
1761 #else
1762                         cptr t = r_name + r_ptr->name;
1763
1764                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1765                         {
1766                                 sprintf(tmp_val2, "%s%s", (is_a_vowel(*t) ? "an " : "a "), t);
1767
1768                                 modstr = tmp_val2;
1769                         }
1770                         else
1771                         {
1772                                 modstr = t;
1773                         }
1774 #endif
1775
1776
1777                         break;
1778                 }
1779
1780                 /* Corpses */
1781                 case TV_CORPSE:
1782                 {
1783                         monster_race *r_ptr = &r_info[o_ptr->pval];
1784
1785                         modstr = r_name + r_ptr->name;
1786
1787
1788 #ifdef JP
1789                         sprintf(tmp_val2, "#%s", basenm);
1790 #else
1791                         if (r_ptr->flags1 & RF1_UNIQUE)
1792                         {
1793                                 sprintf(tmp_val2, "& %s %s", basenm, "of #");
1794                         }
1795                         else
1796                         {
1797                                 sprintf(tmp_val2, "& # %s", basenm);
1798                         }
1799 #endif
1800
1801
1802                         basenm = tmp_val2;
1803                         break;
1804                 }
1805
1806                 /* Missiles/ Bows/ Weapons */
1807                 case TV_SHOT:
1808                 case TV_BOLT:
1809                 case TV_ARROW:
1810                 case TV_BOW:
1811                 case TV_HAFTED:
1812                 case TV_POLEARM:
1813                 case TV_SWORD:
1814                 case TV_DIGGING:
1815                 {
1816                         show_weapon = TRUE;
1817                         break;
1818                 }
1819
1820
1821                 /* Armour */
1822                 case TV_BOOTS:
1823                 case TV_GLOVES:
1824                 case TV_CLOAK:
1825                 case TV_CROWN:
1826                 case TV_HELM:
1827                 case TV_SHIELD:
1828                 case TV_SOFT_ARMOR:
1829                 case TV_HARD_ARMOR:
1830                 case TV_DRAG_ARMOR:
1831                 {
1832                         show_armour = TRUE;
1833                         break;
1834                 }
1835
1836
1837                 /* Lites (including a few "Specials") */
1838                 case TV_LITE:
1839                 {
1840                         break;
1841                 }
1842
1843                 /* Amulets (including a few "Specials") */
1844                 case TV_AMULET:
1845                 {
1846                         /* Known artifacts */
1847                         if (artifact_p(o_ptr) && aware) break;
1848
1849                         if ((k_ptr->gen_flags & TRG_INSTA_ART) && aware) break;
1850
1851                         /* Color the object */
1852                         modstr = amulet_adj[indexx];
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
1864                         if (aware) append_name = TRUE;
1865 #endif
1866
1867                         break;
1868                 }
1869
1870                 /* Rings (including a few "Specials") */
1871                 case TV_RING:
1872                 {
1873                         /* Known artifacts */
1874                         if (artifact_p(o_ptr) && aware) break;
1875
1876                         if ((k_ptr->gen_flags & TRG_INSTA_ART) && aware) break;
1877
1878                         /* Color the object */
1879                         modstr = ring_adj[indexx];
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
1891                         if (aware) append_name = TRUE;
1892 #endif
1893
1894                         if (!k_ptr->to_h && !k_ptr->to_d && (o_ptr->to_h || o_ptr->to_d)) show_weapon = TRUE;
1895
1896                         break;
1897                 }
1898
1899                 case TV_CARD:
1900                 {
1901                         break;
1902                 }
1903
1904                 case TV_STAFF:
1905                 {
1906                         /* Color the object */
1907                         modstr = staff_adj[indexx];
1908
1909                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1910 #ifdef JP
1911                                 basenm = aware ? "%¤Î¾ó" : "¾ó";
1912                         else
1913                                 basenm = aware ? "#%¤Î¾ó" : "#¾ó";
1914 #else
1915                                 basenm = "& Staff~";
1916                         else
1917                                 basenm = aware ? "& # Staff~" : "& # Staff~";
1918
1919                         if (aware) append_name = TRUE;
1920 #endif
1921
1922                         break;
1923                 }
1924
1925                 case TV_WAND:
1926                 {
1927                         /* Color the object */
1928                         modstr = wand_adj[indexx];
1929
1930                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1931 #ifdef JP
1932                                 basenm = aware? "%¤ÎËâË¡ËÀ":"ËâË¡ËÀ";
1933                         else
1934                                 basenm = aware ? "#%¤ÎËâË¡ËÀ" : "#ËâË¡ËÀ";
1935 #else
1936                                 basenm = "& Wand~";
1937                         else
1938                                 basenm = aware ? "& # Wand~" : "& # Wand~";
1939
1940                         if (aware) append_name = TRUE;
1941 #endif
1942
1943                         break;
1944                 }
1945
1946                 case TV_ROD:
1947                 {
1948                         /* Color the object */
1949                         modstr = rod_adj[indexx];
1950
1951                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1952 #ifdef JP
1953                                 basenm = aware? "%¤Î¥í¥Ã¥É":"¥í¥Ã¥É";
1954                         else
1955                                 basenm = aware ? "#%¤Î¥í¥Ã¥É" : "#¥í¥Ã¥É";
1956 #else
1957                                 basenm = "& Rod~";
1958                         else
1959                                 basenm = aware ? "& # Rod~" : "& # Rod~";
1960
1961                         if (aware) append_name = TRUE;
1962 #endif
1963
1964                         break;
1965                 }
1966
1967                 case TV_SCROLL:
1968                 {
1969                         /* Color the object */
1970                         modstr = scroll_adj[indexx];
1971
1972                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1973 #ifdef JP
1974                                 basenm = aware ? "%¤Î´¬Êª" : "´¬Êª";
1975                         else
1976                                 basenm = aware ? "¡Ö#¡×¤È½ñ¤«¤ì¤¿%¤Î´¬Êª" : "¡Ö#¡×¤È½ñ¤«¤ì¤¿´¬Êª";
1977 #else
1978                                 basenm = "& Scroll~";
1979                         else
1980                                 basenm = aware ? "& Scroll~ titled \"#\"" : "& Scroll~ titled \"#\"";
1981
1982                         if (aware) append_name = TRUE;
1983 #endif
1984
1985                         break;
1986                 }
1987
1988                 case TV_POTION:
1989                 {
1990                         /* Color the object */
1991                         modstr = potion_adj[indexx];
1992
1993                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
1994 #ifdef JP
1995                                 basenm = aware ? "%¤ÎÌô" : "Ìô";
1996                         else
1997                                 basenm = aware ? "#%¤ÎÌô" : "#Ìô";
1998 #else
1999                                 basenm = "& Potion~";
2000                         else
2001                                 basenm = aware ? "& # Potion~" : "& # Potion~";
2002
2003                         if (aware) append_name = TRUE;
2004 #endif
2005
2006                         break;
2007                 }
2008
2009                 case TV_FOOD:
2010                 {
2011                         /* Ordinary food is "boring" */
2012                         if (o_ptr->sval >= SV_FOOD_MIN_FOOD) break;
2013
2014                         /* Color the object */
2015                         modstr = food_adj[indexx];
2016
2017                         if (((plain_descriptions) && (aware)) || o_ptr->ident & IDENT_STOREB)
2018 #ifdef JP
2019                                 basenm = aware ? "%¤Î¥¥Î¥³" : "¥¥Î¥³";
2020                         else
2021                                 basenm = aware ? "#%¤Î¥¥Î¥³" : "#¥¥Î¥³";
2022 #else
2023                                 basenm = "& Mushroom~";
2024                         else
2025                                 basenm = aware ? "& # Mushroom~" : "& # Mushroom~";
2026
2027                         if (aware) append_name = TRUE;
2028 #endif
2029
2030                         break;
2031                 }
2032
2033                 case TV_PARCHEMENT:
2034                 {
2035                         modstr = basenm;
2036 #ifdef JP
2037                         basenm = "ÍÓÈé»æ - #";
2038 #else
2039                         basenm = "& Parchement~ - #";
2040 #endif
2041                         break;
2042                 }
2043
2044                 /* Magic Books */
2045                 case TV_LIFE_BOOK:
2046                 {
2047                         modstr = basenm;
2048 #ifdef JP
2049                                 basenm = "À¸Ì¿¤ÎËâË¡½ñ#";
2050 #else
2051                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2052                                 basenm = "& Book~ of Life Magic #";
2053                         else
2054                                 basenm = "& Life Spellbook~ #";
2055 #endif
2056
2057                         break;
2058                 }
2059
2060                 case TV_SORCERY_BOOK:
2061                 {
2062                         modstr = basenm;
2063 #ifdef JP
2064                                 basenm = "Àç½Ñ¤ÎËâË¡½ñ#";
2065 #else
2066                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2067                                 basenm = "& Book~ of Sorcery #";
2068                         else
2069                                 basenm = "& Sorcery Spellbook~ #";
2070 #endif
2071
2072                         break;
2073                 }
2074
2075                 case TV_NATURE_BOOK:
2076                 {
2077                         modstr = basenm;
2078 #ifdef JP
2079                                 basenm = "¼«Á³¤ÎËâË¡½ñ#";
2080 #else
2081                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2082                                 basenm = "& Book~ of Nature Magic #";
2083                         else
2084                                 basenm = "& Nature Spellbook~ #";
2085 #endif
2086
2087                         break;
2088                 }
2089
2090                 case TV_CHAOS_BOOK:
2091                 {
2092                         modstr = basenm;
2093 #ifdef JP
2094                                 basenm = "¥«¥ª¥¹¤ÎËâË¡½ñ#";
2095 #else
2096                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2097                                 basenm = "& Book~ of Chaos Magic #";
2098                         else
2099                                 basenm = "& Chaos Spellbook~ #";
2100 #endif
2101
2102                         break;
2103                 }
2104
2105                 case TV_DEATH_BOOK:
2106                 {
2107                         modstr = basenm;
2108 #ifdef JP
2109                                 basenm = "°Å¹õ¤ÎËâË¡½ñ#";
2110 #else
2111                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2112                                 basenm = "& Book~ of Death Magic #";
2113                         else
2114                                 basenm = "& Death Spellbook~ #";
2115 #endif
2116
2117                         break;
2118                 }
2119
2120                 case TV_TRUMP_BOOK:
2121                 {
2122                         modstr = basenm;
2123 #ifdef JP
2124                                 basenm = "¥È¥é¥ó¥×¤ÎËâË¡½ñ#";
2125 #else
2126                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2127                                 basenm = "& Book~ of Trump Magic #";
2128                         else
2129                                 basenm = "& Trump Spellbook~ #";
2130 #endif
2131
2132                         break;
2133                 }
2134
2135                 case TV_ARCANE_BOOK:
2136                 {
2137                         modstr = basenm;
2138 #ifdef JP
2139                                 basenm = "Èë½Ñ¤ÎËâË¡½ñ#";
2140 #else
2141                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2142                                 basenm = "& Book~ of Arcane Magic #";
2143                         else
2144                                 basenm = "& Arcane Spellbook~ #";
2145 #endif
2146
2147                         break;
2148                 }
2149                 case TV_ENCHANT_BOOK:
2150                 {
2151                         modstr = basenm;
2152 #ifdef JP
2153                                 basenm = "¾¢¤ÎËâË¡½ñ#";
2154 #else
2155                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2156                                 basenm = "& Book~ of Craft Magic #";
2157                         else
2158                                 basenm = "& Craft Spellbook~ #";
2159 #endif
2160
2161                         break;
2162                 }
2163                 case TV_DAEMON_BOOK:
2164                 {
2165                         modstr = basenm;
2166 #ifdef JP
2167                                 basenm = "°Ëâ¤ÎËâË¡½ñ#";
2168 #else
2169                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2170                                 basenm = "& Book~ of Daemon Magic #";
2171                         else
2172                                 basenm = "& Daemon Spellbook~ #";
2173 #endif
2174
2175                         break;
2176                 }
2177                 case TV_CRUSADE_BOOK:
2178                 {
2179                         modstr = basenm;
2180 #ifdef JP
2181                                 basenm = "ÇË¼Ù¤ÎËâË¡½ñ#";
2182 #else
2183                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
2184                                 basenm = "& Book~ of Crusade Magic #";
2185                         else
2186                                 basenm = "& Crusade Spellbook~ #";
2187 #endif
2188
2189                         break;
2190                 }
2191                 case TV_MUSIC_BOOK:
2192                 {
2193                         modstr = basenm;
2194 #ifdef JP
2195                                 basenm = "²Î½¸#";
2196 #else
2197                                 basenm = "& Song Book~ #";
2198 #endif
2199
2200                         break;
2201                 }
2202                 case TV_HISSATSU_BOOK:
2203                 {
2204                         modstr = basenm;
2205 #ifdef JP
2206                                 basenm = "& Éð·Ý¤Î½ñ#";
2207 #else
2208                                 basenm = "Book~ of Kendo #";
2209 #endif
2210
2211                         break;
2212                 }
2213
2214
2215
2216                 /* Hack -- Gold/Gems */
2217                 case TV_GOLD:
2218                 {
2219                         strcpy(buf, basenm);
2220                         return;
2221                 }
2222
2223                 /* Used in the "inventory" routine */
2224                 default:
2225                 {
2226 #ifdef JP
2227                         strcpy(buf, "(¤Ê¤·)");
2228 #else
2229                         strcpy(buf, "(nothing)");
2230 #endif
2231
2232                         return;
2233                 }
2234         }
2235
2236         /* Use full name from k_info or a_info */
2237         if (aware && have_flag(flgs, TR_FULL_NAME))
2238         {
2239                 if (known && o_ptr->name1) basenm = a_name + a_info[o_ptr->name1].name;
2240                 else basenm = get_object_name(o_ptr);
2241 #ifndef JP
2242                 append_name = FALSE;
2243 #endif
2244         }
2245
2246         /* Start dumping the result */
2247         t = tmp_val;
2248
2249 #ifdef JP
2250         if (basenm[0] == '&')
2251                 s = basenm + 2;
2252         else
2253                 s = basenm;
2254
2255         /* No prefix */
2256         if (!pref)
2257         {
2258                 /* Nothing */
2259         }
2260         else if (o_ptr->number > 1)
2261         {
2262                 if ( change_numeral == FALSE ){
2263                         t = object_desc_num(t, o_ptr->number);
2264                         if (o_ptr->number > 9)
2265                                 t = object_desc_str(t, "¸Ä¤Î ");
2266                         else
2267                                 t = object_desc_str(t, "¤Ä¤Î ");
2268                 }
2269                 else
2270                 {
2271                         t = object_desc_kosuu(t,o_ptr);
2272                         t = object_desc_str(t, "¤Î ");
2273                 }
2274         }
2275
2276         /* ±Ñ¸ì¤Î¾ì¹ç¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Ï The ¤¬ÉÕ¤¯¤Î¤ÇÊ¬¤«¤ë¤¬
2277          * ÆüËÜ¸ì¤Ç¤ÏÊ¬¤«¤é¤Ê¤¤¤Î¤Ç¥Þ¡¼¥¯¤ò¤Ä¤±¤ë
2278          */
2279         if (known && artifact_p(o_ptr)) t = object_desc_str(t, "¡ú");
2280         else if (known && o_ptr->art_name) t = object_desc_str(t, "¡ù");
2281
2282 #else
2283
2284         /* The object "expects" a "number" */
2285         if (basenm[0] == '&')
2286         {
2287                 /* Skip the ampersand (and space) */
2288                 s = basenm + 2;
2289
2290                 /* No prefix */
2291                 if (!pref)
2292                 {
2293                         /* Nothing */
2294                 }
2295
2296                 /* Hack -- None left */
2297                 else if (o_ptr->number <= 0)
2298                 {
2299                         t = object_desc_str(t, "no more ");
2300                 }
2301
2302                 /* Extract the number */
2303                 else if (o_ptr->number > 1)
2304                 {
2305                         t = object_desc_num(t, o_ptr->number);
2306                         t = object_desc_chr(t, ' ');
2307                 }
2308
2309                 /* Hack -- The only one of its kind */
2310                 else if (known && (artifact_p(o_ptr) || o_ptr->art_name))
2311                 {
2312                         t = object_desc_str(t, "The ");
2313                 }
2314
2315                 /* Unique corpses are unique */
2316                 else if (o_ptr->tval == TV_CORPSE)
2317                 {
2318                         monster_race *r_ptr = &r_info[o_ptr->pval];
2319
2320                         if (r_ptr->flags1 & RF1_UNIQUE)
2321                         {
2322                                 t = object_desc_str(t, "The ");
2323                         }
2324                 }
2325
2326                 /* A single one, with a vowel in the modifier */
2327                 else if ((*s == '#') && (is_a_vowel(modstr[0])))
2328                 {
2329                         t = object_desc_str(t, "an ");
2330                 }
2331
2332                 /* A single one, with a vowel */
2333                 else if (is_a_vowel(*s))
2334                 {
2335                         t = object_desc_str(t, "an ");
2336                 }
2337
2338                 /* A single one, without a vowel */
2339                 else
2340                 {
2341                         t = object_desc_str(t, "a ");
2342                 }
2343         }
2344
2345         /* Hack -- objects that "never" take an article */
2346         else
2347         {
2348                 /* No ampersand */
2349                 s = basenm;
2350
2351                 /* No pref */
2352                 if (!pref)
2353                 {
2354                         /* Nothing */
2355                 }
2356
2357                 /* Hack -- all gone */
2358                 else if (o_ptr->number <= 0)
2359                 {
2360                         t = object_desc_str(t, "no more ");
2361                 }
2362
2363                 /* Prefix a number if required */
2364                 else if (o_ptr->number > 1)
2365                 {
2366                         t = object_desc_num(t, o_ptr->number);
2367                         t = object_desc_chr(t, ' ');
2368                 }
2369
2370                 /* Hack -- The only one of its kind */
2371                 else if (known && (artifact_p(o_ptr) || o_ptr->art_name))
2372                 {
2373                         t = object_desc_str(t, "The ");
2374                 }
2375
2376                 /* Hack -- single items get no prefix */
2377                 else
2378                 {
2379                         /* Nothing */
2380                 }
2381         }
2382 #endif
2383
2384         /* Paranoia -- skip illegal tildes */
2385         /* while (*s == '~') s++; */
2386
2387 #ifdef JP
2388         if ((o_ptr->tval > TV_CAPTURE) && o_ptr->xtra3)
2389         {
2390                 t = object_desc_str(t,format("ÃÃÌê»Õ%s¤Î",player_name));
2391         }
2392
2393         /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¡¢Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤òÉÕ²Ã¤¹¤ë */
2394         if (known) {
2395                 /* ¥é¥ó¥À¥à¡¦¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È */
2396                 if (o_ptr->art_name)
2397                 {       char temp[256];
2398                         strcpy(temp, quark_str(o_ptr->art_name));
2399                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ½é¤ËÉÕ²Ã¤¹¤ë */
2400                         /* ±Ñ¸ìÈÇ¤Î¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤«¤éÍè¤¿ 'of XXX' ¤Ï,¡ÖXXX¤Î¡×¤ÈÉ½¼¨¤¹¤ë */
2401                         if ( strncmp( temp , "of ",3)==0 ) {t=object_desc_str(t,&temp[3]);t=object_desc_str(t,"¤Î");}
2402                         else
2403                         if ( strncmp( temp , "¡Ø" , 2 ) != 0 && temp[0]!='\'')
2404                                 t=object_desc_str(t,  temp);
2405                 }
2406                 /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à */
2407                 else if (o_ptr->name1 && !have_flag(flgs, TR_FULL_NAME)) {
2408                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2409                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ½é¤ËÉÕ²Ã¤¹¤ë */
2410                         if ( strncmp( (a_name + a_ptr->name), "¡Ø" , 2) != 0){
2411                                 t=object_desc_str(t, (a_name + a_ptr->name));
2412                         }
2413                 }
2414                 /* Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à */
2415                 else if (o_ptr->name2) {
2416                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
2417                         t=object_desc_str(t, (e_name + e_ptr->name));
2418                 }
2419         }
2420 #endif
2421         /* Copy the string */
2422         for (; *s; s++)
2423         {
2424                 /* Pluralizer */
2425 #ifdef JP
2426                 if (*s == '#')
2427 #else
2428                 if (*s == '~')
2429                 {
2430                         /* Add a plural if needed */
2431                         if (pref && o_ptr->number != 1)
2432                         {
2433                                 char k = t[-1];
2434
2435                                 /* XXX XXX XXX Mega-Hack */
2436
2437                                 /* Hack -- "Cutlass-es" and "Torch-es" */
2438                                 if ((k == 's') || (k == 'h')) *t++ = 'e';
2439
2440                                 /* Add an 's' */
2441                                 *t++ = 's';
2442                         }
2443                 }
2444
2445                 /* Modifier */
2446                 else if (*s == '#')
2447 #endif
2448
2449                 {
2450                         /* Insert the modifier */
2451                         for (u = modstr; *u; u++) *t++ = *u;
2452                 }
2453
2454 #ifdef JP
2455                 else if (*s == '%')
2456                   /* saigo ¤ÎÂå¤ï¤ê¡£¸úÇ½¤òÉÕ²½¤¹¤ë by ita*/
2457                 {
2458                   modstr=get_object_name(o_ptr);
2459                   for (u = modstr; *u; u++) *t++ = *u;
2460                 }
2461 #endif
2462                 /* Normal */
2463                 else
2464                 {
2465                         /* Copy */
2466                         *t++ = *s;
2467                 }
2468         }
2469
2470         /* Terminate */
2471         *t = '\0';
2472
2473
2474         /* Append the "kind name" to the "base name" */
2475 #ifndef JP
2476         if (append_name)
2477         {
2478                 t = object_desc_str(t, " of ");
2479                 t = object_desc_str(t, get_object_name(o_ptr));
2480         }
2481 #endif
2482
2483
2484 #ifdef JP
2485         /* '¡Ø'¤«¤é»Ï¤Þ¤ëÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ¸å¤ËÉÕ²Ã¤¹¤ë */
2486         if (known) {
2487                 /* ¥é¥ó¥À¥à¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤ÎÌ¾Á°¤Ï¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤ËµÏ¿
2488                    ¤µ¤ì¤ë¤Î¤Ç¡¢±Ñ¸ìÈÇ¤ÎÌ¾Á°¤â¤½¤ì¤é¤·¤¯ÊÑ´¹¤¹¤ë */
2489                 if (o_ptr->art_name)
2490                 {       char temp[256];int itemp;
2491                         strcpy(temp, quark_str(o_ptr->art_name));
2492                         /* MEGA HACK by ita*/
2493                                 if ( strncmp( temp , "¡Ø" , 2 ) == 0 ) t=object_desc_str(t,  temp);else
2494                          if( temp[0]=='\'' ) { itemp=strlen(temp);temp[itemp-1]=0;
2495                          t=object_desc_str(t,"¡Ø");
2496                          t=object_desc_str(t,&temp[1]);
2497                          t=object_desc_str(t,"¡Ù");}
2498
2499                 }
2500                 else if (o_ptr->name1) {
2501                                 artifact_type *a_ptr = &a_info[o_ptr->name1];
2502                                 if ( strncmp( (a_name + a_ptr->name) , "¡Ø" , 2 ) == 0 ){
2503                                         t=object_desc_str(t, (a_name + a_ptr->name));
2504                                 }
2505                 }
2506                 else if (o_ptr->inscription)
2507                 {
2508                         cptr str = quark_str(o_ptr->inscription);
2509
2510                         while(*str)
2511                         {
2512                                 if (iskanji(*str))
2513                                 {
2514                                         str += 2;
2515                                         continue;
2516                                 }
2517                                 if (*str == '#') break;
2518                                 str++;
2519                         }
2520                         if (*str)
2521                         {
2522                                 /* Find the '#' */
2523                                 cptr str = strchr(quark_str(o_ptr->inscription), '#');
2524
2525                                 /* Add the false name */
2526                                 t=object_desc_str(t,"¡Ø");
2527                                 t = object_desc_str(t, &str[1]);
2528                                 t=object_desc_str(t,"¡Ù");
2529                         }
2530                 }
2531         }
2532 #else
2533         if ((o_ptr->tval > TV_CAPTURE) && o_ptr->xtra3)
2534         {
2535                 t = object_desc_str(t,format(" of %s the Smith",player_name));
2536         }
2537
2538         /* Hack -- Append "Artifact" or "Special" names */
2539         if (known && !have_flag(flgs, TR_FULL_NAME))
2540         {
2541                 /* Is it a new random artifact ? */
2542                 if (o_ptr->art_name)
2543                 {
2544                         t = object_desc_chr(t, ' ');
2545
2546                         t = object_desc_str(t, quark_str(o_ptr->art_name));
2547                 }
2548
2549                 /* Grab any artifact name */
2550                 else if (o_ptr->name1)
2551                 {
2552                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2553
2554                         t = object_desc_chr(t, ' ');
2555                         t = object_desc_str(t, (a_name + a_ptr->name));
2556                 }
2557
2558                 /* Grab any ego-item name */
2559                 else
2560                 {
2561                         if (o_ptr->name2)
2562                         {
2563                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
2564
2565                                 t = object_desc_chr(t, ' ');
2566                                 t = object_desc_str(t, (e_name + e_ptr->name));
2567                         }
2568
2569                         if (o_ptr->inscription && strchr(quark_str(o_ptr->inscription), '#'))
2570                         {
2571                                 /* Find the '#' */
2572                                 cptr str = strchr(quark_str(o_ptr->inscription), '#');
2573
2574                                 /* Add the false name */
2575                                 t = object_desc_chr(t, ' ');
2576                                 t = object_desc_str(t, &str[1]);
2577                         }
2578                 }
2579         }
2580 #endif
2581
2582
2583
2584         /* No more details wanted */
2585         if (mode < 1) goto copyback;
2586
2587         /* Hack -- Chests must be described in detail */
2588         if (o_ptr->tval == TV_CHEST)
2589         {
2590                 /* Not searched yet */
2591                 if (!known)
2592                 {
2593                         /* Nothing */
2594                 }
2595
2596                 /* May be "empty" */
2597                 else if (!o_ptr->pval)
2598                 {
2599 #ifdef JP
2600 t = object_desc_str(t, "(¶õ)");
2601 #else
2602                         t = object_desc_str(t, " (empty)");
2603 #endif
2604
2605                 }
2606
2607                 /* May be "disarmed" */
2608                 else if (o_ptr->pval < 0)
2609                 {
2610                         if (chest_traps[0 - o_ptr->pval])
2611                         {
2612 #ifdef JP
2613 t = object_desc_str(t, "(²ò½üºÑ)");
2614 #else
2615                                 t = object_desc_str(t, " (disarmed)");
2616 #endif
2617
2618                         }
2619                         else
2620                         {
2621 #ifdef JP
2622 t = object_desc_str(t, "(Èó»Ü¾û)");
2623 #else
2624                                 t = object_desc_str(t, " (unlocked)");
2625 #endif
2626
2627                         }
2628                 }
2629
2630                 /* Describe the traps, if any */
2631                 else
2632                 {
2633                         /* Describe the traps */
2634                         switch (chest_traps[o_ptr->pval])
2635                         {
2636                                 case 0:
2637                                 {
2638 #ifdef JP
2639 t = object_desc_str(t, "(»Ü¾û)");
2640 #else
2641                                         t = object_desc_str(t, " (Locked)");
2642 #endif
2643
2644                                         break;
2645                                 }
2646                                 case CHEST_LOSE_STR:
2647                                 {
2648 #ifdef JP
2649 t = object_desc_str(t, "(ÆÇ¿Ë)");
2650 #else
2651                                         t = object_desc_str(t, " (Poison Needle)");
2652 #endif
2653
2654                                         break;
2655                                 }
2656                                 case CHEST_LOSE_CON:
2657                                 {
2658 #ifdef JP
2659 t = object_desc_str(t, "(ÆÇ¿Ë)");
2660 #else
2661                                         t = object_desc_str(t, " (Poison Needle)");
2662 #endif
2663
2664                                         break;
2665                                 }
2666                                 case CHEST_POISON:
2667                                 {
2668 #ifdef JP
2669 t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2670 #else
2671                                         t = object_desc_str(t, " (Gas Trap)");
2672 #endif
2673
2674                                         break;
2675                                 }
2676                                 case CHEST_PARALYZE:
2677                                 {
2678 #ifdef JP
2679 t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2680 #else
2681                                         t = object_desc_str(t, " (Gas Trap)");
2682 #endif
2683
2684                                         break;
2685                                 }
2686                                 case CHEST_EXPLODE:
2687                                 {
2688 #ifdef JP
2689 t = object_desc_str(t, "(ÇúÈ¯ÁõÃÖ)");
2690 #else
2691                                         t = object_desc_str(t, " (Explosion Device)");
2692 #endif
2693
2694                                         break;
2695                                 }
2696                                 case CHEST_SUMMON:
2697                                 case CHEST_BIRD_STORM:
2698                                 case CHEST_E_SUMMON:
2699                                 case CHEST_H_SUMMON:
2700                                 {
2701 #ifdef JP
2702 t = object_desc_str(t, "(¾¤´¤Î¥ë¡¼¥ó)");
2703 #else
2704                                         t = object_desc_str(t, " (Summoning Runes)");
2705 #endif
2706
2707                                         break;
2708                                 }
2709                                 case CHEST_RUNES_OF_EVIL:
2710                                 {
2711 #ifdef JP
2712 t = object_desc_str(t, "(¼Ù°¤Ê¥ë¡¼¥ó)");
2713 #else
2714                                         t = object_desc_str(t, " (Gleaming Black Runes)");
2715 #endif
2716
2717                                         break;
2718                                 }
2719                                 case CHEST_ALARM:
2720                                 {
2721 #ifdef JP
2722 t = object_desc_str(t, "(·ÙÊóÁõÃÖ)");
2723 #else
2724                                         t = object_desc_str(t, " (Alarm)");
2725 #endif
2726
2727                                         break;
2728                                 }
2729                                 default:
2730                                 {
2731 #ifdef JP
2732 t = object_desc_str(t, "(¥Þ¥ë¥Á¡¦¥È¥é¥Ã¥×)");
2733 #else
2734                                         t = object_desc_str(t, " (Multiple Traps)");
2735 #endif
2736
2737                                         break;
2738                                 }
2739                         }
2740                 }
2741         }
2742
2743
2744         /* Display the item like a weapon */
2745         if (have_flag(flgs, TR_SHOW_MODS)) show_weapon = TRUE;
2746
2747         /* Display the item like a weapon */
2748         if ((o_ptr->tval > TV_CAPTURE) && (o_ptr->xtra3 == 1 + ESSENCE_SLAY_GLOVE))
2749                 show_weapon = TRUE;
2750
2751         /* Display the item like a weapon */
2752         if (o_ptr->to_h && o_ptr->to_d) show_weapon = TRUE;
2753
2754         /* Display the item like armour */
2755         if (o_ptr->ac) show_armour = TRUE;
2756
2757
2758         /* Dump base weapon info */
2759         switch (o_ptr->tval)
2760         {
2761                 /* Missiles and Weapons */
2762                 case TV_SHOT:
2763                 case TV_BOLT:
2764                 case TV_ARROW:
2765                 case TV_HAFTED:
2766                 case TV_POLEARM:
2767                 case TV_SWORD:
2768                 case TV_DIGGING:
2769
2770                 /* Append a "damage" string */
2771                 t = object_desc_chr(t, ' ');
2772                 t = object_desc_chr(t, p1);
2773                 t = object_desc_num(t, o_ptr->dd);
2774                 t = object_desc_chr(t, 'd');
2775                 t = object_desc_num(t, o_ptr->ds);
2776                 t = object_desc_chr(t, p2);
2777
2778                 /* All done */
2779                 break;
2780
2781
2782                 /* Bows get a special "damage string" */
2783                 case TV_BOW:
2784
2785                 /* Mega-Hack -- Extract the "base power" */
2786                 power = bow_tmul(o_ptr->sval);
2787
2788                 /* Apply the "Extra Might" flag */
2789                 if (have_flag(flgs, TR_XTRA_MIGHT)) power++;
2790
2791                 /* Append a special "damage" string */
2792                 t = object_desc_chr(t, ' ');
2793                 t = object_desc_chr(t, p1);
2794                 t = object_desc_chr(t, 'x');
2795                 t = object_desc_num(t, power);
2796                 t = object_desc_chr(t, p2);
2797
2798                 /* All done */
2799                 break;
2800         }
2801
2802
2803         /* Add the weapon bonuses */
2804         if (known)
2805         {
2806                 /* Show the tohit/todam on request */
2807                 if (show_weapon)
2808                 {
2809                         t = object_desc_chr(t, ' ');
2810                         t = object_desc_chr(t, p1);
2811                         t = object_desc_int(t, o_ptr->to_h);
2812                         t = object_desc_chr(t, ',');
2813                         t = object_desc_int(t, o_ptr->to_d);
2814                         t = object_desc_chr(t, p2);
2815                 }
2816
2817                 /* Show the tohit if needed */
2818                 else if (o_ptr->to_h)
2819                 {
2820                         t = object_desc_chr(t, ' ');
2821                         t = object_desc_chr(t, p1);
2822                         t = object_desc_int(t, o_ptr->to_h);
2823                         t = object_desc_chr(t, p2);
2824                 }
2825
2826                 /* Show the todam if needed */
2827                 else if (o_ptr->to_d)
2828                 {
2829                         t = object_desc_chr(t, ' ');
2830                         t = object_desc_chr(t, p1);
2831                         t = object_desc_int(t, o_ptr->to_d);
2832                         t = object_desc_chr(t, p2);
2833                 }
2834         }
2835
2836         bow_ptr = &inventory[INVEN_BOW];
2837
2838         /* if have a firing weapon + ammo matches bow*/
2839         if (bow_ptr->k_idx &&
2840             (((bow_ptr->sval == SV_SLING) && (o_ptr->tval == TV_SHOT)) ||
2841              (((bow_ptr->sval == SV_SHORT_BOW) ||
2842                (bow_ptr->sval == SV_LONG_BOW) ||
2843                (bow_ptr->sval == SV_NAMAKE_BOW)) && (o_ptr->tval == TV_ARROW)) ||
2844              (((bow_ptr->sval == SV_LIGHT_XBOW) ||
2845                (bow_ptr->sval == SV_HEAVY_XBOW)) && (o_ptr->tval == TV_BOLT))))
2846         {
2847                 int avgdam = 10;
2848                 int tmul;
2849                 s16b energy_fire;
2850
2851                 avgdam = o_ptr->dd * (o_ptr->ds + 1) * 10 / 2;
2852
2853                 /* See if the bow is "known" - then set damage bonus*/
2854                 if (object_known_p(bow_ptr))
2855                 {
2856                         avgdam += (bow_ptr->to_d * 10);
2857                 }
2858
2859                 /* effect of ammo */
2860                 if (known) avgdam += (o_ptr->to_d * 10);
2861
2862                 energy_fire = bow_energy(bow_ptr->sval);
2863                 tmul = bow_tmul(bow_ptr->sval);
2864
2865                 /* Get extra "power" from "extra might" */
2866                 if (p_ptr->xtra_might) tmul++;
2867
2868                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
2869
2870                 /* launcher multiplier */
2871                 avgdam *= tmul;
2872                 avgdam /= (100 * 10);
2873                 if (avgdam < 0) avgdam = 0;
2874
2875                 /* display (shot damage/ avg damage) */
2876                 t = object_desc_chr(t, ' ');
2877                 t = object_desc_chr(t, p1);
2878                 t = object_desc_num(t, avgdam);
2879                 t = object_desc_chr(t, '/');
2880
2881                 if (p_ptr->num_fire == 0)
2882                 {
2883                         t = object_desc_chr(t, '0');
2884                 }
2885                 else
2886                 {
2887                         /* calc effects of energy */
2888                         avgdam *= (p_ptr->num_fire * 100);
2889
2890                         avgdam /= energy_fire;
2891
2892                         t = object_desc_num(t, avgdam);
2893                 }
2894
2895                 t = object_desc_chr(t, p2);
2896         }
2897         else if ((p_ptr->pclass == CLASS_NINJA) && (o_ptr->tval == TV_SPIKE))
2898         {
2899                 int avgdam;
2900                 s16b energy_fire;
2901
2902                 if (p_ptr->mighty_throw)
2903                         avgdam =  1 + 3;
2904                 else
2905                         avgdam =  1;
2906                 avgdam += ((p_ptr->lev+30)*(p_ptr->lev+30)-900)/55;
2907
2908                 energy_fire = 100 - p_ptr->lev;
2909
2910                 /* display (shot damage/ avg damage) */
2911                 t = object_desc_chr(t, ' ');
2912                 t = object_desc_chr(t, p1);
2913                 t = object_desc_num(t, avgdam);
2914                 t = object_desc_chr(t, '/');
2915
2916                 /* calc effects of energy */
2917                 avgdam = 100 * avgdam / energy_fire;
2918
2919                 t = object_desc_num(t, avgdam);
2920
2921                 t = object_desc_chr(t, p2);
2922         }
2923
2924
2925         /* Add the armor bonuses */
2926         if (known)
2927         {
2928                 /* Show the armor class info */
2929                 if (show_armour)
2930                 {
2931                         t = object_desc_chr(t, ' ');
2932                         t = object_desc_chr(t, b1);
2933                         t = object_desc_num(t, o_ptr->ac);
2934                         t = object_desc_chr(t, ',');
2935                         t = object_desc_int(t, o_ptr->to_a);
2936                         t = object_desc_chr(t, b2);
2937                 }
2938
2939                 /* No base armor, but does increase armor */
2940                 else if (o_ptr->to_a)
2941                 {
2942                         t = object_desc_chr(t, ' ');
2943                         t = object_desc_chr(t, b1);
2944                         t = object_desc_int(t, o_ptr->to_a);
2945                         t = object_desc_chr(t, b2);
2946                 }
2947         }
2948
2949         /* Hack -- always show base armor */
2950         else if (show_armour)
2951         {
2952                 t = object_desc_chr(t, ' ');
2953                 t = object_desc_chr(t, b1);
2954                 t = object_desc_num(t, o_ptr->ac);
2955                 t = object_desc_chr(t, b2);
2956         }
2957
2958
2959         /* No more details wanted */
2960         if (mode < 2) goto copyback;
2961
2962
2963         /*
2964          * Hack -- Wands and Staffs have charges.  Make certain how many charges
2965          * a stack of staffs really has is clear. -LM-
2966          */
2967         if (known &&
2968             ((o_ptr->tval == TV_STAFF) ||
2969              (o_ptr->tval == TV_WAND)))
2970         {
2971                 /* Dump " (N charges)" */
2972                 t = object_desc_chr(t, ' ');
2973                 t = object_desc_chr(t, p1);
2974
2975                 /* Clear explaination for staffs. */
2976                 if ((o_ptr->tval == TV_STAFF) && (o_ptr->number > 1))
2977                 {
2978                         t = object_desc_num(t, o_ptr->number);
2979                         t = object_desc_str(t, "x ");
2980                 }
2981                 t = object_desc_num(t, o_ptr->pval);
2982 #ifdef JP
2983                 t = object_desc_str(t, "²óÊ¬");
2984 #else
2985                 t = object_desc_str(t, " charge");
2986
2987                 if (o_ptr->pval != 1)
2988                 {
2989                         t = object_desc_chr(t, 's');
2990                 }
2991 #endif
2992
2993
2994                 t = object_desc_chr(t, p2);
2995         }
2996         /* Hack -- Rods have a "charging" indicator.  Now that stacks of rods may
2997          * be in any state of charge or discharge, this now includes a number. -LM-
2998          */
2999         else if (known && (o_ptr->tval == TV_ROD))
3000         {
3001                 /* Hack -- Dump " (# charging)" if relevant */
3002                 if (o_ptr->timeout)
3003                 {
3004                         /* Stacks of rods display an exact count of charging rods. */
3005                         if (o_ptr->number > 1)
3006                         {
3007                                 /* Paranoia. */
3008                                 if (k_ptr->pval == 0) k_ptr->pval = 1;
3009
3010                                 /* Find out how many rods are charging, by dividing
3011                                  * current timeout by each rod's maximum timeout.
3012                                  * Ensure that any remainder is rounded up.  Display
3013                                  * very discharged stacks as merely fully discharged.
3014                                  */
3015                                 power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
3016                                 if (power > o_ptr->number) power = o_ptr->number;
3017
3018                                 /* Display prettily. */
3019                                 t = object_desc_str(t, " (");
3020                                 t = object_desc_num(t, power);
3021 #ifdef JP
3022                                 t = object_desc_str(t, "ËÜ ½¼Å¶Ãæ)");
3023 #else
3024                                 t = object_desc_str(t, " charging)");
3025 #endif
3026
3027                         }
3028
3029                         /* "one Rod of Perception (1 charging)" would look tacky. */
3030                         else
3031                         {
3032 #ifdef JP
3033 t = object_desc_str(t, "(½¼Å¶Ãæ)");
3034 #else
3035                                 t = object_desc_str(t, " (charging)");
3036 #endif
3037
3038                         }
3039                 }
3040         }
3041
3042         /* Dump "pval" flags for wearable items */
3043         if (known && (have_pval_flags(flgs)))
3044         {
3045                 /* Start the display */
3046                 t = object_desc_chr(t, ' ');
3047                 t = object_desc_chr(t, p1);
3048
3049                 /* Dump the "pval" itself */
3050                 t = object_desc_int(t, o_ptr->pval);
3051
3052                 /* Do not display the "pval" flags */
3053                 if (have_flag(flgs, TR_HIDE_TYPE))
3054                 {
3055                         /* Nothing */
3056                 }
3057
3058                 /* Speed */
3059                 else if (have_flag(flgs, TR_SPEED))
3060                 {
3061                         /* Dump " to speed" */
3062 #ifdef JP
3063 t = object_desc_str(t, "²ÃÂ®");
3064 #else
3065                         t = object_desc_str(t, " to speed");
3066 #endif
3067
3068                 }
3069
3070                 /* Attack speed */
3071                 else if (have_flag(flgs, TR_BLOWS))
3072                 {
3073                         /* Add " attack" */
3074 #ifdef JP
3075 t = object_desc_str(t, "¹¶·â");
3076 #else
3077                         t = object_desc_str(t, " attack");
3078
3079                         /* Add "attacks" */
3080                         if (ABS(o_ptr->pval) != 1) t = object_desc_chr(t, 's');
3081 #endif
3082
3083                 }
3084
3085                 /* Stealth */
3086                 else if (have_flag(flgs, TR_STEALTH))
3087                 {
3088                         /* Dump " to stealth" */
3089 #ifdef JP
3090 t = object_desc_str(t, "±£Ì©");
3091 #else
3092                         t = object_desc_str(t, " to stealth");
3093 #endif
3094
3095                 }
3096
3097                 /* Search */
3098                 else if (have_flag(flgs, TR_SEARCH))
3099                 {
3100                         /* Dump " to searching" */
3101 #ifdef JP
3102 t = object_desc_str(t, "Ãµº÷");
3103 #else
3104                         t = object_desc_str(t, " to searching");
3105 #endif
3106
3107                 }
3108
3109                 /* Infravision */
3110                 else if (have_flag(flgs, TR_INFRA))
3111                 {
3112                         /* Dump " to infravision" */
3113 #ifdef JP
3114 t = object_desc_str(t, "ÀÖ³°Àþ»ëÎÏ");
3115 #else
3116                         t = object_desc_str(t, " to infravision");
3117 #endif
3118
3119                 }
3120
3121                 /* Tunneling */
3122                 else if (have_flag(flgs, TR_TUNNEL))
3123                 {
3124                         /* Nothing */
3125                 }
3126
3127                 /* Finish the display */
3128                 t = object_desc_chr(t, p2);
3129         }
3130
3131         /* Hack -- Process Lanterns/Torches */
3132         if (known && (o_ptr->tval == TV_LITE) && (!(artifact_p(o_ptr) || (o_ptr->sval == SV_LITE_FEANOR))))
3133         {
3134                 /* Hack -- Turns of light for normal lites */
3135 #ifdef JP
3136 t = object_desc_str(t, "(");
3137 #else
3138                 t = object_desc_str(t, " (with ");
3139 #endif
3140
3141                 if (o_ptr->name2 == EGO_LITE_LONG) t = object_desc_num(t, o_ptr->xtra4*2);
3142                 else t = object_desc_num(t, o_ptr->xtra4);
3143 #ifdef JP
3144 t = object_desc_str(t, "¥¿¡¼¥ó¤Î¼÷Ì¿)");
3145 #else
3146                 t = object_desc_str(t, " turns of light)");
3147 #endif
3148
3149         }
3150
3151
3152         /* Indicate charging objects, but not rods. */
3153         if (known && o_ptr->timeout && o_ptr->tval != TV_ROD)
3154         {
3155                 /* Hack -- Dump " (charging)" if relevant */
3156 #ifdef JP
3157 t = object_desc_str(t, "(½¼Å¶Ãæ)");
3158 #else
3159                 t = object_desc_str(t, " (charging)");
3160 #endif
3161
3162         }
3163
3164
3165         /* No more details wanted */
3166         if (mode < 3) goto copyback;
3167
3168
3169         /* No inscription yet */
3170         tmp_val2[0] = '\0';
3171
3172         /* Use the game-generated "feeling" otherwise, if available */
3173         if (o_ptr->feeling)
3174         {
3175                 strcpy(tmp_val2, game_inscriptions[o_ptr->feeling]);
3176         }
3177
3178         /* Note "cursed" if the item is known to be cursed */
3179         else if (cursed_p(o_ptr) && (known || (o_ptr->ident & (IDENT_SENSE))))
3180         {
3181 #ifdef JP
3182 strcpy(tmp_val2, "¼ö¤ï¤ì¤Æ¤¤¤ë");
3183 #else
3184                 strcpy(tmp_val2, "cursed");
3185 #endif
3186
3187         }
3188
3189         /* Note "unidentified" if the item is unidentified */
3190         else if ((o_ptr->tval == TV_RING || o_ptr->tval == TV_AMULET
3191                   || o_ptr->tval == TV_LITE || o_ptr->tval == TV_FIGURINE)
3192                  && object_aware_p(o_ptr) && !object_known_p(o_ptr)
3193                  && !((o_ptr->ident)&IDENT_SENSE))
3194         {
3195 #ifdef JP
3196 strcpy(tmp_val2, "Ì¤´ÕÄê");
3197 #else
3198                 strcpy(tmp_val2, "unidentified");
3199 #endif
3200         }
3201
3202         /* Mega-Hack -- note empty wands/staffs */
3203         else if (!known && (o_ptr->ident & (IDENT_EMPTY)))
3204         {
3205 #ifdef JP
3206 strcpy(tmp_val2, "¶õ");
3207 #else
3208                 strcpy(tmp_val2, "empty");
3209 #endif
3210
3211         }
3212
3213         /* Note "tried" if the object has been tested unsuccessfully */
3214         else if (!aware && object_tried_p(o_ptr))
3215         {
3216 #ifdef JP
3217 strcpy(tmp_val2, "Ì¤È½ÌÀ");
3218 #else
3219                 strcpy(tmp_val2, "tried");
3220 #endif
3221
3222         }
3223
3224         /* Use the standard inscription if available */
3225         if (o_ptr->inscription)
3226         {
3227                 char buff[1024];
3228
3229                 if (tmp_val2[0]) strcat(tmp_val2, ", ");
3230
3231                 /* Get inscription and convert {%} */
3232                 get_inscription(buff, o_ptr);
3233
3234                 /* strcat with correct treating of kanji */
3235                 my_strcat(tmp_val2, buff, sizeof(tmp_val2));
3236         }
3237
3238         /* Note the discount, if any */
3239         else if (o_ptr->discount && !(tmp_val2[0]))
3240         {
3241                 (void)object_desc_num(tmp_val2, o_ptr->discount);
3242 #ifdef JP
3243                 strcat(tmp_val2, "%°ú¤");
3244 #else
3245                 strcat(tmp_val2, "% off");
3246 #endif
3247
3248         }
3249
3250         /* Append the inscription, if any */
3251         if (tmp_val2[0])
3252         {
3253                 /* Append the inscription */
3254                 t = object_desc_chr(t, ' ');
3255                 t = object_desc_chr(t, c1);
3256                 t = object_desc_str(t, tmp_val2);
3257                 t = object_desc_chr(t, c2);
3258         }
3259
3260 copyback:
3261         t = tmp_val;
3262         for (i = 0; i < MAX_NLEN-2; i++)
3263         {
3264 #ifdef JP
3265                 if (iskanji(*(t+i)))
3266                 {
3267                         *(buf+i) = *(t+i);
3268                         i++;
3269                 }
3270 #endif
3271                 *(buf+i) = *(t+i);
3272         }
3273         if (i == MAX_NLEN-2)
3274         {
3275 #ifdef JP
3276                 if (iskanji(*(t+i)))
3277                         *(buf+i) = '\0';
3278                 else
3279 #endif
3280                         *(buf+i) = *(t+i);
3281         }
3282         *(buf+MAX_NLEN-1) = '\0';
3283 }
3284