src/flavor.c

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