src/flavor.c

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