src/flavor.c

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