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         int fd = -1;
1564         int mode = 0644;
1565
1566         /* No file yet */
1567         fff = NULL;
1568
1569         /* File type is "SAVE" */
1570         FILE_TYPE(FILE_TYPE_SAVE);
1571
1572         /* Grab permissions */
1573         safe_setuid_grab();
1574
1575         /* Create the savefile */
1576         fd = fd_make(name, mode);
1577
1578         /* Drop permissions */
1579         safe_setuid_drop();
1580
1581         /* File is okay */
1582         if (fd >= 0)
1583         {
1584                 /* Close the "fd" */
1585                 (void)fd_close(fd);
1586
1587                 /* Grab permissions */
1588                 safe_setuid_grab();
1589
1590                 /* Open the savefile */
1591                 fff = my_fopen(name, "wb");
1592
1593                 /* Drop permissions */
1594                 safe_setuid_drop();
1595
1596                 /* Successful open */
1597                 if (fff)
1598                 {
1599                         /* Write the savefile */
1600                         if (wr_savefile_new()) ok = TRUE;
1601
1602                         /* Attempt to close it */
1603                         if (my_fclose(fff)) ok = FALSE;
1604                 }
1605
1606                 /* Grab permissions */
1607                 safe_setuid_grab();
1608
1609                 /* Remove "broken" files */
1610                 if (!ok) (void)fd_kill(name);
1611
1612                 /* Drop permissions */
1613                 safe_setuid_drop();
1614         }
1615
1616
1617         /* Failure */
1618         if (!ok) return (FALSE);
1619
1620         counts_write(0, playtime);
1621
1622         /* Successful save */
1623         character_saved = TRUE;
1624
1625         /* Success */
1626         return (TRUE);
1627 }
1628
1629
1630
1631 /*!
1632  * @brief セーブデータ書き込みのメインルーチン /
1633  * Attempt to save the player in a savefile
1634  * @return 成功すればtrue
1635  */
1636 bool save_player(void)
1637 {
1638         bool result = FALSE;
1639
1640         char safe[1024];
1641
1642
1643 #ifdef SET_UID
1644
1645 # ifdef SECURE
1646
1647         /* Get "games" permissions */
1648         beGames();
1649
1650 # endif
1651
1652 #endif
1653
1654
1655         /* New savefile */
1656         strcpy(safe, savefile);
1657         strcat(safe, ".new");
1658
1659         /* Grab permissions */
1660         safe_setuid_grab();
1661
1662         /* Remove it */
1663         fd_kill(safe);
1664
1665         /* Drop permissions */
1666         safe_setuid_drop();
1667
1668         update_playtime();
1669
1670         /* Attempt to save the player */
1671         if (save_player_aux(safe))
1672         {
1673                 char temp[1024];
1674
1675                 /* Old savefile */
1676                 strcpy(temp, savefile);
1677                 strcat(temp, ".old");
1678
1679                 /* Grab permissions */
1680                 safe_setuid_grab();
1681
1682                 /* Remove it */
1683                 fd_kill(temp);
1684
1685                 /* Preserve old savefile */
1686                 fd_move(savefile, temp);
1687
1688                 /* Activate new savefile */
1689                 fd_move(safe, savefile);
1690
1691                 /* Remove preserved savefile */
1692                 fd_kill(temp);
1693
1694                 /* Drop permissions */
1695                 safe_setuid_drop();
1696
1697                 /* Hack -- Pretend the character was loaded */
1698                 character_loaded = TRUE;
1699
1700 #ifdef VERIFY_SAVEFILE
1701
1702                 /* Lock on savefile */
1703                 strcpy(temp, savefile);
1704                 strcat(temp, ".lok");
1705
1706                 /* Grab permissions */
1707                 safe_setuid_grab();
1708
1709                 /* Remove lock file */
1710                 fd_kill(temp);
1711
1712                 /* Drop permissions */
1713                 safe_setuid_drop();
1714
1715 #endif
1716
1717                 /* Success */
1718                 result = TRUE;
1719         }
1720
1721
1722 #ifdef SET_UID
1723
1724 # ifdef SECURE
1725
1726         /* Drop "games" permissions */
1727         bePlayer();
1728
1729 # endif
1730
1731 #endif
1732
1733         /* Return the result */
1734         return (result);
1735 }
1736
1737
1738 /*!
1739  * @brief セーブデータ読み込みのメインルーチン /
1740  * Attempt to Load a "savefile"
1741  * @return 成功すればtrue
1742  * @details
1743  * <pre>
1744  * Version 2.7.0 introduced a slightly different "savefile" format from
1745  * older versions, requiring a completely different parsing method.
1746  *
1747  * Note that savefiles from 2.7.0 - 2.7.2 are completely obsolete.
1748  *
1749  * Pre-2.8.0 savefiles lose some data, see "load2.c" for info.
1750  *
1751  * Pre-2.7.0 savefiles lose a lot of things, see "load1.c" for info.
1752  *
1753  * On multi-user systems, you may only "read" a savefile if you will be
1754  * allowed to "write" it later, this prevents painful situations in which
1755  * the player loads a savefile belonging to someone else, and then is not
1756  * allowed to save his game when he quits.
1757  *
1758  * We return "TRUE" if the savefile was usable, and we set the global
1759  * flag "character_loaded" if a real, living, character was loaded.
1760  *
1761  * Note that we always try to load the "current" savefile, even if
1762  * there is no such file, so we must check for "empty" savefile names.
1763  * </pre>
1764  */
1765 bool load_player(void)
1766 {
1767         int             fd = -1;
1768
1769         errr    err = 0;
1770
1771         byte    vvv[4];
1772
1773 #ifdef VERIFY_TIMESTAMP
1774         struct stat     statbuf;
1775 #endif
1776
1777         cptr    what = "generic";
1778
1779
1780         /* Paranoia */
1781         turn = 0;
1782
1783         /* Paranoia */
1784         p_ptr->is_dead = FALSE;
1785
1786
1787         /* Allow empty savefile name */
1788         if (!savefile[0]) return (TRUE);
1789
1790
1791 #if !defined(MACINTOSH) && !defined(WINDOWS)
1792
1793         /* Fix this */
1794
1795         /* Verify the existance of the savefile */
1796         if (access(savefile, 0) < 0)
1797         {
1798                 /* Give a message */
1799                 msg_print(_("セーブファイルがありません。", "Savefile does not exist."));
1800
1801                 msg_print(NULL);
1802
1803                 /* Allow this */
1804                 return (TRUE);
1805         }
1806
1807 #endif
1808
1809
1810 #ifdef VERIFY_SAVEFILE
1811
1812         /* Verify savefile usage */
1813         if (!err)
1814         {
1815                 FILE *fkk;
1816
1817                 char temp[1024];
1818
1819                 /* Extract name of lock file */
1820                 strcpy(temp, savefile);
1821                 strcat(temp, ".lok");
1822
1823                 /* Check for lock */
1824                 fkk = my_fopen(temp, "r");
1825
1826                 /* Oops, lock exists */
1827                 if (fkk)
1828                 {
1829                         /* Close the file */
1830                         my_fclose(fkk);
1831
1832                         msg_print(_("セーブファイルは現在使用中です。", "Savefile is currently in use."));
1833                         msg_print(NULL);
1834
1835                         return (FALSE);
1836                 }
1837
1838                 /* Create a lock file */
1839                 fkk = my_fopen(temp, "w");
1840
1841                 /* Dump a line of info */
1842                 fprintf(fkk, "Lock file for savefile '%s'\n", savefile);
1843
1844                 /* Close the lock file */
1845                 my_fclose(fkk);
1846         }
1847
1848 #endif
1849
1850
1851         if (!err)
1852         {
1853                 /* Open the savefile */
1854                 fd = fd_open(savefile, O_RDONLY);
1855
1856                 /* No file */
1857                 if (fd < 0) err = -1;
1858
1859                 /* Message (below) */
1860                 if (err) what = _("セーブファイルを開けません。", "Cannot open savefile");
1861         }
1862
1863         /* Process file */
1864         if (!err)
1865         {
1866
1867 #ifdef VERIFY_TIMESTAMP
1868                 /* Get the timestamp */
1869                 (void)fstat(fd, &statbuf);
1870 #endif
1871
1872                 /* Read the first four bytes */
1873                 if (fd_read(fd, (char*)(vvv), 4)) err = -1;
1874
1875                 /* What */
1876                 if (err) what = _("セーブファイルを読めません。", "Cannot read savefile");
1877
1878                 /* Close the file */
1879                 (void)fd_close(fd);
1880         }
1881
1882         /* Process file */
1883         if (!err)
1884         {
1885
1886                 /* Extract version */
1887                 z_major = vvv[0];
1888                 z_minor = vvv[1];
1889                 z_patch = vvv[2];
1890                 sf_extra = vvv[3];
1891
1892
1893                 /* Clear screen */
1894                 Term_clear();
1895
1896                 /* Attempt to load */
1897                 err = rd_savefile_new();
1898
1899                 /* Message (below) */
1900                 if (err) what = _("セーブファイルを解析出来ません。", "Cannot parse savefile");
1901         }
1902
1903         /* Paranoia */
1904         if (!err)
1905         {
1906                 /* Invalid turn */
1907                 if (!turn) err = -1;
1908
1909                 /* Message (below) */
1910                 if (err) what = _("セーブファイルが壊れています", "Broken savefile");
1911         }
1912
1913 #ifdef VERIFY_TIMESTAMP
1914         /* Verify timestamp */
1915         if (!err && !arg_wizard)
1916         {
1917                 /* Hack -- Verify the timestamp */
1918                 if (sf_when > (statbuf.st_ctime + 100) ||
1919                     sf_when < (statbuf.st_ctime - 100))
1920                 {
1921                         what = _("無効なタイム・スタンプです", "Invalid timestamp");
1922
1923                         err = -1;
1924                 }
1925         }
1926 #endif
1927
1928
1929         if (!err)
1930         {
1931                 /* Give a conversion warning */
1932                 if ((FAKE_VER_MAJOR != z_major) ||
1933                     (FAKE_VER_MINOR != z_minor) ||
1934                     (FAKE_VER_PATCH != z_patch))
1935                 {
1936                         if (z_major == 2 && z_minor == 0 && z_patch == 6)
1937                         {
1938                                 msg_print(_("バージョン 2.0.* 用のセーブファイルを変換しました。", "Converted a 2.0.* savefile."));
1939                         }
1940                         else
1941                         {
1942 #ifdef JP
1943                                 msg_format("バージョン %d.%d.%d 用のセーブ・ファイルを変換しました。",
1944                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1945 #else
1946                                 msg_format("Converted a %d.%d.%d savefile.",
1947                                     (z_major > 9) ? z_major-10 : z_major , z_minor, z_patch);
1948 #endif
1949                         }
1950                         msg_print(NULL);
1951                 }
1952
1953                 /* Player is dead */
1954                 if (p_ptr->is_dead)
1955                 {
1956                         /* Cheat death */
1957                         if (arg_wizard)
1958                         {
1959                                 /* A character was loaded */
1960                                 character_loaded = TRUE;
1961
1962                                 return (TRUE);
1963                         }
1964
1965                         /* Player is no longer "dead" */
1966                         p_ptr->is_dead = FALSE;
1967
1968                         /* Count lives */
1969                         sf_lives++;
1970
1971                         return (TRUE);
1972                 }
1973
1974                 /* A character was loaded */
1975                 character_loaded = TRUE;
1976
1977                 {
1978                         u32b tmp = counts_read(2);
1979                         if (tmp > p_ptr->count)
1980                                 p_ptr->count = tmp;
1981                         if (counts_read(0) > playtime || counts_read(1) == playtime)
1982                                 counts_write(2, ++p_ptr->count);
1983                         counts_write(1, playtime);
1984                 }
1985
1986                 /* Success */
1987                 return (TRUE);
1988         }
1989
1990
1991 #ifdef VERIFY_SAVEFILE
1992
1993         /* Verify savefile usage */
1994         if (TRUE)
1995         {
1996                 char temp[1024];
1997
1998                 /* Extract name of lock file */
1999                 strcpy(temp, savefile);
2000                 strcat(temp, ".lok");
2001
2002                 /* Remove lock */
2003                 fd_kill(temp);
2004         }
2005
2006 #endif
2007
2008
2009 #ifdef JP
2010         msg_format("エラー(%s)がバージョン%d.%d.%d 用セーブファイル読み込み中に発生。",
2011                    what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
2012 #else
2013         msg_format("Error (%s) reading %d.%d.%d savefile.",
2014                    what, (z_major>9) ? z_major - 10 : z_major, z_minor, z_patch);
2015 #endif
2016         msg_print(NULL);
2017
2018         return (FALSE);
2019 }
2020
2021 /*!
2022  * @brief ファイルロック処理
2023  * @return なし
2024  */
2025 void remove_loc(void)
2026 {
2027 #ifdef VERIFY_SAVEFILE
2028         char temp[1024];
2029 #endif /* VERIFY_SAVEFILE */
2030
2031 #ifdef SET_UID
2032 # ifdef SECURE
2033
2034         /* Get "games" permissions */
2035         beGames();
2036
2037 # endif /* SECURE */
2038 #endif /* SET_UID */
2039
2040 #ifdef VERIFY_SAVEFILE
2041
2042         /* Lock on savefile */
2043         strcpy(temp, savefile);
2044         strcat(temp, ".lok");
2045
2046         /* Remove lock file */
2047         fd_kill(temp);
2048
2049 #endif /* VERIFY_SAVEFILE */
2050
2051 #ifdef SET_UID
2052 # ifdef SECURE
2053
2054         /* Drop "games" permissions */
2055         bePlayer();
2056
2057 # endif /* SECURE */
2058 #endif /* SET_UID */
2059
2060 }
2061
2062
2063 /*!
2064  * @brief ゲームプレイ中のフロア一時保存出力処理サブルーチン / Actually write a temporal saved floor file
2065  * @param sf_ptr 保存フロア参照ポインタ
2066  * @return なし
2067  */
2068 static bool save_floor_aux(saved_floor_type *sf_ptr)
2069 {
2070         byte tmp8u;
2071
2072         /* Compact the objects */
2073         compact_objects(0);
2074         /* Compact the monsters */
2075         compact_monsters(0);
2076
2077
2078         /*** Actually write the file ***/
2079
2080         /* Initial value of xor_byte */
2081         tmp8u = (byte)randint0(256);
2082         xor_byte = 0;
2083         wr_byte(tmp8u);
2084
2085
2086         /* Reset the checksum */
2087         v_stamp = 0L;
2088         x_stamp = 0L;
2089
2090         /* Write the sign of this process */
2091         wr_u32b(saved_floor_file_sign);
2092
2093         /* Dump the dungeon floor */
2094         wr_saved_floor(sf_ptr);
2095
2096
2097         /* Write the "value check-sum" */
2098         wr_u32b(v_stamp);
2099
2100         /* Write the "encoded checksum" */
2101         wr_u32b(x_stamp);
2102
2103
2104         /* Error in save */
2105         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
2106
2107         /* Successful save */
2108         return TRUE;
2109 }
2110
2111
2112 /*!
2113  * @brief ゲームプレイ中のフロア一時保存出力処理メインルーチン / Attempt to save the temporally saved-floor data
2114  * @param sf_ptr 保存フロア参照ポインタ
2115  * @param mode 保存オプション
2116  * @return なし
2117  */
2118 bool save_floor(saved_floor_type *sf_ptr, BIT_FLAGS mode)
2119 {
2120         FILE *old_fff = NULL;
2121         byte old_xor_byte = 0;
2122         u32b old_v_stamp = 0;
2123         u32b old_x_stamp = 0;
2124
2125         char floor_savefile[1024];
2126         int fd = -1;
2127         bool ok = FALSE;
2128
2129         if (!(mode & SLF_SECOND))
2130         {
2131 #ifdef SET_UID
2132 # ifdef SECURE
2133                 /* Get "games" permissions */
2134                 beGames();
2135 # endif
2136 #endif
2137         }
2138
2139         /* We have one file already opened */
2140         else
2141         {
2142                 /* Backup original values */
2143                 old_fff = fff;
2144                 old_xor_byte = xor_byte;
2145                 old_v_stamp = v_stamp;
2146                 old_x_stamp = x_stamp;
2147         }
2148
2149         /* New savefile */
2150         sprintf(floor_savefile, "%s.F%02d", savefile, (int)sf_ptr->savefile_id);
2151
2152         /* Grab permissions */
2153         safe_setuid_grab();
2154
2155         /* Remove it */
2156         fd_kill(floor_savefile);
2157
2158         /* Drop permissions */
2159         safe_setuid_drop();
2160
2161
2162         /* Attempt to save the player */
2163
2164         /* No file yet */
2165         fff = NULL;
2166
2167         /* File type is "SAVE" */
2168         FILE_TYPE(FILE_TYPE_SAVE);
2169
2170         /* Grab permissions */
2171         safe_setuid_grab();
2172
2173         /* Create the savefile */
2174         fd = fd_make(floor_savefile, 0644);
2175
2176         /* Drop permissions */
2177         safe_setuid_drop();
2178
2179         /* File is okay */
2180         if (fd >= 0)
2181         {
2182                 /* Close the "fd" */
2183                 (void)fd_close(fd);
2184
2185                 /* Grab permissions */
2186                 safe_setuid_grab();
2187
2188                 /* Open the savefile */
2189                 fff = my_fopen(floor_savefile, "wb");
2190
2191                 /* Drop permissions */
2192                 safe_setuid_drop();
2193
2194                 /* Successful open */
2195                 if (fff)
2196                 {
2197                         /* Write the savefile */
2198                         if (save_floor_aux(sf_ptr)) ok = TRUE;
2199
2200                         /* Attempt to close it */
2201                         if (my_fclose(fff)) ok = FALSE;
2202                 }
2203
2204                 /* Remove "broken" files */
2205                 if (!ok)
2206                 {
2207                         /* Grab permissions */
2208                         safe_setuid_grab();
2209
2210                         (void)fd_kill(floor_savefile);
2211
2212                         /* Drop permissions */
2213                         safe_setuid_drop();
2214                 }
2215         }
2216
2217         if (!(mode & SLF_SECOND))
2218         {
2219 #ifdef SET_UID
2220 # ifdef SECURE
2221                 /* Drop "games" permissions */
2222                 bePlayer();
2223 # endif
2224 #endif
2225         }
2226
2227         /* We have one file already opened */
2228         else
2229         {
2230                 /* Restore original values */
2231                 fff = old_fff;
2232                 xor_byte = old_xor_byte;
2233                 v_stamp = old_v_stamp;
2234                 x_stamp = old_x_stamp;
2235         }
2236
2237         /* Return the result */
2238         return ok;
2239 }