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