src/load.c

   1 /*!
   2  * @file load.c
   3  * @brief セーブファイル読み込み処理 / Purpose: support for loading savefiles -BEN-
   4  * @date 2014/07/07
   5  * @author
   6  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   7  *
   8  * This software may be copied and distributed for educational, research,
   9  * and not for profit purposes provided that this copyright and statement
  10  * are included in all such copies.  Other copyrights may also apply.
  11  * @details
  12  * This file loads savefiles from Angband 2.7.X and 2.8.X
  13  *
  14  * Ancient savefiles (pre-2.7.0) are loaded by another file.
  15  *
  16  * Note that Angband 2.7.0 through 2.7.3 are now officially obsolete,
  17  * and savefiles from those versions may not be successfully converted.
  18  *
  19  * We attempt to prevent corrupt savefiles from inducing memory errors.
  20  *
  21  * Note that this file should not use the random number generator, the
  22  * object flavors, the visual attr/char mappings, or anything else which
  23  * is initialized *after* or *during* the "load character" function.
  24  *
  25  * This file assumes that the monster/object records are initialized
  26  * to zero, and the race/kind tables have been loaded correctly.  The
  27  * order of object stacks is currently not saved in the savefiles, but
  28  * the "next" pointers are saved, so all necessary knowledge is present.
  29  *
  30  * We should implement simple "savefile extenders" using some form of
  31  * "sized" chunks of bytes, with a {size,type,data} format, so everyone
  32  * can know the size, interested people can know the type, and the actual
  33  * data is available to the parsing routines that acknowledge the type.
  34  *
  35  * Consider changing the "globe of invulnerability" code so that it
  36  * takes some form of "maximum damage to protect from" in addition to
  37  * the existing "number of turns to protect for", and where each hit
  38  * by a monster will reduce the shield by that amount.
  39  *
  40  *
  41  */
  42
  43 #include "angband.h"
  44 #include "util.h"
  45
  46 #include "feature.h"
  47 #include "floor-generate.h"
  48 #include "trap.h"
  49 #include "mutation.h"
  50 #include "monster.h"
  51 #include "quest.h"
  52 #include "store.h"
  53 #include "artifact.h"
  54 #include "avatar.h"
  55 #include "spells-status.h"
  56 #include "object-hook.h"
  57 #include "wild.h"
  58 #include "patron.h"
  59
  60 #include "floor-save.h"
  61 #include "floor.h"
  62 #include "grid.h"
  63
  64 #include "cmd-pet.h"
  65 #include "dungeon-file.h"
  66 #include "files.h"
  67
  68
  69 /*
  70  * Maximum number of tries for selection of a proper quest monster
  71  */
  72 #define MAX_TRIES 100
  73
  74
  75 /*
  76  * Local "savefile" pointer
  77  */
  78 static FILE     *fff;
  79
  80 /*
  81  * Hack -- old "encryption" byte
  82  */
  83 static byte     xor_byte;
  84
  85 /*
  86  * Hack -- simple "checksum" on the actual values
  87  */
  88 static u32b     v_check = 0L;
  89
  90 /*
  91  * Hack -- simple "checksum" on the encoded bytes
  92  */
  93 static u32b     x_check = 0L;
  94
  95 /*
  96  * Hack -- Japanese Kanji code
  97  * 0: Unknown
  98  * 1: ASCII
  99  * 2: EUC
 100  * 3: SJIS
 101  */
 102 static byte kanji_code = 0;
 103
 104 /*!
 105  * @brief 変愚蛮怒のバージョン比較処理 / This function determines if the version of the savefile currently being read is older than version "major.minor.patch.extra".
 106  * @param major メジャーバージョン値
 107  * @param minor マイナーバージョン値
 108  * @param patch パッチバージョン値
 109  * @param extra エクストラパージョン値
 110  * @return 現在のバージョンより値が古いならtrue
 111  */
 112 static bool h_older_than(byte major, byte minor, byte patch, byte extra)
 113 {
 114         /* Much older, or much more recent */
 115         if (h_ver_major < major) return (TRUE);
 116         if (h_ver_major > major) return (FALSE);
 117
 118         /* Distinctly older, or distinctly more recent */
 119         if (h_ver_minor < minor) return (TRUE);
 120         if (h_ver_minor > minor) return (FALSE);
 121
 122         /* Barely older, or barely more recent */
 123         if (h_ver_patch < patch) return (TRUE);
 124         if (h_ver_patch > patch) return (FALSE);
 125
 126         /* Barely older, or barely more recent */
 127         if (h_ver_extra < extra) return (TRUE);
 128         if (h_ver_extra > extra) return (FALSE);
 129
 130         /* Identical versions */
 131         return (FALSE);
 132 }
 133
 134
 135 /*!
 136  * @brief Zangbandのバージョン比較処理 / The above function, adapted for Zangband
 137  * @param x メジャーバージョン値
 138  * @param y マイナーバージョン値
 139  * @param z パッチバージョン値
 140  * @return 現在のバージョンより値が古いならtrue
 141  */
 142 static bool z_older_than(byte x, byte y, byte z)
 143 {
 144         /* Much older, or much more recent */
 145         if (z_major < x) return (TRUE);
 146         if (z_major > x) return (FALSE);
 147
 148         /* Distinctly older, or distinctly more recent */
 149         if (z_minor < y) return (TRUE);
 150         if (z_minor > y) return (FALSE);
 151
 152         /* Barely older, or barely more recent */
 153         if (z_patch < z) return (TRUE);
 154         if (z_patch > z) return (FALSE);
 155
 156         /* Identical versions */
 157         return (FALSE);
 158 }
 159
 160
 161 /*!
 162  * @brief ゲームスクリーンにメッセージを表示する / Hack -- Show information on the screen, one line at a time.
 163  * @param msg 表示文字列
 164  * @return なし
 165  * @details
 166  * Avoid the top two lines, to avoid interference with "msg_print()".
 167  */
 168 static void note(concptr msg)
 169 {
 170         static TERM_LEN y = 2;
 171
 172         /* Draw the message */
 173         prt(msg, y, 0);
 174
 175         /* Advance one line (wrap if needed) */
 176         if (++y >= 24) y = 2;
 177
 178         /* Flush it */
 179         Term_fresh();
 180 }
 181
 182
 183 /*!
 184  * @brief ロードファイルポインタから1バイトを読み込む
 185  * @return 読み込んだバイト値
 186  * @details
 187  * The following functions are used to load the basic building blocks
 188  * of savefiles.  They also maintain the "checksum" info for 2.7.0+
 189  */
 190 static byte sf_get(void)
 191 {
 192         byte c, v;
 193
 194         /* Get a character, decode the value */
 195         c = getc(fff) & 0xFF;
 196         v = c ^ xor_byte;
 197         xor_byte = c;
 198
 199         /* Maintain the checksum info */
 200         v_check += v;
 201         x_check += xor_byte;
 202
 203         /* Return the value */
 204         return (v);
 205 }
 206
 207 /*!
 208  * @brief ロードファイルポインタから1バイトを読み込んでポインタに渡す
 209  * @param ip 読み込みポインタ
 210  * @return なし
 211  */
 212 static void rd_byte(byte *ip)
 213 {
 214         *ip = sf_get();
 215 }
 216
 217 /*!
 218  * @brief ロードファイルポインタから符号なし16bit値を読み込んでポインタに渡す
 219  * @param ip 読み込みポインタ
 220  * @return なし
 221  */
 222 static void rd_u16b(u16b *ip)
 223 {
 224         (*ip) = sf_get();
 225         (*ip) |= ((u16b)(sf_get()) << 8);
 226 }
 227
 228 /*!
 229  * @brief ロードファイルポインタから符号つき16bit値を読み込んでポインタに渡す
 230  * @param ip 読み込みポインタ
 231  * @return なし
 232  */
 233 static void rd_s16b(s16b *ip)
 234 {
 235         rd_u16b((u16b*)ip);
 236 }
 237
 238 /*!
 239  * @brief ロードファイルポインタから符号なし32bit値を読み込んでポインタに渡す
 240  * @param ip 読み込みポインタ
 241  * @return なし
 242  */
 243 static void rd_u32b(u32b *ip)
 244 {
 245         (*ip) = sf_get();
 246         (*ip) |= ((u32b)(sf_get()) << 8);
 247         (*ip) |= ((u32b)(sf_get()) << 16);
 248         (*ip) |= ((u32b)(sf_get()) << 24);
 249 }
 250
 251 /*!
 252  * @brief ロードファイルポインタから符号つき32bit値を読み込んでポインタに渡す
 253  * @param ip 読み込みポインタ
 254  * @return なし
 255  */
 256 static void rd_s32b(s32b *ip)
 257 {
 258         rd_u32b((u32b*)ip);
 259 }
 260
 261
 262 /*!
 263  * @brief ロードファイルポインタから文字列を読み込んでポインタに渡す / Hack -- read a string
 264  * @param str 読み込みポインタ
 265  * @param max 最大読み取りバイト数
 266  * @return なし
 267  */
 268 static void rd_string(char *str, int max)
 269 {
 270         int i;
 271
 272         /* Read the string */
 273         for (i = 0; TRUE; i++)
 274         {
 275                 byte tmp8u;
 276
 277                 /* Read a byte */
 278                 rd_byte(&tmp8u);
 279
 280                 /* Collect string while legal */
 281                 if (i < max) str[i] = tmp8u;
 282
 283                 /* End of string */
 284                 if (!tmp8u) break;
 285         }
 286
 287         /* Terminate */
 288         str[max-1] = '\0';
 289
 290
 291 #ifdef JP
 292         /* Convert Kanji code */
 293         switch (kanji_code)
 294         {
 295 #ifdef SJIS
 296         case 2:
 297                 /* EUC to SJIS */
 298                 euc2sjis(str);
 299                 break;
 300 #endif
 301
 302 #ifdef EUC
 303         case 3:
 304                 /* SJIS to EUC */
 305                 sjis2euc(str);
 306                 break;
 307 #endif
 308
 309         case 0:
 310         {
 311                 /* 不明の漢字コードからシステムの漢字コードに変換 */
 312                 byte code = codeconv(str);
 313
 314                 /* 漢字コードが判明したら、それを記録 */
 315                 if (code) kanji_code = code;
 316
 317                 break;
 318         }
 319         default:
 320                 /* No conversion needed */
 321                 break;
 322         }
 323 #endif
 324 }
 325
 326
 327 /*!
 328  * @brief ロードファイルポインタを指定バイト分飛ばして進める / Hack -- strip some bytes
 329  * @param n スキップバイト数
 330  * @return なし
 331  */
 332 static void strip_bytes(int n)
 333 {
 334         byte tmp8u;
 335
 336         /* Strip the bytes */
 337         while (n--) rd_byte(&tmp8u);
 338 }
 339
 340 #define OLD_MAX_MANE 22
 341
 342 /*!
 343  * @brief アイテムオブジェクト１件を読み込む(変愚ver1.5.0以前) / Read an object (Old method)
 344  * @param o_ptr アイテムオブジェクト読み取り先ポインタ
 345  * @return なし
 346  * @details
 347  * This function attempts to "repair" old savefiles, and to extract
 348  * the most up to date values for various object fields.
 349  *
 350  * Note that Angband 2.7.9 introduced a new method for object "flags"
 351  * in which the "flags" on an object are actually extracted when they
 352  * are needed from the object kind, artifact index, ego-item index,
 353  * and two special "xtra" fields which are used to encode any "extra"
 354  * power of certain ego-items.  This had the side effect that items
 355  * imported from pre-2.7.9 savefiles will lose any "extra" powers they
 356  * may have had, and also, all "uncursed" items will become "cursed"
 357  * again, including Calris, even if it is being worn at the time.  As
 358  * a complete hack, items which are inscribed with "uncursed" will be
 359  * "uncursed" when imported from pre-2.7.9 savefiles.
 360  */
 361 static void rd_item_old(object_type *o_ptr)
 362 {
 363         char buf[128];
 364         byte_hack tmp8u;
 365         s16b tmp16s;
 366
 367
 368         /* Kind */
 369         rd_s16b(&o_ptr->k_idx);
 370
 371         rd_byte(&tmp8u);
 372         o_ptr->iy = (POSITION)tmp8u;
 373         rd_byte(&tmp8u);
 374         o_ptr->ix = (POSITION)tmp8u;
 375
 376         /* Type/Subtype */
 377         rd_byte(&tmp8u);
 378         o_ptr->tval = tmp8u;
 379         rd_byte(&tmp8u);
 380         o_ptr->sval = tmp8u;
 381
 382         if (z_older_than(10, 4, 4))
 383         {
 384                 if (o_ptr->tval == 100) o_ptr->tval = TV_GOLD;
 385                 if (o_ptr->tval == 98) o_ptr->tval = TV_MUSIC_BOOK;
 386                 if (o_ptr->tval == 110) o_ptr->tval = TV_HISSATSU_BOOK;
 387         }
 388
 389         /* Special pval */
 390         rd_s16b(&o_ptr->pval);
 391
 392         rd_byte(&o_ptr->discount);
 393         rd_byte(&tmp8u);
 394         o_ptr->number = (ITEM_NUMBER)tmp8u;
 395
 396         rd_s16b(&tmp16s);
 397         o_ptr->weight = tmp16s;
 398
 399         rd_byte(&tmp8u);
 400         o_ptr->name1 = tmp8u;
 401
 402         rd_byte(&tmp8u);
 403         o_ptr->name2 = tmp8u;
 404
 405         rd_s16b(&o_ptr->timeout);
 406
 407         rd_s16b(&o_ptr->to_h);
 408
 409         rd_s16b(&tmp16s);
 410         o_ptr->to_d = tmp16s;
 411         rd_s16b(&o_ptr->to_a);
 412
 413         rd_s16b(&o_ptr->ac);
 414
 415         rd_byte(&tmp8u);
 416         o_ptr->dd = tmp8u;
 417         rd_byte(&tmp8u);
 418         o_ptr->ds = tmp8u;
 419
 420         rd_byte(&o_ptr->ident);
 421
 422         rd_byte(&o_ptr->marked);
 423
 424         /* Object flags */
 425         rd_u32b(&o_ptr->art_flags[0]);
 426         rd_u32b(&o_ptr->art_flags[1]);
 427         rd_u32b(&o_ptr->art_flags[2]);
 428         if (h_older_than(1, 3, 0, 0)) o_ptr->art_flags[3] = 0L;
 429         else rd_u32b(&o_ptr->art_flags[3]);
 430
 431         if (h_older_than(1, 3, 0, 0))
 432         {
 433                 if (o_ptr->name2 == EGO_TELEPATHY)
 434                         add_flag(o_ptr->art_flags, TR_TELEPATHY);
 435         }
 436
 437         if (z_older_than(11, 0, 11))
 438         {
 439                 o_ptr->curse_flags = 0L;
 440                 if (o_ptr->ident & 0x40)
 441                 {
 442                         o_ptr->curse_flags |= TRC_CURSED;
 443                         if (o_ptr->art_flags[2] & 0x40000000L) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
 444                         if (o_ptr->art_flags[2] & 0x80000000L) o_ptr->curse_flags |= TRC_PERMA_CURSE;
 445                         if (object_is_fixed_artifact(o_ptr))
 446                         {
 447                                 artifact_type *a_ptr = &a_info[o_ptr->name1];
 448                                 if (a_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
 449                                 if (a_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
 450                         }
 451                         else if (object_is_ego(o_ptr))
 452                         {
 453                                 ego_item_type *e_ptr = &e_info[o_ptr->name2];
 454                                 if (e_ptr->gen_flags & (TRG_HEAVY_CURSE)) o_ptr->curse_flags |= TRC_HEAVY_CURSE;
 455                                 if (e_ptr->gen_flags & (TRG_PERMA_CURSE)) o_ptr->curse_flags |= TRC_PERMA_CURSE;
 456                         }
 457                 }
 458                 o_ptr->art_flags[2] &= (0x1FFFFFFFL);
 459         }
 460         else
 461         {
 462                 rd_u32b(&o_ptr->curse_flags);
 463         }
 464
 465         /* Monster holding object */
 466         rd_s16b(&o_ptr->held_m_idx);
 467
 468         /* Special powers */
 469         rd_byte(&o_ptr->xtra1);
 470         rd_byte(&o_ptr->xtra2);
 471
 472         if (z_older_than(11, 0, 10))
 473         {
 474                 if (o_ptr->xtra1 == EGO_XTRA_SUSTAIN)
 475                 {
 476                         switch (o_ptr->xtra2 % 6)
 477                         {
 478                         case 0: add_flag(o_ptr->art_flags, TR_SUST_STR); break;
 479                         case 1: add_flag(o_ptr->art_flags, TR_SUST_INT); break;
 480                         case 2: add_flag(o_ptr->art_flags, TR_SUST_WIS); break;
 481                         case 3: add_flag(o_ptr->art_flags, TR_SUST_DEX); break;
 482                         case 4: add_flag(o_ptr->art_flags, TR_SUST_CON); break;
 483                         case 5: add_flag(o_ptr->art_flags, TR_SUST_CHR); break;
 484                         }
 485                         o_ptr->xtra2 = 0;
 486                 }
 487                 else if (o_ptr->xtra1 == EGO_XTRA_POWER)
 488                 {
 489                         switch (o_ptr->xtra2 % 11)
 490                         {
 491                         case  0: add_flag(o_ptr->art_flags, TR_RES_BLIND);  break;
 492                         case  1: add_flag(o_ptr->art_flags, TR_RES_CONF);   break;
 493                         case  2: add_flag(o_ptr->art_flags, TR_RES_SOUND);  break;
 494                         case  3: add_flag(o_ptr->art_flags, TR_RES_SHARDS); break;
 495                         case  4: add_flag(o_ptr->art_flags, TR_RES_NETHER); break;
 496                         case  5: add_flag(o_ptr->art_flags, TR_RES_NEXUS);  break;
 497                         case  6: add_flag(o_ptr->art_flags, TR_RES_CHAOS);  break;
 498                         case  7: add_flag(o_ptr->art_flags, TR_RES_DISEN);  break;
 499                         case  8: add_flag(o_ptr->art_flags, TR_RES_POIS);   break;
 500                         case  9: add_flag(o_ptr->art_flags, TR_RES_DARK);   break;
 501                         case 10: add_flag(o_ptr->art_flags, TR_RES_LITE);   break;
 502                         }
 503                         o_ptr->xtra2 = 0;
 504                 }
 505                 else if (o_ptr->xtra1 == EGO_XTRA_ABILITY)
 506                 {
 507                         switch (o_ptr->xtra2 % 8)
 508                         {
 509                         case 0: add_flag(o_ptr->art_flags, TR_LEVITATION);     break;
 510                         case 1: add_flag(o_ptr->art_flags, TR_LITE_1);        break;
 511                         case 2: add_flag(o_ptr->art_flags, TR_SEE_INVIS);   break;
 512                         case 3: add_flag(o_ptr->art_flags, TR_WARNING);     break;
 513                         case 4: add_flag(o_ptr->art_flags, TR_SLOW_DIGEST); break;
 514                         case 5: add_flag(o_ptr->art_flags, TR_REGEN);       break;
 515                         case 6: add_flag(o_ptr->art_flags, TR_FREE_ACT);    break;
 516                         case 7: add_flag(o_ptr->art_flags, TR_HOLD_EXP);   break;
 517                         }
 518                         o_ptr->xtra2 = 0;
 519                 }
 520                 o_ptr->xtra1 = 0;
 521         }
 522
 523         if (z_older_than(10, 2, 3))
 524         {
 525                 o_ptr->xtra3 = 0;
 526                 o_ptr->xtra4 = 0;
 527                 o_ptr->xtra5 = 0;
 528                 if ((o_ptr->tval == TV_CHEST) || (o_ptr->tval == TV_CAPTURE))
 529                 {
 530                         o_ptr->xtra3 = o_ptr->xtra1;
 531                         o_ptr->xtra1 = 0;
 532                 }
 533                 if (o_ptr->tval == TV_CAPTURE)
 534                 {
 535                         if (r_info[o_ptr->pval].flags1 & RF1_FORCE_MAXHP)
 536                                 o_ptr->xtra5 = maxroll(r_info[o_ptr->pval].hdice, r_info[o_ptr->pval].hside);
 537                         else
 538                                 o_ptr->xtra5 = damroll(r_info[o_ptr->pval].hdice, r_info[o_ptr->pval].hside);
 539                         if (ironman_nightmare)
 540                         {
 541                                 o_ptr->xtra5 = (s16b)MIN(30000, o_ptr->xtra5*2L);
 542                         }
 543                         o_ptr->xtra4 = o_ptr->xtra5;
 544                 }
 545         }
 546         else
 547         {
 548                 rd_byte(&o_ptr->xtra3);
 549                 if (h_older_than(1, 3, 0, 1))
 550                 {
 551                         if (object_is_smith(o_ptr) && o_ptr->xtra3 >= 1+96)
 552                                 o_ptr->xtra3 += -96 + MIN_SPECIAL_ESSENCE;
 553                 }
 554
 555                 rd_s16b(&o_ptr->xtra4);
 556                 rd_s16b(&o_ptr->xtra5);
 557         }
 558
 559         if (z_older_than(11, 0, 5) && (((o_ptr->tval == TV_LITE) && ((o_ptr->sval == SV_LITE_TORCH) || (o_ptr->sval == SV_LITE_LANTERN))) || (o_ptr->tval == TV_FLASK)))
 560         {
 561                 o_ptr->xtra4 = o_ptr->pval;
 562                 o_ptr->pval = 0;
 563         }
 564
 565         rd_byte(&o_ptr->feeling);
 566
 567         /* Inscription */
 568         rd_string(buf, sizeof(buf));
 569
 570         /* Save the inscription */
 571         if (buf[0]) o_ptr->inscription = quark_add(buf);
 572
 573         rd_string(buf, sizeof(buf));
 574         if (buf[0]) o_ptr->art_name = quark_add(buf);
 575
 576         /* The Python object */
 577         {
 578                 s32b tmp32s;
 579
 580                 rd_s32b(&tmp32s);
 581                 strip_bytes(tmp32s);
 582         }
 583
 584         /* Mega-Hack -- handle "dungeon objects" later */
 585         if ((o_ptr->k_idx >= 445) && (o_ptr->k_idx <= 479)) return;
 586
 587         if (z_older_than(10, 4, 10) && (o_ptr->name2 == EGO_YOIYAMI)) o_ptr->k_idx = lookup_kind(TV_SOFT_ARMOR, SV_YOIYAMI_ROBE);
 588
 589         if (z_older_than(10, 4, 9))
 590         {
 591                 if (have_flag(o_ptr->art_flags, TR_MAGIC_MASTERY))
 592                 {
 593                         remove_flag(o_ptr->art_flags, TR_MAGIC_MASTERY);
 594                         add_flag(o_ptr->art_flags, TR_DEC_MANA);
 595                 }
 596         }
 597         if (object_is_fixed_artifact(o_ptr))
 598         {
 599                 artifact_type *a_ptr;
 600
 601                 /* Obtain the artifact info */
 602                 a_ptr = &a_info[o_ptr->name1];
 603
 604                 /* Verify that artifact */
 605                 if (!a_ptr->name) o_ptr->name1 = 0;
 606         }
 607         if (object_is_ego(o_ptr))
 608         {
 609                 ego_item_type *e_ptr;
 610
 611                 /* Obtain the ego-item info */
 612                 e_ptr = &e_info[o_ptr->name2];
 613
 614                 /* Verify that ego-item */
 615                 if (!e_ptr->name) o_ptr->name2 = 0;
 616
 617         }
 618 }
 619
 620
 621 /*!
 622  * @brief アイテムオブジェクトを読み込む(現版) / Read an object (New method)
 623  * @param o_ptr アイテムオブジェクト保存先ポインタ
 624  * @return なし
 625  */
 626 static void rd_item(object_type *o_ptr)
 627 {
 628         object_kind *k_ptr;
 629         BIT_FLAGS flags;
 630         char buf[128];
 631         byte_hack tmp8u;
 632         s16b tmp16s;
 633
 634         if (h_older_than(1, 5, 0, 0))
 635         {
 636                 rd_item_old(o_ptr);
 637                 return;
 638         }
 639
 640         /*** Item save flags ***/
 641         rd_u32b(&flags);
 642
 643         /*** Read un-obvious elements ***/
 644         /* Kind */
 645         rd_s16b(&o_ptr->k_idx);
 646
 647         rd_byte(&tmp8u);
 648         o_ptr->iy = (POSITION)tmp8u;
 649         rd_byte(&tmp8u);
 650         o_ptr->ix = (POSITION)tmp8u;
 651
 652         /* Type/Subtype */
 653         k_ptr = &k_info[o_ptr->k_idx];
 654         o_ptr->tval = k_ptr->tval;
 655         o_ptr->sval = k_ptr->sval;
 656
 657         /* Special pval */
 658         if (flags & SAVE_ITEM_PVAL) rd_s16b(&o_ptr->pval);
 659         else o_ptr->pval = 0;
 660
 661         if (flags & SAVE_ITEM_DISCOUNT) rd_byte(&o_ptr->discount);
 662         else o_ptr->discount = 0;
 663         if (flags & SAVE_ITEM_NUMBER) {
 664                 rd_byte(&tmp8u);
 665                 o_ptr->number = tmp8u;
 666         }
 667         else o_ptr->number = 1;
 668
 669         rd_s16b(&tmp16s);
 670         o_ptr->weight = tmp16s;
 671
 672         if (flags & SAVE_ITEM_NAME1)
 673         {
 674                 rd_byte(&tmp8u);
 675                 o_ptr->name1 = tmp8u;
 676         }
 677         else o_ptr->name1 = 0;
 678         if (flags & SAVE_ITEM_NAME2)
 679         {
 680                 rd_byte(&tmp8u);
 681                 o_ptr->name2 = tmp8u;
 682         }
 683         else o_ptr->name2 = 0;
 684         if (flags & SAVE_ITEM_TIMEOUT) rd_s16b(&o_ptr->timeout);
 685         else o_ptr->timeout = 0;
 686
 687         if (flags & SAVE_ITEM_TO_H) rd_s16b(&o_ptr->to_h);
 688         else o_ptr->to_h = 0;
 689         if (flags & SAVE_ITEM_TO_D)
 690         {
 691                 rd_s16b(&tmp16s);
 692                 o_ptr->to_d = tmp16s;
 693         }
 694         else o_ptr->to_d = 0;
 695         if (flags & SAVE_ITEM_TO_A) rd_s16b(&o_ptr->to_a);
 696         else o_ptr->to_a = 0;
 697
 698         if (flags & SAVE_ITEM_AC) rd_s16b(&o_ptr->ac);
 699         else o_ptr->ac = 0;
 700
 701         if (flags & SAVE_ITEM_DD)
 702         {
 703                  rd_byte(&tmp8u);
 704                  o_ptr->dd = tmp8u;
 705         }
 706         else o_ptr->dd = 0;
 707         if (flags & SAVE_ITEM_DS)
 708         {
 709                 rd_byte(&tmp8u);
 710                 o_ptr->ds = tmp8u;
 711         }
 712         else o_ptr->ds = 0;
 713
 714         if (flags & SAVE_ITEM_IDENT) rd_byte(&o_ptr->ident);
 715         else o_ptr->ident = 0;
 716
 717         if (flags & SAVE_ITEM_MARKED) rd_byte(&o_ptr->marked);
 718         else o_ptr->marked = 0;
 719
 720         /* Object flags */
 721         if (flags & SAVE_ITEM_ART_FLAGS0) rd_u32b(&o_ptr->art_flags[0]);
 722         else o_ptr->art_flags[0] = 0;
 723         if (flags & SAVE_ITEM_ART_FLAGS1) rd_u32b(&o_ptr->art_flags[1]);
 724         else o_ptr->art_flags[1] = 0;
 725         if (flags & SAVE_ITEM_ART_FLAGS2) rd_u32b(&o_ptr->art_flags[2]);
 726         else o_ptr->art_flags[2] = 0;
 727         if (flags & SAVE_ITEM_ART_FLAGS3) rd_u32b(&o_ptr->art_flags[3]);
 728         else o_ptr->art_flags[3] = 0;
 729         if (flags & SAVE_ITEM_ART_FLAGS4) rd_u32b(&o_ptr->art_flags[4]);
 730         else o_ptr->art_flags[4] = 0;
 731
 732         if (flags & SAVE_ITEM_CURSE_FLAGS) rd_u32b(&o_ptr->curse_flags);
 733         else o_ptr->curse_flags = 0;
 734
 735         /* Monster holding object */
 736         if (flags & SAVE_ITEM_HELD_M_IDX) rd_s16b(&o_ptr->held_m_idx);
 737         else o_ptr->held_m_idx = 0;
 738
 739         /* Special powers */
 740         if (flags & SAVE_ITEM_XTRA1) rd_byte(&o_ptr->xtra1);
 741         else o_ptr->xtra1 = 0;
 742         if (flags & SAVE_ITEM_XTRA2) rd_byte(&o_ptr->xtra2);
 743         else o_ptr->xtra2 = 0;
 744
 745         if (flags & SAVE_ITEM_XTRA3) rd_byte(&o_ptr->xtra3);
 746         else o_ptr->xtra3 = 0;
 747
 748         if (flags & SAVE_ITEM_XTRA4) rd_s16b(&o_ptr->xtra4);
 749         else o_ptr->xtra4 = 0;
 750         if (flags & SAVE_ITEM_XTRA5) rd_s16b(&o_ptr->xtra5);
 751         else o_ptr->xtra5 = 0;
 752
 753         if (flags & SAVE_ITEM_FEELING) rd_byte(&o_ptr->feeling);
 754         else o_ptr->feeling = 0;
 755
 756         if (flags & SAVE_ITEM_INSCRIPTION)
 757         {
 758                 rd_string(buf, sizeof(buf));
 759                 o_ptr->inscription = quark_add(buf);
 760         }
 761         else o_ptr->inscription = 0;
 762
 763         if (flags & SAVE_ITEM_ART_NAME)
 764         {
 765                 rd_string(buf, sizeof(buf));
 766                 o_ptr->art_name = quark_add(buf);
 767         }
 768         else o_ptr->art_name = 0;
 769
 770         if(h_older_than(2,1,2,4))
 771         {
 772                 BIT_FLAGS flgs[TR_FLAG_SIZE];
 773                 object_flags(o_ptr, flgs);
 774
 775                 if ((o_ptr->name2 == EGO_DARK) || (o_ptr->name2 == EGO_ANCIENT_CURSE) || (o_ptr->name1 == ART_NIGHT))
 776                 {
 777                         add_flag(o_ptr->art_flags, TR_LITE_M1);
 778                         remove_flag(o_ptr->art_flags, TR_LITE_1);
 779                         remove_flag(o_ptr->art_flags, TR_LITE_2);
 780                         remove_flag(o_ptr->art_flags, TR_LITE_3);
 781                 }
 782                 else if (o_ptr->name2 == EGO_LITE_DARKNESS)
 783                 {
 784                         if (o_ptr->tval == TV_LITE)
 785                         {
 786                                 if (o_ptr->sval == SV_LITE_TORCH)
 787                                 {
 788                                         add_flag(o_ptr->art_flags, TR_LITE_M1);
 789                                 }
 790                                 else if (o_ptr->sval == SV_LITE_LANTERN)
 791                                 {
 792                                         add_flag(o_ptr->art_flags, TR_LITE_M2);
 793                                 }
 794                                 else if (o_ptr->sval == SV_LITE_FEANOR)
 795                                 {
 796                                         add_flag(o_ptr->art_flags, TR_LITE_M3);
 797                                 }
 798                         }
 799                         else
 800                         {
 801                                 add_flag(o_ptr->art_flags, TR_LITE_M1);
 802                         }
 803                 }
 804                 else if (o_ptr->tval == TV_LITE)
 805                 {
 806                         if (object_is_fixed_artifact(o_ptr))
 807                         {
 808                                 add_flag(o_ptr->art_flags, TR_LITE_3);
 809                         }
 810                         else if (o_ptr->sval == SV_LITE_TORCH)
 811                         {
 812                                 add_flag(o_ptr->art_flags, TR_LITE_1);
 813                                 add_flag(o_ptr->art_flags, TR_LITE_FUEL);
 814                         }
 815                         else if (o_ptr->sval == SV_LITE_LANTERN)
 816                         {
 817                                 add_flag(o_ptr->art_flags, TR_LITE_2);
 818                                 add_flag(o_ptr->art_flags, TR_LITE_FUEL);
 819                         }
 820                         else if (o_ptr->sval == SV_LITE_FEANOR)
 821                         {
 822                                 add_flag(o_ptr->art_flags, TR_LITE_2);
 823                         }
 824                 }
 825         }
 826 }
 827
 828
 829 /*!
 830  * @brief モンスターを読み込む(変愚ver1.5.0以前) / Read a monster (Old method)
 831  * @param m_ptr モンスター保存先ポインタ
 832  * @return なし
 833  */
 834 static void rd_monster_old(monster_type *m_ptr)
 835 {
 836         byte tmp8u;
 837         s16b tmp16s;
 838         u32b tmp32u;
 839         char buf[128];
 840
 841         /* Read the monster race */
 842         rd_s16b(&m_ptr->r_idx);
 843
 844         if (z_older_than(11, 0, 12))
 845                 m_ptr->ap_r_idx = m_ptr->r_idx;
 846         else
 847                 rd_s16b(&m_ptr->ap_r_idx);
 848
 849         if (z_older_than(11, 0, 14))
 850         {
 851                 monster_race *r_ptr = &r_info[m_ptr->r_idx];
 852
 853                 m_ptr->sub_align = SUB_ALIGN_NEUTRAL;
 854                 if (r_ptr->flags3 & RF3_EVIL) m_ptr->sub_align |= SUB_ALIGN_EVIL;
 855                 if (r_ptr->flags3 & RF3_GOOD) m_ptr->sub_align |= SUB_ALIGN_GOOD;
 856         }
 857         else
 858                 rd_byte(&m_ptr->sub_align);
 859
 860         /* Read the other information */
 861         rd_byte(&tmp8u);
 862         m_ptr->fy = (POSITION)tmp8u;
 863         rd_byte(&tmp8u);
 864         m_ptr->fx = (POSITION)tmp8u;
 865
 866         rd_s16b(&tmp16s);
 867         m_ptr->hp = tmp16s;
 868         rd_s16b(&tmp16s);
 869         m_ptr->maxhp = tmp16s;
 870
 871         if (z_older_than(11, 0, 5))
 872         {
 873                 m_ptr->max_maxhp = m_ptr->maxhp;
 874         }
 875         else
 876         {
 877                 rd_s16b(&tmp16s);
 878                 m_ptr->max_maxhp = (HIT_POINT)tmp16s;
 879         }
 880         if(h_older_than(2, 1, 2, 1))
 881         {
 882                 m_ptr->dealt_damage = 0;
 883         }
 884         else
 885         {
 886                 rd_s32b(&m_ptr->dealt_damage);
 887         }
 888
 889         rd_s16b(&m_ptr->mtimed[MTIMED_CSLEEP]);
 890
 891         rd_byte(&tmp8u);
 892         m_ptr->mspeed = tmp8u;
 893
 894         if (z_older_than(10, 4, 2))
 895         {
 896                 rd_byte(&tmp8u);
 897                 m_ptr->energy_need = (s16b)tmp8u;
 898         }
 899         else rd_s16b(&m_ptr->energy_need);
 900
 901         if (z_older_than(11, 0, 13))
 902                 m_ptr->energy_need = 100 - m_ptr->energy_need;
 903
 904         if (z_older_than(10,0,7))
 905         {
 906                 m_ptr->mtimed[MTIMED_FAST] = 0;
 907                 m_ptr->mtimed[MTIMED_SLOW] = 0;
 908         }
 909         else
 910         {
 911                 rd_byte(&tmp8u);
 912                 m_ptr->mtimed[MTIMED_FAST] = (s16b)tmp8u;
 913                 rd_byte(&tmp8u);
 914                 m_ptr->mtimed[MTIMED_SLOW] = (s16b)tmp8u;
 915         }
 916         rd_byte(&tmp8u);
 917         m_ptr->mtimed[MTIMED_STUNNED] = (s16b)tmp8u;
 918         rd_byte(&tmp8u);
 919         m_ptr->mtimed[MTIMED_CONFUSED] = (s16b)tmp8u;
 920         rd_byte(&tmp8u);
 921         m_ptr->mtimed[MTIMED_MONFEAR] = (s16b)tmp8u;
 922
 923         if (z_older_than(10,0,10))
 924         {
 925                 reset_target(m_ptr);
 926         }
 927         else if (z_older_than(10,0,11))
 928         {
 929                 rd_s16b(&tmp16s);
 930                 reset_target(m_ptr);
 931         }
 932         else
 933         {
 934                 rd_s16b(&tmp16s);
 935                 m_ptr->target_y = (POSITION)tmp16s;
 936                 rd_s16b(&tmp16s);
 937                 m_ptr->target_x = (POSITION)tmp16s;
 938         }
 939
 940         rd_byte(&tmp8u);
 941         m_ptr->mtimed[MTIMED_INVULNER] = (s16b)tmp8u;
 942
 943         if (!(z_major == 2 && z_minor == 0 && z_patch == 6))
 944                 rd_u32b(&m_ptr->smart);
 945         else
 946                 m_ptr->smart = 0;
 947
 948         if (z_older_than(10, 4, 5)) {
 949                 m_ptr->exp = 0;
 950         } else {
 951                 rd_u32b(&tmp32u);
 952                 m_ptr->exp = tmp32u;
 953         }
 954
 955         if (z_older_than(10, 2, 2))
 956         {
 957                 if (m_ptr->r_idx < 0)
 958                 {
 959                         m_ptr->r_idx = (0-m_ptr->r_idx);
 960                         m_ptr->mflag2 |= MFLAG2_KAGE;
 961                 }
 962         }
 963         else
 964         {
 965                 rd_byte(&m_ptr->mflag2);
 966         }
 967
 968         if (z_older_than(11, 0, 12))
 969         {
 970                 if (m_ptr->mflag2 & MFLAG2_KAGE)
 971                         m_ptr->ap_r_idx = MON_KAGE;
 972         }
 973
 974         if (z_older_than(10, 1, 3))
 975         {
 976                 m_ptr->nickname = 0;
 977         }
 978         else
 979         {
 980                 rd_string(buf, sizeof(buf));
 981                 if (buf[0]) m_ptr->nickname = quark_add(buf);
 982         }
 983
 984         rd_byte(&tmp8u);
 985 }
 986
 987
 988 /*!
 989  * @brief モンスターを読み込む(現版) / Read a monster (New method)
 990  * @param m_ptr モンスター保存先ポインタ
 991  * @return なし
 992  */
 993 static void rd_monster(monster_type *m_ptr)
 994 {
 995         BIT_FLAGS flags;
 996         char buf[128];
 997         byte tmp8u;
 998         s16b tmp16s;
 999         u32b tmp32u;
1000
1001         if (h_older_than(1, 5, 0, 0))
1002         {
1003                 rd_monster_old(m_ptr);
1004                 return;
1005         }
1006
1007         /*** Monster save flags ***/
1008         rd_u32b(&flags);
1009
1010         /*** Read un-obvious elements ***/
1011
1012         /* Read the monster race */
1013         rd_s16b(&m_ptr->r_idx);
1014
1015         /* Read the other information */
1016         rd_byte(&tmp8u);
1017         m_ptr->fy = (POSITION)tmp8u;
1018         rd_byte(&tmp8u);
1019         m_ptr->fx = (POSITION)tmp8u;
1020
1021         rd_s16b(&tmp16s);
1022         m_ptr->hp = (HIT_POINT)tmp16s;
1023         rd_s16b(&tmp16s);
1024         m_ptr->maxhp = (HIT_POINT)tmp16s;
1025         rd_s16b(&tmp16s);
1026         m_ptr->max_maxhp = (HIT_POINT)tmp16s;
1027
1028         if(h_older_than(2, 1, 2, 1))
1029         {
1030                 m_ptr->dealt_damage = 0;
1031         }
1032         else
1033         {
1034                 rd_s32b(&m_ptr->dealt_damage);
1035         }
1036
1037         /* Monster race index of its appearance */
1038         if (flags & SAVE_MON_AP_R_IDX) rd_s16b(&m_ptr->ap_r_idx);
1039         else m_ptr->ap_r_idx = m_ptr->r_idx;
1040
1041         if (flags & SAVE_MON_SUB_ALIGN) rd_byte(&m_ptr->sub_align);
1042         else m_ptr->sub_align = 0;
1043
1044         if (flags & SAVE_MON_CSLEEP) rd_s16b(&m_ptr->mtimed[MTIMED_CSLEEP]);
1045         else m_ptr->mtimed[MTIMED_CSLEEP] = 0;
1046
1047         rd_byte(&tmp8u);
1048         m_ptr->mspeed = tmp8u;
1049
1050         rd_s16b(&m_ptr->energy_need);
1051
1052         if (flags & SAVE_MON_FAST)
1053         {
1054                 rd_byte(&tmp8u);
1055                 m_ptr->mtimed[MTIMED_FAST] = (s16b)tmp8u;
1056         }
1057         else m_ptr->mtimed[MTIMED_FAST] = 0;
1058         if (flags & SAVE_MON_SLOW)
1059         {
1060                 rd_byte(&tmp8u);
1061                 m_ptr->mtimed[MTIMED_SLOW] = (s16b)tmp8u;
1062         }
1063         else m_ptr->mtimed[MTIMED_SLOW] = 0;
1064         if (flags & SAVE_MON_STUNNED)
1065         {
1066                 rd_byte(&tmp8u);
1067                 m_ptr->mtimed[MTIMED_STUNNED] = (s16b)tmp8u;
1068         }
1069         else m_ptr->mtimed[MTIMED_STUNNED] = 0;
1070         if (flags & SAVE_MON_CONFUSED)
1071         {
1072                 rd_byte(&tmp8u);
1073                 m_ptr->mtimed[MTIMED_CONFUSED] = (s16b)tmp8u;
1074         }
1075         else m_ptr->mtimed[MTIMED_CONFUSED] = 0;
1076         if (flags & SAVE_MON_MONFEAR)
1077         {
1078                 rd_byte(&tmp8u);
1079                 m_ptr->mtimed[MTIMED_MONFEAR] = (s16b)tmp8u;
1080         }
1081         else m_ptr->mtimed[MTIMED_MONFEAR] = 0;
1082
1083         if (flags & SAVE_MON_TARGET_Y)
1084         {
1085                 rd_s16b(&tmp16s);
1086                 m_ptr->target_y = (POSITION)tmp16s;
1087         }
1088         else m_ptr->target_y = 0;
1089         if (flags & SAVE_MON_TARGET_X)
1090         {
1091                 rd_s16b(&tmp16s);
1092                 m_ptr->target_x = (POSITION)tmp16s;
1093         }
1094         else m_ptr->target_x = 0;
1095
1096         if (flags & SAVE_MON_INVULNER)
1097         {
1098                 rd_byte(&tmp8u);
1099                 m_ptr->mtimed[MTIMED_INVULNER] = (s16b)tmp8u;
1100         }
1101         else m_ptr->mtimed[MTIMED_INVULNER] = 0;
1102
1103         if (flags & SAVE_MON_SMART) rd_u32b(&m_ptr->smart);
1104         else m_ptr->smart = 0;
1105
1106         if (flags & SAVE_MON_EXP)
1107         {
1108                 rd_u32b(&tmp32u);
1109                 m_ptr->exp = (EXP)tmp32u;
1110         }
1111         else m_ptr->exp = 0;
1112
1113         m_ptr->mflag = 0; /* Not saved */
1114
1115         if (flags & SAVE_MON_MFLAG2) rd_byte(&m_ptr->mflag2);
1116         else m_ptr->mflag2 = 0;
1117
1118         if (flags & SAVE_MON_NICKNAME)
1119         {
1120                 rd_string(buf, sizeof(buf));
1121                 m_ptr->nickname = quark_add(buf);
1122         }
1123         else m_ptr->nickname = 0;
1124
1125         if (flags & SAVE_MON_PARENT) rd_s16b(&m_ptr->parent_m_idx);
1126         else m_ptr->parent_m_idx = 0;
1127 }
1128
1129
1130 /*
1131  * Old monster bit flags of racial resistances
1132  */
1133 #define RF3_IM_ACID         0x00010000  /* Resist acid a lot */
1134 #define RF3_IM_ELEC         0x00020000  /* Resist elec a lot */
1135 #define RF3_IM_FIRE         0x00040000  /* Resist fire a lot */
1136 #define RF3_IM_COLD         0x00080000  /* Resist cold a lot */
1137 #define RF3_IM_POIS         0x00100000  /* Resist poison a lot */
1138 #define RF3_RES_TELE        0x00200000  /* Resist teleportation */
1139 #define RF3_RES_NETH        0x00400000  /* Resist nether a lot */
1140 #define RF3_RES_WATE        0x00800000  /* Resist water */
1141 #define RF3_RES_PLAS        0x01000000  /* Resist plasma */
1142 #define RF3_RES_NEXU        0x02000000  /* Resist nexus */
1143 #define RF3_RES_DISE        0x04000000  /* Resist disenchantment */
1144 #define RF3_RES_ALL         0x08000000  /* Resist all */
1145
1146 #define MOVE_RF3_TO_RFR(R_PTR,RF3,RFR) \
1147 {\
1148         if ((R_PTR)->r_flags3 & (RF3)) \
1149         { \
1150                 (R_PTR)->r_flags3 &= ~(RF3); \
1151                 (R_PTR)->r_flagsr |= (RFR); \
1152         } \
1153 }
1154
1155 #define RF4_BR_TO_RFR(R_PTR,RF4_BR,RFR) \
1156 {\
1157         if ((R_PTR)->r_flags4 & (RF4_BR)) \
1158         { \
1159                 (R_PTR)->r_flagsr |= (RFR); \
1160         } \
1161 }
1162
1163 #define RF4_BR_LITE         0x00004000  /* Breathe Lite */
1164 #define RF4_BR_DARK         0x00008000  /* Breathe Dark */
1165 #define RF4_BR_CONF         0x00010000  /* Breathe Confusion */
1166 #define RF4_BR_SOUN         0x00020000  /* Breathe Sound */
1167 #define RF4_BR_CHAO         0x00040000  /* Breathe Chaos */
1168 #define RF4_BR_TIME         0x00200000  /* Breathe Time */
1169 #define RF4_BR_INER         0x00400000  /* Breathe Inertia */
1170 #define RF4_BR_GRAV         0x00800000  /* Breathe Gravity */
1171 #define RF4_BR_SHAR         0x01000000  /* Breathe Shards */
1172 #define RF4_BR_WALL         0x04000000  /* Breathe Force */
1173
1174 /*!
1175  * @brief モンスターの思い出を読み込む / Read the monster lore
1176  * @param r_idx 読み込み先モンスターID
1177  * @return なし
1178  */
1179 static void rd_lore(MONRACE_IDX r_idx)
1180 {
1181         byte tmp8u;
1182         s16b tmp16s;
1183
1184         monster_race *r_ptr = &r_info[r_idx];
1185
1186         /* Count sights/deaths/kills */
1187         rd_s16b(&tmp16s);
1188         r_ptr->r_sights = (MONSTER_NUMBER)tmp16s;
1189         rd_s16b(&tmp16s);
1190         r_ptr->r_deaths = (MONSTER_NUMBER)tmp16s;
1191         rd_s16b(&tmp16s);
1192         r_ptr->r_pkills = (MONSTER_NUMBER)tmp16s;
1193         if (h_older_than(1, 7, 0, 5))
1194         {
1195                 r_ptr->r_akills = r_ptr->r_pkills;
1196         }
1197         else
1198         {
1199                 rd_s16b(&tmp16s);
1200                 r_ptr->r_akills = (MONSTER_NUMBER)tmp16s;
1201         }
1202         rd_s16b(&tmp16s);
1203         r_ptr->r_tkills = (MONSTER_NUMBER)tmp16s;
1204
1205         /* Count wakes and ignores */
1206         rd_byte(&r_ptr->r_wake);
1207         rd_byte(&r_ptr->r_ignore);
1208
1209         /* Extra stuff */
1210         rd_byte(&r_ptr->r_xtra1);
1211         rd_byte(&r_ptr->r_xtra2);
1212
1213         /* Count drops */
1214         rd_byte(&tmp8u);
1215         r_ptr->r_drop_gold = (ITEM_NUMBER)tmp8u;
1216         rd_byte(&tmp8u);
1217         r_ptr->r_drop_item = (ITEM_NUMBER)tmp8u;
1218
1219         /* Count spells */
1220         rd_byte(&tmp8u);
1221         rd_byte(&r_ptr->r_cast_spell);
1222
1223         /* Count blows of each type */
1224         rd_byte(&r_ptr->r_blows[0]);
1225         rd_byte(&r_ptr->r_blows[1]);
1226         rd_byte(&r_ptr->r_blows[2]);
1227         rd_byte(&r_ptr->r_blows[3]);
1228
1229         /* Memorize flags */
1230         rd_u32b(&r_ptr->r_flags1);
1231         rd_u32b(&r_ptr->r_flags2);
1232         rd_u32b(&r_ptr->r_flags3);
1233         rd_u32b(&r_ptr->r_flags4);
1234         rd_u32b(&r_ptr->r_flags5);
1235         rd_u32b(&r_ptr->r_flags6);
1236         if (h_older_than(1, 5, 0, 3))
1237         {
1238                 r_ptr->r_flagsr = 0L;
1239
1240                 /* Move RF3 resistance flags to RFR */
1241                 MOVE_RF3_TO_RFR(r_ptr, RF3_IM_ACID,  RFR_IM_ACID);
1242                 MOVE_RF3_TO_RFR(r_ptr, RF3_IM_ELEC,  RFR_IM_ELEC);
1243                 MOVE_RF3_TO_RFR(r_ptr, RF3_IM_FIRE,  RFR_IM_FIRE);
1244                 MOVE_RF3_TO_RFR(r_ptr, RF3_IM_COLD,  RFR_IM_COLD);
1245                 MOVE_RF3_TO_RFR(r_ptr, RF3_IM_POIS,  RFR_IM_POIS);
1246                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_TELE, RFR_RES_TELE);
1247                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_NETH, RFR_RES_NETH);
1248                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_WATE, RFR_RES_WATE);
1249                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_PLAS, RFR_RES_PLAS);
1250                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_NEXU, RFR_RES_NEXU);
1251                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_DISE, RFR_RES_DISE);
1252                 MOVE_RF3_TO_RFR(r_ptr, RF3_RES_ALL,  RFR_RES_ALL);
1253
1254                 /* Separate breathers resistance from RF4 to RFR */
1255                 RF4_BR_TO_RFR(r_ptr, RF4_BR_LITE, RFR_RES_LITE);
1256                 RF4_BR_TO_RFR(r_ptr, RF4_BR_DARK, RFR_RES_DARK);
1257                 RF4_BR_TO_RFR(r_ptr, RF4_BR_SOUN, RFR_RES_SOUN);
1258                 RF4_BR_TO_RFR(r_ptr, RF4_BR_CHAO, RFR_RES_CHAO);
1259                 RF4_BR_TO_RFR(r_ptr, RF4_BR_TIME, RFR_RES_TIME);
1260                 RF4_BR_TO_RFR(r_ptr, RF4_BR_INER, RFR_RES_INER);
1261                 RF4_BR_TO_RFR(r_ptr, RF4_BR_GRAV, RFR_RES_GRAV);
1262                 RF4_BR_TO_RFR(r_ptr, RF4_BR_SHAR, RFR_RES_SHAR);
1263                 RF4_BR_TO_RFR(r_ptr, RF4_BR_WALL, RFR_RES_WALL);
1264
1265                 /* Resist confusion is merged to RF3_NO_CONF */
1266                 if (r_ptr->r_flags4 & RF4_BR_CONF) r_ptr->r_flags3 |= RF3_NO_CONF;
1267
1268                 /* Misc resistance hack to RFR */
1269                 if (r_idx == MON_STORMBRINGER) r_ptr->r_flagsr |= RFR_RES_CHAO;
1270                 if (r_ptr->r_flags3 & RF3_ORC) r_ptr->r_flagsr |= RFR_RES_DARK;
1271         }
1272         else
1273         {
1274                 rd_u32b(&r_ptr->r_flagsr);
1275         }
1276
1277         /* Read the "Racial" monster limit per level */
1278         rd_byte(&tmp8u);
1279         r_ptr->max_num = (MONSTER_NUMBER)tmp8u;
1280
1281         /* Location in saved floor */
1282         rd_s16b(&r_ptr->floor_id);
1283
1284         /* Later (?) */
1285         rd_byte(&tmp8u);
1286
1287         /* Repair the lore flags */
1288         r_ptr->r_flags1 &= r_ptr->flags1;
1289         r_ptr->r_flags2 &= r_ptr->flags2;
1290         r_ptr->r_flags3 &= r_ptr->flags3;
1291         r_ptr->r_flags4 &= r_ptr->flags4;
1292         r_ptr->r_flags5 &= r_ptr->a_ability_flags1;
1293         r_ptr->r_flags6 &= r_ptr->a_ability_flags2;
1294         r_ptr->r_flagsr &= r_ptr->flagsr;
1295 }
1296
1297 /*!
1298  * @brief 店置きのアイテムオブジェクトを読み込む / Add the item "o_ptr" to the inventory of the "Home"
1299  * @param st_ptr 店舗の参照ポインタ
1300  * @param o_ptr アイテムオブジェクト参照ポインタ
1301  * @return なし
1302  * @details
1303  * In all cases, return the slot (or -1) where the object was placed
1304  *
1305  * Note that this is a hacked up version of "inven_carry()".
1306  *
1307  * Also note that it may not correctly "adapt" to "knowledge" bacoming
1308  * known, the player may have to pick stuff up and drop it again.
1309  */
1310 static void home_carry(store_type *st_ptr, object_type *o_ptr)
1311 {
1312         int                             slot;
1313         s32b                       value;
1314         int     i;
1315         object_type *j_ptr;
1316
1317
1318         /* Check each existing item (try to combine) */
1319         for (slot = 0; slot < st_ptr->stock_num; slot++)
1320         {
1321                 /* Get the existing item */
1322                 j_ptr = &st_ptr->stock[slot];
1323
1324                 /* The home acts just like the player */
1325                 if (object_similar(j_ptr, o_ptr))
1326                 {
1327                         /* Save the new number of items */
1328                         object_absorb(j_ptr, o_ptr);
1329
1330                         /* All done */
1331                         return;
1332                 }
1333         }
1334
1335         /* No space? */
1336         if (st_ptr->stock_num >= STORE_INVEN_MAX * 10) {
1337                 return;
1338         }
1339
1340         /* Determine the "value" of the item */
1341         value = object_value(o_ptr);
1342
1343         /* Check existing slots to see if we must "slide" */
1344         for (slot = 0; slot < st_ptr->stock_num; slot++)
1345         {
1346                 if (object_sort_comp(o_ptr, value, &st_ptr->stock[slot])) break;
1347         }
1348
1349         /* Slide the others up */
1350         for (i = st_ptr->stock_num; i > slot; i--)
1351         {
1352                 st_ptr->stock[i] = st_ptr->stock[i-1];
1353         }
1354
1355         /* More stuff now */
1356         st_ptr->stock_num++;
1357
1358         /* Insert the new item */
1359         st_ptr->stock[slot] = *o_ptr;
1360
1361         chg_virtue(V_SACRIFICE, -1);
1362
1363         /* Return the location */
1364         return;
1365 }
1366
1367 /*!
1368  * @brief 店舗情報を読み込む / Read a store
1369  * @param town_number 街ID
1370  * @param store_number 店舗ID
1371  * @return エラーID
1372  */
1373 static errr rd_store(int town_number, int store_number)
1374 {
1375         store_type *st_ptr;
1376
1377         int j;
1378
1379         byte own;
1380         byte tmp8u;
1381         s16b num;
1382
1383         bool sort = FALSE;
1384
1385         if (z_older_than(10, 3, 3) && (store_number == STORE_HOME))
1386         {
1387                 st_ptr = &town_info[1].store[store_number];
1388                 if (st_ptr->stock_num) sort = TRUE;
1389         }
1390         else
1391         {
1392                 st_ptr = &town_info[town_number].store[store_number];
1393         }
1394
1395         /* Read the basic info */
1396         rd_s32b(&st_ptr->store_open);
1397         rd_s16b(&st_ptr->insult_cur);
1398         rd_byte(&own);
1399         if (z_older_than(11, 0, 4))
1400         {
1401                 rd_byte(&tmp8u);
1402                 num = tmp8u;
1403         }
1404         else
1405         {
1406                 rd_s16b(&num);
1407         }
1408         rd_s16b(&st_ptr->good_buy);
1409         rd_s16b(&st_ptr->bad_buy);
1410
1411         /* Read last visit */
1412         rd_s32b(&st_ptr->last_visit);
1413
1414         /* Extract the owner (see above) */
1415         st_ptr->owner = own;
1416
1417         /* Read the items */
1418         for (j = 0; j < num; j++)
1419         {
1420                 object_type forge;
1421                 object_type *q_ptr;
1422                 q_ptr = &forge;
1423                 object_wipe(q_ptr);
1424
1425                 /* Read the item */
1426                 rd_item(q_ptr);
1427
1428                 /* Acquire valid items */
1429                 if (st_ptr->stock_num < (store_number == STORE_HOME ? (STORE_INVEN_MAX) * 10 : (store_number == STORE_MUSEUM ? (STORE_INVEN_MAX) * 50 : STORE_INVEN_MAX)))
1430                 {
1431                         int k;
1432                         if (sort)
1433                         {
1434                                 home_carry(st_ptr, q_ptr);
1435                         }
1436                         else
1437                         {
1438                                 k = st_ptr->stock_num++;
1439
1440                                 /* Acquire the item */
1441                                 object_copy(&st_ptr->stock[k], q_ptr);
1442                         }
1443                 }
1444         }
1445
1446         /* Success */
1447         return (0);
1448 }
1449
1450
1451 /*!
1452  * @brief 乱数状態を読み込む / Read RNG state (added in 2.8.0)
1453  * @return なし
1454  */
1455 static void rd_randomizer(void)
1456 {
1457         int i;
1458
1459         u16b tmp16u;
1460
1461         /* Tmp */
1462         rd_u16b(&tmp16u);
1463
1464         /* Place */
1465         rd_u16b(&Rand_place);
1466
1467         /* State */
1468         for (i = 0; i < RAND_DEG; i++)
1469         {
1470                 rd_u32b(&Rand_state[i]);
1471         }
1472 }
1473
1474
1475
1476 /*!
1477  * @brief ゲームオプションを読み込む / Read options (ignore most pre-2.8.0 options)
1478  * @return なし
1479  * @details
1480  * Note that the normal options are now stored as a set of 256 bit flags,
1481  * plus a set of 256 bit masks to indicate which bit flags were defined
1482  * at the time the savefile was created.  This will allow new options
1483  * to be added, and old options to be removed, at any time, without
1484  * hurting old savefiles.
1485  *
1486  * The window options are stored in the same way, but note that each
1487  * window gets 32 options, and their order is fixed by certain defines.
1488  */
1489 static void rd_options(void)
1490 {
1491         int i, n;
1492         byte b;
1493         u16b c;
1494
1495         BIT_FLAGS flag[8];
1496         BIT_FLAGS mask[8];
1497
1498         /* Ignore old options */
1499         strip_bytes(16);
1500
1501         /*** Special info */
1502
1503         /* Read "delay_factor" */
1504         rd_byte(&b);
1505         delay_factor = b;
1506
1507         /* Read "hitpoint_warn" */
1508         rd_byte(&b);
1509         hitpoint_warn = b;
1510
1511         /* Read "mana_warn" */
1512         if(h_older_than(1, 7, 0, 0))
1513         {
1514                 mana_warn=2;
1515         }
1516         else
1517         {
1518                 rd_byte(&b);
1519                 mana_warn = b;
1520         }
1521
1522         /*** Cheating options ***/
1523
1524         rd_u16b(&c);
1525
1526         if (c & 0x0002) p_ptr->wizard = TRUE;
1527
1528         cheat_peek = (c & 0x0100) ? TRUE : FALSE;
1529         cheat_hear = (c & 0x0200) ? TRUE : FALSE;
1530         cheat_room = (c & 0x0400) ? TRUE : FALSE;
1531         cheat_xtra = (c & 0x0800) ? TRUE : FALSE;
1532         cheat_know = (c & 0x1000) ? TRUE : FALSE;
1533         cheat_live = (c & 0x2000) ? TRUE : FALSE;
1534         cheat_save = (c & 0x4000) ? TRUE : FALSE;
1535         cheat_diary_output = (c & 0x8000) ? TRUE : FALSE;
1536         cheat_turn = (c & 0x0080) ? TRUE : FALSE;
1537         cheat_sight = (c & 0x0040) ? TRUE : FALSE;
1538
1539         rd_byte((byte *)&autosave_l);
1540         rd_byte((byte *)&autosave_t);
1541         rd_s16b(&autosave_freq);
1542
1543
1544         /*** Normal Options ***/
1545
1546         /* Read the option flags */
1547         for (n = 0; n < 8; n++) rd_u32b(&flag[n]);
1548
1549         /* Read the option masks */
1550         for (n = 0; n < 8; n++) rd_u32b(&mask[n]);
1551
1552         /* Analyze the options */
1553         for (n = 0; n < 8; n++)
1554         {
1555                 /* Analyze the options */
1556                 for (i = 0; i < 32; i++)
1557                 {
1558                         /* Process valid flags */
1559                         if (mask[n] & (1L << i))
1560                         {
1561                                 /* Process valid flags */
1562                                 if (option_mask[n] & (1L << i))
1563                                 {
1564                                         /* Set */
1565                                         if (flag[n] & (1L << i))
1566                                         {
1567                                                 /* Set */
1568                                                 option_flag[n] |= (1L << i);
1569                                         }
1570
1571                                         /* Clear */
1572                                         else
1573                                         {
1574                                                 /* Clear */
1575                                                 option_flag[n] &= ~(1L << i);
1576                                         }
1577                                 }
1578                         }
1579                 }
1580         }
1581
1582         if (z_older_than(10, 4, 5))
1583         {
1584                 if (option_flag[5] & (0x00000001 << 4)) option_flag[5] &= ~(0x00000001 << 4);
1585                 else option_flag[5] |= (0x00000001 << 4);
1586                 if (option_flag[2] & (0x00000001 << 5)) option_flag[2] &= ~(0x00000001 << 5);
1587                 else option_flag[2] |= (0x00000001 << 5);
1588                 if (option_flag[4] & (0x00000001 << 5)) option_flag[4] &= ~(0x00000001 << 5);
1589                 else option_flag[4] |= (0x00000001 << 5);
1590                 if (option_flag[5] & (0x00000001 << 0)) option_flag[5] &= ~(0x00000001 << 0);
1591                 else option_flag[5] |= (0x00000001 << 0);
1592                 if (option_flag[5] & (0x00000001 << 12)) option_flag[5] &= ~(0x00000001 << 12);
1593                 else option_flag[5] |= (0x00000001 << 12);
1594                 if (option_flag[1] & (0x00000001 << 0)) option_flag[1] &= ~(0x00000001 << 0);
1595                 else option_flag[1] |= (0x00000001 << 0);
1596                 if (option_flag[1] & (0x00000001 << 18)) option_flag[1] &= ~(0x00000001 << 18);
1597                 else option_flag[1] |= (0x00000001 << 18);
1598                 if (option_flag[1] & (0x00000001 << 19)) option_flag[1] &= ~(0x00000001 << 19);
1599                 else option_flag[1] |= (0x00000001 << 19);
1600                 if (option_flag[5] & (0x00000001 << 3)) option_flag[1] &= ~(0x00000001 << 3);
1601                 else option_flag[5] |= (0x00000001 << 3);
1602         }
1603
1604         /* Extract the options */
1605         extract_option_vars();
1606
1607
1608         /*** Window Options ***/
1609
1610         /* Read the window flags */
1611         for (n = 0; n < 8; n++) rd_u32b(&flag[n]);
1612
1613         /* Read the window masks */
1614         for (n = 0; n < 8; n++) rd_u32b(&mask[n]);
1615
1616         /* Analyze the options */
1617         for (n = 0; n < 8; n++)
1618         {
1619                 /* Analyze the options */
1620                 for (i = 0; i < 32; i++)
1621                 {
1622                         /* Process valid flags */
1623                         if (mask[n] & (1L << i))
1624                         {
1625                                 /* Process valid flags */
1626                                 if (window_mask[n] & (1L << i))
1627                                 {
1628                                         /* Set */
1629                                         if (flag[n] & (1L << i))
1630                                         {
1631                                                 /* Set */
1632                                                 window_flag[n] |= (1L << i);
1633                                         }
1634
1635                                         /* Clear */
1636                                         else
1637                                         {
1638                                                 /* Clear */
1639                                                 window_flag[n] &= ~(1L << i);
1640                                         }
1641                                 }
1642                         }
1643                 }
1644         }
1645 }
1646
1647
1648
1649 /*!
1650  * @brief ダミー情報スキップ / Hack -- strip the "ghost" info
1651  * @return なし
1652  * @details
1653  * This is such a nasty hack it hurts.
1654  */
1655 static void rd_ghost(void)
1656 {
1657         char buf[64];
1658
1659         /* Strip name */
1660         rd_string(buf, sizeof(buf));
1661
1662         /* Strip old data */
1663         strip_bytes(60);
1664 }
1665
1666
1667 /*!
1668  * @brief クイックスタート情報を読み込む / Load quick start data
1669  * @return なし
1670  */
1671 static void load_quick_start(void)
1672 {
1673         byte tmp8u;
1674         s16b tmp16s;
1675         int i;
1676
1677         if (z_older_than(11, 0, 13))
1678         {
1679                 previous_char.quick_ok = FALSE;
1680                 return;
1681         }
1682
1683         rd_byte(&previous_char.psex);
1684         rd_byte(&tmp8u);
1685         previous_char.prace = (RACE_IDX)tmp8u;
1686         rd_byte(&tmp8u);
1687         previous_char.pclass = (CLASS_IDX)tmp8u;
1688         rd_byte(&tmp8u);
1689         previous_char.pseikaku = (CHARACTER_IDX)tmp8u;
1690         rd_byte(&tmp8u);
1691         previous_char.realm1 = (REALM_IDX)tmp8u;
1692         rd_byte(&tmp8u);
1693         previous_char.realm2 = (REALM_IDX)tmp8u;
1694
1695         rd_s16b(&previous_char.age);
1696         rd_s16b(&previous_char.ht);
1697         rd_s16b(&previous_char.wt);
1698         rd_s16b(&previous_char.sc);
1699         rd_s32b(&previous_char.au);
1700
1701         for (i = 0; i < A_MAX; i++) rd_s16b(&previous_char.stat_max[i]);
1702         for (i = 0; i < A_MAX; i++) rd_s16b(&previous_char.stat_max_max[i]);
1703
1704         for (i = 0; i < PY_MAX_LEVEL; i++)
1705         {
1706                 rd_s16b(&tmp16s);
1707                 previous_char.player_hp[i] = (HIT_POINT)tmp16s;
1708         }
1709
1710         rd_s16b(&previous_char.chaos_patron);
1711
1712         for (i = 0; i < 8; i++) rd_s16b(&previous_char.vir_types[i]);
1713
1714         for (i = 0; i < 4; i++) rd_string(previous_char.history[i], sizeof(previous_char.history[i]));
1715
1716         /* UNUSED : Was number of random quests */
1717         rd_byte(&tmp8u);
1718
1719         rd_byte(&tmp8u);
1720         previous_char.quick_ok = (bool)tmp8u;
1721 }
1722
1723 /*!
1724  * @brief その他の情報を読み込む / Read the "extra" information
1725  * @return なし
1726  */
1727 static void rd_extra(void)
1728 {
1729         int i,j;
1730
1731         byte tmp8u;
1732         s16b tmp16s;
1733         s32b tmp32s;
1734         u16b tmp16u;
1735
1736         rd_string(p_ptr->name, sizeof(p_ptr->name));
1737
1738         rd_string(p_ptr->died_from, sizeof(p_ptr->died_from));
1739
1740         if (!h_older_than(1, 7, 0, 1))
1741         {
1742                 char buf[1024];
1743
1744                 /* Read the message */
1745                 rd_string(buf, sizeof buf);
1746                 if (buf[0]) p_ptr->last_message = string_make(buf);
1747         }
1748
1749         load_quick_start();
1750
1751         for (i = 0; i < 4; i++)
1752         {
1753                 rd_string(p_ptr->history[i], sizeof(p_ptr->history[i]));
1754         }
1755
1756         /* Class/Race/Seikaku/Gender/Spells */
1757         rd_byte(&tmp8u);
1758         p_ptr->prace = (RACE_IDX)tmp8u;
1759         rd_byte(&tmp8u);
1760         p_ptr->pclass = (CLASS_IDX)tmp8u;
1761         rd_byte(&tmp8u);
1762         p_ptr->pseikaku = (CHARACTER_IDX)tmp8u;
1763         rd_byte(&p_ptr->psex);
1764         rd_byte(&tmp8u);
1765         p_ptr->realm1 = (REALM_IDX)tmp8u;
1766         rd_byte(&tmp8u);
1767         p_ptr->realm2 = (REALM_IDX)tmp8u;
1768         rd_byte(&tmp8u);
1769
1770         if (z_older_than(10, 4, 4))
1771         {
1772                 if (p_ptr->realm1 == 9) p_ptr->realm1 = REALM_MUSIC;
1773                 if (p_ptr->realm2 == 9) p_ptr->realm2 = REALM_MUSIC;
1774                 if (p_ptr->realm1 == 10) p_ptr->realm1 = REALM_HISSATSU;
1775                 if (p_ptr->realm2 == 10) p_ptr->realm2 = REALM_HISSATSU;
1776         }
1777
1778         /* Special Race/Class info */
1779         rd_byte(&tmp8u);
1780         p_ptr->hitdie = tmp8u;
1781         rd_u16b(&p_ptr->expfact);
1782
1783         /* Age/Height/Weight */
1784         rd_s16b(&p_ptr->age);
1785         rd_s16b(&p_ptr->ht);
1786         rd_s16b(&p_ptr->wt);
1787
1788         /* Read the stat info */
1789         for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_max[i]);
1790         for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_max_max[i]);
1791         for (i = 0; i < A_MAX; i++) rd_s16b(&p_ptr->stat_cur[i]);
1792
1793         strip_bytes(24);
1794         rd_s32b(&p_ptr->au);
1795
1796         rd_s32b(&p_ptr->max_exp);
1797         if (h_older_than(1, 5, 4, 1)) p_ptr->max_max_exp = p_ptr->max_exp;
1798         else rd_s32b(&p_ptr->max_max_exp);
1799         rd_s32b(&p_ptr->exp);
1800
1801         if (h_older_than(1, 7, 0, 3))
1802         {
1803                 rd_u16b(&tmp16u);
1804                 p_ptr->exp_frac = (u32b)tmp16u;
1805         }
1806         else
1807         {
1808                 rd_u32b(&p_ptr->exp_frac);
1809         }
1810
1811         rd_s16b(&p_ptr->lev);
1812
1813         for (i = 0; i < 64; i++) rd_s16b(&p_ptr->spell_exp[i]);
1814         if ((p_ptr->pclass == CLASS_SORCERER) && z_older_than(10, 4, 2))
1815         {
1816                 for (i = 0; i < 64; i++) p_ptr->spell_exp[i] = SPELL_EXP_MASTER;
1817         }
1818         if (z_older_than(10, 3, 6))
1819                 for (i = 0; i < 5; i++) for (j = 0; j < 60; j++) rd_s16b(&p_ptr->weapon_exp[i][j]);
1820         else
1821                 for (i = 0; i < 5; i++) for (j = 0; j < 64; j++) rd_s16b(&p_ptr->weapon_exp[i][j]);
1822         for (i = 0; i < GINOU_MAX; i++) rd_s16b(&p_ptr->skill_exp[i]);
1823         if (z_older_than(10, 4, 1))
1824         {
1825                 if (p_ptr->pclass != CLASS_BEASTMASTER) p_ptr->skill_exp[GINOU_RIDING] /= 2;
1826                 p_ptr->skill_exp[GINOU_RIDING] = MIN(p_ptr->skill_exp[GINOU_RIDING], s_info[p_ptr->pclass].s_max[GINOU_RIDING]);
1827         }
1828         if (z_older_than(10, 3, 14))
1829         {
1830                 for (i = 0; i < 108; i++) p_ptr->magic_num1[i] = 0;
1831                 for (i = 0; i < 108; i++) p_ptr->magic_num2[i] = 0;
1832         }
1833         else
1834         {
1835                 for (i = 0; i < 108; i++) rd_s32b(&p_ptr->magic_num1[i]);
1836                 for (i = 0; i < 108; i++) rd_byte(&p_ptr->magic_num2[i]);
1837                 if (h_older_than(1, 3, 0, 1))
1838                 {
1839                         if (p_ptr->pclass == CLASS_SMITH)
1840                         {
1841                                 p_ptr->magic_num1[TR_ES_ATTACK] = p_ptr->magic_num1[96];
1842                                 p_ptr->magic_num1[96] = 0;
1843                                 p_ptr->magic_num1[TR_ES_AC] = p_ptr->magic_num1[97];
1844                                 p_ptr->magic_num1[97] = 0;
1845                         }
1846                 }
1847         }
1848         if (music_singing_any()) p_ptr->action = ACTION_SING;
1849
1850         if (z_older_than(11, 0, 7))
1851         {
1852                 p_ptr->start_race = p_ptr->prace;
1853                 p_ptr->old_race1 = 0L;
1854                 p_ptr->old_race2 = 0L;
1855                 p_ptr->old_realm = 0;
1856         }
1857         else
1858         {
1859                 rd_byte(&tmp8u);
1860                 p_ptr->start_race = (RACE_IDX)tmp8u;
1861                 rd_s32b(&tmp32s);
1862                 p_ptr->old_race1 = (BIT_FLAGS)tmp32s;
1863                 rd_s32b(&tmp32s);
1864                 p_ptr->old_race2 = (BIT_FLAGS)tmp32s;
1865                 rd_s16b(&p_ptr->old_realm);
1866         }
1867
1868         if (z_older_than(10, 0, 1))
1869         {
1870                 for (i = 0; i < MAX_MANE; i++)
1871                 {
1872                         p_ptr->mane_spell[i] = -1;
1873                         p_ptr->mane_dam[i] = 0;
1874                 }
1875                 p_ptr->mane_num = 0;
1876         }
1877         else if (z_older_than(10, 2, 3))
1878         {
1879                 for (i = 0; i < OLD_MAX_MANE; i++)
1880                 {
1881                         rd_s16b(&tmp16s);
1882                         rd_s16b(&tmp16s);
1883                 }
1884                 for (i = 0; i < MAX_MANE; i++)
1885                 {
1886                         p_ptr->mane_spell[i] = -1;
1887                         p_ptr->mane_dam[i] = 0;
1888                 }
1889                 rd_s16b(&tmp16s);
1890                 p_ptr->mane_num = 0;
1891         }
1892         else
1893         {
1894                 for (i = 0; i < MAX_MANE; i++)
1895                 {
1896                         rd_s16b(&tmp16s);
1897                         p_ptr->mane_spell[i] = (SPELL_IDX)tmp16s;
1898                         rd_s16b(&tmp16s);
1899                         p_ptr->mane_dam[i] = (SPELL_IDX)tmp16s;
1900                 }
1901                 rd_s16b(&p_ptr->mane_num);
1902         }
1903
1904         if (z_older_than(10, 0, 3))
1905         {
1906                 determine_bounty_uniques();
1907
1908                 for (i = 0; i < MAX_KUBI; i++)
1909                 {
1910                         /* Is this bounty unique already dead? */
1911                         if (!r_info[current_world_ptr->bounty_r_idx[i]].max_num) current_world_ptr->bounty_r_idx[i] += 10000;
1912                 }
1913         }
1914         else
1915         {
1916                 for (i = 0; i < MAX_KUBI; i++)
1917                 {
1918                         rd_s16b(&current_world_ptr->bounty_r_idx[i]);
1919                 }
1920         }
1921
1922         if (z_older_than(10, 0, 3))
1923         {
1924                 update_gambling_monsters();
1925         }
1926         else
1927         {
1928                 for (i = 0; i < 4; i++)
1929                 {
1930                         rd_s16b(&battle_mon[i]);
1931                         if (z_older_than(10, 3, 4))
1932                         {
1933                                 rd_s16b(&tmp16s);
1934                                 mon_odds[i] = tmp16s;
1935                         }
1936                         else rd_u32b(&mon_odds[i]);
1937                 }
1938         }
1939
1940         rd_s16b(&p_ptr->town_num);
1941
1942         /* Read arena and rewards information */
1943         rd_s16b(&p_ptr->arena_number);
1944         if (h_older_than(1, 5, 0, 1))
1945         {
1946                 /* Arena loser of previous version was marked number 99 */
1947                 if (p_ptr->arena_number >= 99) p_ptr->arena_number = ARENA_DEFEATED_OLD_VER;
1948         }
1949         rd_s16b(&tmp16s);
1950         p_ptr->inside_arena = (bool)tmp16s;
1951         rd_s16b(&p_ptr->inside_quest);
1952         if (z_older_than(10, 3, 5)) p_ptr->inside_battle = FALSE;
1953         else
1954         {
1955                 rd_s16b(&tmp16s);
1956                 p_ptr->inside_battle = (bool)tmp16s;
1957         }
1958         rd_byte(&p_ptr->exit_bldg);
1959         rd_byte(&tmp8u);
1960
1961         rd_s16b(&tmp16s);
1962         p_ptr->oldpx = (POSITION)tmp16s;
1963         rd_s16b(&tmp16s);
1964         p_ptr->oldpy = (POSITION)tmp16s;
1965
1966         if (z_older_than(10, 3, 13) && !current_floor_ptr->dun_level && !p_ptr->inside_arena) {p_ptr->oldpy = 33;p_ptr->oldpx = 131;}
1967
1968         /* Was p_ptr->rewards[MAX_BACT] */
1969         rd_s16b(&tmp16s);
1970         for (i = 0; i < tmp16s; i++)
1971         {
1972                 s16b tmp16s2;
1973                 rd_s16b(&tmp16s2);
1974         }
1975
1976         if (h_older_than(1, 7, 0, 3))
1977         {
1978                 rd_s16b(&tmp16s);
1979                 p_ptr->mhp = tmp16s;
1980
1981                 rd_s16b(&tmp16s);
1982                 p_ptr->chp = tmp16s;
1983
1984                 rd_u16b(&tmp16u);
1985                 p_ptr->chp_frac = (u32b)tmp16u;
1986         }
1987         else
1988         {
1989                 rd_s32b(&p_ptr->mhp);
1990                 rd_s32b(&p_ptr->chp);
1991                 rd_u32b(&p_ptr->chp_frac);
1992         }
1993
1994         if (h_older_than(1, 7, 0, 3))
1995         {
1996                 rd_s16b(&tmp16s);
1997                 p_ptr->msp = tmp16s;
1998
1999                 rd_s16b(&tmp16s);
2000                 p_ptr->csp = tmp16s;
2001
2002                 rd_u16b(&tmp16u);
2003                 p_ptr->csp_frac = (u32b)tmp16u;
2004         }
2005         else
2006         {
2007                 rd_s32b(&p_ptr->msp);
2008                 rd_s32b(&p_ptr->csp);
2009                 rd_u32b(&p_ptr->csp_frac);
2010         }
2011
2012         rd_s16b(&p_ptr->max_plv);
2013         if (z_older_than(10, 3, 8))
2014         {
2015                 rd_s16b(&tmp16s);
2016                 max_dlv[DUNGEON_ANGBAND] = tmp16s;
2017         }
2018         else
2019         {
2020                 byte max = (byte)max_d_idx;
2021
2022                 rd_byte(&max);
2023
2024                 for(i = 0; i < max; i++)
2025                 {
2026                         rd_s16b(&tmp16s);
2027                         max_dlv[i] = tmp16s;
2028                         if (max_dlv[i] > d_info[i].maxdepth) max_dlv[i] = d_info[i].maxdepth;
2029                 }
2030         }
2031
2032         /* Repair maximum player level */
2033         if (p_ptr->max_plv < p_ptr->lev) p_ptr->max_plv = p_ptr->lev;
2034
2035         /* More info */
2036         strip_bytes(8);
2037         rd_s16b(&p_ptr->sc);
2038         rd_s16b(&p_ptr->concent);
2039
2040         /* Read the flags */
2041         strip_bytes(2); /* Old "rest" */
2042         rd_s16b(&p_ptr->blind);
2043         rd_s16b(&p_ptr->paralyzed);
2044         rd_s16b(&p_ptr->confused);
2045         rd_s16b(&p_ptr->food);
2046         strip_bytes(4); /* Old "food_digested" / "protection" */
2047
2048         rd_s16b(&p_ptr->energy_need);
2049         if (z_older_than(11, 0, 13))
2050                 p_ptr->energy_need = 100 - p_ptr->energy_need;
2051         if (h_older_than(2, 1, 2, 0))
2052                 p_ptr->enchant_energy_need = 0;
2053         else
2054                 rd_s16b(&p_ptr->enchant_energy_need);
2055
2056         rd_s16b(&p_ptr->fast);
2057         rd_s16b(&p_ptr->slow);
2058         rd_s16b(&p_ptr->afraid);
2059         rd_s16b(&p_ptr->cut);
2060         rd_s16b(&p_ptr->stun);
2061         rd_s16b(&p_ptr->poisoned);
2062         rd_s16b(&p_ptr->image);
2063         rd_s16b(&p_ptr->protevil);
2064         rd_s16b(&p_ptr->invuln);
2065         if(z_older_than(10, 0, 0))
2066                 p_ptr->ult_res = 0;
2067         else
2068                 rd_s16b(&p_ptr->ult_res);
2069         rd_s16b(&p_ptr->hero);
2070         rd_s16b(&p_ptr->shero);
2071         rd_s16b(&p_ptr->shield);
2072         rd_s16b(&p_ptr->blessed);
2073         rd_s16b(&p_ptr->tim_invis);
2074         rd_s16b(&p_ptr->word_recall);
2075         if (z_older_than(10, 3, 8))
2076                 p_ptr->recall_dungeon = DUNGEON_ANGBAND;
2077         else
2078         {
2079                 rd_s16b(&tmp16s);
2080                 p_ptr->recall_dungeon = (byte)tmp16s;
2081         }
2082
2083         if (h_older_than(1, 5, 0, 0))
2084                 p_ptr->alter_reality = 0;
2085         else
2086                 rd_s16b(&p_ptr->alter_reality);
2087
2088         rd_s16b(&p_ptr->see_infra);
2089         rd_s16b(&p_ptr->tim_infra);
2090         rd_s16b(&p_ptr->oppose_fire);
2091         rd_s16b(&p_ptr->oppose_cold);
2092         rd_s16b(&p_ptr->oppose_acid);
2093         rd_s16b(&p_ptr->oppose_elec);
2094         rd_s16b(&p_ptr->oppose_pois);
2095         if (z_older_than(10,0,2)) p_ptr->tsuyoshi = 0;
2096         else rd_s16b(&p_ptr->tsuyoshi);
2097
2098         /* Old savefiles do not have the following fields... */
2099         if ((z_major == 2) && (z_minor == 0) && (z_patch == 6))
2100         {
2101                 p_ptr->tim_esp = 0;
2102                 p_ptr->wraith_form = 0;
2103                 p_ptr->resist_magic = 0;
2104                 p_ptr->tim_regen = 0;
2105                 p_ptr->kabenuke = 0;
2106                 p_ptr->tim_stealth = 0;
2107                 p_ptr->tim_levitation = 0;
2108                 p_ptr->tim_sh_touki = 0;
2109                 p_ptr->lightspeed = 0;
2110                 p_ptr->tsubureru = 0;
2111                 p_ptr->tim_res_nether = 0;
2112                 p_ptr->tim_res_time = 0;
2113                 p_ptr->mimic_form = 0;
2114                 p_ptr->tim_mimic = 0;
2115                 p_ptr->tim_sh_fire = 0;
2116
2117                 /* by henkma */
2118                 p_ptr->tim_reflect = 0;
2119                 p_ptr->multishadow = 0;
2120                 p_ptr->dustrobe = 0;
2121
2122                 p_ptr->chaos_patron = ((p_ptr->age + p_ptr->sc) % MAX_PATRON);
2123                 p_ptr->muta1 = 0;
2124                 p_ptr->muta2 = 0;
2125                 p_ptr->muta3 = 0;
2126                 get_virtues();
2127         }
2128         else
2129         {
2130                 rd_s16b(&p_ptr->tim_esp);
2131                 rd_s16b(&p_ptr->wraith_form);
2132                 rd_s16b(&p_ptr->resist_magic);
2133                 rd_s16b(&p_ptr->tim_regen);
2134                 rd_s16b(&p_ptr->kabenuke);
2135                 rd_s16b(&p_ptr->tim_stealth);
2136                 rd_s16b(&p_ptr->tim_levitation);
2137                 rd_s16b(&p_ptr->tim_sh_touki);
2138                 rd_s16b(&p_ptr->lightspeed);
2139                 rd_s16b(&p_ptr->tsubureru);
2140                 if (z_older_than(10, 4, 7))
2141                         p_ptr->magicdef = 0;
2142                 else
2143                         rd_s16b(&p_ptr->magicdef);
2144                 rd_s16b(&p_ptr->tim_res_nether);
2145                 if (z_older_than(10, 4, 11))
2146                 {
2147                         p_ptr->tim_res_time = 0;
2148                         p_ptr->mimic_form = 0;
2149                         p_ptr->tim_mimic = 0;
2150                         p_ptr->tim_sh_fire = 0;
2151                 }
2152                 else
2153                 {
2154                         rd_s16b(&p_ptr->tim_res_time);
2155                         rd_byte(&tmp8u);
2156                         p_ptr->mimic_form = (IDX)tmp8u;
2157                         rd_s16b(&p_ptr->tim_mimic);
2158                         rd_s16b(&p_ptr->tim_sh_fire);
2159                 }
2160
2161                 if (z_older_than(11, 0, 99))
2162                 {
2163                         p_ptr->tim_sh_holy = 0;
2164                         p_ptr->tim_eyeeye = 0;
2165                 }
2166                 else
2167                 {
2168                         rd_s16b(&p_ptr->tim_sh_holy);
2169                         rd_s16b(&p_ptr->tim_eyeeye);
2170                 }
2171
2172                 /* by henkma */
2173                 if ( z_older_than(11,0,3) ){
2174                   p_ptr->tim_reflect=0;
2175                   p_ptr->multishadow=0;
2176                   p_ptr->dustrobe=0;
2177                 }
2178                 else {
2179                   rd_s16b(&p_ptr->tim_reflect);
2180                   rd_s16b(&p_ptr->multishadow);
2181                   rd_s16b(&p_ptr->dustrobe);
2182                 }
2183
2184                 rd_s16b(&p_ptr->chaos_patron);
2185                 rd_u32b(&p_ptr->muta1);
2186                 rd_u32b(&p_ptr->muta2);
2187                 rd_u32b(&p_ptr->muta3);
2188
2189                 for (i = 0; i < 8; i++)
2190                         rd_s16b(&p_ptr->virtues[i]);
2191                 for (i = 0; i < 8; i++)
2192                         rd_s16b(&p_ptr->vir_types[i]);
2193         }
2194
2195         /* Calc the regeneration modifier for mutations */
2196         p_ptr->mutant_regenerate_mod = calc_mutant_regenerate_mod();
2197
2198         if (z_older_than(10,0,9))
2199         {
2200                 rd_byte(&tmp8u);
2201                 if (tmp8u) p_ptr->special_attack = ATTACK_CONFUSE;
2202                 p_ptr->ele_attack = 0;
2203         }
2204         else
2205         {
2206                 rd_s16b(&p_ptr->ele_attack);
2207                 rd_u32b(&p_ptr->special_attack);
2208         }
2209         if (p_ptr->special_attack & KAMAE_MASK) p_ptr->action = ACTION_KAMAE;
2210         else if (p_ptr->special_attack & KATA_MASK) p_ptr->action = ACTION_KATA;
2211         if (z_older_than(10,0,12))
2212         {
2213                 p_ptr->ele_immune = 0;
2214                 p_ptr->special_defense = 0;
2215         }
2216         else
2217         {
2218                 rd_s16b(&p_ptr->ele_immune);
2219                 rd_u32b(&p_ptr->special_defense);
2220         }
2221         rd_byte(&p_ptr->knowledge);
2222
2223         rd_byte(&tmp8u);
2224         p_ptr->autopick_autoregister = tmp8u ? TRUE : FALSE;
2225
2226         rd_byte(&tmp8u);
2227         rd_byte(&tmp8u);
2228         p_ptr->action = (ACTION_IDX)tmp8u;
2229         if (!z_older_than(10, 4, 3))
2230         {
2231                 rd_byte(&tmp8u);
2232                 if (tmp8u) p_ptr->action = ACTION_LEARN;
2233         }
2234         rd_byte((byte *)&preserve_mode);
2235         rd_byte((byte *)&p_ptr->wait_report_score);
2236
2237         /* Future use */
2238         for (i = 0; i < 48; i++) rd_byte(&tmp8u);
2239
2240         /* Skip the flags */
2241         strip_bytes(12);
2242
2243
2244         /* Hack -- the two "special seeds" */
2245         rd_u32b(&seed_flavor);
2246         rd_u32b(&seed_town);
2247
2248
2249         /* Special stuff */
2250         rd_u16b(&p_ptr->panic_save);
2251         rd_u16b(&p_ptr->total_winner);
2252         rd_u16b(&p_ptr->noscore);
2253
2254
2255         /* Read "death" */
2256         rd_byte(&tmp8u);
2257         p_ptr->is_dead = tmp8u;
2258
2259         /* Read "feeling" */
2260         rd_byte(&p_ptr->feeling);
2261
2262         switch (p_ptr->start_race)
2263         {
2264         case RACE_VAMPIRE:
2265         case RACE_SKELETON:
2266         case RACE_ZOMBIE:
2267         case RACE_SPECTRE:
2268                 current_world_ptr->game_turn_limit = TURNS_PER_TICK * TOWN_DAWN * MAX_DAYS + TURNS_PER_TICK * TOWN_DAWN * 3 / 4;
2269                 break;
2270         default:
2271                 current_world_ptr->game_turn_limit = TURNS_PER_TICK * TOWN_DAWN * (MAX_DAYS - 1) + TURNS_PER_TICK * TOWN_DAWN * 3 / 4;
2272                 break;
2273         }
2274         current_world_ptr->dungeon_turn_limit = TURNS_PER_TICK * TOWN_DAWN * (MAX_DAYS - 1) + TURNS_PER_TICK * TOWN_DAWN * 3 / 4;
2275
2276         /* Turn when level began */
2277         rd_s32b(&current_floor_ptr->generated_turn);
2278
2279         if (h_older_than(1, 7, 0, 4))
2280         {
2281                 p_ptr->feeling_turn = current_floor_ptr->generated_turn;
2282         }
2283         else
2284         {
2285                 /* Turn of last "feeling" */
2286                 rd_s32b(&p_ptr->feeling_turn);
2287         }
2288
2289         /* Current current_world_ptr->game_turn */
2290         rd_s32b(&current_world_ptr->game_turn);
2291
2292         if (z_older_than(10, 3, 12))
2293         {
2294                 current_world_ptr->dungeon_turn = current_world_ptr->game_turn;
2295         }
2296         else rd_s32b(&current_world_ptr->dungeon_turn);
2297
2298         if (z_older_than(11, 0, 13))
2299         {
2300                 current_floor_ptr->generated_turn /= 2;
2301                 p_ptr->feeling_turn /= 2;
2302                 current_world_ptr->game_turn /= 2;
2303                 current_world_ptr->dungeon_turn /= 2;
2304         }
2305
2306         if (z_older_than(10, 3, 13))
2307         {
2308                 old_battle = current_world_ptr->game_turn;
2309         }
2310         else rd_s32b(&old_battle);
2311
2312         if (z_older_than(10,0,3))
2313         {
2314                 determine_today_mon(TRUE);
2315         }
2316         else
2317         {
2318                 rd_s16b(&today_mon);
2319                 rd_s16b(&p_ptr->today_mon);
2320         }
2321
2322         if (z_older_than(10,0,7))
2323         {
2324                 p_ptr->riding = 0;
2325         }
2326         else
2327         {
2328                 rd_s16b(&p_ptr->riding);
2329         }
2330
2331         /* Current floor_id */
2332         if (h_older_than(1, 5, 0, 0))
2333         {
2334                 p_ptr->floor_id = 0;
2335         }
2336         else
2337         {
2338                 rd_s16b(&p_ptr->floor_id);
2339         }
2340
2341         if (h_older_than(1, 5, 0, 2))
2342         {
2343                 /* Nothing to do */
2344         }
2345         else
2346         {
2347                 /* Get number of party_mon array */
2348                 rd_s16b(&tmp16s);
2349
2350                 /* Strip old temporary preserved pets */
2351                 for (i = 0; i < tmp16s; i++)
2352                 {
2353                         monster_type dummy_mon;
2354
2355                         rd_monster(&dummy_mon);
2356                 }
2357         }
2358
2359         if (z_older_than(10,1,2))
2360         {
2361                 current_world_ptr->play_time = 0;
2362         }
2363         else
2364         {
2365                 rd_u32b(&current_world_ptr->play_time);
2366         }
2367
2368         if (z_older_than(10,3,9))
2369         {
2370                 p_ptr->visit = 1L;
2371         }
2372         else if (z_older_than(10, 3, 10))
2373         {
2374                 rd_s32b(&tmp32s);
2375                 p_ptr->visit = 1L;
2376         }
2377         else
2378         {
2379                 rd_s32b(&tmp32s);
2380                 p_ptr->visit = (BIT_FLAGS)tmp32s;
2381         }
2382         if (!z_older_than(11, 0, 5))
2383         {
2384                 rd_u32b(&p_ptr->count);
2385         }
2386 }
2387
2388
2389 /*!
2390  * @brief プレイヤーの所持品情報を読み込む / Read the player inventory
2391  * @return なし
2392  * @details
2393  * Note that the inventory changed in Angband 2.7.4.  Two extra
2394  * pack slots were added and the equipment was rearranged.  Note
2395  * that these two features combine when parsing old save-files, in
2396  * which items from the old "aux" slot are "carried", perhaps into
2397  * one of the two new "inventory" slots.
2398  *
2399  * Note that the inventory is "re-sorted" later by "dungeon()".
2400  */
2401 static errr rd_inventory(void)
2402 {
2403         int slot = 0;
2404
2405         object_type forge;
2406         object_type *q_ptr;
2407
2408         /* No weight */
2409         p_ptr->total_weight = 0;
2410
2411         /* No items */
2412         inven_cnt = 0;
2413         equip_cnt = 0;
2414
2415         /* Read until done */
2416         while (1)
2417         {
2418                 u16b n;
2419
2420                 /* Get the next item index */
2421                 rd_u16b(&n);
2422
2423                 /* Nope, we reached the end */
2424                 if (n == 0xFFFF) break;
2425                 q_ptr = &forge;
2426                 object_wipe(q_ptr);
2427
2428                 /* Read the item */
2429                 rd_item(q_ptr);
2430
2431                 /* Hack -- verify item */
2432                 if (!q_ptr->k_idx) return (53);
2433
2434                 /* Wield equipment */
2435                 if (n >= INVEN_RARM)
2436                 {
2437                         q_ptr->marked |= OM_TOUCHED;
2438                         object_copy(&inventory[n], q_ptr);
2439
2440                         /* Add the weight */
2441                         p_ptr->total_weight += (q_ptr->number * q_ptr->weight);
2442
2443                         /* One more item */
2444                         equip_cnt++;
2445                 }
2446
2447                 /* Warning -- backpack is full */
2448                 else if (inven_cnt == INVEN_PACK)
2449                 {
2450                         note(_("持ち物の中のアイテムが多すぎる！", "Too many items in the inventory!"));
2451
2452                         /* Fail */
2453                         return (54);
2454                 }
2455
2456                 /* Carry inventory */
2457                 else
2458                 {
2459                         /* Get a slot */
2460                         n = slot++;
2461
2462                         q_ptr->marked |= OM_TOUCHED;
2463                         object_copy(&inventory[n], q_ptr);
2464
2465                         /* Add the weight */
2466                         p_ptr->total_weight += (q_ptr->number * q_ptr->weight);
2467
2468                         /* One more item */
2469                         inven_cnt++;
2470                 }
2471         }
2472
2473         /* Success */
2474         return (0);
2475 }
2476
2477
2478 /*!
2479  * @brief メッセージログを読み込む / Read the saved messages
2480  * @return なし
2481  */
2482 static void rd_messages(void)
2483 {
2484         int i;
2485         char buf[128];
2486         int message_max;
2487
2488
2489         if (h_older_than(2, 2, 0, 75))
2490         {
2491                 u16b num;
2492                 /* Total */
2493                 rd_u16b(&num);
2494                 message_max = (int)num;
2495
2496                 /* Read the messages */
2497                 for (i = 0; i < message_max; i++)
2498                 {
2499                         /* Read the message */
2500                         rd_string(buf, sizeof(buf));
2501
2502                         /* Save the message */
2503                         message_add(buf);
2504                 }
2505         }
2506         else
2507         {
2508                 u32b num;
2509                 /* Total */
2510                 rd_u32b(&num);
2511                 message_max = (int)num;
2512
2513                 /* Read the messages */
2514                 for (i = 0; i < message_max; i++)
2515                 {
2516                         /* Read the message */
2517                         rd_string(buf, sizeof(buf));
2518
2519                         /* Save the message */
2520                         message_add(buf);
2521                 }
2522         }
2523
2524 }
2525
2526
2527
2528 /* Old hidden trap flag */
2529 #define CAVE_TRAP       0x8000
2530
2531 /*** Terrain Feature Indexes (see "lib/edit/f_info.txt") ***/
2532 #define OLD_FEAT_INVIS              0x02
2533 #define OLD_FEAT_GLYPH              0x03
2534 #define OLD_FEAT_QUEST_ENTER        0x08
2535 #define OLD_FEAT_QUEST_EXIT         0x09
2536 #define OLD_FEAT_MINOR_GLYPH        0x40
2537 #define OLD_FEAT_BLDG_1             0x81
2538 #define OLD_FEAT_MIRROR             0xc3
2539
2540 /* Old quests */
2541 #define OLD_QUEST_WATER_CAVE 18
2542
2543 /* Quest constants */
2544 #define QUEST_OLD_CASTLE  27
2545 #define QUEST_ROYAL_CRYPT 28
2546
2547 /*!
2548  * @brief メッセージログを読み込む / Read the dungeon (old method)
2549  * @return なし
2550  * @details
2551  * The monsters/objects must be loaded in the same order
2552  * that they were stored, since the actual indexes matter.
2553  */
2554 static errr rd_dungeon_old(void)
2555 {
2556         int i, y, x;
2557         int ymax, xmax;
2558         byte count;
2559         byte tmp8u;
2560         s16b tmp16s;
2561         u16b limit;
2562         grid_type *g_ptr;
2563
2564
2565         /*** Basic info ***/
2566
2567         /* Header info */
2568         rd_s16b(&tmp16s);
2569         current_floor_ptr->dun_level = (DEPTH)tmp16s;
2570         if (z_older_than(10, 3, 8)) p_ptr->dungeon_idx = DUNGEON_ANGBAND;
2571         else
2572         {
2573                 rd_byte(&tmp8u);
2574                 p_ptr->dungeon_idx = (IDX)tmp8u;
2575         }
2576
2577         /* Set the base level for old versions */
2578         current_floor_ptr->base_level = current_floor_ptr->dun_level;
2579
2580         rd_s16b(&tmp16s);
2581         current_floor_ptr->base_level = (DEPTH)tmp16s;
2582
2583         rd_s16b(&tmp16s);
2584         current_floor_ptr->num_repro = (MONSTER_NUMBER)tmp16s;
2585         rd_s16b(&tmp16s);
2586         p_ptr->y = (POSITION)tmp16s;
2587         rd_s16b(&tmp16s);
2588         p_ptr->x = (POSITION)tmp16s;
2589         if (z_older_than(10, 3, 13) && !current_floor_ptr->dun_level && !p_ptr->inside_arena) {p_ptr->y = 33;p_ptr->x = 131;}
2590         rd_s16b(&tmp16s);
2591         current_floor_ptr->height = (POSITION)tmp16s;
2592         rd_s16b(&tmp16s);
2593         current_floor_ptr->width = (POSITION)tmp16s;
2594         rd_s16b(&tmp16s); /* max_panel_rows */
2595         rd_s16b(&tmp16s); /* max_panel_cols */
2596
2597 #if 0
2598         if (!p_ptr->y || !p_ptr->x) {p_ptr->y = 10;p_ptr->x = 10;}/* ダンジョン生成に失敗してセグメンテったときの復旧用 */
2599 #endif
2600
2601         /* Maximal size */
2602         ymax = current_floor_ptr->height;
2603         xmax = current_floor_ptr->width;
2604
2605
2606         /*** Run length decoding ***/
2607
2608         /* Load the dungeon data */
2609         for (x = y = 0; y < ymax; )
2610         {
2611                 u16b info;
2612
2613                 /* Grab RLE info */
2614                 rd_byte(&count);
2615                 if (z_older_than(10,3,6))
2616                 {
2617                         rd_byte(&tmp8u);
2618                         info = (u16b)tmp8u;
2619                 }
2620                 else
2621                 {
2622                         rd_u16b(&info);
2623
2624                         /* Decline invalid flags */
2625                         info &= ~(CAVE_LITE | CAVE_VIEW | CAVE_MNLT | CAVE_MNDK);
2626                 }
2627
2628                 /* Apply the RLE info */
2629                 for (i = count; i > 0; i--)
2630                 {
2631                         /* Access the current_floor_ptr->grid_array */
2632                         g_ptr = &current_floor_ptr->grid_array[y][x];
2633
2634                         /* Extract "info" */
2635                         g_ptr->info = info;
2636
2637                         /* Advance/Wrap */
2638                         if (++x >= xmax)
2639                         {
2640                                 /* Wrap */
2641                                 x = 0;
2642
2643                                 /* Advance/Wrap */
2644                                 if (++y >= ymax) break;
2645                         }
2646                 }
2647         }
2648
2649
2650         /*** Run length decoding ***/
2651
2652         /* Load the dungeon data */
2653         for (x = y = 0; y < ymax; )
2654         {
2655                 /* Grab RLE info */
2656                 rd_byte(&count);
2657                 rd_byte(&tmp8u);
2658
2659                 /* Apply the RLE info */
2660                 for (i = count; i > 0; i--)
2661                 {
2662                         /* Access the current_floor_ptr->grid_array */
2663                         g_ptr = &current_floor_ptr->grid_array[y][x];
2664
2665                         /* Extract "feat" */
2666                         g_ptr->feat = (s16b)tmp8u;
2667
2668                         /* Advance/Wrap */
2669                         if (++x >= xmax)
2670                         {
2671                                 /* Wrap */
2672                                 x = 0;
2673
2674                                 /* Advance/Wrap */
2675                                 if (++y >= ymax) break;
2676                         }
2677                 }
2678         }
2679
2680         /*** Run length decoding ***/
2681
2682         /* Load the dungeon data */
2683         for (x = y = 0; y < ymax; )
2684         {
2685                 /* Grab RLE info */
2686                 rd_byte(&count);
2687                 rd_byte(&tmp8u);
2688
2689                 /* Apply the RLE info */
2690                 for (i = count; i > 0; i--)
2691                 {
2692                         /* Access the current_floor_ptr->grid_array */
2693                         g_ptr = &current_floor_ptr->grid_array[y][x];
2694
2695                         /* Extract "mimic" */
2696                         g_ptr->mimic = (s16b)tmp8u;
2697
2698                         /* Advance/Wrap */
2699                         if (++x >= xmax)
2700                         {
2701                                 /* Wrap */
2702                                 x = 0;
2703
2704                                 /* Advance/Wrap */
2705                                 if (++y >= ymax) break;
2706                         }
2707                 }
2708         }
2709
2710         /*** Run length decoding ***/
2711
2712         /* Load the dungeon data */
2713         for (x = y = 0; y < ymax; )
2714         {
2715                 /* Grab RLE info */
2716                 rd_byte(&count);
2717                 rd_s16b(&tmp16s);
2718
2719                 /* Apply the RLE info */
2720                 for (i = count; i > 0; i--)
2721                 {
2722                         /* Access the current_floor_ptr->grid_array */
2723                         g_ptr = &current_floor_ptr->grid_array[y][x];
2724
2725                         /* Extract "feat" */
2726                         g_ptr->special = tmp16s;
2727
2728                         /* Advance/Wrap */
2729                         if (++x >= xmax)
2730                         {
2731                                 /* Wrap */
2732                                 x = 0;
2733
2734                                 /* Advance/Wrap */
2735                                 if (++y >= ymax) break;
2736                         }
2737                 }
2738         }
2739
2740         /* Convert current_floor_ptr->grid_array data */
2741         if (z_older_than(11, 0, 99))
2742         {
2743                 for (y = 0; y < ymax; y++) for (x = 0; x < xmax; x++)
2744                 {
2745                         /* Wipe old unused flags */
2746                         current_floor_ptr->grid_array[y][x].info &= ~(CAVE_MASK);
2747                 }
2748         }
2749
2750         if (h_older_than(1, 1, 1, 0))
2751         {
2752                 for (y = 0; y < ymax; y++) for (x = 0; x < xmax; x++)
2753                 {
2754                         /* Access the current_floor_ptr->grid_array */
2755                         g_ptr = &current_floor_ptr->grid_array[y][x];
2756
2757                         /* Very old */
2758                         if (g_ptr->feat == OLD_FEAT_INVIS)
2759                         {
2760                                 g_ptr->feat = feat_floor;
2761                                 g_ptr->info |= CAVE_TRAP;
2762                         }
2763
2764                         /* Older than 1.1.1 */
2765                         if (g_ptr->feat == OLD_FEAT_MIRROR)
2766                         {
2767                                 g_ptr->feat = feat_floor;
2768                                 g_ptr->info |= CAVE_OBJECT;
2769                         }
2770                 }
2771         }
2772
2773         if (h_older_than(1, 3, 1, 0))
2774         {
2775                 for (y = 0; y < ymax; y++) for (x = 0; x < xmax; x++)
2776                 {
2777                         /* Access the current_floor_ptr->grid_array */
2778                         g_ptr = &current_floor_ptr->grid_array[y][x];
2779
2780                         /* Old CAVE_IN_MIRROR flag */
2781                         if (g_ptr->info & CAVE_OBJECT)
2782                         {
2783                                 g_ptr->mimic = feat_mirror;
2784                         }
2785
2786                         /* Runes will be mimics and flags */
2787                         else if ((g_ptr->feat == OLD_FEAT_MINOR_GLYPH) ||
2788                                  (g_ptr->feat == OLD_FEAT_GLYPH))
2789                         {
2790                                 g_ptr->info |= CAVE_OBJECT;
2791                                 g_ptr->mimic = g_ptr->feat;
2792                                 g_ptr->feat = feat_floor;
2793                         }
2794
2795                         /* Hidden traps will be trap terrains mimicing floor */
2796                         else if (g_ptr->info & CAVE_TRAP)
2797                         {
2798                                 g_ptr->info &= ~CAVE_TRAP;
2799                                 g_ptr->mimic = g_ptr->feat;
2800                                 g_ptr->feat = choose_random_trap();
2801                         }
2802
2803                         /* Another hidden trap */
2804                         else if (g_ptr->feat == OLD_FEAT_INVIS)
2805                         {
2806                                 g_ptr->mimic = feat_floor;
2807                                 g_ptr->feat = feat_trap_open;
2808                         }
2809                 }
2810         }
2811
2812         /* Quest 18 was removed */
2813         if (h_older_than(1, 7, 0, 6) && !vanilla_town)
2814         {
2815                 for (y = 0; y < ymax; y++) for (x = 0; x < xmax; x++)
2816                 {
2817                         /* Access the current_floor_ptr->grid_array */
2818                         g_ptr = &current_floor_ptr->grid_array[y][x];
2819
2820                         if ((g_ptr->special == OLD_QUEST_WATER_CAVE) && !current_floor_ptr->dun_level)
2821                         {
2822                                 if (g_ptr->feat == OLD_FEAT_QUEST_ENTER)
2823                                 {
2824                                         g_ptr->feat = feat_tree;
2825                                         g_ptr->special = 0;
2826                                 }
2827                                 else if (g_ptr->feat == OLD_FEAT_BLDG_1)
2828                                 {
2829                                         g_ptr->special = lite_town ? QUEST_OLD_CASTLE : QUEST_ROYAL_CRYPT;
2830                                 }
2831                         }
2832                         else if ((g_ptr->feat == OLD_FEAT_QUEST_EXIT) &&
2833                                  (p_ptr->inside_quest == OLD_QUEST_WATER_CAVE))
2834                         {
2835                                 g_ptr->feat = feat_up_stair;
2836                                 g_ptr->special = 0;
2837                         }
2838                 }
2839         }
2840
2841         /*** Objects ***/
2842
2843         /* Read the item count */
2844         rd_u16b(&limit);
2845
2846         /* Verify maximum */
2847         if (limit > current_floor_ptr->max_o_idx)
2848         {
2849                 note(format(_("アイテムの配列が大きすぎる(%d)！", "Too many (%d) object entries!"), limit));
2850                 return (151);
2851         }
2852
2853         /* Read the dungeon items */
2854         for (i = 1; i < limit; i++)
2855         {
2856                 OBJECT_IDX o_idx;
2857
2858                 object_type *o_ptr;
2859
2860
2861                 /* Get a new record */
2862                 o_idx = o_pop();
2863
2864                 if (i != o_idx)
2865                 {
2866                         note(format(_("アイテム配置エラー (%d <> %d)", "Object allocation error (%d <> %d)"), i, o_idx));
2867                         return (152);
2868                 }
2869
2870
2871                 /* Acquire place */
2872                 o_ptr = &current_floor_ptr->o_list[o_idx];
2873
2874                 /* Read the item */
2875                 rd_item(o_ptr);
2876
2877
2878                 /* XXX XXX */
2879
2880                 if (o_ptr->held_m_idx)
2881                 {
2882                         monster_type *m_ptr;
2883                         m_ptr = &current_floor_ptr->m_list[o_ptr->held_m_idx];
2884
2885                         /* Build a stack */
2886                         o_ptr->next_o_idx = m_ptr->hold_o_idx;
2887
2888                         m_ptr->hold_o_idx = o_idx;
2889                 }
2890
2891                 /* Dungeon */
2892                 else
2893                 {
2894                         /* Access the item location */
2895                         g_ptr = &current_floor_ptr->grid_array[o_ptr->iy][o_ptr->ix];
2896
2897                         /* Build a stack */
2898                         o_ptr->next_o_idx = g_ptr->o_idx;
2899
2900                         g_ptr->o_idx = o_idx;
2901                 }
2902         }
2903
2904
2905         /*** Monsters ***/
2906
2907         /* Read the monster count */
2908         rd_u16b(&limit);
2909
2910         /* Hack -- verify */
2911         if (limit > current_floor_ptr->max_m_idx)
2912         {
2913                 note(format(_("モンスターの配列が大きすぎる(%d)！", "Too many (%d) monster entries!"), limit));
2914                 return (161);
2915         }
2916
2917         /* Read the monsters */
2918         for (i = 1; i < limit; i++)
2919         {
2920                 MONSTER_IDX m_idx;
2921                 monster_type *m_ptr;
2922
2923                 /* Get a new record */
2924                 m_idx = m_pop();
2925
2926                 if (i != m_idx)
2927                 {
2928                         note(format(_("モンスター配置エラー (%d <> %d)", "Monster allocation error (%d <> %d)"), i, m_idx));
2929                         return (162);
2930                 }
2931
2932
2933                 /* Acquire monster */
2934                 m_ptr = &current_floor_ptr->m_list[m_idx];
2935
2936                 /* Read the monster */
2937                 rd_monster(m_ptr);
2938
2939
2940                 /* Access grid */
2941                 g_ptr = &current_floor_ptr->grid_array[m_ptr->fy][m_ptr->fx];
2942
2943                 /* Mark the location */
2944                 g_ptr->m_idx = m_idx;
2945
2946                 /* Count */
2947                 real_r_ptr(m_ptr)->cur_num++;
2948         }
2949
2950         /*** Success ***/
2951
2952         /* The dungeon is ready */
2953         if (z_older_than(10, 3, 13) && !current_floor_ptr->dun_level && !p_ptr->inside_arena)
2954                 character_dungeon = FALSE;
2955         else
2956                 character_dungeon = TRUE;
2957
2958         /* Success */
2959         return (0);
2960 }
2961
2962
2963 /*!
2964  * @brief 保存されたフロアを読み込む / Read the saved floor
2965  * @return info読み込みエラーコード
2966  * @details
2967  * この関数は、セーブデータの互換性を保つために多くのデータ改変処理を備えている。
2968  * 現在確認している処理は以下の通り、
2969  * <ul>
2970  * <li>1.7.0.2で8bitだったgrid_typeのfeat,mimicのID値を16bitに拡張する処理。</li>
2971  * <li>1.7.0.8までに廃止、IDなどを差し替えたクエスト番号を置換する処理。</li>
2972  * </ul>
2973  * The monsters/objects must be loaded in the same order
2974  * that they were stored, since the actual indexes matter.
2975  */
2976 static errr rd_saved_floor(saved_floor_type *sf_ptr)
2977 {
2978         POSITION ymax, xmax;
2979         POSITION y, x;
2980         int i;
2981         byte count;
2982         byte tmp8u;
2983         s16b tmp16s;
2984         u16b tmp16u;
2985         s32b tmp32s;
2986         u32b tmp32u;
2987         u16b limit;
2988
2989         cave_template_type *templates;
2990
2991
2992         /*** Wipe all current_floor_ptr->grid_array ***/
2993         clear_cave();
2994
2995
2996         /*** Basic info ***/
2997
2998         /* Dungeon floor specific info follows */
2999
3000         if (!sf_ptr)
3001         {
3002                 /*** Not a saved floor ***/
3003
3004                 rd_s16b(&tmp16s);
3005                 current_floor_ptr->dun_level = (DEPTH)tmp16s;
3006                 current_floor_ptr->base_level = current_floor_ptr->dun_level;
3007         }
3008         else
3009         {
3010                 /*** The saved floor ***/
3011
3012                 rd_s16b(&tmp16s);
3013                 if (tmp16s != sf_ptr->floor_id) return 171;
3014
3015                 rd_byte(&tmp8u);
3016                 if (tmp8u != sf_ptr->savefile_id) return 171;
3017
3018                 rd_s16b(&tmp16s);
3019                 if (tmp16s != sf_ptr->dun_level) return 171;
3020                 current_floor_ptr->dun_level = sf_ptr->dun_level;
3021
3022                 rd_s32b(&tmp32s);
3023                 if (tmp32s != sf_ptr->last_visit) return 171;
3024
3025                 rd_u32b(&tmp32u);
3026                 if (tmp32u != sf_ptr->visit_mark) return 171;
3027
3028                 rd_s16b(&tmp16s);
3029                 if (tmp16s != sf_ptr->upper_floor_id) return 171;
3030
3031                 rd_s16b(&tmp16s);
3032                 if (tmp16s != sf_ptr->lower_floor_id) return 171;
3033         }
3034
3035         rd_s16b(&tmp16s);
3036         current_floor_ptr->base_level = (DEPTH)tmp16s;
3037         rd_s16b(&tmp16s);
3038         current_floor_ptr->num_repro = (MONSTER_NUMBER)tmp16s;
3039
3040         rd_u16b(&tmp16u);
3041         p_ptr->y = (POSITION)tmp16u;
3042
3043         rd_u16b(&tmp16u);
3044         p_ptr->x = (POSITION)tmp16u;
3045
3046         rd_s16b(&tmp16s);
3047         current_floor_ptr->height = (POSITION)tmp16s;
3048         rd_s16b(&tmp16s);
3049         current_floor_ptr->width = (POSITION)tmp16s;
3050
3051         rd_byte(&p_ptr->feeling);
3052
3053
3054
3055         /*** Read template for grid_type ***/
3056
3057         /* Read the template count */
3058         rd_u16b(&limit);
3059
3060         /* Allocate the "template" array */
3061         C_MAKE(templates, limit, cave_template_type);
3062
3063         /* Read the templates */
3064         for (i = 0; i < limit; i++)
3065         {
3066                 cave_template_type *ct_ptr = &templates[i];
3067
3068                 /* Read it */
3069                 rd_u16b(&tmp16u);
3070                 ct_ptr->info = (BIT_FLAGS)tmp16u;
3071                 if (h_older_than(1, 7, 0, 2))
3072                 {
3073                         rd_byte(&tmp8u);
3074                         ct_ptr->feat = (s16b)tmp8u;
3075                         rd_byte(&tmp8u);
3076                         ct_ptr->mimic = (s16b)tmp8u;
3077                 }
3078                 else
3079                 {
3080                         rd_s16b(&ct_ptr->feat);
3081                         rd_s16b(&ct_ptr->mimic);
3082                 }
3083                 rd_s16b(&ct_ptr->special);
3084         }
3085
3086         /* Maximal size */
3087         ymax = current_floor_ptr->height;
3088         xmax = current_floor_ptr->width;
3089
3090
3091         /*** Run length decoding ***/
3092
3093         /* Load the dungeon data */
3094         for (x = y = 0; y < ymax; )
3095         {
3096                 u16b id;
3097
3098                 /* Grab RLE info */
3099                 rd_byte(&count);
3100
3101                 id = 0;
3102                 do
3103                 {
3104                         rd_byte(&tmp8u);
3105                         id += tmp8u;
3106                 } while (tmp8u == MAX_UCHAR);
3107
3108                 /* Apply the RLE info */
3109                 for (i = count; i > 0; i--)
3110                 {
3111                         /* Access the current_floor_ptr->grid_array */
3112                         grid_type *g_ptr = &current_floor_ptr->grid_array[y][x];
3113
3114                         /* Extract current_floor_ptr->grid_array data */
3115                         g_ptr->info = templates[id].info;
3116                         g_ptr->feat = templates[id].feat;
3117                         g_ptr->mimic = templates[id].mimic;
3118                         g_ptr->special = templates[id].special;
3119
3120                         /* Advance/Wrap */
3121                         if (++x >= xmax)
3122                         {
3123                                 /* Wrap */
3124                                 x = 0;
3125
3126                                 /* Advance/Wrap */
3127                                 if (++y >= ymax) break;
3128                         }
3129                 }
3130         }
3131
3132         /* Quest 18 was removed */
3133         if (h_older_than(1, 7, 0, 6) && !vanilla_town)
3134         {
3135                 for (y = 0; y < ymax; y++) for (x = 0; x < xmax; x++)
3136                 {
3137                         /* Access the current_floor_ptr->grid_array */
3138                         grid_type *g_ptr = &current_floor_ptr->grid_array[y][x];
3139
3140                         if ((g_ptr->special == OLD_QUEST_WATER_CAVE) && !current_floor_ptr->dun_level)
3141                         {
3142                                 if (g_ptr->feat == OLD_FEAT_QUEST_ENTER)
3143                                 {
3144                                         g_ptr->feat = feat_tree;
3145                                         g_ptr->special = 0;
3146                                 }
3147                                 else if (g_ptr->feat == OLD_FEAT_BLDG_1)
3148                                 {
3149                                         g_ptr->special = lite_town ? QUEST_OLD_CASTLE : QUEST_ROYAL_CRYPT;
3150                                 }
3151                         }
3152                         else if ((g_ptr->feat == OLD_FEAT_QUEST_EXIT) &&
3153                                 (p_ptr->inside_quest == OLD_QUEST_WATER_CAVE))
3154                         {
3155                                 g_ptr->feat = feat_up_stair;
3156                                 g_ptr->special = 0;
3157                         }
3158                 }
3159         }
3160
3161         /* Free the "template" array */
3162         C_KILL(templates, limit, cave_template_type);
3163
3164
3165         /*** Objects ***/
3166
3167         /* Read the item count */
3168         rd_u16b(&limit);
3169
3170         /* Verify maximum */
3171         if (limit > current_floor_ptr->max_o_idx) return 151;
3172
3173
3174         /* Read the dungeon items */
3175         for (i = 1; i < limit; i++)
3176         {
3177                 OBJECT_IDX o_idx;
3178                 object_type *o_ptr;
3179
3180
3181                 /* Get a new record */
3182                 o_idx = o_pop();
3183
3184                 if (i != o_idx) return 152;
3185
3186                 /* Acquire place */
3187                 o_ptr = &current_floor_ptr->o_list[o_idx];
3188
3189                 /* Read the item */
3190                 rd_item(o_ptr);
3191
3192                 if (o_ptr->held_m_idx)
3193                 {
3194                         monster_type *m_ptr;
3195                         m_ptr = &current_floor_ptr->m_list[o_ptr->held_m_idx];
3196
3197                         /* Build a stack */
3198                         o_ptr->next_o_idx = m_ptr->hold_o_idx;
3199
3200                         m_ptr->hold_o_idx = o_idx;
3201                 }
3202
3203                 /* Dungeon */
3204                 else
3205                 {
3206                         /* Access the item location */
3207                         grid_type *g_ptr = &current_floor_ptr->grid_array[o_ptr->iy][o_ptr->ix];
3208
3209                         /* Build a stack */
3210                         o_ptr->next_o_idx = g_ptr->o_idx;
3211
3212                         g_ptr->o_idx = o_idx;
3213                 }
3214         }
3215
3216
3217         /*** Monsters ***/
3218
3219         /* Read the monster count */
3220         rd_u16b(&limit);
3221
3222         /* Hack -- verify */
3223         if (limit > current_floor_ptr->max_m_idx) return 161;
3224
3225         /* Read the monsters */
3226         for (i = 1; i < limit; i++)
3227         {
3228                 grid_type *g_ptr;
3229                 MONSTER_IDX m_idx;
3230                 monster_type *m_ptr;
3231
3232                 /* Get a new record */
3233                 m_idx = m_pop();
3234
3235                 if (i != m_idx) return 162;
3236
3237
3238                 /* Acquire monster */
3239                 m_ptr = &current_floor_ptr->m_list[m_idx];
3240
3241                 /* Read the monster */
3242                 rd_monster(m_ptr);
3243
3244
3245                 /* Access grid */
3246                 g_ptr = &current_floor_ptr->grid_array[m_ptr->fy][m_ptr->fx];
3247
3248                 /* Mark the location */
3249                 g_ptr->m_idx = m_idx;
3250
3251                 /* Count */
3252                 real_r_ptr(m_ptr)->cur_num++;
3253         }
3254
3255         /* Success */
3256         return 0;
3257 }
3258
3259
3260 /*!
3261  * @brief 保存されたフロアを読み込む(現版) / Read the dungeon (new method)
3262  * @return なし
3263  * @details
3264  * The monsters/objects must be loaded in the same order
3265  * that they were stored, since the actual indexes matter.
3266  */
3267 static errr rd_dungeon(void)
3268 {
3269         errr err = 0;
3270         s16b tmp16s;
3271         byte_hack tmp8u;
3272         byte num;
3273         int i;
3274
3275         /* Initialize saved_floors array and temporal files */
3276         init_saved_floors(FALSE);
3277
3278         /* Older method */
3279         if (h_older_than(1, 5, 0, 0))
3280         {
3281                 err = rd_dungeon_old();
3282
3283                 /* Prepare floor_id of current floor */
3284                 if (p_ptr->dungeon_idx)
3285                 {
3286                         p_ptr->floor_id = get_new_floor_id();
3287                         get_sf_ptr(p_ptr->floor_id)->dun_level = current_floor_ptr->dun_level;
3288                 }
3289
3290                 return err;
3291         }
3292
3293
3294         /*** Meta info ***/
3295
3296         /* Number of floor_id used from birth */
3297         rd_s16b(&max_floor_id);
3298
3299         /* Current dungeon type */
3300         rd_byte(&tmp8u);
3301         p_ptr->dungeon_idx = (DUNGEON_IDX)tmp8u;
3302
3303         /* Number of the saved_floors array elements */
3304         rd_byte(&num);
3305
3306         /*** No saved floor (On the surface etc.) ***/
3307         if (!num)
3308         {
3309                 /* Read the current floor data */
3310                 err = rd_saved_floor(NULL);
3311         }
3312
3313         /*** In the dungeon ***/
3314         else
3315         {
3316
3317                 /* Read the saved_floors array */
3318                 for (i = 0; i < num; i++)
3319                 {
3320                         saved_floor_type *sf_ptr = &saved_floors[i];
3321
3322                         rd_s16b(&sf_ptr->floor_id);
3323                         rd_byte(&tmp8u);
3324                         sf_ptr->savefile_id = (s16b)tmp8u;
3325
3326                         rd_s16b(&tmp16s);
3327                         sf_ptr->dun_level = (DEPTH)tmp16s;
3328
3329                         rd_s32b(&sf_ptr->last_visit);
3330                         rd_u32b(&sf_ptr->visit_mark);
3331                         rd_s16b(&sf_ptr->upper_floor_id);
3332                         rd_s16b(&sf_ptr->lower_floor_id);
3333                 }
3334
3335
3336                 /* Move saved floors data to temporal files */
3337                 for (i = 0; i < num; i++)
3338                 {
3339                         saved_floor_type *sf_ptr = &saved_floors[i];
3340
3341                         /* Unused element */
3342                         if (!sf_ptr->floor_id) continue;
3343
3344                         /* Read the failure mark */
3345                         rd_byte(&tmp8u);
3346                         if (tmp8u) continue;
3347
3348                         /* Read from the save file */
3349                         err = rd_saved_floor(sf_ptr);
3350
3351                         /* Error? */
3352                         if (err) break;
3353
3354                         /* Re-save as temporal saved floor file */
3355                         if (!save_floor(sf_ptr, SLF_SECOND)) err = 182;
3356
3357                         /* Error? */
3358                         if (err) break;
3359                 }
3360
3361                 /* Finally load current floor data from temporal file */
3362                 if (!err)
3363                 {
3364                         if (!load_floor(get_sf_ptr(p_ptr->floor_id), SLF_SECOND)) err = 183;
3365                 }
3366         }
3367
3368
3369         /*** Error messages ***/
3370         switch (err)
3371         {
3372         case 151:
3373                 note(_("アイテムの配列が大きすぎる！", "Too many object entries!"));
3374                 break;
3375
3376         case 152:
3377                 note(_("アイテム配置エラー", "Object allocation error"));
3378                 break;
3379
3380         case 161:
3381                 note(_("モンスターの配列が大きすぎる！", "Too many monster entries!"));
3382                 break;
3383
3384         case 162:
3385                 note(_("モンスター配置エラー", "Monster allocation error"));
3386                 break;
3387
3388         case 171:
3389                 note(_("保存されたフロアのダンジョンデータが壊れています！", "Dungeon data of saved floors are broken!"));
3390                 break;
3391
3392         case 182:
3393                 note(_("テンポラリ・ファイルを作成できません！", "Failed to make temporal files!"));
3394                 break;
3395
3396         case 183:
3397                 note(_("Error 183", "Error 183"));
3398                 break;
3399         }
3400
3401         /* The dungeon is ready */
3402         character_dungeon = TRUE;
3403
3404         /* Success or Error */
3405         return err;
3406 }
3407
3408
3409 /*!
3410  * @brief ロード処理全体のサブ関数 / Actually read the savefile
3411  * @return エラーコード
3412  */
3413 static errr rd_savefile_new_aux(void)
3414 {
3415         int i, j;
3416         int town_count;
3417
3418         s32b wild_x_size;
3419         s32b wild_y_size;
3420
3421         byte tmp8u;
3422         u16b tmp16u;
3423         s16b tmp16s;
3424         u32b tmp32u;
3425
3426 #ifdef VERIFY_CHECKSUMS
3427         u32b n_x_check, n_v_check;
3428         u32b o_x_check, o_v_check;
3429 #endif
3430
3431
3432         /* Strip the version bytes */
3433         strip_bytes(4);
3434
3435         /* Hack -- decrypt */
3436         xor_byte = sf_extra;
3437
3438
3439         /* Clear the checksums */
3440         v_check = 0L;
3441         x_check = 0L;
3442
3443         /* Read the version number of the savefile */
3444         /* Old savefile will be version 0.0.0.3 */
3445         rd_byte(&h_ver_extra);
3446         rd_byte(&h_ver_patch);
3447         rd_byte(&h_ver_minor);
3448         rd_byte(&h_ver_major);
3449
3450         /* Mention the savefile version */
3451         note(format(
3452                 _("バージョン %d.%d.%d.%d のセーブ・ファイルをロード中...", "Loading a %d.%d.%d.%d savefile..."),
3453                 (h_ver_major > 9) ? h_ver_major - 10 : h_ver_major, h_ver_minor, h_ver_patch, h_ver_extra));
3454
3455
3456         /* Operating system info */
3457         rd_u32b(&sf_system);
3458
3459         /* Time of savefile creation */
3460         rd_u32b(&sf_when);
3461
3462         /* Number of resurrections */
3463         rd_u16b(&sf_lives);
3464
3465         /* Number of times played */
3466         rd_u16b(&sf_saves);
3467
3468
3469         /* Later use (always zero) */
3470         rd_u32b(&tmp32u);
3471
3472         /* Later use (always zero) */
3473         rd_u16b(&tmp16u);
3474
3475         /* Later use (always zero) */
3476         rd_byte(&tmp8u);
3477
3478         /* Kanji code */
3479         rd_byte(&kanji_code);
3480
3481         /* Read RNG state */
3482         rd_randomizer();
3483         if (arg_fiddle) note(_("乱数情報をロードしました", "Loaded Randomizer Info"));
3484
3485         /* Then the options */
3486         rd_options();
3487         if (arg_fiddle) note(_("オプションをロードしました", "Loaded Option Flags"));
3488
3489         /* Then the "messages" */
3490         rd_messages();
3491         if (arg_fiddle) note(_("メッセージをロードしました", "Loaded Messages"));
3492
3493         for (i = 0; i < max_r_idx; i++)
3494         {
3495                 /* Access that monster */
3496                 monster_race *r_ptr = &r_info[i];
3497
3498                 /* Hack -- Reset the death counter */
3499                 r_ptr->max_num = 100;
3500
3501                 if (r_ptr->flags1 & RF1_UNIQUE) r_ptr->max_num = 1;
3502
3503                 /* Hack -- Non-unique Nazguls are semi-unique */
3504                 else if (r_ptr->flags7 & RF7_NAZGUL) r_ptr->max_num = MAX_NAZGUL_NUM;
3505         }
3506
3507         /* Monster Memory */
3508         rd_u16b(&tmp16u);
3509
3510         /* Incompatible save files */
3511         if (tmp16u > max_r_idx)
3512         {
3513                 note(format(_("モンスターの種族が多すぎる(%u)！", "Too many (%u) monster races!"), tmp16u));
3514                 return (21);
3515         }
3516
3517         /* Read the available records */
3518         for (i = 0; i < tmp16u; i++)
3519         {
3520                 /* Read the lore */
3521                 rd_lore((MONRACE_IDX)i);
3522         }
3523
3524         if (arg_fiddle) note(_("モンスターの思い出をロードしました", "Loaded Monster Memory"));
3525
3526         /* Object Memory */
3527         rd_u16b(&tmp16u);
3528
3529         /* Incompatible save files */
3530         if (tmp16u > max_k_idx)
3531         {
3532                 note(format(_("アイテムの種類が多すぎる(%u)！", "Too many (%u) object kinds!"), tmp16u));
3533                 return (22);
3534         }
3535
3536         /* Read the object memory */
3537         for (i = 0; i < tmp16u; i++)
3538         {
3539                 object_kind *k_ptr = &k_info[i];
3540
3541                 rd_byte(&tmp8u);
3542
3543                 k_ptr->aware = (tmp8u & 0x01) ? TRUE: FALSE;
3544                 k_ptr->tried = (tmp8u & 0x02) ? TRUE: FALSE;
3545         }
3546         if (arg_fiddle) note(_("アイテムの記録をロードしました", "Loaded Object Memory"));
3547
3548         /* 2.1.3 or newer version */
3549         {
3550                 u16b max_towns_load;
3551                 u16b max_quests_load;
3552                 byte max_rquests_load;
3553                 s16b old_inside_quest = p_ptr->inside_quest;
3554
3555                 /* Number of towns */
3556                 rd_u16b(&max_towns_load);
3557
3558                 /* Incompatible save files */
3559                 if (max_towns_load > max_towns)
3560                 {
3561                         note(format(_("町が多すぎる(%u)！", "Too many (%u) towns!"), max_towns_load));
3562                         return (23);
3563                 }
3564
3565                 /* Number of quests */
3566                 rd_u16b(&max_quests_load);
3567
3568                 if (z_older_than(11, 0, 7))
3569                 {
3570                         max_rquests_load = 10;
3571                 }
3572                 else
3573                 {
3574                         rd_byte(&max_rquests_load);
3575                 }
3576
3577                 /* Incompatible save files */
3578                 if (max_quests_load > max_q_idx)
3579                 {
3580                         note(format(_("クエストが多すぎる(%u)！", "Too many (%u) quests!"), max_quests_load));
3581                         return (23);
3582                 }
3583
3584                 for (i = 0; i < max_quests_load; i++)
3585                 {
3586                         if (i < max_q_idx)
3587                         {
3588                                 quest_type* const q_ptr = &quest[i];
3589
3590                                 rd_s16b(&q_ptr->status);
3591                                 rd_s16b(&tmp16s);
3592                                 q_ptr->level = tmp16s;
3593
3594                                 if (z_older_than(11, 0, 6))
3595                                 {
3596                                         q_ptr->complev = 0;
3597                                 }
3598                                 else
3599                                 {
3600                                         rd_byte(&tmp8u);
3601                                         q_ptr->complev = tmp8u;
3602                                 }
3603                                 if(h_older_than(2, 1, 2, 2))
3604                                 {
3605                                         q_ptr->comptime = 0;
3606                                 }
3607                                 else
3608                                 {
3609                                         rd_u32b(&q_ptr->comptime);
3610                                 }
3611
3612                                 /* Load quest status if quest is running */
3613                                 if ((q_ptr->status == QUEST_STATUS_TAKEN) ||
3614                                     (!z_older_than(10, 3, 14) && (q_ptr->status == QUEST_STATUS_COMPLETED)) ||
3615                                     (!z_older_than(11, 0, 7) && (i >= MIN_RANDOM_QUEST) && (i <= (MIN_RANDOM_QUEST + max_rquests_load))))
3616                                 {
3617                                         rd_s16b(&tmp16s);
3618                                         q_ptr->cur_num = (MONSTER_NUMBER)tmp16s;
3619                                         rd_s16b(&tmp16s);
3620                                         q_ptr->max_num = (MONSTER_NUMBER)tmp16s;
3621                                         rd_s16b(&q_ptr->type);
3622
3623                                         /* Load quest monster index */
3624                                         rd_s16b(&q_ptr->r_idx);
3625
3626                                         if ((q_ptr->type == QUEST_TYPE_RANDOM) && (!q_ptr->r_idx))
3627                                         {
3628                                                 determine_random_questor(&quest[i]);
3629                                         }
3630
3631                                         /* Load quest item index */
3632                                         rd_s16b(&q_ptr->k_idx);
3633
3634                                         if (q_ptr->k_idx)
3635                                                 a_info[q_ptr->k_idx].gen_flags |= TRG_QUESTITEM;
3636
3637                                         rd_byte(&tmp8u);
3638                                         q_ptr->flags = tmp8u;
3639
3640                                         if (z_older_than(10, 3, 11))
3641                                         {
3642                                                 if (q_ptr->flags & QUEST_FLAG_PRESET)
3643                                                 {
3644                                                         q_ptr->dungeon = 0;
3645                                                 }
3646                                                 else
3647                                                 {
3648                                                         init_flags = INIT_ASSIGN;
3649                                                         p_ptr->inside_quest = (QUEST_IDX)i;
3650
3651                                                         process_dungeon_file("q_info.txt", 0, 0, 0, 0);
3652                                                         p_ptr->inside_quest = old_inside_quest;
3653                                                 }
3654                                         }
3655                                         else
3656                                         {
3657                                                 rd_byte(&tmp8u);
3658                                                 q_ptr->dungeon = tmp8u;
3659                                         }
3660                                         /* Mark uniques */
3661                                         if (q_ptr->status == QUEST_STATUS_TAKEN || q_ptr->status == QUEST_STATUS_UNTAKEN)
3662                                                 if (r_info[q_ptr->r_idx].flags1 & RF1_UNIQUE)
3663                                                         r_info[q_ptr->r_idx].flags1 |= RF1_QUESTOR;
3664                                 }
3665                         }
3666                         /* Ignore the empty quests from old versions */
3667                         else
3668                         {
3669                                 /* Ignore quest status */
3670                                 strip_bytes(2);
3671
3672                                 /* Ignore quest level */
3673                                 strip_bytes(2);
3674
3675                                 /*
3676                                  * We don't have to care about the other info,
3677                                  * since status should be 0 for these quests anyway
3678                                  */
3679                         }
3680                 }
3681
3682                 /* Quest 18 was removed */
3683                 if (h_older_than(1, 7, 0, 6))
3684                 {
3685                         (void)WIPE(&quest[OLD_QUEST_WATER_CAVE], quest_type);
3686                         quest[OLD_QUEST_WATER_CAVE].status = QUEST_STATUS_UNTAKEN;
3687                 }
3688
3689                 /* Position in the wilderness */
3690                 rd_s32b(&p_ptr->wilderness_x);
3691                 rd_s32b(&p_ptr->wilderness_y);
3692                 if (z_older_than(10, 3, 13))
3693                 {
3694                         p_ptr->wilderness_x = 5;
3695                         p_ptr->wilderness_y = 48;
3696                 }
3697
3698                 if (z_older_than(10, 3, 7)) p_ptr->wild_mode = FALSE;
3699                 else rd_byte((byte *)&p_ptr->wild_mode);
3700                 if (z_older_than(10, 3, 7)) p_ptr->ambush_flag = FALSE;
3701                 else rd_byte((byte *)&p_ptr->ambush_flag);
3702
3703                 /* Size of the wilderness */
3704                 rd_s32b(&wild_x_size);
3705                 rd_s32b(&wild_y_size);
3706
3707                 /* Incompatible save files */
3708                 if ((wild_x_size > current_world_ptr->max_wild_x) || (wild_y_size > current_world_ptr->max_wild_y))
3709                 {
3710                         note(format(_("荒野が大きすぎる(%u/%u)！", "Wilderness is too big (%u/%u)!"), wild_x_size, wild_y_size));
3711                         return (23);
3712                 }
3713
3714                 /* Load the wilderness seeds */
3715                 for (i = 0; i < wild_x_size; i++)
3716                 {
3717                         for (j = 0; j < wild_y_size; j++)
3718                         {
3719                                 rd_u32b(&wilderness[j][i].seed);
3720                         }
3721                 }
3722         }
3723
3724         if (arg_fiddle) note(_("クエスト情報をロードしました", "Loaded Quests"));
3725
3726         /* Load the Artifacts */
3727         rd_u16b(&tmp16u);
3728
3729         /* Incompatible save files */
3730         if (tmp16u > max_a_idx)
3731         {
3732                 note(format(_("伝説のアイテムが多すぎる(%u)！", "Too many (%u) artifacts!"), tmp16u));
3733                 return (24);
3734         }
3735
3736         /* Read the artifact flags */
3737         for (i = 0; i < tmp16u; i++)
3738         {
3739                 artifact_type *a_ptr = &a_info[i];
3740
3741                 rd_byte(&tmp8u);
3742                 a_ptr->cur_num = tmp8u;
3743
3744                 if (h_older_than(1, 5, 0, 0))
3745                 {
3746                         a_ptr->floor_id = 0;
3747
3748                         rd_byte(&tmp8u);
3749                         rd_byte(&tmp8u);
3750                         rd_byte(&tmp8u);
3751                 }
3752                 else
3753                 {
3754                         rd_s16b(&a_ptr->floor_id);
3755                 }
3756         }
3757         if (arg_fiddle) note(_("伝説のアイテムをロードしました", "Loaded Artifacts"));
3758
3759         /* Read the extra stuff */
3760         rd_extra();
3761         if (p_ptr->energy_need < -999) p_ptr->timewalk = TRUE;
3762
3763         if (arg_fiddle) note(_("特別情報をロードしました", "Loaded extra information"));
3764
3765
3766         /* Read the player_hp array */
3767         rd_u16b(&tmp16u);
3768
3769         /* Incompatible save files */
3770         if (tmp16u > PY_MAX_LEVEL)
3771         {
3772                 note(format(_("ヒットポイント配列が大きすぎる(%u)！", "Too many (%u) hitpoint entries!"), tmp16u));
3773                 return (25);
3774         }
3775
3776         /* Read the player_hp array */
3777         for (i = 0; i < tmp16u; i++)
3778         {
3779                 rd_s16b(&tmp16s);
3780                 p_ptr->player_hp[i] = (HIT_POINT)tmp16s;
3781         }
3782
3783         /* Important -- Initialize the sex */
3784         sp_ptr = &sex_info[p_ptr->psex];
3785
3786         /* Important -- Initialize the race/class */
3787         rp_ptr = &race_info[p_ptr->prace];
3788         cp_ptr = &class_info[p_ptr->pclass];
3789         ap_ptr = &seikaku_info[p_ptr->pseikaku];
3790
3791         if(z_older_than(10, 2, 2) && (p_ptr->pclass == CLASS_BEASTMASTER) && !p_ptr->is_dead)
3792         {
3793                 p_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
3794                 roll_hitdice(p_ptr, 0L);
3795         }
3796         if(z_older_than(10, 3, 2) && (p_ptr->pclass == CLASS_ARCHER) && !p_ptr->is_dead)
3797         {
3798                 p_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
3799                 roll_hitdice(p_ptr, 0L);
3800         }
3801         if(z_older_than(10, 2, 6) && (p_ptr->pclass == CLASS_SORCERER) && !p_ptr->is_dead)
3802         {
3803                 p_ptr->hitdie = rp_ptr->r_mhp/2 + cp_ptr->c_mhp + ap_ptr->a_mhp;
3804                 roll_hitdice(p_ptr, 0L);
3805         }
3806         if(z_older_than(10, 4, 7) && (p_ptr->pclass == CLASS_BLUE_MAGE) && !p_ptr->is_dead)
3807         {
3808                 p_ptr->hitdie = rp_ptr->r_mhp + cp_ptr->c_mhp + ap_ptr->a_mhp;
3809                 roll_hitdice(p_ptr, 0L);
3810         }
3811
3812         /* Important -- Initialize the magic */
3813         mp_ptr = &m_info[p_ptr->pclass];
3814
3815
3816         /* Read spell info */
3817         rd_u32b(&p_ptr->spell_learned1);
3818         rd_u32b(&p_ptr->spell_learned2);
3819         rd_u32b(&p_ptr->spell_worked1);
3820         rd_u32b(&p_ptr->spell_worked2);
3821         rd_u32b(&p_ptr->spell_forgotten1);
3822         rd_u32b(&p_ptr->spell_forgotten2);
3823
3824         if (z_older_than(10,0,5))
3825         {
3826                 p_ptr->learned_spells = 0;
3827                 for (i = 0; i < 64; i++)
3828                 {
3829                         /* Count known spells */
3830                         if ((i < 32) ?
3831                             (p_ptr->spell_learned1 & (1L << i)) :
3832                             (p_ptr->spell_learned2 & (1L << (i - 32))))
3833                         {
3834                                 p_ptr->learned_spells++;
3835                         }
3836                 }
3837         }
3838         else rd_s16b(&p_ptr->learned_spells);
3839
3840         if (z_older_than(10,0,6))
3841         {
3842                 p_ptr->add_spells = 0;
3843         }
3844         else rd_s16b(&p_ptr->add_spells);
3845         if (p_ptr->pclass == CLASS_MINDCRAFTER) p_ptr->add_spells = 0;
3846
3847         for (i = 0; i < 64; i++)
3848         {
3849                 rd_byte(&tmp8u);
3850                 p_ptr->spell_order[i] = (SPELL_IDX)tmp8u;
3851         }
3852
3853
3854         /* Read the inventory */
3855         if (rd_inventory())
3856         {
3857                 note(_("持ち物情報を読み込むことができません", "Unable to read inventory"));
3858                 return (21);
3859         }
3860
3861         /* Read number of towns */
3862         rd_u16b(&tmp16u);
3863         town_count = tmp16u;
3864
3865         /* Read the stores */
3866         rd_u16b(&tmp16u);
3867         for (i = 1; i < town_count; i++)
3868         {
3869                 for (j = 0; j < tmp16u; j++)
3870                 {
3871                         if (rd_store(i, j)) return (22);
3872                 }
3873         }
3874
3875         rd_s16b(&p_ptr->pet_follow_distance);
3876         if (z_older_than(10, 4, 10))
3877         {
3878                 p_ptr->pet_extra_flags = 0;
3879                 rd_byte(&tmp8u);
3880                 if (tmp8u) p_ptr->pet_extra_flags |= PF_OPEN_DOORS;
3881                 rd_byte(&tmp8u);
3882                 if (tmp8u) p_ptr->pet_extra_flags |= PF_PICKUP_ITEMS;
3883
3884                 if (z_older_than(10,0,4)) p_ptr->pet_extra_flags |= PF_TELEPORT;
3885                 else
3886                 {
3887                         rd_byte(&tmp8u);
3888                         if (tmp8u) p_ptr->pet_extra_flags |= PF_TELEPORT;
3889                 }
3890
3891                 if (z_older_than(10,0,7)) p_ptr->pet_extra_flags |= PF_ATTACK_SPELL;
3892                 else
3893                 {
3894                         rd_byte(&tmp8u);
3895                         if (tmp8u) p_ptr->pet_extra_flags |= PF_ATTACK_SPELL;
3896                 }
3897
3898                 if (z_older_than(10,0,8)) p_ptr->pet_extra_flags |= PF_SUMMON_SPELL;
3899                 else
3900                 {
3901                         rd_byte(&tmp8u);
3902                         if (tmp8u) p_ptr->pet_extra_flags |= PF_SUMMON_SPELL;
3903                 }
3904
3905                 if (!z_older_than(10,0,8))
3906                 {
3907                         rd_byte(&tmp8u);
3908                         if (tmp8u) p_ptr->pet_extra_flags |= PF_BALL_SPELL;
3909                 }
3910         }
3911         else
3912         {
3913                 rd_s16b(&p_ptr->pet_extra_flags);
3914         }
3915
3916         if (!z_older_than(11, 0, 9))
3917         {
3918                 char buf[SCREEN_BUF_MAX_SIZE];
3919                 rd_string(buf, sizeof(buf));
3920                 if (buf[0]) screen_dump = string_make(buf);
3921         }
3922
3923         if (p_ptr->is_dead)
3924         {
3925                 for (i = MIN_RANDOM_QUEST; i < MAX_RANDOM_QUEST + 1; i++)
3926                 {
3927                         r_info[quest[i].r_idx].flags1 &= ~(RF1_QUESTOR);
3928                 }
3929         }
3930
3931
3932         /* I'm not dead yet... */
3933         if (!p_ptr->is_dead)
3934         {
3935                 /* Dead players have no dungeon */
3936                 note(_("ダンジョン復元中...", "Restoring Dungeon..."));
3937
3938                 if (rd_dungeon())
3939                 {
3940                         note(_("ダンジョンデータ読み込み失敗", "Error reading dungeon data"));
3941                         return (34);
3942                 }
3943
3944                 /* Read the ghost info */
3945                 rd_ghost();
3946
3947                 {
3948                         s32b tmp32s;
3949
3950                         rd_s32b(&tmp32s);
3951                         strip_bytes(tmp32s);
3952                 }
3953         }
3954
3955         /* Quest 18 was removed */
3956         if (h_older_than(1, 7, 0, 6))
3957         {
3958                 if (p_ptr->inside_quest == OLD_QUEST_WATER_CAVE)
3959                 {
3960                         p_ptr->dungeon_idx = lite_town ? DUNGEON_ANGBAND : DUNGEON_GALGALS;
3961                         current_floor_ptr->dun_level = 1;
3962                         p_ptr->inside_quest = 0;
3963                 }
3964         }
3965
3966
3967 #ifdef VERIFY_CHECKSUMS
3968
3969         /* Save the checksum */
3970         n_v_check = v_check;
3971
3972         /* Read the old checksum */
3973         rd_u32b(&o_v_check);
3974
3975         /* Verify */
3976         if (o_v_check != n_v_check)
3977         {
3978                 note(_("チェックサムがおかしい", "Invalid checksum"));
3979                 return (11);
3980         }
3981
3982
3983         /* Save the encoded checksum */
3984         n_x_check = x_check;
3985
3986         /* Read the checksum */
3987         rd_u32b(&o_x_check);
3988
3989
3990         /* Verify */
3991         if (o_x_check != n_x_check)
3992         {
3993                 note(_("エンコードされたチェックサムがおかしい", "Invalid encoded checksum"));
3994                 return (11);
3995         }
3996
3997 #endif
3998
3999         /* Success */
4000         return (0);
4001 }
4002
4003 /*!
4004  * @brief ロード処理全体のメイン関数 / Actually read the savefile
4005  * @return エラーコード
4006  */
4007 errr rd_savefile_new(void)
4008 {
4009         errr err;
4010
4011         /* Grab permissions */
4012         safe_setuid_grab();
4013
4014         /* The savefile is a binary file */
4015         fff = my_fopen(savefile, "rb");
4016
4017         /* Drop permissions */
4018         safe_setuid_drop();
4019         if (!fff) return (-1);
4020
4021         /* Call the sub-function */
4022         err = rd_savefile_new_aux();
4023
4024         /* Check for errors */
4025         if (ferror(fff)) err = -1;
4026         my_fclose(fff);
4027         return (err);
4028 }
4029
4030
4031 /*!
4032  * @brief 保存フロア読み込みのサブ関数 / Actually load and verify a floor save data
4033  * @param sf_ptr 保存フロア読み込み先
4034  * @return 成功したらtrue
4035  */
4036 static bool load_floor_aux(saved_floor_type *sf_ptr)
4037 {
4038         byte tmp8u;
4039         u32b tmp32u;
4040
4041 #ifdef VERIFY_CHECKSUMS
4042         u32b n_x_check, n_v_check;
4043         u32b o_x_check, o_v_check;
4044 #endif
4045
4046         /* Hack -- decrypt (read xor_byte) */
4047         xor_byte = 0;
4048         rd_byte(&tmp8u);
4049
4050         /* Clear the checksums */
4051         v_check = 0L;
4052         x_check = 0L;
4053
4054         /* Set the version number to current version */
4055         /* Never load old temporal files */
4056         h_ver_extra = H_VER_EXTRA;
4057         h_ver_patch = H_VER_PATCH;
4058         h_ver_minor = H_VER_MINOR;
4059         h_ver_major = H_VER_MAJOR;
4060
4061         /* Verify the sign */
4062         rd_u32b(&tmp32u);
4063         if (saved_floor_file_sign != tmp32u) return FALSE;
4064
4065         /* Read -- have error? */
4066         if (rd_saved_floor(sf_ptr)) return FALSE;
4067
4068
4069 #ifdef VERIFY_CHECKSUMS
4070         /* Save the checksum */
4071         n_v_check = v_check;
4072
4073         /* Read the old checksum */
4074         rd_u32b(&o_v_check);
4075
4076         /* Verify */
4077         if (o_v_check != n_v_check) return FALSE;
4078
4079         /* Save the encoded checksum */
4080         n_x_check = x_check;
4081
4082         /* Read the checksum */
4083         rd_u32b(&o_x_check);
4084
4085         /* Verify */
4086         if (o_x_check != n_x_check) return FALSE;
4087 #endif
4088
4089         /* Success */
4090         return TRUE;
4091 }
4092
4093
4094 /*!
4095  * @brief 一時保存フロア情報を読み込む / Attempt to load the temporally saved-floor data
4096  * @param sf_ptr 保存フロア読み込み先
4097  * @param mode オプション
4098  * @return 成功したらtrue
4099  */
4100 bool load_floor(saved_floor_type *sf_ptr, BIT_FLAGS mode)
4101 {
4102         FILE *old_fff = NULL;
4103         byte old_xor_byte = 0;
4104         u32b old_v_check = 0;
4105         u32b old_x_check = 0;
4106         byte old_h_ver_major = 0;
4107         byte old_h_ver_minor = 0;
4108         byte old_h_ver_patch = 0;
4109         byte old_h_ver_extra = 0;
4110
4111         bool ok = TRUE;
4112         char floor_savefile[1024];
4113
4114         byte old_kanji_code = kanji_code;
4115
4116         /*
4117          * Temporal files are always written in system depended kanji
4118          * code.
4119          */
4120 #ifdef JP
4121 # ifdef EUC
4122         /* EUC kanji code */
4123         kanji_code = 2;
4124 # endif
4125 # ifdef SJIS
4126         /* SJIS kanji code */
4127         kanji_code = 3;
4128 # endif
4129 #else
4130         /* ASCII */
4131         kanji_code = 1;
4132 #endif
4133
4134
4135         /* We have one file already opened */
4136         if (mode & SLF_SECOND)
4137         {
4138                 /* Backup original values */
4139                 old_fff = fff;
4140                 old_xor_byte = xor_byte;
4141                 old_v_check = v_check;
4142                 old_x_check = x_check;
4143                 old_h_ver_major = h_ver_major;
4144                 old_h_ver_minor = h_ver_minor;
4145                 old_h_ver_patch = h_ver_patch;
4146                 old_h_ver_extra = h_ver_extra;
4147         }
4148
4149         /* floor savefile */
4150         sprintf(floor_savefile, "%s.F%02d", savefile, (int)sf_ptr->savefile_id);
4151
4152         /* Grab permissions */
4153         safe_setuid_grab();
4154
4155         /* The savefile is a binary file */
4156         fff = my_fopen(floor_savefile, "rb");
4157
4158         /* Drop permissions */
4159         safe_setuid_drop();
4160
4161         /* Couldn't read */
4162         if (!fff) ok = FALSE;
4163
4164         /* Attempt to load */
4165         if (ok)
4166         {
4167                 /* Load saved floor data from file */
4168                 ok = load_floor_aux(sf_ptr);
4169
4170                 /* Check for errors */
4171                 if (ferror(fff)) ok = FALSE;
4172                 my_fclose(fff);
4173
4174                 /* Grab permissions */
4175                 safe_setuid_grab();
4176
4177                 /* Delete the file */
4178                 if (!(mode & SLF_NO_KILL)) (void)fd_kill(floor_savefile);
4179
4180                 /* Drop permissions */
4181                 safe_setuid_drop();
4182         }
4183
4184         /* We have one file already opened */
4185         if (mode & SLF_SECOND)
4186         {
4187                 /* Restore original values */
4188                 fff = old_fff;
4189                 xor_byte = old_xor_byte;
4190                 v_check = old_v_check;
4191                 x_check = old_x_check;
4192                 h_ver_major = old_h_ver_major;
4193                 h_ver_minor = old_h_ver_minor;
4194                 h_ver_patch = old_h_ver_patch;
4195                 h_ver_extra = old_h_ver_extra;
4196         }
4197
4198         /* Restore old knowledge */
4199         kanji_code = old_kanji_code;
4200         return ok;
4201 }