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