src/save.c

   1 /*!
   2  * @file save.c
   3  * @brief セーブファイル書き込み処理 / Purpose: interact with savefiles
   4  * @date 2014/07/12
   5  * @author
   6  * <pre>
   7  * Copyright (c) 1997 Ben Harrison, James E. Wilson, Robert A. Koeneke
   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  * </pre>
  12  */
  13
  14 #include "angband.h"
  15 #include "sort.h"
  16 #include "quest.h"
  17 #include "store.h"
  18
  19
  20
  21 /*
  22  * Some "local" parameters, used to help write savefiles
  23  */
  24
  25 static FILE *fff;           /* Current save "file" */
  26 static byte xor_byte;       /* Simple encryption */
  27 static u32b v_stamp = 0L;   /* A simple "checksum" on the actual values */
  28 static u32b x_stamp = 0L;   /* A simple "checksum" on the encoded bytes */
  29
  30
  31
  32 /*!
  33  * @brief 1バイトをファイルに書き込む / These functions place information into a savefile a byte at a time
  34  * @param v 書き込むバイト値
  35  * @return なし
  36  */
  37 static void sf_put(byte v)
  38 {
  39         /* Encode the value, write a character */
  40         xor_byte ^= v;
  41         (void)putc((int)xor_byte, fff);
  42
  43         /* Maintain the checksum info */
  44         v_stamp += v;
  45         x_stamp += xor_byte;
  46 }
  47
  48 /*!
  49  * @brief 1バイトをファイルに書き込む(sf_put()の糖衣)
  50  * @param v 書き込むバイト
  51  * @return なし
  52  */
  53 static void wr_byte(byte v)
  54 {
  55         sf_put(v);
  56 }
  57
  58 /*!
  59  * @brief 符号なし16ビットをファイルに書き込む
  60  * @param v 書き込む符号なし16bit値
  61  * @return なし
  62  */
  63 static void wr_u16b(u16b v)
  64 {
  65         sf_put((byte)(v & 0xFF));
  66         sf_put((byte)((v >> 8) & 0xFF));
  67 }
  68
  69 /*!
  70  * @brief 符号あり16ビットをファイルに書き込む
  71  * @param v 書き込む符号あり16bit値
  72  * @return なし
  73  */
  74 static void wr_s16b(s16b v)
  75 {
  76         wr_u16b((u16b)v);
  77 }
  78
  79 /*!
  80  * @brief 符号なし32ビットをファイルに書き込む
  81  * @param v 書き込む符号なし32bit値
  82  * @return なし
  83  */
  84 static void wr_u32b(u32b v)
  85 {
  86         sf_put((byte)(v & 0xFF));
  87         sf_put((byte)((v >> 8) & 0xFF));
  88         sf_put((byte)((v >> 16) & 0xFF));
  89         sf_put((byte)((v >> 24) & 0xFF));
  90 }
  91
  92 /*!
  93  * @brief 符号あり32ビットをファイルに書き込む
  94  * @param v 書き込む符号あり32bit値
  95  * @return なし
  96  */
  97 static void wr_s32b(s32b v)
  98 {
  99         wr_u32b((u32b)v);
 100 }
 101
 102 /*!
 103  * @brief 文字列をファイルに書き込む
 104  * @param str 書き込む文字列
 105  * @return なし
 106  */
 107 static void wr_string(concptr str)
 108 {
 109         while (*str)
 110         {
 111                 wr_byte(*str);
 112                 str++;
 113         }
 114         wr_byte(*str);
 115 }
 116
 117
 118 /*
 119  * These functions write info in larger logical records
 120  */
 121
 122
 123 /*!
 124  * @brief アイテムオブジェクトを書き込む / Write an "item" record
 125  * @param o_ptr アイテムオブジェクト保存元ポインタ
 126  * @return なし
 127  */
 128 static void wr_item(object_type *o_ptr)
 129 {
 130         BIT_FLAGS flags = 0x00000000;
 131
 132         if (o_ptr->pval) flags |= SAVE_ITEM_PVAL;
 133         if (o_ptr->discount) flags |= SAVE_ITEM_DISCOUNT;
 134         if (o_ptr->number != 1) flags |= SAVE_ITEM_NUMBER;
 135         if (o_ptr->name1) flags |= SAVE_ITEM_NAME1;
 136         if (o_ptr->name2) flags |= SAVE_ITEM_NAME2;
 137         if (o_ptr->timeout) flags |= SAVE_ITEM_TIMEOUT;
 138         if (o_ptr->to_h) flags |= SAVE_ITEM_TO_H;
 139         if (o_ptr->to_d) flags |= SAVE_ITEM_TO_D;
 140         if (o_ptr->to_a) flags |= SAVE_ITEM_TO_A;
 141         if (o_ptr->ac) flags |= SAVE_ITEM_AC;
 142         if (o_ptr->dd) flags |= SAVE_ITEM_DD;
 143         if (o_ptr->ds) flags |= SAVE_ITEM_DS;
 144         if (o_ptr->ident) flags |= SAVE_ITEM_IDENT;
 145         if (o_ptr->marked) flags |= SAVE_ITEM_MARKED;
 146         if (o_ptr->art_flags[0]) flags |= SAVE_ITEM_ART_FLAGS0;
 147         if (o_ptr->art_flags[1]) flags |= SAVE_ITEM_ART_FLAGS1;
 148         if (o_ptr->art_flags[2]) flags |= SAVE_ITEM_ART_FLAGS2;
 149         if (o_ptr->art_flags[3]) flags |= SAVE_ITEM_ART_FLAGS3;
 150         if (o_ptr->art_flags[4]) flags |= SAVE_ITEM_ART_FLAGS4;
 151         if (o_ptr->curse_flags) flags |= SAVE_ITEM_CURSE_FLAGS;
 152         if (o_ptr->held_m_idx) flags |= SAVE_ITEM_HELD_M_IDX;
 153         if (o_ptr->xtra1) flags |= SAVE_ITEM_XTRA1;
 154         if (o_ptr->xtra2) flags |= SAVE_ITEM_XTRA2;
 155         if (o_ptr->xtra3) flags |= SAVE_ITEM_XTRA3;
 156         if (o_ptr->xtra4) flags |= SAVE_ITEM_XTRA4;
 157         if (o_ptr->xtra5) flags |= SAVE_ITEM_XTRA5;
 158         if (o_ptr->feeling) flags |= SAVE_ITEM_FEELING;
 159         if (o_ptr->inscription) flags |= SAVE_ITEM_INSCRIPTION;
 160         if (o_ptr->art_name) flags |= SAVE_ITEM_ART_NAME;
 161
 162         /*** Item save flags ***/
 163         wr_u32b(flags);
 164
 165         /*** Write only un-obvious elements ***/
 166         wr_s16b(o_ptr->k_idx);
 167
 168         wr_byte((byte_hack)o_ptr->iy);
 169         wr_byte((byte_hack)o_ptr->ix);
 170
 171         if (flags & SAVE_ITEM_PVAL) wr_s16b(o_ptr->pval);
 172
 173         if (flags & SAVE_ITEM_DISCOUNT) wr_byte(o_ptr->discount);
 174         if (flags & SAVE_ITEM_NUMBER) wr_byte((byte_hack)o_ptr->number);
 175
 176         wr_s16b((s16b)o_ptr->weight);
 177
 178         if (flags & SAVE_ITEM_NAME1) wr_byte((byte_hack)o_ptr->name1);
 179         if (flags & SAVE_ITEM_NAME2) wr_byte((byte_hack)o_ptr->name2);
 180         if (flags & SAVE_ITEM_TIMEOUT) wr_s16b(o_ptr->timeout);
 181
 182         if (flags & SAVE_ITEM_TO_H) wr_s16b(o_ptr->to_h);
 183         if (flags & SAVE_ITEM_TO_D) wr_s16b((s16b)o_ptr->to_d);
 184         if (flags & SAVE_ITEM_TO_A) wr_s16b(o_ptr->to_a);
 185         if (flags & SAVE_ITEM_AC) wr_s16b(o_ptr->ac);
 186         if (flags & SAVE_ITEM_DD) wr_byte((byte_hack)o_ptr->dd);
 187         if (flags & SAVE_ITEM_DS) wr_byte((byte_hack)o_ptr->ds);
 188
 189         if (flags & SAVE_ITEM_IDENT) wr_byte(o_ptr->ident);
 190
 191         if (flags & SAVE_ITEM_MARKED) wr_byte(o_ptr->marked);
 192
 193         if (flags & SAVE_ITEM_ART_FLAGS0) wr_u32b(o_ptr->art_flags[0]);
 194         if (flags & SAVE_ITEM_ART_FLAGS1) wr_u32b(o_ptr->art_flags[1]);
 195         if (flags & SAVE_ITEM_ART_FLAGS2) wr_u32b(o_ptr->art_flags[2]);
 196         if (flags & SAVE_ITEM_ART_FLAGS3) wr_u32b(o_ptr->art_flags[3]);
 197         if (flags & SAVE_ITEM_ART_FLAGS4) wr_u32b(o_ptr->art_flags[4]);
 198
 199         if (flags & SAVE_ITEM_CURSE_FLAGS) wr_u32b(o_ptr->curse_flags);
 200
 201         /* Held by monster index */
 202         if (flags & SAVE_ITEM_HELD_M_IDX) wr_s16b(o_ptr->held_m_idx);
 203
 204         /* Extra information */
 205         if (flags & SAVE_ITEM_XTRA1) wr_byte(o_ptr->xtra1);
 206         if (flags & SAVE_ITEM_XTRA2) wr_byte(o_ptr->xtra2);
 207         if (flags & SAVE_ITEM_XTRA3) wr_byte(o_ptr->xtra3);
 208         if (flags & SAVE_ITEM_XTRA4) wr_s16b(o_ptr->xtra4);
 209         if (flags & SAVE_ITEM_XTRA5) wr_s16b(o_ptr->xtra5);
 210
 211         /* Feelings */
 212         if (flags & SAVE_ITEM_FEELING) wr_byte(o_ptr->feeling);
 213
 214         if (flags & SAVE_ITEM_INSCRIPTION) wr_string(quark_str(o_ptr->inscription));
 215         if (flags & SAVE_ITEM_ART_NAME) wr_string(quark_str(o_ptr->art_name));
 216 }
 217
 218
 219 /*!
 220  * @brief モンスター情報を書き込む / Write a "monster" record
 221  * @param m_ptr モンスター情報保存元ポインタ
 222  * @return なし
 223  */
 224 static void wr_monster(monster_type *m_ptr)
 225 {
 226         BIT_FLAGS flags = 0x00000000;
 227         byte tmp8u;
 228
 229         if (!is_original_ap(m_ptr)) flags |= SAVE_MON_AP_R_IDX;
 230         if (m_ptr->sub_align) flags |= SAVE_MON_SUB_ALIGN;
 231         if (MON_CSLEEP(m_ptr)) flags |= SAVE_MON_CSLEEP;
 232         if (MON_FAST(m_ptr)) flags |= SAVE_MON_FAST;
 233         if (MON_SLOW(m_ptr)) flags |= SAVE_MON_SLOW;
 234         if (MON_STUNNED(m_ptr)) flags |= SAVE_MON_STUNNED;
 235         if (MON_CONFUSED(m_ptr)) flags |= SAVE_MON_CONFUSED;
 236         if (MON_MONFEAR(m_ptr)) flags |= SAVE_MON_MONFEAR;
 237         if (m_ptr->target_y) flags |= SAVE_MON_TARGET_Y;
 238         if (m_ptr->target_x) flags |= SAVE_MON_TARGET_X;
 239         if (MON_INVULNER(m_ptr)) flags |= SAVE_MON_INVULNER;
 240         if (m_ptr->smart) flags |= SAVE_MON_SMART;
 241         if (m_ptr->exp) flags |= SAVE_MON_EXP;
 242         if (m_ptr->mflag2) flags |= SAVE_MON_MFLAG2;
 243         if (m_ptr->nickname) flags |= SAVE_MON_NICKNAME;
 244         if (m_ptr->parent_m_idx) flags |= SAVE_MON_PARENT;
 245
 246         /*** Monster save flags ***/
 247         wr_u32b(flags);
 248
 249         /*** Write only un-obvious elements ***/
 250         wr_s16b(m_ptr->r_idx);
 251         wr_byte((byte_hack)m_ptr->fy);
 252         wr_byte((byte_hack)m_ptr->fx);
 253         wr_s16b((s16b)m_ptr->hp);
 254         wr_s16b((s16b)m_ptr->maxhp);
 255         wr_s16b((s16b)m_ptr->max_maxhp);
 256         wr_u32b(m_ptr->dealt_damage);
 257
 258
 259         /* Monster race index of its appearance */
 260         if (flags & SAVE_MON_AP_R_IDX) wr_s16b(m_ptr->ap_r_idx);
 261
 262         if (flags & SAVE_MON_SUB_ALIGN) wr_byte(m_ptr->sub_align);
 263         if (flags & SAVE_MON_CSLEEP) wr_s16b(m_ptr->mtimed[MTIMED_CSLEEP]);
 264
 265         wr_byte((byte)m_ptr->mspeed);
 266         wr_s16b(m_ptr->energy_need);
 267
 268         if (flags & SAVE_MON_FAST)
 269         {
 270                 tmp8u = (byte)m_ptr->mtimed[MTIMED_FAST];
 271                 wr_byte(tmp8u);
 272         }
 273         if (flags & SAVE_MON_SLOW)
 274         {
 275                 tmp8u = (byte)m_ptr->mtimed[MTIMED_SLOW];
 276                 wr_byte(tmp8u);
 277         }
 278         if (flags & SAVE_MON_STUNNED)
 279         {
 280                 tmp8u = (byte)m_ptr->mtimed[MTIMED_STUNNED];
 281                 wr_byte(tmp8u);
 282         }
 283         if (flags & SAVE_MON_CONFUSED)
 284         {
 285                 tmp8u = (byte)m_ptr->mtimed[MTIMED_CONFUSED];
 286                 wr_byte(tmp8u);
 287         }
 288         if (flags & SAVE_MON_MONFEAR)
 289         {
 290                 tmp8u = (byte)m_ptr->mtimed[MTIMED_MONFEAR];
 291                 wr_byte(tmp8u);
 292         }
 293         if (flags & SAVE_MON_TARGET_Y) wr_s16b((s16b)m_ptr->target_y);
 294         if (flags & SAVE_MON_TARGET_X) wr_s16b((s16b)m_ptr->target_x);
 295         if (flags & SAVE_MON_INVULNER)
 296         {
 297                 tmp8u = (byte)m_ptr->mtimed[MTIMED_INVULNER];
 298                 wr_byte(tmp8u);
 299         }
 300         if (flags & SAVE_MON_SMART) wr_u32b(m_ptr->smart);
 301         if (flags & SAVE_MON_EXP) wr_u32b(m_ptr->exp);
 302         if (flags & SAVE_MON_MFLAG2) wr_byte(m_ptr->mflag2);
 303         if (flags & SAVE_MON_NICKNAME) wr_string(quark_str(m_ptr->nickname));
 304         if (flags & SAVE_MON_PARENT) wr_s16b(m_ptr->parent_m_idx);
 305 }
 306
 307
 308 /*!
 309  * @brief モンスターの思い出を書き込む / Write a "lore" record
 310  * @param r_idx モンスター種族ID
 311  * @return なし
 312  */
 313 static void wr_lore(MONRACE_IDX r_idx)
 314 {
 315         monster_race *r_ptr = &r_info[r_idx];
 316
 317         /* Count sights/deaths/kills */
 318         wr_s16b((s16b)r_ptr->r_sights);
 319         wr_s16b((s16b)r_ptr->r_deaths);
 320         wr_s16b((s16b)r_ptr->r_pkills);
 321         wr_s16b((s16b)r_ptr->r_akills);
 322         wr_s16b((s16b)r_ptr->r_tkills);
 323
 324         /* Count wakes and ignores */
 325         wr_byte(r_ptr->r_wake);
 326         wr_byte(r_ptr->r_ignore);
 327
 328         /* Extra stuff */
 329         wr_byte(r_ptr->r_xtra1);
 330         wr_byte(r_ptr->r_xtra2);
 331
 332         /* Count drops */
 333         wr_byte((byte_hack)r_ptr->r_drop_gold);
 334         wr_byte((byte_hack)r_ptr->r_drop_item);
 335
 336         /* Count spells */
 337         wr_byte(0); /* unused now */
 338         wr_byte(r_ptr->r_cast_spell);
 339
 340         /* Count blows of each type */
 341         wr_byte(r_ptr->r_blows[0]);
 342         wr_byte(r_ptr->r_blows[1]);
 343         wr_byte(r_ptr->r_blows[2]);
 344         wr_byte(r_ptr->r_blows[3]);
 345
 346         /* Memorize flags */
 347         wr_u32b(r_ptr->r_flags1);
 348         wr_u32b(r_ptr->r_flags2);
 349         wr_u32b(r_ptr->r_flags3);
 350         wr_u32b(r_ptr->r_flags4);
 351         wr_u32b(r_ptr->r_flags5);
 352         wr_u32b(r_ptr->r_flags6);
 353         wr_u32b(r_ptr->r_flagsr);
 354
 355         /* Monster limit per level */
 356         wr_byte((byte_hack)r_ptr->max_num);
 357
 358         /* Location in saved floor */
 359         wr_s16b(r_ptr->floor_id);
 360
 361         /* Later (?) */
 362         wr_byte(0);
 363 }
 364
 365 /*!
 366  * @brief その他のゲーム情報を書き込む(実質はアイテムの鑑定情報のみ) / Write an "xtra" record
 367  * @param k_idx ベースアイテムのID
 368  * @return なし
 369  */
 370 static void wr_xtra(KIND_OBJECT_IDX k_idx)
 371 {
 372         byte tmp8u = 0;
 373
 374         object_kind *k_ptr = &k_info[k_idx];
 375
 376         if (k_ptr->aware) tmp8u |= 0x01;
 377         if (k_ptr->tried) tmp8u |= 0x02;
 378
 379         wr_byte(tmp8u);
 380 }
 381
 382
 383 /*!
 384  * @brief セーブデータに店舗情報を書き込む / Write a "store" record
 385  * @param st_ptr 店舗情報の参照ポインタ
 386  * @return なし
 387  */
 388 static void wr_store(store_type *st_ptr)
 389 {
 390         int j;
 391
 392         /* Save the "open" counter */
 393         wr_u32b(st_ptr->store_open);
 394
 395         /* Save the "insults" */
 396         wr_s16b(st_ptr->insult_cur);
 397
 398         /* Save the current owner */
 399         wr_byte(st_ptr->owner);
 400
 401         /* Save the stock size */
 402         wr_s16b(st_ptr->stock_num);
 403
 404         /* Save the "haggle" info */
 405         wr_s16b(st_ptr->good_buy);
 406         wr_s16b(st_ptr->bad_buy);
 407
 408         wr_s32b(st_ptr->last_visit);
 409
 410         /* Save the stock */
 411         for (j = 0; j < st_ptr->stock_num; j++)
 412         {
 413                 /* Save each item in stock */
 414                 wr_item(&st_ptr->stock[j]);
 415         }
 416 }
 417
 418
 419 /*!
 420  * @brief セーブデータに乱数情報を書き込む / Write RNG state
 421  * @return 常に0(成功を返す)
 422  */
 423 static errr wr_randomizer(void)
 424 {
 425         int i;
 426         wr_u16b(0);
 427         wr_u16b(Rand_place);
 428
 429         for (i = 0; i < RAND_DEG; i++)
 430         {
 431                 wr_u32b(Rand_state[i]);
 432         }
 433
 434         return (0);
 435 }
 436
 437
 438 /*!
 439  * @brief ゲームオプション情報を書き込む / Write the "options"
 440  * @return なし
 441  */
 442 static void wr_options(void)
 443 {
 444         int i;
 445
 446         u16b c;
 447
 448
 449         /*** Oops ***/
 450
 451         for (i = 0; i < 4; i++) wr_u32b(0L);
 452
 453
 454         /*** Special Options ***/
 455
 456         /* Write "delay_factor" */
 457         wr_byte(delay_factor);
 458
 459         /* Write "hitpoint_warn" */
 460         wr_byte(hitpoint_warn);
 461
 462         /* Write "mana_warn" */
 463         wr_byte(mana_warn);
 464
 465         /*** Cheating options ***/
 466
 467         c = 0;
 468
 469         if (p_ptr->wizard) c |= 0x0002;
 470
 471         if (cheat_sight) c |= 0x0040;
 472         if (cheat_turn) c |= 0x0080;
 473
 474         if (cheat_peek) c |= 0x0100;
 475         if (cheat_hear) c |= 0x0200;
 476         if (cheat_room) c |= 0x0400;
 477         if (cheat_xtra) c |= 0x0800;
 478         if (cheat_know) c |= 0x1000;
 479         if (cheat_live) c |= 0x2000;
 480         if (cheat_save) c |= 0x4000;
 481         if (cheat_diary_output) c |= 0x8000;
 482
 483         wr_u16b(c);
 484
 485         /* Autosave info */
 486         wr_byte(autosave_l);
 487         wr_byte(autosave_t);
 488         wr_s16b(autosave_freq);
 489
 490         /*** Extract options ***/
 491
 492         /* Analyze the options */
 493         for (i = 0; option_info[i].o_desc; i++)
 494         {
 495                 int os = option_info[i].o_set;
 496                 int ob = option_info[i].o_bit;
 497
 498                 /* Process real entries */
 499                 if (option_info[i].o_var)
 500                 {
 501                         /* Set */
 502                         if (*option_info[i].o_var)
 503                         {
 504                                 /* Set */
 505                                 option_flag[os] |= (1L << ob);
 506                         }
 507
 508                         /* Clear */
 509                         else
 510                         {
 511                                 /* Clear */
 512                                 option_flag[os] &= ~(1L << ob);
 513                         }
 514                 }
 515         }
 516
 517
 518         /*** Normal options ***/
 519
 520         /* Dump the flags */
 521         for (i = 0; i < 8; i++) wr_u32b(option_flag[i]);
 522
 523         /* Dump the masks */
 524         for (i = 0; i < 8; i++) wr_u32b(option_mask[i]);
 525
 526
 527         /*** Window options ***/
 528
 529         /* Dump the flags */
 530         for (i = 0; i < 8; i++) wr_u32b(window_flag[i]);
 531
 532         /* Dump the masks */
 533         for (i = 0; i < 8; i++) wr_u32b(window_mask[i]);
 534 }
 535
 536
 537 /*!
 538  * @brief ダミー情報スキップを書き込む / Hack -- Write the "ghost" info
 539  * @return なし
 540  */
 541 static void wr_ghost(void)
 542 {
 543         int i;
 544
 545         /* Name */
 546         wr_string(_("不正なゴースト", "Broken Ghost"));
 547
 548         /* Hack -- stupid data */
 549         for (i = 0; i < 60; i++) wr_byte(0);
 550 }
 551
 552
 553 /*!
 554  * @brief クイック・スタート情報を書き込む / Save quick start data
 555  * @return なし
 556  */
 557 static void save_quick_start(void)
 558 {
 559         int i;
 560
 561         wr_byte(previous_char.psex);
 562         wr_byte((byte_hack)previous_char.prace);
 563         wr_byte((byte_hack)previous_char.pclass);
 564         wr_byte((byte_hack)previous_char.pseikaku);
 565         wr_byte((byte_hack)previous_char.realm1);
 566         wr_byte((byte_hack)previous_char.realm2);
 567
 568         wr_s16b(previous_char.age);
 569         wr_s16b(previous_char.ht);
 570         wr_s16b(previous_char.wt);
 571         wr_s16b(previous_char.sc);
 572         wr_s32b(previous_char.au);
 573
 574         for (i = 0; i < A_MAX; i++) wr_s16b(previous_char.stat_max[i]);
 575         for (i = 0; i < A_MAX; i++) wr_s16b(previous_char.stat_max_max[i]);
 576
 577         for (i = 0; i < PY_MAX_LEVEL; i++) wr_s16b((s16b)previous_char.player_hp[i]);
 578
 579         wr_s16b(previous_char.chaos_patron);
 580
 581         for (i = 0; i < 8; i++) wr_s16b(previous_char.vir_types[i]);
 582
 583         for (i = 0; i < 4; i++) wr_string(previous_char.history[i]);
 584
 585         /* UNUSED : Was number of random quests */
 586         wr_byte(0);
 587
 588         /* No quick start after using debug mode or cheat options */
 589         if (p_ptr->noscore) previous_char.quick_ok = FALSE;
 590
 591         wr_byte((byte)previous_char.quick_ok);
 592 }
 593
 594
 595 /*!
 596  * @brief その他の情報を書き込む / Write some "extra" info
 597  * @return なし
 598  */
 599 static void wr_extra(void)
 600 {
 601         int i,j;
 602         byte tmp8u;
 603
 604         wr_string(p_ptr->name);
 605         wr_string(p_ptr->died_from);
 606         wr_string(p_ptr->last_message ? p_ptr->last_message : "");
 607
 608         save_quick_start();
 609
 610         for (i = 0; i < 4; i++)
 611         {
 612                 wr_string(p_ptr->history[i]);
 613         }
 614
 615         /* Race/Class/Gender/Spells */
 616         wr_byte((byte_hack)p_ptr->prace);
 617         wr_byte((byte_hack)p_ptr->pclass);
 618         wr_byte((byte_hack)p_ptr->pseikaku);
 619         wr_byte((byte_hack)p_ptr->psex);
 620         wr_byte((byte_hack)p_ptr->realm1);
 621         wr_byte((byte_hack)p_ptr->realm2);
 622         wr_byte(0);
 623
 624         wr_byte((byte)p_ptr->hitdie);
 625         wr_u16b(p_ptr->expfact);
 626
 627         wr_s16b(p_ptr->age);
 628         wr_s16b(p_ptr->ht);
 629         wr_s16b(p_ptr->wt);
 630
 631         /* Dump the stats (maximum and current) */
 632         for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_max[i]);
 633         for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_max_max[i]);
 634         for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_cur[i]);
 635
 636         /* Ignore the transient stats */
 637         for (i = 0; i < 12; ++i) wr_s16b(0);
 638
 639         wr_u32b(p_ptr->au);
 640
 641         wr_u32b(p_ptr->max_exp);
 642         wr_u32b(p_ptr->max_max_exp);
 643         wr_u32b(p_ptr->exp);
 644         wr_u32b(p_ptr->exp_frac);
 645         wr_s16b(p_ptr->lev);
 646
 647         for (i = 0; i < 64; i++) wr_s16b(p_ptr->spell_exp[i]);
 648         for (i = 0; i < 5; i++) for (j = 0; j < 64; j++) wr_s16b(p_ptr->weapon_exp[i][j]);
 649         for (i = 0; i < GINOU_MAX; i++) wr_s16b(p_ptr->skill_exp[i]);
 650         for (i = 0; i < 108; i++) wr_s32b(p_ptr->magic_num1[i]);
 651         for (i = 0; i < 108; i++) wr_byte(p_ptr->magic_num2[i]);
 652
 653         wr_byte((byte_hack)p_ptr->start_race);
 654         wr_s32b(p_ptr->old_race1);
 655         wr_s32b(p_ptr->old_race2);
 656         wr_s16b(p_ptr->old_realm);
 657
 658         for (i = 0; i < MAX_MANE; i++)
 659         {
 660                 wr_s16b((s16b)p_ptr->mane_spell[i]);
 661                 wr_s16b((s16b)p_ptr->mane_dam[i]);
 662         }
 663         wr_s16b(p_ptr->mane_num);
 664
 665         for (i = 0; i < MAX_KUBI; i++)
 666         {
 667                 wr_s16b(kubi_r_idx[i]);
 668         }
 669
 670         for (i = 0; i < 4; i++)
 671         {
 672                 wr_s16b(battle_mon[i]);
 673                 wr_u32b(mon_odds[i]);
 674         }
 675
 676         wr_s16b(p_ptr->town_num); /* -KMW- */
 677
 678         /* Write arena and rewards information -KMW- */
 679         wr_s16b(p_ptr->arena_number);
 680         wr_s16b(p_ptr->inside_arena);
 681         wr_s16b(p_ptr->inside_quest);
 682         wr_s16b(p_ptr->inside_battle);
 683         wr_byte(p_ptr->exit_bldg);
 684         wr_byte(0); /* Unused */
 685
 686         wr_s16b((s16b)p_ptr->oldpx);
 687         wr_s16b((s16b)p_ptr->oldpy);
 688
 689         /* Was number of p_ptr->rewards[] */
 690         wr_s16b(0);
 691
 692         wr_s32b(p_ptr->mhp);
 693         wr_s32b(p_ptr->chp);
 694         wr_u32b(p_ptr->chp_frac);
 695
 696         wr_s32b(p_ptr->msp);
 697         wr_s32b(p_ptr->csp);
 698         wr_u32b(p_ptr->csp_frac);
 699
 700         /* Max Player and Dungeon Levels */
 701         wr_s16b(p_ptr->max_plv);
 702         tmp8u = (byte)max_d_idx;
 703         wr_byte(tmp8u);
 704         for (i = 0; i < tmp8u; i++)
 705                 wr_s16b((s16b)max_dlv[i]);
 706
 707         /* More info */
 708         wr_s16b(0);
 709         wr_s16b(0);
 710         wr_s16b(0);
 711         wr_s16b(0);
 712         wr_s16b(p_ptr->sc);
 713         wr_s16b(p_ptr->concent);
 714
 715         wr_s16b(0);             /* old "rest" */
 716         wr_s16b(p_ptr->blind);
 717         wr_s16b(p_ptr->paralyzed);
 718         wr_s16b(p_ptr->confused);
 719         wr_s16b(p_ptr->food);
 720         wr_s16b(0);     /* old "food_digested" */
 721         wr_s16b(0);     /* old "protection" */
 722         wr_s16b(p_ptr->energy_need);
 723         wr_s16b(p_ptr->enchant_energy_need);
 724         wr_s16b(p_ptr->fast);
 725         wr_s16b(p_ptr->slow);
 726         wr_s16b(p_ptr->afraid);
 727         wr_s16b(p_ptr->cut);
 728         wr_s16b(p_ptr->stun);
 729         wr_s16b(p_ptr->poisoned);
 730         wr_s16b(p_ptr->image);
 731         wr_s16b(p_ptr->protevil);
 732         wr_s16b(p_ptr->invuln);
 733         wr_s16b(p_ptr->ult_res);
 734         wr_s16b(p_ptr->hero);
 735         wr_s16b(p_ptr->shero);
 736         wr_s16b(p_ptr->shield);
 737         wr_s16b(p_ptr->blessed);
 738         wr_s16b(p_ptr->tim_invis);
 739         wr_s16b(p_ptr->word_recall);
 740         wr_s16b(p_ptr->recall_dungeon);
 741         wr_s16b(p_ptr->alter_reality);
 742         wr_s16b(p_ptr->see_infra);
 743         wr_s16b(p_ptr->tim_infra);
 744         wr_s16b(p_ptr->oppose_fire);
 745         wr_s16b(p_ptr->oppose_cold);
 746         wr_s16b(p_ptr->oppose_acid);
 747         wr_s16b(p_ptr->oppose_elec);
 748         wr_s16b(p_ptr->oppose_pois);
 749         wr_s16b(p_ptr->tsuyoshi);
 750         wr_s16b(p_ptr->tim_esp);
 751         wr_s16b(p_ptr->wraith_form);
 752         wr_s16b(p_ptr->resist_magic);
 753         wr_s16b(p_ptr->tim_regen);
 754         wr_s16b(p_ptr->kabenuke);
 755         wr_s16b(p_ptr->tim_stealth);
 756         wr_s16b(p_ptr->tim_levitation);
 757         wr_s16b(p_ptr->tim_sh_touki);
 758         wr_s16b(p_ptr->lightspeed);
 759         wr_s16b(p_ptr->tsubureru);
 760         wr_s16b(p_ptr->magicdef);
 761         wr_s16b(p_ptr->tim_res_nether);
 762         wr_s16b(p_ptr->tim_res_time);
 763         wr_byte((byte)p_ptr->mimic_form);
 764         wr_s16b(p_ptr->tim_mimic);
 765         wr_s16b(p_ptr->tim_sh_fire);
 766         wr_s16b(p_ptr->tim_sh_holy);
 767         wr_s16b(p_ptr->tim_eyeeye);
 768
 769         /* by henkma */
 770         wr_s16b(p_ptr->tim_reflect);
 771         wr_s16b(p_ptr->multishadow);
 772         wr_s16b(p_ptr->dustrobe);
 773
 774         wr_s16b(p_ptr->chaos_patron);
 775         wr_u32b(p_ptr->muta1);
 776         wr_u32b(p_ptr->muta2);
 777         wr_u32b(p_ptr->muta3);
 778
 779         for (i = 0; i<8; i++)
 780                 wr_s16b(p_ptr->virtues[i]);
 781         for (i = 0; i<8; i++)
 782                 wr_s16b(p_ptr->vir_types[i]);
 783
 784         wr_s16b(p_ptr->ele_attack);
 785         wr_u32b(p_ptr->special_attack);
 786         wr_s16b(p_ptr->ele_immune);
 787         wr_u32b(p_ptr->special_defense);
 788         wr_byte(p_ptr->knowledge);
 789         wr_byte(p_ptr->autopick_autoregister);
 790         wr_byte(0);
 791         wr_byte((byte_hack)p_ptr->action);
 792         wr_byte(0);
 793         wr_byte(preserve_mode);
 794         wr_byte(p_ptr->wait_report_score);
 795
 796         /* Future use */
 797         for (i = 0; i < 12; i++) wr_u32b(0L);
 798
 799         /* Ignore some flags */
 800         wr_u32b(0L);
 801         wr_u32b(0L);
 802         wr_u32b(0L);
 803
 804
 805         /* Write the "object seeds" */
 806         wr_u32b(seed_flavor);
 807         wr_u32b(seed_town);
 808
 809
 810         /* Special stuff */
 811         wr_u16b(p_ptr->panic_save);
 812         wr_u16b(p_ptr->total_winner);
 813         wr_u16b(p_ptr->noscore);
 814
 815
 816         /* Write death */
 817         wr_byte(p_ptr->is_dead);
 818
 819         /* Write feeling */
 820         wr_byte(p_ptr->feeling);
 821
 822         /* Turn when level began */
 823         wr_s32b(old_turn);
 824
 825         /* Turn of last "feeling" */
 826         wr_s32b(p_ptr->feeling_turn);
 827
 828         /* Current turn */
 829         wr_s32b(turn);
 830
 831         wr_s32b(dungeon_turn);
 832
 833         wr_s32b(old_battle);
 834
 835         wr_s16b(today_mon);
 836         wr_s16b(p_ptr->today_mon);
 837         wr_s16b(p_ptr->riding);
 838
 839         /* Current floor_id */
 840         wr_s16b(p_ptr->floor_id);
 841
 842         /* Save temporary preserved pets (obsolated) */
 843         wr_s16b(0);
 844
 845         wr_u32b(playtime);
 846
 847         wr_s32b(p_ptr->visit);
 848
 849         wr_u32b(p_ptr->count);
 850 }
 851
 852
 853 /*!
 854  * @brief フロア保存時のcave情報テンプレートをソートするための比較処理
 855  * @param u caveテンプレートの参照ポインタ
 856  * @param v 未使用
 857  * @param a スワップするモンスター種族のID1
 858  * @param b スワップするモンスター種族のID2
 859  * @return aの方が大きければtrue
 860  */
 861 static bool ang_sort_comp_cave_temp(vptr u, vptr v, int a, int b)
 862 {
 863         cave_template_type *who = (cave_template_type *)(u);
 864
 865         u16b o1 = who[a].occurrence;
 866         u16b o2 = who[b].occurrence;
 867
 868         /* Unused */
 869         (void)v;
 870
 871         return o2 <= o1;
 872 }
 873
 874
 875 /*!
 876  * @brief フロア保存時のcave情報テンプレートをソートするためのスワップ処理 / Sorting hook -- Swap function
 877  * @param u caveテンプレートの参照ポインタ
 878  * @param v 未使用
 879  * @param a スワップするモンスター種族のID1
 880  * @param b スワップするモンスター種族のID2
 881  * @return なし
 882  */
 883 static void ang_sort_swap_cave_temp(vptr u, vptr v, int a, int b)
 884 {
 885         cave_template_type *who = (cave_template_type *)(u);
 886
 887         cave_template_type holder;
 888
 889         /* Unused */
 890         (void)v;
 891
 892         /* Swap */
 893         holder = who[a];
 894         who[a] = who[b];
 895         who[b] = holder;
 896 }
 897
 898
 899 /*!
 900  * @brief 保存フロアの書き込み / Actually write a saved floor data using effectively compressed format.
 901  * @param sf_ptr 保存したいフロアの参照ポインタ
 902  * @return なし
 903  */
 904 static void wr_saved_floor(saved_floor_type *sf_ptr)
 905 {
 906         cave_template_type *templates;
 907         u16b max_num_temp;
 908         u16b num_temp = 0;
 909         int dummy_why;
 910
 911         int i, y, x;
 912
 913         u16b tmp16u;
 914
 915         byte count;
 916         u16b prev_u16b;
 917
 918
 919         /*** Basic info ***/
 920
 921         /* Dungeon floor specific info follows */
 922
 923         if (!sf_ptr)
 924         {
 925                 /*** Not a saved floor ***/
 926
 927                 wr_s16b((s16b)dun_level);
 928         }
 929         else
 930         {
 931                 /*** The saved floor ***/
 932
 933                 wr_s16b(sf_ptr->floor_id);
 934                 wr_byte((byte_hack)sf_ptr->savefile_id);
 935                 wr_s16b((s16b)sf_ptr->dun_level);
 936                 wr_s32b(sf_ptr->last_visit);
 937                 wr_u32b(sf_ptr->visit_mark);
 938                 wr_s16b(sf_ptr->upper_floor_id);
 939                 wr_s16b(sf_ptr->lower_floor_id);
 940         }
 941
 942         wr_u16b((u16b)base_level);
 943         wr_u16b((s16b)num_repro);
 944         wr_u16b((u16b)p_ptr->y);
 945         wr_u16b((u16b)p_ptr->x);
 946         wr_u16b((u16b)cur_hgt);
 947         wr_u16b((u16b)cur_wid);
 948         wr_byte(p_ptr->feeling);
 949
 950
 951
 952         /*********** Make template for cave_type **********/
 953
 954         /*
 955          * Usually number of templates are fewer than 255.  Even if
 956          * more than 254 are exist, the occurrence of each template
 957          * with larger ID is very small when we sort templates by
 958          * occurrence.  So we will use two (or more) bytes for
 959          * templete ID larger than 254.
 960          *
 961          * Ex: 256 will be "0xff" "0x01".
 962          *     515 will be "0xff" "0xff" "0x03"
 963          */
 964
 965         /* Fake max number */
 966         max_num_temp = 255;
 967
 968         /* Allocate the "template" array */
 969         C_MAKE(templates, max_num_temp, cave_template_type);
 970
 971         /* Extract template array */
 972         for (y = 0; y < cur_hgt; y++)
 973         {
 974                 for (x = 0; x < cur_wid; x++)
 975                 {
 976                         cave_type *c_ptr = &cave[y][x];
 977
 978                         for (i = 0; i < num_temp; i++)
 979                         {
 980                                 if (templates[i].info == c_ptr->info &&
 981                                     templates[i].feat == c_ptr->feat &&
 982                                     templates[i].mimic == c_ptr->mimic &&
 983                                     templates[i].special == c_ptr->special)
 984                                 {
 985                                         /* Same terrain is exist */
 986                                         templates[i].occurrence++;
 987                                         break;
 988                                 }
 989                         }
 990
 991                         /* Are there same one? */
 992                         if (i < num_temp) continue;
 993
 994                         /* If the max_num_temp is too small, increase it. */
 995                         if (num_temp >= max_num_temp)
 996                         {
 997                                 cave_template_type *old_template = templates;
 998
 999                                 /* Re-allocate the "template" array */
1000                                 C_MAKE(templates, max_num_temp + 255, cave_template_type);
1001                                 (void)C_COPY(templates, old_template, max_num_temp, cave_template_type);
1002                                 C_KILL(old_template, max_num_temp, cave_template_type);
1003                                 max_num_temp += 255;
1004                         }
1005
1006                         /* Add new template */
1007                         templates[num_temp].info = c_ptr->info;
1008                         templates[num_temp].feat = c_ptr->feat;
1009                         templates[num_temp].mimic = c_ptr->mimic;
1010                         templates[num_temp].special = c_ptr->special;
1011                         templates[num_temp].occurrence = 1;
1012
1013                         /* Increase number of template */
1014                         num_temp++;
1015                 }
1016         }
1017
1018         /* Select the sort method */
1019         ang_sort_comp = ang_sort_comp_cave_temp;
1020         ang_sort_swap = ang_sort_swap_cave_temp;
1021
1022         /* Sort by occurrence */
1023         ang_sort(templates, &dummy_why, num_temp);
1024
1025
1026         /*** Dump templates ***/
1027
1028         /* Total templates */
1029         wr_u16b(num_temp);
1030
1031         /* Dump the templates */
1032         for (i = 0; i < num_temp; i++)
1033         {
1034                 cave_template_type *ct_ptr = &templates[i];
1035
1036                 /* Dump it */
1037                 wr_u16b((u16b)ct_ptr->info);
1038                 wr_s16b(ct_ptr->feat);
1039                 wr_s16b(ct_ptr->mimic);
1040                 wr_s16b(ct_ptr->special);
1041         }
1042
1043
1044
1045         /*** "Run-Length-Encoding" of cave ***/
1046
1047         /* Note that this will induce two wasted bytes */
1048         count = 0;
1049         prev_u16b = 0;
1050
1051         /* Dump the cave */
1052         for (y = 0; y < cur_hgt; y++)
1053         {
1054                 for (x = 0; x < cur_wid; x++)
1055                 {
1056                         cave_type *c_ptr = &cave[y][x];
1057
1058                         for (i = 0; i < num_temp; i++)
1059                         {
1060                                 if (templates[i].info == c_ptr->info &&
1061                                     templates[i].feat == c_ptr->feat &&
1062                                     templates[i].mimic == c_ptr->mimic &&
1063                                     templates[i].special == c_ptr->special)
1064                                         break;
1065                         }
1066
1067                         /* Extract an ID */
1068                         tmp16u = (u16b)i;
1069
1070                         /* If the run is broken, or too full, flush it */
1071                         if ((tmp16u != prev_u16b) || (count == MAX_UCHAR))
1072                         {
1073                                 wr_byte((byte)count);
1074
1075                                 while (prev_u16b >= MAX_UCHAR)
1076                                 {
1077                                         /* Mark as actual data is larger than 254 */
1078                                         wr_byte(MAX_UCHAR);
1079                                         prev_u16b -= MAX_UCHAR;
1080                                 }
1081
1082                                 wr_byte((byte)prev_u16b);
1083                                 prev_u16b = tmp16u;
1084                                 count = 1;
1085                         }
1086
1087                         /* Continue the run */
1088                         else
1089                         {
1090                                 count++;
1091                         }
1092                 }
1093         }
1094
1095         /* Flush the data (if any) */
1096         if (count)
1097         {
1098                 wr_byte((byte)count);
1099
1100                 while (prev_u16b >= MAX_UCHAR)
1101                 {
1102                         /* Mark as actual data is larger than 254 */
1103                         wr_byte(MAX_UCHAR);
1104                         prev_u16b -= MAX_UCHAR;
1105                 }
1106                 wr_byte((byte)prev_u16b);
1107         }
1108
1109
1110         /* Free the "template" array */
1111         C_KILL(templates, max_num_temp, cave_template_type);
1112
1113
1114         /*** Dump objects ***/
1115
1116         /* Total objects */
1117         wr_u16b(o_max);
1118
1119         /* Dump the objects */
1120         for (i = 1; i < o_max; i++)
1121         {
1122                 object_type *o_ptr = &o_list[i];
1123
1124                 /* Dump it */
1125                 wr_item(o_ptr);
1126         }
1127
1128
1129         /*** Dump the monsters ***/
1130
1131         /* Total monsters */
1132         wr_u16b(m_max);
1133
1134         /* Dump the monsters */
1135         for (i = 1; i < m_max; i++)
1136         {
1137                 monster_type *m_ptr = &m_list[i];
1138
1139                 /* Dump it */
1140                 wr_monster(m_ptr);
1141         }
1142 }
1143
1144
1145 /*!
1146  * @brief 現在フロアの書き込み /
1147  * Write the current dungeon (new method)
1148  * @return なし
1149  */
1150 static bool wr_dungeon(void)
1151 {
1152         saved_floor_type *cur_sf_ptr;
1153         int i;
1154
1155         forget_lite();
1156         forget_view();
1157         clear_mon_lite();
1158
1159         /* Update lite/view */
1160         p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE);
1161         p_ptr->update |= (PU_MONSTERS | PU_DISTANCE | PU_FLOW);
1162
1163         /*** Meta info ***/
1164
1165         /* Number of floor_id used from birth */
1166         wr_s16b(max_floor_id);
1167
1168         /* Current dungeon type */
1169         wr_byte((byte_hack)dungeon_idx);
1170
1171
1172         /*** No saved floor (On the surface etc.) ***/
1173         if (!p_ptr->floor_id)
1174         {
1175                 /* No array elements */
1176                 wr_byte(0);
1177
1178                 /* Write the current floor data */
1179                 wr_saved_floor(NULL);
1180
1181                 /* Success */
1182                 return TRUE;
1183         }
1184
1185
1186         /*** In the dungeon ***/
1187
1188         /* Number of array elements */
1189         wr_byte(MAX_SAVED_FLOORS);
1190
1191         /* Write the saved_floors array */
1192         for (i = 0; i < MAX_SAVED_FLOORS; i++)
1193         {
1194                 saved_floor_type *sf_ptr = &saved_floors[i];
1195
1196                 wr_s16b(sf_ptr->floor_id);
1197                 wr_byte((byte_hack)sf_ptr->savefile_id);
1198                 wr_s16b((s16b)sf_ptr->dun_level);
1199                 wr_s32b(sf_ptr->last_visit);
1200                 wr_u32b(sf_ptr->visit_mark);
1201                 wr_s16b(sf_ptr->upper_floor_id);
1202                 wr_s16b(sf_ptr->lower_floor_id);
1203         }
1204
1205         /* Extract pointer to current floor */
1206         cur_sf_ptr = get_sf_ptr(p_ptr->floor_id);
1207
1208         /* Save current floor to temporal file */
1209         if (!save_floor(cur_sf_ptr, (SLF_SECOND))) return FALSE;
1210
1211         /* Move data in temporal files to the savefile */
1212         for (i = 0; i < MAX_SAVED_FLOORS; i++)
1213         {
1214                 saved_floor_type *sf_ptr = &saved_floors[i];
1215
1216                 /* Unused element */
1217                 if (!sf_ptr->floor_id) continue;
1218
1219                 /* Load temporal saved floor file */
1220                 if (load_floor(sf_ptr, (SLF_SECOND | SLF_NO_KILL)))
1221                 {
1222                         /* Mark success */
1223                         wr_byte(0);
1224
1225                         /* Write saved floor data to the save file */
1226                         wr_saved_floor(sf_ptr);
1227                 }
1228                 else
1229                 {
1230                         /* Mark failure */
1231                         wr_byte(1);
1232                 }
1233         }
1234
1235         /* Restore current floor */
1236         if (!load_floor(cur_sf_ptr, (SLF_SECOND))) return FALSE;
1237
1238         /* Success */
1239         return TRUE;
1240 }
1241
1242
1243 /*!
1244  * @brief セーブデータの書き込み /
1245  * Actually write a save-file
1246  * @return 成功すればtrue
1247  */
1248 static bool wr_savefile_new(void)
1249 {
1250         int        i, j;
1251
1252         u32b              now;
1253
1254         byte            tmp8u;
1255         u16b            tmp16u;
1256         u32b            tmp32u;
1257
1258         MONRACE_IDX r_idx;
1259         KIND_OBJECT_IDX k_idx;
1260
1261         /* Compact the objects */
1262         compact_objects(0);
1263         /* Compact the monsters */
1264         compact_monsters(0);
1265
1266         /* Guess at the current time */
1267         now = (u32b)time((time_t *)0);
1268
1269
1270         /* Note the operating system */
1271         sf_system = 0L;
1272
1273         /* Note when the file was saved */
1274         sf_when = now;
1275
1276         /* Note the number of saves */
1277         sf_saves++;
1278
1279
1280         /*** Actually write the file ***/
1281
1282         /* Dump the file header */
1283         xor_byte = 0;
1284         wr_byte(FAKE_VER_MAJOR);
1285         xor_byte = 0;
1286         wr_byte(FAKE_VER_MINOR);
1287         xor_byte = 0;
1288         wr_byte(FAKE_VER_PATCH);
1289         xor_byte = 0;
1290
1291         /* Initial value of xor_byte */
1292         tmp8u = (byte)Rand_external(256);
1293         wr_byte(tmp8u);
1294
1295
1296         /* Reset the checksum */
1297         v_stamp = 0L;
1298         x_stamp = 0L;
1299
1300         /* Write the savefile version for Hengband 1.1.1 and later */
1301         wr_byte(H_VER_EXTRA);
1302         wr_byte(H_VER_PATCH);
1303         wr_byte(H_VER_MINOR);
1304         wr_byte(H_VER_MAJOR);
1305
1306         /* Operating system */
1307         wr_u32b(sf_system);
1308
1309
1310         /* Time file last saved */
1311         wr_u32b(sf_when);
1312
1313         /* Number of past lives */
1314         wr_u16b(sf_lives);
1315
1316         /* Number of times saved */
1317         wr_u16b(sf_saves);
1318
1319
1320         /* Space */
1321         wr_u32b(0L);
1322         wr_u16b(0);
1323         wr_byte(0);
1324
1325 #ifdef JP
1326 # ifdef EUC
1327         /* EUC kanji code */
1328         wr_byte(2);
1329 # endif
1330 # ifdef SJIS
1331         /* SJIS kanji code */
1332         wr_byte(3);
1333 # endif
1334 #else
1335         /* ASCII */
1336         wr_byte(1);
1337 #endif
1338
1339         /* Write the RNG state */
1340         wr_randomizer();
1341
1342
1343         /* Write the boolean "options" */
1344         wr_options();
1345
1346
1347         /* Dump the number of "messages" */
1348         tmp32u = message_num();
1349         if (compress_savefile && (tmp32u > 40)) tmp32u = 40;
1350         wr_u32b(tmp32u);
1351
1352         /* Dump the messages (oldest first!) */
1353         for (i = tmp32u - 1; i >= 0; i--)
1354         {
1355                 wr_string(message_str((s16b)i));
1356         }
1357
1358         /* Dump the monster lore */
1359         tmp16u = max_r_idx;
1360         wr_u16b(tmp16u);
1361         for (r_idx = 0; r_idx < tmp16u; r_idx++) wr_lore(r_idx);
1362
1363         /* Dump the object memory */
1364         tmp16u = max_k_idx;
1365         wr_u16b(tmp16u);
1366         for (k_idx = 0; k_idx < tmp16u; k_idx++) wr_xtra(k_idx);
1367
1368         /* Dump the towns */
1369         tmp16u = max_towns;
1370         wr_u16b(tmp16u);
1371
1372         /* Dump the quests */
1373         tmp16u = max_q_idx;
1374         wr_u16b(tmp16u);
1375
1376         /* Dump the quests */
1377         tmp8u = MAX_RANDOM_QUEST-MIN_RANDOM_QUEST;
1378         wr_byte(tmp8u);
1379
1380         for (i = 0; i < max_q_idx; i++)
1381         {
1382                 quest_type* const q_ptr = &quest[i];
1383
1384                 /* Save status for every quest */
1385                 wr_s16b(q_ptr->status);
1386
1387                 /* And the dungeon level too */
1388                 /* (prevents problems with multi-level quests) */
1389                 wr_s16b((s16b)q_ptr->level);
1390
1391                 wr_byte((byte_hack)q_ptr->complev);
1392                 wr_u32b(q_ptr->comptime);
1393
1394                 /* Save quest status if quest is running */
1395                 if (q_ptr->status == QUEST_STATUS_TAKEN || q_ptr->status == QUEST_STATUS_COMPLETED || !is_fixed_quest_idx(i))
1396                 {
1397                         wr_s16b((s16b)q_ptr->cur_num);
1398                         wr_s16b((s16b)q_ptr->max_num);
1399                         wr_s16b(q_ptr->type);
1400                         wr_s16b(q_ptr->r_idx);
1401                         wr_s16b(q_ptr->k_idx);
1402                         wr_byte((byte_hack)q_ptr->flags);
1403                         wr_byte((byte_hack)q_ptr->dungeon);
1404                 }
1405         }
1406
1407         /* Dump the position in the wilderness */
1408         wr_s32b(p_ptr->wilderness_x);
1409         wr_s32b(p_ptr->wilderness_y);
1410
1411         wr_byte(p_ptr->wild_mode);
1412         wr_byte(ambush_flag);
1413
1414         wr_s32b(max_wild_x);
1415         wr_s32b(max_wild_y);
1416
1417         /* Dump the wilderness seeds */
1418         for (i = 0; i < max_wild_x; i++)
1419         {
1420                 for (j = 0; j < max_wild_y; j++)
1421                 {
1422                         wr_u32b(wilderness[j][i].seed);
1423                 }
1424         }
1425
1426         /* Hack -- Dump the artifacts */
1427         tmp16u = max_a_idx;
1428         wr_u16b(tmp16u);
1429         for (i = 0; i < tmp16u; i++)
1430         {
1431                 artifact_type *a_ptr = &a_info[i];
1432                 wr_byte(a_ptr->cur_num);
1433                 wr_s16b(a_ptr->floor_id);
1434         }
1435
1436
1437
1438         /* Write the "extra" information */
1439         wr_extra();
1440
1441         /* Dump the "player hp" entries */
1442         tmp16u = PY_MAX_LEVEL;
1443         wr_u16b(tmp16u);
1444         for (i = 0; i < tmp16u; i++)
1445         {
1446                 wr_s16b((s16b)p_ptr->player_hp[i]);
1447         }
1448
1449
1450         /* Write spell data */
1451         wr_u32b(p_ptr->spell_learned1);
1452         wr_u32b(p_ptr->spell_learned2);
1453         wr_u32b(p_ptr->spell_worked1);
1454         wr_u32b(p_ptr->spell_worked2);
1455         wr_u32b(p_ptr->spell_forgotten1);
1456         wr_u32b(p_ptr->spell_forgotten2);
1457
1458         wr_s16b(p_ptr->learned_spells);
1459         wr_s16b(p_ptr->add_spells);
1460
1461         /* Dump the ordered spells */
1462         for (i = 0; i < 64; i++)
1463         {
1464                 wr_byte((byte_hack)p_ptr->spell_order[i]);
1465         }
1466
1467
1468         /* Write the inventory */
1469         for (i = 0; i < INVEN_TOTAL; i++)
1470         {
1471                 object_type *o_ptr = &inventory[i];
1472
1473                 /* Skip non-objects */
1474                 if (!o_ptr->k_idx) continue;
1475
1476                 /* Dump index */
1477                 wr_u16b((u16b)i);
1478
1479                 /* Dump object */
1480                 wr_item(o_ptr);
1481         }
1482
1483         /* Add a sentinel */
1484         wr_u16b(0xFFFF);
1485
1486         /* Note the towns */
1487         tmp16u = max_towns;
1488         wr_u16b(tmp16u);
1489
1490         /* Note the stores */
1491         tmp16u = MAX_STORES;
1492         wr_u16b(tmp16u);
1493
1494         /* Dump the stores of all towns */
1495         for (i = 1; i < max_towns; i++)
1496         {
1497                 for (j = 0; j < MAX_STORES; j++)
1498                 {
1499                         wr_store(&town[i].store[j]);
1500                 }
1501         }
1502
1503         /* Write the pet command settings */
1504         wr_s16b(p_ptr->pet_follow_distance);
1505         wr_s16b(p_ptr->pet_extra_flags);
1506
1507         /* Write screen dump for sending score */
1508         if (screen_dump && (p_ptr->wait_report_score || !p_ptr->is_dead))
1509         {
1510                 wr_string(screen_dump);
1511         }
1512         else
1513         {
1514                 wr_string("");
1515         }
1516
1517         /* Player is not dead, write the dungeon */
1518         if (!p_ptr->is_dead)
1519         {
1520                 /* Dump the dungeon */
1521                 if (!wr_dungeon()) return FALSE;
1522
1523                 /* Dump the ghost */
1524                 wr_ghost();
1525
1526                 /* No scripts */
1527                 wr_s32b(0);
1528         }
1529
1530
1531         /* Write the "value check-sum" */
1532         wr_u32b(v_stamp);
1533
1534         /* Write the "encoded checksum" */
1535         wr_u32b(x_stamp);
1536
1537
1538         /* Error in save */
1539         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
1540
1541         /* Successful save */
1542         return TRUE;
1543 }
1544
1545
1546 /*!
1547  * @brief セーブデータ書き込みのサブルーチン /
1548  * Medium level player saver
1549  * @return 成功すればtrue
1550  * @details
1551  * Angband 2.8.0 will use "fd" instead of "fff" if possible
1552  */
1553 static bool save_player_aux(char *name)
1554 {
1555         bool ok = FALSE;
1556         int fd = -1;
1557         int mode = 0644;
1558
1559         /* No file yet */
1560         fff = NULL;
1561
1562         /* File type is "SAVE" */
1563         FILE_TYPE(FILE_TYPE_SAVE);
1564
1565         /* Grab permissions */
1566         safe_setuid_grab();
1567
1568         /* Create the savefile */
1569         fd = fd_make(name, mode);
1570
1571         /* Drop permissions */
1572         safe_setuid_drop();
1573
1574         /* File is okay */
1575         if (fd >= 0)
1576         {
1577                 /* Close the "fd" */
1578                 (void)fd_close(fd);
1579
1580                 /* Grab permissions */
1581                 safe_setuid_grab();
1582
1583                 /* Open the savefile */
1584                 fff = my_fopen(name, "wb");
1585
1586                 /* Drop permissions */
1587                 safe_setuid_drop();
1588
1589                 /* Successful open */
1590                 if (fff)
1591                 {
1592                         /* Write the savefile */
1593                         if (wr_savefile_new()) ok = TRUE;
1594
1595                         /* Attempt to close it */
1596                         if (my_fclose(fff)) ok = FALSE;
1597                 }
1598
1599                 /* Grab permissions */
1600                 safe_setuid_grab();
1601
1602                 /* Remove "broken" files */
1603                 if (!ok) (void)fd_kill(name);
1604
1605                 /* Drop permissions */
1606                 safe_setuid_drop();
1607         }
1608
1609
1610         /* Failure */
1611         if (!ok) return (FALSE);
1612
1613         counts_write(0, playtime);
1614
1615         /* Successful save */
1616         character_saved = TRUE;
1617
1618         /* Success */
1619         return (TRUE);
1620 }
1621
1622
1623
1624 /*!
1625  * @brief セーブデータ書き込みのメインルーチン /
1626  * Attempt to save the player in a savefile
1627  * @return 成功すればtrue
1628  */
1629 bool save_player(void)
1630 {
1631         bool result = FALSE;
1632
1633         char safe[1024];
1634
1635
1636 #ifdef SET_UID
1637
1638 # ifdef SECURE
1639
1640         /* Get "games" permissions */
1641         beGames();
1642
1643 # endif
1644
1645 #endif
1646
1647
1648         /* New savefile */
1649         strcpy(safe, savefile);
1650         strcat(safe, ".new");
1651
1652         /* Grab permissions */
1653         safe_setuid_grab();
1654
1655         /* Remove it */
1656         fd_kill(safe);
1657
1658         /* Drop permissions */
1659         safe_setuid_drop();
1660
1661         update_playtime();
1662
1663         /* Attempt to save the player */
1664         if (save_player_aux(safe))
1665         {
1666                 char temp[1024];
1667
1668                 /* Old savefile */
1669                 strcpy(temp, savefile);
1670                 strcat(temp, ".old");
1671
1672                 /* Grab permissions */
1673                 safe_setuid_grab();
1674
1675                 /* Remove it */
1676                 fd_kill(temp);
1677
1678                 /* Preserve old savefile */
1679                 fd_move(savefile, temp);
1680
1681                 /* Activate new savefile */
1682                 fd_move(safe, savefile);
1683
1684                 /* Remove preserved savefile */
1685                 fd_kill(temp);
1686
1687                 /* Drop permissions */
1688                 safe_setuid_drop();
1689
1690                 /* Hack -- Pretend the character was loaded */
1691                 character_loaded = TRUE;
1692
1693 #ifdef VERIFY_SAVEFILE
1694
1695                 /* Lock on savefile */
1696                 strcpy(temp, savefile);
1697                 strcat(temp, ".lok");
1698
1699                 /* Grab permissions */
1700                 safe_setuid_grab();
1701
1702                 /* Remove lock file */
1703                 fd_kill(temp);
1704
1705                 /* Drop permissions */
1706                 safe_setuid_drop();
1707
1708 #endif
1709
1710                 /* Success */
1711                 result = TRUE;
1712         }
1713
1714
1715 #ifdef SET_UID
1716
1717 # ifdef SECURE
1718
1719         /* Drop "games" permissions */
1720         bePlayer();
1721
1722 # endif
1723
1724 #endif
1725
1726         /* Return the result */
1727         return (result);
1728 }
1729
1730
1731 /*!
1732  * @brief セーブデータ読み込みのメインルーチン /
1733  * Attempt to Load a "savefile"
1734  * @return 成功すればtrue
1735  * @details
1736  * <pre>
1737  * Version 2.7.0 introduced a slightly different "savefile" format from
1738  * older versions, requiring a completely different parsing method.
1739  *
1740  * Note that savefiles from 2.7.0 - 2.7.2 are completely obsolete.
1741  *
1742  * Pre-2.8.0 savefiles lose some data, see "load2.c" for info.
1743  *
1744  * Pre-2.7.0 savefiles lose a lot of things, see "load1.c" for info.
1745  *
1746  * On multi-user systems, you may only "read" a savefile if you will be
1747  * allowed to "write" it later, this prevents painful situations in which
1748  * the player loads a savefile belonging to someone else, and then is not
1749  * allowed to save his game when he quits.
1750  *
1751  * We return "TRUE" if the savefile was usable, and we set the global
1752  * flag "character_loaded" if a real, living, character was loaded.
1753  *
1754  * Note that we always try to load the "current" savefile, even if
1755  * there is no such file, so we must check for "empty" savefile names.
1756  * </pre>
1757  */
1758 bool load_player(void)
1759 {
1760         int             fd = -1;
1761
1762         errr    err = 0;
1763
1764         byte    vvv[4];
1765
1766 #ifdef VERIFY_TIMESTAMP
1767         struct stat     statbuf;
1768 #endif
1769
1770         concptr    what = "generic";
1771
1772
1773         /* Paranoia */
1774         turn = 0;
1775
1776         /* Paranoia */
1777         p_ptr->is_dead = FALSE;
1778
1779
1780         /* Allow empty savefile name */
1781         if (!savefile[0]) return (TRUE);
1782
1783
1784 #if !defined(MACINTOSH) && !defined(WINDOWS)
1785
1786         /* Fix this */
1787
1788         /* Verify the existance of the savefile */
1789         if (access(savefile, 0) < 0)
1790         {
1791                 /* Give a message */
1792                 msg_print(_("セーブファイルがありません。", "Savefile does not exist."));
1793
1794                 msg_print(NULL);
1795
1796                 /* Allow this */
1797                 return (TRUE);
1798         }
1799
1800 #endif
1801
1802
1803 #ifdef VERIFY_SAVEFILE
1804
1805         /* Verify savefile usage */
1806         if (!err)
1807         {
1808                 FILE *fkk;
1809
1810                 char temp[1024];
1811
1812                 /* Extract name of lock file */
1813                 strcpy(temp, savefile);
1814                 strcat(temp, ".lok");
1815
1816                 /* Check for lock */
1817                 fkk = my_fopen(temp, "r");
1818
1819                 /* Oops, lock exists */
1820                 if (fkk)
1821                 {
1822                         my_fclose(fkk);
1823
1824                         msg_print(_("セーブファイルは現在使用中です。", "Savefile is currently in use."));
1825                         msg_print(NULL);
1826
1827                         return (FALSE);
1828                 }
1829
1830                 /* Create a lock file */
1831                 fkk = my_fopen(temp, "w");
1832
1833                 /* Dump a line of info */
1834                 fprintf(fkk, "Lock file for savefile '%s'\n", savefile);
1835
1836                 /* Close the lock file */
1837                 my_fclose(fkk);
1838         }
1839
1840 #endif
1841
1842
1843         if (!err)
1844         {
1845                 /* Open the savefile */
1846                 fd = fd_open(savefile, O_RDONLY);
1847
1848                 /* No file */
1849                 if (fd < 0) err = -1;
1850
1851                 /* Message (below) */
1852                 if (err) what = _("セーブファイルを開けません。", "Cannot open savefile");
1853         }
1854
1855         /* Process file */
1856         if (!err)
1857         {
1858
1859 #ifdef VERIFY_TIMESTAMP
1860                 /* Get the timestamp */
1861                 (void)fstat(fd, &statbuf);
1862 #endif
1863
1864                 /* Read the first four bytes */
1865                 if (fd_read(fd, (char*)(vvv), 4)) err = -1;
1866
1867                 /* What */
1868                 if (err) what = _("セーブファイルを読めません。", "Cannot read savefile");
1869                 (void)fd_close(fd);
1870         }
1871
1872         /* Process file */
1873         if (!err)
1874         {
1875
1876                 /* Extract version */
1877                 z_major = vvv[0];
1878                 z_minor = vvv[1];
1879                 z_patch = vvv[2];
1880                 sf_extra = vvv[3];
1881
1882                 Term_clear();
1883
1884                 /* Attempt to load */
1885                 err = rd_savefile_new();
1886
1887                 /* Message (below) */
1888                 if (err) what = _("セーブファイルを解析出来ません。", "Cannot parse savefile");
1889         }
1890
1891         /* Paranoia */
1892         if (!err)
1893         {
1894                 /* Invalid turn */
1895                 if (!turn) err = -1;
1896
1897                 /* Message (below) */
1898                 if (err) what = _("セーブファイルが壊れています", "Broken savefile");
1899         }
1900
1901 #ifdef VERIFY_TIMESTAMP
1902         /* Verify timestamp */
1903         if (!err && !arg_wizard)
1904         {
1905                 /* Hack -- Verify the timestamp */
1906                 if (sf_when > (statbuf.st_ctime + 100) ||
1907                     sf_when < (statbuf.st_ctime - 100))
1908                 {
1909                         what = _("無効なタイム・スタンプです", "Invalid timestamp");
1910
1911                         err = -1;
1912                 }
1913         }
1914 #endif
1915
1916
1917         if (!err)
1918         {
1919                 /* Give a conversion warning */
1920                 if ((FAKE_VER_MAJOR != z_major) ||
1921                     (FAKE_VER_MINOR != z_minor) ||
1922                     (FAKE_VER_PATCH != z_patch))
1923                 {
1924                         if (z_major == 2 && z_minor == 0 && z_patch == 6)
1925                         {
1926                                 msg_print(_("バージョン 2.0.* 用のセーブファイルを変換しました。", "Converted a 2.0.* savefile."));
1927                         }
1928                         else
1929                         {
1930                                 msg_format(_("バージョン %d.%d.%d 用のセーブ・ファイルを変換しました。", "Converted a %d.%d.%d savefile."),
1931                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1932                         }
1933                         msg_print(NULL);
1934                 }
1935
1936                 /* Player is dead */
1937                 if (p_ptr->is_dead)
1938                 {
1939                         /* Cheat death */
1940                         if (arg_wizard)
1941                         {
1942                                 /* A character was loaded */
1943                                 character_loaded = TRUE;
1944                                 return (TRUE);
1945                         }
1946
1947                         /* Player is no longer "dead" */
1948                         p_ptr->is_dead = FALSE;
1949
1950                         /* Count lives */
1951                         sf_lives++;
1952
1953                         return (TRUE);
1954                 }
1955
1956                 /* A character was loaded */
1957                 character_loaded = TRUE;
1958
1959                 {
1960                         u32b tmp = counts_read(2);
1961                         if (tmp > p_ptr->count)
1962                                 p_ptr->count = tmp;
1963                         if (counts_read(0) > playtime || counts_read(1) == playtime)
1964                                 counts_write(2, ++p_ptr->count);
1965                         counts_write(1, playtime);
1966                 }
1967
1968                 /* Success */
1969                 return (TRUE);
1970         }
1971
1972
1973 #ifdef VERIFY_SAVEFILE
1974
1975         /* Verify savefile usage */
1976         if (TRUE)
1977         {
1978                 char temp[1024];
1979
1980                 /* Extract name of lock file */
1981                 strcpy(temp, savefile);
1982                 strcat(temp, ".lok");
1983
1984                 /* Remove lock */
1985                 fd_kill(temp);
1986         }
1987
1988 #endif
1989
1990         msg_format(_("エラー(%s)がバージョン%d.%d.%d 用セーブファイル読み込み中に発生。", "Error (%s) reading %d.%d.%d savefile."),
1991                 what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
1992
1993         msg_print(NULL);
1994
1995         return (FALSE);
1996 }
1997
1998 /*!
1999  * @brief ファイルロック処理
2000  * @return なし
2001  */
2002 void remove_loc(void)
2003 {
2004 #ifdef VERIFY_SAVEFILE
2005         char temp[1024];
2006 #endif /* VERIFY_SAVEFILE */
2007
2008 #ifdef SET_UID
2009 # ifdef SECURE
2010
2011         /* Get "games" permissions */
2012         beGames();
2013
2014 # endif /* SECURE */
2015 #endif /* SET_UID */
2016
2017 #ifdef VERIFY_SAVEFILE
2018
2019         /* Lock on savefile */
2020         strcpy(temp, savefile);
2021         strcat(temp, ".lok");
2022
2023         /* Remove lock file */
2024         fd_kill(temp);
2025
2026 #endif /* VERIFY_SAVEFILE */
2027
2028 #ifdef SET_UID
2029 # ifdef SECURE
2030
2031         /* Drop "games" permissions */
2032         bePlayer();
2033
2034 # endif /* SECURE */
2035 #endif /* SET_UID */
2036
2037 }
2038
2039
2040 /*!
2041  * @brief ゲームプレイ中のフロア一時保存出力処理サブルーチン / Actually write a temporal saved floor file
2042  * @param sf_ptr 保存フロア参照ポインタ
2043  * @return なし
2044  */
2045 static bool save_floor_aux(saved_floor_type *sf_ptr)
2046 {
2047         byte tmp8u;
2048
2049         /* Compact the objects */
2050         compact_objects(0);
2051         /* Compact the monsters */
2052         compact_monsters(0);
2053
2054
2055         /*** Actually write the file ***/
2056
2057         /* Initial value of xor_byte */
2058         tmp8u = (byte)randint0(256);
2059         xor_byte = 0;
2060         wr_byte(tmp8u);
2061
2062
2063         /* Reset the checksum */
2064         v_stamp = 0L;
2065         x_stamp = 0L;
2066
2067         /* Write the sign of this process */
2068         wr_u32b(saved_floor_file_sign);
2069
2070         /* Dump the dungeon floor */
2071         wr_saved_floor(sf_ptr);
2072
2073
2074         /* Write the "value check-sum" */
2075         wr_u32b(v_stamp);
2076
2077         /* Write the "encoded checksum" */
2078         wr_u32b(x_stamp);
2079
2080
2081         /* Error in save */
2082         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
2083
2084         /* Successful save */
2085         return TRUE;
2086 }
2087
2088
2089 /*!
2090  * @brief ゲームプレイ中のフロア一時保存出力処理メインルーチン / Attempt to save the temporally saved-floor data
2091  * @param sf_ptr 保存フロア参照ポインタ
2092  * @param mode 保存オプション
2093  * @return なし
2094  */
2095 bool save_floor(saved_floor_type *sf_ptr, BIT_FLAGS mode)
2096 {
2097         FILE *old_fff = NULL;
2098         byte old_xor_byte = 0;
2099         u32b old_v_stamp = 0;
2100         u32b old_x_stamp = 0;
2101
2102         char floor_savefile[1024];
2103         int fd = -1;
2104         bool ok = FALSE;
2105
2106         if (!(mode & SLF_SECOND))
2107         {
2108 #ifdef SET_UID
2109 # ifdef SECURE
2110                 /* Get "games" permissions */
2111                 beGames();
2112 # endif
2113 #endif
2114         }
2115
2116         /* We have one file already opened */
2117         else
2118         {
2119                 /* Backup original values */
2120                 old_fff = fff;
2121                 old_xor_byte = xor_byte;
2122                 old_v_stamp = v_stamp;
2123                 old_x_stamp = x_stamp;
2124         }
2125
2126         /* New savefile */
2127         sprintf(floor_savefile, "%s.F%02d", savefile, (int)sf_ptr->savefile_id);
2128
2129         /* Grab permissions */
2130         safe_setuid_grab();
2131
2132         /* Remove it */
2133         fd_kill(floor_savefile);
2134
2135         /* Drop permissions */
2136         safe_setuid_drop();
2137
2138
2139         /* Attempt to save the player */
2140
2141         /* No file yet */
2142         fff = NULL;
2143
2144         /* File type is "SAVE" */
2145         FILE_TYPE(FILE_TYPE_SAVE);
2146
2147         /* Grab permissions */
2148         safe_setuid_grab();
2149
2150         /* Create the savefile */
2151         fd = fd_make(floor_savefile, 0644);
2152
2153         /* Drop permissions */
2154         safe_setuid_drop();
2155
2156         /* File is okay */
2157         if (fd >= 0)
2158         {
2159                 /* Close the "fd" */
2160                 (void)fd_close(fd);
2161
2162                 /* Grab permissions */
2163                 safe_setuid_grab();
2164
2165                 /* Open the savefile */
2166                 fff = my_fopen(floor_savefile, "wb");
2167
2168                 /* Drop permissions */
2169                 safe_setuid_drop();
2170
2171                 /* Successful open */
2172                 if (fff)
2173                 {
2174                         /* Write the savefile */
2175                         if (save_floor_aux(sf_ptr)) ok = TRUE;
2176
2177                         /* Attempt to close it */
2178                         if (my_fclose(fff)) ok = FALSE;
2179                 }
2180
2181                 /* Remove "broken" files */
2182                 if (!ok)
2183                 {
2184                         /* Grab permissions */
2185                         safe_setuid_grab();
2186
2187                         (void)fd_kill(floor_savefile);
2188
2189                         /* Drop permissions */
2190                         safe_setuid_drop();
2191                 }
2192         }
2193
2194         if (!(mode & SLF_SECOND))
2195         {
2196 #ifdef SET_UID
2197 # ifdef SECURE
2198                 /* Drop "games" permissions */
2199                 bePlayer();
2200 # endif
2201 #endif
2202         }
2203
2204         /* We have one file already opened */
2205         else
2206         {
2207                 /* Restore original values */
2208                 fff = old_fff;
2209                 xor_byte = old_xor_byte;
2210                 v_stamp = old_v_stamp;
2211                 x_stamp = old_x_stamp;
2212         }
2213
2214         /* Return the result */
2215         return ok;
2216 }