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