src/flavor.c

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