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