src/save.c

   1 /* File: save.c */
   2
   3 /*
   4  * Copyright (c) 1997 Ben Harrison, and others
   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 #include "angband.h"
  12
  13
  14
  15
  16 /*
  17  * Some "local" parameters, used to help write savefiles
  18  */
  19
  20 static FILE     *fff;           /* Current save "file" */
  21
  22 static byte     xor_byte;       /* Simple encryption */
  23
  24 static u32b     v_stamp = 0L;   /* A simple "checksum" on the actual values */
  25 static u32b     x_stamp = 0L;   /* A simple "checksum" on the encoded bytes */
  26
  27
  28
  29 /*
  30  * These functions place information into a savefile a byte at a time
  31  */
  32
  33 static void sf_put(byte v)
  34 {
  35         /* Encode the value, write a character */
  36         xor_byte ^= v;
  37         (void)putc((int)xor_byte, fff);
  38
  39         /* Maintain the checksum info */
  40         v_stamp += v;
  41         x_stamp += xor_byte;
  42 }
  43
  44 static void wr_byte(byte v)
  45 {
  46         sf_put(v);
  47 }
  48
  49 static void wr_u16b(u16b v)
  50 {
  51         sf_put((byte)(v & 0xFF));
  52         sf_put((byte)((v >> 8) & 0xFF));
  53 }
  54
  55 static void wr_s16b(s16b v)
  56 {
  57         wr_u16b((u16b)v);
  58 }
  59
  60 static void wr_u32b(u32b v)
  61 {
  62         sf_put((byte)(v & 0xFF));
  63         sf_put((byte)((v >> 8) & 0xFF));
  64         sf_put((byte)((v >> 16) & 0xFF));
  65         sf_put((byte)((v >> 24) & 0xFF));
  66 }
  67
  68 static void wr_s32b(s32b v)
  69 {
  70         wr_u32b((u32b)v);
  71 }
  72
  73 static void wr_string(cptr str)
  74 {
  75         while (*str)
  76         {
  77                 wr_byte(*str);
  78                 str++;
  79         }
  80         wr_byte(*str);
  81 }
  82
  83
  84 /*
  85  * These functions write info in larger logical records
  86  */
  87
  88
  89 /*
  90  * Write an "item" record
  91  */
  92 static void wr_item(const object_type *o_ptr)
  93 {
  94         wr_s16b(o_ptr->k_idx);
  95
  96         /* Location */
  97         wr_byte(o_ptr->iy);
  98         wr_byte(o_ptr->ix);
  99
 100         wr_byte(o_ptr->tval);
 101         wr_byte(o_ptr->sval);
 102         wr_s16b(o_ptr->pval);
 103
 104         wr_byte(o_ptr->pseudo);
 105
 106         wr_byte(o_ptr->number);
 107         wr_s16b(o_ptr->weight);
 108
 109         wr_byte(o_ptr->name1);
 110         wr_byte(o_ptr->name2);
 111
 112         wr_s16b(o_ptr->timeout);
 113
 114         wr_s16b(o_ptr->to_h);
 115         wr_s16b(o_ptr->to_d);
 116         wr_s16b(o_ptr->to_a);
 117         wr_s16b(o_ptr->ac);
 118         wr_byte(o_ptr->dd);
 119         wr_byte(o_ptr->ds);
 120
 121         wr_byte(o_ptr->ident);
 122
 123         wr_byte(o_ptr->marked);
 124
 125         /* Old flags */
 126         wr_u32b(0L);
 127         wr_u32b(0L);
 128         wr_u32b(0L);
 129
 130         /* Held by monster index */
 131         wr_s16b(o_ptr->held_m_idx);
 132
 133         /* Extra information */
 134         wr_byte(o_ptr->xtra1);
 135         wr_byte(o_ptr->xtra2);
 136
 137         /* Save the inscription (if any) */
 138         if (o_ptr->note)
 139         {
 140                 wr_string(quark_str(o_ptr->note));
 141         }
 142         else
 143         {
 144                 wr_string("");
 145         }
 146 }
 147
 148
 149 /*
 150  * Write a "monster" record
 151  */
 152 static void wr_monster(const monster_type *m_ptr)
 153 {
 154         wr_s16b(m_ptr->r_idx);
 155         wr_byte(m_ptr->fy);
 156         wr_byte(m_ptr->fx);
 157         wr_s16b(m_ptr->hp);
 158         wr_s16b(m_ptr->maxhp);
 159         wr_s16b(m_ptr->csleep);
 160         wr_byte(m_ptr->mspeed);
 161         wr_byte(m_ptr->energy);
 162         wr_byte(m_ptr->stunned);
 163         wr_byte(m_ptr->confused);
 164         wr_byte(m_ptr->monfear);
 165         wr_byte(0);
 166 }
 167
 168
 169 /*
 170  * Write a "lore" record
 171  */
 172 static void wr_lore(int r_idx)
 173 {
 174         int i;
 175
 176         monster_race *r_ptr = &r_info[r_idx];
 177         monster_lore *l_ptr = &l_list[r_idx];
 178
 179         /* Count sights/deaths/kills */
 180         wr_s16b(l_ptr->sights);
 181         wr_s16b(l_ptr->deaths);
 182         wr_s16b(l_ptr->pkills);
 183         wr_s16b(l_ptr->tkills);
 184
 185         /* Count wakes and ignores */
 186         wr_byte(l_ptr->wake);
 187         wr_byte(l_ptr->ignore);
 188
 189         /* Extra stuff */
 190         wr_byte(l_ptr->xtra1);
 191         wr_byte(l_ptr->xtra2);
 192
 193         /* Count drops */
 194         wr_byte(l_ptr->drop_gold);
 195         wr_byte(l_ptr->drop_item);
 196
 197         /* Count spells */
 198         wr_byte(l_ptr->cast_innate);
 199         wr_byte(l_ptr->cast_spell);
 200
 201         /* Count blows of each type */
 202         for (i = 0; i < MONSTER_BLOW_MAX; i++)
 203                 wr_byte(l_ptr->blows[i]);
 204
 205         /* Memorize flags */
 206         wr_u32b(l_ptr->flags1);
 207         wr_u32b(l_ptr->flags2);
 208         wr_u32b(l_ptr->flags3);
 209         wr_u32b(l_ptr->flags4);
 210         wr_u32b(l_ptr->flags5);
 211         wr_u32b(l_ptr->flags6);
 212
 213
 214         /* Monster limit per level */
 215         wr_byte(r_ptr->max_num);
 216
 217         /* Later (?) */
 218         wr_byte(0);
 219         wr_byte(0);
 220         wr_byte(0);
 221 }
 222
 223
 224 /*
 225  * Write an "xtra" record
 226  */
 227 static void wr_xtra(int k_idx)
 228 {
 229         byte tmp8u = 0;
 230
 231         object_kind *k_ptr = &k_info[k_idx];
 232
 233         if (k_ptr->aware) tmp8u |= 0x01;
 234         if (k_ptr->tried) tmp8u |= 0x02;
 235         if (k_ptr->squelch) tmp8u |= 0x04;
 236         if (k_ptr->everseen) tmp8u |= 0x08;
 237
 238         wr_byte(tmp8u);
 239 }
 240
 241
 242 /*
 243  * Write a "store" record
 244  */
 245 static void wr_store(const store_type *st_ptr)
 246 {
 247         int j;
 248
 249         /* XXX Old value (<= Angband 3.0.3) */
 250         wr_u32b(0L);
 251
 252         /* XXX Old value (<= Angband 3.0.3) */
 253         wr_s16b(0);
 254
 255         /* Save the current owner */
 256         wr_byte(st_ptr->owner);
 257
 258         /* Save the stock size */
 259         wr_byte(st_ptr->stock_num);
 260
 261         /* XXX Old values (<= Angband 3.0.3) */
 262         wr_s16b(0);
 263         wr_s16b(0);
 264
 265         /* Save the stock */
 266         for (j = 0; j < st_ptr->stock_num; j++)
 267         {
 268                 /* Save each item in stock */
 269                 wr_item(&st_ptr->stock[j]);
 270         }
 271 }
 272
 273
 274 /*
 275  * Write RNG state
 276  */
 277 static errr wr_randomizer(void)
 278 {
 279         int i;
 280
 281         /* Zero */
 282         wr_u16b(0);
 283
 284         /* Place */
 285         wr_u16b(Rand_place);
 286
 287         /* State */
 288         for (i = 0; i < RAND_DEG; i++)
 289         {
 290                 wr_u32b(Rand_state[i]);
 291         }
 292
 293         /* Success */
 294         return (0);
 295 }
 296
 297
 298 /*
 299  * Write the "options"
 300  */
 301 static void wr_options(void)
 302 {
 303         int i, k;
 304
 305         u32b flag[8];
 306         u32b mask[8];
 307         u32b window_flag[ANGBAND_TERM_MAX];
 308         u32b window_mask[ANGBAND_TERM_MAX];
 309
 310
 311         /*** Oops ***/
 312
 313         /* Oops */
 314         for (i = 0; i < 4; i++) wr_u32b(0L);
 315
 316
 317         /*** Special Options ***/
 318
 319         /* Write "delay_factor" */
 320         wr_byte(op_ptr->delay_factor);
 321
 322         /* Write "hitpoint_warn" */
 323         wr_byte(op_ptr->hitpoint_warn);
 324
 325         wr_u16b(0);     /* oops */
 326
 327
 328         /*** Normal options ***/
 329
 330         /* Reset */
 331         for (i = 0; i < 8; i++)
 332         {
 333                 flag[i] = 0L;
 334                 mask[i] = 0L;
 335         }
 336
 337         /* Analyze the options */
 338         for (i = 0; i < OPT_MAX; i++)
 339         {
 340                 int os = i / 32;
 341                 int ob = i % 32;
 342
 343                 /* Process real entries */
 344                 if (option_text[i])
 345                 {
 346                         /* Set flag */
 347                         if (op_ptr->opt[i])
 348                         {
 349                                 /* Set */
 350                                 flag[os] |= (1L << ob);
 351                         }
 352
 353                         /* Set mask */
 354                         mask[os] |= (1L << ob);
 355                 }
 356         }
 357
 358         /* Dump the flags */
 359         for (i = 0; i < 8; i++) wr_u32b(flag[i]);
 360
 361         /* Dump the masks */
 362         for (i = 0; i < 8; i++) wr_u32b(mask[i]);
 363
 364
 365         /*** Window options ***/
 366
 367         /* Reset */
 368         for (i = 0; i < ANGBAND_TERM_MAX; i++)
 369         {
 370                 /* Flags */
 371                 window_flag[i] = op_ptr->window_flag[i];
 372
 373                 /* Mask */
 374                 window_mask[i] = 0L;
 375
 376                 /* Build the mask */
 377                 for (k = 0; k < 32; k++)
 378                 {
 379                         /* Set mask */
 380                         if (window_flag_desc[k])
 381                         {
 382                                 window_mask[i] |= (1L << k);
 383                         }
 384                 }
 385         }
 386
 387         /* Dump the flags */
 388         for (i = 0; i < ANGBAND_TERM_MAX; i++) wr_u32b(window_flag[i]);
 389
 390         /* Dump the masks */
 391         for (i = 0; i < ANGBAND_TERM_MAX; i++) wr_u32b(window_mask[i]);
 392 }
 393
 394
 395 /*
 396  * Hack -- Write the "ghost" info
 397  */
 398 static void wr_ghost(void)
 399 {
 400         int i;
 401
 402         /* Name */
 403         wr_string("Broken Ghost");
 404
 405         /* Hack -- stupid data */
 406         for (i = 0; i < 60; i++) wr_byte(0);
 407 }
 408
 409
 410 /*
 411  * Write autoinscribe & squelch item-quality submenu to the savefile
 412  */
 413 static void wr_squelch(void)
 414 {
 415         int i;
 416
 417         /* Write number of squelch bytes */
 418         wr_byte(SQUELCH_BYTES);
 419         for (i = 0; i < SQUELCH_BYTES; i++)
 420                 wr_byte(squelch_level[i]);
 421
 422         /* Write ego-item squelch bits */
 423         wr_u16b(z_info->e_max);
 424         for (i = 0; i < z_info->e_max; i++)
 425         {
 426                 byte flags = 0;
 427
 428                 /* Figure out and write the everseen flag */
 429                 if (e_info[i].everseen) flags |= 0x02;
 430                 wr_byte(flags);
 431         }
 432
 433         /* Write the current number of auto-inscriptions */
 434         wr_u16b(inscriptions_count);
 435
 436         /* Write the autoinscriptions array */
 437         for (i = 0; i < inscriptions_count; i++)
 438         {
 439                 wr_s16b(inscriptions[i].kind_idx);
 440                 wr_string(quark_str(inscriptions[i].inscription_idx));
 441         }
 442
 443         return;
 444 }
 445
 446
 447 /*
 448  * Write some "extra" info
 449  */
 450 static void wr_extra(void)
 451 {
 452         int i;
 453
 454         wr_string(op_ptr->full_name);
 455
 456         wr_string(p_ptr->died_from);
 457
 458         wr_string(p_ptr->history);
 459
 460         /* Race/Class/Gender/Spells */
 461         wr_byte(p_ptr->prace);
 462         wr_byte(p_ptr->pclass);
 463         wr_byte(p_ptr->psex);
 464         wr_byte(0);     /* oops */
 465
 466         wr_byte(p_ptr->hitdie);
 467         wr_byte(p_ptr->expfact);
 468
 469         wr_s16b(p_ptr->age);
 470         wr_s16b(p_ptr->ht);
 471         wr_s16b(p_ptr->wt);
 472
 473         /* Dump the stats (maximum and current) */
 474         for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_max[i]);
 475         for (i = 0; i < A_MAX; ++i) wr_s16b(p_ptr->stat_cur[i]);
 476
 477         /* Ignore the transient stats */
 478         for (i = 0; i < 12; ++i) wr_s16b(0);
 479
 480         wr_u32b(p_ptr->au);
 481
 482         wr_u32b(p_ptr->max_exp);
 483         wr_u32b(p_ptr->exp);
 484         wr_u16b(p_ptr->exp_frac);
 485         wr_s16b(p_ptr->lev);
 486
 487         wr_s16b(p_ptr->mhp);
 488         wr_s16b(p_ptr->chp);
 489         wr_u16b(p_ptr->chp_frac);
 490
 491         wr_s16b(p_ptr->msp);
 492         wr_s16b(p_ptr->csp);
 493         wr_u16b(p_ptr->csp_frac);
 494
 495         /* Max Player and Dungeon Levels */
 496         wr_s16b(p_ptr->max_lev);
 497         wr_s16b(p_ptr->max_depth);
 498
 499         /* More info */
 500         wr_s16b(0);     /* oops */
 501         wr_s16b(0);     /* oops */
 502         wr_s16b(0);     /* oops */
 503         wr_s16b(0);     /* oops */
 504         wr_s16b(p_ptr->sc);
 505         wr_s16b(0);     /* oops */
 506
 507         wr_s16b(p_ptr->food);
 508         wr_s16b(p_ptr->energy);
 509         wr_s16b(p_ptr->word_recall);
 510         wr_s16b(p_ptr->see_infra);
 511         wr_byte(p_ptr->confusing);
 512         wr_byte(p_ptr->searching);
 513
 514         /* Find the number of timed effects */
 515         wr_byte(TMD_MAX);
 516
 517         /* Read all the effects, in a loop */
 518         for (i = 0; i < TMD_MAX; i++)
 519                 wr_s16b(p_ptr->timed[i]);
 520
 521         /* Future use */
 522         for (i = 0; i < 10; i++) wr_u32b(0L);
 523
 524         wr_squelch();
 525
 526         /* Random artifact version */
 527         wr_u32b(RANDART_VERSION);
 528
 529         /* Random artifact seed */
 530         wr_u32b(seed_randart);
 531
 532
 533         /* Ignore some flags */
 534         wr_u32b(0L);    /* oops */
 535         wr_u32b(0L);    /* oops */
 536         wr_u32b(0L);    /* oops */
 537
 538
 539         /* Write the "object seeds" */
 540         wr_u32b(seed_flavor);
 541         wr_u32b(seed_town);
 542
 543
 544         /* Special stuff */
 545         wr_u16b(p_ptr->panic_save);
 546         wr_u16b(p_ptr->total_winner);
 547         wr_u16b(p_ptr->noscore);
 548
 549
 550         /* Write death */
 551         wr_byte(p_ptr->is_dead);
 552
 553         /* Write feeling */
 554         wr_byte(feeling);
 555
 556         /* Turn of last "feeling" */
 557         wr_s32b(old_turn);
 558
 559         /* Current turn */
 560         wr_s32b(turn);
 561 }
 562
 563
 564 /*
 565  * Dump the random artifacts
 566  */
 567 static void wr_randarts(void)
 568 {
 569         int i;
 570
 571         wr_u16b(z_info->a_max);
 572
 573         for (i = 0; i < z_info->a_max; i++)
 574         {
 575                 artifact_type *a_ptr = &a_info[i];
 576
 577                 wr_byte(a_ptr->tval);
 578                 wr_byte(a_ptr->sval);
 579                 wr_s16b(a_ptr->pval);
 580
 581                 wr_s16b(a_ptr->to_h);
 582                 wr_s16b(a_ptr->to_d);
 583                 wr_s16b(a_ptr->to_a);
 584                 wr_s16b(a_ptr->ac);
 585
 586                 wr_byte(a_ptr->dd);
 587                 wr_byte(a_ptr->ds);
 588
 589                 wr_s16b(a_ptr->weight);
 590
 591                 wr_s32b(a_ptr->cost);
 592
 593                 wr_u32b(a_ptr->flags1);
 594                 wr_u32b(a_ptr->flags2);
 595                 wr_u32b(a_ptr->flags3);
 596
 597                 wr_byte(a_ptr->level);
 598                 wr_byte(a_ptr->rarity);
 599
 600                 wr_byte(a_ptr->activation);
 601                 wr_u16b(a_ptr->time);
 602                 wr_u16b(a_ptr->randtime);
 603         }
 604 }
 605
 606
 607 /*
 608  * The cave grid flags that get saved in the savefile
 609  */
 610 #define IMPORTANT_FLAGS (CAVE_MARK | CAVE_GLOW | CAVE_ICKY | CAVE_ROOM)
 611
 612
 613 /*
 614  * Write the current dungeon
 615  */
 616 static void wr_dungeon(void)
 617 {
 618         int i, y, x;
 619
 620         byte tmp8u;
 621
 622         byte count;
 623         byte prev_char;
 624
 625
 626         /*** Basic info ***/
 627
 628         /* Dungeon specific info follows */
 629         wr_u16b(p_ptr->depth);
 630         wr_u16b(0);
 631         wr_u16b(p_ptr->py);
 632         wr_u16b(p_ptr->px);
 633         wr_u16b(DUNGEON_HGT);
 634         wr_u16b(DUNGEON_WID);
 635         wr_u16b(0);
 636         wr_u16b(0);
 637
 638
 639         /*** Simple "Run-Length-Encoding" of cave ***/
 640
 641         /* Note that this will induce two wasted bytes */
 642         count = 0;
 643         prev_char = 0;
 644
 645         /* Dump the cave */
 646         for (y = 0; y < DUNGEON_HGT; y++)
 647         {
 648                 for (x = 0; x < DUNGEON_WID; x++)
 649                 {
 650                         /* Extract the important cave_info flags */
 651                         tmp8u = (cave_info[y][x] & (IMPORTANT_FLAGS));
 652
 653                         /* If the run is broken, or too full, flush it */
 654                         if ((tmp8u != prev_char) || (count == MAX_UCHAR))
 655                         {
 656                                 wr_byte((byte)count);
 657                                 wr_byte((byte)prev_char);
 658                                 prev_char = tmp8u;
 659                                 count = 1;
 660                         }
 661
 662                         /* Continue the run */
 663                         else
 664                         {
 665                                 count++;
 666                         }
 667                 }
 668         }
 669
 670         /* Flush the data (if any) */
 671         if (count)
 672         {
 673                 wr_byte((byte)count);
 674                 wr_byte((byte)prev_char);
 675         }
 676
 677
 678         /*** Simple "Run-Length-Encoding" of cave ***/
 679
 680         /* Note that this will induce two wasted bytes */
 681         count = 0;
 682         prev_char = 0;
 683
 684         /* Dump the cave */
 685         for (y = 0; y < DUNGEON_HGT; y++)
 686         {
 687                 for (x = 0; x < DUNGEON_WID; x++)
 688                 {
 689                         /* Extract a byte */
 690                         tmp8u = cave_feat[y][x];
 691
 692                         /* If the run is broken, or too full, flush it */
 693                         if ((tmp8u != prev_char) || (count == MAX_UCHAR))
 694                         {
 695                                 wr_byte((byte)count);
 696                                 wr_byte((byte)prev_char);
 697                                 prev_char = tmp8u;
 698                                 count = 1;
 699                         }
 700
 701                         /* Continue the run */
 702                         else
 703                         {
 704                                 count++;
 705                         }
 706                 }
 707         }
 708
 709         /* Flush the data (if any) */
 710         if (count)
 711         {
 712                 wr_byte((byte)count);
 713                 wr_byte((byte)prev_char);
 714         }
 715
 716
 717         /*** Compact ***/
 718
 719         /* Compact the objects */
 720         compact_objects(0);
 721
 722         /* Compact the monsters */
 723         compact_monsters(0);
 724
 725
 726         /*** Dump objects ***/
 727
 728         /* Total objects */
 729         wr_u16b(o_max);
 730
 731         /* Dump the objects */
 732         for (i = 1; i < o_max; i++)
 733         {
 734                 object_type *o_ptr = &o_list[i];
 735
 736                 /* Dump it */
 737                 wr_item(o_ptr);
 738         }
 739
 740
 741         /*** Dump the monsters ***/
 742
 743         /* Total monsters */
 744         wr_u16b(mon_max);
 745
 746         /* Dump the monsters */
 747         for (i = 1; i < mon_max; i++)
 748         {
 749                 monster_type *m_ptr = &mon_list[i];
 750
 751                 /* Dump it */
 752                 wr_monster(m_ptr);
 753         }
 754 }
 755
 756
 757
 758 /*
 759  * Actually write a save-file
 760  */
 761 static bool wr_savefile_new(void)
 762 {
 763         int i;
 764
 765         u32b now;
 766
 767         u16b tmp16u;
 768
 769
 770         /* Guess at the current time */
 771         now = time((time_t *)0);
 772
 773
 774         /* Note the operating system */
 775         sf_xtra = 0L;
 776
 777         /* Note when the file was saved */
 778         sf_when = now;
 779
 780         /* Note the number of saves */
 781         sf_saves++;
 782
 783
 784         /*** Actually write the file ***/
 785
 786         /* Dump the file header */
 787         xor_byte = 0;
 788         wr_byte(VERSION_MAJOR);
 789         xor_byte = 0;
 790         wr_byte(VERSION_MINOR);
 791         xor_byte = 0;
 792         wr_byte(VERSION_PATCH);
 793         xor_byte = 0;
 794         wr_byte(VERSION_EXTRA);
 795
 796
 797         /* Reset the checksum */
 798         v_stamp = 0L;
 799         x_stamp = 0L;
 800
 801
 802         /* Operating system */
 803         wr_u32b(sf_xtra);
 804
 805
 806         /* Time file last saved */
 807         wr_u32b(sf_when);
 808
 809         /* Number of past lives */
 810         wr_u16b(sf_lives);
 811
 812         /* Number of times saved */
 813         wr_u16b(sf_saves);
 814
 815
 816         /* Space */
 817         wr_u32b(0L);
 818         wr_u32b(0L);
 819
 820
 821         /* Write the RNG state */
 822         wr_randomizer();
 823
 824
 825         /* Write the boolean "options" */
 826         wr_options();
 827
 828
 829         /* Dump the number of "messages" */
 830         tmp16u = message_num();
 831         if (tmp16u > 80) tmp16u = 80;
 832         wr_u16b(tmp16u);
 833
 834         /* Dump the messages (oldest first!) */
 835         for (i = tmp16u - 1; i >= 0; i--)
 836         {
 837                 wr_string(message_str((s16b)i));
 838                 wr_u16b(message_type((s16b)i));
 839         }
 840
 841
 842         /* Dump the monster lore */
 843         tmp16u = z_info->r_max;
 844         wr_u16b(tmp16u);
 845         for (i = 0; i < tmp16u; i++) wr_lore(i);
 846
 847
 848         /* Dump the object memory */
 849         tmp16u = z_info->k_max;
 850         wr_u16b(tmp16u);
 851         for (i = 0; i < tmp16u; i++) wr_xtra(i);
 852
 853
 854         /* Hack -- Dump the quests */
 855         tmp16u = MAX_Q_IDX;
 856         wr_u16b(tmp16u);
 857         for (i = 0; i < tmp16u; i++)
 858         {
 859                 wr_byte(q_list[i].level);
 860                 wr_byte(0);
 861                 wr_byte(0);
 862                 wr_byte(0);
 863         }
 864
 865         /* Hack -- Dump the artifacts */
 866         tmp16u = z_info->a_max;
 867         wr_u16b(tmp16u);
 868         for (i = 0; i < tmp16u; i++)
 869         {
 870                 artifact_type *a_ptr = &a_info[i];
 871                 wr_byte(a_ptr->cur_num);
 872                 wr_byte(0);
 873                 wr_byte(0);
 874                 wr_byte(0);
 875         }
 876
 877
 878         /* Write the "extra" information */
 879         wr_extra();
 880
 881
 882         /* Dump the "player hp" entries */
 883         tmp16u = PY_MAX_LEVEL;
 884         wr_u16b(tmp16u);
 885         for (i = 0; i < tmp16u; i++)
 886         {
 887                 wr_s16b(p_ptr->player_hp[i]);
 888         }
 889
 890
 891         /* Write spell data */
 892         wr_u16b(PY_MAX_SPELLS);
 893
 894         for (i = 0; i < PY_MAX_SPELLS; i++)
 895         {
 896                 wr_byte(p_ptr->spell_flags[i]);
 897         }
 898
 899         /* Dump the ordered spells */
 900         for (i = 0; i < PY_MAX_SPELLS; i++)
 901         {
 902                 wr_byte(p_ptr->spell_order[i]);
 903         }
 904
 905
 906         /* Write randart information */
 907         if (adult_randarts)
 908         {
 909                 wr_randarts();
 910         }
 911
 912
 913         /* Write the inventory */
 914         for (i = 0; i < INVEN_TOTAL; i++)
 915         {
 916                 object_type *o_ptr = &inventory[i];
 917
 918                 /* Skip non-objects */
 919                 if (!o_ptr->k_idx) continue;
 920
 921                 /* Dump index */
 922                 wr_u16b((u16b)i);
 923
 924                 /* Dump object */
 925                 wr_item(o_ptr);
 926         }
 927
 928         /* Add a sentinel */
 929         wr_u16b(0xFFFF);
 930
 931
 932         /* Note the stores */
 933         tmp16u = MAX_STORES;
 934         wr_u16b(tmp16u);
 935
 936         /* Dump the stores */
 937         for (i = 0; i < tmp16u; i++) wr_store(&store[i]);
 938
 939
 940         /* Player is not dead, write the dungeon */
 941         if (!p_ptr->is_dead)
 942         {
 943                 /* Dump the dungeon */
 944                 wr_dungeon();
 945
 946                 /* Dump the ghost */
 947                 wr_ghost();
 948         }
 949
 950
 951         /* Write the "value check-sum" */
 952         wr_u32b(v_stamp);
 953
 954         /* Write the "encoded checksum" */
 955         wr_u32b(x_stamp);
 956
 957
 958         /* Error in save */
 959         if (ferror(fff) || (fflush(fff) == EOF)) return FALSE;
 960
 961         /* Successful save */
 962         return TRUE;
 963 }
 964
 965
 966 /*
 967  * Medium level player saver
 968  */
 969 static bool save_player_aux(cptr name)
 970 {
 971         bool ok = FALSE;
 972
 973         int fd;
 974
 975         int mode = 0644;
 976
 977
 978         /* No file yet */
 979         fff = NULL;
 980
 981
 982         /* File type is "SAVE" */
 983         FILE_TYPE(FILE_TYPE_SAVE);
 984
 985
 986         /* Grab permissions */
 987         safe_setuid_grab();
 988
 989         /* Create the savefile */
 990         fd = fd_make(name, mode);
 991
 992         /* Drop permissions */
 993         safe_setuid_drop();
 994
 995         /* File is okay */
 996         if (fd >= 0)
 997         {
 998                 /* Close the "fd" */
 999                 fd_close(fd);
1000
1001                 /* Grab permissions */
1002                 safe_setuid_grab();
1003
1004                 /* Open the savefile */
1005                 fff = my_fopen(name, "wb");
1006
1007                 /* Drop permissions */
1008                 safe_setuid_drop();
1009
1010                 /* Successful open */
1011                 if (fff)
1012                 {
1013                         /* Write the savefile */
1014                         if (wr_savefile_new()) ok = TRUE;
1015
1016                         /* Attempt to close it */
1017                         if (my_fclose(fff)) ok = FALSE;
1018                 }
1019
1020                 /* Grab permissions */
1021                 safe_setuid_grab();
1022
1023                 /* Remove "broken" files */
1024                 if (!ok) fd_kill(name);
1025
1026                 /* Drop permissions */
1027                 safe_setuid_drop();
1028         }
1029
1030
1031         /* Failure */
1032         if (!ok) return (FALSE);
1033
1034         /* Successful save */
1035         character_saved = TRUE;
1036
1037         /* Success */
1038         return (TRUE);
1039 }
1040
1041
1042
1043 /*
1044  * Attempt to save the player in a savefile
1045  */
1046 bool save_player(void)
1047 {
1048         int result = FALSE;
1049
1050         char safe[1024];
1051
1052
1053         /* New savefile */
1054         my_strcpy(safe, savefile, sizeof(safe));
1055         my_strcat(safe, ".new", sizeof(safe));
1056
1057         /* Grab permissions */
1058         safe_setuid_grab();
1059
1060         /* Remove it */
1061         fd_kill(safe);
1062
1063         /* Drop permissions */
1064         safe_setuid_drop();
1065
1066         /* Attempt to save the player */
1067         if (save_player_aux(safe))
1068         {
1069                 char temp[1024];
1070
1071                 /* Old savefile */
1072                 my_strcpy(temp, savefile, sizeof(temp));
1073                 my_strcat(temp, ".old", sizeof(temp));
1074
1075                 /* Grab permissions */
1076                 safe_setuid_grab();
1077
1078                 /* Remove it */
1079                 fd_kill(temp);
1080
1081                 /* Preserve old savefile */
1082                 fd_move(savefile, temp);
1083
1084                 /* Activate new savefile */
1085                 fd_move(safe, savefile);
1086
1087                 /* Remove preserved savefile */
1088                 fd_kill(temp);
1089
1090                 /* Drop permissions */
1091                 safe_setuid_drop();
1092
1093                 /* Success */
1094                 result = TRUE;
1095         }
1096
1097
1098         /* Return the result */
1099         return (result);
1100 }