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