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