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