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