src/save.c

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