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         p_ptr->update |= (PU_MONSTERS | PU_DISTANCE | PU_FLOW);
1166
1167
1168         /*** Meta info ***/
1169
1170         /* Number of floor_id used from birth */
1171         wr_s16b(max_floor_id);
1172
1173         /* Current dungeon type */
1174         wr_byte((byte_hack)dungeon_type);
1175
1176
1177         /*** No saved floor (On the surface etc.) ***/
1178         if (!p_ptr->floor_id)
1179         {
1180                 /* No array elements */
1181                 wr_byte(0);
1182
1183                 /* Write the current floor data */
1184                 wr_saved_floor(NULL);
1185
1186                 /* Success */
1187                 return TRUE;
1188         }
1189
1190
1191         /*** In the dungeon ***/
1192
1193         /* Number of array elements */
1194         wr_byte(MAX_SAVED_FLOORS);
1195
1196         /* Write the saved_floors array */
1197         for (i = 0; i < MAX_SAVED_FLOORS; i++)
1198         {
1199                 saved_floor_type *sf_ptr = &saved_floors[i];
1200
1201                 wr_s16b(sf_ptr->floor_id);
1202                 wr_byte((byte_hack)sf_ptr->savefile_id);
1203                 wr_s16b((s16b)sf_ptr->dun_level);
1204                 wr_s32b(sf_ptr->last_visit);
1205                 wr_u32b(sf_ptr->visit_mark);
1206                 wr_s16b(sf_ptr->upper_floor_id);
1207                 wr_s16b(sf_ptr->lower_floor_id);
1208         }
1209
1210         /* Extract pointer to current floor */
1211         cur_sf_ptr = get_sf_ptr(p_ptr->floor_id);
1212
1213         /* Save current floor to temporal file */
1214         if (!save_floor(cur_sf_ptr, (SLF_SECOND))) return FALSE;
1215
1216         /* Move data in temporal files to the savefile */
1217         for (i = 0; i < MAX_SAVED_FLOORS; i++)
1218         {
1219                 saved_floor_type *sf_ptr = &saved_floors[i];
1220
1221                 /* Unused element */
1222                 if (!sf_ptr->floor_id) continue;
1223
1224                 /* Load temporal saved floor file */
1225                 if (load_floor(sf_ptr, (SLF_SECOND | SLF_NO_KILL)))
1226                 {
1227                         /* Mark success */
1228                         wr_byte(0);
1229
1230                         /* Write saved floor data to the save file */
1231                         wr_saved_floor(sf_ptr);
1232                 }
1233                 else
1234                 {
1235                         /* Mark failure */
1236                         wr_byte(1);
1237                 }
1238         }
1239
1240         /* Restore current floor */
1241         if (!load_floor(cur_sf_ptr, (SLF_SECOND))) return FALSE;
1242
1243         /* Success */
1244         return TRUE;
1245 }
1246
1247
1248 /*!
1249  * @brief セーブデータの書き込み /
1250  * Actually write a save-file
1251  * @return 成功すればtrue
1252  */
1253 static bool wr_savefile_new(void)
1254 {
1255         int        i, j;
1256
1257         u32b              now;
1258
1259         byte            tmp8u;
1260         u16b            tmp16u;
1261         u32b            tmp32u;
1262
1263         MONRACE_IDX r_idx;
1264         KIND_OBJECT_IDX k_idx;
1265
1266         /* Compact the objects */
1267         compact_objects(0);
1268         /* Compact the monsters */
1269         compact_monsters(0);
1270
1271         /* Guess at the current time */
1272         now = (u32b)time((time_t *)0);
1273
1274
1275         /* Note the operating system */
1276         sf_system = 0L;
1277
1278         /* Note when the file was saved */
1279         sf_when = now;
1280
1281         /* Note the number of saves */
1282         sf_saves++;
1283
1284
1285         /*** Actually write the file ***/
1286
1287         /* Dump the file header */
1288         xor_byte = 0;
1289         wr_byte(FAKE_VER_MAJOR);
1290         xor_byte = 0;
1291         wr_byte(FAKE_VER_MINOR);
1292         xor_byte = 0;
1293         wr_byte(FAKE_VER_PATCH);
1294         xor_byte = 0;
1295
1296         /* Initial value of xor_byte */
1297         tmp8u = (byte)Rand_external(256);
1298         wr_byte(tmp8u);
1299
1300
1301         /* Reset the checksum */
1302         v_stamp = 0L;
1303         x_stamp = 0L;
1304
1305         /* Write the savefile version for Hengband 1.1.1 and later */
1306         wr_byte(H_VER_EXTRA);
1307         wr_byte(H_VER_PATCH);
1308         wr_byte(H_VER_MINOR);
1309         wr_byte(H_VER_MAJOR);
1310
1311         /* Operating system */
1312         wr_u32b(sf_system);
1313
1314
1315         /* Time file last saved */
1316         wr_u32b(sf_when);
1317
1318         /* Number of past lives */
1319         wr_u16b(sf_lives);
1320
1321         /* Number of times saved */
1322         wr_u16b(sf_saves);
1323
1324
1325         /* Space */
1326         wr_u32b(0L);
1327         wr_u16b(0);
1328         wr_byte(0);
1329
1330 #ifdef JP
1331 # ifdef EUC
1332         /* EUC kanji code */
1333         wr_byte(2);
1334 # endif
1335 # ifdef SJIS
1336         /* SJIS kanji code */
1337         wr_byte(3);
1338 # endif
1339 #else
1340         /* ASCII */
1341         wr_byte(1);
1342 #endif
1343
1344         /* Write the RNG state */
1345         wr_randomizer();
1346
1347
1348         /* Write the boolean "options" */
1349         wr_options();
1350
1351
1352         /* Dump the number of "messages" */
1353         tmp32u = message_num();
1354         if (compress_savefile && (tmp32u > 40)) tmp32u = 40;
1355         wr_u32b(tmp32u);
1356
1357         /* Dump the messages (oldest first!) */
1358         for (i = tmp32u - 1; i >= 0; i--)
1359         {
1360                 wr_string(message_str((s16b)i));
1361         }
1362
1363         /* Dump the monster lore */
1364         tmp16u = max_r_idx;
1365         wr_u16b(tmp16u);
1366         for (r_idx = 0; r_idx < tmp16u; r_idx++) wr_lore(r_idx);
1367
1368         /* Dump the object memory */
1369         tmp16u = max_k_idx;
1370         wr_u16b(tmp16u);
1371         for (k_idx = 0; k_idx < tmp16u; k_idx++) wr_xtra(k_idx);
1372
1373         /* Dump the towns */
1374         tmp16u = max_towns;
1375         wr_u16b(tmp16u);
1376
1377         /* Dump the quests */
1378         tmp16u = max_q_idx;
1379         wr_u16b(tmp16u);
1380
1381         /* Dump the quests */
1382         tmp8u = MAX_RANDOM_QUEST-MIN_RANDOM_QUEST;
1383         wr_byte(tmp8u);
1384
1385         for (i = 0; i < max_q_idx; i++)
1386         {
1387                 quest_type* const q_ptr = &quest[i];
1388
1389                 /* Save status for every quest */
1390                 wr_s16b(q_ptr->status);
1391
1392                 /* And the dungeon level too */
1393                 /* (prevents problems with multi-level quests) */
1394                 wr_s16b((s16b)q_ptr->level);
1395
1396                 wr_byte((byte_hack)q_ptr->complev);
1397                 wr_u32b(q_ptr->comptime);
1398
1399                 /* Save quest status if quest is running */
1400                 if (q_ptr->status == QUEST_STATUS_TAKEN || q_ptr->status == QUEST_STATUS_COMPLETED || !is_fixed_quest_idx(i))
1401                 {
1402                         wr_s16b((s16b)q_ptr->cur_num);
1403                         wr_s16b((s16b)q_ptr->max_num);
1404                         wr_s16b(q_ptr->type);
1405                         wr_s16b(q_ptr->r_idx);
1406                         wr_s16b(q_ptr->k_idx);
1407                         wr_byte((byte_hack)q_ptr->flags);
1408                         wr_byte((byte_hack)q_ptr->dungeon);
1409                 }
1410         }
1411
1412         /* Dump the position in the wilderness */
1413         wr_s32b(p_ptr->wilderness_x);
1414         wr_s32b(p_ptr->wilderness_y);
1415
1416         wr_byte(p_ptr->wild_mode);
1417         wr_byte(ambush_flag);
1418
1419         wr_s32b(max_wild_x);
1420         wr_s32b(max_wild_y);
1421
1422         /* Dump the wilderness seeds */
1423         for (i = 0; i < max_wild_x; i++)
1424         {
1425                 for (j = 0; j < max_wild_y; j++)
1426                 {
1427                         wr_u32b(wilderness[j][i].seed);
1428                 }
1429         }
1430
1431         /* Hack -- Dump the artifacts */
1432         tmp16u = max_a_idx;
1433         wr_u16b(tmp16u);
1434         for (i = 0; i < tmp16u; i++)
1435         {
1436                 artifact_type *a_ptr = &a_info[i];
1437                 wr_byte(a_ptr->cur_num);
1438                 wr_s16b(a_ptr->floor_id);
1439         }
1440
1441
1442
1443         /* Write the "extra" information */
1444         wr_extra();
1445
1446         /* Dump the "player hp" entries */
1447         tmp16u = PY_MAX_LEVEL;
1448         wr_u16b(tmp16u);
1449         for (i = 0; i < tmp16u; i++)
1450         {
1451                 wr_s16b((s16b)p_ptr->player_hp[i]);
1452         }
1453
1454
1455         /* Write spell data */
1456         wr_u32b(p_ptr->spell_learned1);
1457         wr_u32b(p_ptr->spell_learned2);
1458         wr_u32b(p_ptr->spell_worked1);
1459         wr_u32b(p_ptr->spell_worked2);
1460         wr_u32b(p_ptr->spell_forgotten1);
1461         wr_u32b(p_ptr->spell_forgotten2);
1462
1463         wr_s16b(p_ptr->learned_spells);
1464         wr_s16b(p_ptr->add_spells);
1465
1466         /* Dump the ordered spells */
1467         for (i = 0; i < 64; i++)
1468         {
1469                 wr_byte((byte_hack)p_ptr->spell_order[i]);
1470         }
1471
1472
1473         /* Write the inventory */
1474         for (i = 0; i < INVEN_TOTAL; i++)
1475         {
1476                 object_type *o_ptr = &inventory[i];
1477
1478                 /* Skip non-objects */
1479                 if (!o_ptr->k_idx) continue;
1480
1481                 /* Dump index */
1482                 wr_u16b((u16b)i);
1483
1484                 /* Dump object */
1485                 wr_item(o_ptr);
1486         }
1487
1488         /* Add a sentinel */
1489         wr_u16b(0xFFFF);
1490
1491         /* Note the towns */
1492         tmp16u = max_towns;
1493         wr_u16b(tmp16u);
1494
1495         /* Note the stores */
1496         tmp16u = MAX_STORES;
1497         wr_u16b(tmp16u);
1498
1499         /* Dump the stores of all towns */
1500         for (i = 1; i < max_towns; i++)
1501         {
1502                 for (j = 0; j < MAX_STORES; j++)
1503                 {
1504                         wr_store(&town[i].store[j]);
1505                 }
1506         }
1507
1508         /* Write the pet command settings */
1509         wr_s16b(p_ptr->pet_follow_distance);
1510         wr_s16b(p_ptr->pet_extra_flags);
1511
1512         /* Write screen dump for sending score */
1513         if (screen_dump && (p_ptr->wait_report_score || !p_ptr->is_dead))
1514         {
1515                 wr_string(screen_dump);
1516         }
1517         else
1518         {
1519                 wr_string("");
1520         }
1521
1522         /* Player is not dead, write the dungeon */
1523         if (!p_ptr->is_dead)
1524         {
1525                 /* Dump the dungeon */
1526                 if (!wr_dungeon()) return FALSE;
1527
1528                 /* Dump the ghost */
1529                 wr_ghost();
1530
1531                 /* No scripts */
1532                 wr_s32b(0);
1533         }
1534
1535
1536         /* Write the "value check-sum" */
1537         wr_u32b(v_stamp);
1538
1539         /* Write the "encoded checksum" */
1540         wr_u32b(x_stamp);
1541
1542
1543         /* Error in save */
1544         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
1545
1546         /* Successful save */
1547         return TRUE;
1548 }
1549
1550
1551 /*!
1552  * @brief セーブデータ書き込みのサブルーチン /
1553  * Medium level player saver
1554  * @return 成功すればtrue
1555  * @details
1556  * Angband 2.8.0 will use "fd" instead of "fff" if possible
1557  */
1558 static bool save_player_aux(char *name)
1559 {
1560         bool ok = FALSE;
1561         int fd = -1;
1562         int mode = 0644;
1563
1564         /* No file yet */
1565         fff = NULL;
1566
1567         /* File type is "SAVE" */
1568         FILE_TYPE(FILE_TYPE_SAVE);
1569
1570         /* Grab permissions */
1571         safe_setuid_grab();
1572
1573         /* Create the savefile */
1574         fd = fd_make(name, mode);
1575
1576         /* Drop permissions */
1577         safe_setuid_drop();
1578
1579         /* File is okay */
1580         if (fd >= 0)
1581         {
1582                 /* Close the "fd" */
1583                 (void)fd_close(fd);
1584
1585                 /* Grab permissions */
1586                 safe_setuid_grab();
1587
1588                 /* Open the savefile */
1589                 fff = my_fopen(name, "wb");
1590
1591                 /* Drop permissions */
1592                 safe_setuid_drop();
1593
1594                 /* Successful open */
1595                 if (fff)
1596                 {
1597                         /* Write the savefile */
1598                         if (wr_savefile_new()) ok = TRUE;
1599
1600                         /* Attempt to close it */
1601                         if (my_fclose(fff)) ok = FALSE;
1602                 }
1603
1604                 /* Grab permissions */
1605                 safe_setuid_grab();
1606
1607                 /* Remove "broken" files */
1608                 if (!ok) (void)fd_kill(name);
1609
1610                 /* Drop permissions */
1611                 safe_setuid_drop();
1612         }
1613
1614
1615         /* Failure */
1616         if (!ok) return (FALSE);
1617
1618         counts_write(0, playtime);
1619
1620         /* Successful save */
1621         character_saved = TRUE;
1622
1623         /* Success */
1624         return (TRUE);
1625 }
1626
1627
1628
1629 /*!
1630  * @brief セーブデータ書き込みのメインルーチン /
1631  * Attempt to save the player in a savefile
1632  * @return 成功すればtrue
1633  */
1634 bool save_player(void)
1635 {
1636         bool result = FALSE;
1637
1638         char safe[1024];
1639
1640
1641 #ifdef SET_UID
1642
1643 # ifdef SECURE
1644
1645         /* Get "games" permissions */
1646         beGames();
1647
1648 # endif
1649
1650 #endif
1651
1652
1653         /* New savefile */
1654         strcpy(safe, savefile);
1655         strcat(safe, ".new");
1656
1657         /* Grab permissions */
1658         safe_setuid_grab();
1659
1660         /* Remove it */
1661         fd_kill(safe);
1662
1663         /* Drop permissions */
1664         safe_setuid_drop();
1665
1666         update_playtime();
1667
1668         /* Attempt to save the player */
1669         if (save_player_aux(safe))
1670         {
1671                 char temp[1024];
1672
1673                 /* Old savefile */
1674                 strcpy(temp, savefile);
1675                 strcat(temp, ".old");
1676
1677                 /* Grab permissions */
1678                 safe_setuid_grab();
1679
1680                 /* Remove it */
1681                 fd_kill(temp);
1682
1683                 /* Preserve old savefile */
1684                 fd_move(savefile, temp);
1685
1686                 /* Activate new savefile */
1687                 fd_move(safe, savefile);
1688
1689                 /* Remove preserved savefile */
1690                 fd_kill(temp);
1691
1692                 /* Drop permissions */
1693                 safe_setuid_drop();
1694
1695                 /* Hack -- Pretend the character was loaded */
1696                 character_loaded = TRUE;
1697
1698 #ifdef VERIFY_SAVEFILE
1699
1700                 /* Lock on savefile */
1701                 strcpy(temp, savefile);
1702                 strcat(temp, ".lok");
1703
1704                 /* Grab permissions */
1705                 safe_setuid_grab();
1706
1707                 /* Remove lock file */
1708                 fd_kill(temp);
1709
1710                 /* Drop permissions */
1711                 safe_setuid_drop();
1712
1713 #endif
1714
1715                 /* Success */
1716                 result = TRUE;
1717         }
1718
1719
1720 #ifdef SET_UID
1721
1722 # ifdef SECURE
1723
1724         /* Drop "games" permissions */
1725         bePlayer();
1726
1727 # endif
1728
1729 #endif
1730
1731         /* Return the result */
1732         return (result);
1733 }
1734
1735
1736 /*!
1737  * @brief セーブデータ読み込みのメインルーチン /
1738  * Attempt to Load a "savefile"
1739  * @return 成功すればtrue
1740  * @details
1741  * <pre>
1742  * Version 2.7.0 introduced a slightly different "savefile" format from
1743  * older versions, requiring a completely different parsing method.
1744  *
1745  * Note that savefiles from 2.7.0 - 2.7.2 are completely obsolete.
1746  *
1747  * Pre-2.8.0 savefiles lose some data, see "load2.c" for info.
1748  *
1749  * Pre-2.7.0 savefiles lose a lot of things, see "load1.c" for info.
1750  *
1751  * On multi-user systems, you may only "read" a savefile if you will be
1752  * allowed to "write" it later, this prevents painful situations in which
1753  * the player loads a savefile belonging to someone else, and then is not
1754  * allowed to save his game when he quits.
1755  *
1756  * We return "TRUE" if the savefile was usable, and we set the global
1757  * flag "character_loaded" if a real, living, character was loaded.
1758  *
1759  * Note that we always try to load the "current" savefile, even if
1760  * there is no such file, so we must check for "empty" savefile names.
1761  * </pre>
1762  */
1763 bool load_player(void)
1764 {
1765         int             fd = -1;
1766
1767         errr    err = 0;
1768
1769         byte    vvv[4];
1770
1771 #ifdef VERIFY_TIMESTAMP
1772         struct stat     statbuf;
1773 #endif
1774
1775         cptr    what = "generic";
1776
1777
1778         /* Paranoia */
1779         turn = 0;
1780
1781         /* Paranoia */
1782         p_ptr->is_dead = FALSE;
1783
1784
1785         /* Allow empty savefile name */
1786         if (!savefile[0]) return (TRUE);
1787
1788
1789 #if !defined(MACINTOSH) && !defined(WINDOWS)
1790
1791         /* Fix this */
1792
1793         /* Verify the existance of the savefile */
1794         if (access(savefile, 0) < 0)
1795         {
1796                 /* Give a message */
1797                 msg_print(_("セーブファイルがありません。", "Savefile does not exist."));
1798
1799                 msg_print(NULL);
1800
1801                 /* Allow this */
1802                 return (TRUE);
1803         }
1804
1805 #endif
1806
1807
1808 #ifdef VERIFY_SAVEFILE
1809
1810         /* Verify savefile usage */
1811         if (!err)
1812         {
1813                 FILE *fkk;
1814
1815                 char temp[1024];
1816
1817                 /* Extract name of lock file */
1818                 strcpy(temp, savefile);
1819                 strcat(temp, ".lok");
1820
1821                 /* Check for lock */
1822                 fkk = my_fopen(temp, "r");
1823
1824                 /* Oops, lock exists */
1825                 if (fkk)
1826                 {
1827                         /* Close the file */
1828                         my_fclose(fkk);
1829
1830                         msg_print(_("セーブファイルは現在使用中です。", "Savefile is currently in use."));
1831                         msg_print(NULL);
1832
1833                         return (FALSE);
1834                 }
1835
1836                 /* Create a lock file */
1837                 fkk = my_fopen(temp, "w");
1838
1839                 /* Dump a line of info */
1840                 fprintf(fkk, "Lock file for savefile '%s'\n", savefile);
1841
1842                 /* Close the lock file */
1843                 my_fclose(fkk);
1844         }
1845
1846 #endif
1847
1848
1849         if (!err)
1850         {
1851                 /* Open the savefile */
1852                 fd = fd_open(savefile, O_RDONLY);
1853
1854                 /* No file */
1855                 if (fd < 0) err = -1;
1856
1857                 /* Message (below) */
1858                 if (err) what = _("セーブファイルを開けません。", "Cannot open savefile");
1859         }
1860
1861         /* Process file */
1862         if (!err)
1863         {
1864
1865 #ifdef VERIFY_TIMESTAMP
1866                 /* Get the timestamp */
1867                 (void)fstat(fd, &statbuf);
1868 #endif
1869
1870                 /* Read the first four bytes */
1871                 if (fd_read(fd, (char*)(vvv), 4)) err = -1;
1872
1873                 /* What */
1874                 if (err) what = _("セーブファイルを読めません。", "Cannot read savefile");
1875
1876                 /* Close the file */
1877                 (void)fd_close(fd);
1878         }
1879
1880         /* Process file */
1881         if (!err)
1882         {
1883
1884                 /* Extract version */
1885                 z_major = vvv[0];
1886                 z_minor = vvv[1];
1887                 z_patch = vvv[2];
1888                 sf_extra = vvv[3];
1889
1890
1891                 /* Clear screen */
1892                 Term_clear();
1893
1894                 /* Attempt to load */
1895                 err = rd_savefile_new();
1896
1897                 /* Message (below) */
1898                 if (err) what = _("セーブファイルを解析出来ません。", "Cannot parse savefile");
1899         }
1900
1901         /* Paranoia */
1902         if (!err)
1903         {
1904                 /* Invalid turn */
1905                 if (!turn) err = -1;
1906
1907                 /* Message (below) */
1908                 if (err) what = _("セーブファイルが壊れています", "Broken savefile");
1909         }
1910
1911 #ifdef VERIFY_TIMESTAMP
1912         /* Verify timestamp */
1913         if (!err && !arg_wizard)
1914         {
1915                 /* Hack -- Verify the timestamp */
1916                 if (sf_when > (statbuf.st_ctime + 100) ||
1917                     sf_when < (statbuf.st_ctime - 100))
1918                 {
1919                         what = _("無効なタイム・スタンプです", "Invalid timestamp");
1920
1921                         err = -1;
1922                 }
1923         }
1924 #endif
1925
1926
1927         if (!err)
1928         {
1929                 /* Give a conversion warning */
1930                 if ((FAKE_VER_MAJOR != z_major) ||
1931                     (FAKE_VER_MINOR != z_minor) ||
1932                     (FAKE_VER_PATCH != z_patch))
1933                 {
1934                         if (z_major == 2 && z_minor == 0 && z_patch == 6)
1935                         {
1936                                 msg_print(_("バージョン 2.0.* 用のセーブファイルを変換しました。", "Converted a 2.0.* savefile."));
1937                         }
1938                         else
1939                         {
1940 #ifdef JP
1941                                 msg_format("バージョン %d.%d.%d 用のセーブ・ファイルを変換しました。",
1942                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1943 #else
1944                                 msg_format("Converted a %d.%d.%d savefile.",
1945                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1946 #endif
1947                         }
1948                         msg_print(NULL);
1949                 }
1950
1951                 /* Player is dead */
1952                 if (p_ptr->is_dead)
1953                 {
1954                         /* Cheat death */
1955                         if (arg_wizard)
1956                         {
1957                                 /* A character was loaded */
1958                                 character_loaded = TRUE;
1959
1960                                 return (TRUE);
1961                         }
1962
1963                         /* Player is no longer "dead" */
1964                         p_ptr->is_dead = FALSE;
1965
1966                         /* Count lives */
1967                         sf_lives++;
1968
1969                         return (TRUE);
1970                 }
1971
1972                 /* A character was loaded */
1973                 character_loaded = TRUE;
1974
1975                 {
1976                         u32b tmp = counts_read(2);
1977                         if (tmp > p_ptr->count)
1978                                 p_ptr->count = tmp;
1979                         if (counts_read(0) > playtime || counts_read(1) == playtime)
1980                                 counts_write(2, ++p_ptr->count);
1981                         counts_write(1, playtime);
1982                 }
1983
1984                 /* Success */
1985                 return (TRUE);
1986         }
1987
1988
1989 #ifdef VERIFY_SAVEFILE
1990
1991         /* Verify savefile usage */
1992         if (TRUE)
1993         {
1994                 char temp[1024];
1995
1996                 /* Extract name of lock file */
1997                 strcpy(temp, savefile);
1998                 strcat(temp, ".lok");
1999
2000                 /* Remove lock */
2001                 fd_kill(temp);
2002         }
2003
2004 #endif
2005
2006
2007 #ifdef JP
2008         msg_format("エラー(%s)がバージョン%d.%d.%d 用セーブファイル読み込み中に発生。",
2009                    what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
2010 #else
2011         msg_format("Error (%s) reading %d.%d.%d savefile.",
2012                    what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
2013 #endif
2014         msg_print(NULL);
2015
2016         return (FALSE);
2017 }
2018
2019 /*!
2020  * @brief ファイルロック処理
2021  * @return なし
2022  */
2023 void remove_loc(void)
2024 {
2025 #ifdef VERIFY_SAVEFILE
2026         char temp[1024];
2027 #endif /* VERIFY_SAVEFILE */
2028
2029 #ifdef SET_UID
2030 # ifdef SECURE
2031
2032         /* Get "games" permissions */
2033         beGames();
2034
2035 # endif /* SECURE */
2036 #endif /* SET_UID */
2037
2038 #ifdef VERIFY_SAVEFILE
2039
2040         /* Lock on savefile */
2041         strcpy(temp, savefile);
2042         strcat(temp, ".lok");
2043
2044         /* Remove lock file */
2045         fd_kill(temp);
2046
2047 #endif /* VERIFY_SAVEFILE */
2048
2049 #ifdef SET_UID
2050 # ifdef SECURE
2051
2052         /* Drop "games" permissions */
2053         bePlayer();
2054
2055 # endif /* SECURE */
2056 #endif /* SET_UID */
2057
2058 }
2059
2060
2061 /*!
2062  * @brief ゲームプレイ中のフロア一時保存出力処理サブルーチン / Actually write a temporal saved floor file
2063  * @param sf_ptr 保存フロア参照ポインタ
2064  * @return なし
2065  */
2066 static bool save_floor_aux(saved_floor_type *sf_ptr)
2067 {
2068         byte tmp8u;
2069
2070         /* Compact the objects */
2071         compact_objects(0);
2072         /* Compact the monsters */
2073         compact_monsters(0);
2074
2075
2076         /*** Actually write the file ***/
2077
2078         /* Initial value of xor_byte */
2079         tmp8u = (byte)randint0(256);
2080         xor_byte = 0;
2081         wr_byte(tmp8u);
2082
2083
2084         /* Reset the checksum */
2085         v_stamp = 0L;
2086         x_stamp = 0L;
2087
2088         /* Write the sign of this process */
2089         wr_u32b(saved_floor_file_sign);
2090
2091         /* Dump the dungeon floor */
2092         wr_saved_floor(sf_ptr);
2093
2094
2095         /* Write the "value check-sum" */
2096         wr_u32b(v_stamp);
2097
2098         /* Write the "encoded checksum" */
2099         wr_u32b(x_stamp);
2100
2101
2102         /* Error in save */
2103         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
2104
2105         /* Successful save */
2106         return TRUE;
2107 }
2108
2109
2110 /*!
2111  * @brief ゲームプレイ中のフロア一時保存出力処理メインルーチン / Attempt to save the temporally saved-floor data
2112  * @param sf_ptr 保存フロア参照ポインタ
2113  * @param mode 保存オプション
2114  * @return なし
2115  */
2116 bool save_floor(saved_floor_type *sf_ptr, BIT_FLAGS mode)
2117 {
2118         FILE *old_fff = NULL;
2119         byte old_xor_byte = 0;
2120         u32b old_v_stamp = 0;
2121         u32b old_x_stamp = 0;
2122
2123         char floor_savefile[1024];
2124         int fd = -1;
2125         bool ok = FALSE;
2126
2127         if (!(mode & SLF_SECOND))
2128         {
2129 #ifdef SET_UID
2130 # ifdef SECURE
2131                 /* Get "games" permissions */
2132                 beGames();
2133 # endif
2134 #endif
2135         }
2136
2137         /* We have one file already opened */
2138         else
2139         {
2140                 /* Backup original values */
2141                 old_fff = fff;
2142                 old_xor_byte = xor_byte;
2143                 old_v_stamp = v_stamp;
2144                 old_x_stamp = x_stamp;
2145         }
2146
2147         /* New savefile */
2148         sprintf(floor_savefile, "%s.F%02d", savefile, (int)sf_ptr->savefile_id);
2149
2150         /* Grab permissions */
2151         safe_setuid_grab();
2152
2153         /* Remove it */
2154         fd_kill(floor_savefile);
2155
2156         /* Drop permissions */
2157         safe_setuid_drop();
2158
2159
2160         /* Attempt to save the player */
2161
2162         /* No file yet */
2163         fff = NULL;
2164
2165         /* File type is "SAVE" */
2166         FILE_TYPE(FILE_TYPE_SAVE);
2167
2168         /* Grab permissions */
2169         safe_setuid_grab();
2170
2171         /* Create the savefile */
2172         fd = fd_make(floor_savefile, 0644);
2173
2174         /* Drop permissions */
2175         safe_setuid_drop();
2176
2177         /* File is okay */
2178         if (fd >= 0)
2179         {
2180                 /* Close the "fd" */
2181                 (void)fd_close(fd);
2182
2183                 /* Grab permissions */
2184                 safe_setuid_grab();
2185
2186                 /* Open the savefile */
2187                 fff = my_fopen(floor_savefile, "wb");
2188
2189                 /* Drop permissions */
2190                 safe_setuid_drop();
2191
2192                 /* Successful open */
2193                 if (fff)
2194                 {
2195                         /* Write the savefile */
2196                         if (save_floor_aux(sf_ptr)) ok = TRUE;
2197
2198                         /* Attempt to close it */
2199                         if (my_fclose(fff)) ok = FALSE;
2200                 }
2201
2202                 /* Remove "broken" files */
2203                 if (!ok)
2204                 {
2205                         /* Grab permissions */
2206                         safe_setuid_grab();
2207
2208                         (void)fd_kill(floor_savefile);
2209
2210                         /* Drop permissions */
2211                         safe_setuid_drop();
2212                 }
2213         }
2214
2215         if (!(mode & SLF_SECOND))
2216         {
2217 #ifdef SET_UID
2218 # ifdef SECURE
2219                 /* Drop "games" permissions */
2220                 bePlayer();
2221 # endif
2222 #endif
2223         }
2224
2225         /* We have one file already opened */
2226         else
2227         {
2228                 /* Restore original values */
2229                 fff = old_fff;
2230                 xor_byte = old_xor_byte;
2231                 v_stamp = old_v_stamp;
2232                 x_stamp = old_x_stamp;
2233         }
2234
2235         /* Return the result */
2236         return ok;
2237 }