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