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