src/save.c

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