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