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(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(previous_char.prace);
 560         wr_byte(previous_char.pclass);
 561         wr_byte(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 < 6; i++) wr_s16b(previous_char.stat_max[i]);
 572         for (i = 0; i < 6; 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
 603         wr_string(p_ptr->died_from);
 604
 605         wr_string(p_ptr->last_message ? p_ptr->last_message : "");
 606
 607         save_quick_start();
 608
 609         for (i = 0; i < 4; i++)
 610         {
 611                 wr_string(p_ptr->history[i]);
 612         }
 613
 614         /* Race/Class/Gender/Spells */
 615         wr_byte(p_ptr->prace);
 616         wr_byte(p_ptr->pclass);
 617         wr_byte(p_ptr->pseikaku);
 618         wr_byte(p_ptr->psex);
 619         wr_byte((byte_hack)p_ptr->realm1);
 620         wr_byte((byte_hack)p_ptr->realm2);
 621         wr_byte(0);
 622
 623         wr_byte((byte)p_ptr->hitdie);
 624         wr_u16b(p_ptr->expfact);
 625
 626         wr_s16b(p_ptr->age);
 627         wr_s16b(p_ptr->ht);
 628         wr_s16b(p_ptr->wt);
 629
 630         /* Dump the stats (maximum and current) */
 631         for (i = 0; i < 6; ++i) wr_s16b(p_ptr->stat_max[i]);
 632         for (i = 0; i < 6; ++i) wr_s16b(p_ptr->stat_max_max[i]);
 633         for (i = 0; i < 6; ++i) wr_s16b(p_ptr->stat_cur[i]);
 634
 635         /* Ignore the transient stats */
 636         for (i = 0; i < 12; ++i) wr_s16b(0);
 637
 638         wr_u32b(p_ptr->au);
 639
 640         wr_u32b(p_ptr->max_exp);
 641         wr_u32b(p_ptr->max_max_exp);
 642         wr_u32b(p_ptr->exp);
 643         wr_u32b(p_ptr->exp_frac);
 644         wr_s16b(p_ptr->lev);
 645
 646         for (i = 0; i < 64; i++) wr_s16b(p_ptr->spell_exp[i]);
 647         for (i = 0; i < 5; i++) for (j = 0; j < 64; j++) wr_s16b(p_ptr->weapon_exp[i][j]);
 648         for (i = 0; i < GINOU_MAX; i++) wr_s16b(p_ptr->skill_exp[i]);
 649         for (i = 0; i < 108; i++) wr_s32b(p_ptr->magic_num1[i]);
 650         for (i = 0; i < 108; i++) wr_byte(p_ptr->magic_num2[i]);
 651
 652         wr_byte(p_ptr->start_race);
 653         wr_s32b(p_ptr->old_race1);
 654         wr_s32b(p_ptr->old_race2);
 655         wr_s16b(p_ptr->old_realm);
 656
 657         for (i = 0; i < MAX_MANE; i++)
 658         {
 659                 wr_s16b((s16b)p_ptr->mane_spell[i]);
 660                 wr_s16b((s16b)p_ptr->mane_dam[i]);
 661         }
 662         wr_s16b(p_ptr->mane_num);
 663
 664         for (i = 0; i < MAX_KUBI; i++)
 665         {
 666                 wr_s16b(kubi_r_idx[i]);
 667         }
 668
 669         for (i = 0; i < 4; i++)
 670         {
 671                 wr_s16b(battle_mon[i]);
 672                 wr_u32b(mon_odds[i]);
 673         }
 674
 675         wr_s16b(p_ptr->town_num); /* -KMW- */
 676
 677         /* Write arena and rewards information -KMW- */
 678         wr_s16b(p_ptr->arena_number);
 679         wr_s16b(p_ptr->inside_arena);
 680         wr_s16b(p_ptr->inside_quest);
 681         wr_s16b(p_ptr->inside_battle);
 682         wr_byte(p_ptr->exit_bldg);
 683         wr_byte(0); /* Unused */
 684
 685         wr_s16b((s16b)p_ptr->oldpx);
 686         wr_s16b((s16b)p_ptr->oldpy);
 687
 688         /* Was number of p_ptr->rewards[] */
 689         wr_s16b(0);
 690
 691         wr_s32b(p_ptr->mhp);
 692         wr_s32b(p_ptr->chp);
 693         wr_u32b(p_ptr->chp_frac);
 694
 695         wr_s32b(p_ptr->msp);
 696         wr_s32b(p_ptr->csp);
 697         wr_u32b(p_ptr->csp_frac);
 698
 699         /* Max Player and Dungeon Levels */
 700         wr_s16b(p_ptr->max_plv);
 701         tmp8u = (byte)max_d_idx;
 702         wr_byte(tmp8u);
 703         for (i = 0; i < tmp8u; i++)
 704                 wr_s16b((s16b)max_dlv[i]);
 705
 706         /* More info */
 707         wr_s16b(0);
 708         wr_s16b(0);
 709         wr_s16b(0);
 710         wr_s16b(0);
 711         wr_s16b(p_ptr->sc);
 712         wr_s16b(p_ptr->concent);
 713
 714         wr_s16b(0);             /* old "rest" */
 715         wr_s16b(p_ptr->blind);
 716         wr_s16b(p_ptr->paralyzed);
 717         wr_s16b(p_ptr->confused);
 718         wr_s16b(p_ptr->food);
 719         wr_s16b(0);     /* old "food_digested" */
 720         wr_s16b(0);     /* old "protection" */
 721         wr_s16b(p_ptr->energy_need);
 722         wr_s16b(p_ptr->enchant_energy_need);
 723         wr_s16b(p_ptr->fast);
 724         wr_s16b(p_ptr->slow);
 725         wr_s16b(p_ptr->afraid);
 726         wr_s16b(p_ptr->cut);
 727         wr_s16b(p_ptr->stun);
 728         wr_s16b(p_ptr->poisoned);
 729         wr_s16b(p_ptr->image);
 730         wr_s16b(p_ptr->protevil);
 731         wr_s16b(p_ptr->invuln);
 732         wr_s16b(p_ptr->ult_res);
 733         wr_s16b(p_ptr->hero);
 734         wr_s16b(p_ptr->shero);
 735         wr_s16b(p_ptr->shield);
 736         wr_s16b(p_ptr->blessed);
 737         wr_s16b(p_ptr->tim_invis);
 738         wr_s16b(p_ptr->word_recall);
 739         wr_s16b(p_ptr->recall_dungeon);
 740         wr_s16b(p_ptr->alter_reality);
 741         wr_s16b(p_ptr->see_infra);
 742         wr_s16b(p_ptr->tim_infra);
 743         wr_s16b(p_ptr->oppose_fire);
 744         wr_s16b(p_ptr->oppose_cold);
 745         wr_s16b(p_ptr->oppose_acid);
 746         wr_s16b(p_ptr->oppose_elec);
 747         wr_s16b(p_ptr->oppose_pois);
 748         wr_s16b(p_ptr->tsuyoshi);
 749         wr_s16b(p_ptr->tim_esp);
 750         wr_s16b(p_ptr->wraith_form);
 751         wr_s16b(p_ptr->resist_magic);
 752         wr_s16b(p_ptr->tim_regen);
 753         wr_s16b(p_ptr->kabenuke);
 754         wr_s16b(p_ptr->tim_stealth);
 755         wr_s16b(p_ptr->tim_levitation);
 756         wr_s16b(p_ptr->tim_sh_touki);
 757         wr_s16b(p_ptr->lightspeed);
 758         wr_s16b(p_ptr->tsubureru);
 759         wr_s16b(p_ptr->magicdef);
 760         wr_s16b(p_ptr->tim_res_nether);
 761         wr_s16b(p_ptr->tim_res_time);
 762         wr_byte((byte)p_ptr->mimic_form);
 763         wr_s16b(p_ptr->tim_mimic);
 764         wr_s16b(p_ptr->tim_sh_fire);
 765         wr_s16b(p_ptr->tim_sh_holy);
 766         wr_s16b(p_ptr->tim_eyeeye);
 767
 768         /* by henkma */
 769         wr_s16b(p_ptr->tim_reflect);
 770         wr_s16b(p_ptr->multishadow);
 771         wr_s16b(p_ptr->dustrobe);
 772
 773         wr_s16b(p_ptr->chaos_patron);
 774         wr_u32b(p_ptr->muta1);
 775         wr_u32b(p_ptr->muta2);
 776         wr_u32b(p_ptr->muta3);
 777
 778         for (i = 0; i<8; i++)
 779                 wr_s16b(p_ptr->virtues[i]);
 780         for (i = 0; i<8; i++)
 781                 wr_s16b(p_ptr->vir_types[i]);
 782
 783         wr_s16b(p_ptr->ele_attack);
 784         wr_u32b(p_ptr->special_attack);
 785         wr_s16b(p_ptr->ele_immune);
 786         wr_u32b(p_ptr->special_defense);
 787         wr_byte(p_ptr->knowledge);
 788         wr_byte(p_ptr->autopick_autoregister);
 789         wr_byte(0);
 790         wr_byte((byte_hack)p_ptr->action);
 791         wr_byte(0);
 792         wr_byte(preserve_mode);
 793         wr_byte(p_ptr->wait_report_score);
 794
 795         /* Future use */
 796         for (i = 0; i < 12; i++) wr_u32b(0L);
 797
 798         /* Ignore some flags */
 799         wr_u32b(0L);
 800         wr_u32b(0L);
 801         wr_u32b(0L);
 802
 803
 804         /* Write the "object seeds" */
 805         wr_u32b(seed_flavor);
 806         wr_u32b(seed_town);
 807
 808
 809         /* Special stuff */
 810         wr_u16b(p_ptr->panic_save);
 811         wr_u16b(p_ptr->total_winner);
 812         wr_u16b(p_ptr->noscore);
 813
 814
 815         /* Write death */
 816         wr_byte(p_ptr->is_dead);
 817
 818         /* Write feeling */
 819         wr_byte(p_ptr->feeling);
 820
 821         /* Turn when level began */
 822         wr_s32b(old_turn);
 823
 824         /* Turn of last "feeling" */
 825         wr_s32b(p_ptr->feeling_turn);
 826
 827         /* Current turn */
 828         wr_s32b(turn);
 829
 830         wr_s32b(dungeon_turn);
 831
 832         wr_s32b(old_battle);
 833
 834         wr_s16b(today_mon);
 835         wr_s16b(p_ptr->today_mon);
 836         wr_s16b(p_ptr->riding);
 837
 838         /* Current floor_id */
 839         wr_s16b(p_ptr->floor_id);
 840
 841         /* Save temporary preserved pets (obsolated) */
 842         wr_s16b(0);
 843
 844         wr_u32b(playtime);
 845
 846         wr_s32b(p_ptr->visit);
 847
 848         wr_u32b(p_ptr->count);
 849 }
 850
 851
 852 /*!
 853  * @brief フロア保存時のcave情報テンプレートをソートするための比較処理
 854  * @param u caveテンプレートの参照ポインタ
 855  * @param v 未使用
 856  * @param a スワップするモンスター種族のID1
 857  * @param b スワップするモンスター種族のID2
 858  * @return aの方が大きければtrue
 859  */
 860 static bool ang_sort_comp_cave_temp(vptr u, vptr v, int a, int b)
 861 {
 862         cave_template_type *who = (cave_template_type *)(u);
 863
 864         u16b o1 = who[a].occurrence;
 865         u16b o2 = who[b].occurrence;
 866
 867         /* Unused */
 868         (void)v;
 869
 870         return o2 <= o1;
 871 }
 872
 873
 874 /*!
 875  * @brief フロア保存時のcave情報テンプレートをソートするためのスワップ処理 / Sorting hook -- Swap function
 876  * @param u caveテンプレートの参照ポインタ
 877  * @param v 未使用
 878  * @param a スワップするモンスター種族のID1
 879  * @param b スワップするモンスター種族のID2
 880  * @return なし
 881  */
 882 static void ang_sort_swap_cave_temp(vptr u, vptr v, int a, int b)
 883 {
 884         cave_template_type *who = (cave_template_type *)(u);
 885
 886         cave_template_type holder;
 887
 888         /* Unused */
 889         (void)v;
 890
 891         /* Swap */
 892         holder = who[a];
 893         who[a] = who[b];
 894         who[b] = holder;
 895 }
 896
 897
 898 /*!
 899  * @brief 保存フロアの書き込み / Actually write a saved floor data using effectively compressed format.
 900  * @param sf_ptr 保存したいフロアの参照ポインタ
 901  * @return なし
 902  */
 903 static void wr_saved_floor(saved_floor_type *sf_ptr)
 904 {
 905         cave_template_type *templates;
 906         u16b max_num_temp;
 907         u16b num_temp = 0;
 908         int dummy_why;
 909
 910         int i, y, x;
 911
 912         u16b tmp16u;
 913
 914         byte count;
 915         u16b prev_u16b;
 916
 917
 918         /*** Basic info ***/
 919
 920         /* Dungeon floor specific info follows */
 921
 922         if (!sf_ptr)
 923         {
 924                 /*** Not a saved floor ***/
 925
 926                 wr_s16b((s16b)dun_level);
 927         }
 928         else
 929         {
 930                 /*** The saved floor ***/
 931
 932                 wr_s16b(sf_ptr->floor_id);
 933                 wr_byte((byte_hack)sf_ptr->savefile_id);
 934                 wr_s16b((s16b)sf_ptr->dun_level);
 935                 wr_s32b(sf_ptr->last_visit);
 936                 wr_u32b(sf_ptr->visit_mark);
 937                 wr_s16b(sf_ptr->upper_floor_id);
 938                 wr_s16b(sf_ptr->lower_floor_id);
 939         }
 940
 941         wr_u16b((u16b)base_level);
 942         wr_u16b((s16b)num_repro);
 943         wr_u16b((u16b)p_ptr->y);
 944         wr_u16b((u16b)p_ptr->x);
 945         wr_u16b((u16b)cur_hgt);
 946         wr_u16b((u16b)cur_wid);
 947         wr_byte(p_ptr->feeling);
 948
 949
 950
 951         /*********** Make template for cave_type **********/
 952
 953         /*
 954          * Usually number of templates are fewer than 255.  Even if
 955          * more than 254 are exist, the occurrence of each template
 956          * with larger ID is very small when we sort templates by
 957          * occurrence.  So we will use two (or more) bytes for
 958          * templete ID larger than 254.
 959          *
 960          * Ex: 256 will be "0xff" "0x01".
 961          *     515 will be "0xff" "0xff" "0x03"
 962          */
 963
 964         /* Fake max number */
 965         max_num_temp = 255;
 966
 967         /* Allocate the "template" array */
 968         C_MAKE(templates, max_num_temp, cave_template_type);
 969
 970         /* Extract template array */
 971         for (y = 0; y < cur_hgt; y++)
 972         {
 973                 for (x = 0; x < cur_wid; x++)
 974                 {
 975                         cave_type *c_ptr = &cave[y][x];
 976
 977                         for (i = 0; i < num_temp; i++)
 978                         {
 979                                 if (templates[i].info == c_ptr->info &&
 980                                     templates[i].feat == c_ptr->feat &&
 981                                     templates[i].mimic == c_ptr->mimic &&
 982                                     templates[i].special == c_ptr->special)
 983                                 {
 984                                         /* Same terrain is exist */
 985                                         templates[i].occurrence++;
 986                                         break;
 987                                 }
 988                         }
 989
 990                         /* Are there same one? */
 991                         if (i < num_temp) continue;
 992
 993                         /* If the max_num_temp is too small, increase it. */
 994                         if (num_temp >= max_num_temp)
 995                         {
 996                                 cave_template_type *old_template = templates;
 997
 998                                 /* Re-allocate the "template" array */
 999                                 C_MAKE(templates, max_num_temp + 255, cave_template_type);
1000                                 (void)C_COPY(templates, old_template, max_num_temp, cave_template_type);
1001                                 C_KILL(old_template, max_num_temp, cave_template_type);
1002                                 max_num_temp += 255;
1003                         }
1004
1005                         /* Add new template */
1006                         templates[num_temp].info = c_ptr->info;
1007                         templates[num_temp].feat = c_ptr->feat;
1008                         templates[num_temp].mimic = c_ptr->mimic;
1009                         templates[num_temp].special = c_ptr->special;
1010                         templates[num_temp].occurrence = 1;
1011
1012                         /* Increase number of template */
1013                         num_temp++;
1014                 }
1015         }
1016
1017         /* Select the sort method */
1018         ang_sort_comp = ang_sort_comp_cave_temp;
1019         ang_sort_swap = ang_sort_swap_cave_temp;
1020
1021         /* Sort by occurrence */
1022         ang_sort(templates, &dummy_why, num_temp);
1023
1024
1025         /*** Dump templates ***/
1026
1027         /* Total templates */
1028         wr_u16b(num_temp);
1029
1030         /* Dump the templates */
1031         for (i = 0; i < num_temp; i++)
1032         {
1033                 cave_template_type *ct_ptr = &templates[i];
1034
1035                 /* Dump it */
1036                 wr_u16b((u16b)ct_ptr->info);
1037                 wr_s16b(ct_ptr->feat);
1038                 wr_s16b(ct_ptr->mimic);
1039                 wr_s16b(ct_ptr->special);
1040         }
1041
1042
1043
1044         /*** "Run-Length-Encoding" of cave ***/
1045
1046         /* Note that this will induce two wasted bytes */
1047         count = 0;
1048         prev_u16b = 0;
1049
1050         /* Dump the cave */
1051         for (y = 0; y < cur_hgt; y++)
1052         {
1053                 for (x = 0; x < cur_wid; x++)
1054                 {
1055                         cave_type *c_ptr = &cave[y][x];
1056
1057                         for (i = 0; i < num_temp; i++)
1058                         {
1059                                 if (templates[i].info == c_ptr->info &&
1060                                     templates[i].feat == c_ptr->feat &&
1061                                     templates[i].mimic == c_ptr->mimic &&
1062                                     templates[i].special == c_ptr->special)
1063                                         break;
1064                         }
1065
1066                         /* Extract an ID */
1067                         tmp16u = (u16b)i;
1068
1069                         /* If the run is broken, or too full, flush it */
1070                         if ((tmp16u != prev_u16b) || (count == MAX_UCHAR))
1071                         {
1072                                 wr_byte((byte)count);
1073
1074                                 while (prev_u16b >= MAX_UCHAR)
1075                                 {
1076                                         /* Mark as actual data is larger than 254 */
1077                                         wr_byte(MAX_UCHAR);
1078                                         prev_u16b -= MAX_UCHAR;
1079                                 }
1080
1081                                 wr_byte((byte)prev_u16b);
1082                                 prev_u16b = tmp16u;
1083                                 count = 1;
1084                         }
1085
1086                         /* Continue the run */
1087                         else
1088                         {
1089                                 count++;
1090                         }
1091                 }
1092         }
1093
1094         /* Flush the data (if any) */
1095         if (count)
1096         {
1097                 wr_byte((byte)count);
1098
1099                 while (prev_u16b >= MAX_UCHAR)
1100                 {
1101                         /* Mark as actual data is larger than 254 */
1102                         wr_byte(MAX_UCHAR);
1103                         prev_u16b -= MAX_UCHAR;
1104                 }
1105                 wr_byte((byte)prev_u16b);
1106         }
1107
1108
1109         /* Free the "template" array */
1110         C_KILL(templates, max_num_temp, cave_template_type);
1111
1112
1113         /*** Dump objects ***/
1114
1115         /* Total objects */
1116         wr_u16b(o_max);
1117
1118         /* Dump the objects */
1119         for (i = 1; i < o_max; i++)
1120         {
1121                 object_type *o_ptr = &o_list[i];
1122
1123                 /* Dump it */
1124                 wr_item(o_ptr);
1125         }
1126
1127
1128         /*** Dump the monsters ***/
1129
1130         /* Total monsters */
1131         wr_u16b(m_max);
1132
1133         /* Dump the monsters */
1134         for (i = 1; i < m_max; i++)
1135         {
1136                 monster_type *m_ptr = &m_list[i];
1137
1138                 /* Dump it */
1139                 wr_monster(m_ptr);
1140         }
1141 }
1142
1143
1144 /*!
1145  * @brief 現在フロアの書き込み /
1146  * Write the current dungeon (new method)
1147  * @return なし
1148  */
1149 static bool wr_dungeon(void)
1150 {
1151         saved_floor_type *cur_sf_ptr;
1152         int i;
1153
1154         /* Forget the lite */
1155         forget_lite();
1156
1157         /* Forget the view */
1158         forget_view();
1159
1160         /* Forget the view */
1161         clear_mon_lite();
1162
1163         /* Update lite/view */
1164         p_ptr->update |= (PU_VIEW | PU_LITE | PU_MON_LITE);
1165
1166         /* Update monsters */
1167         p_ptr->update |= (PU_MONSTERS | PU_DISTANCE | PU_FLOW);
1168
1169
1170         /*** Meta info ***/
1171
1172         /* Number of floor_id used from birth */
1173         wr_s16b(max_floor_id);
1174
1175         /* Current dungeon type */
1176         wr_byte((byte_hack)dungeon_type);
1177
1178
1179         /*** No saved floor (On the surface etc.) ***/
1180         if (!p_ptr->floor_id)
1181         {
1182                 /* No array elements */
1183                 wr_byte(0);
1184
1185                 /* Write the current floor data */
1186                 wr_saved_floor(NULL);
1187
1188                 /* Success */
1189                 return TRUE;
1190         }
1191
1192
1193         /*** In the dungeon ***/
1194
1195         /* Number of array elements */
1196         wr_byte(MAX_SAVED_FLOORS);
1197
1198         /* Write the saved_floors array */
1199         for (i = 0; i < MAX_SAVED_FLOORS; i++)
1200         {
1201                 saved_floor_type *sf_ptr = &saved_floors[i];
1202
1203                 wr_s16b(sf_ptr->floor_id);
1204                 wr_byte((byte_hack)sf_ptr->savefile_id);
1205                 wr_s16b((s16b)sf_ptr->dun_level);
1206                 wr_s32b(sf_ptr->last_visit);
1207                 wr_u32b(sf_ptr->visit_mark);
1208                 wr_s16b(sf_ptr->upper_floor_id);
1209                 wr_s16b(sf_ptr->lower_floor_id);
1210         }
1211
1212         /* Extract pointer to current floor */
1213         cur_sf_ptr = get_sf_ptr(p_ptr->floor_id);
1214
1215         /* Save current floor to temporal file */
1216         if (!save_floor(cur_sf_ptr, (SLF_SECOND))) return FALSE;
1217
1218         /* Move data in temporal files to the savefile */
1219         for (i = 0; i < MAX_SAVED_FLOORS; i++)
1220         {
1221                 saved_floor_type *sf_ptr = &saved_floors[i];
1222
1223                 /* Unused element */
1224                 if (!sf_ptr->floor_id) continue;
1225
1226                 /* Load temporal saved floor file */
1227                 if (load_floor(sf_ptr, (SLF_SECOND | SLF_NO_KILL)))
1228                 {
1229                         /* Mark success */
1230                         wr_byte(0);
1231
1232                         /* Write saved floor data to the save file */
1233                         wr_saved_floor(sf_ptr);
1234                 }
1235                 else
1236                 {
1237                         /* Mark failure */
1238                         wr_byte(1);
1239                 }
1240         }
1241
1242         /* Restore current floor */
1243         if (!load_floor(cur_sf_ptr, (SLF_SECOND))) return FALSE;
1244
1245         /* Success */
1246         return TRUE;
1247 }
1248
1249
1250 /*!
1251  * @brief セーブデータの書き込み /
1252  * Actually write a save-file
1253  * @return 成功すればtrue
1254  */
1255 static bool wr_savefile_new(void)
1256 {
1257         int        i, j;
1258
1259         u32b              now;
1260
1261         byte            tmp8u;
1262         u16b            tmp16u;
1263         u32b            tmp32u;
1264
1265         MONRACE_IDX r_idx;
1266         KIND_OBJECT_IDX k_idx;
1267
1268         /* Compact the objects */
1269         compact_objects(0);
1270         /* Compact the monsters */
1271         compact_monsters(0);
1272
1273         /* Guess at the current time */
1274         now = (u32b)time((time_t *)0);
1275
1276
1277         /* Note the operating system */
1278         sf_system = 0L;
1279
1280         /* Note when the file was saved */
1281         sf_when = now;
1282
1283         /* Note the number of saves */
1284         sf_saves++;
1285
1286
1287         /*** Actually write the file ***/
1288
1289         /* Dump the file header */
1290         xor_byte = 0;
1291         wr_byte(FAKE_VER_MAJOR);
1292         xor_byte = 0;
1293         wr_byte(FAKE_VER_MINOR);
1294         xor_byte = 0;
1295         wr_byte(FAKE_VER_PATCH);
1296         xor_byte = 0;
1297
1298         /* Initial value of xor_byte */
1299         tmp8u = (byte)Rand_external(256);
1300         wr_byte(tmp8u);
1301
1302
1303         /* Reset the checksum */
1304         v_stamp = 0L;
1305         x_stamp = 0L;
1306
1307         /* Write the savefile version for Hengband 1.1.1 and later */
1308         wr_byte(H_VER_EXTRA);
1309         wr_byte(H_VER_PATCH);
1310         wr_byte(H_VER_MINOR);
1311         wr_byte(H_VER_MAJOR);
1312
1313         /* Operating system */
1314         wr_u32b(sf_system);
1315
1316
1317         /* Time file last saved */
1318         wr_u32b(sf_when);
1319
1320         /* Number of past lives */
1321         wr_u16b(sf_lives);
1322
1323         /* Number of times saved */
1324         wr_u16b(sf_saves);
1325
1326
1327         /* Space */
1328         wr_u32b(0L);
1329         wr_u16b(0);
1330         wr_byte(0);
1331
1332 #ifdef JP
1333 # ifdef EUC
1334         /* EUC kanji code */
1335         wr_byte(2);
1336 # endif
1337 # ifdef SJIS
1338         /* SJIS kanji code */
1339         wr_byte(3);
1340 # endif
1341 #else
1342         /* ASCII */
1343         wr_byte(1);
1344 #endif
1345
1346         /* Write the RNG state */
1347         wr_randomizer();
1348
1349
1350         /* Write the boolean "options" */
1351         wr_options();
1352
1353
1354         /* Dump the number of "messages" */
1355         tmp32u = message_num();
1356         if (compress_savefile && (tmp32u > 40)) tmp32u = 40;
1357         wr_u32b(tmp32u);
1358
1359         /* Dump the messages (oldest first!) */
1360         for (i = tmp32u - 1; i >= 0; i--)
1361         {
1362                 wr_string(message_str((s16b)i));
1363         }
1364
1365         /* Dump the monster lore */
1366         tmp16u = max_r_idx;
1367         wr_u16b(tmp16u);
1368         for (r_idx = 0; r_idx < tmp16u; r_idx++) wr_lore(r_idx);
1369
1370         /* Dump the object memory */
1371         tmp16u = max_k_idx;
1372         wr_u16b(tmp16u);
1373         for (k_idx = 0; k_idx < tmp16u; k_idx++) wr_xtra(k_idx);
1374
1375         /* Dump the towns */
1376         tmp16u = max_towns;
1377         wr_u16b(tmp16u);
1378
1379         /* Dump the quests */
1380         tmp16u = max_q_idx;
1381         wr_u16b(tmp16u);
1382
1383         /* Dump the quests */
1384         tmp8u = MAX_RANDOM_QUEST-MIN_RANDOM_QUEST;
1385         wr_byte(tmp8u);
1386
1387         for (i = 0; i < max_q_idx; i++)
1388         {
1389                 quest_type* const q_ptr = &quest[i];
1390
1391                 /* Save status for every quest */
1392                 wr_s16b(q_ptr->status);
1393
1394                 /* And the dungeon level too */
1395                 /* (prevents problems with multi-level quests) */
1396                 wr_s16b((s16b)q_ptr->level);
1397
1398                 wr_byte((byte_hack)q_ptr->complev);
1399                 wr_u32b(q_ptr->comptime);
1400
1401                 /* Save quest status if quest is running */
1402                 if (q_ptr->status == QUEST_STATUS_TAKEN || q_ptr->status == QUEST_STATUS_COMPLETED || !is_fixed_quest_idx(i))
1403                 {
1404                         wr_s16b((s16b)q_ptr->cur_num);
1405                         wr_s16b((s16b)q_ptr->max_num);
1406                         wr_s16b(q_ptr->type);
1407                         wr_s16b(q_ptr->r_idx);
1408                         wr_s16b(q_ptr->k_idx);
1409                         wr_byte((byte_hack)q_ptr->flags);
1410                         wr_byte((byte_hack)q_ptr->dungeon);
1411                 }
1412         }
1413
1414         /* Dump the position in the wilderness */
1415         wr_s32b(p_ptr->wilderness_x);
1416         wr_s32b(p_ptr->wilderness_y);
1417
1418         wr_byte(p_ptr->wild_mode);
1419         wr_byte(ambush_flag);
1420
1421         wr_s32b(max_wild_x);
1422         wr_s32b(max_wild_y);
1423
1424         /* Dump the wilderness seeds */
1425         for (i = 0; i < max_wild_x; i++)
1426         {
1427                 for (j = 0; j < max_wild_y; j++)
1428                 {
1429                         wr_u32b(wilderness[j][i].seed);
1430                 }
1431         }
1432
1433         /* Hack -- Dump the artifacts */
1434         tmp16u = max_a_idx;
1435         wr_u16b(tmp16u);
1436         for (i = 0; i < tmp16u; i++)
1437         {
1438                 artifact_type *a_ptr = &a_info[i];
1439                 wr_byte(a_ptr->cur_num);
1440                 wr_s16b(a_ptr->floor_id);
1441         }
1442
1443
1444
1445         /* Write the "extra" information */
1446         wr_extra();
1447
1448         /* Dump the "player hp" entries */
1449         tmp16u = PY_MAX_LEVEL;
1450         wr_u16b(tmp16u);
1451         for (i = 0; i < tmp16u; i++)
1452         {
1453                 wr_s16b((s16b)p_ptr->player_hp[i]);
1454         }
1455
1456
1457         /* Write spell data */
1458         wr_u32b(p_ptr->spell_learned1);
1459         wr_u32b(p_ptr->spell_learned2);
1460         wr_u32b(p_ptr->spell_worked1);
1461         wr_u32b(p_ptr->spell_worked2);
1462         wr_u32b(p_ptr->spell_forgotten1);
1463         wr_u32b(p_ptr->spell_forgotten2);
1464
1465         wr_s16b(p_ptr->learned_spells);
1466         wr_s16b(p_ptr->add_spells);
1467
1468         /* Dump the ordered spells */
1469         for (i = 0; i < 64; i++)
1470         {
1471                 wr_byte((byte_hack)p_ptr->spell_order[i]);
1472         }
1473
1474
1475         /* Write the inventory */
1476         for (i = 0; i < INVEN_TOTAL; i++)
1477         {
1478                 object_type *o_ptr = &inventory[i];
1479
1480                 /* Skip non-objects */
1481                 if (!o_ptr->k_idx) continue;
1482
1483                 /* Dump index */
1484                 wr_u16b((u16b)i);
1485
1486                 /* Dump object */
1487                 wr_item(o_ptr);
1488         }
1489
1490         /* Add a sentinel */
1491         wr_u16b(0xFFFF);
1492
1493         /* Note the towns */
1494         tmp16u = max_towns;
1495         wr_u16b(tmp16u);
1496
1497         /* Note the stores */
1498         tmp16u = MAX_STORES;
1499         wr_u16b(tmp16u);
1500
1501         /* Dump the stores of all towns */
1502         for (i = 1; i < max_towns; i++)
1503         {
1504                 for (j = 0; j < MAX_STORES; j++)
1505                 {
1506                         wr_store(&town[i].store[j]);
1507                 }
1508         }
1509
1510         /* Write the pet command settings */
1511         wr_s16b(p_ptr->pet_follow_distance);
1512         wr_s16b(p_ptr->pet_extra_flags);
1513
1514         /* Write screen dump for sending score */
1515         if (screen_dump && (p_ptr->wait_report_score || !p_ptr->is_dead))
1516         {
1517                 wr_string(screen_dump);
1518         }
1519         else
1520         {
1521                 wr_string("");
1522         }
1523
1524         /* Player is not dead, write the dungeon */
1525         if (!p_ptr->is_dead)
1526         {
1527                 /* Dump the dungeon */
1528                 if (!wr_dungeon()) return FALSE;
1529
1530                 /* Dump the ghost */
1531                 wr_ghost();
1532
1533                 /* No scripts */
1534                 wr_s32b(0);
1535         }
1536
1537
1538         /* Write the "value check-sum" */
1539         wr_u32b(v_stamp);
1540
1541         /* Write the "encoded checksum" */
1542         wr_u32b(x_stamp);
1543
1544
1545         /* Error in save */
1546         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
1547
1548         /* Successful save */
1549         return TRUE;
1550 }
1551
1552
1553 /*!
1554  * @brief セーブデータ書き込みのサブルーチン /
1555  * Medium level player saver
1556  * @return 成功すればtrue
1557  * @details
1558  * Angband 2.8.0 will use "fd" instead of "fff" if possible
1559  */
1560 static bool save_player_aux(char *name)
1561 {
1562         bool    ok = FALSE;
1563
1564         int             fd = -1;
1565
1566         int             mode = 0644;
1567
1568
1569         /* No file yet */
1570         fff = NULL;
1571
1572
1573         /* File type is "SAVE" */
1574         FILE_TYPE(FILE_TYPE_SAVE);
1575
1576
1577         /* Grab permissions */
1578         safe_setuid_grab();
1579
1580         /* Create the savefile */
1581         fd = fd_make(name, mode);
1582
1583         /* Drop permissions */
1584         safe_setuid_drop();
1585
1586         /* File is okay */
1587         if (fd >= 0)
1588         {
1589                 /* Close the "fd" */
1590                 (void)fd_close(fd);
1591
1592                 /* Grab permissions */
1593                 safe_setuid_grab();
1594
1595                 /* Open the savefile */
1596                 fff = my_fopen(name, "wb");
1597
1598                 /* Drop permissions */
1599                 safe_setuid_drop();
1600
1601                 /* Successful open */
1602                 if (fff)
1603                 {
1604                         /* Write the savefile */
1605                         if (wr_savefile_new()) ok = TRUE;
1606
1607                         /* Attempt to close it */
1608                         if (my_fclose(fff)) ok = FALSE;
1609                 }
1610
1611                 /* Grab permissions */
1612                 safe_setuid_grab();
1613
1614                 /* Remove "broken" files */
1615                 if (!ok) (void)fd_kill(name);
1616
1617                 /* Drop permissions */
1618                 safe_setuid_drop();
1619         }
1620
1621
1622         /* Failure */
1623         if (!ok) return (FALSE);
1624
1625         counts_write(0, playtime);
1626
1627         /* Successful save */
1628         character_saved = TRUE;
1629
1630         /* Success */
1631         return (TRUE);
1632 }
1633
1634
1635
1636 /*!
1637  * @brief セーブデータ書き込みのメインルーチン /
1638  * Attempt to save the player in a savefile
1639  * @return 成功すればtrue
1640  */
1641 bool save_player(void)
1642 {
1643         bool result = FALSE;
1644
1645         char safe[1024];
1646
1647
1648 #ifdef SET_UID
1649
1650 # ifdef SECURE
1651
1652         /* Get "games" permissions */
1653         beGames();
1654
1655 # endif
1656
1657 #endif
1658
1659
1660         /* New savefile */
1661         strcpy(safe, savefile);
1662         strcat(safe, ".new");
1663
1664         /* Grab permissions */
1665         safe_setuid_grab();
1666
1667         /* Remove it */
1668         fd_kill(safe);
1669
1670         /* Drop permissions */
1671         safe_setuid_drop();
1672
1673         update_playtime();
1674
1675         /* Attempt to save the player */
1676         if (save_player_aux(safe))
1677         {
1678                 char temp[1024];
1679
1680                 /* Old savefile */
1681                 strcpy(temp, savefile);
1682                 strcat(temp, ".old");
1683
1684                 /* Grab permissions */
1685                 safe_setuid_grab();
1686
1687                 /* Remove it */
1688                 fd_kill(temp);
1689
1690                 /* Preserve old savefile */
1691                 fd_move(savefile, temp);
1692
1693                 /* Activate new savefile */
1694                 fd_move(safe, savefile);
1695
1696                 /* Remove preserved savefile */
1697                 fd_kill(temp);
1698
1699                 /* Drop permissions */
1700                 safe_setuid_drop();
1701
1702                 /* Hack -- Pretend the character was loaded */
1703                 character_loaded = TRUE;
1704
1705 #ifdef VERIFY_SAVEFILE
1706
1707                 /* Lock on savefile */
1708                 strcpy(temp, savefile);
1709                 strcat(temp, ".lok");
1710
1711                 /* Grab permissions */
1712                 safe_setuid_grab();
1713
1714                 /* Remove lock file */
1715                 fd_kill(temp);
1716
1717                 /* Drop permissions */
1718                 safe_setuid_drop();
1719
1720 #endif
1721
1722                 /* Success */
1723                 result = TRUE;
1724         }
1725
1726
1727 #ifdef SET_UID
1728
1729 # ifdef SECURE
1730
1731         /* Drop "games" permissions */
1732         bePlayer();
1733
1734 # endif
1735
1736 #endif
1737
1738         /* Return the result */
1739         return (result);
1740 }
1741
1742
1743 /*!
1744  * @brief セーブデータ読み込みのメインルーチン /
1745  * Attempt to Load a "savefile"
1746  * @return 成功すればtrue
1747  * @details
1748  * <pre>
1749  * Version 2.7.0 introduced a slightly different "savefile" format from
1750  * older versions, requiring a completely different parsing method.
1751  *
1752  * Note that savefiles from 2.7.0 - 2.7.2 are completely obsolete.
1753  *
1754  * Pre-2.8.0 savefiles lose some data, see "load2.c" for info.
1755  *
1756  * Pre-2.7.0 savefiles lose a lot of things, see "load1.c" for info.
1757  *
1758  * On multi-user systems, you may only "read" a savefile if you will be
1759  * allowed to "write" it later, this prevents painful situations in which
1760  * the player loads a savefile belonging to someone else, and then is not
1761  * allowed to save his game when he quits.
1762  *
1763  * We return "TRUE" if the savefile was usable, and we set the global
1764  * flag "character_loaded" if a real, living, character was loaded.
1765  *
1766  * Note that we always try to load the "current" savefile, even if
1767  * there is no such file, so we must check for "empty" savefile names.
1768  * </pre>
1769  */
1770 bool load_player(void)
1771 {
1772         int             fd = -1;
1773
1774         errr    err = 0;
1775
1776         byte    vvv[4];
1777
1778 #ifdef VERIFY_TIMESTAMP
1779         struct stat     statbuf;
1780 #endif
1781
1782         cptr    what = "generic";
1783
1784
1785         /* Paranoia */
1786         turn = 0;
1787
1788         /* Paranoia */
1789         p_ptr->is_dead = FALSE;
1790
1791
1792         /* Allow empty savefile name */
1793         if (!savefile[0]) return (TRUE);
1794
1795
1796 #if !defined(MACINTOSH) && !defined(WINDOWS)
1797
1798         /* Fix this */
1799
1800         /* Verify the existance of the savefile */
1801         if (access(savefile, 0) < 0)
1802         {
1803                 /* Give a message */
1804                 msg_print(_("セーブファイルがありません。", "Savefile does not exist."));
1805
1806                 msg_print(NULL);
1807
1808                 /* Allow this */
1809                 return (TRUE);
1810         }
1811
1812 #endif
1813
1814
1815 #ifdef VERIFY_SAVEFILE
1816
1817         /* Verify savefile usage */
1818         if (!err)
1819         {
1820                 FILE *fkk;
1821
1822                 char temp[1024];
1823
1824                 /* Extract name of lock file */
1825                 strcpy(temp, savefile);
1826                 strcat(temp, ".lok");
1827
1828                 /* Check for lock */
1829                 fkk = my_fopen(temp, "r");
1830
1831                 /* Oops, lock exists */
1832                 if (fkk)
1833                 {
1834                         /* Close the file */
1835                         my_fclose(fkk);
1836
1837                         msg_print(_("セーブファイルは現在使用中です。", "Savefile is currently in use."));
1838                         msg_print(NULL);
1839
1840                         return (FALSE);
1841                 }
1842
1843                 /* Create a lock file */
1844                 fkk = my_fopen(temp, "w");
1845
1846                 /* Dump a line of info */
1847                 fprintf(fkk, "Lock file for savefile '%s'\n", savefile);
1848
1849                 /* Close the lock file */
1850                 my_fclose(fkk);
1851         }
1852
1853 #endif
1854
1855
1856         if (!err)
1857         {
1858                 /* Open the savefile */
1859                 fd = fd_open(savefile, O_RDONLY);
1860
1861                 /* No file */
1862                 if (fd < 0) err = -1;
1863
1864                 /* Message (below) */
1865                 if (err) what = _("セーブファイルを開けません。", "Cannot open savefile");
1866         }
1867
1868         /* Process file */
1869         if (!err)
1870         {
1871
1872 #ifdef VERIFY_TIMESTAMP
1873                 /* Get the timestamp */
1874                 (void)fstat(fd, &statbuf);
1875 #endif
1876
1877                 /* Read the first four bytes */
1878                 if (fd_read(fd, (char*)(vvv), 4)) err = -1;
1879
1880                 /* What */
1881                 if (err) what = _("セーブファイルを読めません。", "Cannot read savefile");
1882
1883                 /* Close the file */
1884                 (void)fd_close(fd);
1885         }
1886
1887         /* Process file */
1888         if (!err)
1889         {
1890
1891                 /* Extract version */
1892                 z_major = vvv[0];
1893                 z_minor = vvv[1];
1894                 z_patch = vvv[2];
1895                 sf_extra = vvv[3];
1896
1897
1898                 /* Clear screen */
1899                 Term_clear();
1900
1901                 /* Attempt to load */
1902                 err = rd_savefile_new();
1903
1904                 /* Message (below) */
1905                 if (err) what = _("セーブファイルを解析出来ません。", "Cannot parse savefile");
1906         }
1907
1908         /* Paranoia */
1909         if (!err)
1910         {
1911                 /* Invalid turn */
1912                 if (!turn) err = -1;
1913
1914                 /* Message (below) */
1915                 if (err) what = _("セーブファイルが壊れています", "Broken savefile");
1916         }
1917
1918 #ifdef VERIFY_TIMESTAMP
1919         /* Verify timestamp */
1920         if (!err && !arg_wizard)
1921         {
1922                 /* Hack -- Verify the timestamp */
1923                 if (sf_when > (statbuf.st_ctime + 100) ||
1924                     sf_when < (statbuf.st_ctime - 100))
1925                 {
1926                         what = _("無効なタイム・スタンプです", "Invalid timestamp");
1927
1928                         err = -1;
1929                 }
1930         }
1931 #endif
1932
1933
1934         if (!err)
1935         {
1936                 /* Give a conversion warning */
1937                 if ((FAKE_VER_MAJOR != z_major) ||
1938                     (FAKE_VER_MINOR != z_minor) ||
1939                     (FAKE_VER_PATCH != z_patch))
1940                 {
1941                         if (z_major == 2 && z_minor == 0 && z_patch == 6)
1942                         {
1943                                 msg_print(_("バージョン 2.0.* 用のセーブファイルを変換しました。", "Converted a 2.0.* savefile."));
1944                         }
1945                         else
1946                         {
1947 #ifdef JP
1948                                 msg_format("バージョン %d.%d.%d 用のセーブ・ファイルを変換しました。",
1949                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1950 #else
1951                                 msg_format("Converted a %d.%d.%d savefile.",
1952                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1953 #endif
1954                         }
1955                         msg_print(NULL);
1956                 }
1957
1958                 /* Player is dead */
1959                 if (p_ptr->is_dead)
1960                 {
1961                         /* Cheat death */
1962                         if (arg_wizard)
1963                         {
1964                                 /* A character was loaded */
1965                                 character_loaded = TRUE;
1966
1967                                 return (TRUE);
1968                         }
1969
1970                         /* Player is no longer "dead" */
1971                         p_ptr->is_dead = FALSE;
1972
1973                         /* Count lives */
1974                         sf_lives++;
1975
1976                         return (TRUE);
1977                 }
1978
1979                 /* A character was loaded */
1980                 character_loaded = TRUE;
1981
1982                 {
1983                         u32b tmp = counts_read(2);
1984                         if (tmp > p_ptr->count)
1985                                 p_ptr->count = tmp;
1986                         if (counts_read(0) > playtime || counts_read(1) == playtime)
1987                                 counts_write(2, ++p_ptr->count);
1988                         counts_write(1, playtime);
1989                 }
1990
1991                 /* Success */
1992                 return (TRUE);
1993         }
1994
1995
1996 #ifdef VERIFY_SAVEFILE
1997
1998         /* Verify savefile usage */
1999         if (TRUE)
2000         {
2001                 char temp[1024];
2002
2003                 /* Extract name of lock file */
2004                 strcpy(temp, savefile);
2005                 strcat(temp, ".lok");
2006
2007                 /* Remove lock */
2008                 fd_kill(temp);
2009         }
2010
2011 #endif
2012
2013
2014 #ifdef JP
2015         msg_format("エラー(%s)がバージョン%d.%d.%d 用セーブファイル読み込み中に発生。",
2016                    what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
2017 #else
2018         msg_format("Error (%s) reading %d.%d.%d savefile.",
2019                    what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
2020 #endif
2021         msg_print(NULL);
2022
2023         return (FALSE);
2024 }
2025
2026 /*!
2027  * @brief ファイルロック処理
2028  * @return なし
2029  */
2030 void remove_loc(void)
2031 {
2032 #ifdef VERIFY_SAVEFILE
2033         char temp[1024];
2034 #endif /* VERIFY_SAVEFILE */
2035
2036 #ifdef SET_UID
2037 # ifdef SECURE
2038
2039         /* Get "games" permissions */
2040         beGames();
2041
2042 # endif /* SECURE */
2043 #endif /* SET_UID */
2044
2045 #ifdef VERIFY_SAVEFILE
2046
2047         /* Lock on savefile */
2048         strcpy(temp, savefile);
2049         strcat(temp, ".lok");
2050
2051         /* Remove lock file */
2052         fd_kill(temp);
2053
2054 #endif /* VERIFY_SAVEFILE */
2055
2056 #ifdef SET_UID
2057 # ifdef SECURE
2058
2059         /* Drop "games" permissions */
2060         bePlayer();
2061
2062 # endif /* SECURE */
2063 #endif /* SET_UID */
2064
2065 }
2066
2067
2068 /*!
2069  * @brief ゲームプレイ中のフロア一時保存出力処理サブルーチン / Actually write a temporal saved floor file
2070  * @param sf_ptr 保存フロア参照ポインタ
2071  * @return なし
2072  */
2073 static bool save_floor_aux(saved_floor_type *sf_ptr)
2074 {
2075         byte tmp8u;
2076
2077         /* Compact the objects */
2078         compact_objects(0);
2079         /* Compact the monsters */
2080         compact_monsters(0);
2081
2082
2083         /*** Actually write the file ***/
2084
2085         /* Initial value of xor_byte */
2086         tmp8u = (byte)randint0(256);
2087         xor_byte = 0;
2088         wr_byte(tmp8u);
2089
2090
2091         /* Reset the checksum */
2092         v_stamp = 0L;
2093         x_stamp = 0L;
2094
2095         /* Write the sign of this process */
2096         wr_u32b(saved_floor_file_sign);
2097
2098         /* Dump the dungeon floor */
2099         wr_saved_floor(sf_ptr);
2100
2101
2102         /* Write the "value check-sum" */
2103         wr_u32b(v_stamp);
2104
2105         /* Write the "encoded checksum" */
2106         wr_u32b(x_stamp);
2107
2108
2109         /* Error in save */
2110         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
2111
2112         /* Successful save */
2113         return TRUE;
2114 }
2115
2116
2117 /*!
2118  * @brief ゲームプレイ中のフロア一時保存出力処理メインルーチン / Attempt to save the temporally saved-floor data
2119  * @param sf_ptr 保存フロア参照ポインタ
2120  * @param mode 保存オプション
2121  * @return なし
2122  */
2123 bool save_floor(saved_floor_type *sf_ptr, BIT_FLAGS mode)
2124 {
2125         FILE *old_fff = NULL;
2126         byte old_xor_byte = 0;
2127         u32b old_v_stamp = 0;
2128         u32b old_x_stamp = 0;
2129
2130         char floor_savefile[1024];
2131         int fd = -1;
2132         bool ok = FALSE;
2133
2134         if (!(mode & SLF_SECOND))
2135         {
2136 #ifdef SET_UID
2137 # ifdef SECURE
2138                 /* Get "games" permissions */
2139                 beGames();
2140 # endif
2141 #endif
2142         }
2143
2144         /* We have one file already opened */
2145         else
2146         {
2147                 /* Backup original values */
2148                 old_fff = fff;
2149                 old_xor_byte = xor_byte;
2150                 old_v_stamp = v_stamp;
2151                 old_x_stamp = x_stamp;
2152         }
2153
2154         /* New savefile */
2155         sprintf(floor_savefile, "%s.F%02d", savefile, (int)sf_ptr->savefile_id);
2156
2157         /* Grab permissions */
2158         safe_setuid_grab();
2159
2160         /* Remove it */
2161         fd_kill(floor_savefile);
2162
2163         /* Drop permissions */
2164         safe_setuid_drop();
2165
2166
2167         /* Attempt to save the player */
2168
2169         /* No file yet */
2170         fff = NULL;
2171
2172         /* File type is "SAVE" */
2173         FILE_TYPE(FILE_TYPE_SAVE);
2174
2175         /* Grab permissions */
2176         safe_setuid_grab();
2177
2178         /* Create the savefile */
2179         fd = fd_make(floor_savefile, 0644);
2180
2181         /* Drop permissions */
2182         safe_setuid_drop();
2183
2184         /* File is okay */
2185         if (fd >= 0)
2186         {
2187                 /* Close the "fd" */
2188                 (void)fd_close(fd);
2189
2190                 /* Grab permissions */
2191                 safe_setuid_grab();
2192
2193                 /* Open the savefile */
2194                 fff = my_fopen(floor_savefile, "wb");
2195
2196                 /* Drop permissions */
2197                 safe_setuid_drop();
2198
2199                 /* Successful open */
2200                 if (fff)
2201                 {
2202                         /* Write the savefile */
2203                         if (save_floor_aux(sf_ptr)) ok = TRUE;
2204
2205                         /* Attempt to close it */
2206                         if (my_fclose(fff)) ok = FALSE;
2207                 }
2208
2209                 /* Remove "broken" files */
2210                 if (!ok)
2211                 {
2212                         /* Grab permissions */
2213                         safe_setuid_grab();
2214
2215                         (void)fd_kill(floor_savefile);
2216
2217                         /* Drop permissions */
2218                         safe_setuid_drop();
2219                 }
2220         }
2221
2222         if (!(mode & SLF_SECOND))
2223         {
2224 #ifdef SET_UID
2225 # ifdef SECURE
2226                 /* Drop "games" permissions */
2227                 bePlayer();
2228 # endif
2229 #endif
2230         }
2231
2232         /* We have one file already opened */
2233         else
2234         {
2235                 /* Restore original values */
2236                 fff = old_fff;
2237                 xor_byte = old_xor_byte;
2238                 v_stamp = old_v_stamp;
2239                 x_stamp = old_x_stamp;
2240         }
2241
2242         /* Return the result */
2243         return ok;
2244 }