src/save.c

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