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