base/sv_save.c

   1
   2 //**************************************************************************
   3 //**
   4 //** sv_save.c : Heretic 2 : Raven Software, Corp.
   5 //**
   6 //** $RCSfile$
   7 //** $Revision$
   8 //** $Date$
   9 //** $Author$
  10 //**
  11 //**************************************************************************
  12
  13 // HEADER FILES ------------------------------------------------------------
  14
  15 #include "h2def.h"
  16 #include "p_local.h"
  17
  18 // MACROS ------------------------------------------------------------------
  19
  20 #define MAX_TARGET_PLAYERS 512
  21 #define MOBJ_NULL -1
  22 #define MOBJ_XX_PLAYER -2
  23 #define GET_BYTE (*SavePtr.b++)
  24 #define GET_WORD (*SavePtr.w++)
  25 #define GET_LONG (*SavePtr.l++)
  26 #define MAX_MAPS 99
  27 #define BASE_SLOT 6
  28 #define REBORN_SLOT 7
  29 #define REBORN_DESCRIPTION "TEMP GAME"
  30 #define MAX_THINKER_SIZE 256
  31
  32 // TYPES -------------------------------------------------------------------
  33
  34 typedef enum
  35 {
  36         ASEG_GAME_HEADER = 101,
  37         ASEG_MAP_HEADER,
  38         ASEG_WORLD,
  39         ASEG_POLYOBJS,
  40         ASEG_MOBJS,
  41         ASEG_THINKERS,
  42         ASEG_SCRIPTS,
  43         ASEG_PLAYERS,
  44         ASEG_SOUNDS,
  45         ASEG_MISC,
  46         ASEG_END
  47 } gameArchiveSegment_t;
  48
  49 typedef enum
  50 {
  51         TC_NULL,
  52         TC_MOVE_CEILING,
  53         TC_VERTICAL_DOOR,
  54         TC_MOVE_FLOOR,
  55         TC_PLAT_RAISE,
  56         TC_INTERPRET_ACS,
  57         TC_FLOOR_WAGGLE,
  58         TC_LIGHT,
  59         TC_PHASE,
  60         TC_BUILD_PILLAR,
  61         TC_ROTATE_POLY,
  62         TC_MOVE_POLY,
  63         TC_POLY_DOOR
  64 } thinkClass_t;
  65
  66 typedef struct
  67 {
  68         thinkClass_t tClass;
  69         think_t thinkerFunc;
  70         void (*mangleFunc)();
  71         void (*restoreFunc)();
  72         size_t size;
  73 } thinkInfo_t;
  74
  75 typedef struct
  76 {
  77         thinker_t thinker;
  78         sector_t *sector;
  79 } ssthinker_t;
  80
  81 // EXTERNAL FUNCTION PROTOTYPES --------------------------------------------
  82
  83 void P_SpawnPlayer(mapthing_t *mthing);
  84
  85 // PUBLIC FUNCTION PROTOTYPES ----------------------------------------------
  86
  87 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
  88
  89 static void ArchiveWorld(void);
  90 static void UnarchiveWorld(void);
  91 static void ArchivePolyobjs(void);
  92 static void UnarchivePolyobjs(void);
  93 static void ArchiveMobjs(void);
  94 static void UnarchiveMobjs(void);
  95 static void ArchiveThinkers(void);
  96 static void UnarchiveThinkers(void);
  97 static void ArchiveScripts(void);
  98 static void UnarchiveScripts(void);
  99 static void ArchivePlayers(void);
 100 static void UnarchivePlayers(void);
 101 static void ArchiveSounds(void);
 102 static void UnarchiveSounds(void);
 103 static void ArchiveMisc(void);
 104 static void UnarchiveMisc(void);
 105 static void SetMobjArchiveNums(void);
 106 static void RemoveAllThinkers(void);
 107 static void MangleMobj(mobj_t *mobj);
 108 static void RestoreMobj(mobj_t *mobj);
 109 static int GetMobjNum(mobj_t *mobj);
 110 static void SetMobjPtr(int *archiveNum);
 111 static void MangleSSThinker(ssthinker_t *sst);
 112 static void RestoreSSThinker(ssthinker_t *sst);
 113 static void RestoreSSThinkerNoSD(ssthinker_t *sst);
 114 static void MangleScript(acs_t *script);
 115 static void RestoreScript(acs_t *script);
 116 static void RestorePlatRaise(plat_t *plat);
 117 static void RestoreMoveCeiling(ceiling_t *ceiling);
 118 static void AssertSegment(gameArchiveSegment_t segType);
 119 static void ClearSaveSlot(int slot);
 120 static void CopySaveSlot(int sourceSlot, int destSlot);
 121 static void CopyFile(char *sourceName, char *destName);
 122 static boolean ExistingFile(char *name);
 123 static void OpenStreamOut(char *fileName);
 124 static void CloseStreamOut(void);
 125 static void StreamOutBuffer(void *buffer, int size);
 126 static void StreamOutByte(byte val);
 127 static void StreamOutWord(unsigned short val);
 128 static void StreamOutLong(unsigned int val);
 129
 130 // EXTERNAL DATA DECLARATIONS ----------------------------------------------
 131
 132 extern int ACScriptCount;
 133 extern byte *ActionCodeBase;
 134 extern acsInfo_t *ACSInfo;
 135
 136 // PUBLIC DATA DEFINITIONS -------------------------------------------------
 137
 138 extern char *basePath;
 139
 140 // PRIVATE DATA DEFINITIONS ------------------------------------------------
 141
 142 static int MobjCount;
 143 static mobj_t **MobjList;
 144 static int **TargetPlayerAddrs;
 145 static int TargetPlayerCount;
 146 static byte *SaveBuffer;
 147 static boolean SavingPlayers;
 148 static union
 149 {
 150         byte *b;
 151         short *w;
 152         int *l;
 153 } SavePtr;
 154 static FILE *SavingFP;
 155
 156 // This list has been prioritized using frequency estimates
 157 static thinkInfo_t ThinkerInfo[] =
 158 {
 159         {
 160                 TC_MOVE_FLOOR,
 161                 T_MoveFloor,
 162                 MangleSSThinker,
 163                 RestoreSSThinker,
 164                 sizeof(floormove_t)
 165         },
 166         {
 167                 TC_PLAT_RAISE,
 168                 T_PlatRaise,
 169                 MangleSSThinker,
 170                 RestorePlatRaise,
 171                 sizeof(plat_t)
 172         },
 173         {
 174                 TC_MOVE_CEILING,
 175                 T_MoveCeiling,
 176                 MangleSSThinker,
 177                 RestoreMoveCeiling,
 178                 sizeof(ceiling_t)
 179         },
 180         {
 181                 TC_LIGHT,
 182                 T_Light,
 183                 MangleSSThinker,
 184                 RestoreSSThinkerNoSD,
 185                 sizeof(light_t)
 186         },
 187         {
 188                 TC_VERTICAL_DOOR,
 189                 T_VerticalDoor,
 190                 MangleSSThinker,
 191                 RestoreSSThinker,
 192                 sizeof(vldoor_t)
 193         },
 194         {
 195                 TC_PHASE,
 196                 T_Phase,
 197                 MangleSSThinker,
 198                 RestoreSSThinkerNoSD,
 199                 sizeof(phase_t)
 200         },
 201         {
 202                 TC_INTERPRET_ACS,
 203                 T_InterpretACS,
 204                 MangleScript,
 205                 RestoreScript,
 206                 sizeof(acs_t)
 207         },
 208         {
 209                 TC_ROTATE_POLY,
 210                 T_RotatePoly,
 211                 NULL,
 212                 NULL,
 213                 sizeof(polyevent_t)
 214         },
 215         {
 216                 TC_BUILD_PILLAR,
 217                 T_BuildPillar,
 218                 MangleSSThinker,
 219                 RestoreSSThinker,
 220                 sizeof(pillar_t)
 221         },
 222         {
 223                 TC_MOVE_POLY,
 224                 T_MovePoly,
 225                 NULL,
 226                 NULL,
 227                 sizeof(polyevent_t)
 228         },
 229         {
 230                 TC_POLY_DOOR,
 231                 T_PolyDoor,
 232                 NULL,
 233                 NULL,
 234                 sizeof(polydoor_t)
 235         },
 236         {
 237                 TC_FLOOR_WAGGLE,
 238                 T_FloorWaggle,
 239                 MangleSSThinker,
 240                 RestoreSSThinker,
 241                 sizeof(floorWaggle_t)
 242         },
 243         { // Terminator
 244                 TC_NULL, NULL, NULL, NULL, 0
 245         }
 246 };
 247
 248 // CODE --------------------------------------------------------------------
 249
 250 //==========================================================================
 251 //
 252 // SV_SaveGame
 253 //
 254 //==========================================================================
 255
 256 void SV_SaveGame(int slot, char *description)
 257 {
 258         char fileName[100];
 259         char versionText[HXS_VERSION_TEXT_LENGTH];
 260
 261         // Open the output file
 262         snprintf(fileName, 100, "%shex6.hxs", basePath);
 263         OpenStreamOut(fileName);
 264
 265         // Write game save description
 266         StreamOutBuffer(description, HXS_DESCRIPTION_LENGTH);
 267
 268         // Write version info
 269         memset(versionText, 0, HXS_VERSION_TEXT_LENGTH);
 270         strcpy(versionText, HXS_VERSION_TEXT);
 271         StreamOutBuffer(versionText, HXS_VERSION_TEXT_LENGTH);
 272
 273         // Place a header marker
 274         StreamOutLong(ASEG_GAME_HEADER);
 275
 276         // Write current map and difficulty
 277         StreamOutByte(gamemap);
 278         StreamOutByte(gameskill);
 279
 280         // Write global script info
 281         StreamOutBuffer(WorldVars, sizeof(WorldVars));
 282         StreamOutBuffer(ACSStore, sizeof(ACSStore));
 283
 284         ArchivePlayers();
 285
 286         // Place a termination marker
 287         StreamOutLong(ASEG_END);
 288
 289         // Close the output file
 290         CloseStreamOut();
 291
 292         // Save out the current map
 293         SV_SaveMap(true); // true = save player info
 294
 295         // Clear all save files at destination slot
 296         ClearSaveSlot(slot);
 297
 298         // Copy base slot to destination slot
 299         CopySaveSlot(BASE_SLOT, slot);
 300 }
 301
 302 //==========================================================================
 303 //
 304 // SV_SaveMap
 305 //
 306 //==========================================================================
 307
 308 void SV_SaveMap(boolean savePlayers)
 309 {
 310         char fileName[100];
 311
 312         SavingPlayers = savePlayers;
 313
 314         // Open the output file
 315         snprintf(fileName, 100, "%shex6%02d.hxs", basePath, gamemap);
 316         OpenStreamOut(fileName);
 317
 318         // Place a header marker
 319         StreamOutLong(ASEG_MAP_HEADER);
 320
 321         // Write the level timer
 322         StreamOutLong(leveltime);
 323
 324         // Set the mobj archive numbers
 325         SetMobjArchiveNums();
 326
 327         ArchiveWorld();
 328         ArchivePolyobjs();
 329         ArchiveMobjs();
 330         ArchiveThinkers();
 331         ArchiveScripts();
 332         ArchiveSounds();
 333         ArchiveMisc();
 334
 335         // Place a termination marker
 336         StreamOutLong(ASEG_END);
 337
 338         // Close the output file
 339         CloseStreamOut();
 340 }
 341
 342 //==========================================================================
 343 //
 344 // SV_LoadGame
 345 //
 346 //==========================================================================
 347
 348 void SV_LoadGame(int slot)
 349 {
 350         int i;
 351         char fileName[100];
 352         player_t playerBackup[MAXPLAYERS];
 353         mobj_t *mobj;
 354
 355         // Copy all needed save files to the base slot
 356         if(slot != BASE_SLOT)
 357         {
 358                 ClearSaveSlot(BASE_SLOT);
 359                 CopySaveSlot(slot, BASE_SLOT);
 360         }
 361
 362         // Create the name
 363         snprintf(fileName, 100, "%shex6.hxs", basePath);
 364
 365         // Load the file
 366         M_ReadFile(fileName, &SaveBuffer);
 367
 368         // Set the save pointer and skip the description field
 369         SavePtr.b = SaveBuffer+HXS_DESCRIPTION_LENGTH;
 370
 371         // Check the version text
 372         if(strcmp(SavePtr.b, HXS_VERSION_TEXT))
 373         { // Bad version
 374                 return;
 375         }
 376         SavePtr.b += HXS_VERSION_TEXT_LENGTH;
 377
 378         AssertSegment(ASEG_GAME_HEADER);
 379
 380         gameepisode = 1;
 381         gamemap = GET_BYTE;
 382         gameskill = GET_BYTE;
 383
 384         // Read global script info
 385         memcpy(WorldVars, SavePtr.b, sizeof(WorldVars));
 386         SavePtr.b += sizeof(WorldVars);
 387         memcpy(ACSStore, SavePtr.b, sizeof(ACSStore));
 388         SavePtr.b += sizeof(ACSStore);
 389
 390         // Read the player structures
 391         UnarchivePlayers();
 392
 393         AssertSegment(ASEG_END);
 394
 395         Z_Free(SaveBuffer);
 396
 397         // Save player structs
 398         for(i = 0; i < MAXPLAYERS; i++)
 399         {
 400                 playerBackup[i] = players[i];
 401         }
 402
 403         // Load the current map
 404         SV_LoadMap();
 405
 406         // Don't need the player mobj relocation info for load game
 407         Z_Free(TargetPlayerAddrs);
 408
 409         // Restore player structs
 410         inv_ptr = 0;
 411         curpos = 0;
 412         for(i = 0; i < MAXPLAYERS; i++)
 413         {
 414                 mobj = players[i].mo;
 415                 players[i] = playerBackup[i];
 416                 players[i].mo = mobj;
 417                 if(i == consoleplayer)
 418                 {
 419                         players[i].readyArtifact = players[i].inventory[inv_ptr].type;
 420                 }
 421         }
 422 }
 423
 424 //==========================================================================
 425 //
 426 // SV_UpdateRebornSlot
 427 //
 428 // Copies the base slot to the reborn slot.
 429 //
 430 //==========================================================================
 431
 432 void SV_UpdateRebornSlot(void)
 433 {
 434         ClearSaveSlot(REBORN_SLOT);
 435         CopySaveSlot(BASE_SLOT, REBORN_SLOT);
 436 }
 437
 438 //==========================================================================
 439 //
 440 // SV_ClearRebornSlot
 441 //
 442 //==========================================================================
 443
 444 void SV_ClearRebornSlot(void)
 445 {
 446         ClearSaveSlot(REBORN_SLOT);
 447 }
 448
 449 //==========================================================================
 450 //
 451 // SV_MapTeleport
 452 //
 453 //==========================================================================
 454
 455 void SV_MapTeleport(int map, int position)
 456 {
 457         int i;
 458         int j;
 459         char fileName[100];
 460         player_t playerBackup[MAXPLAYERS];
 461         mobj_t *targetPlayerMobj;
 462         mobj_t *mobj;
 463         int inventoryPtr;
 464         int currentInvPos;
 465         boolean rClass;
 466         boolean playerWasReborn;
 467         boolean oldWeaponowned[NUMWEAPONS];
 468         int oldKeys   = 0; /* jim added initialiser */
 469         int oldPieces = 0; /* jim added initialiser */
 470         int bestWeapon;
 471
 472         if(!deathmatch)
 473         {
 474                 if(P_GetMapCluster(gamemap) == P_GetMapCluster(map))
 475                 { // Same cluster - save map without saving player mobjs
 476                         SV_SaveMap(false);
 477                 }
 478                 else
 479                 { // Entering new cluster - clear base slot
 480                         ClearSaveSlot(BASE_SLOT);
 481                 }
 482         }
 483
 484         // Store player structs for later
 485         rClass = randomclass;
 486         randomclass = false;
 487         for(i = 0; i < MAXPLAYERS; i++)
 488         {
 489                 playerBackup[i] = players[i];
 490         }
 491
 492         // Save some globals that get trashed during the load
 493         inventoryPtr = inv_ptr;
 494         currentInvPos = curpos;
 495
 496         // Only SV_LoadMap() uses TargetPlayerAddrs, so it's NULLed here
 497         // for the following check (player mobj redirection)
 498         TargetPlayerAddrs = NULL;
 499
 500         gamemap = map;
 501         snprintf(fileName, 100, "%shex6%02d.hxs", basePath, gamemap);
 502         if(!deathmatch && ExistingFile(fileName))
 503         { // Unarchive map
 504                 SV_LoadMap();
 505         }
 506         else
 507         { // New map
 508                 G_InitNew(gameskill, gameepisode, gamemap);
 509
 510                 // Destroy all freshly spawned players
 511                 for(i = 0; i < MAXPLAYERS; i++)
 512                 {
 513                         if(playeringame[i])
 514                         {
 515                                 P_RemoveMobj(players[i].mo);
 516                         }
 517                 }
 518         }
 519
 520         // Restore player structs
 521         targetPlayerMobj = NULL;
 522         for(i = 0; i < MAXPLAYERS; i++)
 523         {
 524                 if(!playeringame[i])
 525                 {
 526                         continue;
 527                 }
 528                 players[i] = playerBackup[i];
 529                 P_ClearMessage(&players[i]);
 530                 players[i].attacker = NULL;
 531                 players[i].poisoner = NULL;
 532
 533                 if(netgame)
 534                 {
 535                         if(players[i].playerstate == PST_DEAD)
 536                         { // In a network game, force all players to be alive
 537                                 players[i].playerstate = PST_REBORN;
 538                         }
 539                         if(!deathmatch)
 540                         { // Cooperative net-play, retain keys and weapons
 541                                 oldKeys = players[i].keys;
 542                                 oldPieces = players[i].pieces;
 543                                 for(j = 0; j < NUMWEAPONS; j++)
 544                                 {
 545                                         oldWeaponowned[j] = players[i].weaponowned[j];
 546                                 }
 547                         }
 548                 }
 549                 playerWasReborn = (players[i].playerstate == PST_REBORN);
 550                 if(deathmatch)
 551                 {
 552                         memset(players[i].frags, 0, sizeof(players[i].frags));
 553                         mobj = P_SpawnMobj(playerstarts[0][i].x<<16,
 554                                 playerstarts[0][i].y<<16, 0, MT_PLAYER_FIGHTER);
 555                         players[i].mo = mobj;
 556                         G_DeathMatchSpawnPlayer(i);
 557                         P_RemoveMobj(mobj);
 558                 }
 559                 else
 560                 {
 561                         P_SpawnPlayer(&playerstarts[position][i]);
 562                 }
 563
 564                 if(playerWasReborn && netgame && !deathmatch)
 565                 { // Restore keys and weapons when reborn in co-op
 566                         players[i].keys = oldKeys;
 567                         players[i].pieces = oldPieces;
 568                         for(bestWeapon = 0, j = 0; j < NUMWEAPONS; j++)
 569                         {
 570                                 if(oldWeaponowned[j])
 571                                 {
 572                                         bestWeapon = j;
 573                                         players[i].weaponowned[j] = true;
 574                                 }
 575                         }
 576                         players[i].mana[MANA_1] = 25;
 577                         players[i].mana[MANA_2] = 25;
 578                         if(bestWeapon)
 579                         { // Bring up the best weapon
 580                                 players[i].pendingweapon = bestWeapon;
 581                         }
 582                 }
 583
 584                 if(targetPlayerMobj == NULL)
 585                 { // The poor sap
 586                         targetPlayerMobj = players[i].mo;
 587                 }
 588         }
 589         randomclass = rClass;
 590
 591         // Redirect anything targeting a player mobj
 592         if(TargetPlayerAddrs)
 593         {
 594                 for(i = 0; i < TargetPlayerCount; i++)
 595                 {
 596                         *TargetPlayerAddrs[i] = (int)targetPlayerMobj;
 597                 }
 598                 Z_Free(TargetPlayerAddrs);
 599         }
 600
 601         // Destroy all things touching players
 602         for(i = 0; i < MAXPLAYERS; i++)
 603         {
 604                 if(playeringame[i])
 605                 {
 606                         P_TeleportMove(players[i].mo, players[i].mo->x,
 607                                 players[i].mo->y);
 608                 }
 609         }
 610
 611         // Restore trashed globals
 612         inv_ptr = inventoryPtr;
 613         curpos = currentInvPos;
 614
 615         // Launch waiting scripts
 616         if(!deathmatch)
 617         {
 618                 P_CheckACSStore();
 619         }
 620
 621         // For single play, save immediately into the reborn slot
 622         if(!netgame)
 623         {
 624                 SV_SaveGame(REBORN_SLOT, REBORN_DESCRIPTION);
 625         }
 626 }
 627
 628 //==========================================================================
 629 //
 630 // SV_GetRebornSlot
 631 //
 632 //==========================================================================
 633
 634 int SV_GetRebornSlot(void)
 635 {
 636         return(REBORN_SLOT);
 637 }
 638
 639 //==========================================================================
 640 //
 641 // SV_RebornSlotAvailable
 642 //
 643 // Returns true if the reborn slot is available.
 644 //
 645 //==========================================================================
 646
 647 boolean SV_RebornSlotAvailable(void)
 648 {
 649         char fileName[100];
 650
 651         snprintf(fileName, 100, "%shex%d.hxs", basePath, REBORN_SLOT);
 652         return ExistingFile(fileName);
 653 }
 654
 655 //==========================================================================
 656 //
 657 // SV_LoadMap
 658 //
 659 //==========================================================================
 660
 661 void SV_LoadMap(void)
 662 {
 663         char fileName[100];
 664
 665         // Load a base level
 666         G_InitNew(gameskill, gameepisode, gamemap);
 667
 668         // Remove all thinkers
 669         RemoveAllThinkers();
 670
 671         // Create the name
 672         snprintf(fileName, 100, "%shex6%02d.hxs", basePath, gamemap);
 673
 674         // Load the file
 675         M_ReadFile(fileName, &SaveBuffer);
 676         SavePtr.b = SaveBuffer;
 677
 678         AssertSegment(ASEG_MAP_HEADER);
 679
 680         // Read the level timer
 681         leveltime = GET_LONG;
 682
 683         UnarchiveWorld();
 684         UnarchivePolyobjs();
 685         UnarchiveMobjs();
 686         UnarchiveThinkers();
 687         UnarchiveScripts();
 688         UnarchiveSounds();
 689         UnarchiveMisc();
 690
 691         AssertSegment(ASEG_END);
 692
 693         // Free mobj list and save buffer
 694         Z_Free(MobjList);
 695         Z_Free(SaveBuffer);
 696 }
 697
 698 //==========================================================================
 699 //
 700 // SV_InitBaseSlot
 701 //
 702 //==========================================================================
 703
 704 void SV_InitBaseSlot(void)
 705 {
 706         ClearSaveSlot(BASE_SLOT);
 707 }
 708
 709 //==========================================================================
 710 //
 711 // ArchivePlayers
 712 //
 713 //==========================================================================
 714
 715 static void ArchivePlayers(void)
 716 {
 717         int i;
 718         int j;
 719         player_t tempPlayer;
 720
 721         StreamOutLong(ASEG_PLAYERS);
 722         for(i = 0; i < MAXPLAYERS; i++)
 723         {
 724                 StreamOutByte(playeringame[i]);
 725         }
 726         for(i = 0; i < MAXPLAYERS; i++)
 727         {
 728                 if(!playeringame[i])
 729                 {
 730                         continue;
 731                 }
 732                 StreamOutByte(PlayerClass[i]);
 733                 tempPlayer = players[i];
 734                 for(j = 0; j < NUMPSPRITES; j++)
 735                 {
 736                         if(tempPlayer.psprites[j].state)
 737                         {
 738                                 tempPlayer.psprites[j].state =
 739                                         (state_t *)(tempPlayer.psprites[j].state-states);
 740                         }
 741                 }
 742                 StreamOutBuffer(&tempPlayer, sizeof(player_t));
 743         }
 744 }
 745
 746 //==========================================================================
 747 //
 748 // UnarchivePlayers
 749 //
 750 //==========================================================================
 751
 752 static void UnarchivePlayers(void)
 753 {
 754         int i, j;
 755
 756         AssertSegment(ASEG_PLAYERS);
 757         for(i = 0; i < MAXPLAYERS; i++)
 758         {
 759                 playeringame[i] = GET_BYTE;
 760         }
 761         for(i = 0; i < MAXPLAYERS; i++)
 762         {
 763                 if(!playeringame[i])
 764                 {
 765                         continue;
 766                 }
 767                 PlayerClass[i] = GET_BYTE;
 768                 memcpy(&players[i], SavePtr.b, sizeof(player_t));
 769                 SavePtr.b += sizeof(player_t);
 770                 players[i].mo = NULL; // Will be set when unarc thinker
 771                 P_ClearMessage(&players[i]);
 772                 players[i].attacker = NULL;
 773                 players[i].poisoner = NULL;
 774                 for(j = 0; j < NUMPSPRITES; j++)
 775                 {
 776                         if(players[i].psprites[j].state)
 777                         {
 778                                 players[i].psprites[j].state =
 779                                         &states[(int)players[i].psprites[j].state];
 780                         }
 781                 }
 782         }
 783 }
 784
 785 //==========================================================================
 786 //
 787 // ArchiveWorld
 788 //
 789 //==========================================================================
 790
 791 static void ArchiveWorld(void)
 792 {
 793         int i;
 794         int j;
 795         sector_t *sec;
 796         line_t *li;
 797         side_t *si;
 798
 799         StreamOutLong(ASEG_WORLD);
 800         for(i = 0, sec = sectors; i < numsectors; i++, sec++)
 801         {
 802                 StreamOutWord(sec->floorheight>>FRACBITS);
 803                 StreamOutWord(sec->ceilingheight>>FRACBITS);
 804                 StreamOutWord(sec->floorpic);
 805                 StreamOutWord(sec->ceilingpic);
 806                 StreamOutWord(sec->lightlevel);
 807                 StreamOutWord(sec->special);
 808                 StreamOutWord(sec->tag);
 809                 StreamOutWord(sec->seqType);
 810         }
 811         for(i = 0, li = lines; i < numlines; i++, li++)
 812         {
 813                 StreamOutWord(li->flags);
 814                 StreamOutByte(li->special);
 815                 StreamOutByte(li->arg1);
 816                 StreamOutByte(li->arg2);
 817                 StreamOutByte(li->arg3);
 818                 StreamOutByte(li->arg4);
 819                 StreamOutByte(li->arg5);
 820                 for(j = 0; j < 2; j++)
 821                 {
 822                         if(li->sidenum[j] == -1)
 823                         {
 824                                 continue;
 825                         }
 826                         si = &sides[li->sidenum[j]];
 827                         StreamOutWord(si->textureoffset>>FRACBITS);
 828                         StreamOutWord(si->rowoffset>>FRACBITS);
 829                         StreamOutWord(si->toptexture);
 830                         StreamOutWord(si->bottomtexture);
 831                         StreamOutWord(si->midtexture);
 832                 }
 833         }
 834 }
 835
 836 //==========================================================================
 837 //
 838 // UnarchiveWorld
 839 //
 840 //==========================================================================
 841
 842 static void UnarchiveWorld(void)
 843 {
 844         int i;
 845         int j;
 846         sector_t *sec;
 847         line_t *li;
 848         side_t *si;
 849
 850         AssertSegment(ASEG_WORLD);
 851         for(i = 0, sec = sectors; i < numsectors; i++, sec++)
 852         {
 853                 sec->floorheight = GET_WORD<<FRACBITS;
 854                 sec->ceilingheight = GET_WORD<<FRACBITS;
 855                 sec->floorpic = GET_WORD;
 856                 sec->ceilingpic = GET_WORD;
 857                 sec->lightlevel = GET_WORD;
 858                 sec->special = GET_WORD;
 859                 sec->tag = GET_WORD;
 860                 sec->seqType = GET_WORD;
 861                 sec->specialdata = 0;
 862                 sec->soundtarget = 0;
 863         }
 864         for(i = 0, li = lines; i < numlines; i++, li++)
 865         {
 866                 li->flags = GET_WORD;
 867                 li->special = GET_BYTE;
 868                 li->arg1 = GET_BYTE;
 869                 li->arg2 = GET_BYTE;
 870                 li->arg3 = GET_BYTE;
 871                 li->arg4 = GET_BYTE;
 872                 li->arg5 = GET_BYTE;
 873                 for(j = 0; j < 2; j++)
 874                 {
 875                         if(li->sidenum[j] == -1)
 876                         {
 877                                 continue;
 878                         }
 879                         si = &sides[li->sidenum[j]];
 880                         si->textureoffset = GET_WORD<<FRACBITS;
 881                         si->rowoffset = GET_WORD<<FRACBITS;
 882                         si->toptexture = GET_WORD;
 883                         si->bottomtexture = GET_WORD;
 884                         si->midtexture = GET_WORD;
 885                 }
 886         }
 887 }
 888
 889 //==========================================================================
 890 //
 891 // SetMobjArchiveNums
 892 //
 893 // Sets the archive numbers in all mobj structs.  Also sets the MobjCount
 894 // global.  Ignores player mobjs if SavingPlayers is false.
 895 //
 896 //==========================================================================
 897
 898 static void SetMobjArchiveNums(void)
 899 {
 900         mobj_t *mobj;
 901         thinker_t *thinker;
 902
 903         MobjCount = 0;
 904         for(thinker = thinkercap.next; thinker != &thinkercap;
 905                 thinker = thinker->next)
 906         {
 907                 if(thinker->function == P_MobjThinker)
 908                 {
 909                         mobj = (mobj_t *)thinker;
 910                         if(mobj->player && !SavingPlayers)
 911                         { // Skipping player mobjs
 912                                 continue;
 913                         }
 914                         mobj->archiveNum = MobjCount++;
 915                 }
 916         }
 917 }
 918
 919 //==========================================================================
 920 //
 921 // ArchiveMobjs
 922 //
 923 //==========================================================================
 924
 925 static void ArchiveMobjs(void)
 926 {
 927         int count;
 928         thinker_t *thinker;
 929         mobj_t tempMobj;
 930
 931         StreamOutLong(ASEG_MOBJS);
 932         StreamOutLong(MobjCount);
 933         count = 0;
 934         for(thinker = thinkercap.next; thinker != &thinkercap;
 935                 thinker = thinker->next)
 936         {
 937                 if(thinker->function != P_MobjThinker)
 938                 { // Not a mobj thinker
 939                         continue;
 940                 }
 941                 if(((mobj_t *)thinker)->player && !SavingPlayers)
 942                 { // Skipping player mobjs
 943                         continue;
 944                 }
 945                 count++;
 946                 memcpy(&tempMobj, thinker, sizeof(mobj_t));
 947                 MangleMobj(&tempMobj);
 948                 StreamOutBuffer(&tempMobj, sizeof(mobj_t));
 949         }
 950         if(count != MobjCount)
 951         {
 952                 I_Error("ArchiveMobjs: bad mobj count");
 953         }
 954 }
 955
 956 //==========================================================================
 957 //
 958 // UnarchiveMobjs
 959 //
 960 //==========================================================================
 961
 962 static void UnarchiveMobjs(void)
 963 {
 964         int i;
 965         mobj_t *mobj;
 966
 967         AssertSegment(ASEG_MOBJS);
 968         TargetPlayerAddrs = Z_Malloc(MAX_TARGET_PLAYERS*sizeof(int *),
 969                 PU_STATIC, NULL);
 970         TargetPlayerCount = 0;
 971         MobjCount = GET_LONG;
 972         MobjList = Z_Malloc(MobjCount*sizeof(mobj_t *), PU_STATIC, NULL);
 973         for(i = 0; i < MobjCount; i++)
 974         {
 975                 MobjList[i] = Z_Malloc(sizeof(mobj_t), PU_LEVEL, NULL);
 976         }
 977         for(i = 0; i < MobjCount; i++)
 978         {
 979                 mobj = MobjList[i];
 980                 memcpy(mobj, SavePtr.b, sizeof(mobj_t));
 981                 SavePtr.b += sizeof(mobj_t);
 982                 mobj->thinker.function = P_MobjThinker;
 983                 RestoreMobj(mobj);
 984                 P_AddThinker(&mobj->thinker);
 985         }
 986         P_CreateTIDList();
 987         P_InitCreatureCorpseQueue(true); // true = scan for corpses
 988 }
 989
 990 //==========================================================================
 991 //
 992 // MangleMobj
 993 //
 994 //==========================================================================
 995
 996 static void MangleMobj(mobj_t *mobj)
 997 {
 998         boolean corpse;
 999
1000         corpse = mobj->flags&MF_CORPSE;
1001         mobj->state = (state_t *)(mobj->state-states);
1002         if(mobj->player)
1003         {
1004                 mobj->player = (player_t *)((mobj->player-players)+1);
1005         }
1006         if(corpse)
1007         {
1008                 mobj->target = (mobj_t *)MOBJ_NULL;
1009         }
1010         else
1011         {
1012                 mobj->target = (mobj_t *)GetMobjNum(mobj->target);
1013         }
1014         switch(mobj->type)
1015         {
1016                 // Just special1
1017                 case MT_BISH_FX:
1018                 case MT_HOLY_FX:
1019                 case MT_DRAGON:
1020                 case MT_THRUSTFLOOR_UP:
1021                 case MT_THRUSTFLOOR_DOWN:
1022                 case MT_MINOTAUR:
1023                 case MT_SORCFX1:
1024                 case MT_MSTAFF_FX2:
1025                         if(corpse)
1026                         {
1027                                 mobj->special1 = MOBJ_NULL;
1028                         }
1029                         else
1030                         {
1031                                 mobj->special1 = GetMobjNum((mobj_t *)mobj->special1);
1032                         }
1033                         break;
1034
1035                 // Just special2
1036                 case MT_LIGHTNING_FLOOR:
1037                 case MT_LIGHTNING_ZAP:
1038                         if(corpse)
1039                         {
1040                                 mobj->special2 = MOBJ_NULL;
1041                         }
1042                         else
1043                         {
1044                                 mobj->special2 = GetMobjNum((mobj_t *)mobj->special2);
1045                         }
1046                         break;
1047
1048                 // Both special1 and special2
1049                 case MT_HOLY_TAIL:
1050                 case MT_LIGHTNING_CEILING:
1051                         if(corpse)
1052                         {
1053                                 mobj->special1 = MOBJ_NULL;
1054                                 mobj->special2 = MOBJ_NULL;
1055                         }
1056                         else
1057                         {
1058                                 mobj->special1 = GetMobjNum((mobj_t *)mobj->special1);
1059                                 mobj->special2 = GetMobjNum((mobj_t *)mobj->special2);
1060                         }
1061                         break;
1062
1063                 // Miscellaneous
1064                 case MT_KORAX:
1065                         mobj->special1 = 0; // Searching index
1066                         break;
1067
1068                 default:
1069                         break;
1070         }
1071 }
1072
1073 //==========================================================================
1074 //
1075 // GetMobjNum
1076 //
1077 //==========================================================================
1078
1079 static int GetMobjNum(mobj_t *mobj)
1080 {
1081         if(mobj == NULL)
1082         {
1083                 return MOBJ_NULL;
1084         }
1085         if(mobj->player && !SavingPlayers)
1086         {
1087                 return MOBJ_XX_PLAYER;
1088         }
1089         return mobj->archiveNum;
1090 }
1091
1092 //==========================================================================
1093 //
1094 // RestoreMobj
1095 //
1096 //==========================================================================
1097
1098 static void RestoreMobj(mobj_t *mobj)
1099 {
1100         mobj->state = &states[(int)mobj->state];
1101         if(mobj->player)
1102         {
1103                 mobj->player = &players[(int)mobj->player-1];
1104                 mobj->player->mo = mobj;
1105         }
1106         P_SetThingPosition(mobj);
1107         mobj->info = &mobjinfo[mobj->type];
1108         mobj->floorz = mobj->subsector->sector->floorheight;
1109         mobj->ceilingz = mobj->subsector->sector->ceilingheight;
1110         SetMobjPtr((int *)&mobj->target);
1111         switch(mobj->type)
1112         {
1113                 // Just special1
1114                 case MT_BISH_FX:
1115                 case MT_HOLY_FX:
1116                 case MT_DRAGON:
1117                 case MT_THRUSTFLOOR_UP:
1118                 case MT_THRUSTFLOOR_DOWN:
1119                 case MT_MINOTAUR:
1120                 case MT_SORCFX1:
1121                         SetMobjPtr(&mobj->special1);
1122                         break;
1123
1124                 // Just special2
1125                 case MT_LIGHTNING_FLOOR:
1126                 case MT_LIGHTNING_ZAP:
1127                         SetMobjPtr(&mobj->special2);
1128                         break;
1129
1130                 // Both special1 and special2
1131                 case MT_HOLY_TAIL:
1132                 case MT_LIGHTNING_CEILING:
1133                         SetMobjPtr(&mobj->special1);
1134                         SetMobjPtr(&mobj->special2);
1135                         break;
1136
1137                 default:
1138                         break;
1139         }
1140 }
1141
1142 //==========================================================================
1143 //
1144 // SetMobjPtr
1145 //
1146 //==========================================================================
1147
1148 static void SetMobjPtr(int *archiveNum)
1149 {
1150         if(*archiveNum == MOBJ_NULL)
1151         {
1152                 *archiveNum = 0;
1153                 return;
1154         }
1155         if(*archiveNum == MOBJ_XX_PLAYER)
1156         {
1157                 if(TargetPlayerCount == MAX_TARGET_PLAYERS)
1158                 {
1159                         I_Error("RestoreMobj: exceeded MAX_TARGET_PLAYERS");
1160                 }
1161                 TargetPlayerAddrs[TargetPlayerCount++] = archiveNum;
1162                 *archiveNum = 0;
1163                 return;
1164         }
1165         *archiveNum = (int)MobjList[*archiveNum];
1166 }
1167
1168 //==========================================================================
1169 //
1170 // ArchiveThinkers
1171 //
1172 //==========================================================================
1173
1174 static void ArchiveThinkers(void)
1175 {
1176         thinker_t *thinker;
1177         thinkInfo_t *info;
1178         byte buffer[MAX_THINKER_SIZE];
1179
1180         StreamOutLong(ASEG_THINKERS);
1181         for(thinker = thinkercap.next; thinker != &thinkercap;
1182                 thinker = thinker->next)
1183         {
1184                 for(info = ThinkerInfo; info->tClass != TC_NULL; info++)
1185                 {
1186                         if(thinker->function == info->thinkerFunc)
1187                         {
1188                                 StreamOutByte(info->tClass);
1189                                 memcpy(buffer, thinker, info->size);
1190                                 if(info->mangleFunc)
1191                                 {
1192                                         info->mangleFunc(buffer);
1193                                 }
1194                                 StreamOutBuffer(buffer, info->size);
1195                                 break;
1196                         }
1197                 }
1198         }
1199         // Add a termination marker
1200         StreamOutByte(TC_NULL);
1201 }
1202
1203 //==========================================================================
1204 //
1205 // UnarchiveThinkers
1206 //
1207 //==========================================================================
1208
1209 static void UnarchiveThinkers(void)
1210 {
1211         int tClass;
1212         thinker_t *thinker;
1213         thinkInfo_t *info;
1214
1215         AssertSegment(ASEG_THINKERS);
1216         while((tClass = GET_BYTE) != TC_NULL)
1217         {
1218                 for(info = ThinkerInfo; info->tClass != TC_NULL; info++)
1219                 {
1220                         if(tClass == info->tClass)
1221                         {
1222                                 thinker = Z_Malloc(info->size, PU_LEVEL, NULL);
1223                                 memcpy(thinker, SavePtr.b, info->size);
1224                                 SavePtr.b += info->size;
1225                                 thinker->function = info->thinkerFunc;
1226                                 if(info->restoreFunc)
1227                                 {
1228                                         info->restoreFunc(thinker);
1229                                 }
1230                                 P_AddThinker(thinker);
1231                                 break;
1232                         }
1233                 }
1234                 if(info->tClass == TC_NULL)
1235                 {
1236                         I_Error("UnarchiveThinkers: Unknown tClass %d in "
1237                                 "savegame", tClass);
1238                 }
1239         }
1240 }
1241
1242 //==========================================================================
1243 //
1244 // MangleSSThinker
1245 //
1246 //==========================================================================
1247
1248 static void MangleSSThinker(ssthinker_t *sst)
1249 {
1250         sst->sector = (sector_t *)(sst->sector-sectors);
1251 }
1252
1253 //==========================================================================
1254 //
1255 // RestoreSSThinker
1256 //
1257 //==========================================================================
1258
1259 static void RestoreSSThinker(ssthinker_t *sst)
1260 {
1261         sst->sector = &sectors[(int)sst->sector];
1262         sst->sector->specialdata = sst->thinker.function;
1263 }
1264
1265 //==========================================================================
1266 //
1267 // RestoreSSThinkerNoSD
1268 //
1269 //==========================================================================
1270
1271 static void RestoreSSThinkerNoSD(ssthinker_t *sst)
1272 {
1273         sst->sector = &sectors[(int)sst->sector];
1274 }
1275
1276 //==========================================================================
1277 //
1278 // MangleScript
1279 //
1280 //==========================================================================
1281
1282 static void MangleScript(acs_t *script)
1283 {
1284         script->ip = (int *)((int)(script->ip)-(int)ActionCodeBase);
1285         script->line = script->line ?
1286                 (line_t *)(script->line-lines) : (line_t *)-1;
1287         script->activator = (mobj_t *)GetMobjNum(script->activator);
1288 }
1289
1290 //==========================================================================
1291 //
1292 // RestoreScript
1293 //
1294 //==========================================================================
1295
1296 static void RestoreScript(acs_t *script)
1297 {
1298         script->ip = (int *)(ActionCodeBase+(int)script->ip);
1299         if((int)script->line == -1)
1300         {
1301                 script->line = NULL;
1302         }
1303         else
1304         {
1305                 script->line = &lines[(int)script->line];
1306         }
1307         SetMobjPtr((int *)&script->activator);
1308 }
1309
1310 //==========================================================================
1311 //
1312 // RestorePlatRaise
1313 //
1314 //==========================================================================
1315
1316 static void RestorePlatRaise(plat_t *plat)
1317 {
1318         plat->sector = &sectors[(int)plat->sector];
1319         plat->sector->specialdata = T_PlatRaise;
1320         P_AddActivePlat(plat);
1321 }
1322
1323 //==========================================================================
1324 //
1325 // RestoreMoveCeiling
1326 //
1327 //==========================================================================
1328
1329 static void RestoreMoveCeiling(ceiling_t *ceiling)
1330 {
1331         ceiling->sector = &sectors[(int)ceiling->sector];
1332         ceiling->sector->specialdata = T_MoveCeiling;
1333         P_AddActiveCeiling(ceiling);
1334 }
1335
1336 //==========================================================================
1337 //
1338 // ArchiveScripts
1339 //
1340 //==========================================================================
1341
1342 static void ArchiveScripts(void)
1343 {
1344         int i;
1345
1346         StreamOutLong(ASEG_SCRIPTS);
1347         for(i = 0; i < ACScriptCount; i++)
1348         {
1349                 StreamOutWord(ACSInfo[i].state);
1350                 StreamOutWord(ACSInfo[i].waitValue);
1351         }
1352         StreamOutBuffer(MapVars, sizeof(MapVars));
1353 }
1354
1355 //==========================================================================
1356 //
1357 // UnarchiveScripts
1358 //
1359 //==========================================================================
1360
1361 static void UnarchiveScripts(void)
1362 {
1363         int i;
1364
1365         AssertSegment(ASEG_SCRIPTS);
1366         for(i = 0; i < ACScriptCount; i++)
1367         {
1368                 ACSInfo[i].state = GET_WORD;
1369                 ACSInfo[i].waitValue = GET_WORD;
1370         }
1371         memcpy(MapVars, SavePtr.b, sizeof(MapVars));
1372         SavePtr.b += sizeof(MapVars);
1373 }
1374
1375 //==========================================================================
1376 //
1377 // ArchiveMisc
1378 //
1379 //==========================================================================
1380
1381 static void ArchiveMisc(void)
1382 {
1383         int ix;
1384
1385         StreamOutLong(ASEG_MISC);
1386         for (ix=0; ix<MAXPLAYERS; ix++)
1387         {
1388                 StreamOutLong(localQuakeHappening[ix]);
1389         }
1390 }
1391
1392 //==========================================================================
1393 //
1394 // UnarchiveMisc
1395 //
1396 //==========================================================================
1397
1398 static void UnarchiveMisc(void)
1399 {
1400         int ix;
1401
1402         AssertSegment(ASEG_MISC);
1403         for (ix=0; ix<MAXPLAYERS; ix++)
1404         {
1405                 localQuakeHappening[ix] = GET_LONG;
1406         }
1407 }
1408
1409 //==========================================================================
1410 //
1411 // RemoveAllThinkers
1412 //
1413 //==========================================================================
1414
1415 static void RemoveAllThinkers(void)
1416 {
1417         thinker_t *thinker;
1418         thinker_t *nextThinker;
1419
1420         thinker = thinkercap.next;
1421         while(thinker != &thinkercap)
1422         {
1423                 nextThinker = thinker->next;
1424                 if(thinker->function == P_MobjThinker)
1425                 {
1426                         P_RemoveMobj((mobj_t *)thinker);
1427                 }
1428                 else
1429                 {
1430                         Z_Free(thinker);
1431                 }
1432                 thinker = nextThinker;
1433         }
1434         P_InitThinkers();
1435 }
1436
1437 //==========================================================================
1438 //
1439 // ArchiveSounds
1440 //
1441 //==========================================================================
1442
1443 static void ArchiveSounds(void)
1444 {
1445         seqnode_t *node;
1446         sector_t *sec;
1447         int difference;
1448         int i;
1449
1450         StreamOutLong(ASEG_SOUNDS);
1451
1452         // Save the sound sequences
1453         StreamOutLong(ActiveSequences);
1454         for(node = SequenceListHead; node; node = node->next)
1455         {
1456                 StreamOutLong(node->sequence);
1457                 StreamOutLong(node->delayTics);
1458                 StreamOutLong(node->volume);
1459                 StreamOutLong(SN_GetSequenceOffset(node->sequence,
1460                         node->sequencePtr));
1461                 StreamOutLong(node->currentSoundID);
1462                 for(i = 0; i < po_NumPolyobjs; i++)
1463                 {
1464                         if(node->mobj == (mobj_t *)&polyobjs[i].startSpot)
1465                         {
1466                                 break;
1467                         }
1468                 }
1469                 if(i == po_NumPolyobjs)
1470                 { // Sound is attached to a sector, not a polyobj
1471                         sec = R_PointInSubsector(node->mobj->x, node->mobj->y)->sector;
1472                         difference = (int)((byte *)sec
1473                                 -(byte *)&sectors[0])/sizeof(sector_t);
1474                         StreamOutLong(0); // 0 -- sector sound origin
1475                 }
1476                 else
1477                 {
1478                         StreamOutLong(1); // 1 -- polyobj sound origin
1479                         difference = i;
1480                 }
1481                 StreamOutLong(difference);
1482         }
1483 }
1484
1485 //==========================================================================
1486 //
1487 // UnarchiveSounds
1488 //
1489 //==========================================================================
1490
1491 static void UnarchiveSounds(void)
1492 {
1493         int i;
1494         int numSequences;
1495         int sequence;
1496         int delayTics;
1497         int volume;
1498         int seqOffset;
1499         int soundID;
1500         int polySnd;
1501         int secNum;
1502         mobj_t *sndMobj;
1503
1504         AssertSegment(ASEG_SOUNDS);
1505
1506         // Reload and restart all sound sequences
1507         numSequences = GET_LONG;
1508         i = 0;
1509         while(i < numSequences)
1510         {
1511                 sequence = GET_LONG;
1512                 delayTics = GET_LONG;
1513                 volume = GET_LONG;
1514                 seqOffset = GET_LONG;
1515
1516                 soundID = GET_LONG;
1517                 polySnd = GET_LONG;
1518                 secNum = GET_LONG;
1519                 if(!polySnd)
1520                 {
1521                         sndMobj = (mobj_t *)&sectors[secNum].soundorg;
1522                 }
1523                 else
1524                 {
1525                         sndMobj = (mobj_t *)&polyobjs[secNum].startSpot;
1526                 }
1527                 SN_StartSequence(sndMobj, sequence);
1528                 SN_ChangeNodeData(i, seqOffset, delayTics, volume, soundID);
1529                 i++;
1530         }
1531 }
1532
1533 //==========================================================================
1534 //
1535 // ArchivePolyobjs
1536 //
1537 //==========================================================================
1538
1539 static void ArchivePolyobjs(void)
1540 {
1541         int i;
1542
1543         StreamOutLong(ASEG_POLYOBJS);
1544         StreamOutLong(po_NumPolyobjs);
1545         for(i = 0; i < po_NumPolyobjs; i++)
1546         {
1547                 StreamOutLong(polyobjs[i].tag);
1548                 StreamOutLong(polyobjs[i].angle);
1549                 StreamOutLong(polyobjs[i].startSpot.x);
1550                 StreamOutLong(polyobjs[i].startSpot.y);
1551         }
1552 }
1553
1554 //==========================================================================
1555 //
1556 // UnarchivePolyobjs
1557 //
1558 //==========================================================================
1559
1560 static void UnarchivePolyobjs(void)
1561 {
1562         int i;
1563         fixed_t deltaX;
1564         fixed_t deltaY;
1565
1566         AssertSegment(ASEG_POLYOBJS);
1567         if(GET_LONG != po_NumPolyobjs)
1568         {
1569                 I_Error("UnarchivePolyobjs: Bad polyobj count");
1570         }
1571         for(i = 0; i < po_NumPolyobjs; i++)
1572         {
1573                 if(GET_LONG != polyobjs[i].tag)
1574                 {
1575                         I_Error("UnarchivePolyobjs: Invalid polyobj tag");
1576                 }
1577                 PO_RotatePolyobj(polyobjs[i].tag, (angle_t)GET_LONG);
1578                 deltaX = GET_LONG-polyobjs[i].startSpot.x;
1579                 deltaY = GET_LONG-polyobjs[i].startSpot.y;
1580                 PO_MovePolyobj(polyobjs[i].tag, deltaX, deltaY);
1581         }
1582 }
1583
1584 //==========================================================================
1585 //
1586 // AssertSegment
1587 //
1588 //==========================================================================
1589
1590 static void AssertSegment(gameArchiveSegment_t segType)
1591 {
1592         if(GET_LONG != segType)
1593         {
1594                 I_Error("Corrupt save game: Segment [%d] failed alignment check",
1595                         segType);
1596         }
1597 }
1598
1599 //==========================================================================
1600 //
1601 // ClearSaveSlot
1602 //
1603 // Deletes all save game files associated with a slot number.
1604 //
1605 //==========================================================================
1606
1607 static void ClearSaveSlot(int slot)
1608 {
1609         int i;
1610         char fileName[100];
1611
1612         for(i = 0; i < MAX_MAPS; i++)
1613         {
1614                 snprintf(fileName, 100, "%shex%d%02d.hxs", basePath, slot, i);
1615                 remove(fileName);
1616         }
1617         snprintf(fileName, 100, "%shex%d.hxs", basePath, slot);
1618         remove(fileName);
1619 }
1620
1621 //==========================================================================
1622 //
1623 // CopySaveSlot
1624 //
1625 // Copies all the save game files from one slot to another.
1626 //
1627 //==========================================================================
1628
1629 static void CopySaveSlot(int sourceSlot, int destSlot)
1630 {
1631         int i;
1632         char sourceName[100];
1633         char destName[100];
1634
1635         for(i = 0; i < MAX_MAPS; i++)
1636         {
1637                 snprintf(sourceName,100, "%shex%d%02d.hxs", basePath,sourceSlot, i);
1638                 if(ExistingFile(sourceName))
1639                 {
1640                         snprintf(destName,100, "%shex%d%02d.hxs", basePath,destSlot, i);
1641                         CopyFile(sourceName, destName);
1642                 }
1643         }
1644         snprintf(sourceName, 100,"%shex%d.hxs", basePath, sourceSlot);
1645         if(ExistingFile(sourceName))
1646         {
1647                 snprintf(destName, 100,"%shex%d.hxs", basePath, destSlot);
1648                 CopyFile(sourceName, destName);
1649         }
1650 }
1651
1652 //==========================================================================
1653 //
1654 // CopyFile
1655 //
1656 //==========================================================================
1657
1658 static void CopyFile(char *sourceName, char *destName)
1659 {
1660         int length;
1661         byte *buffer;
1662
1663         length = M_ReadFile(sourceName, &buffer);
1664         M_WriteFile(destName, buffer, length);
1665         Z_Free(buffer);
1666 }
1667
1668 //==========================================================================
1669 //
1670 // ExistingFile
1671 //
1672 //==========================================================================
1673
1674 static boolean ExistingFile(char *name)
1675 {
1676         FILE *fp;
1677
1678         if((fp = fopen(name, "rb")) != NULL)
1679         {
1680                 fclose(fp);
1681                 return true;
1682         }
1683         else
1684         {
1685                 return false;
1686         }
1687 }
1688
1689 //==========================================================================
1690 //
1691 // OpenStreamOut
1692 //
1693 //==========================================================================
1694
1695 static void OpenStreamOut(char *fileName)
1696 {
1697         SavingFP = fopen(fileName, "wb");
1698 }
1699
1700 //==========================================================================
1701 //
1702 // CloseStreamOut
1703 //
1704 //==========================================================================
1705
1706 static void CloseStreamOut(void)
1707 {
1708         if(SavingFP)
1709         {
1710                 fclose(SavingFP);
1711         }
1712 }
1713
1714 //==========================================================================
1715 //
1716 // StreamOutBuffer
1717 //
1718 //==========================================================================
1719
1720 static void StreamOutBuffer(void *buffer, int size)
1721 {
1722         fwrite(buffer, size, 1, SavingFP);
1723 }
1724
1725 //==========================================================================
1726 //
1727 // StreamOutByte
1728 //
1729 //==========================================================================
1730
1731 static void StreamOutByte(byte val)
1732 {
1733         fwrite(&val, sizeof(byte), 1, SavingFP);
1734 }
1735
1736 //==========================================================================
1737 //
1738 // StreamOutWord
1739 //
1740 //==========================================================================
1741
1742 static void StreamOutWord(unsigned short val)
1743 {
1744         fwrite(&val, sizeof(unsigned short), 1, SavingFP);
1745 }
1746
1747 //==========================================================================
1748 //
1749 // StreamOutLong
1750 //
1751 //==========================================================================
1752
1753 static void StreamOutLong(unsigned int val)
1754 {
1755         fwrite(&val, sizeof(int), 1, SavingFP);
1756 }
1757