src/object-flavor.c

   1 /*!
   2  *  @file object-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 #include "util.h"
  15
  16 #include "player-status.h"
  17 #include "shoot.h"
  18 #include "object-hook.h"
  19 #include "object-flavor.h"
  20 #include "trap.h"
  21 #include "snipe.h"
  22 #include "files.h"
  23
  24 /*!
  25  * @brief 最初から簡易な名称が明らかになるベースアイテムの判定。 /  Certain items, if aware, are known instantly
  26  * @param i ベースアイテムID
  27  * @return 簡易名称を明らかにするならTRUEを返す。
  28  * @details
  29  * This function is used only by "flavor_init()"
  30  */
  31 static bool object_easy_know(int i)
  32 {
  33         object_kind *k_ptr = &k_info[i];
  34
  35         /* Analyze the "tval" */
  36         switch (k_ptr->tval)
  37         {
  38                 /* Spellbooks */
  39                 case TV_LIFE_BOOK:
  40                 case TV_SORCERY_BOOK:
  41                 case TV_NATURE_BOOK:
  42                 case TV_CHAOS_BOOK:
  43                 case TV_DEATH_BOOK:
  44                 case TV_TRUMP_BOOK:
  45                 case TV_ARCANE_BOOK:
  46                 case TV_CRAFT_BOOK:
  47                 case TV_DAEMON_BOOK:
  48                 case TV_CRUSADE_BOOK:
  49                 case TV_MUSIC_BOOK:
  50                 case TV_HISSATSU_BOOK:
  51                 case TV_HEX_BOOK:
  52                 {
  53                         return (TRUE);
  54                 }
  55
  56                 /* Simple items */
  57                 case TV_FLASK:
  58                 case TV_JUNK:
  59                 case TV_BOTTLE:
  60                 case TV_SKELETON:
  61                 case TV_SPIKE:
  62                 case TV_WHISTLE:
  63                 {
  64                         return (TRUE);
  65                 }
  66
  67                 /* All Food, Potions, Scrolls, Rods */
  68                 case TV_FOOD:
  69                 case TV_POTION:
  70                 case TV_SCROLL:
  71                 case TV_ROD:
  72                 {
  73                         return (TRUE);
  74                 }
  75         }
  76
  77         return (FALSE);
  78 }
  79
  80 /*!
  81  * @brief 各種語彙からランダムな名前を作成する / Create a name from random parts.
  82  * @param out_string 作成した名を保管する参照ポインタ
  83  * @return なし
  84  * @details 日本語の場合 aname_j.txt 英語の場合確率に応じて
  85  * syllables 配列と elvish.txt を組み合わせる。\n
  86  */
  87 void get_table_name_aux(char *out_string)
  88 {
  89 #ifdef JP
  90         char Syllable[80];
  91         get_rnd_line("aname_j.txt", 1, Syllable);
  92         strcpy(out_string, Syllable);
  93         get_rnd_line("aname_j.txt", 2, Syllable);
  94         strcat(out_string, Syllable);
  95 #else
  96 #define MAX_SYLLABLES 164       /* Used with scrolls (see below) */
  97
  98         static concptr syllables[MAX_SYLLABLES] = {
  99                 "a", "ab", "ag", "aks", "ala", "an", "ankh", "app",
 100                 "arg", "arze", "ash", "aus", "ban", "bar", "bat", "bek",
 101                 "bie", "bin", "bit", "bjor", "blu", "bot", "bu",
 102                 "byt", "comp", "con", "cos", "cre", "dalf", "dan",
 103                 "den", "der", "doe", "dok", "eep", "el", "eng", "er", "ere", "erk",
 104                 "esh", "evs", "fa", "fid", "flit", "for", "fri", "fu", "gan",
 105                 "gar", "glen", "gop", "gre", "ha", "he", "hyd", "i",
 106                 "ing", "ion", "ip", "ish", "it", "ite", "iv", "jo",
 107                 "kho", "kli", "klis", "la", "lech", "man", "mar",
 108                 "me", "mi", "mic", "mik", "mon", "mung", "mur", "nag", "nej",
 109                 "nelg", "nep", "ner", "nes", "nis", "nih", "nin", "o",
 110                 "od", "ood", "org", "orn", "ox", "oxy", "pay", "pet",
 111                 "ple", "plu", "po", "pot", "prok", "re", "rea", "rhov",
 112                 "ri", "ro", "rog", "rok", "rol", "sa", "san", "sat",
 113                 "see", "sef", "seh", "shu", "ski", "sna", "sne", "snik",
 114                 "sno", "so", "sol", "sri", "sta", "sun", "ta", "tab",
 115                 "tem", "ther", "ti", "tox", "trol", "tue", "turs", "u",
 116                 "ulk", "um", "un", "uni", "ur", "val", "viv", "vly",
 117                 "vom", "wah", "wed", "werg", "wex", "whon", "wun", "x",
 118                 "yerg", "yp", "zun", "tri", "blaa", "jah", "bul", "on",
 119                 "foo", "ju", "xuxu"
 120         };
 121
 122         int testcounter = randint1(3) + 1;
 123
 124         strcpy(out_string, "");
 125
 126         if (randint1(3) == 2)
 127         {
 128                 while (testcounter--)
 129                         strcat(out_string, syllables[randint0(MAX_SYLLABLES)]);
 130         }
 131         else
 132         {
 133                 char Syllable[80];
 134                 testcounter = randint1(2) + 1;
 135                 while (testcounter--)
 136                 {
 137                         (void)get_rnd_line("elvish.txt", 0, Syllable);
 138                         strcat(out_string, Syllable);
 139                 }
 140         }
 141
 142         out_string[0] = toupper(out_string[1]);
 143
 144         out_string[16] = '\0';
 145 #endif
 146 }
 147
 148 /*!
 149  * @brief ランダムな名前をアーティファクト銘として整形する。 / Create a name from random parts with quotes.
 150  * @param out_string 作成した名を保管する参照ポインタ
 151  * @return なし
 152  * @details get_table_name_aux()ほぼ完全に実装を依存している。
 153  */
 154 void get_table_name(char *out_string)
 155 {
 156         char buff[80];
 157         get_table_name_aux(buff);
 158         sprintf(out_string, _("『%s』", "'%s'"), buff);
 159 }
 160
 161 /*!
 162  * @brief ランダムなシンダリン銘を作成する / Make random Sindarin name
 163  * @param out_string 作成した名を保管する参照ポインタ
 164  * @return なし
 165  * @details sname.txtが語幹の辞書となっている。
 166  */
 167 void get_table_sindarin_aux(char *out_string)
 168 {
 169         char Syllable[80];
 170 #ifdef JP
 171         char tmp[80];
 172 #endif
 173
 174         get_rnd_line("sname.txt", 1, Syllable);
 175 #ifdef JP
 176         strcpy(tmp, Syllable);
 177 #else
 178         strcpy(out_string, Syllable);
 179 #endif
 180
 181         get_rnd_line("sname.txt", 2, Syllable);
 182 #ifdef JP
 183         strcat(tmp, Syllable);
 184         sindarin_to_kana(out_string, tmp);
 185 #else
 186         strcat(out_string, Syllable);
 187 #endif
 188 }
 189
 190 /*!
 191  * @brief シンダリン銘をアーティファクト用に整形する。 / Make random Sindarin name with quotes
 192  * @param out_string 作成した名を保管する参照ポインタ
 193  * @return なし
 194  * @details get_table_sindarin_aux()ほぼ完全に実装を依存している。
 195  */
 196 void get_table_sindarin(char *out_string)
 197 {
 198         char buff[80];
 199         get_table_sindarin_aux(buff);
 200         sprintf(out_string, _("『%s』", "'%s'"), buff);
 201 }
 202
 203
 204 /*!
 205  * @brief ベースアイテムの未確定名を共通tval間でシャッフルする / Shuffle flavor indices of a group of objects with given tval
 206  * @param tval シャッフルしたいtval
 207  * @return なし
 208  * @details 巻物、各種魔道具などに利用される。
 209  */
 210 static void shuffle_flavors(OBJECT_TYPE_VALUE tval)
 211 {
 212         KIND_OBJECT_IDX *k_idx_list;
 213         KIND_OBJECT_IDX k_idx_list_num = 0;
 214         KIND_OBJECT_IDX i;
 215
 216         /* Allocate an array for a list of k_idx */
 217         C_MAKE(k_idx_list, max_k_idx, KIND_OBJECT_IDX);
 218
 219         /* Search objects with given tval for shuffle */
 220         for (i = 0; i < max_k_idx; i++)
 221         {
 222                 object_kind *k_ptr = &k_info[i];
 223
 224                 /* Skip non-Rings */
 225                 if (k_ptr->tval != tval) continue;
 226
 227                 /* Paranoia -- Skip objects without flavor */
 228                 if (!k_ptr->flavor) continue;
 229
 230                 /* Skip objects with a fixed flavor name */
 231                 if (have_flag(k_ptr->flags, TR_FIXED_FLAVOR)) continue;
 232
 233                 /* Remember k_idx */
 234                 k_idx_list[k_idx_list_num] = i;
 235
 236                 /* Increase number of remembered indices */
 237                 k_idx_list_num++;
 238         }
 239
 240         /* Shuffle flavors */
 241         for (i = 0; i < k_idx_list_num; i++)
 242         {
 243                 object_kind *k1_ptr = &k_info[k_idx_list[i]];
 244                 object_kind *k2_ptr = &k_info[k_idx_list[randint0(k_idx_list_num)]];
 245
 246                 /* Swap flavors of this pair */
 247                 s16b tmp = k1_ptr->flavor;
 248                 k1_ptr->flavor = k2_ptr->flavor;
 249                 k2_ptr->flavor = tmp;
 250         }
 251
 252         /* Free an array for a list of k_idx */
 253         C_KILL(k_idx_list, max_k_idx, s16b);
 254 }
 255
 256 /*!
 257  * @brief ゲーム開始時に行われるベースアイテムの初期化ルーチン / Prepare the "variable" part of the "k_info" array.
 258  * @return なし
 259  * @details
 260  * Prepare the "variable" part of the "k_info" array.\n
 261  *\n
 262  * The "color"/"metal"/"type" of an item is its "flavor".\n
 263  * For the most part, flavors are assigned randomly each game.\n
 264  *\n
 265  * Initialize descriptions for the "colored" objects, including:\n
 266  * Rings, Amulets, Staffs, Wands, Rods, Food, Potions, Scrolls.\n
 267  *\n
 268  * The first 4 entries for potions are fixed (Water, Apple Juice,\n
 269  * Slime Mold Juice, Unused Potion).\n
 270  *\n
 271  * Scroll titles are always between 6 and 14 letters long.  This is\n
 272  * ensured because every title is composed of whole words, where every\n
 273  * word is from 1 to 8 letters long (one or two syllables of 1 to 4\n
 274  * letters each), and that no scroll is finished until it attempts to\n
 275  * grow beyond 15 letters.  The first time this can happen is when the\n
 276  * current title has 6 letters and the new word has 8 letters, which\n
 277  * would result in a 6 letter scroll title.\n
 278  *\n
 279  * Duplicate titles are avoided by requiring that no two scrolls share\n
 280  * the same first four letters (not the most efficient method, and not\n
 281  * the least efficient method, but it will always work).\n
 282  *\n
 283  * Hack -- make sure everything stays the same for each saved game\n
 284  * This is accomplished by the use of a saved "random seed", as in\n
 285  * "town_gen()".  Since no other functions are called while the special\n
 286  * seed is in effect, so this function is pretty "safe".\n
 287  *\n
 288  * Note that the "hacked seed" may provide an RNG with alternating parity!\n
 289  */
 290 void flavor_init(void)
 291 {
 292         KIND_OBJECT_IDX i;
 293         u32b state_backup[4];
 294
 295         /* Hack -- Backup the RNG state */
 296         Rand_state_backup(state_backup);
 297
 298         /* Hack -- Induce consistant flavors */
 299         Rand_state_set(seed_flavor);
 300
 301
 302         /* Initialize flavor index of each object by itself */
 303         for (i = 0; i < max_k_idx; i++)
 304         {
 305                 object_kind *k_ptr = &k_info[i];
 306
 307                 /* Skip objects without flavor name */
 308                 if (!k_ptr->flavor_name) continue;
 309
 310                 /*
 311                  * Initialize flavor index to itself
 312                  *  -> Shuffle it later
 313                  */
 314                 k_ptr->flavor = i;
 315         }
 316
 317         /* Shuffle Rings */
 318         shuffle_flavors(TV_RING);
 319
 320         /* Shuffle Amulets */
 321         shuffle_flavors(TV_AMULET);
 322
 323         /* Shuffle Staves */
 324         shuffle_flavors(TV_STAFF);
 325
 326         /* Shuffle Wands */
 327         shuffle_flavors(TV_WAND);
 328
 329         /* Shuffle Rods */
 330         shuffle_flavors(TV_ROD);
 331
 332         /* Shuffle Mushrooms */
 333         shuffle_flavors(TV_FOOD);
 334
 335         /* Shuffle Potions */
 336         shuffle_flavors(TV_POTION);
 337
 338         /* Shuffle Scrolls */
 339         shuffle_flavors(TV_SCROLL);
 340
 341
 342         /* Hack -- Restore the RNG state */
 343         Rand_state_restore(state_backup);
 344
 345         /* Analyze every object */
 346         for (i = 1; i < max_k_idx; i++)
 347         {
 348                 object_kind *k_ptr = &k_info[i];
 349
 350                 /* Skip "empty" objects */
 351                 if (!k_ptr->name) continue;
 352
 353                 /* No flavor yields aware */
 354                 if (!k_ptr->flavor) k_ptr->aware = TRUE;
 355
 356                 /* Check for "easily known" */
 357                 k_ptr->easy_know = object_easy_know(i);
 358         }
 359 }
 360
 361
 362 /*!
 363  * @brief 対象文字配列に一文字だけをコピーする。
 364  * @param t 保管先文字列ポインタ
 365  * @param c 保管したい1文字
 366  * @return なし
 367  * @details
 368  * Print a char "c" into a string "t", as if by sprintf(t, "%c", c),\n
 369  * and return a pointer to the terminator (t + 1).\n
 370  */
 371 static char *object_desc_chr(char *t, char c)
 372 {
 373         /* Copy the char */
 374         *t++ = c;
 375
 376         /* Terminate */
 377         *t = '\0';
 378         return (t);
 379 }
 380
 381 /*!
 382  * @brief 対象文字配列に文字列をコピーする。
 383  * @param t 保管先文字列ポインタ
 384  * @param s コピーしたい文字列ポインタ
 385  * @return 保管先の末尾アドレス
 386  * @details
 387  * Print a string "s" into a string "t", as if by strcpy(t, s),
 388  * and return a pointer to the terminator.
 389  */
 390 static char *object_desc_str(char *t, concptr s)
 391 {
 392         /* Copy the string */
 393         while (*s) *t++ = *s++;
 394
 395         /* Terminate */
 396         *t = '\0';
 397         return (t);
 398 }
 399
 400 /*!
 401  * @brief 対象文字配列に符号なし整数値をコピーする。
 402  * @param t 保管先文字列ポインタ
 403  * @param n コピーしたい数値
 404  * @return なし
 405  * @details
 406  * Print an unsigned number "n" into a string "t", as if by
 407  * sprintf(t, "%u", n), and return a pointer to the terminator.
 408  */
 409 static char *object_desc_num(char *t, uint n)
 410 {
 411         uint p;
 412
 413         /* Find "size" of "n" */
 414         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
 415
 416         /* Dump each digit */
 417         while (p >= 1)
 418         {
 419                 /* Dump the digit */
 420                 *t++ = '0' + n / p;
 421
 422                 /* Remove the digit */
 423                 n = n % p;
 424
 425                 /* Process next digit */
 426                 p = p / 10;
 427         }
 428
 429         /* Terminate */
 430         *t = '\0';
 431         return (t);
 432 }
 433
 434
 435
 436
 437 #ifdef JP
 438 /*!
 439  * @brief 日本語の個数表示ルーチン
 440  * @param t 保管先文字列ポインタ
 441  * @param o_ptr 記述したいオブジェクトの構造体参照ポインタ
 442  * @return なし
 443  * @details
 444  * cmd1.c で流用するために object_desc_japanese から移動した。
 445  */
 446 char *object_desc_kosuu(char *t, object_type *o_ptr)
 447 {
 448     t = object_desc_num(t, o_ptr->number);
 449
 450     switch (o_ptr->tval)
 451     {
 452       case TV_BOLT:
 453       case TV_ARROW:
 454       case TV_POLEARM:
 455       case TV_STAFF:
 456       case TV_WAND:
 457       case TV_ROD:
 458       case TV_DIGGING:
 459       {
 460           t = object_desc_str(t, "本");
 461           break;
 462       }
 463       case TV_SCROLL:
 464       {
 465           t = object_desc_str(t, "巻");
 466           break;
 467       }
 468       case TV_POTION:
 469       {
 470           t = object_desc_str(t, "服");
 471           break;
 472       }
 473       case  TV_LIFE_BOOK:
 474       case  TV_SORCERY_BOOK:
 475       case  TV_NATURE_BOOK:
 476       case  TV_CHAOS_BOOK:
 477       case  TV_DEATH_BOOK:
 478       case  TV_TRUMP_BOOK:
 479       case  TV_ARCANE_BOOK:
 480       case  TV_CRAFT_BOOK:
 481       case  TV_DAEMON_BOOK:
 482       case  TV_CRUSADE_BOOK:
 483       case  TV_MUSIC_BOOK:
 484       case  TV_HISSATSU_BOOK:
 485           case TV_HEX_BOOK:
 486       {
 487           t = object_desc_str(t, "冊");
 488           break;
 489       }
 490       case TV_SOFT_ARMOR:
 491       case TV_HARD_ARMOR:
 492       case TV_DRAG_ARMOR:
 493       case TV_CLOAK:
 494       {
 495           t = object_desc_str(t, "着");
 496           break;
 497       }
 498       case TV_SWORD:
 499       case TV_HAFTED:
 500       case TV_BOW:
 501       {
 502           t = object_desc_str(t, "振");
 503           break;
 504       }
 505       case TV_BOOTS:
 506       {
 507           t = object_desc_str(t, "足");
 508           break;
 509       }
 510       case TV_CARD:
 511       {
 512           t = object_desc_str(t, "枚");
 513           break;
 514       }
 515             /* 食べもの by ita */
 516       case TV_FOOD:
 517       {
 518           if(o_ptr->sval == SV_FOOD_JERKY)
 519           {
 520               t = object_desc_str(t, "切れ");
 521               break;
 522           }
 523       }
 524       default:
 525       {
 526           if (o_ptr->number < 10)
 527           {
 528               t = object_desc_str(t, "つ");
 529           }
 530           else
 531           {
 532               t = object_desc_str(t, "個");
 533           }
 534           break;
 535       }
 536   }
 537   return (t);
 538 }
 539 #endif
 540
 541 /*!
 542  * @brief 対象文字配列に符号あり整数値をコピーする。
 543  * @param t 保管先文字列ポインタ
 544  * @param v コピーしたい数値
 545  * @return なし
 546  * @details
 547  * Print an signed number "v" into a string "t", as if by
 548  * sprintf(t, "%+d", n), and return a pointer to the terminator.
 549  * Note that we always print a sign, either "+" or "-".
 550  */
 551 static char *object_desc_int(char *t, sint v)
 552 {
 553         uint p, n;
 554
 555         /* Negative */
 556         if (v < 0)
 557         {
 558                 /* Take the absolute value */
 559                 n = 0 - v;
 560
 561                 /* Use a "minus" sign */
 562                 *t++ = '-';
 563         }
 564
 565         /* Positive (or zero) */
 566         else
 567         {
 568                 /* Use the actual number */
 569                 n = v;
 570
 571                 /* Use a "plus" sign */
 572                 *t++ = '+';
 573         }
 574
 575         /* Find "size" of "n" */
 576         for (p = 1; n >= p * 10; p = p * 10) /* loop */;
 577
 578         /* Dump each digit */
 579         while (p >= 1)
 580         {
 581                 /* Dump the digit */
 582                 *t++ = '0' + n / p;
 583
 584                 /* Remove the digit */
 585                 n = n % p;
 586
 587                 /* Process next digit */
 588                 p = p / 10;
 589         }
 590
 591         /* Terminate */
 592         *t = '\0';
 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         concptr japanese;
 604 #endif
 605         concptr 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, BIT_FLAGS 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, BIT_FLAGS 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         BIT_FLAGS flgs[TR_FLAG_SIZE];
1022         object_flags(o_ptr, flgs);
1023
1024         /* Remove obvious flags */
1025         if (!all)
1026         {
1027                 object_kind *k_ptr = &k_info[o_ptr->k_idx];
1028                 int j;
1029
1030                 /* Base object */
1031                 for (j = 0; j < TR_FLAG_SIZE; j++)
1032                         flgs[j] &= ~k_ptr->flags[j];
1033
1034                 if (object_is_fixed_artifact(o_ptr))
1035                 {
1036                         artifact_type *a_ptr = &a_info[o_ptr->name1];
1037
1038                         for (j = 0; j < TR_FLAG_SIZE; j++)
1039                                 flgs[j] &= ~a_ptr->flags[j];
1040                 }
1041
1042                 if (object_is_ego(o_ptr))
1043                 {
1044                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
1045
1046                         for (j = 0; j < TR_FLAG_SIZE; j++)
1047                                 flgs[j] &= ~e_ptr->flags[j];
1048                 }
1049         }
1050
1051         /* Remove lite flags when this is a dark lite object */
1052         if (have_dark_flag(flgs))
1053         {
1054                 if (have_flag(flgs, TR_LITE_1)) remove_flag(flgs, TR_LITE_1);
1055                 if (have_flag(flgs, TR_LITE_2)) remove_flag(flgs, TR_LITE_2);
1056                 if (have_flag(flgs, TR_LITE_3)) remove_flag(flgs, TR_LITE_3);
1057         }
1058         else if (have_lite_flag(flgs))
1059         {
1060                 add_flag(flgs, TR_LITE_1);
1061                 if (have_flag(flgs, TR_LITE_2)) remove_flag(flgs, TR_LITE_2);
1062                 if (have_flag(flgs, TR_LITE_3)) remove_flag(flgs, TR_LITE_3);
1063         }
1064
1065         /* Plusses */
1066         if (have_flag_of(flag_insc_plus, flgs))
1067         {
1068                 if (kanji)
1069                         ADD_INSC("+");
1070         }
1071         ptr = inscribe_flags_aux(flag_insc_plus, flgs, kanji, ptr);
1072
1073         /* Immunity */
1074         if (have_flag_of(flag_insc_immune, flgs))
1075         {
1076                 if (!kanji && ptr != prev_ptr)
1077                 {
1078                         ADD_INSC(";");
1079                         prev_ptr = ptr;
1080                 }
1081                 ADD_INSC("*");
1082         }
1083         ptr = inscribe_flags_aux(flag_insc_immune, flgs, kanji, ptr);
1084
1085         /* Resistance */
1086         if (have_flag_of(flag_insc_resistance, flgs))
1087         {
1088                 if (kanji)
1089                         ADD_INSC("r");
1090                 else if (ptr != prev_ptr)
1091                 {
1092                         ADD_INSC(";");
1093                         prev_ptr = ptr;
1094                 }
1095         }
1096         ptr = inscribe_flags_aux(flag_insc_resistance, flgs, kanji, ptr);
1097
1098         /* Misc Ability */
1099         if (have_flag_of(flag_insc_misc, flgs))
1100         {
1101                 if (ptr != prev_ptr)
1102                 {
1103                         ADD_INSC(";");
1104                         prev_ptr = ptr;
1105                 }
1106         }
1107         ptr = inscribe_flags_aux(flag_insc_misc, flgs, kanji, ptr);
1108
1109         /* Aura */
1110         if (have_flag_of(flag_insc_aura, flgs))
1111         {
1112                 ADD_INSC("[");
1113         }
1114         ptr = inscribe_flags_aux(flag_insc_aura, flgs, kanji, ptr);
1115
1116         /* Brand Weapon */
1117         if (have_flag_of(flag_insc_brand, flgs))
1118                 ADD_INSC("|");
1119         ptr = inscribe_flags_aux(flag_insc_brand, flgs, kanji, ptr);
1120
1121         /* Kill Weapon */
1122         if (have_flag_of(flag_insc_kill, flgs))
1123                 ADD_INSC("/X");
1124         ptr = inscribe_flags_aux(flag_insc_kill, flgs, kanji, ptr);
1125
1126         /* Slay Weapon */
1127         if (have_flag_of(flag_insc_slay, flgs))
1128                 ADD_INSC("/");
1129         ptr = inscribe_flags_aux(flag_insc_slay, flgs, kanji, ptr);
1130
1131         /* Esp */
1132         if (kanji)
1133         {
1134                 if (have_flag_of(flag_insc_esp1, flgs) ||
1135                     have_flag_of(flag_insc_esp2, flgs))
1136                         ADD_INSC("~");
1137                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1138                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1139         }
1140         else
1141         {
1142                 if (have_flag_of(flag_insc_esp1, flgs))
1143                         ADD_INSC("~");
1144                 ptr = inscribe_flags_aux(flag_insc_esp1, flgs, kanji, ptr);
1145                 if (have_flag_of(flag_insc_esp2, flgs))
1146                         ADD_INSC("~");
1147                 ptr = inscribe_flags_aux(flag_insc_esp2, flgs, kanji, ptr);
1148         }
1149
1150         /* sustain */
1151         if (have_flag_of(flag_insc_sust, flgs))
1152         {
1153                 ADD_INSC("(");
1154         }
1155         ptr = inscribe_flags_aux(flag_insc_sust, flgs, kanji, ptr);
1156
1157         *ptr = '\0';
1158
1159         return ptr;
1160 }
1161
1162
1163 /*!
1164  * @brief オブジェクト名の特性短縮表記＋刻み内容を提示する。 / Get object inscription with auto inscription of object flags.
1165  * @param buff 特性短縮表記を格納する文字列ポインタ
1166  * @param o_ptr 特性短縮表記を得たいオブジェクト構造体の参照ポインタ
1167  * @return なし
1168  */
1169 static void get_inscription(char *buff, object_type *o_ptr)
1170 {
1171         concptr insc = quark_str(o_ptr->inscription);
1172         char *ptr = buff;
1173
1174         /* Not fully identified */
1175         if (!(o_ptr->ident & IDENT_MENTAL))
1176         {
1177                 /* Copy until end of line or '#' */
1178                 while (*insc)
1179                 {
1180                         if (*insc == '#') break;
1181 #ifdef JP
1182                         if (iskanji(*insc)) *buff++ = *insc++;
1183 #endif
1184                         *buff++ = *insc++;
1185                 }
1186
1187                 *buff = '\0';
1188                 return;
1189         }
1190
1191         *buff = '\0';
1192         for (; *insc; insc++)
1193         {
1194                 /* Ignore fake artifact inscription */
1195                 if (*insc == '#') break;
1196
1197                 /* {%} will be automatically converted */
1198                 else if ('%' == *insc)
1199                 {
1200                         bool kanji = FALSE;
1201                         bool all;
1202                         concptr start = ptr;
1203
1204                         /* check for too long inscription */
1205                         if (ptr >= buff + MAX_NLEN) continue;
1206
1207 #ifdef JP
1208                         if ('%' == insc[1])
1209                         {
1210                                 insc++;
1211                                 kanji = FALSE;
1212                         }
1213                         else
1214                         {
1215                                 kanji = TRUE;
1216                         }
1217 #endif
1218                         if ('a' == insc[1] && 'l' == insc[2] && 'l' == insc[3])
1219                         {
1220                                 all = TRUE;
1221                                 insc += 3;
1222                         }
1223                         else
1224                         {
1225                                 all = FALSE;
1226                         }
1227
1228                         ptr = get_ability_abbreviation(ptr, o_ptr, kanji, all);
1229
1230                         if (ptr == start)
1231                                 ADD_INSC(" ");
1232                 }
1233                 else
1234                 {
1235                         *ptr++ = *insc;
1236                 }
1237         }
1238         *ptr = '\0';
1239 }
1240
1241
1242 /*!
1243  * @brief オブジェクトの各表記を返すメイン関数 / Creates a description of the item "o_ptr", and stores it in "out_val".
1244  * @param buf 表記を返すための文字列参照ポインタ
1245  * @param o_ptr 特性短縮表記を得たいオブジェクト構造体の参照ポインタ
1246  * @param mode 表記に関するオプション指定
1247  * @return 現在クエスト達成目的のアイテムならばTRUEを返す。
1248  * @details
1249  * One can choose the "verbosity" of the description, including whether\n
1250  * or not the "number" of items should be described, and how much detail\n
1251  * should be used when describing the item.\n
1252  *\n
1253  * The given "buf" must be MAX_NLEN chars long to hold the longest possible\n
1254  * description, which can get pretty long, including incriptions, such as:\n
1255  * "no more Maces of Disruption (Defender) (+10,+10) [+5] (+3 to stealth)".\n
1256  * Note that the inscription will be clipped to keep the total description\n
1257  * under MAX_NLEN-1 chars (plus a terminator).\n
1258  *\n
1259  * Note the use of "object_desc_num()" and "object_desc_int()" as hyper-efficient,\n
1260  * portable, versions of some common "sprintf()" commands.\n
1261  *\n
1262  * Note that all ego-items (when known) append an "Ego-Item Name", unless\n
1263  * the item is also an artifact, which should NEVER happen.\n
1264  *\n
1265  * Note that all artifacts (when known) append an "Artifact Name", so we\n
1266  * have special processing for "Specials" (artifact Lites, Rings, Amulets).\n
1267  * The "Specials" never use "modifiers" if they are "known", since they\n
1268  * have special "descriptions", such as "The Necklace of the Dwarves".\n
1269  *\n
1270  * Special Lite's use the "k_info" base-name (Phial, Star, or Arkenstone),\n
1271  * plus the artifact name, just like any other artifact, if known.\n
1272  *\n
1273  * Special Ring's and Amulet's, if not "aware", use the same code as normal\n
1274  * rings and amulets, and if "aware", use the "k_info" base-name (Ring or\n
1275  * Amulet or Necklace).  They will NEVER "append" the "k_info" name.  But,\n
1276  * they will append the artifact name, just like any artifact, if known.\n
1277  *\n
1278  * Hack -- Display "The One Ring" as "a Plain Gold Ring" until aware.\n
1279  *\n
1280  * Mode:\n
1281  *   OD_NAME_ONLY        : The Cloak of Death\n
1282  *   OD_NAME_AND_ENCHANT : The Cloak of Death [1,+3]\n
1283  *   OD_OMIT_INSCRIPTION : The Cloak of Death [1,+3] (+2 to Stealth)\n
1284  *   0                   : The Cloak of Death [1,+3] (+2 to Stealth) {nifty}\n
1285  *\n
1286  *   OD_OMIT_PREFIX      : Forbidden numeric prefix\n
1287  *   OD_NO_PLURAL        : Forbidden use of plural \n
1288  *   OD_STORE            : Assume to be aware and known\n
1289  *   OD_NO_FLAVOR        : Allow to hidden flavor\n
1290  *   OD_FORCE_FLAVOR     : Get un-shuffled flavor name\n
1291  */
1292 void object_desc(char *buf, object_type *o_ptr, BIT_FLAGS mode)
1293 {
1294         /* Extract object kind name */
1295         concptr            kindname = k_name + k_info[o_ptr->k_idx].name;
1296
1297         /* Extract default "base" string */
1298         concptr            basenm = kindname;
1299
1300         /* Assume no "modifier" string */
1301         concptr            modstr = "";
1302
1303         int power;
1304         int fire_rate;
1305
1306         bool            aware = FALSE;
1307         bool            known = FALSE;
1308         bool            flavor = TRUE;
1309
1310         bool            show_weapon = FALSE;
1311         bool            show_armour = FALSE;
1312
1313         concptr            s, s0;
1314         char            *t;
1315
1316         char            p1 = '(', p2 = ')';
1317         char            b1 = '[', b2 = ']';
1318         char            c1 = '{', c2 = '}';
1319
1320         char            tmp_val[MAX_NLEN+160];
1321         char            tmp_val2[MAX_NLEN+10];
1322         char            fake_insc_buf[30];
1323
1324         BIT_FLAGS flgs[TR_FLAG_SIZE];
1325
1326         object_type *bow_ptr;
1327
1328         object_kind *k_ptr = &k_info[o_ptr->k_idx];
1329         object_kind *flavor_k_ptr = &k_info[k_ptr->flavor];
1330
1331         /* Extract some flags */
1332         object_flags(o_ptr, flgs);
1333
1334         /* See if the object is "aware" */
1335         if (object_is_aware(o_ptr)) aware = TRUE;
1336
1337         /* See if the object is "known" */
1338         if (object_is_known(o_ptr)) known = TRUE;
1339
1340         /* Allow flavors to be hidden when aware */
1341         if (aware && ((mode & OD_NO_FLAVOR) || plain_descriptions)) flavor = FALSE;
1342
1343         /* Object is in the inventory of a store or spoiler */
1344         if ((mode & OD_STORE) || (o_ptr->ident & IDENT_STORE))
1345         {
1346                 /* Don't show flavors */
1347                 flavor = FALSE;
1348
1349                 /* Pretend known and aware */
1350                 aware = TRUE;
1351                 known = TRUE;
1352         }
1353
1354         /* Force to be flavor name only */
1355         if (mode & OD_FORCE_FLAVOR)
1356         {
1357                 aware = FALSE;
1358                 flavor = TRUE;
1359                 known = FALSE;
1360
1361                 /* Cancel shuffling */
1362                 flavor_k_ptr = k_ptr;
1363         }
1364
1365         /* Analyze the object */
1366         switch (o_ptr->tval)
1367         {
1368                 /* Some objects are easy to describe */
1369                 case TV_SKELETON:
1370                 case TV_BOTTLE:
1371                 case TV_JUNK:
1372                 case TV_SPIKE:
1373                 case TV_FLASK:
1374                 case TV_CHEST:
1375                 case TV_WHISTLE:
1376                 {
1377                         break;
1378                 }
1379
1380                 case TV_CAPTURE:
1381                 {
1382                         monster_race *r_ptr = &r_info[o_ptr->pval];
1383
1384                         if (known)
1385                         {
1386                                 if (!o_ptr->pval)
1387                                 {
1388                                         modstr = _(" (空)", " (empty)");
1389                                 }
1390                                 else
1391                                 {
1392 #ifdef JP
1393                                         sprintf(tmp_val2, " (%s)",r_name + r_ptr->name);
1394                                         modstr = tmp_val2;
1395 #else
1396                                         concptr t = r_name + r_ptr->name;
1397
1398                                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1399                                         {
1400                                                 sprintf(tmp_val2, " (%s%s)", (is_a_vowel(*t) ? "an " : "a "), t);
1401
1402                                                 modstr = tmp_val2;
1403                                         }
1404                                         else
1405                                         {
1406                                                 sprintf(tmp_val2, "(%s)", t);
1407
1408                                                 modstr = t;
1409                                         }
1410 #endif
1411                                 }
1412                         }
1413                         break;
1414                 }
1415
1416                 /* Figurines/Statues */
1417                 case TV_FIGURINE:
1418                 case TV_STATUE:
1419                 {
1420                         monster_race *r_ptr = &r_info[o_ptr->pval];
1421
1422 #ifdef JP
1423                         modstr = r_name + r_ptr->name;
1424 #else
1425                         concptr t = r_name + r_ptr->name;
1426
1427                         if (!(r_ptr->flags1 & RF1_UNIQUE))
1428                         {
1429                                 sprintf(tmp_val2, "%s%s", (is_a_vowel(*t) ? "an " : "a "), t);
1430
1431                                 modstr = tmp_val2;
1432                         }
1433                         else
1434                         {
1435                                 modstr = t;
1436                         }
1437 #endif
1438
1439
1440                         break;
1441                 }
1442
1443                 /* Corpses */
1444                 case TV_CORPSE:
1445                 {
1446                         monster_race *r_ptr = &r_info[o_ptr->pval];
1447
1448                         modstr = r_name + r_ptr->name;
1449
1450 #ifdef JP
1451                         basenm = "#%";
1452 #else
1453                         if (r_ptr->flags1 & RF1_UNIQUE)
1454                                 basenm = "& % of #";
1455                         else
1456                                 basenm = "& # %";
1457 #endif
1458
1459                         break;
1460                 }
1461
1462                 /* Missiles/ Bows/ Weapons */
1463                 case TV_SHOT:
1464                 case TV_BOLT:
1465                 case TV_ARROW:
1466                 case TV_BOW:
1467                 case TV_HAFTED:
1468                 case TV_POLEARM:
1469                 case TV_SWORD:
1470                 case TV_DIGGING:
1471                 {
1472                         show_weapon = TRUE;
1473                         break;
1474                 }
1475
1476                 /* Armour */
1477                 case TV_BOOTS:
1478                 case TV_GLOVES:
1479                 case TV_CLOAK:
1480                 case TV_CROWN:
1481                 case TV_HELM:
1482                 case TV_SHIELD:
1483                 case TV_SOFT_ARMOR:
1484                 case TV_HARD_ARMOR:
1485                 case TV_DRAG_ARMOR:
1486                 {
1487                         show_armour = TRUE;
1488                         break;
1489                 }
1490
1491                 /* Lites (including a few "Specials") */
1492                 case TV_LITE:
1493                 {
1494                         break;
1495                 }
1496
1497                 /* Amulets (including a few "Specials") */
1498                 case TV_AMULET:
1499                 {
1500                         /* Known artifacts */
1501                         if (aware)
1502                         {
1503                                 if (object_is_fixed_artifact(o_ptr)) break;
1504                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1505                         }
1506
1507                         /* Color the object */
1508                         modstr = k_name + flavor_k_ptr->flavor_name;
1509
1510 #ifdef JP
1511                         if (!flavor)    basenm = "%のアミュレット";
1512                         else if (aware) basenm = "%の#アミュレット";
1513                         else            basenm = "#アミュレット";
1514 #else
1515                         if (!flavor)    basenm = "& Amulet~ of %";
1516                         else if (aware) basenm = "& # Amulet~ of %";
1517                         else            basenm = "& # Amulet~";
1518 #endif
1519
1520                         break;
1521                 }
1522
1523                 /* Rings (including a few "Specials") */
1524                 case TV_RING:
1525                 {
1526                         /* Known artifacts */
1527                         if (aware)
1528                         {
1529                                 if (object_is_fixed_artifact(o_ptr)) break;
1530                                 if (k_ptr->gen_flags & TRG_INSTA_ART) break;
1531                         }
1532
1533                         /* Color the object */
1534                         modstr = k_name + flavor_k_ptr->flavor_name;
1535
1536 #ifdef JP
1537                         if (!flavor)    basenm = "%の指輪";
1538                         else if (aware) basenm = "%の#指輪";
1539                         else            basenm = "#指輪";
1540 #else
1541                         if (!flavor)    basenm = "& Ring~ of %";
1542                         else if (aware) basenm = "& # Ring~ of %";
1543                         else            basenm = "& # Ring~";
1544 #endif
1545
1546                         if (!k_ptr->to_h && !k_ptr->to_d && (o_ptr->to_h || o_ptr->to_d)) show_weapon = TRUE;
1547
1548                         break;
1549                 }
1550
1551                 case TV_CARD:
1552                 {
1553                         break;
1554                 }
1555
1556                 case TV_STAFF:
1557                 {
1558                         /* Color the object */
1559                         modstr = k_name + flavor_k_ptr->flavor_name;
1560
1561 #ifdef JP
1562                         if (!flavor)    basenm = "%の杖";
1563                         else if (aware) basenm = "%の#杖";
1564                         else            basenm = "#杖";
1565 #else
1566                         if (!flavor)    basenm = "& Staff~ of %";
1567                         else if (aware) basenm = "& # Staff~ of %";
1568                         else            basenm = "& # Staff~";
1569 #endif
1570
1571                         break;
1572                 }
1573
1574                 case TV_WAND:
1575                 {
1576                         /* Color the object */
1577                         modstr = k_name + flavor_k_ptr->flavor_name;
1578
1579 #ifdef JP
1580                         if (!flavor)    basenm = "%の魔法棒";
1581                         else if (aware) basenm = "%の#魔法棒";
1582                         else            basenm = "#魔法棒";
1583 #else
1584                         if (!flavor)    basenm = "& Wand~ of %";
1585                         else if (aware) basenm = "& # Wand~ of %";
1586                         else            basenm = "& # Wand~";
1587 #endif
1588
1589                         break;
1590                 }
1591
1592                 case TV_ROD:
1593                 {
1594                         /* Color the object */
1595                         modstr = k_name + flavor_k_ptr->flavor_name;
1596
1597 #ifdef JP
1598                         if (!flavor)    basenm = "%のロッド";
1599                         else if (aware) basenm = "%の#ロッド";
1600                         else            basenm = "#ロッド";
1601 #else
1602                         if (!flavor)    basenm = "& Rod~ of %";
1603                         else if (aware) basenm = "& # Rod~ of %";
1604                         else            basenm = "& # Rod~";
1605 #endif
1606
1607                         break;
1608                 }
1609
1610                 case TV_SCROLL:
1611                 {
1612                         /* Color the object */
1613                         modstr = k_name + flavor_k_ptr->flavor_name;
1614
1615 #ifdef JP
1616                         if (!flavor)    basenm = "%の巻物";
1617                         else if (aware) basenm = "「#」と書かれた%の巻物";
1618                         else            basenm = "「#」と書かれた巻物";
1619 #else
1620                         if (!flavor)    basenm = "& Scroll~ of %";
1621                         else if (aware) basenm = "& Scroll~ titled \"#\" of %";
1622                         else            basenm = "& Scroll~ titled \"#\"";
1623 #endif
1624
1625                         break;
1626                 }
1627
1628                 case TV_POTION:
1629                 {
1630                         /* Color the object */
1631                         modstr = k_name + flavor_k_ptr->flavor_name;
1632
1633 #ifdef JP
1634                         if (!flavor)    basenm = "%の薬";
1635                         else if (aware) basenm = "%の#薬";
1636                         else            basenm = "#薬";
1637 #else
1638                         if (!flavor)    basenm = "& Potion~ of %";
1639                         else if (aware) basenm = "& # Potion~ of %";
1640                         else            basenm = "& # Potion~";
1641 #endif
1642
1643                         break;
1644                 }
1645
1646                 case TV_FOOD:
1647                 {
1648                         /* Ordinary food is "boring" */
1649                         if (!k_ptr->flavor_name) break;
1650
1651                         /* Color the object */
1652                         modstr = k_name + flavor_k_ptr->flavor_name;
1653
1654 #ifdef JP
1655                         if (!flavor)    basenm = "%のキノコ";
1656                         else if (aware) basenm = "%の#キノコ";
1657                         else            basenm = "#キノコ";
1658 #else
1659                         if (!flavor)    basenm = "& Mushroom~ of %";
1660                         else if (aware) basenm = "& # Mushroom~ of %";
1661                         else            basenm = "& # Mushroom~";
1662 #endif
1663
1664                         break;
1665                 }
1666
1667                 case TV_PARCHMENT:
1668                 {
1669                         basenm = _("羊皮紙 - %", "& Parchment~ - %");
1670                         break;
1671                 }
1672
1673                 /* Magic Books */
1674                 case TV_LIFE_BOOK:
1675                 {
1676 #ifdef JP
1677                         basenm = "生命の魔法書%";
1678 #else
1679                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1680                                 basenm = "& Book~ of Life Magic %";
1681                         else
1682                                 basenm = "& Life Spellbook~ %";
1683 #endif
1684
1685                         break;
1686                 }
1687
1688                 case TV_SORCERY_BOOK:
1689                 {
1690 #ifdef JP
1691                         basenm = "仙術の魔法書%";
1692 #else
1693                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1694                                 basenm = "& Book~ of Sorcery %";
1695                         else
1696                                 basenm = "& Sorcery Spellbook~ %";
1697 #endif
1698
1699                         break;
1700                 }
1701
1702                 case TV_NATURE_BOOK:
1703                 {
1704 #ifdef JP
1705                         basenm = "自然の魔法書%";
1706 #else
1707                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1708                                 basenm = "& Book~ of Nature Magic %";
1709                         else
1710                                 basenm = "& Nature Spellbook~ %";
1711 #endif
1712
1713                         break;
1714                 }
1715
1716                 case TV_CHAOS_BOOK:
1717                 {
1718 #ifdef JP
1719                         basenm = "カオスの魔法書%";
1720 #else
1721                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1722                                 basenm = "& Book~ of Chaos Magic %";
1723                         else
1724                                 basenm = "& Chaos Spellbook~ %";
1725 #endif
1726
1727                         break;
1728                 }
1729
1730                 case TV_DEATH_BOOK:
1731                 {
1732 #ifdef JP
1733                         basenm = "暗黒の魔法書%";
1734 #else
1735                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1736                                 basenm = "& Book~ of Death Magic %";
1737                         else
1738                                 basenm = "& Death Spellbook~ %";
1739 #endif
1740
1741                         break;
1742                 }
1743
1744                 case TV_TRUMP_BOOK:
1745                 {
1746 #ifdef JP
1747                         basenm = "トランプの魔法書%";
1748 #else
1749                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1750                                 basenm = "& Book~ of Trump Magic %";
1751                         else
1752                                 basenm = "& Trump Spellbook~ %";
1753 #endif
1754
1755                         break;
1756                 }
1757
1758                 case TV_ARCANE_BOOK:
1759                 {
1760 #ifdef JP
1761                         basenm = "秘術の魔法書%";
1762 #else
1763                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1764                                 basenm = "& Book~ of Arcane Magic %";
1765                         else
1766                                 basenm = "& Arcane Spellbook~ %";
1767 #endif
1768
1769                         break;
1770                 }
1771
1772                 case TV_CRAFT_BOOK:
1773                 {
1774 #ifdef JP
1775                         basenm = "匠の魔法書%";
1776 #else
1777                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1778                                 basenm = "& Book~ of Craft Magic %";
1779                         else
1780                                 basenm = "& Craft Spellbook~ %";
1781 #endif
1782
1783                         break;
1784                 }
1785
1786                 case TV_DAEMON_BOOK:
1787                 {
1788 #ifdef JP
1789                         basenm = "悪魔の魔法書%";
1790 #else
1791                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1792                                 basenm = "& Book~ of Daemon Magic %";
1793                         else
1794                                 basenm = "& Daemon Spellbook~ %";
1795 #endif
1796
1797                         break;
1798                 }
1799
1800                 case TV_CRUSADE_BOOK:
1801                 {
1802 #ifdef JP
1803                         basenm = "破邪の魔法書%";
1804 #else
1805                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1806                                 basenm = "& Book~ of Crusade Magic %";
1807                         else
1808                                 basenm = "& Crusade Spellbook~ %";
1809 #endif
1810
1811                         break;
1812                 }
1813
1814                 case TV_MUSIC_BOOK:
1815                 {
1816                         basenm = _("歌集%", "& Song Book~ %");
1817                         break;
1818                 }
1819
1820                 case TV_HISSATSU_BOOK:
1821                 {
1822                         basenm = _("& 武芸の書%", "Book~ of Kendo %");
1823                         break;
1824                 }
1825
1826                 case TV_HEX_BOOK:
1827                 {
1828 #ifdef JP
1829                         basenm = "呪術の魔法書%";
1830 #else
1831                         if (mp_ptr->spell_book == TV_LIFE_BOOK)
1832                                 basenm = "& Book~ of Hex Magic %";
1833                         else
1834                                 basenm = "& Hex Spellbook~ %";
1835 #endif
1836
1837                         break;
1838                 }
1839
1840                 /* Hack -- Gold/Gems */
1841                 case TV_GOLD:
1842                 {
1843                         strcpy(buf, basenm);
1844                         return;
1845                 }
1846
1847                 /* Used in the "inventory" routine */
1848                 default:
1849                 {
1850                         strcpy(buf, _("(なし)", "(nothing)"));
1851                         return;
1852                 }
1853         }
1854
1855         /* Use full name from k_info or a_info */
1856         if (aware && have_flag(flgs, TR_FULL_NAME))
1857         {
1858                 if (known && o_ptr->name1) basenm = a_name + a_info[o_ptr->name1].name;
1859                 else basenm = kindname;
1860         }
1861
1862         /* Start dumping the result */
1863         t = tmp_val;
1864
1865 #ifdef JP
1866         if (basenm[0] == '&')
1867                 s = basenm + 2;
1868         else
1869                 s = basenm;
1870
1871         /* No prefix */
1872         if (mode & OD_OMIT_PREFIX)
1873         {
1874                 /* Nothing */
1875         }
1876         else if (o_ptr->number > 1)
1877         {
1878                 t = object_desc_kosuu(t, o_ptr);
1879                 t = object_desc_str(t, "の ");
1880         }
1881
1882         /* 英語の場合アーティファクトは The が付くので分かるが
1883          * 日本語では分からないのでマークをつける
1884          */
1885         if (known)
1886         {
1887                 if (object_is_fixed_artifact(o_ptr)) t = object_desc_str(t, "★");
1888                 else if (o_ptr->art_name) t = object_desc_str(t, "☆");
1889         }
1890
1891 #else
1892
1893         /* The object "expects" a "number" */
1894         if (basenm[0] == '&')
1895         {
1896                 /* Skip the ampersand (and space) */
1897                 s = basenm + 2;
1898
1899                 /* No prefix */
1900                 if (mode & OD_OMIT_PREFIX)
1901                 {
1902                         /* Nothing */
1903                 }
1904
1905                 /* Hack -- None left */
1906                 else if (o_ptr->number <= 0)
1907                 {
1908                         t = object_desc_str(t, "no more ");
1909                 }
1910
1911                 /* Extract the number */
1912                 else if (o_ptr->number > 1)
1913                 {
1914                         t = object_desc_num(t, o_ptr->number);
1915                         t = object_desc_chr(t, ' ');
1916                 }
1917
1918                 /* Hack -- The only one of its kind */
1919                 else if ((known && object_is_artifact(o_ptr)) ||
1920                          ((o_ptr->tval == TV_CORPSE) &&
1921                           (r_info[o_ptr->pval].flags1 & RF1_UNIQUE)))
1922                 {
1923                         t = object_desc_str(t, "The ");
1924                 }
1925
1926                 /* A single one */
1927                 else
1928                 {
1929                         bool vowel;
1930
1931                         switch (*s)
1932                         {
1933                         case '#': vowel = is_a_vowel(modstr[0]); break;
1934                         case '%': vowel = is_a_vowel(*kindname); break;
1935                         default:  vowel = is_a_vowel(*s); break;
1936                         }
1937
1938                         if (vowel)
1939                         {
1940                                 /* A single one, with a vowel */
1941                                 t = object_desc_str(t, "an ");
1942                         }
1943                         else
1944                         {
1945                                 /* A single one, without a vowel */
1946                                 t = object_desc_str(t, "a ");
1947                         }
1948                 }
1949         }
1950
1951         /* Hack -- objects that "never" take an article */
1952         else
1953         {
1954                 /* No ampersand */
1955                 s = basenm;
1956
1957                 /* No pref */
1958                 if (mode & OD_OMIT_PREFIX)
1959                 {
1960                         /* Nothing */
1961                 }
1962
1963                 /* Hack -- all gone */
1964                 else if (o_ptr->number <= 0)
1965                 {
1966                         t = object_desc_str(t, "no more ");
1967                 }
1968
1969                 /* Prefix a number if required */
1970                 else if (o_ptr->number > 1)
1971                 {
1972                         t = object_desc_num(t, o_ptr->number);
1973                         t = object_desc_chr(t, ' ');
1974                 }
1975
1976                 /* Hack -- The only one of its kind */
1977                 else if (known && object_is_artifact(o_ptr))
1978                 {
1979                         t = object_desc_str(t, "The ");
1980                 }
1981
1982                 /* Hack -- single items get no prefix */
1983                 else
1984                 {
1985                         /* Nothing */
1986                 }
1987         }
1988 #endif
1989
1990         /* Paranoia -- skip illegal tildes */
1991         /* while (*s == '~') s++; */
1992
1993 #ifdef JP
1994         if (object_is_smith(o_ptr))
1995         {
1996                 t = object_desc_str(t, format("鍛冶師%sの", p_ptr->name));
1997         }
1998
1999         /* 伝説のアイテム、名のあるアイテムの名前を付加する */
2000         if (known)
2001         {
2002                 /* ランダム・アーティファクト */
2003                 if (o_ptr->art_name)
2004                 {
2005                         concptr temp = quark_str(o_ptr->art_name);
2006
2007                         /* '『' から始まらない伝説のアイテムの名前は最初に付加する */
2008                         /* 英語版のセーブファイルから来た 'of XXX' は,「XXXの」と表示する */
2009                         if (strncmp(temp, "of ", 3) == 0)
2010                         {
2011                                 t = object_desc_str(t, &temp[3]);
2012                                 t = object_desc_str(t, "の");
2013                         }
2014                         else if ((strncmp(temp, "『", 2) != 0) &&
2015                                  (strncmp(temp, "《", 2) != 0) &&
2016                                  (temp[0] != '\''))
2017                                 t = object_desc_str(t, temp);
2018                 }
2019                 /* 伝説のアイテム */
2020                 else if (o_ptr->name1 && !have_flag(flgs, TR_FULL_NAME))
2021                 {
2022                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2023                         /* '『' から始まらない伝説のアイテムの名前は最初に付加する */
2024                         if (strncmp(a_name + a_ptr->name, "『", 2) != 0)
2025                         {
2026                                 t = object_desc_str(t, a_name + a_ptr->name);
2027                         }
2028                 }
2029                 /* 名のあるアイテム */
2030                 else if (object_is_ego(o_ptr))
2031                 {
2032                         ego_item_type *e_ptr = &e_info[o_ptr->name2];
2033                         t = object_desc_str(t, e_name + e_ptr->name);
2034                 }
2035         }
2036 #endif
2037
2038         /* Copy the string */
2039         for (s0 = NULL; *s || s0; )
2040         {
2041                 /* The end of the flavour/kind string. */
2042                 if (!*s)
2043                 {
2044                         s = s0 + 1;
2045                         s0 = NULL;
2046                 }
2047
2048                 /* Begin to append the modifier (flavor) */
2049                 else if ((*s == '#') && !s0)
2050                 {
2051                         s0 = s;
2052                         s = modstr;
2053
2054                         /* Paranoia -- Never append multiple modstrs */
2055                         modstr = "";
2056                 }
2057
2058                 /* Begin to append the kind name */
2059                 else if ((*s == '%') && !s0)
2060                 {
2061                         s0 = s;
2062                         s = kindname;
2063
2064                         /* Paranoia -- Never append multiple kindnames */
2065                         kindname = "";
2066                 }
2067
2068 #ifndef JP
2069                 /* Pluralizer */
2070                 else if (*s == '~')
2071                 {
2072                         /* Add a plural if needed */
2073                         if (!(mode & OD_NO_PLURAL) && (o_ptr->number != 1))
2074                         {
2075                                 char k = t[-1];
2076
2077                                 /* Mega-Hack */
2078
2079                                 /* Hack -- "Cutlass-es" and "Torch-es" */
2080                                 if ((k == 's') || (k == 'h')) *t++ = 'e';
2081
2082                                 /* Add an 's' */
2083                                 *t++ = 's';
2084                         }
2085                         s++;
2086                 }
2087 #endif
2088
2089                 /* Normal */
2090                 else
2091                 {
2092                         /* Copy */
2093                         *t++ = *s++;
2094                 }
2095         }
2096
2097         /* Terminate */
2098         *t = '\0';
2099
2100
2101 #ifdef JP
2102         /* '『'から始まる伝説のアイテムの名前は最後に付加する */
2103         if (known)
2104         {
2105                 /* ランダムアーティファクトの名前はセーブファイルに記録
2106                    されるので、英語版の名前もそれらしく変換する */
2107                 if (o_ptr->art_name)
2108                 {
2109                         char temp[256];
2110                         int itemp;
2111                         strcpy(temp, quark_str(o_ptr->art_name));
2112                         /* MEGA HACK by ita */
2113                         if (strncmp(temp, "『", 2) == 0 ||
2114                             strncmp(temp, "《", 2) == 0)
2115                                 t = object_desc_str(t, temp);
2116                         else if (temp[0] == '\'')
2117                         {
2118                                 itemp = strlen(temp);
2119                                 temp[itemp - 1] = 0;
2120                                 t = object_desc_str(t, "『");
2121                                 t = object_desc_str(t, &temp[1]);
2122                                 t = object_desc_str(t, "』");
2123                         }
2124                 }
2125                 else if (object_is_fixed_artifact(o_ptr))
2126                 {
2127                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2128                         if (strncmp(a_name + a_ptr->name, "『", 2) == 0)
2129                         {
2130                                 t = object_desc_str(t, a_name + a_ptr->name);
2131                         }
2132                 }
2133                 else if (o_ptr->inscription)
2134                 {
2135                         concptr str = quark_str(o_ptr->inscription);
2136
2137                         while(*str)
2138                         {
2139                                 if (iskanji(*str))
2140                                 {
2141                                         str += 2;
2142                                         continue;
2143                                 }
2144                                 if (*str == '#') break;
2145                                 str++;
2146                         }
2147                         if (*str)
2148                         {
2149                                 /* Find the '#' */
2150                                 concptr str_aux = my_strchr(quark_str(o_ptr->inscription), '#');
2151
2152                                 /* Add the false name */
2153                                 t = object_desc_str(t,"『");
2154                                 t = object_desc_str(t, &str_aux[1]);
2155                                 t = object_desc_str(t,"』");
2156                         }
2157                 }
2158         }
2159 #else
2160         if (object_is_smith(o_ptr))
2161         {
2162                 t = object_desc_str(t,format(" of %s the Smith",p_ptr->name));
2163         }
2164
2165         /* Hack -- Append "Artifact" or "Special" names */
2166         if (known && !have_flag(flgs, TR_FULL_NAME))
2167         {
2168                 /* Is it a new random artifact ? */
2169                 if (o_ptr->art_name)
2170                 {
2171                         t = object_desc_chr(t, ' ');
2172                         t = object_desc_str(t, quark_str(o_ptr->art_name));
2173                 }
2174
2175                 /* Grab any artifact name */
2176                 else if (object_is_fixed_artifact(o_ptr))
2177                 {
2178                         artifact_type *a_ptr = &a_info[o_ptr->name1];
2179
2180                         t = object_desc_chr(t, ' ');
2181                         t = object_desc_str(t, a_name + a_ptr->name);
2182                 }
2183
2184                 /* Grab any ego-item name */
2185                 else
2186                 {
2187                         if (object_is_ego(o_ptr))
2188                         {
2189                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
2190
2191                                 t = object_desc_chr(t, ' ');
2192                                 t = object_desc_str(t, e_name + e_ptr->name);
2193                         }
2194
2195                         if (o_ptr->inscription && my_strchr(quark_str(o_ptr->inscription), '#'))
2196                         {
2197                                 /* Find the '#' */
2198                                 concptr str = my_strchr(quark_str(o_ptr->inscription), '#');
2199
2200                                 /* Add the false name */
2201                                 t = object_desc_chr(t, ' ');
2202                                 t = object_desc_str(t, &str[1]);
2203                         }
2204                 }
2205         }
2206 #endif
2207
2208
2209         /* No more details wanted */
2210         if (mode & OD_NAME_ONLY) goto object_desc_done;
2211
2212         /* Hack -- Chests must be described in detail */
2213         if (o_ptr->tval == TV_CHEST)
2214         {
2215                 /* Not searched yet */
2216                 if (!known)
2217                 {
2218                         /* Nothing */
2219                 }
2220
2221                 /* May be "empty" */
2222                 else if (!o_ptr->pval)
2223                 {
2224                         t = object_desc_str(t, _("(空)", " (empty)"));
2225                 }
2226
2227                 /* May be "disarmed" */
2228                 else if (o_ptr->pval < 0)
2229                 {
2230                         if (chest_traps[0 - o_ptr->pval])
2231                         {
2232                                 t = object_desc_str(t, _("(解除済)", " (disarmed)"));
2233                         }
2234                         else
2235                         {
2236                                 t = object_desc_str(t, _("(非施錠)", " (unlocked)"));
2237                         }
2238                 }
2239
2240                 /* Describe the traps, if any */
2241                 else
2242                 {
2243                         /* Describe the traps */
2244                         switch (chest_traps[o_ptr->pval])
2245                         {
2246                                 case 0:
2247                                 {
2248                                         t = object_desc_str(t, _("(施錠)", " (Locked)"));
2249                                         break;
2250                                 }
2251                                 case CHEST_LOSE_STR:
2252                                 {
2253                                         t = object_desc_str(t, _("(毒針)", " (Poison Needle)"));
2254                                         break;
2255                                 }
2256                                 case CHEST_LOSE_CON:
2257                                 {
2258                                         t = object_desc_str(t, _("(毒針)", " (Poison Needle)"));
2259                                         break;
2260                                 }
2261                                 case CHEST_POISON:
2262                                 {
2263                                         t = object_desc_str(t, _("(ガス・トラップ)", " (Gas Trap)"));
2264                                         break;
2265                                 }
2266                                 case CHEST_PARALYZE:
2267                                 {
2268                                         t = object_desc_str(t, _("(ガス・トラップ)", " (Gas Trap)"));
2269                                         break;
2270                                 }
2271                                 case CHEST_EXPLODE:
2272                                 {
2273                                         t = object_desc_str(t, _("(爆発装置)", " (Explosion Device)"));
2274                                         break;
2275                                 }
2276                                 case CHEST_SUMMON:
2277                                 case CHEST_BIRD_STORM:
2278                                 case CHEST_E_SUMMON:
2279                                 case CHEST_H_SUMMON:
2280                                 {
2281                                         t = object_desc_str(t, _("(召喚のルーン)", " (Summoning Runes)"));
2282                                         break;
2283                                 }
2284                                 case CHEST_RUNES_OF_EVIL:
2285                                 {
2286                                         t = object_desc_str(t, _("(邪悪なルーン)", " (Gleaming Black Runes)"));
2287                                         break;
2288                                 }
2289                                 case CHEST_ALARM:
2290                                 {
2291                                         t = object_desc_str(t, _("(警報装置)", " (Alarm)"));
2292                                         break;
2293                                 }
2294                                 default:
2295                                 {
2296                                         t = object_desc_str(t, _("(マルチ・トラップ)", " (Multiple Traps)"));
2297                                         break;
2298                                 }
2299                         }
2300                 }
2301         }
2302
2303
2304         /* Display the item like a weapon */
2305         if (have_flag(flgs, TR_SHOW_MODS)) show_weapon = TRUE;
2306
2307         /* Display the item like a weapon */
2308         if (object_is_smith(o_ptr) && (o_ptr->xtra3 == 1 + ESSENCE_SLAY_GLOVE))
2309                 show_weapon = TRUE;
2310
2311         /* Display the item like a weapon */
2312         if (o_ptr->to_h && o_ptr->to_d) show_weapon = TRUE;
2313
2314         /* Display the item like armour */
2315         if (o_ptr->ac) show_armour = TRUE;
2316
2317
2318         /* Dump base weapon info */
2319         switch (o_ptr->tval)
2320         {
2321                 /* Missiles and Weapons */
2322                 case TV_SHOT:
2323                 case TV_BOLT:
2324                 case TV_ARROW:
2325                 case TV_HAFTED:
2326                 case TV_POLEARM:
2327                 case TV_SWORD:
2328             case TV_DIGGING:
2329
2330                 /* In Vault Quest, hide the dice of target weapon. */
2331                 if(object_is_quest_target(o_ptr) && !known)
2332                 {
2333                         break;
2334                 }
2335
2336                 /* Append a "damage" string */
2337                 t = object_desc_chr(t, ' ');
2338                 t = object_desc_chr(t, p1);
2339                 t = object_desc_num(t, o_ptr->dd);
2340                 t = object_desc_chr(t, 'd');
2341                 t = object_desc_num(t, o_ptr->ds);
2342                 t = object_desc_chr(t, p2);
2343
2344                 /* All done */
2345                 break;
2346
2347
2348                 /* Bows get a special "damage string" */
2349                 case TV_BOW:
2350
2351                 /* Mega-Hack -- Extract the "base power" */
2352                 power = bow_tmul(o_ptr->sval);
2353
2354                 /* Apply the "Extra Might" flag */
2355                 if (have_flag(flgs, TR_XTRA_MIGHT)) power++;
2356
2357                 /* Append a special "damage" string */
2358                 t = object_desc_chr(t, ' ');
2359                 t = object_desc_chr(t, p1);
2360                 t = object_desc_chr(t, 'x');
2361                 t = object_desc_num(t, power);
2362                 t = object_desc_chr(t, p2);
2363
2364                 fire_rate = calc_num_fire(o_ptr);
2365                 /* Show Fire rate */
2366                 if (fire_rate != 0 && power > 0 && known)
2367                 {
2368                         fire_rate = bow_energy(o_ptr->sval) / fire_rate;
2369
2370                         t = object_desc_chr(t, ' ');
2371                         t = object_desc_chr(t, p1);
2372                         t = object_desc_num(t,  fire_rate/100);
2373                         t = object_desc_chr(t,  '.');
2374                         t = object_desc_num(t,  fire_rate%100);
2375                         t = object_desc_str(t, "turn");
2376                         t = object_desc_chr(t, p2);
2377                 }
2378
2379                 /* All done */
2380                 break;
2381         }
2382
2383
2384         /* Add the weapon bonuses */
2385         if (known)
2386         {
2387                 /* Show the tohit/todam on request */
2388                 if (show_weapon)
2389                 {
2390                         t = object_desc_chr(t, ' ');
2391                         t = object_desc_chr(t, p1);
2392                         t = object_desc_int(t, o_ptr->to_h);
2393                         t = object_desc_chr(t, ',');
2394                         t = object_desc_int(t, o_ptr->to_d);
2395                         t = object_desc_chr(t, p2);
2396                 }
2397
2398                 /* Show the tohit if needed */
2399                 else if (o_ptr->to_h)
2400                 {
2401                         t = object_desc_chr(t, ' ');
2402                         t = object_desc_chr(t, p1);
2403                         t = object_desc_int(t, o_ptr->to_h);
2404                         t = object_desc_chr(t, p2);
2405                 }
2406
2407                 /* Show the todam if needed */
2408                 else if (o_ptr->to_d)
2409                 {
2410                         t = object_desc_chr(t, ' ');
2411                         t = object_desc_chr(t, p1);
2412                         t = object_desc_int(t, o_ptr->to_d);
2413                         t = object_desc_chr(t, p2);
2414                 }
2415         }
2416
2417         bow_ptr = &inventory[INVEN_BOW];
2418
2419         /* If have a firing weapon + ammo matches bow */
2420         if (bow_ptr->k_idx && (o_ptr->tval == p_ptr->tval_ammo))
2421         {
2422                 int avgdam = o_ptr->dd * (o_ptr->ds + 1) * 10 / 2;
2423                 int tmul = bow_tmul(bow_ptr->sval);
2424                 ENERGY energy_fire = bow_energy(bow_ptr->sval);
2425
2426                 /* See if the bow is "known" - then set damage bonus */
2427                 if (object_is_known(bow_ptr)) avgdam += (bow_ptr->to_d * 10);
2428
2429                 /* Effect of ammo */
2430                 if (known) avgdam += (o_ptr->to_d * 10);
2431
2432                 /* Get extra "power" from "extra might" */
2433                 if (p_ptr->xtra_might) tmul++;
2434
2435                 tmul = tmul * (100 + (int)(adj_str_td[p_ptr->stat_ind[A_STR]]) - 128);
2436
2437                 /* Launcher multiplier */
2438                 avgdam *= tmul;
2439                 avgdam /= (100 * 10);
2440
2441                 /* Get extra damage from concentration */
2442                 if (p_ptr->concent) avgdam = boost_concentration_damage(avgdam);
2443
2444                 if (avgdam < 0) avgdam = 0;
2445
2446                 /* Display (shot damage/ shot damage with critical/ avg damage with critical) */
2447                 t = object_desc_chr(t, ' ');
2448                 t = object_desc_chr(t, p1);
2449
2450                 if(show_ammo_no_crit)
2451                 {
2452                         /* Damage with no-crit */
2453                         t = object_desc_num(t, avgdam);
2454                         t = object_desc_str(t, show_ammo_detail ? "/shot " : "/");
2455                 }
2456
2457                 /* Apply Expect damage of Critical */
2458                 avgdam = calc_expect_crit_shot(o_ptr->weight, o_ptr->to_h, bow_ptr->to_h, avgdam);
2459                 t = object_desc_num(t, avgdam);
2460
2461                 t = show_ammo_no_crit ? object_desc_str(t, show_ammo_detail ? "/crit " : "/")
2462                                                           : object_desc_str(t, show_ammo_detail ? "/shot " : "/");
2463
2464                 if (p_ptr->num_fire == 0)
2465                 {
2466                         t = object_desc_chr(t, '0');
2467                 }
2468                 else
2469                 {
2470                         /* Calc effects of energy */
2471                         avgdam *= (p_ptr->num_fire * 100);
2472                         avgdam /= energy_fire;
2473                         t = object_desc_num(t, avgdam);
2474                         t = object_desc_str(t, show_ammo_detail ? "/current_world_ptr->game_turn" : "");
2475
2476                         if(show_ammo_crit_ratio)
2477                         {
2478                                 int percent = calc_crit_ratio_shot(known ? o_ptr->to_h : 0, known ? bow_ptr->to_h : 0);
2479
2480                                 t = object_desc_chr(t, '/');
2481                                 t = object_desc_num(t, percent / 100);
2482                                 t = object_desc_chr(t, '.');
2483                 if(percent % 100 < 10)
2484                 {
2485                                     t = object_desc_chr(t, '0');
2486                 }
2487                                 t = object_desc_num(t, percent % 100);
2488                                 t = object_desc_str(t, show_ammo_detail ? "% crit" : "%");
2489                         }
2490                 }
2491
2492                 t = object_desc_chr(t, p2);
2493         }
2494         else if ((p_ptr->pclass == CLASS_NINJA) && (o_ptr->tval == TV_SPIKE))
2495         {
2496                 int avgdam = p_ptr->mighty_throw ? (1 + 3) : 1;
2497                 s16b energy_fire = 100 - p_ptr->lev;
2498
2499                 avgdam += ((p_ptr->lev + 30) * (p_ptr->lev + 30) - 900) / 55;
2500
2501                 /* Display (shot damage/ avg damage) */
2502                 t = object_desc_chr(t, ' ');
2503                 t = object_desc_chr(t, p1);
2504                 t = object_desc_num(t, avgdam);
2505                 t = object_desc_chr(t, '/');
2506
2507                 /* Calc effects of energy */
2508                 avgdam = 100 * avgdam / energy_fire;
2509
2510                 t = object_desc_num(t, avgdam);
2511                 t = object_desc_chr(t, p2);
2512         }
2513
2514         /* Add the armor bonuses */
2515         if (known)
2516         {
2517                 /* Show the armor class info */
2518                 if (show_armour)
2519                 {
2520                         t = object_desc_chr(t, ' ');
2521                         t = object_desc_chr(t, b1);
2522                         t = object_desc_num(t, o_ptr->ac);
2523                         t = object_desc_chr(t, ',');
2524                         t = object_desc_int(t, o_ptr->to_a);
2525                         t = object_desc_chr(t, b2);
2526                 }
2527
2528                 /* No base armor, but does increase armor */
2529                 else if (o_ptr->to_a)
2530                 {
2531                         t = object_desc_chr(t, ' ');
2532                         t = object_desc_chr(t, b1);
2533                         t = object_desc_int(t, o_ptr->to_a);
2534                         t = object_desc_chr(t, b2);
2535                 }
2536         }
2537
2538         /* Hack -- always show base armor */
2539         else if (show_armour)
2540         {
2541                 t = object_desc_chr(t, ' ');
2542                 t = object_desc_chr(t, b1);
2543                 t = object_desc_num(t, o_ptr->ac);
2544                 t = object_desc_chr(t, b2);
2545         }
2546
2547
2548         /* No more details wanted */
2549         if (mode & OD_NAME_AND_ENCHANT) goto object_desc_done;
2550
2551
2552         if (known) /* Known item only */
2553         {
2554                 /*
2555                  * Hack -- Wands and Staffs have charges.  Make certain how many charges
2556                  * a stack of staffs really has is clear. -LM-
2557                  */
2558                 if (((o_ptr->tval == TV_STAFF) || (o_ptr->tval == TV_WAND)))
2559                 {
2560                         /* Dump " (N charges)" */
2561                         t = object_desc_chr(t, ' ');
2562                         t = object_desc_chr(t, p1);
2563
2564                         /* Clear explaination for staffs. */
2565                         if ((o_ptr->tval == TV_STAFF) && (o_ptr->number > 1))
2566                         {
2567                                 t = object_desc_num(t, o_ptr->number);
2568                                 t = object_desc_str(t, "x ");
2569                         }
2570                         t = object_desc_num(t, o_ptr->pval);
2571 #ifdef JP
2572                         t = object_desc_str(t, "回分");
2573 #else
2574                         t = object_desc_str(t, " charge");
2575                         if (o_ptr->pval != 1) t = object_desc_chr(t, 's');
2576 #endif
2577
2578                         t = object_desc_chr(t, p2);
2579                 }
2580                 /* Hack -- Rods have a "charging" indicator.  Now that stacks of rods may
2581                  * be in any state of charge or discharge, this now includes a number. -LM-
2582                  */
2583                 else if (o_ptr->tval == TV_ROD)
2584                 {
2585                         /* Hack -- Dump " (# charging)" if relevant */
2586                         if (o_ptr->timeout)
2587                         {
2588                                 /* Stacks of rods display an exact count of charging rods. */
2589                                 if (o_ptr->number > 1)
2590                                 {
2591                                         /* Paranoia. */
2592                                         if (k_ptr->pval == 0) k_ptr->pval = 1;
2593
2594                                         /* Find out how many rods are charging, by dividing
2595                                          * current timeout by each rod's maximum timeout.
2596                                          * Ensure that any remainder is rounded up.  Display
2597                                          * very discharged stacks as merely fully discharged.
2598                                          */
2599                                         power = (o_ptr->timeout + (k_ptr->pval - 1)) / k_ptr->pval;
2600                                         if (power > o_ptr->number) power = o_ptr->number;
2601
2602                                         /* Display prettily. */
2603                                         t = object_desc_str(t, " (");
2604                                         t = object_desc_num(t, power);
2605                                         t = object_desc_str(t, _("本 充填中)", " charging)"));
2606                                 }
2607
2608                                 /* "one Rod of Perception (1 charging)" would look tacky. */
2609                                 else
2610                                 {
2611                                         t = object_desc_str(t, _("(充填中)", " (charging)"));
2612                                 }
2613                         }
2614                 }
2615
2616                 /* Dump "pval" flags for wearable items */
2617                 if (have_pval_flags(flgs))
2618                 {
2619                         /* Start the display */
2620                         t = object_desc_chr(t, ' ');
2621                         t = object_desc_chr(t, p1);
2622
2623                         /* Dump the "pval" itself */
2624                         t = object_desc_int(t, o_ptr->pval);
2625
2626                         /* Do not display the "pval" flags */
2627                         if (have_flag(flgs, TR_HIDE_TYPE))
2628                         {
2629                                 /* Nothing */
2630                         }
2631
2632                         else if (have_flag(flgs, TR_SPEED))
2633                         {
2634                                 /* Dump " to speed" */
2635                                 t = object_desc_str(t, _("加速", " to speed"));
2636                         }
2637
2638                         /* Attack speed */
2639                         else if (have_flag(flgs, TR_BLOWS))
2640                         {
2641                                 /* Add " attack" */
2642 #ifdef JP
2643                                 t = object_desc_str(t, "攻撃");
2644 #else
2645                                 t = object_desc_str(t, " attack");
2646
2647                                 /* Add "attacks" */
2648                                 if (ABS(o_ptr->pval) != 1) t = object_desc_chr(t, 's');
2649 #endif
2650                         }
2651
2652                         /* Stealth */
2653                         else if (have_flag(flgs, TR_STEALTH))
2654                         {
2655                                 /* Dump " to stealth" */
2656                                 t = object_desc_str(t, _("隠密", " to stealth"));
2657                         }
2658
2659                         /* Search */
2660                         else if (have_flag(flgs, TR_SEARCH))
2661                         {
2662                                 /* Dump " to searching" */
2663                                 t = object_desc_str(t, _("探索", " to searching"));
2664                         }
2665
2666                         /* Infravision */
2667                         else if (have_flag(flgs, TR_INFRA))
2668                         {
2669                                 /* Dump " to infravision" */
2670                                 t = object_desc_str(t, _("赤外線視力", " to infravision"));
2671                         }
2672
2673                         /* Finish the display */
2674                         t = object_desc_chr(t, p2);
2675                 }
2676
2677                 /* Hack -- Process Lanterns/Torches */
2678                 if ((o_ptr->tval == TV_LITE) && (!(object_is_fixed_artifact(o_ptr) || (o_ptr->sval == SV_LITE_FEANOR))))
2679                 {
2680                         /* Hack -- Turns of light for normal lites */
2681 #ifdef JP
2682                         t = object_desc_chr(t, '(');
2683 #else
2684                         t = object_desc_str(t, " (with ");
2685 #endif
2686
2687                         if (o_ptr->name2 == EGO_LITE_LONG) t = object_desc_num(t, o_ptr->xtra4 * 2);
2688                         else t = object_desc_num(t, o_ptr->xtra4);
2689                         t = object_desc_str(t, _("ターンの寿命)", " turns of light)"));
2690                 }
2691
2692                 /* Indicate charging objects, but not rods. */
2693                 if (o_ptr->timeout && (o_ptr->tval != TV_ROD))
2694                 {
2695                         /* Hack -- Dump " (charging)" if relevant */
2696                         t = object_desc_str(t, _("(充填中)", " (charging)"));
2697                 }
2698         }
2699
2700
2701         /* No more details wanted */
2702         if (mode & OD_OMIT_INSCRIPTION) goto object_desc_done;
2703
2704
2705         /* Prepare real inscriptions in a buffer */
2706         tmp_val2[0] = '\0';
2707
2708         /* Auto abbreviation inscribe */
2709         if ((abbrev_extra || abbrev_all) && (o_ptr->ident & IDENT_MENTAL))
2710         {
2711                 if (!o_ptr->inscription || !my_strchr(quark_str(o_ptr->inscription), '%'))
2712                 {
2713                         bool kanji, all;
2714
2715 #ifdef JP
2716                         kanji = TRUE;
2717 #else
2718                         kanji = FALSE;
2719 #endif
2720                         all = abbrev_all;
2721
2722                         get_ability_abbreviation(tmp_val2, o_ptr, kanji, all);
2723                 }
2724         }
2725
2726         /* Use the standard inscription if available */
2727         if (o_ptr->inscription)
2728         {
2729                 char buff[1024];
2730
2731                 if (tmp_val2[0]) strcat(tmp_val2, ", ");
2732
2733                 /* Get inscription and convert {%} */
2734                 get_inscription(buff, o_ptr);
2735
2736                 /* strcat with correct treating of kanji */
2737                 my_strcat(tmp_val2, buff, sizeof(tmp_val2));
2738         }
2739
2740
2741         /* No fake inscription yet */
2742         fake_insc_buf[0] = '\0';
2743
2744         /* Use the game-generated "feeling" otherwise, if available */
2745         if (o_ptr->feeling)
2746         {
2747                 strcpy(fake_insc_buf, game_inscriptions[o_ptr->feeling]);
2748         }
2749
2750         /* Note "cursed" if the item is known to be cursed */
2751         else if (object_is_cursed(o_ptr) && (known || (o_ptr->ident & IDENT_SENSE)))
2752         {
2753                 strcpy(fake_insc_buf, _("呪われている", "cursed"));
2754         }
2755
2756         /* Note "unidentified" if the item is unidentified */
2757         else if (((o_ptr->tval == TV_RING) || (o_ptr->tval == TV_AMULET)
2758                    || (o_ptr->tval == TV_LITE) || (o_ptr->tval == TV_FIGURINE))
2759                  && aware && !known
2760                  && !(o_ptr->ident & IDENT_SENSE))
2761         {
2762                 strcpy(fake_insc_buf, _("未鑑定", "unidentified"));
2763         }
2764
2765         /* Mega-Hack -- note empty wands/staffs */
2766         else if (!known && (o_ptr->ident & IDENT_EMPTY))
2767         {
2768                 strcpy(fake_insc_buf, _("空", "empty"));
2769         }
2770
2771         /* Note "tried" if the object has been tested unsuccessfully */
2772         else if (!aware && object_is_tried(o_ptr))
2773         {
2774                 strcpy(fake_insc_buf, _("未判明", "tried"));
2775         }
2776
2777         /* Note the discount, if any */
2778         if (o_ptr->discount)
2779         {
2780                 /* Hidden by real inscription unless in a store */
2781                 if (!tmp_val2[0] || (o_ptr->ident & IDENT_STORE))
2782                 {
2783                         char discount_num_buf[4];
2784
2785                         /* Append to other fake inscriptions if any */
2786                         if (fake_insc_buf[0]) strcat(fake_insc_buf, ", ");
2787
2788                         (void)object_desc_num(discount_num_buf, o_ptr->discount);
2789                         strcat(fake_insc_buf, discount_num_buf);
2790                         strcat(fake_insc_buf, _("%引き", "% off"));
2791                 }
2792         }
2793
2794
2795         /* Append the inscription, if any */
2796         if (fake_insc_buf[0] || tmp_val2[0])
2797         {
2798                 /* Append the inscription */
2799                 t = object_desc_chr(t, ' ');
2800                 t = object_desc_chr(t, c1);
2801
2802                 /* Append fake inscriptions */
2803                 if (fake_insc_buf[0])
2804                 {
2805                         t = object_desc_str(t, fake_insc_buf);
2806                 }
2807
2808                 /* Append a separater */
2809                 if (fake_insc_buf[0] && tmp_val2[0])
2810                 {
2811                         t = object_desc_chr(t, ',');
2812                         t = object_desc_chr(t, ' ');
2813                 }
2814
2815                 /* Append real inscriptions */
2816                 if (tmp_val2[0])
2817                 {
2818                         t = object_desc_str(t, tmp_val2);
2819                 }
2820
2821                 t = object_desc_chr(t, c2);
2822         }
2823
2824 object_desc_done:
2825         my_strcpy(buf, tmp_val, MAX_NLEN);
2826 }
2827
2828