src/flavor.c

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