src/wizard1.c

   1 /*!
   2  *  @file wizard1.c
   3  *  @brief ウィザードモードの処理(スポイラー出力中心) / Spoiler generation -BEN-
   4  *  @date 2014/02/17
   5  *  @author
   6  * Copyright (c) 1997 Ben Harrison, and others
   7  * This software may be copied and distributed for educational, research,
   8  * and not for profit purposes provided that this copyright and statement
   9  * are included in all such copies.  Other copyrights may also apply.
  10  * 2013 Deskull rearranged comment for Doxygen.
  11  */
  12
  13 #include "angband.h"
  14
  15
  16 #ifdef ALLOW_SPOILERS
  17
  18
  19 /*
  20  * The spoiler file being created
  21  */
  22 static FILE *fff = NULL;
  23
  24
  25
  26 /*!
  27  * @brief シンボル職の記述名を返す /
  28  * Extract a textual representation of an attribute
  29  * @param r_ptr モンスター種族の構造体ポインタ
  30  * @return シンボル職の記述名
  31  */
  32 static cptr attr_to_text(monster_race *r_ptr)
  33 {
  34 #ifdef JP000
  35         if (r_ptr->flags1 & RF1_ATTR_CLEAR)    return "透明な";
  36         if (r_ptr->flags1 & RF1_ATTR_MULTI)    return "万色の";
  37         if (r_ptr->flags1 & RF1_ATTR_SEMIRAND) return "準ランダムな";
  38 #else
  39         if (r_ptr->flags1 & RF1_ATTR_CLEAR)    return "Clear";
  40         if (r_ptr->flags1 & RF1_ATTR_MULTI)    return "Multi";
  41         if (r_ptr->flags1 & RF1_ATTR_SEMIRAND) return "S.Rand";
  42 #endif
  43
  44         switch (r_ptr->d_attr)
  45         {
  46 #ifdef JP000
  47         case TERM_DARK:    return "XXXい";
  48         case TERM_WHITE:   return "白い";
  49         case TERM_SLATE:   return "青灰色の";
  50         case TERM_ORANGE:  return "オレンジの";
  51         case TERM_RED:     return "赤い";
  52         case TERM_GREEN:   return "緑の";
  53         case TERM_BLUE:    return "青い";
  54         case TERM_UMBER:   return "琥珀色の";
  55         case TERM_L_DARK:  return "灰色の";
  56         case TERM_L_WHITE: return "明青灰色の";
  57         case TERM_VIOLET:  return "紫の";
  58         case TERM_YELLOW:  return "黄色い";
  59         case TERM_L_RED:   return "明い赤の";
  60         case TERM_L_GREEN: return "明い緑の";
  61         case TERM_L_BLUE:  return "明い青の";
  62         case TERM_L_UMBER: return "明い琥珀色の";
  63 #else
  64         case TERM_DARK:    return "xxx";
  65         case TERM_WHITE:   return "White";
  66         case TERM_SLATE:   return "Slate";
  67         case TERM_ORANGE:  return "Orange";
  68         case TERM_RED:     return "Red";
  69         case TERM_GREEN:   return "Green";
  70         case TERM_BLUE:    return "Blue";
  71         case TERM_UMBER:   return "Umber";
  72         case TERM_L_DARK:  return "L.Dark";
  73         case TERM_L_WHITE: return "L.Slate";
  74         case TERM_VIOLET:  return "Violet";
  75         case TERM_YELLOW:  return "Yellow";
  76         case TERM_L_RED:   return "L.Red";
  77         case TERM_L_GREEN: return "L.Green";
  78         case TERM_L_BLUE:  return "L.Blue";
  79         case TERM_L_UMBER: return "L.Umber";
  80 #endif
  81         }
  82
  83         /* Oops */
  84 #ifdef JP000
  85         return "変な";
  86 #else
  87         return "Icky";
  88 #endif
  89 }
  90
  91
  92
  93 /*
  94  * A tval grouper
  95  */
  96 typedef struct
  97 {
  98         byte tval;
  99         cptr name;
 100 } grouper;
 101
 102
 103
 104 /*
 105  * Item Spoilers by: benh@phial.com (Ben Harrison)
 106  */
 107
 108
 109 /*
 110  * The basic items categorized by type
 111  */
 112 static grouper group_item[] =
 113 {
 114 #ifdef JP
 115         { TV_SHOT,          "射撃物" },
 116 #else
 117         { TV_SHOT,          "Ammo" },
 118 #endif
 119
 120         { TV_ARROW,         NULL },
 121         { TV_BOLT,          NULL },
 122
 123 #ifdef JP
 124         { TV_BOW,           "弓" },
 125 #else
 126         { TV_BOW,           "Bows" },
 127 #endif
 128
 129 #ifdef JP
 130         { TV_DIGGING,       "武器" },
 131 #else
 132         { TV_DIGGING,       "Weapons" },
 133 #endif
 134
 135         { TV_POLEARM,       NULL },
 136         { TV_HAFTED,        NULL },
 137         { TV_SWORD,         NULL },
 138
 139 #ifdef JP
 140         { TV_SOFT_ARMOR,    "防具 (体)" },
 141 #else
 142         { TV_SOFT_ARMOR,    "Armour (Body)" },
 143 #endif
 144
 145         { TV_HARD_ARMOR,    NULL },
 146         { TV_DRAG_ARMOR,    NULL },
 147
 148 #ifdef JP
 149         { TV_BOOTS,         "防具 (その他)" },
 150 #else
 151         { TV_BOOTS,         "Armour (Misc)" },
 152 #endif
 153
 154         { TV_GLOVES,        NULL },
 155         { TV_HELM,          NULL },
 156         { TV_CROWN,         NULL },
 157         { TV_SHIELD,        NULL },
 158         { TV_CLOAK,         NULL },
 159
 160 #ifdef JP
 161         { TV_LITE,          "光源" },
 162         { TV_AMULET,        "アミュレット" },
 163         { TV_RING,          "指輪" },
 164 #else
 165         { TV_LITE,          "Light Sources" },
 166         { TV_AMULET,        "Amulets" },
 167         { TV_RING,          "Rings" },
 168 #endif
 169
 170 #ifdef JP
 171         { TV_STAFF,         "杖" },
 172         { TV_WAND,          "魔法棒" },
 173         { TV_ROD,           "ロッド" },
 174 #else
 175         { TV_STAFF,         "Staffs" },
 176         { TV_WAND,          "Wands" },
 177         { TV_ROD,           "Rods" },
 178 #endif
 179
 180 #ifdef JP
 181         { TV_SCROLL,        "巻物" },
 182         { TV_POTION,        "薬" },
 183         { TV_FOOD,          "食料" },
 184 #else
 185         { TV_SCROLL,        "Scrolls" },
 186         { TV_POTION,        "Potions" },
 187         { TV_FOOD,          "Food" },
 188 #endif
 189
 190 #ifdef JP
 191         { TV_LIFE_BOOK,     "魔法書 (生命)" },
 192         { TV_SORCERY_BOOK,  "魔法書 (仙術)" },
 193         { TV_NATURE_BOOK,   "魔法書 (自然)" },
 194         { TV_CHAOS_BOOK,    "魔法書 (カオス)" },
 195         { TV_DEATH_BOOK,    "魔法書 (暗黒)" },
 196         { TV_TRUMP_BOOK,    "魔法書 (トランプ)" },
 197         { TV_ARCANE_BOOK,   "魔法書 (秘術)" },
 198         { TV_CRAFT_BOOK,    "魔法書 (匠)" },
 199         { TV_DAEMON_BOOK,   "魔法書 (悪魔)" },
 200         { TV_CRUSADE_BOOK,  "魔法書 (破邪)" },
 201         { TV_MUSIC_BOOK,    "歌集" },
 202         { TV_HISSATSU_BOOK, "武芸の書" },
 203         { TV_HEX_BOOK,      "魔法書 (呪術)" },
 204 #else
 205         { TV_LIFE_BOOK,     "Books (Life)" },
 206         { TV_SORCERY_BOOK,  "Books (Sorcery)" },
 207         { TV_NATURE_BOOK,   "Books (Nature)" },
 208         { TV_CHAOS_BOOK,    "Books (Chaos)" },
 209         { TV_DEATH_BOOK,    "Books (Death)" },
 210         { TV_TRUMP_BOOK,    "Books (Trump)" },
 211         { TV_ARCANE_BOOK,   "Books (Arcane)" },
 212         { TV_CRAFT_BOOK,    "Books (Craft)" },
 213         { TV_DAEMON_BOOK,   "Books (Daemon)" },
 214         { TV_CRUSADE_BOOK,  "Books (Crusade)" },
 215         { TV_MUSIC_BOOK,    "Song Books" },
 216         { TV_HISSATSU_BOOK, "Books (Kendo)" },
 217         { TV_HEX_BOOK,      "Books (Hex)" },
 218 #endif
 219
 220 #ifdef JP
 221         { TV_WHISTLE,       "笛" },
 222         { TV_CAPTURE,       "キャプチャー・ボール" },
 223         { TV_CARD,          "エクスプレスカード" },
 224 #else
 225         { TV_WHISTLE,       "Whistle" },
 226         { TV_CAPTURE,       "Capture Ball" },
 227         { TV_CARD,          "Express Card" },
 228 #endif
 229
 230 #ifdef JP
 231         { TV_CHEST,         "箱" },
 232 #else
 233         { TV_CHEST,         "Chests" },
 234 #endif
 235
 236 #ifdef JP
 237         { TV_FIGURINE,      "人形" },
 238         { TV_STATUE,        "像" },
 239         { TV_CORPSE,        "死体" },
 240 #else
 241         { TV_FIGURINE,      "Magical Figurines" },
 242         { TV_STATUE,        "Statues" },
 243         { TV_CORPSE,        "Corpses" },
 244 #endif
 245
 246 #ifdef JP
 247         { TV_SKELETON,      "その他" },
 248 #else
 249         { TV_SKELETON,      "Misc" },
 250 #endif
 251
 252         { TV_BOTTLE,        NULL },
 253         { TV_JUNK,          NULL },
 254         { TV_SPIKE,         NULL },
 255         { TV_FLASK,         NULL },
 256         { TV_PARCHMENT,     NULL },
 257
 258         { 0, "" }
 259 };
 260
 261
 262 /*!
 263  * @brief ベースアイテムの各情報を文字列化する /
 264  * Describe the kind
 265  * @param buf 名称を返すバッファ参照ポインタ
 266  * @param dam ダメージダイス記述を返すバッファ参照ポインタ
 267  * @param wgt 重量記述を返すバッファ参照ポインタ
 268  * @param lev 生成階記述を返すバッファ参照ポインタ
 269  * @param val 価値を返すバッファ参照ポインタ
 270  * @param k ベースアイテムID
 271  * @return なし
 272  */
 273 static void kind_info(char *buf, char *dam, char *wgt, int *lev, s32b *val, int k)
 274 {
 275         object_type forge;
 276         object_type *q_ptr;
 277
 278
 279         /* Get local object */
 280         q_ptr = &forge;
 281
 282         /* Prepare a fake item */
 283         object_prep(q_ptr, k);
 284
 285         /* It is known */
 286         q_ptr->ident |= (IDENT_KNOWN);
 287
 288         /* Cancel bonuses */
 289         q_ptr->pval = 0;
 290         q_ptr->to_a = 0;
 291         q_ptr->to_h = 0;
 292         q_ptr->to_d = 0;
 293
 294
 295         /* Level */
 296         (*lev) = k_info[q_ptr->k_idx].level;
 297
 298         /* Value */
 299         (*val) = object_value(q_ptr);
 300
 301
 302         /* Hack */
 303         if (!buf || !dam || !wgt) return;
 304
 305
 306         /* Description (too brief) */
 307         object_desc(buf, q_ptr, (OD_NAME_ONLY | OD_STORE));
 308
 309
 310         /* Misc info */
 311         strcpy(dam, "");
 312
 313         /* Damage */
 314         switch (q_ptr->tval)
 315         {
 316                 /* Bows */
 317                 case TV_BOW:
 318                 {
 319                         break;
 320                 }
 321
 322                 /* Ammo */
 323                 case TV_SHOT:
 324                 case TV_BOLT:
 325                 case TV_ARROW:
 326                 {
 327                         sprintf(dam, "%dd%d", q_ptr->dd, q_ptr->ds);
 328                         break;
 329                 }
 330
 331                 /* Weapons */
 332                 case TV_HAFTED:
 333                 case TV_POLEARM:
 334                 case TV_SWORD:
 335                 case TV_DIGGING:
 336                 {
 337                         sprintf(dam, "%dd%d", q_ptr->dd, q_ptr->ds);
 338                         break;
 339                 }
 340
 341                 /* Armour */
 342                 case TV_BOOTS:
 343                 case TV_GLOVES:
 344                 case TV_CLOAK:
 345                 case TV_CROWN:
 346                 case TV_HELM:
 347                 case TV_SHIELD:
 348                 case TV_SOFT_ARMOR:
 349                 case TV_HARD_ARMOR:
 350                 case TV_DRAG_ARMOR:
 351                 {
 352                         sprintf(dam, "%d", q_ptr->ac);
 353                         break;
 354                 }
 355         }
 356
 357
 358         /* Weight */
 359         sprintf(wgt, "%3d.%d", q_ptr->weight / 10, q_ptr->weight % 10);
 360 }
 361
 362
 363 /*!
 364  * @brief 各ベースアイテムの情報を一行毎に記述する /
 365  * Create a spoiler file for items
 366  * @param fname ファイル名
 367  * @return なし
 368  */
 369 static void spoil_obj_desc(cptr fname)
 370 {
 371         int i, k, s, t, n = 0, group_start = 0;
 372
 373         u16b who[200];
 374
 375         char buf[1024];
 376
 377         char wgt[80];
 378         char dam[80];
 379
 380
 381         /* Build the filename */
 382         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, fname);
 383
 384         /* File type is "TEXT" */
 385         FILE_TYPE(FILE_TYPE_TEXT);
 386
 387         /* Open the file */
 388         fff = my_fopen(buf, "w");
 389
 390         /* Oops */
 391         if (!fff)
 392         {
 393                 msg_print("Cannot create spoiler file.");
 394                 return;
 395         }
 396
 397
 398         /* Header */
 399         fprintf(fff, "Spoiler File -- Basic Items (Hengband %d.%d.%d)\n\n\n",
 400                 FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
 401
 402         /* More Header */
 403         fprintf(fff, "%-45s     %8s%7s%5s%9s\n",
 404                 "Description", "Dam/AC", "Wgt", "Lev", "Cost");
 405         fprintf(fff, "%-45s     %8s%7s%5s%9s\n",
 406                 "----------------------------------------",
 407                 "------", "---", "---", "----");
 408
 409         /* List the groups */
 410         for (i = 0; TRUE; i++)
 411         {
 412                 /* Write out the group title */
 413                 if (group_item[i].name)
 414                 {
 415                         if (n)
 416                         {
 417                                 /* Hack -- bubble-sort by cost and then level */
 418                                 for (s = 0; s < n - 1; s++)
 419                                 {
 420                                         for (t = 0; t < n - 1; t++)
 421                                         {
 422                                                 int i1 = t;
 423                                                 int i2 = t + 1;
 424
 425                                                 int e1;
 426                                                 int e2;
 427
 428                                                 s32b t1;
 429                                                 s32b t2;
 430
 431                                                 kind_info(NULL, NULL, NULL, &e1, &t1, who[i1]);
 432                                                 kind_info(NULL, NULL, NULL, &e2, &t2, who[i2]);
 433
 434                                                 if ((t1 > t2) || ((t1 == t2) && (e1 > e2)))
 435                                                 {
 436                                                         int tmp = who[i1];
 437                                                         who[i1] = who[i2];
 438                                                         who[i2] = tmp;
 439                                                 }
 440                                         }
 441                                 }
 442
 443                                 fprintf(fff, "\n\n%s\n\n", group_item[group_start].name);
 444
 445                                 /* Spoil each item */
 446                                 for (s = 0; s < n; s++)
 447                                 {
 448                                         int e;
 449                                         s32b v;
 450
 451                                         /* Describe the kind */
 452                                         kind_info(buf, dam, wgt, &e, &v, who[s]);
 453
 454                                         /* Dump it */
 455                                         fprintf(fff, "     %-45s%8s%7s%5d%9ld\n",
 456                                                 buf, dam, wgt, e, (long)(v));
 457                                 }
 458
 459                                 /* Start a new set */
 460                                 n = 0;
 461                         }
 462
 463                         /* Notice the end */
 464                         if (!group_item[i].tval) break;
 465
 466                         /* Start a new set */
 467                         group_start = i;
 468                 }
 469
 470                 /* Acquire legal item types */
 471                 for (k = 1; k < max_k_idx; k++)
 472                 {
 473                         object_kind *k_ptr = &k_info[k];
 474
 475                         /* Skip wrong tval's */
 476                         if (k_ptr->tval != group_item[i].tval) continue;
 477
 478                         /* Hack -- Skip instant-artifacts */
 479                         if (k_ptr->gen_flags & (TRG_INSTA_ART)) continue;
 480
 481                         /* Save the index */
 482                         who[n++] = k;
 483                 }
 484         }
 485
 486
 487         /* Check for errors */
 488         if (ferror(fff) || my_fclose(fff))
 489         {
 490                 msg_print("Cannot close spoiler file.");
 491                 return;
 492         }
 493
 494         /* Message */
 495         msg_print("Successfully created a spoiler file.");
 496 }
 497
 498
 499 /*
 500  * Artifact Spoilers by: randy@PICARD.tamu.edu (Randy Hutson)
 501  */
 502
 503
 504 /*
 505  * Returns a "+" string if a number is non-negative and an empty
 506  * string if negative
 507  */
 508 #define POSITIZE(v) (((v) >= 0) ? "+" : "")
 509
 510 /*
 511  * These are used to format the artifact spoiler file. INDENT1 is used
 512  * to indent all but the first line of an artifact spoiler. INDENT2 is
 513  * used when a line "wraps". (Bladeturner's resistances cause this.)
 514  */
 515 #define INDENT1 "    "
 516 #define INDENT2 "      "
 517
 518 /*
 519  * MAX_LINE_LEN specifies when a line should wrap.
 520  */
 521 #define MAX_LINE_LEN 75
 522
 523 /*
 524  * Given an array, determine how many elements are in the array
 525  */
 526 #define N_ELEMENTS(a) (sizeof (a) / sizeof ((a)[0]))
 527
 528 /*
 529  * The artifacts categorized by type
 530  */
 531 static grouper group_artifact[] =
 532 {
 533 #ifdef JP
 534         { TV_SWORD,             "刀剣" },
 535         { TV_POLEARM,           "槍/斧" },
 536         { TV_HAFTED,            "鈍器" },
 537         { TV_DIGGING,           "シャベル/つるはし" },
 538         { TV_BOW,               "飛び道具" },
 539         { TV_ARROW,             "矢" },
 540         { TV_BOLT,              NULL },
 541
 542         { TV_SOFT_ARMOR,        "鎧" },
 543         { TV_HARD_ARMOR,        NULL },
 544         { TV_DRAG_ARMOR,        NULL },
 545
 546         { TV_CLOAK,             "クローク" },
 547         { TV_SHIELD,            "盾" },
 548         { TV_CARD,              NULL },
 549         { TV_HELM,              "兜/冠" },
 550         { TV_CROWN,             NULL },
 551         { TV_GLOVES,            "籠手" },
 552         { TV_BOOTS,             "靴" },
 553
 554         { TV_LITE,              "光源" },
 555         { TV_AMULET,            "アミュレット" },
 556         { TV_RING,              "指輪" },
 557 #else
 558         { TV_SWORD,             "Edged Weapons" },
 559         { TV_POLEARM,           "Polearms" },
 560         { TV_HAFTED,            "Hafted Weapons" },
 561         { TV_DIGGING,           "Shovels/Picks" },
 562         { TV_BOW,               "Bows" },
 563         { TV_ARROW,             "Ammo" },
 564         { TV_BOLT,              NULL },
 565
 566         { TV_SOFT_ARMOR,        "Body Armor" },
 567         { TV_HARD_ARMOR,        NULL },
 568         { TV_DRAG_ARMOR,        NULL },
 569
 570         { TV_CLOAK,             "Cloaks" },
 571         { TV_SHIELD,            "Shields" },
 572         { TV_CARD,              NULL },
 573         { TV_HELM,              "Helms/Crowns" },
 574         { TV_CROWN,             NULL },
 575         { TV_GLOVES,            "Gloves" },
 576         { TV_BOOTS,             "Boots" },
 577
 578         { TV_LITE,              "Light Sources" },
 579         { TV_AMULET,            "Amulets" },
 580         { TV_RING,              "Rings" },
 581 #endif
 582
 583         { 0, NULL }
 584 };
 585
 586
 587
 588 /*
 589  * Pair together a constant flag with a textual description.
 590  *
 591  * Used by both "init.c" and "wiz-spo.c".
 592  *
 593  * Note that it sometimes more efficient to actually make an array
 594  * of textual names, where entry 'N' is assumed to be paired with
 595  * the flag whose value is "1L << N", but that requires hard-coding.
 596  */
 597
 598 typedef struct flag_desc flag_desc;
 599
 600 struct flag_desc
 601 {
 602         const int flag;
 603         const char *const desc;
 604 };
 605
 606
 607
 608 /*
 609  * These are used for "+3 to STR, DEX", etc. These are separate from
 610  * the other pval affected traits to simplify the case where an object
 611  * affects all stats.  In this case, "All stats" is used instead of
 612  * listing each stat individually.
 613  */
 614
 615 static flag_desc stat_flags_desc[] =
 616 {
 617 #ifdef JP
 618         { TR_STR,        "腕力" },
 619         { TR_INT,        "知能" },
 620         { TR_WIS,        "賢さ" },
 621         { TR_DEX,        "器用さ" },
 622         { TR_CON,        "耐久力" },
 623         { TR_CHR,        "魅力" }
 624 #else
 625         { TR_STR,        "STR" },
 626         { TR_INT,        "INT" },
 627         { TR_WIS,        "WIS" },
 628         { TR_DEX,        "DEX" },
 629         { TR_CON,        "CON" },
 630         { TR_CHR,        "CHR" }
 631 #endif
 632 };
 633
 634 /*
 635  * Besides stats, these are the other player traits
 636  * which may be affected by an object's pval
 637  */
 638
 639 static flag_desc pval_flags1_desc[] =
 640 {
 641 #ifdef JP
 642         { TR_MAGIC_MASTERY,    "魔法道具使用能力" },
 643         { TR_STEALTH,    "隠密" },
 644         { TR_SEARCH,     "探索" },
 645         { TR_INFRA,      "赤外線視力" },
 646         { TR_TUNNEL,     "採掘" },
 647         { TR_BLOWS,      "攻撃回数" },
 648         { TR_SPEED,      "スピード" }
 649 #else
 650         { TR_STEALTH,    "Stealth" },
 651         { TR_SEARCH,     "Searching" },
 652         { TR_INFRA,      "Infravision" },
 653         { TR_TUNNEL,     "Tunneling" },
 654         { TR_BLOWS,      "Attacks" },
 655         { TR_SPEED,      "Speed" }
 656 #endif
 657 };
 658
 659 /*
 660  * Slaying preferences for weapons
 661  */
 662
 663 static flag_desc slay_flags_desc[] =
 664 {
 665 #ifdef JP
 666         { TR_SLAY_ANIMAL,        "動物" },
 667         { TR_KILL_ANIMAL,        "*動物*" },
 668         { TR_SLAY_EVIL,          "邪悪" },
 669         { TR_KILL_EVIL,          "*邪悪*" },
 670         { TR_SLAY_HUMAN,         "人間" },
 671         { TR_KILL_HUMAN,         "*人間*" },
 672         { TR_SLAY_UNDEAD,        "アンデッド" },
 673         { TR_KILL_UNDEAD,        "*アンデッド*" },
 674         { TR_SLAY_DEMON,         "悪魔" },
 675         { TR_KILL_DEMON,         "*悪魔*" },
 676         { TR_SLAY_ORC,           "オーク" },
 677         { TR_KILL_ORC,           "*オーク*" },
 678         { TR_SLAY_TROLL,         "トロル" },
 679         { TR_KILL_TROLL,         "*トロル*" },
 680         { TR_SLAY_GIANT,         "巨人" },
 681         { TR_KILL_GIANT,         "*巨人*" },
 682         { TR_SLAY_DRAGON,        "ドラゴン" },
 683         { TR_KILL_DRAGON,        "*ドラゴン*" },
 684 #else
 685         { TR_SLAY_ANIMAL,        "Animal" },
 686         { TR_KILL_ANIMAL,        "XAnimal" },
 687         { TR_SLAY_EVIL,          "Evil" },
 688         { TR_KILL_EVIL,          "XEvil" },
 689         { TR_SLAY_HUMAN,         "Human" },
 690         { TR_KILL_HUMAN,         "XHuman" },
 691         { TR_SLAY_UNDEAD,        "Undead" },
 692         { TR_KILL_UNDEAD,        "XUndead" },
 693         { TR_SLAY_DEMON,         "Demon" },
 694         { TR_KILL_DEMON,         "XDemon" },
 695         { TR_SLAY_ORC,           "Orc" },
 696         { TR_KILL_ORC,           "XOrc" },
 697         { TR_SLAY_TROLL,         "Troll" },
 698         { TR_KILL_TROLL,         "XTroll" },
 699         { TR_SLAY_GIANT,         "Giant" },
 700         { TR_KILL_GIANT,         "Xgiant" },
 701         { TR_SLAY_DRAGON,        "Dragon" },
 702         { TR_KILL_DRAGON,        "Xdragon" }
 703 #endif
 704 };
 705
 706 /*
 707  * Elemental brands for weapons
 708  *
 709  * Clearly, TR1_IMPACT is a bit out of place here. To simplify
 710  * coding, it has been included here along with the elemental
 711  * brands. It does seem to fit in with the brands and slaying
 712  * more than the miscellaneous section.
 713  */
 714 static flag_desc brand_flags_desc[] =
 715 {
 716 #ifdef JP
 717         { TR_BRAND_ACID,         "溶解" },
 718         { TR_BRAND_ELEC,         "電撃" },
 719         { TR_BRAND_FIRE,         "焼棄" },
 720         { TR_BRAND_COLD,         "凍結" },
 721         { TR_BRAND_POIS,         "毒殺" },
 722
 723         { TR_FORCE_WEAPON,       "理力" },
 724         { TR_CHAOTIC,            "混沌" },
 725         { TR_VAMPIRIC,           "吸血" },
 726         { TR_IMPACT,             "地震" },
 727         { TR_VORPAL,             "切れ味" },
 728 #else
 729         { TR_BRAND_ACID,         "Acid Brand" },
 730         { TR_BRAND_ELEC,         "Lightning Brand" },
 731         { TR_BRAND_FIRE,         "Flame Tongue" },
 732         { TR_BRAND_COLD,         "Frost Brand" },
 733         { TR_BRAND_POIS,         "Poisoned" },
 734
 735         { TR_FORCE_WEAPON,       "Force" },
 736         { TR_CHAOTIC,            "Mark of Chaos" },
 737         { TR_VAMPIRIC,           "Vampiric" },
 738         { TR_IMPACT,             "Earthquake impact on hit" },
 739         { TR_VORPAL,             "Very sharp" },
 740 #endif
 741 };
 742
 743
 744 /*
 745  * The 15 resistables
 746  */
 747 static const flag_desc resist_flags_desc[] =
 748 {
 749 #ifdef JP
 750         { TR_RES_ACID,   "酸" },
 751         { TR_RES_ELEC,   "電撃" },
 752         { TR_RES_FIRE,   "火炎" },
 753         { TR_RES_COLD,   "冷気" },
 754         { TR_RES_POIS,   "毒" },
 755         { TR_RES_FEAR,   "恐怖"},
 756         { TR_RES_LITE,   "閃光" },
 757         { TR_RES_DARK,   "暗黒" },
 758         { TR_RES_BLIND,  "盲目" },
 759         { TR_RES_CONF,   "混乱" },
 760         { TR_RES_SOUND,  "轟音" },
 761         { TR_RES_SHARDS, "破片" },
 762         { TR_RES_NETHER, "地獄" },
 763         { TR_RES_NEXUS,  "因果混乱" },
 764         { TR_RES_CHAOS,  "カオス" },
 765         { TR_RES_DISEN,  "劣化" },
 766 #else
 767         { TR_RES_ACID,   "Acid" },
 768         { TR_RES_ELEC,   "Lightning" },
 769         { TR_RES_FIRE,   "Fire" },
 770         { TR_RES_COLD,   "Cold" },
 771         { TR_RES_POIS,   "Poison" },
 772         { TR_RES_FEAR,   "Fear"},
 773         { TR_RES_LITE,   "Light" },
 774         { TR_RES_DARK,   "Dark" },
 775         { TR_RES_BLIND,  "Blindness" },
 776         { TR_RES_CONF,   "Confusion" },
 777         { TR_RES_SOUND,  "Sound" },
 778         { TR_RES_SHARDS, "Shards" },
 779         { TR_RES_NETHER, "Nether" },
 780         { TR_RES_NEXUS,  "Nexus" },
 781         { TR_RES_CHAOS,  "Chaos" },
 782         { TR_RES_DISEN,  "Disenchantment" },
 783 #endif
 784 };
 785
 786 /*
 787  * Elemental immunities (along with poison)
 788  */
 789
 790 static const flag_desc immune_flags_desc[] =
 791 {
 792 #ifdef JP
 793         { TR_IM_ACID,    "酸" },
 794         { TR_IM_ELEC,    "電撃" },
 795         { TR_IM_FIRE,    "火炎" },
 796         { TR_IM_COLD,    "冷気" },
 797 #else
 798         { TR_IM_ACID,    "Acid" },
 799         { TR_IM_ELEC,    "Lightning" },
 800         { TR_IM_FIRE,    "Fire" },
 801         { TR_IM_COLD,    "Cold" },
 802 #endif
 803 };
 804
 805 /*
 806  * Sustain stats -  these are given their "own" line in the
 807  * spoiler file, mainly for simplicity
 808  */
 809 static const flag_desc sustain_flags_desc[] =
 810 {
 811 #ifdef JP
 812         { TR_SUST_STR,   "腕力" },
 813         { TR_SUST_INT,   "知能" },
 814         { TR_SUST_WIS,   "賢さ" },
 815         { TR_SUST_DEX,   "器用さ" },
 816         { TR_SUST_CON,   "耐久力" },
 817         { TR_SUST_CHR,   "魅力" },
 818 #else
 819         { TR_SUST_STR,   "STR" },
 820         { TR_SUST_INT,   "INT" },
 821         { TR_SUST_WIS,   "WIS" },
 822         { TR_SUST_DEX,   "DEX" },
 823         { TR_SUST_CON,   "CON" },
 824         { TR_SUST_CHR,   "CHR" },
 825 #endif
 826 };
 827
 828 /*
 829  * Miscellaneous magic given by an object's "flags2" field
 830  */
 831
 832 static const flag_desc misc_flags2_desc[] =
 833 {
 834 #ifdef JP
 835         { TR_THROW,      "投擲" },
 836         { TR_REFLECT,    "反射" },
 837         { TR_FREE_ACT,   "麻痺知らず" },
 838         { TR_HOLD_EXP,   "経験値維持" },
 839 #else
 840         { TR_THROW,      "Throwing" },
 841         { TR_REFLECT,    "Reflection" },
 842         { TR_FREE_ACT,   "Free Action" },
 843         { TR_HOLD_EXP,   "Hold Experience" },
 844 #endif
 845 };
 846
 847 /*
 848  * Miscellaneous magic given by an object's "flags3" field
 849  *
 850  * Note that cursed artifacts and objects with permanent light
 851  * are handled "directly" -- see analyze_misc_magic()
 852  */
 853
 854 static const flag_desc misc_flags3_desc[] =
 855 {
 856 #ifdef JP
 857         { TR_SH_FIRE,            "火炎オーラ" },
 858         { TR_SH_ELEC,            "電撃オーラ" },
 859         { TR_SH_COLD,            "冷気オーラ" },
 860         { TR_NO_TELE,            "反テレポート" },
 861         { TR_NO_MAGIC,           "反魔法" },
 862         { TR_LEVITATION,         "浮遊" },
 863         { TR_SEE_INVIS,          "可視透明" },
 864         { TR_TELEPATHY,          "テレパシー" },
 865         { TR_ESP_ANIMAL,         "動物感知" },
 866         { TR_ESP_UNDEAD,         "不死感知" },
 867         { TR_ESP_DEMON,          "悪魔感知" },
 868         { TR_ESP_ORC,            "オーク感知" },
 869         { TR_ESP_TROLL,          "トロル感知" },
 870         { TR_ESP_GIANT,          "巨人感知" },
 871         { TR_ESP_DRAGON,         "ドラゴン感知" },
 872         { TR_ESP_HUMAN,          "人間感知" },
 873         { TR_ESP_EVIL,           "邪悪感知" },
 874         { TR_ESP_GOOD,           "善良感知" },
 875         { TR_ESP_NONLIVING,      "無生物感知" },
 876         { TR_ESP_UNIQUE,         "ユニーク感知" },
 877         { TR_SLOW_DIGEST,        "遅消化" },
 878         { TR_REGEN,              "急速回復" },
 879         { TR_WARNING,            "警告" },
 880 /*      { TR_XTRA_MIGHT,         "強力射撃" }, */
 881         { TR_XTRA_SHOTS,         "追加射撃" },        /* always +1? */
 882         { TR_DRAIN_EXP,          "経験値吸収" },
 883         { TR_AGGRAVATE,          "反感" },
 884         { TR_BLESSED,            "祝福" },
 885         { TR_DEC_MANA,           "消費魔力減少" },
 886 #else
 887         { TR_SH_FIRE,            "Fiery Aura" },
 888         { TR_SH_ELEC,            "Electric Aura" },
 889         { TR_SH_COLD,            "Coldly Aura" },
 890         { TR_NO_TELE,            "Prevent Teleportation" },
 891         { TR_NO_MAGIC,           "Anti-Magic" },
 892         { TR_LEVITATION,            "Levitation" },
 893         { TR_SEE_INVIS,          "See Invisible" },
 894         { TR_TELEPATHY,          "ESP" },
 895         { TR_ESP_ANIMAL,         "Sense Animal" },
 896         { TR_ESP_UNDEAD,         "Sense Undead" },
 897         { TR_ESP_DEMON,          "Sense Demon" },
 898         { TR_ESP_ORC,            "Sense Orc" },
 899         { TR_ESP_TROLL,          "Sense Troll" },
 900         { TR_ESP_GIANT,          "Sense Giant" },
 901         { TR_ESP_DRAGON,         "Sense Dragon" },
 902         { TR_ESP_HUMAN,          "Sense Human" },
 903         { TR_ESP_EVIL,           "Sense Evil" },
 904         { TR_ESP_GOOD,           "Sense Good" },
 905         { TR_ESP_NONLIVING,      "Sense Nonliving" },
 906         { TR_ESP_UNIQUE,         "Sense Unique" },
 907         { TR_SLOW_DIGEST,        "Slow Digestion" },
 908         { TR_REGEN,              "Regeneration" },
 909         { TR_WARNING,            "Warning" },
 910 /*      { TR_XTRA_MIGHT,         "Extra Might" }, */
 911         { TR_XTRA_SHOTS,         "+1 Extra Shot" },        /* always +1? */
 912         { TR_DRAIN_EXP,          "Drains Experience" },
 913         { TR_AGGRAVATE,          "Aggravates" },
 914         { TR_BLESSED,            "Blessed Blade" },
 915         { TR_DEC_MANA,           "Decrease Mana Consumption Rate" },
 916 #endif
 917 };
 918
 919
 920 /*
 921  * A special type used just for deailing with pvals
 922  */
 923 typedef struct
 924 {
 925         /*
 926          * This will contain a string such as "+2", "-10", etc.
 927          */
 928         char pval_desc[12];
 929
 930         /*
 931          * A list of various player traits affected by an object's pval such
 932          * as stats, speed, stealth, etc.  "Extra attacks" is NOT included in
 933          * this list since it will probably be desirable to format its
 934          * description differently.
 935          *
 936          * Note that room need only be reserved for the number of stats - 1
 937          * since the description "All stats" is used if an object affects all
 938          * all stats. Also, room must be reserved for a sentinel NULL pointer.
 939          *
 940          * This will be a list such as ["STR", "DEX", "Stealth", NULL] etc.
 941          *
 942          * This list includes extra attacks, for simplicity.
 943          */
 944         cptr pval_affects[N_ELEMENTS(stat_flags_desc) - 1 +
 945                           N_ELEMENTS(pval_flags1_desc) + 1];
 946
 947 } pval_info_type;
 948
 949
 950 /*
 951  * An "object analysis structure"
 952  *
 953  * It will be filled with descriptive strings detailing an object's
 954  * various magical powers. The "ignore X" traits are not noted since
 955  * all artifacts ignore "normal" destruction.
 956  */
 957
 958 typedef struct
 959 {
 960         /* "The Longsword Dragonsmiter (6d4) (+20, +25)" */
 961         char description[MAX_NLEN];
 962
 963         /* Description of what is affected by an object's pval */
 964         pval_info_type pval_info;
 965
 966         /* A list of an object's slaying preferences */
 967         cptr slays[N_ELEMENTS(slay_flags_desc) + 1];
 968
 969         /* A list if an object's elemental brands */
 970         cptr brands[N_ELEMENTS(brand_flags_desc) + 1];
 971
 972         /* A list of immunities granted by an object */
 973         cptr immunities[N_ELEMENTS(immune_flags_desc) + 1];
 974
 975         /* A list of resistances granted by an object */
 976         cptr resistances[N_ELEMENTS(resist_flags_desc) + 1];
 977
 978         /* A list of stats sustained by an object */
 979         cptr sustains[N_ELEMENTS(sustain_flags_desc)  - 1 + 1];
 980
 981         /* A list of various magical qualities an object may have */
 982         cptr misc_magic[N_ELEMENTS(misc_flags2_desc) + N_ELEMENTS(misc_flags3_desc)
 983                         + 1       /* Permanent Light */
 984                         + 1       /* TY curse */
 985                         + 1       /* type of curse */
 986                         + 1];     /* sentinel NULL */
 987
 988         /* Additional ability or resistance */
 989         char addition[80];
 990
 991         /* A string describing an artifact's activation */
 992         cptr activation;
 993
 994         /* "Level 20, Rarity 30, 3.0 lbs, 20000 Gold" */
 995         char misc_desc[80];
 996 } obj_desc_list;
 997
 998
 999 /*!
1000  * @brief ファイルポインタ先に同じ文字を複数出力する /
1001  * Write out `n' of the character `c' to the spoiler file
1002  * @param n 出力する数
1003  * @param c 出力するキャラクタ
1004  * @return なし
1005  */
1006 static void spoiler_out_n_chars(int n, char c)
1007 {
1008         while (--n >= 0) fputc(c, fff);
1009 }
1010
1011
1012 /*!
1013  * @brief ファイルポインタ先に改行を複数出力する /
1014  * Write out `n' blank lines to the spoiler file
1015  * @param n 改行を出力する数
1016  * @return なし
1017  */
1018 static void spoiler_blanklines(int n)
1019 {
1020         spoiler_out_n_chars(n, '\n');
1021 }
1022
1023
1024 /*!
1025  * @brief ファイルポインタ先に複数のハイフンで装飾した文字列を出力する /
1026  * Write a line to the spoiler file and then "underline" it with hypens
1027  * @param str 出力したい文字列
1028  * @return なし
1029  */
1030 static void spoiler_underline(cptr str)
1031 {
1032         fprintf(fff, "%s\n", str);
1033         spoiler_out_n_chars(strlen(str), '-');
1034         fprintf(fff, "\n");
1035 }
1036
1037
1038
1039 /*!
1040  * @brief アーティファクトの特性一覧を出力する /
1041  * Write a line to the spoiler file and then "underline" it with hypens
1042  * @param art_flags アーティファクトのフラグ群
1043  * @param flag_ptr フラグ記述情報の参照ポインタ
1044  * @param desc_ptr 記述内容を返すための文字列参照ポインタ
1045  * @param n_elmnts フラグの要素数
1046  * @return desc_ptrと同じアドレス
1047  * @details
1048  * <pre>
1049  * This function does most of the actual "analysis". Given a set of bit flags
1050  * (which will be from one of the flags fields from the object in question),
1051  * a "flag description structure", a "description list", and the number of
1052  * elements in the "flag description structure", this function sets the
1053  * "description list" members to the appropriate descriptions contained in
1054  * the "flag description structure".
1055  * The possibly updated description pointer is returned.
1056  * </pre>
1057  */
1058 static cptr *spoiler_flag_aux(const u32b art_flags[TR_FLAG_SIZE],
1059                               const flag_desc *flag_ptr,
1060                               cptr *desc_ptr, const int n_elmnts)
1061 {
1062         int i;
1063
1064         for (i = 0; i < n_elmnts; ++i)
1065         {
1066                 if (have_flag(art_flags, flag_ptr[i].flag))
1067                 {
1068                         *desc_ptr++ = flag_ptr[i].desc;
1069                 }
1070         }
1071
1072         return desc_ptr;
1073 }
1074
1075
1076 /*!
1077  * @brief アイテムの特定記述内容を返す /
1078  * Acquire a "basic" description "The Cloak of Death [1,+10]"
1079  * @param o_ptr 記述を得たいオブジェクトの参照ポインタ
1080  * @param desc_ptr 記述内容を返すための文字列参照ポインタ
1081  * @return なし
1082  */
1083 static void analyze_general(object_type *o_ptr, char *desc_ptr)
1084 {
1085         /* Get a "useful" description of the object */
1086         object_desc(desc_ptr, o_ptr, (OD_NAME_AND_ENCHANT | OD_STORE));
1087 }
1088
1089
1090 /*!
1091  * @brief アーティファクトがプレイヤーに与えるpval修正を構造体に収める /
1092  * List "player traits" altered by an artifact's pval. These include stats,
1093  * speed, infravision, tunneling, stealth, searching, and extra attacks.
1094  * @param o_ptr オブジェクト構造体の参照ポインタ
1095  * @param p_ptr pval修正構造体の参照ポインタ
1096  * @return なし
1097  */
1098 static void analyze_pval(object_type *o_ptr, pval_info_type *p_ptr)
1099 {
1100         u32b flgs[TR_FLAG_SIZE];
1101
1102         cptr *affects_list;
1103
1104         /* If pval == 0, there is nothing to do. */
1105         if (!o_ptr->pval)
1106         {
1107                 /* An "empty" pval description indicates that pval == 0 */
1108                 p_ptr->pval_desc[0] = '\0';
1109                 return;
1110         }
1111
1112         /* Extract the flags */
1113         object_flags(o_ptr, flgs);
1114
1115         affects_list = p_ptr->pval_affects;
1116
1117         /* Create the "+N" string */
1118         sprintf(p_ptr->pval_desc, "%s%d", POSITIZE(o_ptr->pval), o_ptr->pval);
1119
1120         /* First, check to see if the pval affects all stats */
1121         if (have_flag(flgs, TR_STR) && have_flag(flgs, TR_INT) &&
1122             have_flag(flgs, TR_WIS) && have_flag(flgs, TR_DEX) &&
1123             have_flag(flgs, TR_CON) && have_flag(flgs, TR_CHR))
1124         {
1125 #ifdef JP
1126                 *affects_list++ = "全能力";
1127 #else
1128                 *affects_list++ = "All stats";
1129 #endif
1130         }
1131
1132         /* Are any stats affected? */
1133         else if (have_flag(flgs, TR_STR) || have_flag(flgs, TR_INT) ||
1134                  have_flag(flgs, TR_WIS) || have_flag(flgs, TR_DEX) ||
1135                  have_flag(flgs, TR_CON) || have_flag(flgs, TR_CHR))
1136         {
1137                 affects_list = spoiler_flag_aux(flgs, stat_flags_desc,
1138                                                 affects_list,
1139                                                 N_ELEMENTS(stat_flags_desc));
1140         }
1141
1142         /* And now the "rest" */
1143         affects_list = spoiler_flag_aux(flgs, pval_flags1_desc,
1144                                         affects_list,
1145                                         N_ELEMENTS(pval_flags1_desc));
1146
1147         /* Terminate the description list */
1148         *affects_list = NULL;
1149 }
1150
1151 /*!
1152  * @brief アーティファクトの種族スレイ特性を構造体に収める /
1153  * Note the slaying specialties of a weapon
1154  * @param o_ptr オブジェクト構造体の参照ポインタ
1155  * @param slay_list 種族スレイ構造体の参照ポインタ
1156  * @return なし
1157  */
1158 static void analyze_slay(object_type *o_ptr, cptr *slay_list)
1159 {
1160         u32b flgs[TR_FLAG_SIZE];
1161
1162         object_flags(o_ptr, flgs);
1163
1164         slay_list = spoiler_flag_aux(flgs, slay_flags_desc, slay_list,
1165                                      N_ELEMENTS(slay_flags_desc));
1166
1167         /* Terminate the description list */
1168         *slay_list = NULL;
1169 }
1170
1171
1172 /*!
1173  * @brief アーティファクトの属性ブランド特性を構造体に収める /
1174  * Note an object's elemental brands
1175  * @param o_ptr オブジェクト構造体の参照ポインタ
1176  * @param brand_list 属性ブランド構造体の参照ポインタ
1177  * @return なし
1178  */
1179 static void analyze_brand(object_type *o_ptr, cptr *brand_list)
1180 {
1181         u32b flgs[TR_FLAG_SIZE];
1182
1183         object_flags(o_ptr, flgs);
1184
1185         brand_list = spoiler_flag_aux(flgs, brand_flags_desc, brand_list,
1186                                       N_ELEMENTS(brand_flags_desc));
1187
1188         /* Terminate the description list */
1189         *brand_list = NULL;
1190 }
1191
1192
1193 /*!
1194  * @brief アーティファクトの通常耐性を構造体に収める /
1195  * Note an object's elemental brands
1196  * @param o_ptr オブジェクト構造体の参照ポインタ
1197  * @param resist_list 通常耐性構造体の参照ポインタ
1198  * @return なし
1199  */
1200 static void analyze_resist(object_type *o_ptr, cptr *resist_list)
1201 {
1202         u32b flgs[TR_FLAG_SIZE];
1203
1204         object_flags(o_ptr, flgs);
1205
1206         resist_list = spoiler_flag_aux(flgs, resist_flags_desc,
1207                                        resist_list, N_ELEMENTS(resist_flags_desc));
1208
1209         /* Terminate the description list */
1210         *resist_list = NULL;
1211 }
1212
1213
1214 /*!
1215  * @brief アーティファクトの免疫特性を構造体に収める /
1216  * Note the immunities granted by an object
1217  * @param o_ptr オブジェクト構造体の参照ポインタ
1218  * @param immune_list 免疫構造体の参照ポインタ
1219  * @return なし
1220  */
1221 static void analyze_immune(object_type *o_ptr, cptr *immune_list)
1222 {
1223         u32b flgs[TR_FLAG_SIZE];
1224
1225         object_flags(o_ptr, flgs);
1226
1227         immune_list = spoiler_flag_aux(flgs, immune_flags_desc,
1228                                        immune_list, N_ELEMENTS(immune_flags_desc));
1229
1230         /* Terminate the description list */
1231         *immune_list = NULL;
1232 }
1233
1234
1235 /*!
1236  * @brief アーティファクトの維持特性を構造体に収める /
1237  * Note which stats an object sustains
1238  * @param o_ptr オブジェクト構造体の参照ポインタ
1239  * @param sustain_list 維持特性構造体の参照ポインタ
1240  * @return なし
1241  */
1242 static void analyze_sustains(object_type *o_ptr, cptr *sustain_list)
1243 {
1244         u32b flgs[TR_FLAG_SIZE];
1245
1246         object_flags(o_ptr, flgs);
1247
1248         /* Simplify things if an item sustains all stats */
1249         if (have_flag(flgs, TR_SUST_STR) && have_flag(flgs, TR_SUST_INT) &&
1250             have_flag(flgs, TR_SUST_WIS) && have_flag(flgs, TR_SUST_DEX) &&
1251             have_flag(flgs, TR_SUST_CON) && have_flag(flgs, TR_SUST_CHR))
1252         {
1253 #ifdef JP
1254                 *sustain_list++ = "全能力";
1255 #else
1256                 *sustain_list++ = "All stats";
1257 #endif
1258         }
1259
1260         /* Should we bother? */
1261         else if (have_flag(flgs, TR_SUST_STR) || have_flag(flgs, TR_SUST_INT) ||
1262                  have_flag(flgs, TR_SUST_WIS) || have_flag(flgs, TR_SUST_DEX) ||
1263                  have_flag(flgs, TR_SUST_CON) || have_flag(flgs, TR_SUST_CHR))
1264         {
1265                 sustain_list = spoiler_flag_aux(flgs, sustain_flags_desc,
1266                                                 sustain_list,
1267                                                 N_ELEMENTS(sustain_flags_desc));
1268         }
1269
1270         /* Terminate the description list */
1271         *sustain_list = NULL;
1272 }
1273
1274
1275 /*!
1276  * @brief アーティファクトのその他の特性を構造体に収める /
1277  * Note miscellaneous powers bestowed by an artifact such as see invisible,
1278  * free action, permanent light, etc.
1279  * @param o_ptr オブジェクト構造体の参照ポインタ
1280  * @param misc_list その他の特性構造体の参照ポインタ
1281  * @return なし
1282  */
1283 static void analyze_misc_magic(object_type *o_ptr, cptr *misc_list)
1284 {
1285         u32b flgs[TR_FLAG_SIZE];
1286         int rad;
1287         char desc[256];
1288
1289         object_flags(o_ptr, flgs);
1290
1291         misc_list = spoiler_flag_aux(flgs, misc_flags2_desc, misc_list,
1292                                      N_ELEMENTS(misc_flags2_desc));
1293
1294         misc_list = spoiler_flag_aux(flgs, misc_flags3_desc, misc_list,
1295                                      N_ELEMENTS(misc_flags3_desc));
1296
1297         /*
1298          * Glowing artifacts -- small radius light.
1299         */
1300         rad = 0;
1301         if (have_flag(flgs, TR_LITE_1))  rad += 1;
1302         if (have_flag(flgs, TR_LITE_2))  rad += 2;
1303         if (have_flag(flgs, TR_LITE_3))  rad += 3;
1304         if (have_flag(flgs, TR_LITE_M1)) rad -= 1;
1305         if (have_flag(flgs, TR_LITE_M2)) rad -= 2;
1306         if (have_flag(flgs, TR_LITE_M3)) rad -= 3;
1307
1308         if(o_ptr->name2 == EGO_LITE_SHINE) rad++;
1309
1310         if (have_flag(flgs, TR_LITE_FUEL))
1311         {
1312                 if(rad > 0) sprintf(desc, _("それは燃料補給によって明かり(半径 %d)を授ける。", "It provides light (radius %d) when fueled."), rad);
1313         }
1314         else
1315         {
1316                 if(rad > 0) sprintf(desc, _("永久光源(半径 %d)", "Permanent Light(radius %d)"), rad);
1317                 if(rad < 0) sprintf(desc, _("永久光源(半径-%d)。", "Permanent Light(radius -%d)"), -rad);
1318         }
1319
1320         if(rad != 0) *misc_list++ = quark_str(quark_add(desc));
1321
1322         /*
1323          * Handle cursed objects here to avoid redundancies such as noting
1324          * that a permanently cursed object is heavily cursed as well as
1325          * being "lightly cursed".
1326          */
1327
1328 /*      if (object_is_cursed(o_ptr)) */
1329         {
1330                 if (have_flag(flgs, TR_TY_CURSE))
1331                 {
1332                         *misc_list++ = _("太古の怨念", "Ancient Curse");
1333                 }
1334                 if (o_ptr->curse_flags & TRC_PERMA_CURSE)
1335                 {
1336                         *misc_list++ = _("永遠の呪い", "Permanently Cursed");
1337                 }
1338                 else if (o_ptr->curse_flags & TRC_HEAVY_CURSE)
1339                 {
1340                         *misc_list++ = _("強力な呪い", "Heavily Cursed");
1341                 }
1342 /*              else */
1343                 else if (o_ptr->curse_flags & TRC_CURSED)
1344                 {
1345                         *misc_list++ = _("呪い", "Cursed");
1346                 }
1347                 if (have_flag(flgs, TR_ADD_L_CURSE))
1348                 {
1349                         *misc_list++ = _("呪いを増やす", "Cursing");
1350                 }
1351                 if (have_flag(flgs, TR_ADD_H_CURSE))
1352                 {
1353                         *misc_list++ = _("強力な呪いを増やす", "Heavily Cursing");
1354                 }
1355         }
1356
1357         /* Terminate the description list */
1358         *misc_list = NULL;
1359 }
1360
1361
1362 /*!
1363  * @brief アーティファクトの追加ランダム特性を構造体に収める /
1364  * Note additional ability and/or resistance of fixed artifacts
1365  * @param o_ptr オブジェクト構造体の参照ポインタ
1366  * @param addition 追加ランダム耐性構造体の参照ポインタ
1367  * @return なし
1368  */
1369 static void analyze_addition(object_type *o_ptr, char *addition)
1370 {
1371         artifact_type *a_ptr = &a_info[o_ptr->name1];
1372
1373         /* Init */
1374         strcpy(addition, "");
1375
1376 #ifdef JP
1377         if ((a_ptr->gen_flags & TRG_XTRA_POWER) && (a_ptr->gen_flags & TRG_XTRA_H_RES)) strcat(addition, "能力and耐性");
1378         else if (a_ptr->gen_flags & TRG_XTRA_POWER)
1379         {
1380                 strcat(addition, "能力");
1381                 if (a_ptr->gen_flags & TRG_XTRA_RES_OR_POWER) strcat(addition, "(1/2でand耐性)");
1382         }
1383         else if (a_ptr->gen_flags & TRG_XTRA_H_RES)
1384         {
1385                 strcat(addition, "耐性");
1386                 if (a_ptr->gen_flags & TRG_XTRA_RES_OR_POWER) strcat(addition, "(1/2でand能力)");
1387         }
1388         else if (a_ptr->gen_flags & TRG_XTRA_RES_OR_POWER) strcat(addition, "能力or耐性");
1389 #else
1390         if ((a_ptr->gen_flags & TRG_XTRA_POWER) && (a_ptr->gen_flags & TRG_XTRA_H_RES)) strcat(addition, "Ability and Resistance");
1391         else if (a_ptr->gen_flags & TRG_XTRA_POWER)
1392         {
1393                 strcat(addition, "Ability");
1394                 if (a_ptr->gen_flags & TRG_XTRA_RES_OR_POWER) strcat(addition, "(plus Resistance about 1/2)");
1395         }
1396         else if (a_ptr->gen_flags & TRG_XTRA_H_RES)
1397         {
1398                 strcat(addition, "Resistance");
1399                 if (a_ptr->gen_flags & TRG_XTRA_RES_OR_POWER) strcat(addition, "(plus Ability about 1/2)");
1400         }
1401         else if (a_ptr->gen_flags & TRG_XTRA_RES_OR_POWER) strcat(addition, "Ability or Resistance");
1402 #endif
1403 }
1404
1405
1406 /*!
1407  * @brief アーティファクトの基本情報を文字列に収める /
1408  * Determine the minimum depth an artifact can appear, its rarity, its weight,
1409  * and its value in gold pieces
1410  * @param o_ptr オブジェクト構造体の参照ポインタ
1411  * @param misc_desc 基本情報を収める文字列参照ポインタ
1412  * @return なし
1413  */
1414 static void analyze_misc(object_type *o_ptr, char *misc_desc)
1415 {
1416         artifact_type *a_ptr = &a_info[o_ptr->name1];
1417
1418 #ifdef JP
1419         sprintf(misc_desc, "レベル %u, 希少度 %u, %d.%d kg, ＄%ld",
1420                 a_ptr->level, a_ptr->rarity,
1421                 lbtokg1(a_ptr->weight), lbtokg2(a_ptr->weight), (long int)a_ptr->cost);
1422 #else
1423         sprintf(misc_desc, "Level %u, Rarity %u, %d.%d lbs, %ld Gold",
1424                 a_ptr->level, a_ptr->rarity,
1425                 a_ptr->weight / 10, a_ptr->weight % 10, a_ptr->cost);
1426 #endif
1427 }
1428
1429
1430 /*!
1431  * @brief アーティファクトの情報全体を構造体に収める /
1432  * Fill in an object description structure for a given object
1433  * and its value in gold pieces
1434  * @param o_ptr オブジェクト構造体の参照ポインタ
1435  * @param desc_ptr 全アーティファクト情報を収める文字列参照ポインタ
1436  * @return なし
1437  */
1438 static void object_analyze(object_type *o_ptr, obj_desc_list *desc_ptr)
1439 {
1440         analyze_general(o_ptr, desc_ptr->description);
1441         analyze_pval(o_ptr, &desc_ptr->pval_info);
1442         analyze_brand(o_ptr, desc_ptr->brands);
1443         analyze_slay(o_ptr, desc_ptr->slays);
1444         analyze_immune(o_ptr, desc_ptr->immunities);
1445         analyze_resist(o_ptr, desc_ptr->resistances);
1446         analyze_sustains(o_ptr, desc_ptr->sustains);
1447         analyze_misc_magic(o_ptr, desc_ptr->misc_magic);
1448         analyze_addition(o_ptr, desc_ptr->addition);
1449         analyze_misc(o_ptr, desc_ptr->misc_desc);
1450         desc_ptr->activation = item_activation(o_ptr);
1451 }
1452
1453
1454 /*!
1455  * @brief バッファにアーティファクト出力情報ヘッダを収める /
1456  * @return なし
1457  */
1458 static void print_header(void)
1459 {
1460         char buf[80];
1461
1462         sprintf(buf, "Artifact Spoilers for Hengband Version %d.%d.%d",
1463                 FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
1464         spoiler_underline(buf);
1465 }
1466
1467 /*
1468  * This is somewhat ugly.
1469  *
1470  * Given a header ("Resist", e.g.), a list ("Fire", "Cold", Acid", e.g.),
1471  * and a separator character (',', e.g.), write the list to the spoiler file
1472  * in a "nice" format, such as:
1473  *
1474  *      Resist Fire, Cold, Acid
1475  *
1476  * That was a simple example, but when the list is long, a line wrap
1477  * should occur, and this should induce a new level of indention if
1478  * a list is being spread across lines. So for example, Bladeturner's
1479  * list of resistances should look something like this
1480  *
1481  *     Resist Acid, Lightning, Fire, Cold, Poison, Light, Dark, Blindness,
1482  *       Confusion, Sound, Shards, Nether, Nexus, Chaos, Disenchantment
1483  *
1484  * However, the code distinguishes between a single list of many items vs.
1485  * many lists. (The separator is used to make this determination.) A single
1486  * list of many items will not cause line wrapping (since there is no
1487  * apparent reason to do so). So the lists of Ulmo's miscellaneous traits
1488  * might look like this:
1489  *
1490  *     Free Action; Hold Life; See Invisible; Slow Digestion; Regeneration
1491  *     Blessed Blade
1492  *
1493  * So comparing the two, "Regeneration" has no trailing separator and
1494  * "Blessed Blade" was not indented. (Also, Ulmo's lists have no headers,
1495  * but that's not relevant to line wrapping and indention.)
1496  */
1497
1498 /* ITEM_SEP separates items within a list */
1499 #define ITEM_SEP ','
1500
1501
1502 /* LIST_SEP separates lists */
1503 #ifdef JP
1504 #define LIST_SEP ','
1505 #else
1506 #define LIST_SEP ';'
1507 #endif
1508
1509 /*!
1510  * @brief フラグ名称を出力する汎用関数
1511  * @param header ヘッダに出力するフラグ群の名前
1512  * @param list フラグ名リスト
1513  * @param separator フラグ表示の区切り記号
1514  * @return なし
1515  */
1516 static void spoiler_outlist(cptr header, cptr *list, char separator)
1517 {
1518         int line_len, buf_len;
1519         char line[MAX_LINE_LEN+1], buf[80];
1520
1521         /* Ignore an empty list */
1522         if (*list == NULL) return;
1523
1524         /* This function always indents */
1525         strcpy(line, INDENT1);
1526
1527         /* Create header (if one was given) */
1528         if (header && (header[0]))
1529         {
1530                 strcat(line, header);
1531                 strcat(line, " ");
1532         }
1533
1534         line_len = strlen(line);
1535
1536         /* Now begin the tedious task */
1537         while (1)
1538         {
1539                 /* Copy the current item to a buffer */
1540                 strcpy(buf, *list);
1541
1542                 /* Note the buffer's length */
1543                 buf_len = strlen(buf);
1544
1545                 /*
1546                  * If there is an item following this one, pad with separator and
1547                  * a space and adjust the buffer length
1548                  */
1549
1550                 if (list[1])
1551                 {
1552                         sprintf(buf + buf_len, "%c ", separator);
1553                         buf_len += 2;
1554                 }
1555
1556                 /*
1557                  * If the buffer will fit on the current line, just append the
1558                  * buffer to the line and adjust the line length accordingly.
1559                  */
1560
1561                 if (line_len + buf_len <= MAX_LINE_LEN)
1562                 {
1563                         strcat(line, buf);
1564                         line_len += buf_len;
1565                 }
1566
1567                 /* Apply line wrapping and indention semantics described above */
1568                 else
1569                 {
1570                         /*
1571                          * Don't print a trailing list separator but do print a trailing
1572                          * item separator.
1573                          */
1574                         if (line_len > 1 && line[line_len - 1] == ' '
1575                             && line[line_len - 2] == LIST_SEP)
1576                         {
1577                                 /* Ignore space and separator */
1578                                 line[line_len - 2] = '\0';
1579
1580                                 /* Write to spoiler file */
1581                                 fprintf(fff, "%s\n", line);
1582
1583                                 /* Begin new line at primary indention level */
1584                                 sprintf(line, "%s%s", INDENT1, buf);
1585                         }
1586
1587                         else
1588                         {
1589                                 /* Write to spoiler file */
1590                                 fprintf(fff, "%s\n", line);
1591
1592                                 /* Begin new line at secondary indention level */
1593                                 sprintf(line, "%s%s", INDENT2, buf);
1594                         }
1595
1596                         line_len = strlen(line);
1597                 }
1598
1599                 /* Advance, with break */
1600                 if (!*++list) break;
1601         }
1602
1603         /* Write what's left to the spoiler file */
1604         fprintf(fff, "%s\n", line);
1605 }
1606
1607 /*!
1608  * @brief アーティファクト一件をスポイラー出力する /
1609  * Create a spoiler file entry for an artifact
1610  * @param art_ptr アーティファクト情報をまとめた構造体の参照ポインタ
1611  * @return なし
1612  */
1613 static void spoiler_print_art(obj_desc_list *art_ptr)
1614 {
1615         pval_info_type *pval_ptr = &art_ptr->pval_info;
1616
1617         char buf[80];
1618
1619         /* Don't indent the first line */
1620         fprintf(fff, "%s\n", art_ptr->description);
1621
1622         /* An "empty" pval description indicates that the pval affects nothing */
1623         if (pval_ptr->pval_desc[0])
1624         {
1625                 /* Mention the effects of pval */
1626 #ifdef JP
1627                 sprintf(buf, "%sの修正:", pval_ptr->pval_desc);
1628 #else
1629                 sprintf(buf, "%s to", pval_ptr->pval_desc);
1630 #endif
1631                 spoiler_outlist(buf, pval_ptr->pval_affects, ITEM_SEP);
1632         }
1633
1634         /* Now deal with the description lists */
1635
1636 #ifdef JP
1637         spoiler_outlist("対:", art_ptr->slays, ITEM_SEP);
1638         spoiler_outlist("武器属性:", art_ptr->brands, LIST_SEP);
1639         spoiler_outlist("免疫:", art_ptr->immunities, ITEM_SEP);
1640         spoiler_outlist("耐性:", art_ptr->resistances, ITEM_SEP);
1641         spoiler_outlist("維持:", art_ptr->sustains, ITEM_SEP);
1642 #else
1643         spoiler_outlist("Slay", art_ptr->slays, ITEM_SEP);
1644         spoiler_outlist("", art_ptr->brands, LIST_SEP);
1645         spoiler_outlist("Immunity to", art_ptr->immunities, ITEM_SEP);
1646         spoiler_outlist("Resist", art_ptr->resistances, ITEM_SEP);
1647         spoiler_outlist("Sustain", art_ptr->sustains, ITEM_SEP);
1648 #endif
1649         spoiler_outlist("", art_ptr->misc_magic, LIST_SEP);
1650
1651         if (art_ptr->addition[0])
1652         {
1653 #ifdef JP
1654                 fprintf(fff, "%s追加: %s\n", INDENT1, art_ptr->addition);
1655 #else
1656                 fprintf(fff, "%sAdditional %s\n", INDENT1, art_ptr->addition);
1657 #endif
1658         }
1659
1660         /* Write out the possible activation at the primary indention level */
1661         if (art_ptr->activation)
1662         {
1663 #ifdef JP
1664                 fprintf(fff, "%s発動: %s\n", INDENT1, art_ptr->activation);
1665 #else
1666                 fprintf(fff, "%sActivates for %s\n", INDENT1, art_ptr->activation);
1667 #endif
1668         }
1669
1670         /* End with the miscellaneous facts */
1671         fprintf(fff, "%s%s\n\n", INDENT1, art_ptr->misc_desc);
1672 }
1673
1674
1675 /*!
1676  * @brief アーティファクト情報を出力するためにダミー生成を行う /
1677  * Hack -- Create a "forged" artifact
1678  * @param o_ptr 一時生成先を保管するオブジェクト構造体
1679  * @param name1 生成するアーティファクトID
1680  * @return 生成が成功した場合TRUEを返す
1681  */
1682 static bool make_fake_artifact(object_type *o_ptr, int name1)
1683 {
1684         int i;
1685
1686         artifact_type *a_ptr = &a_info[name1];
1687
1688
1689         /* Ignore "empty" artifacts */
1690         if (!a_ptr->name) return FALSE;
1691
1692         /* Acquire the "kind" index */
1693         i = lookup_kind(a_ptr->tval, a_ptr->sval);
1694
1695         /* Oops */
1696         if (!i) return (FALSE);
1697
1698         /* Create the artifact */
1699         object_prep(o_ptr, i);
1700
1701         /* Save the name */
1702         o_ptr->name1 = name1;
1703
1704         /* Extract the fields */
1705         o_ptr->pval = a_ptr->pval;
1706         o_ptr->ac = a_ptr->ac;
1707         o_ptr->dd = a_ptr->dd;
1708         o_ptr->ds = a_ptr->ds;
1709         o_ptr->to_a = a_ptr->to_a;
1710         o_ptr->to_h = a_ptr->to_h;
1711         o_ptr->to_d = a_ptr->to_d;
1712         o_ptr->weight = a_ptr->weight;
1713
1714         /* Success */
1715         return (TRUE);
1716 }
1717
1718
1719 /*!
1720  * @brief アーティファクト情報のスポイラー出力を行うメインルーチン /
1721  * Create a spoiler file for artifacts
1722  * @param fname 生成ファイル名
1723  * @return なし
1724  */
1725 static void spoil_artifact(cptr fname)
1726 {
1727         int i, j;
1728
1729         object_type forge;
1730         object_type *q_ptr;
1731
1732         obj_desc_list artifact;
1733
1734         char buf[1024];
1735
1736
1737         /* Build the filename */
1738         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, fname);
1739
1740         /* File type is "TEXT" */
1741         FILE_TYPE(FILE_TYPE_TEXT);
1742
1743         /* Open the file */
1744         fff = my_fopen(buf, "w");
1745
1746         /* Oops */
1747         if (!fff)
1748         {
1749                 msg_print("Cannot create spoiler file.");
1750                 return;
1751         }
1752
1753         /* Dump the header */
1754         print_header();
1755
1756         /* List the artifacts by tval */
1757         for (i = 0; group_artifact[i].tval; i++)
1758         {
1759                 /* Write out the group title */
1760                 if (group_artifact[i].name)
1761                 {
1762                         spoiler_blanklines(2);
1763                         spoiler_underline(group_artifact[i].name);
1764                         spoiler_blanklines(1);
1765                 }
1766
1767                 /* Now search through all of the artifacts */
1768                 for (j = 1; j < max_a_idx; ++j)
1769                 {
1770                         artifact_type *a_ptr = &a_info[j];
1771
1772                         /* We only want objects in the current group */
1773                         if (a_ptr->tval != group_artifact[i].tval) continue;
1774
1775                         /* Get local object */
1776                         q_ptr = &forge;
1777
1778                         /* Wipe the object */
1779                         object_wipe(q_ptr);
1780
1781                         /* Attempt to "forge" the artifact */
1782                         if (!make_fake_artifact(q_ptr, j)) continue;
1783
1784                         /* Analyze the artifact */
1785                         object_analyze(q_ptr, &artifact);
1786
1787                         /* Write out the artifact description to the spoiler file */
1788                         spoiler_print_art(&artifact);
1789                 }
1790         }
1791
1792         /* Check for errors */
1793         if (ferror(fff) || my_fclose(fff))
1794         {
1795                 msg_print("Cannot close spoiler file.");
1796                 return;
1797         }
1798
1799         /* Message */
1800         msg_print("Successfully created a spoiler file.");
1801 }
1802
1803
1804 /*!
1805  * @brief モンスター簡易情報のスポイラー出力を行うメインルーチン /
1806  * Create a spoiler file for monsters   -BEN-
1807  * @param fname 生成ファイル名
1808  * @return なし
1809  */
1810 static void spoil_mon_desc(cptr fname)
1811 {
1812         int i, n = 0;
1813
1814         u16b why = 2;
1815         s16b *who;
1816
1817         char buf[1024];
1818
1819         char nam[80];
1820         char lev[80];
1821         char rar[80];
1822         char spd[80];
1823         char ac[80];
1824         char hp[80];
1825         char exp[80];
1826
1827         /* Build the filename */
1828         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, fname);
1829
1830         /* File type is "TEXT" */
1831         FILE_TYPE(FILE_TYPE_TEXT);
1832
1833         /* Open the file */
1834         fff = my_fopen(buf, "w");
1835
1836         /* Oops */
1837         if (!fff)
1838         {
1839                 msg_print("Cannot create spoiler file.");
1840                 return;
1841         }
1842
1843         /* Allocate the "who" array */
1844         C_MAKE(who, max_r_idx, s16b);
1845
1846         /* Dump the header */
1847         fprintf(fff, "Monster Spoilers for Hengband Version %d.%d.%d\n",
1848                 FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
1849         fprintf(fff, "------------------------------------------\n\n");
1850
1851         /* Dump the header */
1852         fprintf(fff, "    %-38.38s%4s%4s%4s%7s%5s  %11.11s\n",
1853                 "Name", "Lev", "Rar", "Spd", "Hp", "Ac", "Visual Info");
1854         fprintf(fff, "%-42.42s%4s%4s%4s%7s%5s  %11.11s\n",
1855                 "--------", "---", "---", "---", "--", "--", "-----------");
1856
1857
1858         /* Scan the monsters */
1859         for (i = 1; i < max_r_idx; i++)
1860         {
1861                 monster_race *r_ptr = &r_info[i];
1862
1863                 /* Use that monster */
1864                 if (r_ptr->name) who[n++] = i;
1865         }
1866
1867         /* Select the sort method */
1868         ang_sort_comp = ang_sort_comp_hook;
1869         ang_sort_swap = ang_sort_swap_hook;
1870
1871         /* Sort the array by dungeon depth of monsters */
1872         ang_sort(who, &why, n);
1873
1874         /* Scan again */
1875         for (i = 0; i < n; i++)
1876         {
1877                 monster_race *r_ptr = &r_info[who[i]];
1878
1879                 cptr name = (r_name + r_ptr->name);
1880                 if (r_ptr->flags7 & (RF7_KAGE)) continue;
1881
1882                 /* Get the "name" */
1883                 /*
1884                 else if (r_ptr->flags1 & (RF1_QUESTOR))
1885                 {
1886                         sprintf(nam, "[Q] %s", name);
1887                 }
1888                 */
1889                 else if (r_ptr->flags1 & (RF1_UNIQUE))
1890                 {
1891                         sprintf(nam, "[U] %s", name);
1892                 }
1893                 else
1894                 {
1895 #ifdef JP
1896                         sprintf(nam, "    %s", name);
1897 #else
1898                         sprintf(nam, "The %s", name);
1899 #endif
1900                 }
1901
1902
1903                 /* Level */
1904                 sprintf(lev, "%d", r_ptr->level);
1905
1906                 /* Rarity */
1907                 sprintf(rar, "%d", r_ptr->rarity);
1908
1909                 /* Speed */
1910                 if (r_ptr->speed >= 110)
1911                 {
1912                         sprintf(spd, "+%d", (r_ptr->speed - 110));
1913                 }
1914                 else
1915                 {
1916                         sprintf(spd, "-%d", (110 - r_ptr->speed));
1917                 }
1918
1919                 /* Armor Class */
1920                 sprintf(ac, "%d", r_ptr->ac);
1921
1922                 /* Hitpoints */
1923                 if ((r_ptr->flags1 & (RF1_FORCE_MAXHP)) || (r_ptr->hside == 1))
1924                 {
1925                         sprintf(hp, "%d", r_ptr->hdice * r_ptr->hside);
1926                 }
1927                 else
1928                 {
1929                         sprintf(hp, "%dd%d", r_ptr->hdice, r_ptr->hside);
1930                 }
1931
1932
1933                 /* Experience */
1934                 sprintf(exp, "%ld", (long)(r_ptr->mexp));
1935
1936                 /* Hack -- use visual instead */
1937                 sprintf(exp, "%s '%c'", attr_to_text(r_ptr), r_ptr->d_char);
1938
1939                 /* Dump the info */
1940                 fprintf(fff, "%-42.42s%4s%4s%4s%7s%5s  %11.11s\n",
1941                         nam, lev, rar, spd, hp, ac, exp);
1942         }
1943
1944         /* End it */
1945         fprintf(fff, "\n");
1946
1947
1948         /* Free the "who" array */
1949         C_KILL(who, max_r_idx, s16b);
1950
1951         /* Check for errors */
1952         if (ferror(fff) || my_fclose(fff))
1953         {
1954                 msg_print("Cannot close spoiler file.");
1955                 return;
1956         }
1957
1958         /* Worked */
1959         msg_print("Successfully created a spoiler file.");
1960 }
1961
1962
1963
1964
1965 /*
1966  * Monster spoilers by: smchorse@ringer.cs.utsa.edu (Shawn McHorse)
1967  *
1968  * Primarily based on code already in mon-desc.c, mostly by -BEN-
1969  */
1970
1971
1972
1973 /*!
1974  * @brief 文字列をファイルポインタに出力する /
1975  * Buffer text to the given file. (-SHAWN-)
1976  * This is basically c_roff() from mon-desc.c with a few changes.
1977  * @param str 文字列参照ポインタ
1978  * @return なし
1979  */
1980 static void spoil_out(cptr str)
1981 {
1982         cptr r;
1983
1984         /* Line buffer */
1985         static char roff_buf[256];
1986
1987         /* Delay buffer */
1988         static char roff_waiting_buf[256];
1989
1990 #ifdef JP
1991         bool iskanji_flag = FALSE;
1992 #endif
1993         /* Current pointer into line roff_buf */
1994         static char *roff_p = roff_buf;
1995
1996         /* Last space saved into roff_buf */
1997         static char *roff_s = NULL;
1998
1999         /* Mega-Hack -- Delayed output */
2000         static bool waiting_output = FALSE;
2001
2002         /* Special handling for "new sequence" */
2003         if (!str)
2004         {
2005                 if (waiting_output)
2006                 {
2007                         fputs(roff_waiting_buf, fff);
2008                         waiting_output = FALSE;
2009                 }
2010
2011                 if (roff_p != roff_buf) roff_p--;
2012                 while (*roff_p == ' ' && roff_p != roff_buf) roff_p--;
2013
2014                 if (roff_p == roff_buf) fprintf(fff, "\n");
2015                 else
2016                 {
2017                         *(roff_p + 1) = '\0';
2018                         fprintf(fff, "%s\n\n", roff_buf);
2019                 }
2020
2021                 roff_p = roff_buf;
2022                 roff_s = NULL;
2023                 roff_buf[0] = '\0';
2024                 return;
2025         }
2026
2027         /* Scan the given string, character at a time */
2028         for (; *str; str++)
2029         {
2030 #ifdef JP
2031                 char cbak;
2032                 bool k_flag = iskanji((unsigned char)(*str));
2033 #endif
2034                 char ch = *str;
2035                 bool wrap = (ch == '\n');
2036
2037 #ifdef JP
2038                 if (!isprint(ch) && !k_flag && !iskanji_flag) ch = ' ';
2039                 iskanji_flag = k_flag && !iskanji_flag;
2040 #else
2041                 if (!isprint(ch)) ch = ' ';
2042 #endif
2043
2044                 if (waiting_output)
2045                 {
2046                         fputs(roff_waiting_buf, fff);
2047                         if (!wrap) fputc('\n', fff);
2048                         waiting_output = FALSE;
2049                 }
2050
2051                 if (!wrap)
2052                 {
2053 #ifdef JP
2054                         if (roff_p >= roff_buf + (k_flag ? 74 : 75)) wrap = TRUE;
2055                         else if ((ch == ' ') && (roff_p >= roff_buf + (k_flag ? 72 : 73))) wrap = TRUE;
2056 #else
2057                         if (roff_p >= roff_buf + 75) wrap = TRUE;
2058                         else if ((ch == ' ') && (roff_p >= roff_buf + 73)) wrap = TRUE;
2059 #endif
2060
2061                         if (wrap)
2062                         {
2063 #ifdef JP
2064                                 bool k_flag_local;
2065                                 bool iskanji_flag_local = FALSE;
2066                                 cptr tail = str + (k_flag ? 2 : 1);
2067 #else
2068                                 cptr tail = str + 1;
2069 #endif
2070
2071                                 for (; *tail; tail++)
2072                                 {
2073                                         if (*tail == ' ') continue;
2074
2075 #ifdef JP
2076                                         k_flag_local = iskanji((unsigned char)(*tail));
2077                                         if (isprint(*tail) || k_flag_local || iskanji_flag_local) break;
2078                                         iskanji_flag_local = k_flag_local && !iskanji_flag_local;
2079 #else
2080                                         if (isprint(*tail)) break;
2081 #endif
2082                                 }
2083
2084                                 if (!*tail) waiting_output = TRUE;
2085                         }
2086                 }
2087
2088                 /* Handle line-wrap */
2089                 if (wrap)
2090                 {
2091                         *roff_p = '\0';
2092                         r = roff_p;
2093 #ifdef JP
2094                         cbak = ' ';
2095 #endif
2096                         if (roff_s && (ch != ' '))
2097                         {
2098 #ifdef JP
2099                                 cbak = *roff_s;
2100 #endif
2101                                 *roff_s = '\0';
2102                                 r = roff_s + 1;
2103                         }
2104                         if (!waiting_output) fprintf(fff, "%s\n", roff_buf);
2105                         else strcpy(roff_waiting_buf, roff_buf);
2106                         roff_s = NULL;
2107                         roff_p = roff_buf;
2108 #ifdef JP
2109                         if (cbak != ' ') *roff_p++ = cbak;
2110 #endif
2111                         while (*r) *roff_p++ = *r++;
2112                 }
2113
2114                 /* Save the char */
2115                 if ((roff_p > roff_buf) || (ch != ' '))
2116                 {
2117 #ifdef JP
2118                         if (!k_flag)
2119                         {
2120                                 if ((ch == ' ') || (ch == '(')) roff_s = roff_p;
2121                         }
2122                         else
2123                         {
2124                                 if (iskanji_flag &&
2125                                     strncmp(str, "。", 2) != 0 &&
2126                                     strncmp(str, "、", 2) != 0 &&
2127                                     strncmp(str, "ィ", 2) != 0 &&
2128                                     strncmp(str, "ー", 2) != 0) roff_s = roff_p;
2129                         }
2130 #else
2131                         if (ch == ' ') roff_s = roff_p;
2132 #endif
2133
2134                         *roff_p++ = ch;
2135                 }
2136         }
2137 }
2138
2139
2140
2141 /*!
2142  * @brief 関数ポインタ用の出力関数 /
2143  * Hook function used in spoil_mon_info()
2144  * @param attr 未使用
2145  * @param str 文字列参照ポインタ
2146  * @return なし
2147  */
2148 static void roff_func(byte attr, cptr str)
2149 {
2150         /* Unused */
2151         (void)attr;
2152
2153         spoil_out(str);
2154 }
2155
2156
2157 /*!
2158  * @brief モンスター詳細情報をスポイラー出力するメインルーチン /
2159  * Create a spoiler file for monsters (-SHAWN-)
2160  * @param fname ファイル名
2161  * @return なし
2162  */
2163 static void spoil_mon_info(cptr fname)
2164 {
2165         char buf[1024];
2166         int i, l, n = 0;
2167         u32b flags1;
2168
2169         u16b why = 2;
2170         s16b *who;
2171
2172         /* Build the filename */
2173         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, fname);
2174
2175         /* File type is "TEXT" */
2176         FILE_TYPE(FILE_TYPE_TEXT);
2177
2178         /* Open the file */
2179         fff = my_fopen(buf, "w");
2180
2181         /* Oops */
2182         if (!fff)
2183         {
2184                 msg_print("Cannot create spoiler file.");
2185                 return;
2186         }
2187
2188
2189         /* Dump the header */
2190         sprintf(buf, "Monster Spoilers for Hengband Version %d.%d.%d\n",
2191              FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
2192
2193         spoil_out(buf);
2194         spoil_out("------------------------------------------\n\n");
2195
2196         /* Allocate the "who" array */
2197         C_MAKE(who, max_r_idx, s16b);
2198
2199         /* Scan the monsters */
2200         for (i = 1; i < max_r_idx; i++)
2201         {
2202                 monster_race *r_ptr = &r_info[i];
2203
2204                 /* Use that monster */
2205                 if (r_ptr->name) who[n++] = i;
2206         }
2207
2208         /* Select the sort method */
2209         ang_sort_comp = ang_sort_comp_hook;
2210         ang_sort_swap = ang_sort_swap_hook;
2211
2212         /* Sort the array by dungeon depth of monsters */
2213         ang_sort(who, &why, n);
2214
2215
2216         /*
2217          * List all monsters in order
2218          */
2219         for (l = 0; l < n; l++)
2220         {
2221                 monster_race *r_ptr = &r_info[who[l]];
2222
2223                 /* Extract the flags */
2224                 flags1 = r_ptr->flags1;
2225
2226                 /* Prefix */
2227                 /*
2228                 if (flags1 & (RF1_QUESTOR))
2229                 {
2230                         spoil_out("[Q] ");
2231                 }
2232                 else
2233                 */
2234                 if (flags1 & (RF1_UNIQUE))
2235                 {
2236                         spoil_out("[U] ");
2237                 }
2238                 else
2239                 {
2240 #ifndef JP
2241                         spoil_out("The ");
2242 #endif
2243                 }
2244
2245                 /* Name */
2246 #ifdef JP
2247                 sprintf(buf, "%s/%s  (", (r_name + r_ptr->name),(r_name+r_ptr->E_name));  /* ---)--- */
2248 #else
2249                 sprintf(buf, "%s  (", (r_name + r_ptr->name));  /* ---)--- */
2250 #endif
2251
2252                 spoil_out(buf);
2253
2254                 /* Color */
2255                 spoil_out(attr_to_text(r_ptr));
2256
2257                 /* Symbol --(-- */
2258                 sprintf(buf, " '%c')\n", r_ptr->d_char);
2259                 spoil_out(buf);
2260
2261
2262                 /* Indent */
2263                 sprintf(buf, "=== ");
2264                 spoil_out(buf);
2265
2266                 /* Number */
2267                 sprintf(buf, "Num:%d  ", who[l]);
2268                 spoil_out(buf);
2269
2270                 /* Level */
2271                 sprintf(buf, "Lev:%d  ", r_ptr->level);
2272                 spoil_out(buf);
2273
2274                 /* Rarity */
2275                 sprintf(buf, "Rar:%d  ", r_ptr->rarity);
2276                 spoil_out(buf);
2277
2278                 /* Speed */
2279                 if (r_ptr->speed >= 110)
2280                 {
2281                         sprintf(buf, "Spd:+%d  ", (r_ptr->speed - 110));
2282                 }
2283                 else
2284                 {
2285                         sprintf(buf, "Spd:-%d  ", (110 - r_ptr->speed));
2286                 }
2287                 spoil_out(buf);
2288
2289                 /* Hitpoints */
2290                 if ((flags1 & (RF1_FORCE_MAXHP)) || (r_ptr->hside == 1))
2291                 {
2292                         sprintf(buf, "Hp:%d  ", r_ptr->hdice * r_ptr->hside);
2293                 }
2294                 else
2295                 {
2296                         sprintf(buf, "Hp:%dd%d  ", r_ptr->hdice, r_ptr->hside);
2297                 }
2298                 spoil_out(buf);
2299
2300                 /* Armor Class */
2301                 sprintf(buf, "Ac:%d  ", r_ptr->ac);
2302                 spoil_out(buf);
2303
2304                 /* Experience */
2305                 sprintf(buf, "Exp:%ld\n", (long)(r_ptr->mexp));
2306                 spoil_out(buf);
2307
2308                 /* Reuse the code of monster recall. */
2309                 output_monster_spoiler(who[l], roff_func);
2310
2311                 spoil_out(NULL);
2312         }
2313
2314         /* Free the "who" array */
2315         C_KILL(who, max_r_idx, s16b);
2316
2317         /* Check for errors */
2318         if (ferror(fff) || my_fclose(fff))
2319         {
2320                 msg_print("Cannot close spoiler file.");
2321                 return;
2322         }
2323
2324         msg_print("Successfully created a spoiler file.");
2325 }
2326
2327
2328
2329 #define MAX_EVOL_DEPTH 64
2330
2331
2332 /*!
2333  * @brief int配列でstrncmp()と似た比較処理を行う /
2334  * Compare two int-type array like strncmp() and return TRUE if equals
2335  * @param a 比較するint配列1
2336  * @param b 比較するint配列2
2337  * @param length
2338  * @return 両者の値が等しければTRUEを返す
2339  */
2340 static bool int_n_cmp(int *a, int *b, int length)
2341 {
2342         /* Null-string comparation is always TRUE */
2343         if (!length) return TRUE;
2344
2345         do
2346         {
2347                 if (*a != *(b++)) return FALSE;
2348                 if (!(*(a++))) break;
2349         }
2350         while (--length);
2351
2352         return TRUE;
2353 }
2354
2355
2356 /*!
2357  * @brief ある木が指定された木の部分木かどうかを返す /
2358  * Returns TRUE if an evolution tree is "partial tree"
2359  * @param tree 元となる木構造リスト
2360  * @param partial_tree 部分木かどうか判定したい木構造リスト
2361  * @return 部分木ならばTRUEを返す
2362  */
2363 static bool is_partial_tree(int *tree, int *partial_tree)
2364 {
2365         int pt_head = *(partial_tree++);
2366         int pt_len = 0;
2367
2368         while (partial_tree[pt_len]) pt_len++;
2369
2370         while (*tree)
2371         {
2372                 if (*(tree++) == pt_head)
2373                 {
2374                         if (int_n_cmp(tree, partial_tree, pt_len)) return TRUE;
2375                 }
2376         }
2377
2378         return FALSE;
2379 }
2380
2381
2382 /*!
2383  * @brief 進化ツリーをソートするためモンスター種族の判定関数 /
2384  * Sorting hook -- Comp function
2385  * @param u 進化木構造データ
2386  * @param v 未使用
2387  * @param a 比較したいモンスター種族ID1
2388  * @param b 比較したいモンスター種族ID2
2389  * @return 2が大きければTRUEを返す
2390  */
2391 static bool ang_sort_comp_evol_tree(vptr u, vptr v, int a, int b)
2392 {
2393         int **evol_tree = (int **)u;
2394
2395         int w1 = evol_tree[a][0];
2396         int w2 = evol_tree[b][0];
2397         monster_race *r1_ptr = &r_info[w1];
2398         monster_race *r2_ptr = &r_info[w2];
2399
2400         /* Unused */
2401         (void)v;
2402
2403         /* Used tree first */
2404         if (w1 && !w2) return TRUE;
2405         if (!w1 && w2) return FALSE;
2406
2407         /* Sort by monster level */
2408         if (r1_ptr->level < r2_ptr->level) return TRUE;
2409         if (r1_ptr->level > r2_ptr->level) return FALSE;
2410
2411         /* Sort by monster experience */
2412         if (r1_ptr->mexp < r2_ptr->mexp) return TRUE;
2413         if (r1_ptr->mexp > r2_ptr->mexp) return FALSE;
2414
2415         /* Compare indexes */
2416         return w1 <= w2;
2417 }
2418
2419 /*!
2420  * @brief 進化ツリーをソートするため木構造のスワップ関数 /
2421  * Sorting hook -- Swap function
2422  * @param u 進化木構造データ
2423  * @param v 未使用
2424  * @param a スワップしたい木構造1
2425  * @param b スワップしたい木構造2
2426  * @return 2が大きければTRUEを返す
2427  */
2428 static void ang_sort_swap_evol_tree(vptr u, vptr v, int a, int b)
2429 {
2430         int **evol_tree = (int **)u;
2431         int *holder;
2432
2433         /* Unused */
2434         (void)v;
2435
2436         /* Swap */
2437         holder = evol_tree[a];
2438         evol_tree[a] = evol_tree[b];
2439         evol_tree[b] = holder;
2440 }
2441
2442 /*!
2443  * @brief 進化ツリーをスポイラー出力するメインルーチン /
2444  * Print monsters' evolution information to file
2445  * @param fname 出力ファイル名
2446  * @return なし
2447  */
2448 static void spoil_mon_evol(cptr fname)
2449 {
2450         char buf[1024];
2451         monster_race *r_ptr;
2452         int **evol_tree, i, j, n, r_idx;
2453         int *evol_tree_zero; /* For C_KILL() */
2454
2455         /* Build the filename */
2456         path_build(buf, sizeof buf, ANGBAND_DIR_USER, fname);
2457
2458         /* File type is "TEXT" */
2459         FILE_TYPE(FILE_TYPE_TEXT);
2460
2461         /* Open the file */
2462         fff = my_fopen(buf, "w");
2463
2464         /* Oops */
2465         if (!fff)
2466         {
2467                 msg_print("Cannot create spoiler file.");
2468             return;
2469         }
2470
2471         /* Dump the header */
2472         sprintf(buf, "Monster Spoilers for Hengband Version %d.%d.%d\n",
2473              FAKE_VER_MAJOR-10, FAKE_VER_MINOR, FAKE_VER_PATCH);
2474
2475         spoil_out(buf);
2476         spoil_out("------------------------------------------\n\n");
2477
2478         /* Allocate the "evol_tree" array (2-dimension) */
2479         C_MAKE(evol_tree, max_r_idx, int *);
2480         C_MAKE(*evol_tree, max_r_idx * (MAX_EVOL_DEPTH + 1), int);
2481         for (i = 1; i < max_r_idx; i++) evol_tree[i] = *evol_tree + i * (MAX_EVOL_DEPTH + 1);
2482         evol_tree_zero = *evol_tree;
2483
2484         /* Step 1: Build the evolution tree */
2485         for (i = 1; i < max_r_idx; i++)
2486         {
2487                 r_ptr = &r_info[i];
2488
2489                 /* No evolution */
2490                 if (!r_ptr->next_exp) continue;
2491
2492                 /* Trace evolution */
2493                 n = 0;
2494                 evol_tree[i][n++] = i;
2495                 do
2496                 {
2497                         evol_tree[i][n++] = r_ptr->next_r_idx;
2498                         r_ptr = &r_info[r_ptr->next_r_idx];
2499                 }
2500                 while (r_ptr->next_exp && (n < MAX_EVOL_DEPTH));
2501         }
2502
2503         /* Step 2: Scan the evolution trees and remove "partial tree" */
2504         for (i = 1; i < max_r_idx; i++)
2505         {
2506                 /* Not evolution tree */
2507                 if (!evol_tree[i][0]) continue;
2508
2509                 for (j = 1; j < max_r_idx; j++)
2510                 {
2511                         /* Same tree */
2512                         if (i == j) continue;
2513
2514                         /* Not evolution tree */
2515                         if (!evol_tree[j][0]) continue;
2516
2517                         /* Is evolution tree[i] is part of [j]? */
2518                         if (is_partial_tree(evol_tree[j], evol_tree[i]))
2519                         {
2520                                 /* Remove this evolution tree */
2521                                 evol_tree[i][0] = 0;
2522                                 break;
2523                         }
2524                 }
2525         }
2526
2527         /* Step 3: Sort the evolution trees */
2528
2529         /* Select the sort method */
2530         ang_sort_comp = ang_sort_comp_evol_tree;
2531         ang_sort_swap = ang_sort_swap_evol_tree;
2532
2533         /* Sort the array */
2534         ang_sort(evol_tree, NULL, max_r_idx);
2535
2536         /* Step 4: Print the evolution trees */
2537         for (i = 0; i < max_r_idx; i++)
2538         {
2539                 r_idx = evol_tree[i][0];
2540
2541                 /* No evolution or removed evolution tree */
2542                 if (!r_idx) continue;
2543
2544                 /* Trace the evolution tree */
2545                 r_ptr = &r_info[r_idx];
2546 #ifdef JP
2547                 fprintf(fff, "[%d]: %s (レベル%d, '%c')\n", r_idx,
2548                         r_name + r_ptr->name, r_ptr->level, r_ptr->d_char);
2549 #else
2550                 fprintf(fff, "[%d]: %s (Level %d, '%c')\n", r_idx,
2551                         r_name + r_ptr->name, r_ptr->level, r_ptr->d_char);
2552 #endif
2553                 for (n = 1; r_ptr->next_exp; n++)
2554                 {
2555                         fprintf(fff, "%*s-(%ld)-> ", n * 2, "", (long int)r_ptr->next_exp);
2556                         fprintf(fff, "[%d]: ", r_ptr->next_r_idx);
2557                         r_ptr = &r_info[r_ptr->next_r_idx];
2558 #ifdef JP
2559                         fprintf(fff, "%s (レベル%d, '%c')\n",
2560                                 r_name + r_ptr->name, r_ptr->level, r_ptr->d_char);
2561 #else
2562                         fprintf(fff, "%s (Level %d, '%c')\n",
2563                                 r_name + r_ptr->name, r_ptr->level, r_ptr->d_char);
2564 #endif
2565                 }
2566
2567                 /* End of evolution tree */
2568                 fputc('\n', fff);
2569         }
2570
2571         /* Free the "evol_tree" array (2-dimension) */
2572         C_KILL(evol_tree_zero, max_r_idx * (MAX_EVOL_DEPTH + 1), int);
2573         C_KILL(evol_tree, max_r_idx, int *);
2574
2575         /* Check for errors */
2576         if (ferror(fff) || my_fclose(fff))
2577         {
2578                 msg_print("Cannot close spoiler file.");
2579                 return;
2580         }
2581
2582         /* Message */
2583         msg_print("Successfully created a spoiler file.");
2584 }
2585
2586
2587
2588 /*
2589  * Forward declare
2590  */
2591 extern void do_cmd_spoilers(void);
2592
2593 /*!
2594  * @brief スポイラー出力を行うコマンドのメインルーチン /
2595  * Create Spoiler files -BEN-
2596  * @return なし
2597  */
2598 void do_cmd_spoilers(void)
2599 {
2600         /* Save the screen */
2601         screen_save();
2602
2603         /* Interact */
2604         while (1)
2605         {
2606                 /* Clear screen */
2607                 Term_clear();
2608
2609                 /* Info */
2610                 prt("Create a spoiler file.", 2, 0);
2611
2612                 /* Prompt for a file */
2613                 prt("(1) Brief Object Info (obj-desc.spo)", 5, 5);
2614                 prt("(2) Brief Artifact Info (artifact.spo)", 6, 5);
2615                 prt("(3) Brief Monster Info (mon-desc.spo)", 7, 5);
2616                 prt("(4) Full Monster Info (mon-info.spo)", 8, 5);
2617                 prt("(5) Monster Evolution Info (mon-evol.spo)", 9, 5);
2618
2619                 /* Prompt */
2620 #ifdef JP
2621                 prt("コマンド:", 18, 0);
2622 #else
2623                 prt("Command: ", 12, 0);
2624 #endif
2625
2626                 /* Get a choice */
2627                 switch (inkey())
2628                 {
2629                 /* Escape */
2630                 case ESCAPE:
2631                         /* Restore the screen */
2632                         screen_load();
2633                         return;
2634
2635                 /* Option (1) */
2636                 case '1':
2637                         spoil_obj_desc("obj-desc.spo");
2638                         break;
2639
2640                 /* Option (2) */
2641                 case '2':
2642                         spoil_artifact("artifact.spo");
2643                         break;
2644
2645                 /* Option (3) */
2646                 case '3':
2647                         spoil_mon_desc("mon-desc.spo");
2648                         break;
2649
2650                 /* Option (4) */
2651                 case '4':
2652                         spoil_mon_info("mon-info.spo");
2653                         break;
2654
2655                 /* Option (5) */
2656                 case '5':
2657                         spoil_mon_evol("mon-evol.spo");
2658                         break;
2659
2660                 /* Oops */
2661                 default:
2662                         bell();
2663                         break;
2664                 }
2665
2666                 /* Flush messages */
2667                 msg_print(NULL);
2668         }
2669 }
2670
2671 /*!
2672  * @brief ランダムアーティファクト１件を解析する /
2673  * Fill in an object description structure for a given object
2674  * @param o_ptr ランダムアーティファクトのオブジェクト構造体参照ポインタ
2675  * @param desc_ptr 記述内容を収める構造体参照ポインタ
2676  * @return なし
2677  */
2678 static void random_artifact_analyze(object_type *o_ptr, obj_desc_list *desc_ptr)
2679 {
2680         analyze_general(o_ptr, desc_ptr->description);
2681         analyze_pval(o_ptr, &desc_ptr->pval_info);
2682         analyze_brand(o_ptr, desc_ptr->brands);
2683         analyze_slay(o_ptr, desc_ptr->slays);
2684         analyze_immune(o_ptr, desc_ptr->immunities);
2685         analyze_resist(o_ptr, desc_ptr->resistances);
2686         analyze_sustains(o_ptr, desc_ptr->sustains);
2687         analyze_misc_magic(o_ptr, desc_ptr->misc_magic);
2688         desc_ptr->activation = item_activation(o_ptr);
2689 #ifdef JP
2690         sprintf(desc_ptr->misc_desc, "重さ %d.%d kg",
2691                 lbtokg1(o_ptr->weight), lbtokg2(o_ptr->weight));
2692 #else
2693         sprintf(desc_ptr->misc_desc, "Weight %d.%d lbs",
2694                 o_ptr->weight / 10, o_ptr->weight % 10);
2695 #endif
2696 }
2697
2698 /*!
2699  * @brief ランダムアーティファクト１件をスポイラー出力する /
2700  * Create a spoiler file entry for an artifact
2701  * @param o_ptr ランダムアーティファクトのオブジェクト構造体参照ポインタ
2702  * @param art_ptr 記述内容を収めた構造体参照ポインタ
2703  * Fill in an object description structure for a given object
2704  * @return なし
2705  */
2706 static void spoiler_print_randart(object_type *o_ptr, obj_desc_list *art_ptr)
2707 {
2708         pval_info_type *pval_ptr = &art_ptr->pval_info;
2709
2710         char buf[80];
2711
2712         /* Don't indent the first line */
2713         fprintf(fff, "%s\n", art_ptr->description);
2714
2715         /* unidentified */
2716         if (!(o_ptr->ident & (IDENT_MENTAL)))
2717         {
2718 #ifdef JP
2719                 fprintf(fff, "%s不明\n",INDENT1);
2720 #else
2721                 fprintf(fff, "%sUnknown\n",INDENT1);
2722 #endif
2723         }
2724         else {
2725                 /* An "empty" pval description indicates that the pval affects nothing */
2726                 if (pval_ptr->pval_desc[0])
2727                 {
2728                         /* Mention the effects of pval */
2729 #ifdef JP
2730                         sprintf(buf, "%sの修正:", pval_ptr->pval_desc);
2731 #else
2732                         sprintf(buf, "%s to", pval_ptr->pval_desc);
2733 #endif
2734                         spoiler_outlist(buf, pval_ptr->pval_affects, ITEM_SEP);
2735                 }
2736
2737                 /* Now deal with the description lists */
2738
2739 #ifdef JP
2740                 spoiler_outlist("対:", art_ptr->slays, ITEM_SEP);
2741                 spoiler_outlist("武器属性:", art_ptr->brands, LIST_SEP);
2742                 spoiler_outlist("免疫:", art_ptr->immunities, ITEM_SEP);
2743                 spoiler_outlist("耐性:", art_ptr->resistances, ITEM_SEP);
2744                 spoiler_outlist("維持:", art_ptr->sustains, ITEM_SEP);
2745 #else
2746                 spoiler_outlist("Slay", art_ptr->slays, ITEM_SEP);
2747                 spoiler_outlist("", art_ptr->brands, LIST_SEP);
2748                 spoiler_outlist("Immunity to", art_ptr->immunities, ITEM_SEP);
2749                 spoiler_outlist("Resist", art_ptr->resistances, ITEM_SEP);
2750                 spoiler_outlist("Sustain", art_ptr->sustains, ITEM_SEP);
2751 #endif
2752                 spoiler_outlist("", art_ptr->misc_magic, LIST_SEP);
2753
2754                 /* Write out the possible activation at the primary indention level */
2755                 if (art_ptr->activation)
2756                 {
2757 #ifdef JP
2758                         fprintf(fff, "%s発動: %s\n", INDENT1, art_ptr->activation);
2759 #else
2760                         fprintf(fff, "%sActivates for %s\n", INDENT1, art_ptr->activation);
2761 #endif
2762                 }
2763         }
2764         /* End with the miscellaneous facts */
2765         fprintf(fff, "%s%s\n\n", INDENT1, art_ptr->misc_desc);
2766 }
2767
2768
2769 /*!
2770  * @brief ランダムアーティファクト内容をスポイラー出力するサブルーチン /
2771  * @param o_ptr ランダムアーティファクトのオブジェクト構造体参照ポインタ
2772  * @param i 出力したい記録ランダムアーティファクトID
2773  * @return なし
2774  */
2775 static void spoil_random_artifact_aux(object_type *o_ptr, int i)
2776 {
2777         obj_desc_list artifact;
2778
2779         if (!object_is_known(o_ptr) || !o_ptr->art_name
2780                 || o_ptr->tval != group_artifact[i].tval)
2781                 return;
2782
2783         /* Analyze the artifact */
2784         random_artifact_analyze(o_ptr, &artifact);
2785
2786         /* Write out the artifact description to the spoiler file */
2787         spoiler_print_randart(o_ptr, &artifact);
2788 }
2789
2790 /*!
2791  * @brief ランダムアーティファクト内容をスポイラー出力するメインルーチン /
2792  * Create a list file for random artifacts
2793  * @param fname 出力ファイル名
2794  * @return なし
2795  */
2796 void spoil_random_artifact(cptr fname)
2797 {
2798         int i,j;
2799
2800         store_type  *st_ptr;
2801         object_type *q_ptr;
2802
2803         char buf[1024];
2804
2805
2806         /* Build the filename */
2807         path_build(buf, sizeof(buf), ANGBAND_DIR_USER, fname);
2808
2809         /* File type is "TEXT" */
2810         FILE_TYPE(FILE_TYPE_TEXT);
2811
2812         /* Open the file */
2813         fff = my_fopen(buf, "w");
2814
2815         /* Oops */
2816         if (!fff)
2817         {
2818                 msg_print("Cannot create list file.");
2819                 return;
2820         }
2821
2822         /* Dump the header */
2823         sprintf(buf, "Random artifacts list.\r");
2824         spoiler_underline(buf);
2825
2826         /* List the artifacts by tval */
2827         for (j = 0; group_artifact[j].tval; j++)
2828         {
2829                 /* random artifacts wielding */
2830                 for (i = INVEN_RARM; i < INVEN_TOTAL; i++)
2831                 {
2832                         q_ptr = &inventory[i];
2833                         spoil_random_artifact_aux(q_ptr, j);
2834                 }
2835
2836                 /* random artifacts in inventory */
2837                 for (i = 0; i < INVEN_PACK; i++)
2838                 {
2839                         q_ptr = &inventory[i];
2840                         spoil_random_artifact_aux(q_ptr, j);
2841                 }
2842
2843                 /* random artifacts in home */
2844                 st_ptr = &town[1].store[STORE_HOME];
2845                 for (i = 0; i < st_ptr->stock_num; i++)
2846                 {
2847                         q_ptr = &st_ptr->stock[i];
2848                         spoil_random_artifact_aux(q_ptr, j);
2849                 }
2850
2851                 /* random artifacts in museum */
2852                 st_ptr = &town[1].store[STORE_MUSEUM];
2853                 for (i = 0; i < st_ptr->stock_num; i++)
2854                 {
2855                         q_ptr = &st_ptr->stock[i];
2856                         spoil_random_artifact_aux(q_ptr, j);
2857                 }
2858         }
2859
2860         /* Check for errors */
2861         if (ferror(fff) || my_fclose(fff))
2862         {
2863                 msg_print("Cannot close list file.");
2864                 return;
2865         }
2866
2867         /* Message */
2868         msg_print("Successfully created a list file.");
2869 }
2870
2871 #else
2872
2873 #ifdef MACINTOSH
2874 static int i = 0;
2875 #endif /* MACINTOSH */
2876
2877 #endif