src/flavor.c

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