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