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