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
1238         bool            aware = FALSE;
1239         bool            known = FALSE;
1240         bool            flavor = TRUE;
1241
1242         bool            show_weapon = FALSE;
1243         bool            show_armour = FALSE;
1244
1245         cptr            s, s0;
1246         char            *t;
1247
1248         char            p1 = '(', p2 = ')';
1249         char            b1 = '[', b2 = ']';
1250         char            c1 = '{', c2 = '}';
1251
1252         char            tmp_val[MAX_NLEN+160];
1253         char            tmp_val2[MAX_NLEN+10];
1254         char            fake_insc_buf[30];
1255
1256         u32b flgs[TR_FLAG_SIZE];
1257
1258         object_type *bow_ptr;
1259
1260         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1261         object_kind *flavor_k_ptr = &k_info[k_ptr->flavor];
1262
1263         /* Extract some flags */
1264         object_flags(o_ptr, flgs);
1265
1266         /* See if the object is "aware" */
1267         if (object_is_aware(o_ptr)) aware = TRUE;
1268
1269         /* See if the object is "known" */
1270         if (object_is_known(o_ptr)) known = TRUE;
1271
1272         /* Allow flavors to be hidden when aware */
1273         if (aware && ((mode & OD_NO_FLAVOR) || plain_descriptions)) flavor = FALSE;
1274
1275         /* Object is in the inventory of a store or spoiler */
1276         if ((mode & OD_STORE) || (o_ptr->ident & IDENT_STORE))
1277         {
1278                 /* Don't show flavors */
1279                 flavor = FALSE;
1280
1281                 /* Pretend known and aware */
1282                 aware = TRUE;
1283                 known = TRUE;
1284         }
1285
1286         /* Force to be flavor name only */
1287         if (mode & OD_FORCE_FLAVOR)
1288         {
1289                 aware = FALSE;
1290                 flavor = TRUE;
1291                 known = FALSE;
1292
1293                 /* Cancel shuffling */
1294                 flavor_k_ptr = k_ptr;
1295         }
1296
1297         /* Analyze the object */
1298         switch (o_ptr->tval)
1299         {
1300                 /* Some objects are easy to describe */
1301                 case TV_SKELETON:
1302                 case TV_BOTTLE:
1303                 case TV_JUNK:
1304                 case TV_SPIKE:
1305                 case TV_FLASK:
1306                 case TV_CHEST:
1307                 case TV_WHISTLE:
1308                 {
1309                         break;
1310                 }
1311
1312                 case TV_CAPTURE:
1313                 {
1314                         monster_race *r_ptr = &r_info[o_ptr->pval];
1315
1316                         if (known)
1317                         {
1318                                 if (!o_ptr->pval)
1319                                 {
1320 #ifdef JP
1321                                         modstr = " (¶õ)";
1322 #else
1323                                         modstr = " (empty)";
1324 #endif
1325                                 }
1326                                 else
1327                                 {
1328 #ifdef JP
1329                                         sprintf(tmp_val2, " (%s)",r_name + r_ptr->name);
1330                                         modstr = tmp_val2;
1331 #else
1332                                         cptr t = r_name + r_ptr->name;
1333
1334                                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1335                                         {
1336                                                 sprintf(tmp_val2, " (%s%s)", (is_a_vowel(*t) ? "an " : "a "), t);
1337
1338                                                 modstr = tmp_val2;
1339                                         }
1340                                         else
1341                                         {
1342                                                 sprintf(tmp_val2, "(%s)", t);
1343
1344                                                 modstr = t;
1345                                         }
1346 #endif
1347                                 }
1348                         }
1349                         break;
1350                 }
1351
1352                 /* Figurines/Statues */
1353                 case TV_FIGURINE:
1354                 case TV_STATUE:
1355                 {
1356                         monster_race *r_ptr = &r_info[o_ptr->pval];
1357
1358 #ifdef JP
1359                         modstr = r_name + r_ptr->name;
1360 #else
1361                         cptr t = r_name + r_ptr->name;
1362
1363                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1364                         {
1365                                 sprintf(tmp_val2, "%s%s", (is_a_vowel(*t) ? "an " : "a "), t);
1366
1367                                 modstr = tmp_val2;
1368                         }
1369                         else
1370                         {
1371                                 modstr = t;
1372                         }
1373 #endif
1374
1375
1376                         break;
1377                 }
1378
1379                 /* Corpses */
1380                 case TV_CORPSE:
1381                 {
1382                         monster_race *r_ptr = &r_info[o_ptr->pval];
1383
1384                         modstr = r_name + r_ptr->name;
1385
1386 #ifdef JP
1387                         basenm = "#%";
1388 #else
1389                         if (r_ptr->flags1 & RF1_UNIQUE)
1390                                 basenm = "& % of #";
1391                         else
1392                                 basenm = "& # %";
1393 #endif
1394
1395                         break;
1396                 }
1397
1398                 /* Missiles/ Bows/ Weapons */
1399                 case TV_SHOT:
1400                 case TV_BOLT:
1401                 case TV_ARROW:
1402                 case TV_BOW:
1403                 case TV_HAFTED:
1404                 case TV_POLEARM:
1405                 case TV_SWORD:
1406                 case TV_DIGGING:
1407                 {
1408                         show_weapon = TRUE;
1409                         break;
1410                 }
1411
1412                 /* Armour */
1413                 case TV_BOOTS:
1414                 case TV_GLOVES:
1415                 case TV_CLOAK:
1416                 case TV_CROWN:
1417                 case TV_HELM:
1418                 case TV_SHIELD:
1419                 case TV_SOFT_ARMOR:
1420                 case TV_HARD_ARMOR:
1421                 case TV_DRAG_ARMOR:
1422                 {
1423                         show_armour = TRUE;
1424                         break;
1425                 }
1426
1427                 /* Lites (including a few "Specials") */
1428                 case TV_LITE:
1429                 {
1430                         break;
1431                 }
1432
1433                 /* Amulets (including a few "Specials") */
1434                 case TV_AMULET:
1435                 {
1436                         /* Known artifacts */
1437                         if (aware)
1438                         {
1439                                 if (object_is_fixed_artifact(o_ptr)) break;
1440                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1441                         }
1442
1443                         /* Color the object */
1444                         modstr = k_name + flavor_k_ptr->flavor_name;
1445
1446 #ifdef JP
1447                         if (!flavor)    basenm = "%¤Î¥¢¥ß¥å¥ì¥Ã¥È";
1448                         else if (aware) basenm = "%¤Î#¥¢¥ß¥å¥ì¥Ã¥È";
1449                         else            basenm = "#¥¢¥ß¥å¥ì¥Ã¥È";
1450 #else
1451                         if (!flavor)    basenm = "& Amulet~ of %";
1452                         else if (aware) basenm = "& # Amulet~ of %";
1453                         else            basenm = "& # Amulet~";
1454 #endif
1455
1456                         break;
1457                 }
1458
1459                 /* Rings (including a few "Specials") */
1460                 case TV_RING:
1461                 {
1462                         /* Known artifacts */
1463                         if (aware)
1464                         {
1465                                 if (object_is_fixed_artifact(o_ptr)) break;
1466                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1467                         }
1468
1469                         /* Color the object */
1470                         modstr = k_name + flavor_k_ptr->flavor_name;
1471
1472 #ifdef JP
1473                         if (!flavor)    basenm = "%¤Î»ØÎØ";
1474                         else if (aware) basenm = "%¤Î#»ØÎØ";
1475                         else            basenm = "#»ØÎØ";
1476 #else
1477                         if (!flavor)    basenm = "& Ring~ of %";
1478                         else if (aware) basenm = "& # Ring~ of %";
1479                         else            basenm = "& # Ring~";
1480 #endif
1481
1482                         if (!k_ptr->to_h && !k_ptr->to_d && (o_ptr->to_h || o_ptr->to_d)) show_weapon = TRUE;
1483
1484                         break;
1485                 }
1486
1487                 case TV_CARD:
1488                 {
1489                         break;
1490                 }
1491
1492                 case TV_STAFF:
1493                 {
1494                         /* Color the object */
1495                         modstr = k_name + flavor_k_ptr->flavor_name;
1496
1497 #ifdef JP
1498                         if (!flavor)    basenm = "%¤Î¾ó";
1499                         else if (aware) basenm = "%¤Î#¾ó";
1500                         else            basenm = "#¾ó";
1501 #else
1502                         if (!flavor)    basenm = "& Staff~ of %";
1503                         else if (aware) basenm = "& # Staff~ of %";
1504                         else            basenm = "& # Staff~";
1505 #endif
1506
1507                         break;
1508                 }
1509
1510                 case TV_WAND:
1511                 {
1512                         /* Color the object */
1513                         modstr = k_name + flavor_k_ptr->flavor_name;
1514
1515 #ifdef JP
1516                         if (!flavor)    basenm = "%¤ÎËâË¡ËÀ";
1517                         else if (aware) basenm = "%¤Î#ËâË¡ËÀ";
1518                         else            basenm = "#ËâË¡ËÀ";
1519 #else
1520                         if (!flavor)    basenm = "& Wand~ of %";
1521                         else if (aware) basenm = "& # Wand~ of %";
1522                         else            basenm = "& # Wand~";
1523 #endif
1524
1525                         break;
1526                 }
1527
1528                 case TV_ROD:
1529                 {
1530                         /* Color the object */
1531                         modstr = k_name + flavor_k_ptr->flavor_name;
1532
1533 #ifdef JP
1534                         if (!flavor)    basenm = "%¤Î¥í¥Ã¥É";
1535                         else if (aware) basenm = "%¤Î#¥í¥Ã¥É";
1536                         else            basenm = "#¥í¥Ã¥É";
1537 #else
1538                         if (!flavor)    basenm = "& Rod~ of %";
1539                         else if (aware) basenm = "& # Rod~ of %";
1540                         else            basenm = "& # Rod~";
1541 #endif
1542
1543                         break;
1544                 }
1545
1546                 case TV_SCROLL:
1547                 {
1548                         /* Color the object */
1549                         modstr = k_name + flavor_k_ptr->flavor_name;
1550
1551 #ifdef JP
1552                         if (!flavor)    basenm = "%¤Î´¬Êª";
1553                         else if (aware) basenm = "¡Ö#¡×¤È½ñ¤«¤ì¤¿%¤Î´¬Êª";
1554                         else            basenm = "¡Ö#¡×¤È½ñ¤«¤ì¤¿´¬Êª";
1555 #else
1556                         if (!flavor)    basenm = "& Scroll~ of %";
1557                         else if (aware) basenm = "& Scroll~ titled \"#\" of %";
1558                         else            basenm = "& Scroll~ titled \"#\"";
1559 #endif
1560
1561                         break;
1562                 }
1563
1564                 case TV_POTION:
1565                 {
1566                         /* Color the object */
1567                         modstr = k_name + flavor_k_ptr->flavor_name;
1568
1569 #ifdef JP
1570                         if (!flavor)    basenm = "%¤ÎÌô";
1571                         else if (aware) basenm = "%¤Î#Ìô";
1572                         else            basenm = "#Ìô";
1573 #else
1574                         if (!flavor)    basenm = "& Potion~ of %";
1575                         else if (aware) basenm = "& # Potion~ of %";
1576                         else            basenm = "& # Potion~";
1577 #endif
1578
1579                         break;
1580                 }
1581
1582                 case TV_FOOD:
1583                 {
1584                         /* Ordinary food is "boring" */
1585                         if (!k_ptr->flavor_name) break;
1586
1587                         /* Color the object */
1588                         modstr = k_name + flavor_k_ptr->flavor_name;
1589
1590 #ifdef JP
1591                         if (!flavor)    basenm = "%¤Î¥¥Î¥³";
1592                         else if (aware) basenm = "%¤Î#¥¥Î¥³";
1593                         else            basenm = "#¥¥Î¥³";
1594 #else
1595                         if (!flavor)    basenm = "& Mushroom~ of %";
1596                         else if (aware) basenm = "& # Mushroom~ of %";
1597                         else            basenm = "& # Mushroom~";
1598 #endif
1599
1600                         break;
1601                 }
1602
1603                 case TV_PARCHMENT:
1604                 {
1605 #ifdef JP
1606                         basenm = "ÍÓÈé»æ - %";
1607 #else
1608                         basenm = "& Parchment~ - %";
1609 #endif
1610                         break;
1611                 }
1612
1613                 /* Magic Books */
1614                 case TV_LIFE_BOOK:
1615                 {
1616 #ifdef JP
1617                         basenm = "À¸Ì¿¤ÎËâË¡½ñ%";
1618 #else
1619                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1620                                 basenm = "& Book~ of Life Magic %";
1621                         else
1622                                 basenm = "& Life Spellbook~ %";
1623 #endif
1624
1625                         break;
1626                 }
1627
1628                 case TV_SORCERY_BOOK:
1629                 {
1630 #ifdef JP
1631                         basenm = "Àç½Ñ¤ÎËâË¡½ñ%";
1632 #else
1633                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1634                                 basenm = "& Book~ of Sorcery %";
1635                         else
1636                                 basenm = "& Sorcery Spellbook~ %";
1637 #endif
1638
1639                         break;
1640                 }
1641
1642                 case TV_NATURE_BOOK:
1643                 {
1644 #ifdef JP
1645                         basenm = "¼«Á³¤ÎËâË¡½ñ%";
1646 #else
1647                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1648                                 basenm = "& Book~ of Nature Magic %";
1649                         else
1650                                 basenm = "& Nature Spellbook~ %";
1651 #endif
1652
1653                         break;
1654                 }
1655
1656                 case TV_CHAOS_BOOK:
1657                 {
1658 #ifdef JP
1659                         basenm = "¥«¥ª¥¹¤ÎËâË¡½ñ%";
1660 #else
1661                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1662                                 basenm = "& Book~ of Chaos Magic %";
1663                         else
1664                                 basenm = "& Chaos Spellbook~ %";
1665 #endif
1666
1667                         break;
1668                 }
1669
1670                 case TV_DEATH_BOOK:
1671                 {
1672 #ifdef JP
1673                         basenm = "°Å¹õ¤ÎËâË¡½ñ%";
1674 #else
1675                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1676                                 basenm = "& Book~ of Death Magic %";
1677                         else
1678                                 basenm = "& Death Spellbook~ %";
1679 #endif
1680
1681                         break;
1682                 }
1683
1684                 case TV_TRUMP_BOOK:
1685                 {
1686 #ifdef JP
1687                         basenm = "¥È¥é¥ó¥×¤ÎËâË¡½ñ%";
1688 #else
1689                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1690                                 basenm = "& Book~ of Trump Magic %";
1691                         else
1692                                 basenm = "& Trump Spellbook~ %";
1693 #endif
1694
1695                         break;
1696                 }
1697
1698                 case TV_ARCANE_BOOK:
1699                 {
1700 #ifdef JP
1701                         basenm = "Èë½Ñ¤ÎËâË¡½ñ%";
1702 #else
1703                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1704                                 basenm = "& Book~ of Arcane Magic %";
1705                         else
1706                                 basenm = "& Arcane Spellbook~ %";
1707 #endif
1708
1709                         break;
1710                 }
1711
1712                 case TV_CRAFT_BOOK:
1713                 {
1714 #ifdef JP
1715                         basenm = "¾¢¤ÎËâË¡½ñ%";
1716 #else
1717                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1718                                 basenm = "& Book~ of Craft Magic %";
1719                         else
1720                                 basenm = "& Craft Spellbook~ %";
1721 #endif
1722
1723                         break;
1724                 }
1725
1726                 case TV_DAEMON_BOOK:
1727                 {
1728 #ifdef JP
1729                         basenm = "°Ëâ¤ÎËâË¡½ñ%";
1730 #else
1731                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1732                                 basenm = "& Book~ of Daemon Magic %";
1733                         else
1734                                 basenm = "& Daemon Spellbook~ %";
1735 #endif
1736
1737                         break;
1738                 }
1739
1740                 case TV_CRUSADE_BOOK:
1741                 {
1742 #ifdef JP
1743                         basenm = "ÇË¼Ù¤ÎËâË¡½ñ%";
1744 #else
1745                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1746                                 basenm = "& Book~ of Crusade Magic %";
1747                         else
1748                                 basenm = "& Crusade Spellbook~ %";
1749 #endif
1750
1751                         break;
1752                 }
1753
1754                 case TV_MUSIC_BOOK:
1755                 {
1756 #ifdef JP
1757                         basenm = "²Î½¸%";
1758 #else
1759                         basenm = "& Song Book~ %";
1760 #endif
1761
1762                         break;
1763                 }
1764
1765                 case TV_HISSATSU_BOOK:
1766                 {
1767 #ifdef JP
1768                         basenm = "& Éð·Ý¤Î½ñ%";
1769 #else
1770                         basenm = "Book~ of Kendo %";
1771 #endif
1772
1773                         break;
1774                 }
1775
1776                 case TV_HEX_BOOK:
1777                 {
1778 #ifdef JP
1779                         basenm = "¼ö½Ñ¤ÎËâË¡½ñ%";
1780 #else
1781                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1782                                 basenm = "& Book~ of Crusade Magic %";
1783                         else
1784                                 basenm = "& Crusade Spellbook~ %";
1785 #endif
1786
1787                         break;
1788                 }
1789
1790                 /* Hack -- Gold/Gems */
1791                 case TV_GOLD:
1792                 {
1793                         strcpy(buf, basenm);
1794                         return;
1795                 }
1796
1797                 /* Used in the "inventory" routine */
1798                 default:
1799                 {
1800 #ifdef JP
1801                         strcpy(buf, "(¤Ê¤·)");
1802 #else
1803                         strcpy(buf, "(nothing)");
1804 #endif
1805
1806                         return;
1807                 }
1808         }
1809
1810         /* Use full name from k_info or a_info */
1811         if (aware && have_flag(flgs, TR_FULL_NAME))
1812         {
1813                 if (known && o_ptr->name1) basenm = a_name + a_info[o_ptr->name1].name;
1814                 else basenm = kindname;
1815         }
1816
1817         /* Start dumping the result */
1818         t = tmp_val;
1819
1820 #ifdef JP
1821         if (basenm[0] == '&')
1822                 s = basenm + 2;
1823         else
1824                 s = basenm;
1825
1826         /* No prefix */
1827         if (mode & OD_OMIT_PREFIX)
1828         {
1829                 /* Nothing */
1830         }
1831         else if (o_ptr->number > 1)
1832         {
1833                 t = object_desc_kosuu(t, o_ptr);
1834                 t = object_desc_str(t, "¤Î ");
1835         }
1836
1837         /* ±Ñ¸ì¤Î¾ì¹ç¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤Ï The ¤¬ÉÕ¤¯¤Î¤ÇÊ¬¤«¤ë¤¬
1838          * ÆüËÜ¸ì¤Ç¤ÏÊ¬¤«¤é¤Ê¤¤¤Î¤Ç¥Þ¡¼¥¯¤ò¤Ä¤±¤ë
1839          */
1840         if (known)
1841         {
1842                 if (object_is_fixed_artifact(o_ptr)) t = object_desc_str(t, "¡ú");
1843                 else if (o_ptr->art_name) t = object_desc_str(t, "¡ù");
1844         }
1845
1846 #else
1847
1848         /* The object "expects" a "number" */
1849         if (basenm[0] == '&')
1850         {
1851                 /* Skip the ampersand (and space) */
1852                 s = basenm + 2;
1853
1854                 /* No prefix */
1855                 if (mode & OD_OMIT_PREFIX)
1856                 {
1857                         /* Nothing */
1858                 }
1859
1860                 /* Hack -- None left */
1861                 else if (o_ptr->number <= 0)
1862                 {
1863                         t = object_desc_str(t, "no more ");
1864                 }
1865
1866                 /* Extract the number */
1867                 else if (o_ptr->number > 1)
1868                 {
1869                         t = object_desc_num(t, o_ptr->number);
1870                         t = object_desc_chr(t, ' ');
1871                 }
1872
1873                 /* Hack -- The only one of its kind */
1874                 else if ((known && object_is_artifact(o_ptr)) ||
1875                          ((o_ptr->tval == TV_CORPSE) &&
1876                           (r_info[o_ptr->pval].flags1 & RF1_UNIQUE)))
1877                 {
1878                         t = object_desc_str(t, "The ");
1879                 }
1880
1881                 /* A single one */
1882                 else
1883                 {
1884                         bool vowel;
1885
1886                         switch (*s)
1887                         {
1888                         case '#': vowel = is_a_vowel(modstr[0]); break;
1889                         case '%': vowel = is_a_vowel(*kindname); break;
1890                         default:  vowel = is_a_vowel(*s); break;
1891                         }
1892
1893                         if (vowel)
1894                         {
1895                                 /* A single one, with a vowel */
1896                                 t = object_desc_str(t, "an ");
1897                         }
1898                         else
1899                         {
1900                                 /* A single one, without a vowel */
1901                                 t = object_desc_str(t, "a ");
1902                         }
1903                 }
1904         }
1905
1906         /* Hack -- objects that "never" take an article */
1907         else
1908         {
1909                 /* No ampersand */
1910                 s = basenm;
1911
1912                 /* No pref */
1913                 if (mode & OD_OMIT_PREFIX)
1914                 {
1915                         /* Nothing */
1916                 }
1917
1918                 /* Hack -- all gone */
1919                 else if (o_ptr->number <= 0)
1920                 {
1921                         t = object_desc_str(t, "no more ");
1922                 }
1923
1924                 /* Prefix a number if required */
1925                 else if (o_ptr->number > 1)
1926                 {
1927                         t = object_desc_num(t, o_ptr->number);
1928                         t = object_desc_chr(t, ' ');
1929                 }
1930
1931                 /* Hack -- The only one of its kind */
1932                 else if (known && object_is_artifact(o_ptr))
1933                 {
1934                         t = object_desc_str(t, "The ");
1935                 }
1936
1937                 /* Hack -- single items get no prefix */
1938                 else
1939                 {
1940                         /* Nothing */
1941                 }
1942         }
1943 #endif
1944
1945         /* Paranoia -- skip illegal tildes */
1946         /* while (*s == '~') s++; */
1947
1948 #ifdef JP
1949         if (object_is_smith(o_ptr))
1950         {
1951                 t = object_desc_str(t, format("ÃÃÌê»Õ%s¤Î", player_name));
1952         }
1953
1954         /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¡¢Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤òÉÕ²Ã¤¹¤ë */
1955         if (known)
1956         {
1957                 /* ¥é¥ó¥À¥à¡¦¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È */
1958                 if (o_ptr->art_name)
1959                 {
1960                         cptr temp = quark_str(o_ptr->art_name);
1961
1962                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ½é¤ËÉÕ²Ã¤¹¤ë */
1963                         /* ±Ñ¸ìÈÇ¤Î¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤«¤éÍè¤¿ 'of XXX' ¤Ï,¡ÖXXX¤Î¡×¤ÈÉ½¼¨¤¹¤ë */
1964                         if (strncmp(temp, "of ", 3) == 0)
1965                         {
1966                                 t = object_desc_str(t, &temp[3]);
1967                                 t = object_desc_str(t, "¤Î");
1968                         }
1969                         else if ((strncmp(temp, "¡Ø", 2) != 0) &&
1970                                  (strncmp(temp, "¡Ô", 2) != 0) &&
1971                                  (temp[0] != '\''))
1972                                 t = object_desc_str(t, temp);
1973                 }
1974                 /* ÅÁÀâ¤Î¥¢¥¤¥Æ¥à */
1975                 else if (o_ptr->name1 && !have_flag(flgs, TR_FULL_NAME))
1976                 {
1977                         artifact_type *a_ptr = &a_info[o_ptr->name1];
1978                         /* '¡Ø' ¤«¤é»Ï¤Þ¤é¤Ê¤¤ÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ½é¤ËÉÕ²Ã¤¹¤ë */
1979                         if (strncmp(a_name + a_ptr->name, "¡Ø", 2) != 0)
1980                         {
1981                                 t = object_desc_str(t, a_name + a_ptr->name);
1982                         }
1983                 }
1984                 /* Ì¾¤Î¤¢¤ë¥¢¥¤¥Æ¥à */
1985                 else if (object_is_ego(o_ptr))
1986                 {
1987                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
1988                         t = object_desc_str(t, e_name + e_ptr->name);
1989                 }
1990         }
1991 #endif
1992
1993         /* Copy the string */
1994         for (s0 = NULL; *s || s0; )
1995         {
1996                 /* The end of the flavour/kind string. */
1997                 if (!*s)
1998                 {
1999                         s = s0 + 1;
2000                         s0 = NULL;
2001                 }
2002
2003                 /* Begin to append the modifier (flavor) */
2004                 else if ((*s == '#') && !s0)
2005                 {
2006                         s0 = s;
2007                         s = modstr;
2008
2009                         /* Paranoia -- Never append multiple modstrs */
2010                         modstr = "";
2011                 }
2012
2013                 /* Begin to append the kind name */
2014                 else if ((*s == '%') && !s0)
2015                 {
2016                         s0 = s;
2017                         s = kindname;
2018
2019                         /* Paranoia -- Never append multiple kindnames */
2020                         kindname = "";
2021                 }
2022
2023 #ifndef JP
2024                 /* Pluralizer */
2025                 else if (*s == '~')
2026                 {
2027                         /* Add a plural if needed */
2028                         if (!(mode & OD_NO_PLURAL) && (o_ptr->number != 1))
2029                         {
2030                                 char k = t[-1];
2031
2032                                 /* XXX XXX XXX Mega-Hack */
2033
2034                                 /* Hack -- "Cutlass-es" and "Torch-es" */
2035                                 if ((k == 's') || (k == 'h')) *t++ = 'e';
2036
2037                                 /* Add an 's' */
2038                                 *t++ = 's';
2039                         }
2040                         s++;
2041                 }
2042 #endif
2043
2044                 /* Normal */
2045                 else
2046                 {
2047                         /* Copy */
2048                         *t++ = *s++;
2049                 }
2050         }
2051
2052         /* Terminate */
2053         *t = '\0';
2054
2055
2056 #ifdef JP
2057         /* '¡Ø'¤«¤é»Ï¤Þ¤ëÅÁÀâ¤Î¥¢¥¤¥Æ¥à¤ÎÌ¾Á°¤ÏºÇ¸å¤ËÉÕ²Ã¤¹¤ë */
2058         if (known)
2059         {
2060                 /* ¥é¥ó¥À¥à¥¢¡¼¥Æ¥£¥Õ¥¡¥¯¥È¤ÎÌ¾Á°¤Ï¥»¡¼¥Ö¥Õ¥¡¥¤¥ë¤ËµÏ¿
2061                    ¤µ¤ì¤ë¤Î¤Ç¡¢±Ñ¸ìÈÇ¤ÎÌ¾Á°¤â¤½¤ì¤é¤·¤¯ÊÑ´¹¤¹¤ë */
2062                 if (o_ptr->art_name)
2063                 {
2064                         char temp[256];
2065                         int itemp;
2066                         strcpy(temp, quark_str(o_ptr->art_name));
2067                         /* MEGA HACK by ita */
2068                         if (strncmp(temp, "¡Ø", 2) == 0 ||
2069                             strncmp(temp, "¡Ô", 2) == 0)
2070                                 t = object_desc_str(t, temp);
2071                         else if (temp[0] == '\'')
2072                         {
2073                                 itemp = strlen(temp);
2074                                 temp[itemp - 1] = 0;
2075                                 t = object_desc_str(t, "¡Ø");
2076                                 t = object_desc_str(t, &temp[1]);
2077                                 t = object_desc_str(t, "¡Ù");
2078                         }
2079                 }
2080                 else if (object_is_fixed_artifact(o_ptr))
2081                 {
2082                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2083                         if (strncmp(a_name + a_ptr->name, "¡Ø", 2) == 0)
2084                         {
2085                                 t = object_desc_str(t, a_name + a_ptr->name);
2086                         }
2087                 }
2088                 else if (o_ptr->inscription)
2089                 {
2090                         cptr str = quark_str(o_ptr->inscription);
2091
2092                         while(*str)
2093                         {
2094                                 if (iskanji(*str))
2095                                 {
2096                                         str += 2;
2097                                         continue;
2098                                 }
2099                                 if (*str == '#') break;
2100                                 str++;
2101                         }
2102                         if (*str)
2103                         {
2104                                 /* Find the '#' */
2105                                 cptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2106
2107                                 /* Add the false name */
2108                                 t = object_desc_str(t,"¡Ø");
2109                                 t = object_desc_str(t, &str[1]);
2110                                 t = object_desc_str(t,"¡Ù");
2111                         }
2112                 }
2113         }
2114 #else
2115         if (object_is_smith(o_ptr))
2116         {
2117                 t = object_desc_str(t,format(" of %s the Smith",player_name));
2118         }
2119
2120         /* Hack -- Append "Artifact" or "Special" names */
2121         if (known && !have_flag(flgs, TR_FULL_NAME))
2122         {
2123                 /* Is it a new random artifact ? */
2124                 if (o_ptr->art_name)
2125                 {
2126                         t = object_desc_chr(t, ' ');
2127                         t = object_desc_str(t, quark_str(o_ptr->art_name));
2128                 }
2129
2130                 /* Grab any artifact name */
2131                 else if (object_is_fixed_artifact(o_ptr))
2132                 {
2133                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2134
2135                         t = object_desc_chr(t, ' ');
2136                         t = object_desc_str(t, a_name + a_ptr->name);
2137                 }
2138
2139                 /* Grab any ego-item name */
2140                 else
2141                 {
2142                         if (object_is_ego(o_ptr))
2143                         {
2144                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
2145
2146                                 t = object_desc_chr(t, ' ');
2147                                 t = object_desc_str(t, e_name + e_ptr->name);
2148                         }
2149
2150                         if (o_ptr->inscription && my_strchr(quark_str(o_ptr->inscription), '#'))
2151                         {
2152                                 /* Find the '#' */
2153                                 cptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2154
2155                                 /* Add the false name */
2156                                 t = object_desc_chr(t, ' ');
2157                                 t = object_desc_str(t, &str[1]);
2158                         }
2159                 }
2160         }
2161 #endif
2162
2163
2164         /* No more details wanted */
2165         if (mode & OD_NAME_ONLY) goto object_desc_done;
2166
2167         /* Hack -- Chests must be described in detail */
2168         if (o_ptr->tval == TV_CHEST)
2169         {
2170                 /* Not searched yet */
2171                 if (!known)
2172                 {
2173                         /* Nothing */
2174                 }
2175
2176                 /* May be "empty" */
2177                 else if (!o_ptr->pval)
2178                 {
2179 #ifdef JP
2180                         t = object_desc_str(t, "(¶õ)");
2181 #else
2182                         t = object_desc_str(t, " (empty)");
2183 #endif
2184                 }
2185
2186                 /* May be "disarmed" */
2187                 else if (o_ptr->pval < 0)
2188                 {
2189                         if (chest_traps[0 - o_ptr->pval])
2190                         {
2191 #ifdef JP
2192                                 t = object_desc_str(t, "(²ò½üºÑ)");
2193 #else
2194                                 t = object_desc_str(t, " (disarmed)");
2195 #endif
2196                         }
2197                         else
2198                         {
2199 #ifdef JP
2200                                 t = object_desc_str(t, "(Èó»Ü¾û)");
2201 #else
2202                                 t = object_desc_str(t, " (unlocked)");
2203 #endif
2204                         }
2205                 }
2206
2207                 /* Describe the traps, if any */
2208                 else
2209                 {
2210                         /* Describe the traps */
2211                         switch (chest_traps[o_ptr->pval])
2212                         {
2213                                 case 0:
2214                                 {
2215 #ifdef JP
2216                                         t = object_desc_str(t, "(»Ü¾û)");
2217 #else
2218                                         t = object_desc_str(t, " (Locked)");
2219 #endif
2220                                         break;
2221                                 }
2222                                 case CHEST_LOSE_STR:
2223                                 {
2224 #ifdef JP
2225                                         t = object_desc_str(t, "(ÆÇ¿Ë)");
2226 #else
2227                                         t = object_desc_str(t, " (Poison Needle)");
2228 #endif
2229                                         break;
2230                                 }
2231                                 case CHEST_LOSE_CON:
2232                                 {
2233 #ifdef JP
2234                                         t = object_desc_str(t, "(ÆÇ¿Ë)");
2235 #else
2236                                         t = object_desc_str(t, " (Poison Needle)");
2237 #endif
2238                                         break;
2239                                 }
2240                                 case CHEST_POISON:
2241                                 {
2242 #ifdef JP
2243                                         t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2244 #else
2245                                         t = object_desc_str(t, " (Gas Trap)");
2246 #endif
2247                                         break;
2248                                 }
2249                                 case CHEST_PARALYZE:
2250                                 {
2251 #ifdef JP
2252                                         t = object_desc_str(t, "(¥¬¥¹¡¦¥È¥é¥Ã¥×)");
2253 #else
2254                                         t = object_desc_str(t, " (Gas Trap)");
2255 #endif
2256                                         break;
2257                                 }
2258                                 case CHEST_EXPLODE:
2259                                 {
2260 #ifdef JP
2261                                         t = object_desc_str(t, "(ÇúÈ¯ÁõÃÖ)");
2262 #else
2263                                         t = object_desc_str(t, " (Explosion Device)");
2264 #endif
2265                                         break;
2266                                 }
2267                                 case CHEST_SUMMON:
2268                                 case CHEST_BIRD_STORM:
2269                                 case CHEST_E_SUMMON:
2270                                 case CHEST_H_SUMMON:
2271                                 {
2272 #ifdef JP
2273                                         t = object_desc_str(t, "(¾¤´¤Î¥ë¡¼¥ó)");
2274 #else
2275                                         t = object_desc_str(t, " (Summoning Runes)");
2276 #endif
2277                                         break;
2278                                 }
2279                                 case CHEST_RUNES_OF_EVIL:
2280                                 {
2281 #ifdef JP
2282                                         t = object_desc_str(t, "(¼Ù°¤Ê¥ë¡¼¥ó)");
2283 #else
2284                                         t = object_desc_str(t, " (Gleaming Black Runes)");
2285 #endif
2286                                         break;
2287                                 }
2288                                 case CHEST_ALARM:
2289                                 {
2290 #ifdef JP
2291                                         t = object_desc_str(t, "(·ÙÊóÁõÃÖ)");
2292 #else
2293                                         t = object_desc_str(t, " (Alarm)");
2294 #endif
2295                                         break;
2296                                 }
2297                                 default:
2298                                 {
2299 #ifdef JP
2300                                         t = object_desc_str(t, "(¥Þ¥ë¥Á¡¦¥È¥é¥Ã¥×)");
2301 #else
2302                                         t = object_desc_str(t, " (Multiple Traps)");
2303 #endif
2304                                         break;
2305                                 }
2306                         }
2307                 }
2308         }
2309
2310
2311         /* Display the item like a weapon */
2312         if (have_flag(flgs, TR_SHOW_MODS)) show_weapon = TRUE;
2313
2314         /* Display the item like a weapon */
2315         if (object_is_smith(o_ptr) && (o_ptr->xtra3 == 1 + ESSENCE_SLAY_GLOVE))
2316                 show_weapon = TRUE;
2317
2318         /* Display the item like a weapon */
2319         if (o_ptr->to_h && o_ptr->to_d) show_weapon = TRUE;
2320
2321         /* Display the item like armour */
2322         if (o_ptr->ac) show_armour = TRUE;
2323
2324
2325         /* Dump base weapon info */
2326         switch (o_ptr->tval)
2327         {
2328                 /* Missiles and Weapons */
2329                 case TV_SHOT:
2330                 case TV_BOLT:
2331                 case TV_ARROW:
2332                 case TV_HAFTED:
2333                 case TV_POLEARM:
2334                 case TV_SWORD:
2335             case TV_DIGGING:
2336
2337                 /* In Vault Quest, hide the dice of target weapon. */
2338                 if(object_is_quest_target(o_ptr) && !known)
2339                 {
2340                         break;
2341                 }
2342
2343                 /* Append a "damage" string */
2344                 t = object_desc_chr(t, ' ');
2345                 t = object_desc_chr(t, p1);
2346                 t = object_desc_num(t, o_ptr->dd);
2347                 t = object_desc_chr(t, 'd');
2348                 t = object_desc_num(t, o_ptr->ds);
2349                 t = object_desc_chr(t, p2);
2350
2351                 /* All done */
2352                 break;
2353
2354
2355                 /* Bows get a special "damage string" */
2356                 case TV_BOW:
2357
2358                 /* Mega-Hack -- Extract the "base power" */
2359                 power = bow_tmul(o_ptr->sval);
2360
2361                 /* Apply the "Extra Might" flag */
2362                 if (have_flag(flgs, TR_XTRA_MIGHT)) power++;
2363
2364                 /* Append a special "damage" string */
2365                 t = object_desc_chr(t, ' ');
2366                 t = object_desc_chr(t, p1);
2367                 t = object_desc_chr(t, 'x');
2368                 t = object_desc_num(t, power);
2369                 t = object_desc_chr(t, p2);
2370
2371                 /* All done */
2372                 break;
2373         }
2374
2375
2376         /* Add the weapon bonuses */
2377         if (known)
2378         {
2379                 /* Show the tohit/todam on request */
2380                 if (show_weapon)
2381                 {
2382                         t = object_desc_chr(t, ' ');
2383                         t = object_desc_chr(t, p1);
2384                         t = object_desc_int(t, o_ptr->to_h);
2385                         t = object_desc_chr(t, ',');
2386                         t = object_desc_int(t, o_ptr->to_d);
2387                         t = object_desc_chr(t, p2);
2388                 }
2389
2390                 /* Show the tohit if needed */
2391                 else if (o_ptr->to_h)
2392                 {
2393                         t = object_desc_chr(t, ' ');
2394                         t = object_desc_chr(t, p1);
2395                         t = object_desc_int(t, o_ptr->to_h);
2396                         t = object_desc_chr(t, p2);
2397                 }
2398
2399                 /* Show the todam if needed */
2400                 else if (o_ptr->to_d)
2401                 {
2402                         t = object_desc_chr(t, ' ');
2403                         t = object_desc_chr(t, p1);
2404                         t = object_desc_int(t, o_ptr->to_d);
2405                         t = object_desc_chr(t, p2);
2406                 }
2407         }
2408
2409         bow_ptr = &inventory[INVEN_BOW];
2410
2411         /* If have a firing weapon + ammo matches bow */
2412         if (bow_ptr->k_idx && (o_ptr->tval == p_ptr->tval_ammo))
2413         {
2414                 int avgdam = o_ptr->dd * (o_ptr->ds + 1) * 10 / 2;
2415                 int tmul = bow_tmul(bow_ptr->sval);
2416                 s16b energy_fire = bow_energy(bow_ptr->sval);
2417
2418                 /* See if the bow is "known" - then set damage bonus */
2419                 if (object_is_known(bow_ptr)) avgdam += (bow_ptr->to_d * 10);
2420
2421                 /* Effect of ammo */
2422                 if (known) avgdam += (o_ptr->to_d * 10);
2423
2424                 /* Get extra "power" from "extra might" */
2425                 if (p_ptr->xtra_might) tmul++;
2426
2427                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
2428
2429                 /* Launcher multiplier */
2430                 avgdam *= tmul;
2431                 avgdam /= (100 * 10);
2432
2433                 /* Get extra damage from concentration */
2434                 if (p_ptr->concent) avgdam = boost_concentration_damage(avgdam);
2435
2436                 if (avgdam < 0) avgdam = 0;
2437
2438                 /* Display (shot damage/ shot damage with critical/ avg damage with critical) */
2439                 t = object_desc_chr(t, ' ');
2440                 t = object_desc_chr(t, p1);
2441
2442                 /* Damage with no-crit */
2443                 t = object_desc_num(t, avgdam);
2444                 t = object_desc_str(t, "/shot, ");
2445
2446                 /* Apply Expect damage of Critical */
2447                 avgdam = calc_expect_crit_shot(o_ptr->weight, o_ptr->to_h, avgdam);
2448                 t = object_desc_num(t, avgdam);
2449                 t = object_desc_str(t, "/crit, ");
2450
2451                 if (p_ptr->num_fire == 0)
2452                 {
2453                         t = object_desc_chr(t, '0');
2454                 }
2455                 else
2456                 {
2457                         /* Calc effects of energy */
2458                         avgdam *= (p_ptr->num_fire * 100);
2459                         avgdam /= energy_fire;
2460                         t = object_desc_num(t, avgdam);
2461                         t = object_desc_str(t, "/turn");
2462                 }
2463
2464                 t = object_desc_chr(t, p2);
2465         }
2466         else if ((p_ptr->pclass == CLASS_NINJA) && (o_ptr->tval == TV_SPIKE))
2467         {
2468                 int avgdam = p_ptr->mighty_throw ? (1 + 3) : 1;
2469                 s16b energy_fire = 100 - p_ptr->lev;
2470
2471                 avgdam += ((p_ptr->lev + 30) * (p_ptr->lev + 30) - 900) / 55;
2472
2473                 /* Display (shot damage/ avg damage) */
2474                 t = object_desc_chr(t, ' ');
2475                 t = object_desc_chr(t, p1);
2476                 t = object_desc_num(t, avgdam);
2477                 t = object_desc_chr(t, '/');
2478
2479                 /* Calc effects of energy */
2480                 avgdam = 100 * avgdam / energy_fire;
2481
2482                 t = object_desc_num(t, avgdam);
2483                 t = object_desc_chr(t, p2);
2484         }
2485
2486         /* Add the armor bonuses */
2487         if (known)
2488         {
2489                 /* Show the armor class info */
2490                 if (show_armour)
2491                 {
2492                         t = object_desc_chr(t, ' ');
2493                         t = object_desc_chr(t, b1);
2494                         t = object_desc_num(t, o_ptr->ac);
2495                         t = object_desc_chr(t, ',');
2496                         t = object_desc_int(t, o_ptr->to_a);
2497                         t = object_desc_chr(t, b2);
2498                 }
2499
2500                 /* No base armor, but does increase armor */
2501                 else if (o_ptr->to_a)
2502                 {
2503                         t = object_desc_chr(t, ' ');
2504                         t = object_desc_chr(t, b1);
2505                         t = object_desc_int(t, o_ptr->to_a);
2506                         t = object_desc_chr(t, b2);
2507                 }
2508         }
2509
2510         /* Hack -- always show base armor */
2511         else if (show_armour)
2512         {
2513                 t = object_desc_chr(t, ' ');
2514                 t = object_desc_chr(t, b1);
2515                 t = object_desc_num(t, o_ptr->ac);
2516                 t = object_desc_chr(t, b2);
2517         }
2518
2519
2520         /* No more details wanted */
2521         if (mode & OD_NAME_AND_ENCHANT) goto object_desc_done;
2522
2523
2524         if (known) /* Known item only */
2525         {
2526                 /*
2527                  * Hack -- Wands and Staffs have charges.  Make certain how many charges
2528                  * a stack of staffs really has is clear. -LM-
2529                  */
2530                 if (((o_ptr->tval == TV_STAFF) || (o_ptr->tval == TV_WAND)))
2531                 {
2532                         /* Dump " (N charges)" */
2533                         t = object_desc_chr(t, ' ');
2534                         t = object_desc_chr(t, p1);
2535
2536                         /* Clear explaination for staffs. */
2537                         if ((o_ptr->tval == TV_STAFF) && (o_ptr->number > 1))
2538                         {
2539                                 t = object_desc_num(t, o_ptr->number);
2540                                 t = object_desc_str(t, "x ");
2541                         }
2542                         t = object_desc_num(t, o_ptr->pval);
2543 #ifdef JP
2544                         t = object_desc_str(t, "²óÊ¬");
2545 #else
2546                         t = object_desc_str(t, " charge");
2547                         if (o_ptr->pval != 1) t = object_desc_chr(t, 's');
2548 #endif
2549
2550                         t = object_desc_chr(t, p2);
2551                 }
2552                 /* Hack -- Rods have a "charging" indicator.  Now that stacks of rods may
2553                  * be in any state of charge or discharge, this now includes a number. -LM-
2554                  */
2555                 else if (o_ptr->tval == TV_ROD)
2556                 {
2557                         /* Hack -- Dump " (# charging)" if relevant */
2558                         if (o_ptr->timeout)
2559                         {
2560                                 /* Stacks of rods display an exact count of charging rods. */
2561                                 if (o_ptr->number > 1)
2562                                 {
2563                                         /* Paranoia. */
2564                                         if (k_ptr->pval == 0) k_ptr->pval = 1;
2565
2566                                         /* Find out how many rods are charging, by dividing
2567                                          * current timeout by each rod's maximum timeout.
2568                                          * Ensure that any remainder is rounded up.  Display
2569                                          * very discharged stacks as merely fully discharged.
2570                                          */
2571                                         power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
2572                                         if (power > o_ptr->number) power = o_ptr->number;
2573
2574                                         /* Display prettily. */
2575                                         t = object_desc_str(t, " (");
2576                                         t = object_desc_num(t, power);
2577 #ifdef JP
2578                                         t = object_desc_str(t, "ËÜ ½¼Å¶Ãæ)");
2579 #else
2580                                         t = object_desc_str(t, " charging)");
2581 #endif
2582                                 }
2583
2584                                 /* "one Rod of Perception (1 charging)" would look tacky. */
2585                                 else
2586                                 {
2587 #ifdef JP
2588                                         t = object_desc_str(t, "(½¼Å¶Ãæ)");
2589 #else
2590                                         t = object_desc_str(t, " (charging)");
2591 #endif
2592                                 }
2593                         }
2594                 }
2595
2596                 /* Dump "pval" flags for wearable items */
2597                 if (have_pval_flags(flgs))
2598                 {
2599                         /* Start the display */
2600                         t = object_desc_chr(t, ' ');
2601                         t = object_desc_chr(t, p1);
2602
2603                         /* Dump the "pval" itself */
2604                         t = object_desc_int(t, o_ptr->pval);
2605
2606                         /* Do not display the "pval" flags */
2607                         if (have_flag(flgs, TR_HIDE_TYPE))
2608                         {
2609                                 /* Nothing */
2610                         }
2611
2612                         /* Speed */
2613                         else if (have_flag(flgs, TR_SPEED))
2614                         {
2615                                 /* Dump " to speed" */
2616 #ifdef JP
2617                                 t = object_desc_str(t, "²ÃÂ®");
2618 #else
2619                                 t = object_desc_str(t, " to speed");
2620 #endif
2621                         }
2622
2623                         /* Attack speed */
2624                         else if (have_flag(flgs, TR_BLOWS))
2625                         {
2626                                 /* Add " attack" */
2627 #ifdef JP
2628                                 t = object_desc_str(t, "¹¶·â");
2629 #else
2630                                 t = object_desc_str(t, " attack");
2631
2632                                 /* Add "attacks" */
2633                                 if (ABS(o_ptr->pval) != 1) t = object_desc_chr(t, 's');
2634 #endif
2635                         }
2636
2637                         /* Stealth */
2638                         else if (have_flag(flgs, TR_STEALTH))
2639                         {
2640                                 /* Dump " to stealth" */
2641 #ifdef JP
2642                                 t = object_desc_str(t, "±£Ì©");
2643 #else
2644                                 t = object_desc_str(t, " to stealth");
2645 #endif
2646                         }
2647
2648                         /* Search */
2649                         else if (have_flag(flgs, TR_SEARCH))
2650                         {
2651                                 /* Dump " to searching" */
2652 #ifdef JP
2653                                 t = object_desc_str(t, "Ãµº÷");
2654 #else
2655                                 t = object_desc_str(t, " to searching");
2656 #endif
2657                         }
2658
2659                         /* Infravision */
2660                         else if (have_flag(flgs, TR_INFRA))
2661                         {
2662                                 /* Dump " to infravision" */
2663 #ifdef JP
2664                                 t = object_desc_str(t, "ÀÖ³°Àþ»ëÎÏ");
2665 #else
2666                                 t = object_desc_str(t, " to infravision");
2667 #endif
2668                         }
2669
2670                         /* Finish the display */
2671                         t = object_desc_chr(t, p2);
2672                 }
2673
2674                 /* Hack -- Process Lanterns/Torches */
2675                 if ((o_ptr->tval == TV_LITE) && (!(object_is_fixed_artifact(o_ptr) || (o_ptr->sval == SV_LITE_FEANOR))))
2676                 {
2677                         /* Hack -- Turns of light for normal lites */
2678 #ifdef JP
2679                         t = object_desc_chr(t, '(');
2680 #else
2681                         t = object_desc_str(t, " (with ");
2682 #endif
2683
2684                         if (o_ptr->name2 == EGO_LITE_LONG) t = object_desc_num(t, o_ptr->xtra4 * 2);
2685                         else t = object_desc_num(t, o_ptr->xtra4);
2686 #ifdef JP
2687                         t = object_desc_str(t, "¥¿¡¼¥ó¤Î¼÷Ì¿)");
2688 #else
2689                         t = object_desc_str(t, " turns of light)");
2690 #endif
2691                 }
2692
2693                 /* Indicate charging objects, but not rods. */
2694                 if (o_ptr->timeout && (o_ptr->tval != TV_ROD))
2695                 {
2696                         /* Hack -- Dump " (charging)" if relevant */
2697 #ifdef JP
2698                         t = object_desc_str(t, "(½¼Å¶Ãæ)");
2699 #else
2700                         t = object_desc_str(t, " (charging)");
2701 #endif
2702                 }
2703         }
2704
2705
2706         /* No more details wanted */
2707         if (mode & OD_OMIT_INSCRIPTION) goto object_desc_done;
2708
2709
2710         /* Prepare real inscriptions in a buffer */
2711         tmp_val2[0] = '\0';
2712
2713         /* Auto abbreviation inscribe */
2714         if ((abbrev_extra || abbrev_all) && (o_ptr->ident & IDENT_MENTAL))
2715         {
2716                 if (!o_ptr->inscription || !my_strchr(quark_str(o_ptr->inscription), '%'))
2717                 {
2718                         bool kanji, all;
2719
2720 #ifdef JP
2721                         kanji = TRUE;
2722 #else
2723                         kanji = FALSE;
2724 #endif
2725                         all = abbrev_all;
2726
2727                         get_ability_abbreviation(tmp_val2, o_ptr, kanji, all);
2728                 }
2729         }
2730
2731         /* Use the standard inscription if available */
2732         if (o_ptr->inscription)
2733         {
2734                 char buff[1024];
2735
2736                 if (tmp_val2[0]) strcat(tmp_val2, ", ");
2737
2738                 /* Get inscription and convert {%} */
2739                 get_inscription(buff, o_ptr);
2740
2741                 /* strcat with correct treating of kanji */
2742                 my_strcat(tmp_val2, buff, sizeof(tmp_val2));
2743         }
2744
2745
2746         /* No fake inscription yet */
2747         fake_insc_buf[0] = '\0';
2748
2749         /* Use the game-generated "feeling" otherwise, if available */
2750         if (o_ptr->feeling)
2751         {
2752                 strcpy(fake_insc_buf, game_inscriptions[o_ptr->feeling]);
2753         }
2754
2755         /* Note "cursed" if the item is known to be cursed */
2756         else if (object_is_cursed(o_ptr) && (known || (o_ptr->ident & IDENT_SENSE)))
2757         {
2758 #ifdef JP
2759                 strcpy(fake_insc_buf, "¼ö¤ï¤ì¤Æ¤¤¤ë");
2760 #else
2761                 strcpy(fake_insc_buf, "cursed");
2762 #endif
2763         }
2764
2765         /* Note "unidentified" if the item is unidentified */
2766         else if (((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET)
2767                    || (o_ptr->tval == TV_LITE) || (o_ptr->tval == TV_FIGURINE))
2768                  && aware && !known
2769                  && !(o_ptr->ident & IDENT_SENSE))
2770         {
2771 #ifdef JP
2772                 strcpy(fake_insc_buf, "Ì¤´ÕÄê");
2773 #else
2774                 strcpy(fake_insc_buf, "unidentified");
2775 #endif
2776         }
2777
2778         /* Mega-Hack -- note empty wands/staffs */
2779         else if (!known && (o_ptr->ident & IDENT_EMPTY))
2780         {
2781 #ifdef JP
2782                 strcpy(fake_insc_buf, "¶õ");
2783 #else
2784                 strcpy(fake_insc_buf, "empty");
2785 #endif
2786         }
2787
2788         /* Note "tried" if the object has been tested unsuccessfully */
2789         else if (!aware && object_is_tried(o_ptr))
2790         {
2791 #ifdef JP
2792                 strcpy(fake_insc_buf, "Ì¤È½ÌÀ");
2793 #else
2794                 strcpy(fake_insc_buf, "tried");
2795 #endif
2796         }
2797
2798         /* Note the discount, if any */
2799         if (o_ptr->discount)
2800         {
2801                 /* Hidden by real inscription unless in a store */
2802                 if (!tmp_val2[0] || (o_ptr->ident & IDENT_STORE))
2803                 {
2804                         char discount_num_buf[4];
2805
2806                         /* Append to other fake inscriptions if any */
2807                         if (fake_insc_buf[0]) strcat(fake_insc_buf, ", ");
2808
2809                         (void)object_desc_num(discount_num_buf, o_ptr->discount);
2810                         strcat(fake_insc_buf, discount_num_buf);
2811 #ifdef JP
2812                         strcat(fake_insc_buf, "%°ú¤");
2813 #else
2814                         strcat(fake_insc_buf, "% off");
2815 #endif
2816                 }
2817         }
2818
2819
2820         /* Append the inscription, if any */
2821         if (fake_insc_buf[0] || tmp_val2[0])
2822         {
2823                 /* Append the inscription */
2824                 t = object_desc_chr(t, ' ');
2825                 t = object_desc_chr(t, c1);
2826
2827                 /* Append fake inscriptions */
2828                 if (fake_insc_buf[0])
2829                 {
2830                         t = object_desc_str(t, fake_insc_buf);
2831                 }
2832
2833                 /* Append a separater */
2834                 if (fake_insc_buf[0] && tmp_val2[0])
2835                 {
2836                         t = object_desc_chr(t, ',');
2837                         t = object_desc_chr(t, ' ');
2838                 }
2839
2840                 /* Append real inscriptions */
2841                 if (tmp_val2[0])
2842                 {
2843                         t = object_desc_str(t, tmp_val2);
2844                 }
2845
2846                 t = object_desc_chr(t, c2);
2847         }
2848
2849 object_desc_done:
2850         my_strcpy(buf, tmp_val, MAX_NLEN);
2851 }
2852
2853