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