diff --git a/src/d_clisrv.c b/src/d_clisrv.c
index 27a489916..360bb05b7 100644
--- a/src/d_clisrv.c
+++ b/src/d_clisrv.c
@@ -1143,28 +1143,28 @@ static boolean SV_ResendingSavegameToAnyone(void)
 static void SV_SendSaveGame(INT32 node, boolean resending)
 {
 	size_t length, compressedlen;
-	UINT8 *savebuffer;
+	savebuffer_t save;
 	UINT8 *compressedsave;
 	UINT8 *buffertosend;
 
 	// first save it in a malloced buffer
-	savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
-	if (!savebuffer)
+	save.buffer = (UINT8 *)malloc(SAVEGAMESIZE);
+	if (!save.buffer)
 	{
 		CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
 		return;
 	}
 
 	// Leave room for the uncompressed length.
-	save_p = savebuffer + sizeof(UINT32);
+	save.p = save.buffer + sizeof(UINT32);
 
-	P_SaveNetGame(resending);
+	P_SaveNetGame(&save, resending);
 
-	length = save_p - savebuffer;
+	length = save.p - save.buffer;
 	if (length > SAVEGAMESIZE)
 	{
-		free(savebuffer);
-		save_p = NULL;
+		free(save.buffer);
+		save.p = NULL;
 		I_Error("Savegame buffer overrun");
 	}
 
@@ -1178,11 +1178,11 @@ static void SV_SendSaveGame(INT32 node, boolean resending)
 	}
 
 	// Attempt to compress it.
-	if((compressedlen = lzf_compress(savebuffer + sizeof(UINT32), length - sizeof(UINT32), compressedsave + sizeof(UINT32), length - sizeof(UINT32) - 1)))
+	if((compressedlen = lzf_compress(save.buffer + sizeof(UINT32), length - sizeof(UINT32), compressedsave + sizeof(UINT32), length - sizeof(UINT32) - 1)))
 	{
 		// Compressing succeeded; send compressed data
 
-		free(savebuffer);
+		free(save.buffer);
 
 		// State that we're compressed.
 		buffertosend = compressedsave;
@@ -1196,12 +1196,12 @@ static void SV_SendSaveGame(INT32 node, boolean resending)
 		free(compressedsave);
 
 		// State that we're not compressed
-		buffertosend = savebuffer;
-		WRITEUINT32(savebuffer, 0);
+		buffertosend = save.buffer;
+		WRITEUINT32(save.buffer, 0);
 	}
 
 	AddRamToSendQueue(node, buffertosend, length, SF_RAM, 0);
-	save_p = NULL;
+	save.p = NULL;
 
 	// Remember when we started sending the savegame so we can handle timeouts
 	sendingsavegame[node] = true;
@@ -1215,7 +1215,7 @@ static consvar_t cv_dumpconsistency = CVAR_INIT ("dumpconsistency", "Off", CV_SA
 static void SV_SavedGame(void)
 {
 	size_t length;
-	UINT8 *savebuffer;
+	savebuffer_t save;
 	char tmpsave[256];
 
 	if (!cv_dumpconsistency.value)
@@ -1224,29 +1224,29 @@ static void SV_SavedGame(void)
 	sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
 
 	// first save it in a malloced buffer
-	save_p = savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
-	if (!save_p)
+	save.p = save.buffer = (UINT8 *)malloc(SAVEGAMESIZE);
+	if (!save.p)
 	{
 		CONS_Alert(CONS_ERROR, M_GetText("No more free memory for savegame\n"));
 		return;
 	}
 
-	P_SaveNetGame(false);
+	P_SaveNetGame(&save, false);
 
-	length = save_p - savebuffer;
+	length = save.p - save.buffer;
 	if (length > SAVEGAMESIZE)
 	{
-		free(savebuffer);
-		save_p = NULL;
+		free(save.buffer);
+		save.p = NULL;
 		I_Error("Savegame buffer overrun");
 	}
 
 	// then save it!
-	if (!FIL_WriteFile(tmpsave, savebuffer, length))
+	if (!FIL_WriteFile(tmpsave, save.buffer, length))
 		CONS_Printf(M_GetText("Didn't save %s for netgame"), tmpsave);
 
-	free(savebuffer);
-	save_p = NULL;
+	free(save.buffer);
+	save.p = NULL;
 }
 
 #undef  TMPSAVENAME
@@ -1256,13 +1256,13 @@ static void SV_SavedGame(void)
 
 static void CL_LoadReceivedSavegame(boolean reloading)
 {
-	UINT8 *savebuffer = NULL;
+	savebuffer_t save;
 	size_t length, decompressedlen;
 	char tmpsave[256];
 
 	sprintf(tmpsave, "%s" PATHSEP TMPSAVENAME, srb2home);
 
-	length = FIL_ReadFile(tmpsave, &savebuffer);
+	length = FIL_ReadFile(tmpsave, &save.buffer);
 
 	CONS_Printf(M_GetText("Loading savegame length %s\n"), sizeu1(length));
 	if (!length)
@@ -1271,16 +1271,16 @@ static void CL_LoadReceivedSavegame(boolean reloading)
 		return;
 	}
 
-	save_p = savebuffer;
+	save.p = save.buffer;
 
 	// Decompress saved game if necessary.
-	decompressedlen = READUINT32(save_p);
+	decompressedlen = READUINT32(save.p);
 	if(decompressedlen > 0)
 	{
 		UINT8 *decompressedbuffer = Z_Malloc(decompressedlen, PU_STATIC, NULL);
-		lzf_decompress(save_p, length - sizeof(UINT32), decompressedbuffer, decompressedlen);
-		Z_Free(savebuffer);
-		save_p = savebuffer = decompressedbuffer;
+		lzf_decompress(save.p, length - sizeof(UINT32), decompressedbuffer, decompressedlen);
+		Z_Free(save.buffer);
+		save.p = save.buffer = decompressedbuffer;
 	}
 
 	paused = false;
@@ -1290,7 +1290,7 @@ static void CL_LoadReceivedSavegame(boolean reloading)
 	automapactive = false;
 
 	// load a base level
-	if (P_LoadNetGame(reloading))
+	if (P_LoadNetGame(&save, reloading))
 	{
 		if (!reloading)
 		{
@@ -1312,8 +1312,8 @@ static void CL_LoadReceivedSavegame(boolean reloading)
 	}
 
 	// done
-	Z_Free(savebuffer);
-	save_p = NULL;
+	Z_Free(save.buffer);
+	save.p = NULL;
 	if (unlink(tmpsave) == -1)
 		CONS_Alert(CONS_ERROR, M_GetText("Can't delete %s\n"), tmpsave);
 	consistancy[gametic%BACKUPTICS] = Consistancy();
@@ -6064,6 +6064,7 @@ void CL_ClearRewinds(void)
 
 rewind_t *CL_SaveRewindPoint(size_t demopos)
 {
+	savebuffer_t save;
 	rewind_t *rewind;
 
 	if (rewindhead && rewindhead->leveltime + REWIND_POINT_INTERVAL > leveltime)
@@ -6073,8 +6074,10 @@ rewind_t *CL_SaveRewindPoint(size_t demopos)
 	if (!rewind)
 		return NULL;
 
-	save_p = rewind->savebuffer;
-	P_SaveNetGame(false);
+	save.buffer = save.p = rewind->savebuffer;
+
+	P_SaveNetGame(&save, false);
+
 	rewind->leveltime = leveltime;
 	rewind->next = rewindhead;
 	rewind->demopos = demopos;
@@ -6085,6 +6088,7 @@ rewind_t *CL_SaveRewindPoint(size_t demopos)
 
 rewind_t *CL_RewindToTime(tic_t time)
 {
+	savebuffer_t save;
 	rewind_t *rewind;
 
 	while (rewindhead && rewindhead->leveltime > time)
@@ -6097,8 +6101,10 @@ rewind_t *CL_RewindToTime(tic_t time)
 	if (!rewindhead)
 		return NULL;
 
-	save_p = rewindhead->savebuffer;
-	P_LoadNetGame(false);
+	save.buffer = save.p = rewindhead->savebuffer;
+
+	P_LoadNetGame(&save, false);
+
 	wipegamestate = gamestate; // No fading back in!
 	timeinmap = leveltime;
 
diff --git a/src/d_netcmd.c b/src/d_netcmd.c
index 9679b5631..22aca4b35 100644
--- a/src/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -5776,10 +5776,9 @@ static void Command_Togglemodified_f(void)
 	modifiedgame = !modifiedgame;
 }
 
-extern UINT8 *save_p;
 static void Command_Archivetest_f(void)
 {
-	UINT8 *buf;
+	savebuffer_t save;
 	UINT32 i, wrote;
 	thinker_t *th;
 	if (gamestate != GS_LEVEL)
@@ -5795,28 +5794,28 @@ static void Command_Archivetest_f(void)
 			((mobj_t *)th)->mobjnum = i++;
 
 	// allocate buffer
-	buf = save_p = ZZ_Alloc(1024);
+	save.buffer = save.p = ZZ_Alloc(1024);
 
 	// test archive
 	CONS_Printf("LUA_Archive...\n");
-	LUA_Archive(&save_p);
-	WRITEUINT8(save_p, 0x7F);
-	wrote = (UINT32)(save_p-buf);
+	LUA_Archive(&save.p, true);
+	WRITEUINT8(save.p, 0x7F);
+	wrote = (UINT32)(save.p - save.buffer);
 
 	// clear Lua state, so we can really see what happens!
 	CONS_Printf("Clearing state!\n");
 	LUA_ClearExtVars();
 
 	// test unarchive
-	save_p = buf;
+	save.p = save.buffer;
 	CONS_Printf("LUA_UnArchive...\n");
-	LUA_UnArchive(&save_p);
-	i = READUINT8(save_p);
-	if (i != 0x7F || wrote != (UINT32)(save_p-buf))
-		CONS_Printf("Savegame corrupted. (write %u, read %u)\n", wrote, (UINT32)(save_p-buf));
+	LUA_UnArchive(&save.p, true);
+	i = READUINT8(save.p);
+	if (i != 0x7F || wrote != (UINT32)(save.p - save.buffer))
+		CONS_Printf("Savegame corrupted. (write %u, read %u)\n", wrote, (UINT32)(save.p - save.buffer));
 
 	// free buffer
-	Z_Free(buf);
+	Z_Free(save.buffer);
 	CONS_Printf("Done. No crash.\n");
 }
 #endif
diff --git a/src/g_demo.c b/src/g_demo.c
index e47d8ba28..298f887e5 100644
--- a/src/g_demo.c
+++ b/src/g_demo.c
@@ -2502,7 +2502,7 @@ void G_BeginRecording(void)
 
 	// player lua vars, always saved even if empty
 	if (demoflags & DF_LUAVARS)
-		LUA_Archive(&demo_p);
+		LUA_Archive(&demo_p, false);
 
 	memset(&oldcmd,0,sizeof(oldcmd));
 	memset(&oldghost,0,sizeof(oldghost));
@@ -3366,7 +3366,7 @@ void G_DoPlayDemo(char *defdemoname)
 			LUA_ClearState();
 
 		// No modeattacking check, DF_LUAVARS won't be present here.
-		LUA_UnArchive(&demo_p);
+		LUA_UnArchive(&demo_p, false);
 	}
 
 	splitscreen = 0;
diff --git a/src/g_game.c b/src/g_game.c
index fb49b598c..7787d05ea 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -343,8 +343,6 @@ boolean precache = true; // if true, load all graphics at start
 
 INT16 prevmap, nextmap;
 
-static UINT8 *savebuffer;
-
 static void weaponPrefChange(void);
 static void weaponPrefChange2(void);
 static void weaponPrefChange3(void);
@@ -4311,6 +4309,7 @@ void G_LoadGameData(void)
 	UINT32 versionID;
 	UINT8 versionMinor;
 	UINT8 rtemp;
+	savebuffer_t save;
 
 	//For records
 	UINT32 numgamedatamapheaders;
@@ -4339,7 +4338,7 @@ void G_LoadGameData(void)
 		return; 
 	}
 
-	length = FIL_ReadFile(va(pandf, srb2home, gamedatafilename), &savebuffer);
+	length = FIL_ReadFile(va(pandf, srb2home, gamedatafilename), &save.buffer);
 	if (!length)
 	{
 		// No gamedata. We can save a new one.
@@ -4347,35 +4346,35 @@ void G_LoadGameData(void)
 		return;
 	}
 
-	save_p = savebuffer;
+	save.p = save.buffer;
 
 	// Version check
-	versionID = READUINT32(save_p);
+	versionID = READUINT32(save.p);
 	if (versionID != GD_VERSIONCHECK)
 	{
 		const char *gdfolder = "the Ring Racers folder";
 		if (strcmp(srb2home,"."))
 			gdfolder = srb2home;
 
-		Z_Free(savebuffer);
-		save_p = NULL;
+		Z_Free(save.buffer);
+		save.p = NULL;
 		I_Error("Game data is not for Ring Racers v2.0.\nDelete %s(maybe in %s) and try again.", gamedatafilename, gdfolder);
 	}
 
-	versionMinor = READUINT8(save_p);
+	versionMinor = READUINT8(save.p);
 	if (versionMinor > GD_VERSIONMINOR)
 	{
-		Z_Free(savebuffer);
-		save_p = NULL;
+		Z_Free(save.buffer);
+		save.p = NULL;
 		I_Error("Game data is from the future! (expected %d, got %d)", GD_VERSIONMINOR, versionMinor);
 	}
 
-	gamedata->totalplaytime = READUINT32(save_p);
-	gamedata->matchesplayed = READUINT32(save_p);
+	gamedata->totalplaytime = READUINT32(save.p);
+	gamedata->matchesplayed = READUINT32(save.p);
 
 	{
 		// Quick & dirty hash for what mod this save file is for.
-		UINT32 modID = READUINT32(save_p);
+		UINT32 modID = READUINT32(save.p);
 		UINT32 expectedID = quickncasehash(timeattackfolder, 64);
 
 		if (modID != expectedID)
@@ -4388,34 +4387,34 @@ void G_LoadGameData(void)
 	// To save space, use one bit per collected/achieved/unlocked flag
 	for (i = 0; i < MAXEMBLEMS;)
 	{
-		rtemp = READUINT8(save_p);
+		rtemp = READUINT8(save.p);
 		for (j = 0; j < 8 && j+i < MAXEMBLEMS; ++j)
 			gamedata->collected[j+i] = ((rtemp >> j) & 1);
 		i += j;
 	}
 	for (i = 0; i < MAXUNLOCKABLES;)
 	{
-		rtemp = READUINT8(save_p);
+		rtemp = READUINT8(save.p);
 		for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
 			gamedata->unlocked[j+i] = ((rtemp >> j) & 1);
 		i += j;
 	}
 	for (i = 0; i < MAXUNLOCKABLES;)
 	{
-		rtemp = READUINT8(save_p);
+		rtemp = READUINT8(save.p);
 		for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
 			gamedata->unlockpending[j+i] = ((rtemp >> j) & 1);
 		i += j;
 	}
 	for (i = 0; i < MAXCONDITIONSETS;)
 	{
-		rtemp = READUINT8(save_p);
+		rtemp = READUINT8(save.p);
 		for (j = 0; j < 8 && j+i < MAXCONDITIONSETS; ++j)
 			gamedata->achieved[j+i] = ((rtemp >> j) & 1);
 		i += j;
 	}
 
-	gamedata->challengegridwidth = READUINT16(save_p);
+	gamedata->challengegridwidth = READUINT16(save.p);
 	Z_Free(gamedata->challengegrid);
 	if (gamedata->challengegridwidth)
 	{
@@ -4424,7 +4423,7 @@ void G_LoadGameData(void)
 			PU_STATIC, NULL);
 		for (i = 0; i < (gamedata->challengegridwidth * CHALLENGEGRIDHEIGHT); i++)
 		{
-			gamedata->challengegrid[i] = READUINT8(save_p);
+			gamedata->challengegrid[i] = READUINT8(save.p);
 		}
 	}
 	else
@@ -4432,10 +4431,10 @@ void G_LoadGameData(void)
 		gamedata->challengegrid = NULL;
 	}
 
-	gamedata->timesBeaten = READUINT32(save_p);
+	gamedata->timesBeaten = READUINT32(save.p);
 
 	// Main records
-	numgamedatamapheaders = READUINT32(save_p);
+	numgamedatamapheaders = READUINT32(save.p);
 	if (numgamedatamapheaders >= NEXTMAP_SPECIAL)
 		goto datacorrupt;
 
@@ -4446,12 +4445,12 @@ void G_LoadGameData(void)
 		tic_t rectime;
 		tic_t reclap;
 
-		READSTRINGN(save_p, mapname, sizeof(mapname));
+		READSTRINGN(save.p, mapname, sizeof(mapname));
 		mapnum = G_MapNumber(mapname);
 
-		rtemp = READUINT8(save_p);
-		rectime = (tic_t)READUINT32(save_p);
-		reclap  = (tic_t)READUINT32(save_p);
+		rtemp = READUINT8(save.p);
+		rectime = (tic_t)READUINT32(save.p);
+		reclap  = (tic_t)READUINT32(save.p);
 
 		if (mapnum < nummapheaders && mapheaderinfo[mapnum])
 		{
@@ -4477,8 +4476,8 @@ void G_LoadGameData(void)
 	}
 
 	// done
-	Z_Free(savebuffer);
-	save_p = NULL;
+	Z_Free(save.buffer);
+	save.p = NULL;
 
 	// Don't consider loaded until it's a success!
 	// It used to do this much earlier, but this would cause the gamedata to
@@ -4498,8 +4497,8 @@ void G_LoadGameData(void)
 		if (strcmp(srb2home,"."))
 			gdfolder = srb2home;
 
-		Z_Free(savebuffer);
-		save_p = NULL;
+		Z_Free(save.buffer);
+		save.p = NULL;
 
 		I_Error("Corrupt game data file.\nDelete %s(maybe in %s) and try again.", gamedatafilename, gdfolder);
 	}
@@ -4512,6 +4511,7 @@ void G_SaveGameData(void)
 	size_t length;
 	INT32 i, j;
 	UINT8 btemp;
+	savebuffer_t save;
 
 	if (!gamedata->loaded)
 		return; // If never loaded (-nodata), don't save
@@ -4531,8 +4531,8 @@ void G_SaveGameData(void)
 	}
 	length += nummapheaders * (MAXMAPLUMPNAME+1+4+4);
 
-	save_p = savebuffer = (UINT8 *)malloc(length);
-	if (!save_p)
+	save.p = save.buffer = (UINT8 *)malloc(length);
+	if (!save.p)
 	{
 		CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
 		return;
@@ -4540,11 +4540,11 @@ void G_SaveGameData(void)
 
 	// Version test
 
-	WRITEUINT32(save_p, GD_VERSIONCHECK); // 4
-	WRITEUINT8(save_p, GD_VERSIONMINOR); // 1
-	WRITEUINT32(save_p, gamedata->totalplaytime); // 4
-	WRITEUINT32(save_p, gamedata->matchesplayed); // 4
-	WRITEUINT32(save_p, quickncasehash(timeattackfolder, 64));
+	WRITEUINT32(save.p, GD_VERSIONCHECK); // 4
+	WRITEUINT8(save.p, GD_VERSIONMINOR); // 1
+	WRITEUINT32(save.p, gamedata->totalplaytime); // 4
+	WRITEUINT32(save.p, gamedata->matchesplayed); // 4
+	WRITEUINT32(save.p, quickncasehash(timeattackfolder, 64));
 
 	// To save space, use one bit per collected/achieved/unlocked flag
 	for (i = 0; i < MAXEMBLEMS;) // MAXEMBLEMS * 1;
@@ -4552,7 +4552,7 @@ void G_SaveGameData(void)
 		btemp = 0;
 		for (j = 0; j < 8 && j+i < MAXEMBLEMS; ++j)
 			btemp |= (gamedata->collected[j+i] << j);
-		WRITEUINT8(save_p, btemp);
+		WRITEUINT8(save.p, btemp);
 		i += j;
 	}
 
@@ -4562,7 +4562,7 @@ void G_SaveGameData(void)
 		btemp = 0;
 		for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
 			btemp |= (gamedata->unlocked[j+i] << j);
-		WRITEUINT8(save_p, btemp);
+		WRITEUINT8(save.p, btemp);
 		i += j;
 	}
 	for (i = 0; i < MAXUNLOCKABLES;)
@@ -4570,7 +4570,7 @@ void G_SaveGameData(void)
 		btemp = 0;
 		for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
 			btemp |= (gamedata->unlockpending[j+i] << j);
-		WRITEUINT8(save_p, btemp);
+		WRITEUINT8(save.p, btemp);
 		i += j;
 	}
 
@@ -4579,52 +4579,52 @@ void G_SaveGameData(void)
 		btemp = 0;
 		for (j = 0; j < 8 && j+i < MAXCONDITIONSETS; ++j)
 			btemp |= (gamedata->achieved[j+i] << j);
-		WRITEUINT8(save_p, btemp);
+		WRITEUINT8(save.p, btemp);
 		i += j;
 	}
 
 	if (gamedata->challengegrid) // 2 + gamedata->challengegridwidth * CHALLENGEGRIDHEIGHT
 	{
-		WRITEUINT16(save_p, gamedata->challengegridwidth);
+		WRITEUINT16(save.p, gamedata->challengegridwidth);
 		for (i = 0; i < (gamedata->challengegridwidth * CHALLENGEGRIDHEIGHT); i++)
 		{
-			WRITEUINT8(save_p, gamedata->challengegrid[i]);
+			WRITEUINT8(save.p, gamedata->challengegrid[i]);
 		}
 	}
 	else // 2
 	{
-		WRITEUINT16(save_p, 0);
+		WRITEUINT16(save.p, 0);
 	}
 
-	WRITEUINT32(save_p, gamedata->timesBeaten); // 4
+	WRITEUINT32(save.p, gamedata->timesBeaten); // 4
 
 	// Main records
-	WRITEUINT32(save_p, nummapheaders); // 4
+	WRITEUINT32(save.p, nummapheaders); // 4
 
 	for (i = 0; i < nummapheaders; i++) // nummapheaders * (255+1+4+4)
 	{
 		// For figuring out which header to assing it to on load
-		WRITESTRINGN(save_p, mapheaderinfo[i]->lumpname, MAXMAPLUMPNAME);
+		WRITESTRINGN(save.p, mapheaderinfo[i]->lumpname, MAXMAPLUMPNAME);
 
-		WRITEUINT8(save_p, (mapheaderinfo[i]->mapvisited & MV_MAX));
+		WRITEUINT8(save.p, (mapheaderinfo[i]->mapvisited & MV_MAX));
 
 		if (mapheaderinfo[i]->mainrecord)
 		{
-			WRITEUINT32(save_p, mapheaderinfo[i]->mainrecord->time);
-			WRITEUINT32(save_p, mapheaderinfo[i]->mainrecord->lap);
+			WRITEUINT32(save.p, mapheaderinfo[i]->mainrecord->time);
+			WRITEUINT32(save.p, mapheaderinfo[i]->mainrecord->lap);
 		}
 		else
 		{
-			WRITEUINT32(save_p, 0);
-			WRITEUINT32(save_p, 0);
+			WRITEUINT32(save.p, 0);
+			WRITEUINT32(save.p, 0);
 		}
 	}
 
-	length = save_p - savebuffer;
+	length = save.p - save.buffer;
 
-	FIL_WriteFile(va(pandf, srb2home, gamedatafilename), savebuffer, length);
-	free(savebuffer);
-	save_p = savebuffer = NULL;
+	FIL_WriteFile(va(pandf, srb2home, gamedatafilename), save.buffer, length);
+	free(save.buffer);
+	save.p = save.buffer = NULL;
 
 	// Also save profiles here.
 	PR_SaveProfiles();
@@ -4641,6 +4641,7 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	size_t length;
 	char vcheck[VERSIONSIZE];
 	char savename[255];
+	savebuffer_t save;
 
 	// memset savedata to all 0, fixes calling perfectly valid saves corrupt because of bots
 	memset(&savedata, 0, sizeof(savedata));
@@ -4655,18 +4656,18 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	else
 		sprintf(savename, savegamename, slot);
 
-	length = FIL_ReadFile(savename, &savebuffer);
+	length = FIL_ReadFile(savename, &save.buffer);
 	if (!length)
 	{
 		CONS_Printf(M_GetText("Couldn't read file %s\n"), savename);
 		return;
 	}
 
-	save_p = savebuffer;
+	save.p = save.buffer;
 
 	memset(vcheck, 0, sizeof (vcheck));
 	sprintf(vcheck, (marathonmode ? "back-up %d" : "version %d"), VERSION);
-	if (strcmp((const char *)save_p, (const char *)vcheck))
+	if (strcmp((const char *)save.p, (const char *)vcheck))
 	{
 #ifdef SAVEGAME_OTHERVERSIONS
 		M_StartMessage(M_GetText("Save game from different version.\nYou can load this savegame, but\nsaving afterwards will be disabled.\n\nDo you want to continue anyway?\n\n(Press 'Y' to confirm)\n"),
@@ -4676,15 +4677,15 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 		M_ClearMenus(true); // so ESC backs out to title
 		M_StartMessage(M_GetText("Save game from different version\n\nPress ESC\n"), NULL, MM_NOTHING);
 		Command_ExitGame_f();
-		Z_Free(savebuffer);
-		save_p = savebuffer = NULL;
+		Z_Free(save.buffer);
+		save.p = save.buffer = NULL;
 
 		// no cheating!
 		memset(&savedata, 0, sizeof(savedata));
 #endif
 		return; // bad version
 	}
-	save_p += VERSIONSIZE;
+	save.p += VERSIONSIZE;
 
 	if (demo.playback) // reset game engine
 		G_StopDemo();
@@ -4693,13 +4694,13 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 //	automapactive = false;
 
 	// dearchive all the modifications
-	if (!P_LoadGame(mapoverride))
+	if (!P_LoadGame(&save, mapoverride))
 	{
 		M_ClearMenus(true); // so ESC backs out to title
 		M_StartMessage(M_GetText("Savegame file corrupted\n\nPress ESC\n"), NULL, MM_NOTHING);
 		Command_ExitGame_f();
-		Z_Free(savebuffer);
-		save_p = savebuffer = NULL;
+		Z_Free(save.buffer);
+		save.p = save.buffer = NULL;
 
 		// no cheating!
 		memset(&savedata, 0, sizeof(savedata));
@@ -4707,13 +4708,13 @@ void G_LoadGame(UINT32 slot, INT16 mapoverride)
 	}
 	if (marathonmode)
 	{
-		marathontime = READUINT32(save_p);
-		marathonmode |= READUINT8(save_p);
+		marathontime = READUINT32(save.p);
+		marathonmode |= READUINT8(save.p);
 	}
 
 	// done
-	Z_Free(savebuffer);
-	save_p = savebuffer = NULL;
+	Z_Free(save.buffer);
+	save.p = save.buffer = NULL;
 
 //	gameaction = ga_nothing;
 //	G_SetGamestate(GS_LEVEL);
@@ -4739,6 +4740,7 @@ void G_SaveGame(UINT32 slot, INT16 mapnum)
 	boolean saved;
 	char savename[256] = "";
 	const char *backup;
+	savebuffer_t save;
 
 	if (marathonmode)
 		strcpy(savename, liveeventbackup);
@@ -4751,8 +4753,8 @@ void G_SaveGame(UINT32 slot, INT16 mapnum)
 		char name[VERSIONSIZE];
 		size_t length;
 
-		save_p = savebuffer = (UINT8 *)malloc(SAVEGAMESIZE);
-		if (!save_p)
+		save.p = save.buffer = (UINT8 *)malloc(SAVEGAMESIZE);
+		if (!save.p)
 		{
 			CONS_Alert(CONS_ERROR, M_GetText("No more free memory for saving game data\n"));
 			return;
@@ -4760,22 +4762,22 @@ void G_SaveGame(UINT32 slot, INT16 mapnum)
 
 		memset(name, 0, sizeof (name));
 		sprintf(name, (marathonmode ? "back-up %d" : "version %d"), VERSION);
-		WRITEMEM(save_p, name, VERSIONSIZE);
+		WRITEMEM(save.p, name, VERSIONSIZE);
 
-		P_SaveGame(mapnum);
+		P_SaveGame(&save, mapnum);
 		if (marathonmode)
 		{
 			UINT32 writetime = marathontime;
 			if (!(marathonmode & MA_INGAME))
 				writetime += TICRATE*5; // live event backup penalty because we don't know how long it takes to get to the next map
-			WRITEUINT32(save_p, writetime);
-			WRITEUINT8(save_p, (marathonmode & ~MA_INIT));
+			WRITEUINT32(save.p, writetime);
+			WRITEUINT8(save.p, (marathonmode & ~MA_INIT));
 		}
 
-		length = save_p - savebuffer;
-		saved = FIL_WriteFile(backup, savebuffer, length);
-		free(savebuffer);
-		save_p = savebuffer = NULL;
+		length = save.p - save.buffer;
+		saved = FIL_WriteFile(backup, save.buffer, length);
+		free(save.buffer);
+		save.p = save.buffer = NULL;
 	}
 
 	gameaction = ga_nothing;
@@ -4787,7 +4789,7 @@ void G_SaveGame(UINT32 slot, INT16 mapnum)
 }
 
 #define BADSAVE goto cleanup;
-#define CHECKPOS if (save_p >= end_p) BADSAVE
+#define CHECKPOS if (save.p >= end_p) BADSAVE
 void G_SaveGameOver(UINT32 slot, boolean modifylives)
 {
 	boolean saved = false;
@@ -4795,6 +4797,7 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
 	char vcheck[VERSIONSIZE];
 	char savename[255];
 	const char *backup;
+	savebuffer_t save;
 
 	if (marathonmode)
 		strcpy(savename, liveeventbackup);
@@ -4802,7 +4805,7 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
 		sprintf(savename, savegamename, slot);
 	backup = va("%s",savename);
 
-	length = FIL_ReadFile(savename, &savebuffer);
+	length = FIL_ReadFile(savename, &save.buffer);
 	if (!length)
 	{
 		CONS_Printf(M_GetText("Couldn't read file %s\n"), savename);
@@ -4811,35 +4814,35 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
 
 	{
 		char temp[sizeof(timeattackfolder)];
-		UINT8 *end_p = savebuffer + length;
+		UINT8 *end_p = save.buffer + length;
 		UINT8 *lives_p;
 		SINT8 pllives;
 
-		save_p = savebuffer;
+		save.p = save.buffer;
 		// Version check
 		memset(vcheck, 0, sizeof (vcheck));
 		sprintf(vcheck, (marathonmode ? "back-up %d" : "version %d"), VERSION);
-		if (strcmp((const char *)save_p, (const char *)vcheck)) BADSAVE
-		save_p += VERSIONSIZE;
+		if (strcmp((const char *)save.p, (const char *)vcheck)) BADSAVE
+		save.p += VERSIONSIZE;
 
 		// P_UnArchiveMisc()
-		(void)READINT16(save_p);
+		(void)READINT16(save.p);
 		CHECKPOS
-		(void)READUINT16(save_p); // emeralds
+		(void)READUINT16(save.p); // emeralds
 		CHECKPOS
-		READSTRINGN(save_p, temp, sizeof(temp)); // mod it belongs to
+		READSTRINGN(save.p, temp, sizeof(temp)); // mod it belongs to
 		if (strcmp(temp, timeattackfolder)) BADSAVE
 
 		// P_UnArchivePlayer()
 		CHECKPOS
-		(void)READUINT16(save_p);
+		(void)READUINT16(save.p);
 		CHECKPOS
 
-		WRITEUINT8(save_p, numgameovers);
+		WRITEUINT8(save.p, numgameovers);
 		CHECKPOS
 
-		lives_p = save_p;
-		pllives = READSINT8(save_p); // lives
+		lives_p = save.p;
+		pllives = READSINT8(save.p); // lives
 		CHECKPOS
 		if (modifylives && pllives < startinglivesbalance[numgameovers])
 		{
@@ -4847,28 +4850,28 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
 			WRITESINT8(lives_p, pllives);
 		}
 
-		(void)READINT32(save_p); // Score
+		(void)READINT32(save.p); // Score
 		CHECKPOS
-		(void)READINT32(save_p); // continues
+		(void)READINT32(save.p); // continues
 
 		// File end marker check
 		CHECKPOS
-		switch (READUINT8(save_p))
+		switch (READUINT8(save.p))
 		{
 			case 0xb7:
 				{
 					UINT8 i, banksinuse;
 					CHECKPOS
-					banksinuse = READUINT8(save_p);
+					banksinuse = READUINT8(save.p);
 					CHECKPOS
 					if (banksinuse > NUM_LUABANKS)
 						BADSAVE
 					for (i = 0; i < banksinuse; i++)
 					{
-						(void)READINT32(save_p);
+						(void)READINT32(save.p);
 						CHECKPOS
 					}
-					if (READUINT8(save_p) != 0x1d)
+					if (READUINT8(save.p) != 0x1d)
 						BADSAVE
 				}
 			case 0x1d:
@@ -4878,7 +4881,7 @@ void G_SaveGameOver(UINT32 slot, boolean modifylives)
 		}
 
 		// done
-		saved = FIL_WriteFile(backup, savebuffer, length);
+		saved = FIL_WriteFile(backup, save.buffer, length);
 	}
 
 cleanup:
@@ -4886,8 +4889,8 @@ cleanup:
 		CONS_Printf(M_GetText("Game saved.\n"));
 	else if (!saved)
 		CONS_Alert(CONS_ERROR, M_GetText("Error while writing to %s for save slot %u, base: %s\n"), backup, slot, (marathonmode ? liveeventbackup : savegamename));
-	Z_Free(savebuffer);
-	save_p = savebuffer = NULL;
+	Z_Free(save.buffer);
+	save.p = save.buffer = NULL;
 
 }
 #undef CHECKPOS
diff --git a/src/k_profiles.c b/src/k_profiles.c
index 8b3712ed0..f24d623ab 100644
--- a/src/k_profiles.c
+++ b/src/k_profiles.c
@@ -10,9 +10,10 @@
 /// \file  k_profiles.c
 /// \brief implements methods for profiles etc.
 
+#include "doomtype.h"
 #include "d_main.h" // pandf
 #include "byteptr.h" // READ/WRITE macros
-#include "p_saveg.h" // save_p
+#include "p_saveg.h" // savebuffer_t
 #include "m_misc.h" //FIL_WriteFile()
 #include "k_profiles.h"
 #include "z_zone.h"
@@ -211,68 +212,67 @@ void PR_InitNewProfile(void)
 	PR_AddProfile(dprofile);
 }
 
-static UINT8 *savebuffer;
-
 void PR_SaveProfiles(void)
 {
 	size_t length = 0;
 	const size_t headerlen = strlen(PROFILEHEADER);
 	UINT8 i, j, k;
+	savebuffer_t save;
 
-	save_p = savebuffer = (UINT8 *)malloc(sizeof(UINT32) + (numprofiles * sizeof(profile_t)));
-	if (!save_p)
+	save.p = save.buffer = (UINT8 *)malloc(sizeof(UINT32) + (numprofiles * sizeof(profile_t)));
+	if (!save.p)
 	{
 		I_Error("No more free memory for saving profiles\n");
 		return;
 	}
 
 	// Add header.
-	WRITESTRINGN(save_p, PROFILEHEADER, headerlen);
-	WRITEUINT8(save_p, PROFILEVER);
-	WRITEUINT8(save_p, numprofiles);
+	WRITESTRINGN(save.p, PROFILEHEADER, headerlen);
+	WRITEUINT8(save.p, PROFILEVER);
+	WRITEUINT8(save.p, numprofiles);
 
 	for (i = 1; i < numprofiles; i++)
 	{
 		// Names.
-		WRITESTRINGN(save_p, profilesList[i]->profilename, PROFILENAMELEN);
-		WRITESTRINGN(save_p, profilesList[i]->playername, MAXPLAYERNAME);
+		WRITESTRINGN(save.p, profilesList[i]->profilename, PROFILENAMELEN);
+		WRITESTRINGN(save.p, profilesList[i]->playername, MAXPLAYERNAME);
 
 		// Character and colour.
-		WRITESTRINGN(save_p, profilesList[i]->skinname, SKINNAMESIZE);
-		WRITEUINT16(save_p, profilesList[i]->color);
+		WRITESTRINGN(save.p, profilesList[i]->skinname, SKINNAMESIZE);
+		WRITEUINT16(save.p, profilesList[i]->color);
 
 		// Follower and colour.
-		WRITESTRINGN(save_p, profilesList[i]->follower, SKINNAMESIZE);
-		WRITEUINT16(save_p, profilesList[i]->followercolor);
+		WRITESTRINGN(save.p, profilesList[i]->follower, SKINNAMESIZE);
+		WRITEUINT16(save.p, profilesList[i]->followercolor);
 
 		// PWR.
 		for (j = 0; j < PWRLV_NUMTYPES; j++)
 		{
-			WRITEUINT16(save_p, profilesList[i]->powerlevels[j]);
+			WRITEUINT16(save.p, profilesList[i]->powerlevels[j]);
 		}
 
 		// Consvars.
-		WRITEUINT8(save_p, profilesList[i]->kickstartaccel);
+		WRITEUINT8(save.p, profilesList[i]->kickstartaccel);
 
 		// Controls.
 		for (j = 0; j < num_gamecontrols; j++)
 		{
 			for (k = 0; k < MAXINPUTMAPPING; k++)
 			{
-				WRITEINT32(save_p, profilesList[i]->controls[j][k]);
+				WRITEINT32(save.p, profilesList[i]->controls[j][k]);
 			}
 		}
 	}
 
-	length = save_p - savebuffer;
+	length = save.p - save.buffer;
 
-	if (!FIL_WriteFile(va(pandf, srb2home, PROFILESFILE), savebuffer, length))
+	if (!FIL_WriteFile(va(pandf, srb2home, PROFILESFILE), save.buffer, length))
 	{
-		free(savebuffer);
+		free(save.buffer);
 		I_Error("Couldn't save profiles. Are you out of Disk space / playing in a protected folder?");
 	}
-	free(savebuffer);
-	save_p = savebuffer = NULL;
+	free(save.buffer);
+	save.p = save.buffer = NULL;
 }
 
 void PR_LoadProfiles(void)
@@ -288,8 +288,9 @@ void PR_LoadProfiles(void)
 		gamecontroldefault,
 		true
 	);
+	savebuffer_t save;
 
-	length = FIL_ReadFile(va(pandf, srb2home, PROFILESFILE), &savebuffer);
+	length = FIL_ReadFile(va(pandf, srb2home, PROFILESFILE), &save.buffer);
 	if (!length)
 	{
 		// No profiles. Add the default one.
@@ -297,29 +298,29 @@ void PR_LoadProfiles(void)
 		return;
 	}
 
-	save_p = savebuffer;
+	save.p = save.buffer;
 
-	if (strncmp(PROFILEHEADER, (const char *)savebuffer, headerlen))
+	if (strncmp(PROFILEHEADER, (const char *)save.buffer, headerlen))
 	{
 		const char *gdfolder = "the Ring Racers folder";
 		if (strcmp(srb2home,"."))
 			gdfolder = srb2home;
 
-		Z_Free(savebuffer);
-		save_p = NULL;
+		Z_Free(save.buffer);
+		save.p = NULL;
 		I_Error("Not a valid Profile file.\nDelete %s (maybe in %s) and try again.", PROFILESFILE, gdfolder);
 	}
-	save_p += headerlen;
+	save.p += headerlen;
 
-	version = READUINT8(save_p);
+	version = READUINT8(save.p);
 	if (version > PROFILEVER)
 	{
-		Z_Free(savebuffer);
-		save_p = NULL;
+		Z_Free(save.buffer);
+		save.p = NULL;
 		I_Error("Existing %s is from the future! (expected %d, got %d)", PROFILESFILE, PROFILEVER, version);
 	}
 
-	numprofiles = READUINT8(save_p);
+	numprofiles = READUINT8(save.p);
 	if (numprofiles > MAXPROFILES)
 		numprofiles = MAXPROFILES;
 
@@ -331,12 +332,12 @@ void PR_LoadProfiles(void)
 		profilesList[i]->version = PROFILEVER;
 
 		// Names.
-		READSTRINGN(save_p, profilesList[i]->profilename, PROFILENAMELEN);
-		READSTRINGN(save_p, profilesList[i]->playername, MAXPLAYERNAME);
+		READSTRINGN(save.p, profilesList[i]->profilename, PROFILENAMELEN);
+		READSTRINGN(save.p, profilesList[i]->playername, MAXPLAYERNAME);
 
 		// Character and colour.
-		READSTRINGN(save_p, profilesList[i]->skinname, SKINNAMESIZE);
-		profilesList[i]->color = READUINT16(save_p);
+		READSTRINGN(save.p, profilesList[i]->skinname, SKINNAMESIZE);
+		profilesList[i]->color = READUINT16(save.p);
 
 		if (profilesList[i]->color == SKINCOLOR_NONE)
 		{
@@ -349,8 +350,8 @@ void PR_LoadProfiles(void)
 		}
 
 		// Follower and colour.
-		READSTRINGN(save_p, profilesList[i]->follower, SKINNAMESIZE);
-		profilesList[i]->followercolor = READUINT16(save_p);
+		READSTRINGN(save.p, profilesList[i]->follower, SKINNAMESIZE);
+		profilesList[i]->followercolor = READUINT16(save.p);
 
 		if (profilesList[i]->followercolor == FOLLOWERCOLOR_MATCH
 			|| profilesList[i]->followercolor == FOLLOWERCOLOR_OPPOSITE)
@@ -367,7 +368,7 @@ void PR_LoadProfiles(void)
 		// PWR.
 		for (j = 0; j < PWRLV_NUMTYPES; j++)
 		{
-			profilesList[i]->powerlevels[j] = READUINT16(save_p);
+			profilesList[i]->powerlevels[j] = READUINT16(save.p);
 			if (profilesList[i]->powerlevels[j] < PWRLVRECORD_MIN
 				|| profilesList[i]->powerlevels[j] > PWRLVRECORD_MAX)
 			{
@@ -377,7 +378,7 @@ void PR_LoadProfiles(void)
 		}
 
 		// Consvars.
-		profilesList[i]->kickstartaccel = (boolean)READUINT8(save_p);
+		profilesList[i]->kickstartaccel = (boolean)READUINT8(save.p);
 
 		// Controls.
 		for (j = 0; j < num_gamecontrols; j++)
@@ -396,7 +397,7 @@ void PR_LoadProfiles(void)
 
 			for (k = 0; k < MAXINPUTMAPPING; k++)
 			{
-				profilesList[i]->controls[j][k] = READINT32(save_p);
+				profilesList[i]->controls[j][k] = READINT32(save.p);
 			}
 		}
 	}
diff --git a/src/lua_script.c b/src/lua_script.c
index 4f9eab969..5f12ab416 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -41,6 +41,8 @@ lua_State *gL = NULL;
 
 int hook_defrosting;
 
+static UINT8 **lua_save_p = NULL; // FIXME: Remove this horrible hack
+
 // List of internal libraries to load from SRB2
 static lua_CFunction liblist[] = {
 	LUA_EnumLib, // global metatable for enums
@@ -1248,10 +1250,10 @@ static UINT8 ArchiveValue(UINT8 **p, int TABLESINDEX, int myindex)
 		{
 			polyobj_t *polyobj = *((polyobj_t **)lua_touserdata(gL, myindex));
 			if (!polyobj)
-				WRITEUINT8(save_p, ARCH_NULL);
+				WRITEUINT8(*p, ARCH_NULL);
 			else {
-				WRITEUINT8(save_p, ARCH_POLYOBJ);
-				WRITEUINT16(save_p, polyobj-PolyObjects);
+				WRITEUINT8(*p, ARCH_POLYOBJ);
+				WRITEUINT16(*p, polyobj-PolyObjects);
 			}
 			break;
 		}
@@ -1355,7 +1357,7 @@ static int NetArchive(lua_State *L)
 	int TABLESINDEX = lua_upvalueindex(1);
 	int i, n = lua_gettop(L);
 	for (i = 1; i <= n; i++)
-		ArchiveValue(&save_p, TABLESINDEX, i);
+		ArchiveValue(lua_save_p, TABLESINDEX, i);
 	return n;
 }
 
@@ -1517,7 +1519,7 @@ static UINT8 UnArchiveValue(UINT8 **p, int TABLESINDEX)
 		break;
 	}
 	case ARCH_POLYOBJ:
-		LUA_PushUserdata(gL, &PolyObjects[READUINT16(save_p)], META_POLYOBJ);
+		LUA_PushUserdata(gL, &PolyObjects[READUINT16(*p)], META_POLYOBJ);
 		break;
 	case ARCH_SLOPE:
 		LUA_PushUserdata(gL, P_SlopeById(READUINT16(*p)), META_SLOPE);
@@ -1568,7 +1570,7 @@ static int NetUnArchive(lua_State *L)
 	int TABLESINDEX = lua_upvalueindex(1);
 	int i, n = lua_gettop(L);
 	for (i = 1; i <= n; i++)
-		UnArchiveValue(&save_p, TABLESINDEX);
+		UnArchiveValue(lua_save_p, TABLESINDEX);
 	return n;
 }
 
@@ -1602,7 +1604,7 @@ static void UnArchiveTables(UINT8 **p)
 				lua_rawset(gL, -3);
 		}
 
-		metatableid = READUINT16(save_p);
+		metatableid = READUINT16(*p);
 		if (metatableid)
 		{
 			// setmetatable(table, registry.metatables[metatableid])
@@ -1626,7 +1628,7 @@ void LUA_Step(void)
 	lua_gc(gL, LUA_GCSTEP, 1);
 }
 
-void LUA_Archive(UINT8 **p)
+void LUA_Archive(UINT8 **p, boolean network)
 {
 	INT32 i;
 	thinker_t *th;
@@ -1642,7 +1644,7 @@ void LUA_Archive(UINT8 **p)
 		ArchiveExtVars(p, &players[i], "player");
 	}
 
-	if (p == &save_p)
+	if (network == true)
 	{
 		if (gamestate == GS_LEVEL)
 		{
@@ -1659,6 +1661,7 @@ void LUA_Archive(UINT8 **p)
 		
 		WRITEUINT32(*p, UINT32_MAX); // end of mobjs marker, replaces mobjnum.
 
+		lua_save_p = p;
 		LUA_HookNetArchive(NetArchive); // call the NetArchive hook in archive mode
 	}
 
@@ -1668,7 +1671,7 @@ void LUA_Archive(UINT8 **p)
 		lua_pop(gL, 1); // pop tables
 }
 
-void LUA_UnArchive(UINT8 **p)
+void LUA_UnArchive(UINT8 **p, boolean network)
 {
 	UINT32 mobjnum;
 	INT32 i;
@@ -1684,7 +1687,7 @@ void LUA_UnArchive(UINT8 **p)
 		UnArchiveExtVars(p, &players[i]);
 	}
 
-	if (p == &save_p)
+	if (network == true)
 	{
 		do {
 			mobjnum = READUINT32(*p); // read a mobjnum
@@ -1698,6 +1701,7 @@ void LUA_UnArchive(UINT8 **p)
 			}
 		} while(mobjnum != UINT32_MAX); // repeat until end of mobjs marker.
 
+		lua_save_p = p;
 		LUA_HookNetArchive(NetUnArchive); // call the NetArchive hook in unarchive mode
 	}
 
diff --git a/src/lua_script.h b/src/lua_script.h
index 6268407f3..bab4345fd 100644
--- a/src/lua_script.h
+++ b/src/lua_script.h
@@ -53,8 +53,8 @@ void LUA_DumpFile(const char *filename);
 #endif
 fixed_t LUA_EvalMath(const char *word);
 void LUA_Step(void);
-void LUA_Archive(UINT8 **p);
-void LUA_UnArchive(UINT8 **p);
+void LUA_Archive(UINT8 **p, boolean network);
+void LUA_UnArchive(UINT8 **p, boolean network);
 
 int LUA_PushGlobals(lua_State *L, const char *word);
 int LUA_WriteGlobals(lua_State *L, const char *word);
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 118706d4a..ed009c189 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -43,7 +43,6 @@
 #include "k_terrain.h"
 
 savedata_t savedata;
-UINT8 *save_p;
 
 // Block UINT32s to attempt to ensure that the correct data is
 // being sent and received
@@ -69,7 +68,7 @@ typedef enum
 	STUMBLE = 0x40,
 } player_saveflags;
 
-static inline void P_ArchivePlayer(void)
+static inline void P_ArchivePlayer(savebuffer_t *save)
 {
 	const player_t *player = &players[consoleplayer];
 	INT16 skininfo = player->skin;
@@ -77,39 +76,39 @@ static inline void P_ArchivePlayer(void)
 	if (pllives < startinglivesbalance[numgameovers]) // Bump up to 3 lives if the player
 		pllives = startinglivesbalance[numgameovers]; // has less than that.
 
-	WRITEUINT16(save_p, skininfo);
-	WRITEUINT8(save_p, numgameovers);
-	WRITESINT8(save_p, pllives);
-	WRITEUINT32(save_p, player->score);
+	WRITEUINT16(save->p, skininfo);
+	WRITEUINT8(save->p, numgameovers);
+	WRITESINT8(save->p, pllives);
+	WRITEUINT32(save->p, player->score);
 }
 
-static inline void P_UnArchivePlayer(void)
+static inline void P_UnArchivePlayer(savebuffer_t *save)
 {
-	INT16 skininfo = READUINT16(save_p);
+	INT16 skininfo = READUINT16(save->p);
 	savedata.skin = skininfo;
 
-	savedata.numgameovers = READUINT8(save_p);
-	savedata.lives = READSINT8(save_p);
-	savedata.score = READUINT32(save_p);
+	savedata.numgameovers = READUINT8(save->p);
+	savedata.lives = READSINT8(save->p);
+	savedata.score = READUINT32(save->p);
 }
 
-static void P_NetArchivePlayers(void)
+static void P_NetArchivePlayers(savebuffer_t *save)
 {
 	INT32 i, j;
 	UINT16 flags;
 	size_t q;
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_PLAYERS);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_PLAYERS);
 
 	for (i = 0; i < MAXPLAYERS; i++)
 	{
-		WRITESINT8(save_p, (SINT8)adminplayers[i]);
+		WRITESINT8(save->p, (SINT8)adminplayers[i]);
 
 		for (j = 0; j < PWRLV_NUMTYPES; j++)
 		{
-			WRITEINT16(save_p, clientpowerlevels[i][j]);
+			WRITEINT16(save->p, clientpowerlevels[i][j]);
 		}
-		WRITEINT16(save_p, clientPowerAdd[i]);
+		WRITEINT16(save->p, clientPowerAdd[i]);
 
 		if (!playeringame[i])
 			continue;
@@ -118,84 +117,84 @@ static void P_NetArchivePlayers(void)
 
 		// no longer send ticcmds
 
-		WRITESTRINGN(save_p, player_names[i], MAXPLAYERNAME);
+		WRITESTRINGN(save->p, player_names[i], MAXPLAYERNAME);
 
-		WRITEUINT8(save_p, playerconsole[i]);
-		WRITEINT32(save_p, splitscreen_invitations[i]);
-		WRITEINT32(save_p, splitscreen_party_size[i]);
-		WRITEINT32(save_p, splitscreen_original_party_size[i]);
+		WRITEUINT8(save->p, playerconsole[i]);
+		WRITEINT32(save->p, splitscreen_invitations[i]);
+		WRITEINT32(save->p, splitscreen_party_size[i]);
+		WRITEINT32(save->p, splitscreen_original_party_size[i]);
 
 		for (j = 0; j < MAXSPLITSCREENPLAYERS; ++j)
 		{
-			WRITEINT32(save_p, splitscreen_party[i][j]);
-			WRITEINT32(save_p, splitscreen_original_party[i][j]);
+			WRITEINT32(save->p, splitscreen_party[i][j]);
+			WRITEINT32(save->p, splitscreen_original_party[i][j]);
 		}
 
-		WRITEINT16(save_p, players[i].steering);
-		WRITEANGLE(save_p, players[i].angleturn);
-		WRITEANGLE(save_p, players[i].aiming);
-		WRITEANGLE(save_p, players[i].drawangle);
-		WRITEANGLE(save_p, players[i].viewrollangle);
-		WRITEANGLE(save_p, players[i].tilt);
-		WRITEANGLE(save_p, players[i].awayviewaiming);
-		WRITEINT32(save_p, players[i].awayviewtics);
+		WRITEINT16(save->p, players[i].steering);
+		WRITEANGLE(save->p, players[i].angleturn);
+		WRITEANGLE(save->p, players[i].aiming);
+		WRITEANGLE(save->p, players[i].drawangle);
+		WRITEANGLE(save->p, players[i].viewrollangle);
+		WRITEANGLE(save->p, players[i].tilt);
+		WRITEANGLE(save->p, players[i].awayviewaiming);
+		WRITEINT32(save->p, players[i].awayviewtics);
 
-		WRITEUINT8(save_p, players[i].playerstate);
-		WRITEUINT32(save_p, players[i].pflags);
-		WRITEUINT8(save_p, players[i].panim);
-		WRITEUINT8(save_p, players[i].spectator);
-		WRITEUINT32(save_p, players[i].spectatewait);
+		WRITEUINT8(save->p, players[i].playerstate);
+		WRITEUINT32(save->p, players[i].pflags);
+		WRITEUINT8(save->p, players[i].panim);
+		WRITEUINT8(save->p, players[i].spectator);
+		WRITEUINT32(save->p, players[i].spectatewait);
 
-		WRITEUINT16(save_p, players[i].flashpal);
-		WRITEUINT16(save_p, players[i].flashcount);
+		WRITEUINT16(save->p, players[i].flashpal);
+		WRITEUINT16(save->p, players[i].flashcount);
 
-		WRITEUINT8(save_p, players[i].skincolor);
-		WRITEINT32(save_p, players[i].skin);
+		WRITEUINT8(save->p, players[i].skincolor);
+		WRITEINT32(save->p, players[i].skin);
 
 		for (j = 0; j < MAXAVAILABILITY; j++)
 		{
-			WRITEUINT8(save_p, players[i].availabilities[j]);
+			WRITEUINT8(save->p, players[i].availabilities[j]);
 		}
 
-		WRITEUINT8(save_p, players[i].fakeskin);
-		WRITEUINT8(save_p, players[i].lastfakeskin);
-		WRITEUINT32(save_p, players[i].score);
-		WRITESINT8(save_p, players[i].lives);
-		WRITESINT8(save_p, players[i].xtralife);
-		WRITEFIXED(save_p, players[i].speed);
-		WRITEFIXED(save_p, players[i].lastspeed);
-		WRITEINT32(save_p, players[i].deadtimer);
-		WRITEUINT32(save_p, players[i].exiting);
+		WRITEUINT8(save->p, players[i].fakeskin);
+		WRITEUINT8(save->p, players[i].lastfakeskin);
+		WRITEUINT32(save->p, players[i].score);
+		WRITESINT8(save->p, players[i].lives);
+		WRITESINT8(save->p, players[i].xtralife);
+		WRITEFIXED(save->p, players[i].speed);
+		WRITEFIXED(save->p, players[i].lastspeed);
+		WRITEINT32(save->p, players[i].deadtimer);
+		WRITEUINT32(save->p, players[i].exiting);
 
 		////////////////////////////
 		// Conveyor Belt Movement //
 		////////////////////////////
-		WRITEFIXED(save_p, players[i].cmomx); // Conveyor momx
-		WRITEFIXED(save_p, players[i].cmomy); // Conveyor momy
-		WRITEFIXED(save_p, players[i].rmomx); // "Real" momx (momx - cmomx)
-		WRITEFIXED(save_p, players[i].rmomy); // "Real" momy (momy - cmomy)
+		WRITEFIXED(save->p, players[i].cmomx); // Conveyor momx
+		WRITEFIXED(save->p, players[i].cmomy); // Conveyor momy
+		WRITEFIXED(save->p, players[i].rmomx); // "Real" momx (momx - cmomx)
+		WRITEFIXED(save->p, players[i].rmomy); // "Real" momy (momy - cmomy)
 
-		WRITEINT16(save_p, players[i].totalring);
-		WRITEUINT32(save_p, players[i].realtime);
-		WRITEUINT8(save_p, players[i].laps);
-		WRITEUINT8(save_p, players[i].latestlap);
-		WRITEINT32(save_p, players[i].starpostnum);
+		WRITEINT16(save->p, players[i].totalring);
+		WRITEUINT32(save->p, players[i].realtime);
+		WRITEUINT8(save->p, players[i].laps);
+		WRITEUINT8(save->p, players[i].latestlap);
+		WRITEINT32(save->p, players[i].starpostnum);
 
-		WRITEUINT8(save_p, players[i].ctfteam);
+		WRITEUINT8(save->p, players[i].ctfteam);
 
-		WRITEUINT8(save_p, players[i].checkskip);
+		WRITEUINT8(save->p, players[i].checkskip);
 
-		WRITEINT16(save_p, players[i].lastsidehit);
-		WRITEINT16(save_p, players[i].lastlinehit);
+		WRITEINT16(save->p, players[i].lastsidehit);
+		WRITEINT16(save->p, players[i].lastlinehit);
 
-		WRITEINT32(save_p, players[i].onconveyor);
+		WRITEINT32(save->p, players[i].onconveyor);
 
-		WRITEUINT8(save_p, players[i].timeshit);
-		WRITEUINT8(save_p, players[i].timeshitprev);
+		WRITEUINT8(save->p, players[i].timeshit);
+		WRITEUINT8(save->p, players[i].timeshitprev);
 
-		WRITEUINT32(save_p, players[i].jointime);
+		WRITEUINT32(save->p, players[i].jointime);
 
-		WRITEUINT8(save_p, players[i].splitscreenindex);
+		WRITEUINT8(save->p, players[i].splitscreenindex);
 
 		if (players[i].awayviewmobj)
 			flags |= AWAYVIEW;
@@ -218,270 +217,270 @@ static void P_NetArchivePlayers(void)
 		if (players[i].stumbleIndicator)
 			flags |= STUMBLE;
 
-		WRITEUINT16(save_p, flags);
+		WRITEUINT16(save->p, flags);
 
 		if (flags & SKYBOXVIEW)
-			WRITEUINT32(save_p, players[i].skybox.viewpoint->mobjnum);
+			WRITEUINT32(save->p, players[i].skybox.viewpoint->mobjnum);
 
 		if (flags & SKYBOXCENTER)
-			WRITEUINT32(save_p, players[i].skybox.centerpoint->mobjnum);
+			WRITEUINT32(save->p, players[i].skybox.centerpoint->mobjnum);
 
 		if (flags & AWAYVIEW)
-			WRITEUINT32(save_p, players[i].awayviewmobj->mobjnum);
+			WRITEUINT32(save->p, players[i].awayviewmobj->mobjnum);
 
 		if (flags & FOLLOWITEM)
-			WRITEUINT32(save_p, players[i].followmobj->mobjnum);
+			WRITEUINT32(save->p, players[i].followmobj->mobjnum);
 
 		if (flags & HOVERHYUDORO)
-			WRITEUINT32(save_p, players[i].hoverhyudoro->mobjnum);
+			WRITEUINT32(save->p, players[i].hoverhyudoro->mobjnum);
 
 		if (flags & STUMBLE)
-			WRITEUINT32(save_p, players[i].stumbleIndicator->mobjnum);
+			WRITEUINT32(save->p, players[i].stumbleIndicator->mobjnum);
 
-		WRITEUINT32(save_p, (UINT32)players[i].followitem);
+		WRITEUINT32(save->p, (UINT32)players[i].followitem);
 
-		WRITEUINT32(save_p, players[i].charflags);
+		WRITEUINT32(save->p, players[i].charflags);
 
 		// SRB2kart
-		WRITEUINT8(save_p, players[i].kartspeed);
-		WRITEUINT8(save_p, players[i].kartweight);
+		WRITEUINT8(save->p, players[i].kartspeed);
+		WRITEUINT8(save->p, players[i].kartweight);
 
-		WRITEUINT8(save_p, players[i].followerskin);
-		WRITEUINT8(save_p, players[i].followerready);	// booleans are really just numbers eh??
-		WRITEUINT16(save_p, players[i].followercolor);
+		WRITEUINT8(save->p, players[i].followerskin);
+		WRITEUINT8(save->p, players[i].followerready);	// booleans are really just numbers eh??
+		WRITEUINT16(save->p, players[i].followercolor);
 		if (flags & FOLLOWER)
-			WRITEUINT32(save_p, players[i].follower->mobjnum);
+			WRITEUINT32(save->p, players[i].follower->mobjnum);
 
-		WRITEUINT16(save_p, players[i].nocontrol);
-		WRITEUINT8(save_p, players[i].carry);
-		WRITEUINT16(save_p, players[i].dye);
+		WRITEUINT16(save->p, players[i].nocontrol);
+		WRITEUINT8(save->p, players[i].carry);
+		WRITEUINT16(save->p, players[i].dye);
 
-		WRITEUINT8(save_p, players[i].position);
-		WRITEUINT8(save_p, players[i].oldposition);
-		WRITEUINT8(save_p, players[i].positiondelay);
-		WRITEUINT32(save_p, players[i].distancetofinish);
-		WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].currentwaypoint));
-		WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].nextwaypoint));
-		WRITEUINT32(save_p, players[i].airtime);
-		WRITEUINT8(save_p, players[i].startboost);
+		WRITEUINT8(save->p, players[i].position);
+		WRITEUINT8(save->p, players[i].oldposition);
+		WRITEUINT8(save->p, players[i].positiondelay);
+		WRITEUINT32(save->p, players[i].distancetofinish);
+		WRITEUINT32(save->p, K_GetWaypointHeapIndex(players[i].currentwaypoint));
+		WRITEUINT32(save->p, K_GetWaypointHeapIndex(players[i].nextwaypoint));
+		WRITEUINT32(save->p, players[i].airtime);
+		WRITEUINT8(save->p, players[i].startboost);
 
-		WRITEUINT16(save_p, players[i].flashing);
-		WRITEUINT16(save_p, players[i].spinouttimer);
-		WRITEUINT8(save_p, players[i].spinouttype);
-		WRITEUINT8(save_p, players[i].instashield);
-		WRITEINT32(save_p, players[i].invulnhitlag);
-		WRITEUINT8(save_p, players[i].wipeoutslow);
-		WRITEUINT8(save_p, players[i].justbumped);
-		WRITEUINT8(save_p, players[i].tumbleBounces);
-		WRITEUINT16(save_p, players[i].tumbleHeight);
+		WRITEUINT16(save->p, players[i].flashing);
+		WRITEUINT16(save->p, players[i].spinouttimer);
+		WRITEUINT8(save->p, players[i].spinouttype);
+		WRITEUINT8(save->p, players[i].instashield);
+		WRITEINT32(save->p, players[i].invulnhitlag);
+		WRITEUINT8(save->p, players[i].wipeoutslow);
+		WRITEUINT8(save->p, players[i].justbumped);
+		WRITEUINT8(save->p, players[i].tumbleBounces);
+		WRITEUINT16(save->p, players[i].tumbleHeight);
 
-		WRITEUINT8(save_p, players[i].justDI);
-		WRITEUINT8(save_p, players[i].flipDI);
+		WRITEUINT8(save->p, players[i].justDI);
+		WRITEUINT8(save->p, players[i].flipDI);
 
-		WRITESINT8(save_p, players[i].drift);
-		WRITEFIXED(save_p, players[i].driftcharge);
-		WRITEUINT8(save_p, players[i].driftboost);
-		WRITEUINT8(save_p, players[i].strongdriftboost);
+		WRITESINT8(save->p, players[i].drift);
+		WRITEFIXED(save->p, players[i].driftcharge);
+		WRITEUINT8(save->p, players[i].driftboost);
+		WRITEUINT8(save->p, players[i].strongdriftboost);
 
-		WRITEUINT16(save_p, players[i].gateBoost);
-		WRITEUINT8(save_p, players[i].gateSound);
+		WRITEUINT16(save->p, players[i].gateBoost);
+		WRITEUINT8(save->p, players[i].gateSound);
 
-		WRITESINT8(save_p, players[i].aizdriftstrat);
-		WRITEINT32(save_p, players[i].aizdrifttilt);
-		WRITEINT32(save_p, players[i].aizdriftturn);
+		WRITESINT8(save->p, players[i].aizdriftstrat);
+		WRITEINT32(save->p, players[i].aizdrifttilt);
+		WRITEINT32(save->p, players[i].aizdriftturn);
 
-		WRITEINT32(save_p, players[i].underwatertilt);
+		WRITEINT32(save->p, players[i].underwatertilt);
 
-		WRITEFIXED(save_p, players[i].offroad);
+		WRITEFIXED(save->p, players[i].offroad);
 
-		WRITEUINT16(save_p, players[i].tiregrease);
-		WRITEUINT16(save_p, players[i].springstars);
-		WRITEUINT16(save_p, players[i].springcolor);
-		WRITEUINT8(save_p, players[i].dashpadcooldown);
+		WRITEUINT16(save->p, players[i].tiregrease);
+		WRITEUINT16(save->p, players[i].springstars);
+		WRITEUINT16(save->p, players[i].springcolor);
+		WRITEUINT8(save->p, players[i].dashpadcooldown);
 
-		WRITEUINT16(save_p, players[i].spindash);
-		WRITEFIXED(save_p, players[i].spindashspeed);
-		WRITEUINT8(save_p, players[i].spindashboost);
+		WRITEUINT16(save->p, players[i].spindash);
+		WRITEFIXED(save->p, players[i].spindashspeed);
+		WRITEUINT8(save->p, players[i].spindashboost);
 
-		WRITEFIXED(save_p, players[i].fastfall);
+		WRITEFIXED(save->p, players[i].fastfall);
 
-		WRITEUINT8(save_p, players[i].numboosts);
-		WRITEFIXED(save_p, players[i].boostpower);
-		WRITEFIXED(save_p, players[i].speedboost);
-		WRITEFIXED(save_p, players[i].accelboost);
-		WRITEFIXED(save_p, players[i].handleboost);
-		WRITEANGLE(save_p, players[i].boostangle);
+		WRITEUINT8(save->p, players[i].numboosts);
+		WRITEFIXED(save->p, players[i].boostpower);
+		WRITEFIXED(save->p, players[i].speedboost);
+		WRITEFIXED(save->p, players[i].accelboost);
+		WRITEFIXED(save->p, players[i].handleboost);
+		WRITEANGLE(save->p, players[i].boostangle);
 
-		WRITEFIXED(save_p, players[i].draftpower);
-		WRITEUINT16(save_p, players[i].draftleeway);
-		WRITESINT8(save_p, players[i].lastdraft);
+		WRITEFIXED(save->p, players[i].draftpower);
+		WRITEUINT16(save->p, players[i].draftleeway);
+		WRITESINT8(save->p, players[i].lastdraft);
 
-		WRITEUINT8(save_p, players[i].tripwireState);
-		WRITEUINT8(save_p, players[i].tripwirePass);
-		WRITEUINT16(save_p, players[i].tripwireLeniency);
+		WRITEUINT8(save->p, players[i].tripwireState);
+		WRITEUINT8(save->p, players[i].tripwirePass);
+		WRITEUINT16(save->p, players[i].tripwireLeniency);
 
-		WRITESINT8(save_p, players[i].itemtype);
-		WRITEUINT8(save_p, players[i].itemamount);
-		WRITESINT8(save_p, players[i].throwdir);
+		WRITESINT8(save->p, players[i].itemtype);
+		WRITEUINT8(save->p, players[i].itemamount);
+		WRITESINT8(save->p, players[i].throwdir);
 
-		WRITEUINT8(save_p, players[i].sadtimer);
+		WRITEUINT8(save->p, players[i].sadtimer);
 
-		WRITESINT8(save_p, players[i].rings);
-		WRITEUINT8(save_p, players[i].pickuprings);
-		WRITEUINT8(save_p, players[i].ringdelay);
-		WRITEUINT16(save_p, players[i].ringboost);
-		WRITEUINT8(save_p, players[i].sparkleanim);
-		WRITEUINT16(save_p, players[i].superring);
+		WRITESINT8(save->p, players[i].rings);
+		WRITEUINT8(save->p, players[i].pickuprings);
+		WRITEUINT8(save->p, players[i].ringdelay);
+		WRITEUINT16(save->p, players[i].ringboost);
+		WRITEUINT8(save->p, players[i].sparkleanim);
+		WRITEUINT16(save->p, players[i].superring);
 
-		WRITEUINT8(save_p, players[i].curshield);
-		WRITEUINT8(save_p, players[i].bubblecool);
-		WRITEUINT8(save_p, players[i].bubbleblowup);
-		WRITEUINT16(save_p, players[i].flamedash);
-		WRITEUINT16(save_p, players[i].flamemeter);
-		WRITEUINT8(save_p, players[i].flamelength);
+		WRITEUINT8(save->p, players[i].curshield);
+		WRITEUINT8(save->p, players[i].bubblecool);
+		WRITEUINT8(save->p, players[i].bubbleblowup);
+		WRITEUINT16(save->p, players[i].flamedash);
+		WRITEUINT16(save->p, players[i].flamemeter);
+		WRITEUINT8(save->p, players[i].flamelength);
 
-		WRITEUINT16(save_p, players[i].ballhogcharge);
+		WRITEUINT16(save->p, players[i].ballhogcharge);
 
-		WRITEUINT16(save_p, players[i].hyudorotimer);
-		WRITESINT8(save_p, players[i].stealingtimer);
+		WRITEUINT16(save->p, players[i].hyudorotimer);
+		WRITESINT8(save->p, players[i].stealingtimer);
 
-		WRITEUINT16(save_p, players[i].sneakertimer);
-		WRITEUINT8(save_p, players[i].numsneakers);
-		WRITEUINT8(save_p, players[i].floorboost);
+		WRITEUINT16(save->p, players[i].sneakertimer);
+		WRITEUINT8(save->p, players[i].numsneakers);
+		WRITEUINT8(save->p, players[i].floorboost);
 
-		WRITEINT16(save_p, players[i].growshrinktimer);
-		WRITEUINT16(save_p, players[i].rocketsneakertimer);
-		WRITEUINT16(save_p, players[i].invincibilitytimer);
+		WRITEINT16(save->p, players[i].growshrinktimer);
+		WRITEUINT16(save->p, players[i].rocketsneakertimer);
+		WRITEUINT16(save->p, players[i].invincibilitytimer);
 
-		WRITEUINT8(save_p, players[i].eggmanexplode);
-		WRITESINT8(save_p, players[i].eggmanblame);
+		WRITEUINT8(save->p, players[i].eggmanexplode);
+		WRITESINT8(save->p, players[i].eggmanblame);
 
-		WRITEUINT8(save_p, players[i].bananadrag);
+		WRITEUINT8(save->p, players[i].bananadrag);
 
-		WRITESINT8(save_p, players[i].lastjawztarget);
-		WRITEUINT8(save_p, players[i].jawztargetdelay);
+		WRITESINT8(save->p, players[i].lastjawztarget);
+		WRITEUINT8(save->p, players[i].jawztargetdelay);
 
-		WRITEUINT8(save_p, players[i].confirmVictim);
-		WRITEUINT8(save_p, players[i].confirmVictimDelay);
+		WRITEUINT8(save->p, players[i].confirmVictim);
+		WRITEUINT8(save->p, players[i].confirmVictimDelay);
 
-		WRITEUINT8(save_p, players[i].trickpanel);
-		WRITEUINT8(save_p, players[i].tricktime);
-		WRITEUINT32(save_p, players[i].trickboostpower);
-		WRITEUINT8(save_p, players[i].trickboostdecay);
-		WRITEUINT8(save_p, players[i].trickboost);
+		WRITEUINT8(save->p, players[i].trickpanel);
+		WRITEUINT8(save->p, players[i].tricktime);
+		WRITEUINT32(save->p, players[i].trickboostpower);
+		WRITEUINT8(save->p, players[i].trickboostdecay);
+		WRITEUINT8(save->p, players[i].trickboost);
 
-		WRITEUINT32(save_p, players[i].ebrakefor);
+		WRITEUINT32(save->p, players[i].ebrakefor);
 
-		WRITEUINT32(save_p, players[i].roundscore);
-		WRITEUINT8(save_p, players[i].emeralds);
-		WRITEUINT8(save_p, players[i].bumpers);
-		WRITEINT16(save_p, players[i].karmadelay);
-		WRITEUINT32(save_p, players[i].overtimekarma);
-		WRITEINT16(save_p, players[i].spheres);
-		WRITEUINT32(save_p, players[i].spheredigestion);
+		WRITEUINT32(save->p, players[i].roundscore);
+		WRITEUINT8(save->p, players[i].emeralds);
+		WRITEUINT8(save->p, players[i].bumpers);
+		WRITEINT16(save->p, players[i].karmadelay);
+		WRITEUINT32(save->p, players[i].overtimekarma);
+		WRITEINT16(save->p, players[i].spheres);
+		WRITEUINT32(save->p, players[i].spheredigestion);
 
-		WRITESINT8(save_p, players[i].glanceDir);
+		WRITESINT8(save->p, players[i].glanceDir);
 
-		WRITEUINT8(save_p, players[i].typing_timer);
-		WRITEUINT8(save_p, players[i].typing_duration);
+		WRITEUINT8(save->p, players[i].typing_timer);
+		WRITEUINT8(save->p, players[i].typing_duration);
 
-		WRITEUINT8(save_p, players[i].kickstartaccel);
+		WRITEUINT8(save->p, players[i].kickstartaccel);
 
-		WRITEUINT8(save_p, players[i].stairjank);
-		WRITEUINT8(save_p, players[i].topdriftheld);
-		WRITEUINT8(save_p, players[i].topinfirst);
+		WRITEUINT8(save->p, players[i].stairjank);
+		WRITEUINT8(save->p, players[i].topdriftheld);
+		WRITEUINT8(save->p, players[i].topinfirst);
 
-		WRITEUINT8(save_p, players[i].shrinkLaserDelay);
+		WRITEUINT8(save->p, players[i].shrinkLaserDelay);
 
 		// respawnvars_t
-		WRITEUINT8(save_p, players[i].respawn.state);
-		WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].respawn.wp));
-		WRITEFIXED(save_p, players[i].respawn.pointx);
-		WRITEFIXED(save_p, players[i].respawn.pointy);
-		WRITEFIXED(save_p, players[i].respawn.pointz);
-		WRITEUINT8(save_p, players[i].respawn.flip);
-		WRITEUINT32(save_p, players[i].respawn.timer);
-		WRITEUINT32(save_p, players[i].respawn.airtimer);
-		WRITEUINT32(save_p, players[i].respawn.distanceleft);
-		WRITEUINT32(save_p, players[i].respawn.dropdash);
-		WRITEUINT8(save_p, players[i].respawn.truedeath);
-		WRITEUINT8(save_p, players[i].respawn.manual);
+		WRITEUINT8(save->p, players[i].respawn.state);
+		WRITEUINT32(save->p, K_GetWaypointHeapIndex(players[i].respawn.wp));
+		WRITEFIXED(save->p, players[i].respawn.pointx);
+		WRITEFIXED(save->p, players[i].respawn.pointy);
+		WRITEFIXED(save->p, players[i].respawn.pointz);
+		WRITEUINT8(save->p, players[i].respawn.flip);
+		WRITEUINT32(save->p, players[i].respawn.timer);
+		WRITEUINT32(save->p, players[i].respawn.airtimer);
+		WRITEUINT32(save->p, players[i].respawn.distanceleft);
+		WRITEUINT32(save->p, players[i].respawn.dropdash);
+		WRITEUINT8(save->p, players[i].respawn.truedeath);
+		WRITEUINT8(save->p, players[i].respawn.manual);
 
 		// botvars_t
-		WRITEUINT8(save_p, players[i].botvars.difficulty);
-		WRITEUINT8(save_p, players[i].botvars.diffincrease);
-		WRITEUINT8(save_p, players[i].botvars.rival);
-		WRITEFIXED(save_p, players[i].botvars.rubberband);
-		WRITEUINT16(save_p, players[i].botvars.controller);
-		WRITEUINT32(save_p, players[i].botvars.itemdelay);
-		WRITEUINT32(save_p, players[i].botvars.itemconfirm);
-		WRITESINT8(save_p, players[i].botvars.turnconfirm);
-		WRITEUINT32(save_p, players[i].botvars.spindashconfirm);
+		WRITEUINT8(save->p, players[i].botvars.difficulty);
+		WRITEUINT8(save->p, players[i].botvars.diffincrease);
+		WRITEUINT8(save->p, players[i].botvars.rival);
+		WRITEFIXED(save->p, players[i].botvars.rubberband);
+		WRITEUINT16(save->p, players[i].botvars.controller);
+		WRITEUINT32(save->p, players[i].botvars.itemdelay);
+		WRITEUINT32(save->p, players[i].botvars.itemconfirm);
+		WRITESINT8(save->p, players[i].botvars.turnconfirm);
+		WRITEUINT32(save->p, players[i].botvars.spindashconfirm);
 
 		// itemroulette_t
-		WRITEUINT8(save_p, players[i].itemRoulette.active);
+		WRITEUINT8(save->p, players[i].itemRoulette.active);
 
 #ifdef ITEM_LIST_SIZE
-		WRITEUINT32(save_p, players[i].itemRoulette.itemListLen);
+		WRITEUINT32(save->p, players[i].itemRoulette.itemListLen);
 
 		for (q = 0; q < ITEM_LIST_SIZE; q++)
 		{
 			if (q >= players[i].itemRoulette.itemListLen)
 			{
-				WRITESINT8(save_p, KITEM_NONE);
+				WRITESINT8(save->p, KITEM_NONE);
 			}
 			else
 			{
-				WRITESINT8(save_p, players[i].itemRoulette.itemList[q]);
+				WRITESINT8(save->p, players[i].itemRoulette.itemList[q]);
 			}
 		}
 #else
 		if (players[i].itemRoulette.itemList == NULL)
 		{
-			WRITEUINT32(save_p, 0);
-			WRITEUINT32(save_p, 0);
+			WRITEUINT32(save->p, 0);
+			WRITEUINT32(save->p, 0);
 		}
 		else
 		{
-			WRITEUINT32(save_p, players[i].itemRoulette.itemListCap);
-			WRITEUINT32(save_p, players[i].itemRoulette.itemListLen);
+			WRITEUINT32(save->p, players[i].itemRoulette.itemListCap);
+			WRITEUINT32(save->p, players[i].itemRoulette.itemListLen);
 
 			for (q = 0; q < players[i].itemRoulette.itemListLen; q++)
 			{
-				WRITESINT8(save_p, players[i].itemRoulette.itemList[q]);
+				WRITESINT8(save->p, players[i].itemRoulette.itemList[q]);
 			}
 		}
 #endif
 
-		WRITEUINT8(save_p, players[i].itemRoulette.useOdds);
-		WRITEUINT32(save_p, players[i].itemRoulette.dist);
-		WRITEUINT32(save_p, players[i].itemRoulette.index);
-		WRITEUINT8(save_p, players[i].itemRoulette.sound);
-		WRITEUINT32(save_p, players[i].itemRoulette.speed);
-		WRITEUINT32(save_p, players[i].itemRoulette.tics);
-		WRITEUINT32(save_p, players[i].itemRoulette.elapsed);
-		WRITEUINT8(save_p, players[i].itemRoulette.eggman);
+		WRITEUINT8(save->p, players[i].itemRoulette.useOdds);
+		WRITEUINT32(save->p, players[i].itemRoulette.dist);
+		WRITEUINT32(save->p, players[i].itemRoulette.index);
+		WRITEUINT8(save->p, players[i].itemRoulette.sound);
+		WRITEUINT32(save->p, players[i].itemRoulette.speed);
+		WRITEUINT32(save->p, players[i].itemRoulette.tics);
+		WRITEUINT32(save->p, players[i].itemRoulette.elapsed);
+		WRITEUINT8(save->p, players[i].itemRoulette.eggman);
 	}
 }
 
-static void P_NetUnArchivePlayers(void)
+static void P_NetUnArchivePlayers(savebuffer_t *save)
 {
 	INT32 i, j;
 	UINT16 flags;
 	size_t q;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_PLAYERS)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_PLAYERS)
 		I_Error("Bad $$$.sav at archive block Players");
 
 	for (i = 0; i < MAXPLAYERS; i++)
 	{
-		adminplayers[i] = (INT32)READSINT8(save_p);
+		adminplayers[i] = (INT32)READSINT8(save->p);
 
 		for (j = 0; j < PWRLV_NUMTYPES; j++)
 		{
-			clientpowerlevels[i][j] = READINT16(save_p);
+			clientpowerlevels[i][j] = READINT16(save->p);
 		}
-		clientPowerAdd[i] = READINT16(save_p);
+		clientPowerAdd[i] = READINT16(save->p);
 
 		// Do NOT memset player struct to 0
 		// other areas may initialize data elsewhere
@@ -491,299 +490,299 @@ static void P_NetUnArchivePlayers(void)
 
 		// NOTE: sending tics should (hopefully) no longer be necessary
 
-		READSTRINGN(save_p, player_names[i], MAXPLAYERNAME);
+		READSTRINGN(save->p, player_names[i], MAXPLAYERNAME);
 
-		playerconsole[i] = READUINT8(save_p);
-		splitscreen_invitations[i] = READINT32(save_p);
-		splitscreen_party_size[i] = READINT32(save_p);
-		splitscreen_original_party_size[i] = READINT32(save_p);
+		playerconsole[i] = READUINT8(save->p);
+		splitscreen_invitations[i] = READINT32(save->p);
+		splitscreen_party_size[i] = READINT32(save->p);
+		splitscreen_original_party_size[i] = READINT32(save->p);
 
 		for (j = 0; j < MAXSPLITSCREENPLAYERS; ++j)
 		{
-			splitscreen_party[i][j] = READINT32(save_p);
-			splitscreen_original_party[i][j] = READINT32(save_p);
+			splitscreen_party[i][j] = READINT32(save->p);
+			splitscreen_original_party[i][j] = READINT32(save->p);
 		}
 
-		players[i].steering = READINT16(save_p);
-		players[i].angleturn = READANGLE(save_p);
-		players[i].aiming = READANGLE(save_p);
-		players[i].drawangle = players[i].old_drawangle = READANGLE(save_p);
-		players[i].viewrollangle = READANGLE(save_p);
-		players[i].tilt = READANGLE(save_p);
-		players[i].awayviewaiming = READANGLE(save_p);
-		players[i].awayviewtics = READINT32(save_p);
+		players[i].steering = READINT16(save->p);
+		players[i].angleturn = READANGLE(save->p);
+		players[i].aiming = READANGLE(save->p);
+		players[i].drawangle = players[i].old_drawangle = READANGLE(save->p);
+		players[i].viewrollangle = READANGLE(save->p);
+		players[i].tilt = READANGLE(save->p);
+		players[i].awayviewaiming = READANGLE(save->p);
+		players[i].awayviewtics = READINT32(save->p);
 
-		players[i].playerstate = READUINT8(save_p);
-		players[i].pflags = READUINT32(save_p);
-		players[i].panim = READUINT8(save_p);
-		players[i].spectator = READUINT8(save_p);
-		players[i].spectatewait = READUINT32(save_p);
+		players[i].playerstate = READUINT8(save->p);
+		players[i].pflags = READUINT32(save->p);
+		players[i].panim = READUINT8(save->p);
+		players[i].spectator = READUINT8(save->p);
+		players[i].spectatewait = READUINT32(save->p);
 
-		players[i].flashpal = READUINT16(save_p);
-		players[i].flashcount = READUINT16(save_p);
+		players[i].flashpal = READUINT16(save->p);
+		players[i].flashcount = READUINT16(save->p);
 
-		players[i].skincolor = READUINT8(save_p);
-		players[i].skin = READINT32(save_p);
+		players[i].skincolor = READUINT8(save->p);
+		players[i].skin = READINT32(save->p);
 
 		for (j = 0; j < MAXAVAILABILITY; j++)
 		{
-			players[i].availabilities[j] = READUINT8(save_p);
+			players[i].availabilities[j] = READUINT8(save->p);
 		}
 
-		players[i].fakeskin = READUINT8(save_p);
-		players[i].lastfakeskin = READUINT8(save_p);
-		players[i].score = READUINT32(save_p);
-		players[i].lives = READSINT8(save_p);
-		players[i].xtralife = READSINT8(save_p); // Ring Extra Life counter
-		players[i].speed = READFIXED(save_p); // Player's speed (distance formula of MOMX and MOMY values)
-		players[i].lastspeed = READFIXED(save_p);
-		players[i].deadtimer = READINT32(save_p); // End game if game over lasts too long
-		players[i].exiting = READUINT32(save_p); // Exitlevel timer
+		players[i].fakeskin = READUINT8(save->p);
+		players[i].lastfakeskin = READUINT8(save->p);
+		players[i].score = READUINT32(save->p);
+		players[i].lives = READSINT8(save->p);
+		players[i].xtralife = READSINT8(save->p); // Ring Extra Life counter
+		players[i].speed = READFIXED(save->p); // Player's speed (distance formula of MOMX and MOMY values)
+		players[i].lastspeed = READFIXED(save->p);
+		players[i].deadtimer = READINT32(save->p); // End game if game over lasts too long
+		players[i].exiting = READUINT32(save->p); // Exitlevel timer
 
 		////////////////////////////
 		// Conveyor Belt Movement //
 		////////////////////////////
-		players[i].cmomx = READFIXED(save_p); // Conveyor momx
-		players[i].cmomy = READFIXED(save_p); // Conveyor momy
-		players[i].rmomx = READFIXED(save_p); // "Real" momx (momx - cmomx)
-		players[i].rmomy = READFIXED(save_p); // "Real" momy (momy - cmomy)
+		players[i].cmomx = READFIXED(save->p); // Conveyor momx
+		players[i].cmomy = READFIXED(save->p); // Conveyor momy
+		players[i].rmomx = READFIXED(save->p); // "Real" momx (momx - cmomx)
+		players[i].rmomy = READFIXED(save->p); // "Real" momy (momy - cmomy)
 
-		players[i].totalring = READINT16(save_p); // Total number of rings obtained for GP
-		players[i].realtime = READUINT32(save_p); // integer replacement for leveltime
-		players[i].laps = READUINT8(save_p); // Number of laps (optional)
-		players[i].latestlap = READUINT8(save_p);
-		players[i].starpostnum = READINT32(save_p);
+		players[i].totalring = READINT16(save->p); // Total number of rings obtained for GP
+		players[i].realtime = READUINT32(save->p); // integer replacement for leveltime
+		players[i].laps = READUINT8(save->p); // Number of laps (optional)
+		players[i].latestlap = READUINT8(save->p);
+		players[i].starpostnum = READINT32(save->p);
 
-		players[i].ctfteam = READUINT8(save_p); // 1 == Red, 2 == Blue
+		players[i].ctfteam = READUINT8(save->p); // 1 == Red, 2 == Blue
 
-		players[i].checkskip = READUINT8(save_p);
+		players[i].checkskip = READUINT8(save->p);
 
-		players[i].lastsidehit = READINT16(save_p);
-		players[i].lastlinehit = READINT16(save_p);
+		players[i].lastsidehit = READINT16(save->p);
+		players[i].lastlinehit = READINT16(save->p);
 
-		players[i].timeshit = READUINT8(save_p);
-		players[i].timeshitprev = READUINT8(save_p);
+		players[i].timeshit = READUINT8(save->p);
+		players[i].timeshitprev = READUINT8(save->p);
 
-		players[i].onconveyor = READINT32(save_p);
+		players[i].onconveyor = READINT32(save->p);
 
-		players[i].jointime = READUINT32(save_p);
+		players[i].jointime = READUINT32(save->p);
 
-		players[i].splitscreenindex = READUINT8(save_p);
+		players[i].splitscreenindex = READUINT8(save->p);
 
-		flags = READUINT16(save_p);
+		flags = READUINT16(save->p);
 
 		if (flags & SKYBOXVIEW)
-			players[i].skybox.viewpoint = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].skybox.viewpoint = (mobj_t *)(size_t)READUINT32(save->p);
 
 		if (flags & SKYBOXCENTER)
-			players[i].skybox.centerpoint = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].skybox.centerpoint = (mobj_t *)(size_t)READUINT32(save->p);
 
 		if (flags & AWAYVIEW)
-			players[i].awayviewmobj = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].awayviewmobj = (mobj_t *)(size_t)READUINT32(save->p);
 
 		if (flags & FOLLOWITEM)
-			players[i].followmobj = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].followmobj = (mobj_t *)(size_t)READUINT32(save->p);
 
 		if (flags & HOVERHYUDORO)
-			players[i].hoverhyudoro = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].hoverhyudoro = (mobj_t *)(size_t)READUINT32(save->p);
 
 		if (flags & STUMBLE)
-			players[i].stumbleIndicator = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].stumbleIndicator = (mobj_t *)(size_t)READUINT32(save->p);
 
-		players[i].followitem = (mobjtype_t)READUINT32(save_p);
+		players[i].followitem = (mobjtype_t)READUINT32(save->p);
 
 		//SetPlayerSkinByNum(i, players[i].skin);
-		players[i].charflags = READUINT32(save_p);
+		players[i].charflags = READUINT32(save->p);
 
 		// SRB2kart
-		players[i].kartspeed = READUINT8(save_p);
-		players[i].kartweight = READUINT8(save_p);
+		players[i].kartspeed = READUINT8(save->p);
+		players[i].kartweight = READUINT8(save->p);
 
-		players[i].followerskin = READUINT8(save_p);
-		players[i].followerready = READUINT8(save_p);
-		players[i].followercolor = READUINT16(save_p);
+		players[i].followerskin = READUINT8(save->p);
+		players[i].followerready = READUINT8(save->p);
+		players[i].followercolor = READUINT16(save->p);
 		if (flags & FOLLOWER)
-			players[i].follower = (mobj_t *)(size_t)READUINT32(save_p);
+			players[i].follower = (mobj_t *)(size_t)READUINT32(save->p);
 
-		players[i].nocontrol = READUINT16(save_p);
-		players[i].carry = READUINT8(save_p);
-		players[i].dye = READUINT16(save_p);
+		players[i].nocontrol = READUINT16(save->p);
+		players[i].carry = READUINT8(save->p);
+		players[i].dye = READUINT16(save->p);
 
-		players[i].position = READUINT8(save_p);
-		players[i].oldposition = READUINT8(save_p);
-		players[i].positiondelay = READUINT8(save_p);
-		players[i].distancetofinish = READUINT32(save_p);
-		players[i].currentwaypoint = (waypoint_t *)(size_t)READUINT32(save_p);
-		players[i].nextwaypoint = (waypoint_t *)(size_t)READUINT32(save_p);
-		players[i].airtime = READUINT32(save_p);
-		players[i].startboost = READUINT8(save_p);
+		players[i].position = READUINT8(save->p);
+		players[i].oldposition = READUINT8(save->p);
+		players[i].positiondelay = READUINT8(save->p);
+		players[i].distancetofinish = READUINT32(save->p);
+		players[i].currentwaypoint = (waypoint_t *)(size_t)READUINT32(save->p);
+		players[i].nextwaypoint = (waypoint_t *)(size_t)READUINT32(save->p);
+		players[i].airtime = READUINT32(save->p);
+		players[i].startboost = READUINT8(save->p);
 
-		players[i].flashing = READUINT16(save_p);
-		players[i].spinouttimer = READUINT16(save_p);
-		players[i].spinouttype = READUINT8(save_p);
-		players[i].instashield = READUINT8(save_p);
-		players[i].invulnhitlag = READINT32(save_p);
-		players[i].wipeoutslow = READUINT8(save_p);
-		players[i].justbumped = READUINT8(save_p);
-		players[i].tumbleBounces = READUINT8(save_p);
-		players[i].tumbleHeight = READUINT16(save_p);
+		players[i].flashing = READUINT16(save->p);
+		players[i].spinouttimer = READUINT16(save->p);
+		players[i].spinouttype = READUINT8(save->p);
+		players[i].instashield = READUINT8(save->p);
+		players[i].invulnhitlag = READINT32(save->p);
+		players[i].wipeoutslow = READUINT8(save->p);
+		players[i].justbumped = READUINT8(save->p);
+		players[i].tumbleBounces = READUINT8(save->p);
+		players[i].tumbleHeight = READUINT16(save->p);
 
-		players[i].justDI = READUINT8(save_p);
-		players[i].flipDI = (boolean)READUINT8(save_p);
+		players[i].justDI = READUINT8(save->p);
+		players[i].flipDI = (boolean)READUINT8(save->p);
 
-		players[i].drift = READSINT8(save_p);
-		players[i].driftcharge = READFIXED(save_p);
-		players[i].driftboost = READUINT8(save_p);
-		players[i].strongdriftboost = READUINT8(save_p);
+		players[i].drift = READSINT8(save->p);
+		players[i].driftcharge = READFIXED(save->p);
+		players[i].driftboost = READUINT8(save->p);
+		players[i].strongdriftboost = READUINT8(save->p);
 
-		players[i].gateBoost = READUINT16(save_p);
-		players[i].gateSound = READUINT8(save_p);
+		players[i].gateBoost = READUINT16(save->p);
+		players[i].gateSound = READUINT8(save->p);
 
-		players[i].aizdriftstrat = READSINT8(save_p);
-		players[i].aizdrifttilt = READINT32(save_p);
-		players[i].aizdriftturn = READINT32(save_p);
+		players[i].aizdriftstrat = READSINT8(save->p);
+		players[i].aizdrifttilt = READINT32(save->p);
+		players[i].aizdriftturn = READINT32(save->p);
 
-		players[i].underwatertilt = READINT32(save_p);
+		players[i].underwatertilt = READINT32(save->p);
 
-		players[i].offroad = READFIXED(save_p);
+		players[i].offroad = READFIXED(save->p);
 
-		players[i].tiregrease = READUINT16(save_p);
-		players[i].springstars = READUINT16(save_p);
-		players[i].springcolor = READUINT16(save_p);
-		players[i].dashpadcooldown = READUINT8(save_p);
+		players[i].tiregrease = READUINT16(save->p);
+		players[i].springstars = READUINT16(save->p);
+		players[i].springcolor = READUINT16(save->p);
+		players[i].dashpadcooldown = READUINT8(save->p);
 
-		players[i].spindash = READUINT16(save_p);
-		players[i].spindashspeed = READFIXED(save_p);
-		players[i].spindashboost = READUINT8(save_p);
+		players[i].spindash = READUINT16(save->p);
+		players[i].spindashspeed = READFIXED(save->p);
+		players[i].spindashboost = READUINT8(save->p);
 
-		players[i].fastfall = READFIXED(save_p);
+		players[i].fastfall = READFIXED(save->p);
 
-		players[i].numboosts = READUINT8(save_p);
-		players[i].boostpower = READFIXED(save_p);
-		players[i].speedboost = READFIXED(save_p);
-		players[i].accelboost = READFIXED(save_p);
-		players[i].handleboost = READFIXED(save_p);
-		players[i].boostangle = READANGLE(save_p);
+		players[i].numboosts = READUINT8(save->p);
+		players[i].boostpower = READFIXED(save->p);
+		players[i].speedboost = READFIXED(save->p);
+		players[i].accelboost = READFIXED(save->p);
+		players[i].handleboost = READFIXED(save->p);
+		players[i].boostangle = READANGLE(save->p);
 
-		players[i].draftpower = READFIXED(save_p);
-		players[i].draftleeway = READUINT16(save_p);
-		players[i].lastdraft = READSINT8(save_p);
+		players[i].draftpower = READFIXED(save->p);
+		players[i].draftleeway = READUINT16(save->p);
+		players[i].lastdraft = READSINT8(save->p);
 
-		players[i].tripwireState = READUINT8(save_p);
-		players[i].tripwirePass = READUINT8(save_p);
-		players[i].tripwireLeniency = READUINT16(save_p);
+		players[i].tripwireState = READUINT8(save->p);
+		players[i].tripwirePass = READUINT8(save->p);
+		players[i].tripwireLeniency = READUINT16(save->p);
 
-		players[i].itemtype = READSINT8(save_p);
-		players[i].itemamount = READUINT8(save_p);
-		players[i].throwdir = READSINT8(save_p);
+		players[i].itemtype = READSINT8(save->p);
+		players[i].itemamount = READUINT8(save->p);
+		players[i].throwdir = READSINT8(save->p);
 
-		players[i].sadtimer = READUINT8(save_p);
+		players[i].sadtimer = READUINT8(save->p);
 
-		players[i].rings = READSINT8(save_p);
-		players[i].pickuprings = READUINT8(save_p);
-		players[i].ringdelay = READUINT8(save_p);
-		players[i].ringboost = READUINT16(save_p);
-		players[i].sparkleanim = READUINT8(save_p);
-		players[i].superring = READUINT16(save_p);
+		players[i].rings = READSINT8(save->p);
+		players[i].pickuprings = READUINT8(save->p);
+		players[i].ringdelay = READUINT8(save->p);
+		players[i].ringboost = READUINT16(save->p);
+		players[i].sparkleanim = READUINT8(save->p);
+		players[i].superring = READUINT16(save->p);
 
-		players[i].curshield = READUINT8(save_p);
-		players[i].bubblecool = READUINT8(save_p);
-		players[i].bubbleblowup = READUINT8(save_p);
-		players[i].flamedash = READUINT16(save_p);
-		players[i].flamemeter = READUINT16(save_p);
-		players[i].flamelength = READUINT8(save_p);
+		players[i].curshield = READUINT8(save->p);
+		players[i].bubblecool = READUINT8(save->p);
+		players[i].bubbleblowup = READUINT8(save->p);
+		players[i].flamedash = READUINT16(save->p);
+		players[i].flamemeter = READUINT16(save->p);
+		players[i].flamelength = READUINT8(save->p);
 
-		players[i].ballhogcharge = READUINT16(save_p);
+		players[i].ballhogcharge = READUINT16(save->p);
 
-		players[i].hyudorotimer = READUINT16(save_p);
-		players[i].stealingtimer = READSINT8(save_p);
+		players[i].hyudorotimer = READUINT16(save->p);
+		players[i].stealingtimer = READSINT8(save->p);
 
-		players[i].sneakertimer = READUINT16(save_p);
-		players[i].numsneakers = READUINT8(save_p);
-		players[i].floorboost = READUINT8(save_p);
+		players[i].sneakertimer = READUINT16(save->p);
+		players[i].numsneakers = READUINT8(save->p);
+		players[i].floorboost = READUINT8(save->p);
 
-		players[i].growshrinktimer = READINT16(save_p);
-		players[i].rocketsneakertimer = READUINT16(save_p);
-		players[i].invincibilitytimer = READUINT16(save_p);
+		players[i].growshrinktimer = READINT16(save->p);
+		players[i].rocketsneakertimer = READUINT16(save->p);
+		players[i].invincibilitytimer = READUINT16(save->p);
 
-		players[i].eggmanexplode = READUINT8(save_p);
-		players[i].eggmanblame = READSINT8(save_p);
+		players[i].eggmanexplode = READUINT8(save->p);
+		players[i].eggmanblame = READSINT8(save->p);
 
-		players[i].bananadrag = READUINT8(save_p);
+		players[i].bananadrag = READUINT8(save->p);
 
-		players[i].lastjawztarget = READSINT8(save_p);
-		players[i].jawztargetdelay = READUINT8(save_p);
+		players[i].lastjawztarget = READSINT8(save->p);
+		players[i].jawztargetdelay = READUINT8(save->p);
 
-		players[i].confirmVictim = READUINT8(save_p);
-		players[i].confirmVictimDelay = READUINT8(save_p);
+		players[i].confirmVictim = READUINT8(save->p);
+		players[i].confirmVictimDelay = READUINT8(save->p);
 
-		players[i].trickpanel = READUINT8(save_p);
-		players[i].tricktime = READUINT8(save_p);
-		players[i].trickboostpower = READUINT32(save_p);
-		players[i].trickboostdecay = READUINT8(save_p);
-		players[i].trickboost = READUINT8(save_p);
+		players[i].trickpanel = READUINT8(save->p);
+		players[i].tricktime = READUINT8(save->p);
+		players[i].trickboostpower = READUINT32(save->p);
+		players[i].trickboostdecay = READUINT8(save->p);
+		players[i].trickboost = READUINT8(save->p);
 
-		players[i].ebrakefor = READUINT32(save_p);
+		players[i].ebrakefor = READUINT32(save->p);
 
-		players[i].roundscore = READUINT32(save_p);
-		players[i].emeralds = READUINT8(save_p);
-		players[i].bumpers = READUINT8(save_p);
-		players[i].karmadelay = READINT16(save_p);
-		players[i].overtimekarma = READUINT32(save_p);
-		players[i].spheres = READINT16(save_p);
-		players[i].spheredigestion = READUINT32(save_p);
+		players[i].roundscore = READUINT32(save->p);
+		players[i].emeralds = READUINT8(save->p);
+		players[i].bumpers = READUINT8(save->p);
+		players[i].karmadelay = READINT16(save->p);
+		players[i].overtimekarma = READUINT32(save->p);
+		players[i].spheres = READINT16(save->p);
+		players[i].spheredigestion = READUINT32(save->p);
 
-		players[i].glanceDir = READSINT8(save_p);
+		players[i].glanceDir = READSINT8(save->p);
 
-		players[i].typing_timer = READUINT8(save_p);
-		players[i].typing_duration = READUINT8(save_p);
+		players[i].typing_timer = READUINT8(save->p);
+		players[i].typing_duration = READUINT8(save->p);
 
-		players[i].kickstartaccel = READUINT8(save_p);
+		players[i].kickstartaccel = READUINT8(save->p);
 
-		players[i].stairjank = READUINT8(save_p);
-		players[i].topdriftheld = READUINT8(save_p);
-		players[i].topinfirst = READUINT8(save_p);
+		players[i].stairjank = READUINT8(save->p);
+		players[i].topdriftheld = READUINT8(save->p);
+		players[i].topinfirst = READUINT8(save->p);
 
-		players[i].shrinkLaserDelay = READUINT8(save_p);
+		players[i].shrinkLaserDelay = READUINT8(save->p);
 
 		// respawnvars_t
-		players[i].respawn.state = READUINT8(save_p);
-		players[i].respawn.wp = (waypoint_t *)(size_t)READUINT32(save_p);
-		players[i].respawn.pointx = READFIXED(save_p);
-		players[i].respawn.pointy = READFIXED(save_p);
-		players[i].respawn.pointz = READFIXED(save_p);
-		players[i].respawn.flip = (boolean)READUINT8(save_p);
-		players[i].respawn.timer = READUINT32(save_p);
-		players[i].respawn.airtimer = READUINT32(save_p);
-		players[i].respawn.distanceleft = READUINT32(save_p);
-		players[i].respawn.dropdash = READUINT32(save_p);
-		players[i].respawn.truedeath = READUINT8(save_p);
-		players[i].respawn.manual = READUINT8(save_p);
+		players[i].respawn.state = READUINT8(save->p);
+		players[i].respawn.wp = (waypoint_t *)(size_t)READUINT32(save->p);
+		players[i].respawn.pointx = READFIXED(save->p);
+		players[i].respawn.pointy = READFIXED(save->p);
+		players[i].respawn.pointz = READFIXED(save->p);
+		players[i].respawn.flip = (boolean)READUINT8(save->p);
+		players[i].respawn.timer = READUINT32(save->p);
+		players[i].respawn.airtimer = READUINT32(save->p);
+		players[i].respawn.distanceleft = READUINT32(save->p);
+		players[i].respawn.dropdash = READUINT32(save->p);
+		players[i].respawn.truedeath = READUINT8(save->p);
+		players[i].respawn.manual = READUINT8(save->p);
 
 		// botvars_t
-		players[i].botvars.difficulty = READUINT8(save_p);
-		players[i].botvars.diffincrease = READUINT8(save_p);
-		players[i].botvars.rival = (boolean)READUINT8(save_p);
-		players[i].botvars.rubberband = READFIXED(save_p);
-		players[i].botvars.controller = READUINT16(save_p);
-		players[i].botvars.itemdelay = READUINT32(save_p);
-		players[i].botvars.itemconfirm = READUINT32(save_p);
-		players[i].botvars.turnconfirm = READSINT8(save_p);
-		players[i].botvars.spindashconfirm = READUINT32(save_p);
+		players[i].botvars.difficulty = READUINT8(save->p);
+		players[i].botvars.diffincrease = READUINT8(save->p);
+		players[i].botvars.rival = (boolean)READUINT8(save->p);
+		players[i].botvars.rubberband = READFIXED(save->p);
+		players[i].botvars.controller = READUINT16(save->p);
+		players[i].botvars.itemdelay = READUINT32(save->p);
+		players[i].botvars.itemconfirm = READUINT32(save->p);
+		players[i].botvars.turnconfirm = READSINT8(save->p);
+		players[i].botvars.spindashconfirm = READUINT32(save->p);
 
 		// itemroulette_t
-		players[i].itemRoulette.active = (boolean)READUINT8(save_p);
+		players[i].itemRoulette.active = (boolean)READUINT8(save->p);
 
 #ifdef ITEM_LIST_SIZE
-		players[i].itemRoulette.itemListLen = (size_t)READUINT32(save_p);
+		players[i].itemRoulette.itemListLen = (size_t)READUINT32(save->p);
 
 		for (q = 0; q < ITEM_LIST_SIZE; q++)
 		{
-			players[i].itemRoulette.itemList[q] = READSINT8(save_p);
+			players[i].itemRoulette.itemList[q] = READSINT8(save->p);
 		}
 #else
-		players[i].itemRoulette.itemListCap = (size_t)READUINT32(save_p);
-		players[i].itemRoulette.itemListLen = (size_t)READUINT32(save_p);
+		players[i].itemRoulette.itemListCap = (size_t)READUINT32(save->p);
+		players[i].itemRoulette.itemListLen = (size_t)READUINT32(save->p);
 
 		if (players[i].itemRoulette.itemListCap > 0)
 		{
@@ -812,19 +811,19 @@ static void P_NetUnArchivePlayers(void)
 
 			for (q = 0; q < players[i].itemRoulette.itemListLen; q++)
 			{
-				players[i].itemRoulette.itemList[q] = READSINT8(save_p);
+				players[i].itemRoulette.itemList[q] = READSINT8(save->p);
 			}
 		}
 #endif
 
-		players[i].itemRoulette.useOdds = READUINT8(save_p);
-		players[i].itemRoulette.dist = READUINT32(save_p);
-		players[i].itemRoulette.index = (size_t)READUINT32(save_p);
-		players[i].itemRoulette.sound = READUINT8(save_p);
-		players[i].itemRoulette.speed = (tic_t)READUINT32(save_p);
-		players[i].itemRoulette.tics = (tic_t)READUINT32(save_p);
-		players[i].itemRoulette.elapsed = (tic_t)READUINT32(save_p);
-		players[i].itemRoulette.eggman = (boolean)READUINT8(save_p);
+		players[i].itemRoulette.useOdds = READUINT8(save->p);
+		players[i].itemRoulette.dist = READUINT32(save->p);
+		players[i].itemRoulette.index = (size_t)READUINT32(save->p);
+		players[i].itemRoulette.sound = READUINT8(save->p);
+		players[i].itemRoulette.speed = (tic_t)READUINT32(save->p);
+		players[i].itemRoulette.tics = (tic_t)READUINT32(save->p);
+		players[i].itemRoulette.elapsed = (tic_t)READUINT32(save->p);
+		players[i].itemRoulette.eggman = (boolean)READUINT8(save->p);
 
 		//players[i].viewheight = P_GetPlayerViewHeight(players[i]); // scale cannot be factored in at this point
 	}
@@ -927,12 +926,12 @@ static void ClearNetColormaps(void)
 	net_colormaps = NULL;
 }
 
-static void P_NetArchiveColormaps(void)
+static void P_NetArchiveColormaps(savebuffer_t *save)
 {
 	// We save and then we clean up our colormap mess
 	extracolormap_t *exc, *exc_next;
 	UINT32 i = 0;
-	WRITEUINT32(save_p, num_net_colormaps); // save for safety
+	WRITEUINT32(save->p, num_net_colormaps); // save for safety
 
 	for (exc = net_colormaps; i < num_net_colormaps; i++, exc = exc_next)
 	{
@@ -941,15 +940,15 @@ static void P_NetArchiveColormaps(void)
 		if (!exc)
 			exc = R_CreateDefaultColormap(false);
 
-		WRITEUINT8(save_p, exc->fadestart);
-		WRITEUINT8(save_p, exc->fadeend);
-		WRITEUINT8(save_p, exc->flags);
+		WRITEUINT8(save->p, exc->fadestart);
+		WRITEUINT8(save->p, exc->fadeend);
+		WRITEUINT8(save->p, exc->flags);
 
-		WRITEINT32(save_p, exc->rgba);
-		WRITEINT32(save_p, exc->fadergba);
+		WRITEINT32(save->p, exc->rgba);
+		WRITEINT32(save->p, exc->fadergba);
 
 #ifdef EXTRACOLORMAPLUMPS
-		WRITESTRINGN(save_p, exc->lumpname, 9);
+		WRITESTRINGN(save->p, exc->lumpname, 9);
 #endif
 
 		exc_next = exc->next;
@@ -961,7 +960,7 @@ static void P_NetArchiveColormaps(void)
 	net_colormaps = NULL;
 }
 
-static void P_NetUnArchiveColormaps(void)
+static void P_NetUnArchiveColormaps(savebuffer_t *save)
 {
 	// When we reach this point, we already populated our list with
 	// dummy colormaps. Now that we are loading the color data,
@@ -969,7 +968,7 @@ static void P_NetUnArchiveColormaps(void)
 	extracolormap_t *exc, *existing_exc, *exc_next = NULL;
 	UINT32 i = 0;
 
-	num_net_colormaps = READUINT32(save_p);
+	num_net_colormaps = READUINT32(save->p);
 
 	for (exc = net_colormaps; i < num_net_colormaps; i++, exc = exc_next)
 	{
@@ -979,15 +978,15 @@ static void P_NetUnArchiveColormaps(void)
 		char lumpname[9];
 #endif
 
-		fadestart = READUINT8(save_p);
-		fadeend = READUINT8(save_p);
-		flags = READUINT8(save_p);
+		fadestart = READUINT8(save->p);
+		fadeend = READUINT8(save->p);
+		flags = READUINT8(save->p);
 
-		rgba = READINT32(save_p);
-		fadergba = READINT32(save_p);
+		rgba = READINT32(save->p);
+		fadergba = READINT32(save->p);
 
 #ifdef EXTRACOLORMAPLUMPS
-		READSTRINGN(save_p, lumpname, 9);
+		READSTRINGN(save->p, lumpname, 9);
 
 		if (lumpname[0])
 		{
@@ -1063,29 +1062,29 @@ static void P_NetUnArchiveColormaps(void)
 	net_colormaps = NULL;
 }
 
-static void P_NetArchiveTubeWaypoints(void)
+static void P_NetArchiveTubeWaypoints(savebuffer_t *save)
 {
 	INT32 i, j;
 
 	for (i = 0; i < NUMTUBEWAYPOINTSEQUENCES; i++)
 	{
-		WRITEUINT16(save_p, numtubewaypoints[i]);
+		WRITEUINT16(save->p, numtubewaypoints[i]);
 		for (j = 0; j < numtubewaypoints[i]; j++)
-			WRITEUINT32(save_p, tubewaypoints[i][j] ? tubewaypoints[i][j]->mobjnum : 0);
+			WRITEUINT32(save->p, tubewaypoints[i][j] ? tubewaypoints[i][j]->mobjnum : 0);
 	}
 }
 
-static void P_NetUnArchiveTubeWaypoints(void)
+static void P_NetUnArchiveTubeWaypoints(savebuffer_t *save)
 {
 	INT32 i, j;
 	UINT32 mobjnum;
 
 	for (i = 0; i < NUMTUBEWAYPOINTSEQUENCES; i++)
 	{
-		numtubewaypoints[i] = READUINT16(save_p);
+		numtubewaypoints[i] = READUINT16(save->p);
 		for (j = 0; j < numtubewaypoints[i]; j++)
 		{
-			mobjnum = READUINT32(save_p);
+			mobjnum = READUINT32(save->p);
 			tubewaypoints[i][j] = (mobjnum == 0) ? NULL : P_FindNewPosition(mobjnum);
 		}
 	}
@@ -1195,7 +1194,7 @@ static boolean CheckFFloorDiff(const sector_t *ss)
 
 // Special case: save the stats of all modified ffloors along with their ffloor "number"s
 // we don't bother with ffloors that haven't changed, that would just add to savegame even more than is really needed
-static void ArchiveFFloors(const sector_t *ss)
+static void ArchiveFFloors(savebuffer_t *save, const sector_t *ss)
 {
 	size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
 	ffloor_t *rover;
@@ -1210,19 +1209,19 @@ static void ArchiveFFloors(const sector_t *ss)
 
 		if (fflr_diff)
 		{
-			WRITEUINT16(save_p, j); // save ffloor "number"
-			WRITEUINT8(save_p, fflr_diff);
+			WRITEUINT16(save->p, j); // save ffloor "number"
+			WRITEUINT8(save->p, fflr_diff);
 			if (fflr_diff & FD_FLAGS)
-				WRITEUINT32(save_p, rover->fofflags);
+				WRITEUINT32(save->p, rover->fofflags);
 			if (fflr_diff & FD_ALPHA)
-				WRITEINT16(save_p, rover->alpha);
+				WRITEINT16(save->p, rover->alpha);
 		}
 		j++;
 	}
-	WRITEUINT16(save_p, 0xffff);
+	WRITEUINT16(save->p, 0xffff);
 }
 
-static void UnArchiveFFloors(const sector_t *ss)
+static void UnArchiveFFloors(savebuffer_t *save, const sector_t *ss)
 {
 	UINT16 j = 0; // number of current ffloor in loop
 	UINT16 fflr_i; // saved ffloor "number" of next modified ffloor
@@ -1233,7 +1232,7 @@ static void UnArchiveFFloors(const sector_t *ss)
 	if (!rover) // it is assumed sectors[i].ffloors actually exists, but just in case...
 		I_Error("Sector does not have any ffloors!");
 
-	fflr_i = READUINT16(save_p); // get first modified ffloor's number ready
+	fflr_i = READUINT16(save->p); // get first modified ffloor's number ready
 	for (;;) // for some reason the usual for (rover = x; ...) thing doesn't work here?
 	{
 		if (fflr_i == 0xffff) // end of modified ffloors list, let's stop already
@@ -1248,21 +1247,21 @@ static void UnArchiveFFloors(const sector_t *ss)
 			continue;
 		}
 
-		fflr_diff = READUINT8(save_p);
+		fflr_diff = READUINT8(save->p);
 
 		if (fflr_diff & FD_FLAGS)
-			rover->fofflags = READUINT32(save_p);
+			rover->fofflags = READUINT32(save->p);
 		if (fflr_diff & FD_ALPHA)
-			rover->alpha = READINT16(save_p);
+			rover->alpha = READINT16(save->p);
 
-		fflr_i = READUINT16(save_p); // get next ffloor "number" ready
+		fflr_i = READUINT16(save->p); // get next ffloor "number" ready
 
 		j++;
 		rover = rover->next;
 	}
 }
 
-static void ArchiveSectors(void)
+static void ArchiveSectors(savebuffer_t *save)
 {
 	size_t i, j;
 	const sector_t *ss = sectors;
@@ -1341,87 +1340,87 @@ static void ArchiveSectors(void)
 
 		if (diff)
 		{
-			WRITEUINT16(save_p, i);
-			WRITEUINT8(save_p, diff);
+			WRITEUINT16(save->p, i);
+			WRITEUINT8(save->p, diff);
 			if (diff & SD_DIFF2)
-				WRITEUINT8(save_p, diff2);
+				WRITEUINT8(save->p, diff2);
 			if (diff2 & SD_DIFF3)
-				WRITEUINT8(save_p, diff3);
+				WRITEUINT8(save->p, diff3);
 			if (diff3 & SD_DIFF4)
-				WRITEUINT8(save_p, diff4);
+				WRITEUINT8(save->p, diff4);
 			if (diff & SD_FLOORHT)
-				WRITEFIXED(save_p, ss->floorheight);
+				WRITEFIXED(save->p, ss->floorheight);
 			if (diff & SD_CEILHT)
-				WRITEFIXED(save_p, ss->ceilingheight);
+				WRITEFIXED(save->p, ss->ceilingheight);
 			if (diff & SD_FLOORPIC)
-				WRITEMEM(save_p, levelflats[ss->floorpic].name, 8);
+				WRITEMEM(save->p, levelflats[ss->floorpic].name, 8);
 			if (diff & SD_CEILPIC)
-				WRITEMEM(save_p, levelflats[ss->ceilingpic].name, 8);
+				WRITEMEM(save->p, levelflats[ss->ceilingpic].name, 8);
 			if (diff & SD_LIGHT)
-				WRITEINT16(save_p, ss->lightlevel);
+				WRITEINT16(save->p, ss->lightlevel);
 			if (diff & SD_SPECIAL)
-				WRITEINT16(save_p, ss->special);
+				WRITEINT16(save->p, ss->special);
 			if (diff2 & SD_FXOFFS)
-				WRITEFIXED(save_p, ss->floor_xoffs);
+				WRITEFIXED(save->p, ss->floor_xoffs);
 			if (diff2 & SD_FYOFFS)
-				WRITEFIXED(save_p, ss->floor_yoffs);
+				WRITEFIXED(save->p, ss->floor_yoffs);
 			if (diff2 & SD_CXOFFS)
-				WRITEFIXED(save_p, ss->ceiling_xoffs);
+				WRITEFIXED(save->p, ss->ceiling_xoffs);
 			if (diff2 & SD_CYOFFS)
-				WRITEFIXED(save_p, ss->ceiling_yoffs);
+				WRITEFIXED(save->p, ss->ceiling_yoffs);
 			if (diff2 & SD_FLOORANG)
-				WRITEANGLE(save_p, ss->floorpic_angle);
+				WRITEANGLE(save->p, ss->floorpic_angle);
 			if (diff2 & SD_CEILANG)
-				WRITEANGLE(save_p, ss->ceilingpic_angle);
+				WRITEANGLE(save->p, ss->ceilingpic_angle);
 			if (diff2 & SD_TAG)
 			{
-				WRITEUINT32(save_p, ss->tags.count);
+				WRITEUINT32(save->p, ss->tags.count);
 				for (j = 0; j < ss->tags.count; j++)
-					WRITEINT16(save_p, ss->tags.tags[j]);
+					WRITEINT16(save->p, ss->tags.tags[j]);
 			}
 
 			if (diff3 & SD_COLORMAP)
-				WRITEUINT32(save_p, CheckAddNetColormapToList(ss->extra_colormap));
+				WRITEUINT32(save->p, CheckAddNetColormapToList(ss->extra_colormap));
 					// returns existing index if already added, or appends to net_colormaps and returns new index
 			if (diff3 & SD_CRUMBLESTATE)
-				WRITEINT32(save_p, ss->crumblestate);
+				WRITEINT32(save->p, ss->crumblestate);
 			if (diff3 & SD_FLOORLIGHT)
 			{
-				WRITEINT16(save_p, ss->floorlightlevel);
-				WRITEUINT8(save_p, ss->floorlightabsolute);
+				WRITEINT16(save->p, ss->floorlightlevel);
+				WRITEUINT8(save->p, ss->floorlightabsolute);
 			}
 			if (diff3 & SD_CEILLIGHT)
 			{
-				WRITEINT16(save_p, ss->ceilinglightlevel);
-				WRITEUINT8(save_p, ss->ceilinglightabsolute);
+				WRITEINT16(save->p, ss->ceilinglightlevel);
+				WRITEUINT8(save->p, ss->ceilinglightabsolute);
 			}
 			if (diff3 & SD_FLAG)
-				WRITEUINT32(save_p, ss->flags);
+				WRITEUINT32(save->p, ss->flags);
 			if (diff3 & SD_SPECIALFLAG)
-				WRITEUINT32(save_p, ss->specialflags);
+				WRITEUINT32(save->p, ss->specialflags);
 			if (diff4 & SD_DAMAGETYPE)
-				WRITEUINT8(save_p, ss->damagetype);
+				WRITEUINT8(save->p, ss->damagetype);
 			if (diff4 & SD_TRIGGERTAG)
-				WRITEINT16(save_p, ss->triggertag);
+				WRITEINT16(save->p, ss->triggertag);
 			if (diff4 & SD_TRIGGERER)
-				WRITEUINT8(save_p, ss->triggerer);
+				WRITEUINT8(save->p, ss->triggerer);
 			if (diff4 & SD_GRAVITY)
-				WRITEFIXED(save_p, ss->gravity);
+				WRITEFIXED(save->p, ss->gravity);
 			if (diff & SD_FFLOORS)
-				ArchiveFFloors(ss);
+				ArchiveFFloors(save, ss);
 		}
 	}
 
-	WRITEUINT16(save_p, 0xffff);
+	WRITEUINT16(save->p, 0xffff);
 }
 
-static void UnArchiveSectors(void)
+static void UnArchiveSectors(savebuffer_t *save)
 {
 	UINT16 i, j;
 	UINT8 diff, diff2, diff3, diff4;
 	for (;;)
 	{
-		i = READUINT16(save_p);
+		i = READUINT16(save->p);
 
 		if (i == 0xffff)
 			break;
@@ -1429,54 +1428,54 @@ static void UnArchiveSectors(void)
 		if (i > numsectors)
 			I_Error("Invalid sector number %u from server (expected end at %s)", i, sizeu1(numsectors));
 
-		diff = READUINT8(save_p);
+		diff = READUINT8(save->p);
 		if (diff & SD_DIFF2)
-			diff2 = READUINT8(save_p);
+			diff2 = READUINT8(save->p);
 		else
 			diff2 = 0;
 		if (diff2 & SD_DIFF3)
-			diff3 = READUINT8(save_p);
+			diff3 = READUINT8(save->p);
 		else
 			diff3 = 0;
 		if (diff3 & SD_DIFF4)
-			diff4 = READUINT8(save_p);
+			diff4 = READUINT8(save->p);
 		else
 			diff4 = 0;
 
 		if (diff & SD_FLOORHT)
-			sectors[i].floorheight = READFIXED(save_p);
+			sectors[i].floorheight = READFIXED(save->p);
 		if (diff & SD_CEILHT)
-			sectors[i].ceilingheight = READFIXED(save_p);
+			sectors[i].ceilingheight = READFIXED(save->p);
 		if (diff & SD_FLOORPIC)
 		{
-			sectors[i].floorpic = P_AddLevelFlatRuntime((char *)save_p);
-			save_p += 8;
+			sectors[i].floorpic = P_AddLevelFlatRuntime((char *)save->p);
+			save->p += 8;
 		}
 		if (diff & SD_CEILPIC)
 		{
-			sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)save_p);
-			save_p += 8;
+			sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)save->p);
+			save->p += 8;
 		}
 		if (diff & SD_LIGHT)
-			sectors[i].lightlevel = READINT16(save_p);
+			sectors[i].lightlevel = READINT16(save->p);
 		if (diff & SD_SPECIAL)
-			sectors[i].special = READINT16(save_p);
+			sectors[i].special = READINT16(save->p);
 
 		if (diff2 & SD_FXOFFS)
-			sectors[i].floor_xoffs = READFIXED(save_p);
+			sectors[i].floor_xoffs = READFIXED(save->p);
 		if (diff2 & SD_FYOFFS)
-			sectors[i].floor_yoffs = READFIXED(save_p);
+			sectors[i].floor_yoffs = READFIXED(save->p);
 		if (diff2 & SD_CXOFFS)
-			sectors[i].ceiling_xoffs = READFIXED(save_p);
+			sectors[i].ceiling_xoffs = READFIXED(save->p);
 		if (diff2 & SD_CYOFFS)
-			sectors[i].ceiling_yoffs = READFIXED(save_p);
+			sectors[i].ceiling_yoffs = READFIXED(save->p);
 		if (diff2 & SD_FLOORANG)
-			sectors[i].floorpic_angle  = READANGLE(save_p);
+			sectors[i].floorpic_angle  = READANGLE(save->p);
 		if (diff2 & SD_CEILANG)
-			sectors[i].ceilingpic_angle = READANGLE(save_p);
+			sectors[i].ceilingpic_angle = READANGLE(save->p);
 		if (diff2 & SD_TAG)
 		{
-			size_t ncount = READUINT32(save_p);
+			size_t ncount = READUINT32(save->p);
 
 			// Remove entries from global lists.
 			for (j = 0; j < sectors[i].tags.count; j++)
@@ -1490,7 +1489,7 @@ static void UnArchiveSectors(void)
 			}
 
 			for (j = 0; j < ncount; j++)
-				sectors[i].tags.tags[j] = READINT16(save_p);
+				sectors[i].tags.tags[j] = READINT16(save->p);
 
 			// Add new entries.
 			for (j = 0; j < sectors[i].tags.count; j++)
@@ -1499,41 +1498,41 @@ static void UnArchiveSectors(void)
 
 
 		if (diff3 & SD_COLORMAP)
-			sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(save_p));
+			sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(save->p));
 		if (diff3 & SD_CRUMBLESTATE)
-			sectors[i].crumblestate = READINT32(save_p);
+			sectors[i].crumblestate = READINT32(save->p);
 		if (diff3 & SD_FLOORLIGHT)
 		{
-			sectors[i].floorlightlevel = READINT16(save_p);
-			sectors[i].floorlightabsolute = READUINT8(save_p);
+			sectors[i].floorlightlevel = READINT16(save->p);
+			sectors[i].floorlightabsolute = READUINT8(save->p);
 		}
 		if (diff3 & SD_CEILLIGHT)
 		{
-			sectors[i].ceilinglightlevel = READINT16(save_p);
-			sectors[i].ceilinglightabsolute = READUINT8(save_p);
+			sectors[i].ceilinglightlevel = READINT16(save->p);
+			sectors[i].ceilinglightabsolute = READUINT8(save->p);
 		}
 		if (diff3 & SD_FLAG)
 		{
-			sectors[i].flags = READUINT32(save_p);
+			sectors[i].flags = READUINT32(save->p);
 			CheckForReverseGravity |= (sectors[i].flags & MSF_GRAVITYFLIP);
 		}
 		if (diff3 & SD_SPECIALFLAG)
-			sectors[i].specialflags = READUINT32(save_p);
+			sectors[i].specialflags = READUINT32(save->p);
 		if (diff4 & SD_DAMAGETYPE)
-			sectors[i].damagetype = READUINT8(save_p);
+			sectors[i].damagetype = READUINT8(save->p);
 		if (diff4 & SD_TRIGGERTAG)
-			sectors[i].triggertag = READINT16(save_p);
+			sectors[i].triggertag = READINT16(save->p);
 		if (diff4 & SD_TRIGGERER)
-			sectors[i].triggerer = READUINT8(save_p);
+			sectors[i].triggerer = READUINT8(save->p);
 		if (diff4 & SD_GRAVITY)
-			sectors[i].gravity = READFIXED(save_p);
+			sectors[i].gravity = READFIXED(save->p);
 
 		if (diff & SD_FFLOORS)
-			UnArchiveFFloors(&sectors[i]);
+			UnArchiveFFloors(save, &sectors[i]);
 	}
 }
 
-static void ArchiveLines(void)
+static void ArchiveLines(savebuffer_t *save)
 {
 	size_t i;
 	const line_t *li = lines;
@@ -1594,41 +1593,41 @@ static void ArchiveLines(void)
 
 		if (diff)
 		{
-			WRITEINT16(save_p, i);
-			WRITEUINT8(save_p, diff);
+			WRITEINT16(save->p, i);
+			WRITEUINT8(save->p, diff);
 			if (diff & LD_DIFF2)
-				WRITEUINT8(save_p, diff2);
+				WRITEUINT8(save->p, diff2);
 			if (diff & LD_FLAG)
-				WRITEUINT32(save_p, li->flags);
+				WRITEUINT32(save->p, li->flags);
 			if (diff & LD_SPECIAL)
-				WRITEINT16(save_p, li->special);
+				WRITEINT16(save->p, li->special);
 			if (diff & LD_CLLCOUNT)
-				WRITEINT16(save_p, li->callcount);
+				WRITEINT16(save->p, li->callcount);
 
 			si = &sides[li->sidenum[0]];
 			if (diff & LD_S1TEXOFF)
-				WRITEFIXED(save_p, si->textureoffset);
+				WRITEFIXED(save->p, si->textureoffset);
 			if (diff & LD_S1TOPTEX)
-				WRITEINT32(save_p, si->toptexture);
+				WRITEINT32(save->p, si->toptexture);
 			if (diff & LD_S1BOTTEX)
-				WRITEINT32(save_p, si->bottomtexture);
+				WRITEINT32(save->p, si->bottomtexture);
 			if (diff & LD_S1MIDTEX)
-				WRITEINT32(save_p, si->midtexture);
+				WRITEINT32(save->p, si->midtexture);
 
 			si = &sides[li->sidenum[1]];
 			if (diff2 & LD_S2TEXOFF)
-				WRITEFIXED(save_p, si->textureoffset);
+				WRITEFIXED(save->p, si->textureoffset);
 			if (diff2 & LD_S2TOPTEX)
-				WRITEINT32(save_p, si->toptexture);
+				WRITEINT32(save->p, si->toptexture);
 			if (diff2 & LD_S2BOTTEX)
-				WRITEINT32(save_p, si->bottomtexture);
+				WRITEINT32(save->p, si->bottomtexture);
 			if (diff2 & LD_S2MIDTEX)
-				WRITEINT32(save_p, si->midtexture);
+				WRITEINT32(save->p, si->midtexture);
 			if (diff2 & LD_ARGS)
 			{
 				UINT8 j;
 				for (j = 0; j < NUMLINEARGS; j++)
-					WRITEINT32(save_p, li->args[j]);
+					WRITEINT32(save->p, li->args[j]);
 			}
 			if (diff2 & LD_STRINGARGS)
 			{
@@ -1639,24 +1638,24 @@ static void ArchiveLines(void)
 
 					if (!li->stringargs[j])
 					{
-						WRITEINT32(save_p, 0);
+						WRITEINT32(save->p, 0);
 						continue;
 					}
 
 					len = strlen(li->stringargs[j]);
-					WRITEINT32(save_p, len);
+					WRITEINT32(save->p, len);
 					for (k = 0; k < len; k++)
-						WRITECHAR(save_p, li->stringargs[j][k]);
+						WRITECHAR(save->p, li->stringargs[j][k]);
 				}
 			}
 			if (diff2 & LD_EXECUTORDELAY)
-				WRITEINT32(save_p, li->executordelay);
+				WRITEINT32(save->p, li->executordelay);
 		}
 	}
-	WRITEUINT16(save_p, 0xffff);
+	WRITEUINT16(save->p, 0xffff);
 }
 
-static void UnArchiveLines(void)
+static void UnArchiveLines(savebuffer_t *save)
 {
 	UINT16 i;
 	line_t *li;
@@ -1665,59 +1664,59 @@ static void UnArchiveLines(void)
 
 	for (;;)
 	{
-		i = READUINT16(save_p);
+		i = READUINT16(save->p);
 
 		if (i == 0xffff)
 			break;
 		if (i > numlines)
 			I_Error("Invalid line number %u from server", i);
 
-		diff = READUINT8(save_p);
+		diff = READUINT8(save->p);
 		li = &lines[i];
 
 		if (diff & LD_DIFF2)
-			diff2 = READUINT8(save_p);
+			diff2 = READUINT8(save->p);
 		else
 			diff2 = 0;
 
 		if (diff & LD_FLAG)
-			li->flags = READUINT32(save_p);
+			li->flags = READUINT32(save->p);
 		if (diff & LD_SPECIAL)
-			li->special = READINT16(save_p);
+			li->special = READINT16(save->p);
 		if (diff & LD_CLLCOUNT)
-			li->callcount = READINT16(save_p);
+			li->callcount = READINT16(save->p);
 
 		si = &sides[li->sidenum[0]];
 		if (diff & LD_S1TEXOFF)
-			si->textureoffset = READFIXED(save_p);
+			si->textureoffset = READFIXED(save->p);
 		if (diff & LD_S1TOPTEX)
-			si->toptexture = READINT32(save_p);
+			si->toptexture = READINT32(save->p);
 		if (diff & LD_S1BOTTEX)
-			si->bottomtexture = READINT32(save_p);
+			si->bottomtexture = READINT32(save->p);
 		if (diff & LD_S1MIDTEX)
-			si->midtexture = READINT32(save_p);
+			si->midtexture = READINT32(save->p);
 
 		si = &sides[li->sidenum[1]];
 		if (diff2 & LD_S2TEXOFF)
-			si->textureoffset = READFIXED(save_p);
+			si->textureoffset = READFIXED(save->p);
 		if (diff2 & LD_S2TOPTEX)
-			si->toptexture = READINT32(save_p);
+			si->toptexture = READINT32(save->p);
 		if (diff2 & LD_S2BOTTEX)
-			si->bottomtexture = READINT32(save_p);
+			si->bottomtexture = READINT32(save->p);
 		if (diff2 & LD_S2MIDTEX)
-			si->midtexture = READINT32(save_p);
+			si->midtexture = READINT32(save->p);
 		if (diff2 & LD_ARGS)
 		{
 			UINT8 j;
 			for (j = 0; j < NUMLINEARGS; j++)
-				li->args[j] = READINT32(save_p);
+				li->args[j] = READINT32(save->p);
 		}
 		if (diff2 & LD_STRINGARGS)
 		{
 			UINT8 j;
 			for (j = 0; j < NUMLINESTRINGARGS; j++)
 			{
-				size_t len = READINT32(save_p);
+				size_t len = READINT32(save->p);
 				size_t k;
 
 				if (!len)
@@ -1729,33 +1728,33 @@ static void UnArchiveLines(void)
 
 				li->stringargs[j] = Z_Realloc(li->stringargs[j], len + 1, PU_LEVEL, NULL);
 				for (k = 0; k < len; k++)
-					li->stringargs[j][k] = READCHAR(save_p);
+					li->stringargs[j][k] = READCHAR(save->p);
 				li->stringargs[j][len] = '\0';
 			}
 		}
 		if (diff2 & LD_EXECUTORDELAY)
-			li->executordelay = READINT32(save_p);
+			li->executordelay = READINT32(save->p);
 
 	}
 }
 
-static void P_NetArchiveWorld(void)
+static void P_NetArchiveWorld(savebuffer_t *save)
 {
 	// initialize colormap vars because paranoia
 	ClearNetColormaps();
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_WORLD);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_WORLD);
 
-	ArchiveSectors();
-	ArchiveLines();
+	ArchiveSectors(save);
+	ArchiveLines(save);
 	R_ClearTextureNumCache(false);
 }
 
-static void P_NetUnArchiveWorld(void)
+static void P_NetUnArchiveWorld(savebuffer_t *save)
 {
 	UINT16 i;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_WORLD)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_WORLD)
 		I_Error("Bad $$$.sav at archive block World");
 
 	// initialize colormap vars because paranoia
@@ -1769,8 +1768,8 @@ static void P_NetUnArchiveWorld(void)
 			num_ffloors++;
 	}
 
-	UnArchiveSectors();
-	UnArchiveLines();
+	UnArchiveSectors(save);
+	UnArchiveLines(save);
 }
 
 //
@@ -1924,7 +1923,7 @@ static UINT32 SaveSlope(const pslope_t *slope)
 	return 0xFFFFFFFF;
 }
 
-static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
+static void SaveMobjThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const mobj_t *mobj = (const mobj_t *)th;
 	UINT32 diff;
@@ -2102,28 +2101,28 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
 	if (mobj->type == MT_HOOPCENTER)
 		diff = MD_SPAWNPOINT;
 
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, diff);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, diff);
 	if (diff & MD_MORE)
-		WRITEUINT32(save_p, diff2);
+		WRITEUINT32(save->p, diff2);
 
 	// save pointer, at load time we will search this pointer to reinitilize pointers
-	WRITEUINT32(save_p, (size_t)mobj);
+	WRITEUINT32(save->p, (size_t)mobj);
 
-	WRITEFIXED(save_p, mobj->z); // Force this so 3dfloor problems don't arise.
-	WRITEFIXED(save_p, mobj->floorz);
-	WRITEFIXED(save_p, mobj->ceilingz);
+	WRITEFIXED(save->p, mobj->z); // Force this so 3dfloor problems don't arise.
+	WRITEFIXED(save->p, mobj->floorz);
+	WRITEFIXED(save->p, mobj->ceilingz);
 
 	if (diff2 & MD2_FLOORROVER)
 	{
-		WRITEUINT32(save_p, SaveSector(mobj->floorrover->target));
-		WRITEUINT16(save_p, P_GetFFloorID(mobj->floorrover));
+		WRITEUINT32(save->p, SaveSector(mobj->floorrover->target));
+		WRITEUINT16(save->p, P_GetFFloorID(mobj->floorrover));
 	}
 
 	if (diff2 & MD2_CEILINGROVER)
 	{
-		WRITEUINT32(save_p, SaveSector(mobj->ceilingrover->target));
-		WRITEUINT16(save_p, P_GetFFloorID(mobj->ceilingrover));
+		WRITEUINT32(save->p, SaveSector(mobj->ceilingrover->target));
+		WRITEUINT16(save->p, P_GetFFloorID(mobj->ceilingrover));
 	}
 
 	if (diff & MD_SPAWNPOINT)
@@ -2134,7 +2133,7 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
 		{
 			if (&mapthings[z] != mobj->spawnpoint)
 				continue;
-			WRITEUINT16(save_p, z);
+			WRITEUINT16(save->p, z);
 			break;
 		}
 		if (mobj->type == MT_HOOPCENTER)
@@ -2142,110 +2141,110 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
 	}
 
 	if (diff & MD_TYPE)
-		WRITEUINT32(save_p, mobj->type);
+		WRITEUINT32(save->p, mobj->type);
 	if (diff & MD_POS)
 	{
-		WRITEFIXED(save_p, mobj->x);
-		WRITEFIXED(save_p, mobj->y);
-		WRITEANGLE(save_p, mobj->angle);
-		WRITEANGLE(save_p, mobj->pitch);
-		WRITEANGLE(save_p, mobj->roll);
+		WRITEFIXED(save->p, mobj->x);
+		WRITEFIXED(save->p, mobj->y);
+		WRITEANGLE(save->p, mobj->angle);
+		WRITEANGLE(save->p, mobj->pitch);
+		WRITEANGLE(save->p, mobj->roll);
 	}
 	if (diff & MD_MOM)
 	{
-		WRITEFIXED(save_p, mobj->momx);
-		WRITEFIXED(save_p, mobj->momy);
-		WRITEFIXED(save_p, mobj->momz);
-		WRITEFIXED(save_p, mobj->pmomz);
+		WRITEFIXED(save->p, mobj->momx);
+		WRITEFIXED(save->p, mobj->momy);
+		WRITEFIXED(save->p, mobj->momz);
+		WRITEFIXED(save->p, mobj->pmomz);
 	}
 	if (diff & MD_RADIUS)
-		WRITEFIXED(save_p, mobj->radius);
+		WRITEFIXED(save->p, mobj->radius);
 	if (diff & MD_HEIGHT)
-		WRITEFIXED(save_p, mobj->height);
+		WRITEFIXED(save->p, mobj->height);
 	if (diff & MD_FLAGS)
-		WRITEUINT32(save_p, mobj->flags);
+		WRITEUINT32(save->p, mobj->flags);
 	if (diff & MD_FLAGS2)
-		WRITEUINT32(save_p, mobj->flags2);
+		WRITEUINT32(save->p, mobj->flags2);
 	if (diff & MD_HEALTH)
-		WRITEINT32(save_p, mobj->health);
+		WRITEINT32(save->p, mobj->health);
 	if (diff & MD_RTIME)
-		WRITEINT32(save_p, mobj->reactiontime);
+		WRITEINT32(save->p, mobj->reactiontime);
 	if (diff & MD_STATE)
-		WRITEUINT16(save_p, mobj->state-states);
+		WRITEUINT16(save->p, mobj->state-states);
 	if (diff & MD_TICS)
-		WRITEINT32(save_p, mobj->tics);
+		WRITEINT32(save->p, mobj->tics);
 	if (diff & MD_SPRITE) {
-		WRITEUINT16(save_p, mobj->sprite);
+		WRITEUINT16(save->p, mobj->sprite);
 		if (mobj->sprite == SPR_PLAY)
-			WRITEUINT8(save_p, mobj->sprite2);
+			WRITEUINT8(save->p, mobj->sprite2);
 	}
 	if (diff & MD_FRAME)
 	{
-		WRITEUINT32(save_p, mobj->frame);
-		WRITEUINT16(save_p, mobj->anim_duration);
+		WRITEUINT32(save->p, mobj->frame);
+		WRITEUINT16(save->p, mobj->anim_duration);
 	}
 	if (diff & MD_EFLAGS)
-		WRITEUINT16(save_p, mobj->eflags);
+		WRITEUINT16(save->p, mobj->eflags);
 	if (diff & MD_PLAYER)
-		WRITEUINT8(save_p, mobj->player-players);
+		WRITEUINT8(save->p, mobj->player-players);
 	if (diff & MD_MOVEDIR)
-		WRITEANGLE(save_p, mobj->movedir);
+		WRITEANGLE(save->p, mobj->movedir);
 	if (diff & MD_MOVECOUNT)
-		WRITEINT32(save_p, mobj->movecount);
+		WRITEINT32(save->p, mobj->movecount);
 	if (diff & MD_THRESHOLD)
-		WRITEINT32(save_p, mobj->threshold);
+		WRITEINT32(save->p, mobj->threshold);
 	if (diff & MD_LASTLOOK)
-		WRITEINT32(save_p, mobj->lastlook);
+		WRITEINT32(save->p, mobj->lastlook);
 	if (diff & MD_TARGET)
-		WRITEUINT32(save_p, mobj->target->mobjnum);
+		WRITEUINT32(save->p, mobj->target->mobjnum);
 	if (diff & MD_TRACER)
-		WRITEUINT32(save_p, mobj->tracer->mobjnum);
+		WRITEUINT32(save->p, mobj->tracer->mobjnum);
 	if (diff & MD_FRICTION)
-		WRITEFIXED(save_p, mobj->friction);
+		WRITEFIXED(save->p, mobj->friction);
 	if (diff & MD_MOVEFACTOR)
-		WRITEFIXED(save_p, mobj->movefactor);
+		WRITEFIXED(save->p, mobj->movefactor);
 	if (diff & MD_FUSE)
-		WRITEINT32(save_p, mobj->fuse);
+		WRITEINT32(save->p, mobj->fuse);
 	if (diff & MD_WATERTOP)
-		WRITEFIXED(save_p, mobj->watertop);
+		WRITEFIXED(save->p, mobj->watertop);
 	if (diff & MD_WATERBOTTOM)
-		WRITEFIXED(save_p, mobj->waterbottom);
+		WRITEFIXED(save->p, mobj->waterbottom);
 	if (diff & MD_SCALE)
-		WRITEFIXED(save_p, mobj->scale);
+		WRITEFIXED(save->p, mobj->scale);
 	if (diff & MD_DSCALE)
-		WRITEFIXED(save_p, mobj->destscale);
+		WRITEFIXED(save->p, mobj->destscale);
 	if (diff2 & MD2_SCALESPEED)
-		WRITEFIXED(save_p, mobj->scalespeed);
+		WRITEFIXED(save->p, mobj->scalespeed);
 	if (diff2 & MD2_CUSVAL)
-		WRITEINT32(save_p, mobj->cusval);
+		WRITEINT32(save->p, mobj->cusval);
 	if (diff2 & MD2_CVMEM)
-		WRITEINT32(save_p, mobj->cvmem);
+		WRITEINT32(save->p, mobj->cvmem);
 	if (diff2 & MD2_SKIN)
-		WRITEUINT8(save_p, (UINT8)((skin_t *)mobj->skin - skins));
+		WRITEUINT8(save->p, (UINT8)((skin_t *)mobj->skin - skins));
 	if (diff2 & MD2_COLOR)
-		WRITEUINT16(save_p, mobj->color);
+		WRITEUINT16(save->p, mobj->color);
 	if (diff2 & MD2_EXTVAL1)
-		WRITEINT32(save_p, mobj->extravalue1);
+		WRITEINT32(save->p, mobj->extravalue1);
 	if (diff2 & MD2_EXTVAL2)
-		WRITEINT32(save_p, mobj->extravalue2);
+		WRITEINT32(save->p, mobj->extravalue2);
 	if (diff2 & MD2_HNEXT)
-		WRITEUINT32(save_p, mobj->hnext->mobjnum);
+		WRITEUINT32(save->p, mobj->hnext->mobjnum);
 	if (diff2 & MD2_HPREV)
-		WRITEUINT32(save_p, mobj->hprev->mobjnum);
+		WRITEUINT32(save->p, mobj->hprev->mobjnum);
 	if (diff2 & MD2_ITNEXT)
-		WRITEUINT32(save_p, mobj->itnext->mobjnum);
+		WRITEUINT32(save->p, mobj->itnext->mobjnum);
 	if (diff2 & MD2_SLOPE)
-		WRITEUINT16(save_p, mobj->standingslope->id);
+		WRITEUINT16(save->p, mobj->standingslope->id);
 	if (diff2 & MD2_COLORIZED)
-		WRITEUINT8(save_p, mobj->colorized);
+		WRITEUINT8(save->p, mobj->colorized);
 	if (diff2 & MD2_MIRRORED)
-		WRITEUINT8(save_p, mobj->mirrored);
+		WRITEUINT8(save->p, mobj->mirrored);
 	if (diff2 & MD2_ROLLANGLE)
-		WRITEANGLE(save_p, mobj->rollangle);
+		WRITEANGLE(save->p, mobj->rollangle);
 	if (diff2 & MD2_SHADOWSCALE)
 	{
-		WRITEFIXED(save_p, mobj->shadowscale);
-		WRITEUINT8(save_p, mobj->whiteshadow);
+		WRITEFIXED(save->p, mobj->shadowscale);
+		WRITEUINT8(save->p, mobj->whiteshadow);
 	}
 	if (diff2 & MD2_RENDERFLAGS)
 	{
@@ -2259,553 +2258,553 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
 		&& q != (RF_DONTDRAWP4|RF_DONTDRAWP2|RF_DONTDRAWP3))
 			rf &= ~q;
 
-		WRITEUINT32(save_p, rf);
+		WRITEUINT32(save->p, rf);
 	}
 	if (diff2 & MD2_SPRITEXSCALE)
-		WRITEFIXED(save_p, mobj->spritexscale);
+		WRITEFIXED(save->p, mobj->spritexscale);
 	if (diff2 & MD2_SPRITEYSCALE)
-		WRITEFIXED(save_p, mobj->spriteyscale);
+		WRITEFIXED(save->p, mobj->spriteyscale);
 	if (diff2 & MD2_SPRITEXOFFSET)
-		WRITEFIXED(save_p, mobj->spritexoffset);
+		WRITEFIXED(save->p, mobj->spritexoffset);
 	if (diff2 & MD2_SPRITEYOFFSET)
-		WRITEFIXED(save_p, mobj->spriteyoffset);
+		WRITEFIXED(save->p, mobj->spriteyoffset);
 	if (diff2 & MD2_FLOORSPRITESLOPE)
 	{
 		pslope_t *slope = mobj->floorspriteslope;
 
-		WRITEFIXED(save_p, slope->zdelta);
-		WRITEANGLE(save_p, slope->zangle);
-		WRITEANGLE(save_p, slope->xydirection);
+		WRITEFIXED(save->p, slope->zdelta);
+		WRITEANGLE(save->p, slope->zangle);
+		WRITEANGLE(save->p, slope->xydirection);
 
-		WRITEFIXED(save_p, slope->o.x);
-		WRITEFIXED(save_p, slope->o.y);
-		WRITEFIXED(save_p, slope->o.z);
+		WRITEFIXED(save->p, slope->o.x);
+		WRITEFIXED(save->p, slope->o.y);
+		WRITEFIXED(save->p, slope->o.z);
 
-		WRITEFIXED(save_p, slope->d.x);
-		WRITEFIXED(save_p, slope->d.y);
+		WRITEFIXED(save->p, slope->d.x);
+		WRITEFIXED(save->p, slope->d.y);
 
-		WRITEFIXED(save_p, slope->normal.x);
-		WRITEFIXED(save_p, slope->normal.y);
-		WRITEFIXED(save_p, slope->normal.z);
+		WRITEFIXED(save->p, slope->normal.x);
+		WRITEFIXED(save->p, slope->normal.y);
+		WRITEFIXED(save->p, slope->normal.z);
 	}
 	if (diff2 & MD2_HITLAG)
 	{
-		WRITEINT32(save_p, mobj->hitlag);
+		WRITEINT32(save->p, mobj->hitlag);
 	}
 	if (diff2 & MD2_WATERSKIP)
 	{
-		WRITEUINT8(save_p, mobj->waterskip);
+		WRITEUINT8(save->p, mobj->waterskip);
 	}
 	if (diff2 & MD2_DISPOFFSET)
 	{
-		WRITEINT32(save_p, mobj->dispoffset);
+		WRITEINT32(save->p, mobj->dispoffset);
 	}
 	if (diff2 & MD2_LASTMOMZ)
 	{
-		WRITEINT32(save_p, mobj->lastmomz);
+		WRITEINT32(save->p, mobj->lastmomz);
 	}
 	if (diff2 & MD2_TERRAIN)
 	{
-		WRITEUINT32(save_p, K_GetTerrainHeapIndex(mobj->terrain));
-		WRITEUINT32(save_p, SaveMobjnum(mobj->terrainOverlay));
+		WRITEUINT32(save->p, K_GetTerrainHeapIndex(mobj->terrain));
+		WRITEUINT32(save->p, SaveMobjnum(mobj->terrainOverlay));
 	}
 
-	WRITEUINT32(save_p, mobj->mobjnum);
+	WRITEUINT32(save->p, mobj->mobjnum);
 }
 
-static void SaveNoEnemiesThinker(const thinker_t *th, const UINT8 type)
+static void SaveNoEnemiesThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const noenemies_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
 }
 
-static void SaveBounceCheeseThinker(const thinker_t *th, const UINT8 type)
+static void SaveBounceCheeseThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const bouncecheese_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEFIXED(save_p, ht->speed);
-	WRITEFIXED(save_p, ht->distance);
-	WRITEFIXED(save_p, ht->floorwasheight);
-	WRITEFIXED(save_p, ht->ceilingwasheight);
-	WRITECHAR(save_p, ht->low);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEFIXED(save->p, ht->speed);
+	WRITEFIXED(save->p, ht->distance);
+	WRITEFIXED(save->p, ht->floorwasheight);
+	WRITEFIXED(save->p, ht->ceilingwasheight);
+	WRITECHAR(save->p, ht->low);
 }
 
-static void SaveContinuousFallThinker(const thinker_t *th, const UINT8 type)
+static void SaveContinuousFallThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const continuousfall_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEFIXED(save_p, ht->speed);
-	WRITEINT32(save_p, ht->direction);
-	WRITEFIXED(save_p, ht->floorstartheight);
-	WRITEFIXED(save_p, ht->ceilingstartheight);
-	WRITEFIXED(save_p, ht->destheight);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEFIXED(save->p, ht->speed);
+	WRITEINT32(save->p, ht->direction);
+	WRITEFIXED(save->p, ht->floorstartheight);
+	WRITEFIXED(save->p, ht->ceilingstartheight);
+	WRITEFIXED(save->p, ht->destheight);
 }
 
-static void SaveMarioBlockThinker(const thinker_t *th, const UINT8 type)
+static void SaveMarioBlockThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const mariothink_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEFIXED(save_p, ht->speed);
-	WRITEINT32(save_p, ht->direction);
-	WRITEFIXED(save_p, ht->floorstartheight);
-	WRITEFIXED(save_p, ht->ceilingstartheight);
-	WRITEINT16(save_p, ht->tag);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEFIXED(save->p, ht->speed);
+	WRITEINT32(save->p, ht->direction);
+	WRITEFIXED(save->p, ht->floorstartheight);
+	WRITEFIXED(save->p, ht->ceilingstartheight);
+	WRITEINT16(save->p, ht->tag);
 }
 
-static void SaveMarioCheckThinker(const thinker_t *th, const UINT8 type)
+static void SaveMarioCheckThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const mariocheck_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEUINT32(save_p, SaveSector(ht->sector));
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEUINT32(save->p, SaveSector(ht->sector));
 }
 
-static void SaveThwompThinker(const thinker_t *th, const UINT8 type)
+static void SaveThwompThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const thwomp_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEFIXED(save_p, ht->crushspeed);
-	WRITEFIXED(save_p, ht->retractspeed);
-	WRITEINT32(save_p, ht->direction);
-	WRITEFIXED(save_p, ht->floorstartheight);
-	WRITEFIXED(save_p, ht->ceilingstartheight);
-	WRITEINT32(save_p, ht->delay);
-	WRITEINT16(save_p, ht->tag);
-	WRITEUINT16(save_p, ht->sound);
-	WRITEINT32(save_p, ht->initDelay);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEFIXED(save->p, ht->crushspeed);
+	WRITEFIXED(save->p, ht->retractspeed);
+	WRITEINT32(save->p, ht->direction);
+	WRITEFIXED(save->p, ht->floorstartheight);
+	WRITEFIXED(save->p, ht->ceilingstartheight);
+	WRITEINT32(save->p, ht->delay);
+	WRITEINT16(save->p, ht->tag);
+	WRITEUINT16(save->p, ht->sound);
+	WRITEINT32(save->p, ht->initDelay);
 }
 
-static void SaveFloatThinker(const thinker_t *th, const UINT8 type)
+static void SaveFloatThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const floatthink_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT16(save_p, ht->tag);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT16(save->p, ht->tag);
 }
 
-static void SaveEachTimeThinker(const thinker_t *th, const UINT8 type)
+static void SaveEachTimeThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const eachtime_t *ht  = (const void *)th;
 	size_t i;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
 	for (i = 0; i < MAXPLAYERS; i++)
 	{
-		WRITECHAR(save_p, ht->playersInArea[i]);
+		WRITECHAR(save->p, ht->playersInArea[i]);
 	}
-	WRITECHAR(save_p, ht->triggerOnExit);
+	WRITECHAR(save->p, ht->triggerOnExit);
 }
 
-static void SaveRaiseThinker(const thinker_t *th, const UINT8 type)
+static void SaveRaiseThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const raise_t *ht  = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT16(save_p, ht->tag);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEFIXED(save_p, ht->ceilingbottom);
-	WRITEFIXED(save_p, ht->ceilingtop);
-	WRITEFIXED(save_p, ht->basespeed);
-	WRITEFIXED(save_p, ht->extraspeed);
-	WRITEUINT8(save_p, ht->shaketimer);
-	WRITEUINT8(save_p, ht->flags);
+	WRITEUINT8(save->p, type);
+	WRITEINT16(save->p, ht->tag);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEFIXED(save->p, ht->ceilingbottom);
+	WRITEFIXED(save->p, ht->ceilingtop);
+	WRITEFIXED(save->p, ht->basespeed);
+	WRITEFIXED(save->p, ht->extraspeed);
+	WRITEUINT8(save->p, ht->shaketimer);
+	WRITEUINT8(save->p, ht->flags);
 }
 
-static void SaveCeilingThinker(const thinker_t *th, const UINT8 type)
+static void SaveCeilingThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const ceiling_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT8(save_p, ht->type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEFIXED(save_p, ht->bottomheight);
-	WRITEFIXED(save_p, ht->topheight);
-	WRITEFIXED(save_p, ht->speed);
-	WRITEFIXED(save_p, ht->delay);
-	WRITEFIXED(save_p, ht->delaytimer);
-	WRITEUINT8(save_p, ht->crush);
-	WRITEINT32(save_p, ht->texture);
-	WRITEINT32(save_p, ht->direction);
-	WRITEINT16(save_p, ht->tag);
-	WRITEFIXED(save_p, ht->origspeed);
-	WRITEFIXED(save_p, ht->sourceline);
+	WRITEUINT8(save->p, type);
+	WRITEUINT8(save->p, ht->type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEFIXED(save->p, ht->bottomheight);
+	WRITEFIXED(save->p, ht->topheight);
+	WRITEFIXED(save->p, ht->speed);
+	WRITEFIXED(save->p, ht->delay);
+	WRITEFIXED(save->p, ht->delaytimer);
+	WRITEUINT8(save->p, ht->crush);
+	WRITEINT32(save->p, ht->texture);
+	WRITEINT32(save->p, ht->direction);
+	WRITEINT16(save->p, ht->tag);
+	WRITEFIXED(save->p, ht->origspeed);
+	WRITEFIXED(save->p, ht->sourceline);
 }
 
-static void SaveFloormoveThinker(const thinker_t *th, const UINT8 type)
+static void SaveFloormoveThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const floormove_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT8(save_p, ht->type);
-	WRITEUINT8(save_p, ht->crush);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT32(save_p, ht->direction);
-	WRITEINT32(save_p, ht->texture);
-	WRITEFIXED(save_p, ht->floordestheight);
-	WRITEFIXED(save_p, ht->speed);
-	WRITEFIXED(save_p, ht->origspeed);
-	WRITEFIXED(save_p, ht->delay);
-	WRITEFIXED(save_p, ht->delaytimer);
-	WRITEINT16(save_p, ht->tag);
-	WRITEFIXED(save_p, ht->sourceline);
+	WRITEUINT8(save->p, type);
+	WRITEUINT8(save->p, ht->type);
+	WRITEUINT8(save->p, ht->crush);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT32(save->p, ht->direction);
+	WRITEINT32(save->p, ht->texture);
+	WRITEFIXED(save->p, ht->floordestheight);
+	WRITEFIXED(save->p, ht->speed);
+	WRITEFIXED(save->p, ht->origspeed);
+	WRITEFIXED(save->p, ht->delay);
+	WRITEFIXED(save->p, ht->delaytimer);
+	WRITEINT16(save->p, ht->tag);
+	WRITEFIXED(save->p, ht->sourceline);
 }
 
-static void SaveLightflashThinker(const thinker_t *th, const UINT8 type)
+static void SaveLightflashThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const lightflash_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT32(save_p, ht->maxlight);
-	WRITEINT32(save_p, ht->minlight);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT32(save->p, ht->maxlight);
+	WRITEINT32(save->p, ht->minlight);
 }
 
-static void SaveStrobeThinker(const thinker_t *th, const UINT8 type)
+static void SaveStrobeThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const strobe_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT32(save_p, ht->count);
-	WRITEINT16(save_p, ht->minlight);
-	WRITEINT16(save_p, ht->maxlight);
-	WRITEINT32(save_p, ht->darktime);
-	WRITEINT32(save_p, ht->brighttime);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT32(save->p, ht->count);
+	WRITEINT16(save->p, ht->minlight);
+	WRITEINT16(save->p, ht->maxlight);
+	WRITEINT32(save->p, ht->darktime);
+	WRITEINT32(save->p, ht->brighttime);
 }
 
-static void SaveGlowThinker(const thinker_t *th, const UINT8 type)
+static void SaveGlowThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const glow_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT16(save_p, ht->minlight);
-	WRITEINT16(save_p, ht->maxlight);
-	WRITEINT16(save_p, ht->direction);
-	WRITEINT16(save_p, ht->speed);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT16(save->p, ht->minlight);
+	WRITEINT16(save->p, ht->maxlight);
+	WRITEINT16(save->p, ht->direction);
+	WRITEINT16(save->p, ht->speed);
 }
 
-static inline void SaveFireflickerThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveFireflickerThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const fireflicker_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT32(save_p, ht->count);
-	WRITEINT32(save_p, ht->resetcount);
-	WRITEINT16(save_p, ht->maxlight);
-	WRITEINT16(save_p, ht->minlight);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT32(save->p, ht->count);
+	WRITEINT32(save->p, ht->resetcount);
+	WRITEINT16(save->p, ht->maxlight);
+	WRITEINT16(save->p, ht->minlight);
 }
 
-static void SaveElevatorThinker(const thinker_t *th, const UINT8 type)
+static void SaveElevatorThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const elevator_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT8(save_p, ht->type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEUINT32(save_p, SaveSector(ht->actionsector));
-	WRITEINT32(save_p, ht->direction);
-	WRITEFIXED(save_p, ht->floordestheight);
-	WRITEFIXED(save_p, ht->ceilingdestheight);
-	WRITEFIXED(save_p, ht->speed);
-	WRITEFIXED(save_p, ht->origspeed);
-	WRITEFIXED(save_p, ht->low);
-	WRITEFIXED(save_p, ht->high);
-	WRITEFIXED(save_p, ht->distance);
-	WRITEFIXED(save_p, ht->delay);
-	WRITEFIXED(save_p, ht->delaytimer);
-	WRITEFIXED(save_p, ht->floorwasheight);
-	WRITEFIXED(save_p, ht->ceilingwasheight);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
+	WRITEUINT8(save->p, type);
+	WRITEUINT8(save->p, ht->type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEUINT32(save->p, SaveSector(ht->actionsector));
+	WRITEINT32(save->p, ht->direction);
+	WRITEFIXED(save->p, ht->floordestheight);
+	WRITEFIXED(save->p, ht->ceilingdestheight);
+	WRITEFIXED(save->p, ht->speed);
+	WRITEFIXED(save->p, ht->origspeed);
+	WRITEFIXED(save->p, ht->low);
+	WRITEFIXED(save->p, ht->high);
+	WRITEFIXED(save->p, ht->distance);
+	WRITEFIXED(save->p, ht->delay);
+	WRITEFIXED(save->p, ht->delaytimer);
+	WRITEFIXED(save->p, ht->floorwasheight);
+	WRITEFIXED(save->p, ht->ceilingwasheight);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
 }
 
-static void SaveCrumbleThinker(const thinker_t *th, const UINT8 type)
+static void SaveCrumbleThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const crumble_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEUINT32(save_p, SaveSector(ht->actionsector));
-	WRITEUINT32(save_p, SavePlayer(ht->player)); // was dummy
-	WRITEINT32(save_p, ht->direction);
-	WRITEINT32(save_p, ht->origalpha);
-	WRITEINT32(save_p, ht->timer);
-	WRITEFIXED(save_p, ht->speed);
-	WRITEFIXED(save_p, ht->floorwasheight);
-	WRITEFIXED(save_p, ht->ceilingwasheight);
-	WRITEUINT8(save_p, ht->flags);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEUINT32(save->p, SaveSector(ht->actionsector));
+	WRITEUINT32(save->p, SavePlayer(ht->player)); // was dummy
+	WRITEINT32(save->p, ht->direction);
+	WRITEINT32(save->p, ht->origalpha);
+	WRITEINT32(save->p, ht->timer);
+	WRITEFIXED(save->p, ht->speed);
+	WRITEFIXED(save->p, ht->floorwasheight);
+	WRITEFIXED(save->p, ht->ceilingwasheight);
+	WRITEUINT8(save->p, ht->flags);
 }
 
-static inline void SaveScrollThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveScrollThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const scroll_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEFIXED(save_p, ht->dx);
-	WRITEFIXED(save_p, ht->dy);
-	WRITEINT32(save_p, ht->affectee);
-	WRITEINT32(save_p, ht->control);
-	WRITEFIXED(save_p, ht->last_height);
-	WRITEFIXED(save_p, ht->vdx);
-	WRITEFIXED(save_p, ht->vdy);
-	WRITEINT32(save_p, ht->accel);
-	WRITEINT32(save_p, ht->exclusive);
-	WRITEUINT8(save_p, ht->type);
+	WRITEUINT8(save->p, type);
+	WRITEFIXED(save->p, ht->dx);
+	WRITEFIXED(save->p, ht->dy);
+	WRITEINT32(save->p, ht->affectee);
+	WRITEINT32(save->p, ht->control);
+	WRITEFIXED(save->p, ht->last_height);
+	WRITEFIXED(save->p, ht->vdx);
+	WRITEFIXED(save->p, ht->vdy);
+	WRITEINT32(save->p, ht->accel);
+	WRITEINT32(save->p, ht->exclusive);
+	WRITEUINT8(save->p, ht->type);
 }
 
-static inline void SaveFrictionThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveFrictionThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const friction_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->friction);
-	WRITEINT32(save_p, ht->movefactor);
-	WRITEINT32(save_p, ht->affectee);
-	WRITEINT32(save_p, ht->referrer);
-	WRITEUINT8(save_p, ht->roverfriction);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->friction);
+	WRITEINT32(save->p, ht->movefactor);
+	WRITEINT32(save->p, ht->affectee);
+	WRITEINT32(save->p, ht->referrer);
+	WRITEUINT8(save->p, ht->roverfriction);
 }
 
-static inline void SavePusherThinker(const thinker_t *th, const UINT8 type)
+static inline void SavePusherThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const pusher_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT8(save_p, ht->type);
-	WRITEFIXED(save_p, ht->x_mag);
-	WRITEFIXED(save_p, ht->y_mag);
-	WRITEFIXED(save_p, ht->z_mag);
-	WRITEINT32(save_p, ht->affectee);
-	WRITEUINT8(save_p, ht->roverpusher);
-	WRITEINT32(save_p, ht->referrer);
-	WRITEINT32(save_p, ht->exclusive);
-	WRITEINT32(save_p, ht->slider);
+	WRITEUINT8(save->p, type);
+	WRITEUINT8(save->p, ht->type);
+	WRITEFIXED(save->p, ht->x_mag);
+	WRITEFIXED(save->p, ht->y_mag);
+	WRITEFIXED(save->p, ht->z_mag);
+	WRITEINT32(save->p, ht->affectee);
+	WRITEUINT8(save->p, ht->roverpusher);
+	WRITEINT32(save->p, ht->referrer);
+	WRITEINT32(save->p, ht->exclusive);
+	WRITEINT32(save->p, ht->slider);
 }
 
-static void SaveLaserThinker(const thinker_t *th, const UINT8 type)
+static void SaveLaserThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const laserthink_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT16(save_p, ht->tag);
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEUINT8(save_p, ht->nobosses);
+	WRITEUINT8(save->p, type);
+	WRITEINT16(save->p, ht->tag);
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEUINT8(save->p, ht->nobosses);
 }
 
-static void SaveLightlevelThinker(const thinker_t *th, const UINT8 type)
+static void SaveLightlevelThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const lightlevel_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT16(save_p, ht->sourcelevel);
-	WRITEINT16(save_p, ht->destlevel);
-	WRITEFIXED(save_p, ht->fixedcurlevel);
-	WRITEFIXED(save_p, ht->fixedpertic);
-	WRITEINT32(save_p, ht->timer);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT16(save->p, ht->sourcelevel);
+	WRITEINT16(save->p, ht->destlevel);
+	WRITEFIXED(save->p, ht->fixedcurlevel);
+	WRITEFIXED(save->p, ht->fixedpertic);
+	WRITEINT32(save->p, ht->timer);
 }
 
-static void SaveExecutorThinker(const thinker_t *th, const UINT8 type)
+static void SaveExecutorThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const executor_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveLine(ht->line));
-	WRITEUINT32(save_p, SaveMobjnum(ht->caller));
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEINT32(save_p, ht->timer);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveLine(ht->line));
+	WRITEUINT32(save->p, SaveMobjnum(ht->caller));
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEINT32(save->p, ht->timer);
 }
 
-static void SaveDisappearThinker(const thinker_t *th, const UINT8 type)
+static void SaveDisappearThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const disappear_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, ht->appeartime);
-	WRITEUINT32(save_p, ht->disappeartime);
-	WRITEUINT32(save_p, ht->offset);
-	WRITEUINT32(save_p, ht->timer);
-	WRITEINT32(save_p, ht->affectee);
-	WRITEINT32(save_p, ht->sourceline);
-	WRITEINT32(save_p, ht->exists);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, ht->appeartime);
+	WRITEUINT32(save->p, ht->disappeartime);
+	WRITEUINT32(save->p, ht->offset);
+	WRITEUINT32(save->p, ht->timer);
+	WRITEINT32(save->p, ht->affectee);
+	WRITEINT32(save->p, ht->sourceline);
+	WRITEINT32(save->p, ht->exists);
 }
 
-static void SaveFadeThinker(const thinker_t *th, const UINT8 type)
+static void SaveFadeThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const fade_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, CheckAddNetColormapToList(ht->dest_exc));
-	WRITEUINT32(save_p, ht->sectornum);
-	WRITEUINT32(save_p, ht->ffloornum);
-	WRITEINT32(save_p, ht->alpha);
-	WRITEINT16(save_p, ht->sourcevalue);
-	WRITEINT16(save_p, ht->destvalue);
-	WRITEINT16(save_p, ht->destlightlevel);
-	WRITEINT16(save_p, ht->speed);
-	WRITEUINT8(save_p, (UINT8)ht->ticbased);
-	WRITEINT32(save_p, ht->timer);
-	WRITEUINT8(save_p, ht->doexists);
-	WRITEUINT8(save_p, ht->dotranslucent);
-	WRITEUINT8(save_p, ht->dolighting);
-	WRITEUINT8(save_p, ht->docolormap);
-	WRITEUINT8(save_p, ht->docollision);
-	WRITEUINT8(save_p, ht->doghostfade);
-	WRITEUINT8(save_p, ht->exactalpha);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, CheckAddNetColormapToList(ht->dest_exc));
+	WRITEUINT32(save->p, ht->sectornum);
+	WRITEUINT32(save->p, ht->ffloornum);
+	WRITEINT32(save->p, ht->alpha);
+	WRITEINT16(save->p, ht->sourcevalue);
+	WRITEINT16(save->p, ht->destvalue);
+	WRITEINT16(save->p, ht->destlightlevel);
+	WRITEINT16(save->p, ht->speed);
+	WRITEUINT8(save->p, (UINT8)ht->ticbased);
+	WRITEINT32(save->p, ht->timer);
+	WRITEUINT8(save->p, ht->doexists);
+	WRITEUINT8(save->p, ht->dotranslucent);
+	WRITEUINT8(save->p, ht->dolighting);
+	WRITEUINT8(save->p, ht->docolormap);
+	WRITEUINT8(save->p, ht->docollision);
+	WRITEUINT8(save->p, ht->doghostfade);
+	WRITEUINT8(save->p, ht->exactalpha);
 }
 
-static void SaveFadeColormapThinker(const thinker_t *th, const UINT8 type)
+static void SaveFadeColormapThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const fadecolormap_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSector(ht->sector));
-	WRITEUINT32(save_p, CheckAddNetColormapToList(ht->source_exc));
-	WRITEUINT32(save_p, CheckAddNetColormapToList(ht->dest_exc));
-	WRITEUINT8(save_p, (UINT8)ht->ticbased);
-	WRITEINT32(save_p, ht->duration);
-	WRITEINT32(save_p, ht->timer);
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSector(ht->sector));
+	WRITEUINT32(save->p, CheckAddNetColormapToList(ht->source_exc));
+	WRITEUINT32(save->p, CheckAddNetColormapToList(ht->dest_exc));
+	WRITEUINT8(save->p, (UINT8)ht->ticbased);
+	WRITEINT32(save->p, ht->duration);
+	WRITEINT32(save->p, ht->timer);
 }
 
-static void SavePlaneDisplaceThinker(const thinker_t *th, const UINT8 type)
+static void SavePlaneDisplaceThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const planedisplace_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->affectee);
-	WRITEINT32(save_p, ht->control);
-	WRITEFIXED(save_p, ht->last_height);
-	WRITEFIXED(save_p, ht->speed);
-	WRITEUINT8(save_p, ht->type);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->affectee);
+	WRITEINT32(save->p, ht->control);
+	WRITEFIXED(save->p, ht->last_height);
+	WRITEFIXED(save->p, ht->speed);
+	WRITEUINT8(save->p, ht->type);
 }
 
-static inline void SaveDynamicLineSlopeThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveDynamicLineSlopeThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const dynlineplanethink_t* ht = (const void*)th;
 
-	WRITEUINT8(save_p, type);
-	WRITEUINT8(save_p, ht->type);
-	WRITEUINT32(save_p, SaveSlope(ht->slope));
-	WRITEUINT32(save_p, SaveLine(ht->sourceline));
-	WRITEFIXED(save_p, ht->extent);
+	WRITEUINT8(save->p, type);
+	WRITEUINT8(save->p, ht->type);
+	WRITEUINT32(save->p, SaveSlope(ht->slope));
+	WRITEUINT32(save->p, SaveLine(ht->sourceline));
+	WRITEFIXED(save->p, ht->extent);
 }
 
-static inline void SaveDynamicVertexSlopeThinker(const thinker_t *th, const UINT8 type)
+static inline void SaveDynamicVertexSlopeThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	size_t i;
 	const dynvertexplanethink_t* ht = (const void*)th;
 
-	WRITEUINT8(save_p, type);
-	WRITEUINT32(save_p, SaveSlope(ht->slope));
+	WRITEUINT8(save->p, type);
+	WRITEUINT32(save->p, SaveSlope(ht->slope));
 	for (i = 0; i < 3; i++)
-		WRITEUINT32(save_p, SaveSector(ht->secs[i]));
-	WRITEMEM(save_p, ht->vex, sizeof(ht->vex));
-	WRITEMEM(save_p, ht->origsecheights, sizeof(ht->origsecheights));
-	WRITEMEM(save_p, ht->origvecheights, sizeof(ht->origvecheights));
-	WRITEUINT8(save_p, ht->relative);
+		WRITEUINT32(save->p, SaveSector(ht->secs[i]));
+	WRITEMEM(save->p, ht->vex, sizeof(ht->vex));
+	WRITEMEM(save->p, ht->origsecheights, sizeof(ht->origsecheights));
+	WRITEMEM(save->p, ht->origvecheights, sizeof(ht->origvecheights));
+	WRITEUINT8(save->p, ht->relative);
 }
 
-static inline void SavePolyrotatetThinker(const thinker_t *th, const UINT8 type)
+static inline void SavePolyrotatetThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polyrotate_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEINT32(save_p, ht->speed);
-	WRITEINT32(save_p, ht->distance);
-	WRITEUINT8(save_p, ht->turnobjs);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEINT32(save->p, ht->speed);
+	WRITEINT32(save->p, ht->distance);
+	WRITEUINT8(save->p, ht->turnobjs);
 }
 
-static void SavePolymoveThinker(const thinker_t *th, const UINT8 type)
+static void SavePolymoveThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polymove_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEINT32(save_p, ht->speed);
-	WRITEFIXED(save_p, ht->momx);
-	WRITEFIXED(save_p, ht->momy);
-	WRITEINT32(save_p, ht->distance);
-	WRITEANGLE(save_p, ht->angle);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEINT32(save->p, ht->speed);
+	WRITEFIXED(save->p, ht->momx);
+	WRITEFIXED(save->p, ht->momy);
+	WRITEINT32(save->p, ht->distance);
+	WRITEANGLE(save->p, ht->angle);
 }
 
-static void SavePolywaypointThinker(const thinker_t *th, UINT8 type)
+static void SavePolywaypointThinker(savebuffer_t *save, const thinker_t *th, UINT8 type)
 {
 	const polywaypoint_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEINT32(save_p, ht->speed);
-	WRITEINT32(save_p, ht->sequence);
-	WRITEINT32(save_p, ht->pointnum);
-	WRITEINT32(save_p, ht->direction);
-	WRITEUINT8(save_p, ht->returnbehavior);
-	WRITEUINT8(save_p, ht->continuous);
-	WRITEUINT8(save_p, ht->stophere);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEINT32(save->p, ht->speed);
+	WRITEINT32(save->p, ht->sequence);
+	WRITEINT32(save->p, ht->pointnum);
+	WRITEINT32(save->p, ht->direction);
+	WRITEUINT8(save->p, ht->returnbehavior);
+	WRITEUINT8(save->p, ht->continuous);
+	WRITEUINT8(save->p, ht->stophere);
 }
 
-static void SavePolyslidedoorThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyslidedoorThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polyslidedoor_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEINT32(save_p, ht->delay);
-	WRITEINT32(save_p, ht->delayCount);
-	WRITEINT32(save_p, ht->initSpeed);
-	WRITEINT32(save_p, ht->speed);
-	WRITEINT32(save_p, ht->initDistance);
-	WRITEINT32(save_p, ht->distance);
-	WRITEUINT32(save_p, ht->initAngle);
-	WRITEUINT32(save_p, ht->angle);
-	WRITEUINT32(save_p, ht->revAngle);
-	WRITEFIXED(save_p, ht->momx);
-	WRITEFIXED(save_p, ht->momy);
-	WRITEUINT8(save_p, ht->closing);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEINT32(save->p, ht->delay);
+	WRITEINT32(save->p, ht->delayCount);
+	WRITEINT32(save->p, ht->initSpeed);
+	WRITEINT32(save->p, ht->speed);
+	WRITEINT32(save->p, ht->initDistance);
+	WRITEINT32(save->p, ht->distance);
+	WRITEUINT32(save->p, ht->initAngle);
+	WRITEUINT32(save->p, ht->angle);
+	WRITEUINT32(save->p, ht->revAngle);
+	WRITEFIXED(save->p, ht->momx);
+	WRITEFIXED(save->p, ht->momy);
+	WRITEUINT8(save->p, ht->closing);
 }
 
-static void SavePolyswingdoorThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyswingdoorThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polyswingdoor_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEINT32(save_p, ht->delay);
-	WRITEINT32(save_p, ht->delayCount);
-	WRITEINT32(save_p, ht->initSpeed);
-	WRITEINT32(save_p, ht->speed);
-	WRITEINT32(save_p, ht->initDistance);
-	WRITEINT32(save_p, ht->distance);
-	WRITEUINT8(save_p, ht->closing);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEINT32(save->p, ht->delay);
+	WRITEINT32(save->p, ht->delayCount);
+	WRITEINT32(save->p, ht->initSpeed);
+	WRITEINT32(save->p, ht->speed);
+	WRITEINT32(save->p, ht->initDistance);
+	WRITEINT32(save->p, ht->distance);
+	WRITEUINT8(save->p, ht->closing);
 }
 
-static void SavePolydisplaceThinker(const thinker_t *th, const UINT8 type)
+static void SavePolydisplaceThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polydisplace_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEUINT32(save_p, SaveSector(ht->controlSector));
-	WRITEFIXED(save_p, ht->dx);
-	WRITEFIXED(save_p, ht->dy);
-	WRITEFIXED(save_p, ht->oldHeights);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEUINT32(save->p, SaveSector(ht->controlSector));
+	WRITEFIXED(save->p, ht->dx);
+	WRITEFIXED(save->p, ht->dy);
+	WRITEFIXED(save->p, ht->oldHeights);
 }
 
-static void SavePolyrotdisplaceThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyrotdisplaceThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polyrotdisplace_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEUINT32(save_p, SaveSector(ht->controlSector));
-	WRITEFIXED(save_p, ht->rotscale);
-	WRITEUINT8(save_p, ht->turnobjs);
-	WRITEFIXED(save_p, ht->oldHeights);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEUINT32(save->p, SaveSector(ht->controlSector));
+	WRITEFIXED(save->p, ht->rotscale);
+	WRITEUINT8(save->p, ht->turnobjs);
+	WRITEFIXED(save->p, ht->oldHeights);
 }
 
-static void SavePolyfadeThinker(const thinker_t *th, const UINT8 type)
+static void SavePolyfadeThinker(savebuffer_t *save, const thinker_t *th, const UINT8 type)
 {
 	const polyfade_t *ht = (const void *)th;
-	WRITEUINT8(save_p, type);
-	WRITEINT32(save_p, ht->polyObjNum);
-	WRITEINT32(save_p, ht->sourcevalue);
-	WRITEINT32(save_p, ht->destvalue);
-	WRITEUINT8(save_p, (UINT8)ht->docollision);
-	WRITEUINT8(save_p, (UINT8)ht->doghostfade);
-	WRITEUINT8(save_p, (UINT8)ht->ticbased);
-	WRITEINT32(save_p, ht->duration);
-	WRITEINT32(save_p, ht->timer);
+	WRITEUINT8(save->p, type);
+	WRITEINT32(save->p, ht->polyObjNum);
+	WRITEINT32(save->p, ht->sourcevalue);
+	WRITEINT32(save->p, ht->destvalue);
+	WRITEUINT8(save->p, (UINT8)ht->docollision);
+	WRITEUINT8(save->p, (UINT8)ht->doghostfade);
+	WRITEUINT8(save->p, (UINT8)ht->ticbased);
+	WRITEINT32(save->p, ht->duration);
+	WRITEINT32(save->p, ht->timer);
 }
 
-static void P_NetArchiveThinkers(void)
+static void P_NetArchiveThinkers(savebuffer_t *save)
 {
 	const thinker_t *th;
 	UINT32 i;
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_THINKERS);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_THINKERS);
 
 	for (i = 0; i < NUM_THINKERLISTS; i++)
 	{
@@ -2819,7 +2818,7 @@ static void P_NetArchiveThinkers(void)
 
 			if (th->function.acp1 == (actionf_p1)P_MobjThinker)
 			{
-				SaveMobjThinker(th, tc_mobj);
+				SaveMobjThinker(save, th, tc_mobj);
 				continue;
 			}
 	#ifdef PARANOIA
@@ -2827,202 +2826,202 @@ static void P_NetArchiveThinkers(void)
 	#endif
 			else if (th->function.acp1 == (actionf_p1)T_MoveCeiling)
 			{
-				SaveCeilingThinker(th, tc_ceiling);
+				SaveCeilingThinker(save, th, tc_ceiling);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_CrushCeiling)
 			{
-				SaveCeilingThinker(th, tc_crushceiling);
+				SaveCeilingThinker(save, th, tc_crushceiling);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_MoveFloor)
 			{
-				SaveFloormoveThinker(th, tc_floor);
+				SaveFloormoveThinker(save, th, tc_floor);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_LightningFlash)
 			{
-				SaveLightflashThinker(th, tc_flash);
+				SaveLightflashThinker(save, th, tc_flash);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_StrobeFlash)
 			{
-				SaveStrobeThinker(th, tc_strobe);
+				SaveStrobeThinker(save, th, tc_strobe);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_Glow)
 			{
-				SaveGlowThinker(th, tc_glow);
+				SaveGlowThinker(save, th, tc_glow);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_FireFlicker)
 			{
-				SaveFireflickerThinker(th, tc_fireflicker);
+				SaveFireflickerThinker(save, th, tc_fireflicker);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_MoveElevator)
 			{
-				SaveElevatorThinker(th, tc_elevator);
+				SaveElevatorThinker(save, th, tc_elevator);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_ContinuousFalling)
 			{
-				SaveContinuousFallThinker(th, tc_continuousfalling);
+				SaveContinuousFallThinker(save, th, tc_continuousfalling);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_ThwompSector)
 			{
-				SaveThwompThinker(th, tc_thwomp);
+				SaveThwompThinker(save, th, tc_thwomp);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_NoEnemiesSector)
 			{
-				SaveNoEnemiesThinker(th, tc_noenemies);
+				SaveNoEnemiesThinker(save, th, tc_noenemies);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_EachTimeThinker)
 			{
-				SaveEachTimeThinker(th, tc_eachtime);
+				SaveEachTimeThinker(save, th, tc_eachtime);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_RaiseSector)
 			{
-				SaveRaiseThinker(th, tc_raisesector);
+				SaveRaiseThinker(save, th, tc_raisesector);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_CameraScanner)
 			{
-				SaveElevatorThinker(th, tc_camerascanner);
+				SaveElevatorThinker(save, th, tc_camerascanner);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_Scroll)
 			{
-				SaveScrollThinker(th, tc_scroll);
+				SaveScrollThinker(save, th, tc_scroll);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_Friction)
 			{
-				SaveFrictionThinker(th, tc_friction);
+				SaveFrictionThinker(save, th, tc_friction);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_Pusher)
 			{
-				SavePusherThinker(th, tc_pusher);
+				SavePusherThinker(save, th, tc_pusher);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_BounceCheese)
 			{
-				SaveBounceCheeseThinker(th, tc_bouncecheese);
+				SaveBounceCheeseThinker(save, th, tc_bouncecheese);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_StartCrumble)
 			{
-				SaveCrumbleThinker(th, tc_startcrumble);
+				SaveCrumbleThinker(save, th, tc_startcrumble);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_MarioBlock)
 			{
-				SaveMarioBlockThinker(th, tc_marioblock);
+				SaveMarioBlockThinker(save, th, tc_marioblock);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_MarioBlockChecker)
 			{
-				SaveMarioCheckThinker(th, tc_marioblockchecker);
+				SaveMarioCheckThinker(save, th, tc_marioblockchecker);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_FloatSector)
 			{
-				SaveFloatThinker(th, tc_floatsector);
+				SaveFloatThinker(save, th, tc_floatsector);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_LaserFlash)
 			{
-				SaveLaserThinker(th, tc_laserflash);
+				SaveLaserThinker(save, th, tc_laserflash);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_LightFade)
 			{
-				SaveLightlevelThinker(th, tc_lightfade);
+				SaveLightlevelThinker(save, th, tc_lightfade);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_ExecutorDelay)
 			{
-				SaveExecutorThinker(th, tc_executor);
+				SaveExecutorThinker(save, th, tc_executor);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_Disappear)
 			{
-				SaveDisappearThinker(th, tc_disappear);
+				SaveDisappearThinker(save, th, tc_disappear);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_Fade)
 			{
-				SaveFadeThinker(th, tc_fade);
+				SaveFadeThinker(save, th, tc_fade);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_FadeColormap)
 			{
-				SaveFadeColormapThinker(th, tc_fadecolormap);
+				SaveFadeColormapThinker(save, th, tc_fadecolormap);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PlaneDisplace)
 			{
-				SavePlaneDisplaceThinker(th, tc_planedisplace);
+				SavePlaneDisplaceThinker(save, th, tc_planedisplace);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjRotate)
 			{
-				SavePolyrotatetThinker(th, tc_polyrotate);
+				SavePolyrotatetThinker(save, th, tc_polyrotate);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjMove)
 			{
-				SavePolymoveThinker(th, tc_polymove);
+				SavePolymoveThinker(save, th, tc_polymove);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjWaypoint)
 			{
-				SavePolywaypointThinker(th, tc_polywaypoint);
+				SavePolywaypointThinker(save, th, tc_polywaypoint);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyDoorSlide)
 			{
-				SavePolyslidedoorThinker(th, tc_polyslidedoor);
+				SavePolyslidedoorThinker(save, th, tc_polyslidedoor);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyDoorSwing)
 			{
-				SavePolyswingdoorThinker(th, tc_polyswingdoor);
+				SavePolyswingdoorThinker(save, th, tc_polyswingdoor);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjFlag)
 			{
-				SavePolymoveThinker(th, tc_polyflag);
+				SavePolymoveThinker(save, th, tc_polyflag);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjDisplace)
 			{
-				SavePolydisplaceThinker(th, tc_polydisplace);
+				SavePolydisplaceThinker(save, th, tc_polydisplace);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjRotDisplace)
 			{
-				SavePolyrotdisplaceThinker(th, tc_polyrotdisplace);
+				SavePolyrotdisplaceThinker(save, th, tc_polyrotdisplace);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_PolyObjFade)
 			{
-				SavePolyfadeThinker(th, tc_polyfade);
+				SavePolyfadeThinker(save, th, tc_polyfade);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_DynamicSlopeLine)
 			{
-				SaveDynamicLineSlopeThinker(th, tc_dynslopeline);
+				SaveDynamicLineSlopeThinker(save, th, tc_dynslopeline);
 				continue;
 			}
 			else if (th->function.acp1 == (actionf_p1)T_DynamicSlopeVert)
 			{
-				SaveDynamicVertexSlopeThinker(th, tc_dynslopevert);
+				SaveDynamicVertexSlopeThinker(save, th, tc_dynslopevert);
 				continue;
 			}
 #ifdef PARANOIA
@@ -3033,34 +3032,34 @@ static void P_NetArchiveThinkers(void)
 
 		CONS_Debug(DBG_NETPLAY, "%u thinkers saved in list %d\n", numsaved, i);
 
-		WRITEUINT8(save_p, tc_end);
+		WRITEUINT8(save->p, tc_end);
 	}
 }
 
-static void P_NetArchiveWaypoints(void)
+static void P_NetArchiveWaypoints(savebuffer_t *save)
 {
 	waypoint_t *waypoint;
 	size_t i;
 	size_t numWaypoints = K_GetNumWaypoints();
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_WAYPOINTS);
-	WRITEUINT32(save_p, numWaypoints);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_WAYPOINTS);
+	WRITEUINT32(save->p, numWaypoints);
 
 	for (i = 0U; i < numWaypoints; i++) {
 		waypoint = K_GetWaypointFromIndex(i);
 
 		// The only thing we save for each waypoint is the mobj.
 		// Waypoints should NEVER be completely created or destroyed mid-race as a result of this
-		WRITEUINT32(save_p, waypoint->mobj->mobjnum);
+		WRITEUINT32(save->p, waypoint->mobj->mobjnum);
 	}
 }
 
-static void P_NetUnArchiveWaypoints(void)
+static void P_NetUnArchiveWaypoints(savebuffer_t *save)
 {
-	if (READUINT32(save_p) != ARCHIVEBLOCK_WAYPOINTS)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_WAYPOINTS)
 		I_Error("Bad $$$.sav at archive block Waypoints!");
 	else {
-		UINT32 numArchiveWaypoints = READUINT32(save_p);
+		UINT32 numArchiveWaypoints = READUINT32(save->p);
 		size_t numSpawnedWaypoints = K_GetNumWaypoints();
 
 		if (numArchiveWaypoints != numSpawnedWaypoints) {
@@ -3071,7 +3070,7 @@ static void P_NetUnArchiveWaypoints(void)
 			UINT32 temp;
 			for (i = 0U; i < numArchiveWaypoints; i++) {
 				waypoint = K_GetWaypointFromIndex(i);
-				temp = READUINT32(save_p);
+				temp = READUINT32(save->p);
 				if (!P_SetTarget(&waypoint->mobj, P_FindNewPosition(temp))) {
 					CONS_Debug(DBG_GAMELOGIC, "waypoint mobj not found for %d\n", i);
 				}
@@ -3140,7 +3139,7 @@ static inline pslope_t *LoadSlope(UINT32 slopeid)
 	return NULL;
 }
 
-static thinker_t* LoadMobjThinker(actionf_p1 thinker)
+static thinker_t* LoadMobjThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	thinker_t *next;
 	mobj_t *mobj;
@@ -3150,35 +3149,35 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	fixed_t z, floorz, ceilingz;
 	ffloor_t *floorrover = NULL, *ceilingrover = NULL;
 
-	diff = READUINT32(save_p);
+	diff = READUINT32(save->p);
 	if (diff & MD_MORE)
-		diff2 = READUINT32(save_p);
+		diff2 = READUINT32(save->p);
 	else
 		diff2 = 0;
 
-	next = (void *)(size_t)READUINT32(save_p);
+	next = (void *)(size_t)READUINT32(save->p);
 
-	z = READFIXED(save_p); // Force this so 3dfloor problems don't arise.
-	floorz = READFIXED(save_p);
-	ceilingz = READFIXED(save_p);
+	z = READFIXED(save->p); // Force this so 3dfloor problems don't arise.
+	floorz = READFIXED(save->p);
+	ceilingz = READFIXED(save->p);
 
 	if (diff2 & MD2_FLOORROVER)
 	{
-		sector_t *sec = LoadSector(READUINT32(save_p));
-		UINT16 id = READUINT16(save_p);
+		sector_t *sec = LoadSector(READUINT32(save->p));
+		UINT16 id = READUINT16(save->p);
 		floorrover = P_GetFFloorByID(sec, id);
 	}
 
 	if (diff2 & MD2_CEILINGROVER)
 	{
-		sector_t *sec = LoadSector(READUINT32(save_p));
-		UINT16 id = READUINT16(save_p);
+		sector_t *sec = LoadSector(READUINT32(save->p));
+		UINT16 id = READUINT16(save->p);
 		ceilingrover = P_GetFFloorByID(sec, id);
 	}
 
 	if (diff & MD_SPAWNPOINT)
 	{
-		UINT16 spawnpointnum = READUINT16(save_p);
+		UINT16 spawnpointnum = READUINT16(save->p);
 
 		if (mapthings[spawnpointnum].type == 1713) // NiGHTS Hoop special case
 		{
@@ -3204,7 +3203,7 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	mobj->ceilingrover = ceilingrover;
 
 	if (diff & MD_TYPE)
-		mobj->type = READUINT32(save_p);
+		mobj->type = READUINT32(save->p);
 	else
 	{
 		for (i = 0; i < NUMMOBJTYPES; i++)
@@ -3223,11 +3222,11 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	mobj->info = &mobjinfo[mobj->type];
 	if (diff & MD_POS)
 	{
-		mobj->x = mobj->old_x = READFIXED(save_p);
-		mobj->y = mobj->old_y = READFIXED(save_p);
-		mobj->angle = mobj->old_angle = READANGLE(save_p);
-		mobj->pitch = mobj->old_pitch = READANGLE(save_p);
-		mobj->roll = mobj->old_roll = READANGLE(save_p);
+		mobj->x = mobj->old_x = READFIXED(save->p);
+		mobj->y = mobj->old_y = READFIXED(save->p);
+		mobj->angle = mobj->old_angle = READANGLE(save->p);
+		mobj->pitch = mobj->old_pitch = READANGLE(save->p);
+		mobj->roll = mobj->old_roll = READANGLE(save->p);
 	}
 	else
 	{
@@ -3239,47 +3238,47 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	}
 	if (diff & MD_MOM)
 	{
-		mobj->momx = READFIXED(save_p);
-		mobj->momy = READFIXED(save_p);
-		mobj->momz = READFIXED(save_p);
-		mobj->pmomz = READFIXED(save_p);
+		mobj->momx = READFIXED(save->p);
+		mobj->momy = READFIXED(save->p);
+		mobj->momz = READFIXED(save->p);
+		mobj->pmomz = READFIXED(save->p);
 	} // otherwise they're zero, and the memset took care of it
 
 	if (diff & MD_RADIUS)
-		mobj->radius = READFIXED(save_p);
+		mobj->radius = READFIXED(save->p);
 	else
 		mobj->radius = mobj->info->radius;
 	if (diff & MD_HEIGHT)
-		mobj->height = READFIXED(save_p);
+		mobj->height = READFIXED(save->p);
 	else
 		mobj->height = mobj->info->height;
 	if (diff & MD_FLAGS)
-		mobj->flags = READUINT32(save_p);
+		mobj->flags = READUINT32(save->p);
 	else
 		mobj->flags = mobj->info->flags;
 	if (diff & MD_FLAGS2)
-		mobj->flags2 = READUINT32(save_p);
+		mobj->flags2 = READUINT32(save->p);
 	if (diff & MD_HEALTH)
-		mobj->health = READINT32(save_p);
+		mobj->health = READINT32(save->p);
 	else
 		mobj->health = mobj->info->spawnhealth;
 	if (diff & MD_RTIME)
-		mobj->reactiontime = READINT32(save_p);
+		mobj->reactiontime = READINT32(save->p);
 	else
 		mobj->reactiontime = mobj->info->reactiontime;
 
 	if (diff & MD_STATE)
-		mobj->state = &states[READUINT16(save_p)];
+		mobj->state = &states[READUINT16(save->p)];
 	else
 		mobj->state = &states[mobj->info->spawnstate];
 	if (diff & MD_TICS)
-		mobj->tics = READINT32(save_p);
+		mobj->tics = READINT32(save->p);
 	else
 		mobj->tics = mobj->state->tics;
 	if (diff & MD_SPRITE) {
-		mobj->sprite = READUINT16(save_p);
+		mobj->sprite = READUINT16(save->p);
 		if (mobj->sprite == SPR_PLAY)
-			mobj->sprite2 = READUINT8(save_p);
+			mobj->sprite2 = READUINT8(save->p);
 	}
 	else {
 		mobj->sprite = mobj->state->sprite;
@@ -3288,8 +3287,8 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	}
 	if (diff & MD_FRAME)
 	{
-		mobj->frame = READUINT32(save_p);
-		mobj->anim_duration = READUINT16(save_p);
+		mobj->frame = READUINT32(save->p);
+		mobj->anim_duration = READUINT16(save->p);
 	}
 	else
 	{
@@ -3297,139 +3296,139 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 		mobj->anim_duration = (UINT16)mobj->state->var2;
 	}
 	if (diff & MD_EFLAGS)
-		mobj->eflags = READUINT16(save_p);
+		mobj->eflags = READUINT16(save->p);
 	if (diff & MD_PLAYER)
 	{
-		i = READUINT8(save_p);
+		i = READUINT8(save->p);
 		mobj->player = &players[i];
 		mobj->player->mo = mobj;
 	}
 	if (diff & MD_MOVEDIR)
-		mobj->movedir = READANGLE(save_p);
+		mobj->movedir = READANGLE(save->p);
 	if (diff & MD_MOVECOUNT)
-		mobj->movecount = READINT32(save_p);
+		mobj->movecount = READINT32(save->p);
 	if (diff & MD_THRESHOLD)
-		mobj->threshold = READINT32(save_p);
+		mobj->threshold = READINT32(save->p);
 	if (diff & MD_LASTLOOK)
-		mobj->lastlook = READINT32(save_p);
+		mobj->lastlook = READINT32(save->p);
 	else
 		mobj->lastlook = -1;
 	if (diff & MD_TARGET)
-		mobj->target = (mobj_t *)(size_t)READUINT32(save_p);
+		mobj->target = (mobj_t *)(size_t)READUINT32(save->p);
 	if (diff & MD_TRACER)
-		mobj->tracer = (mobj_t *)(size_t)READUINT32(save_p);
+		mobj->tracer = (mobj_t *)(size_t)READUINT32(save->p);
 	if (diff & MD_FRICTION)
-		mobj->friction = READFIXED(save_p);
+		mobj->friction = READFIXED(save->p);
 	else
 		mobj->friction = ORIG_FRICTION;
 	if (diff & MD_MOVEFACTOR)
-		mobj->movefactor = READFIXED(save_p);
+		mobj->movefactor = READFIXED(save->p);
 	else
 		mobj->movefactor = FRACUNIT;
 	if (diff & MD_FUSE)
-		mobj->fuse = READINT32(save_p);
+		mobj->fuse = READINT32(save->p);
 	if (diff & MD_WATERTOP)
-		mobj->watertop = READFIXED(save_p);
+		mobj->watertop = READFIXED(save->p);
 	if (diff & MD_WATERBOTTOM)
-		mobj->waterbottom = READFIXED(save_p);
+		mobj->waterbottom = READFIXED(save->p);
 	if (diff & MD_SCALE)
-		mobj->scale = READFIXED(save_p);
+		mobj->scale = READFIXED(save->p);
 	else
 		mobj->scale = FRACUNIT;
 	if (diff & MD_DSCALE)
-		mobj->destscale = READFIXED(save_p);
+		mobj->destscale = READFIXED(save->p);
 	else
 		mobj->destscale = mobj->scale;
 	if (diff2 & MD2_SCALESPEED)
-		mobj->scalespeed = READFIXED(save_p);
+		mobj->scalespeed = READFIXED(save->p);
 	else
 		mobj->scalespeed = mapobjectscale/12;
 	if (diff2 & MD2_CUSVAL)
-		mobj->cusval = READINT32(save_p);
+		mobj->cusval = READINT32(save->p);
 	if (diff2 & MD2_CVMEM)
-		mobj->cvmem = READINT32(save_p);
+		mobj->cvmem = READINT32(save->p);
 	if (diff2 & MD2_SKIN)
-		mobj->skin = &skins[READUINT8(save_p)];
+		mobj->skin = &skins[READUINT8(save->p)];
 	if (diff2 & MD2_COLOR)
-		mobj->color = READUINT16(save_p);
+		mobj->color = READUINT16(save->p);
 	if (diff2 & MD2_EXTVAL1)
-		mobj->extravalue1 = READINT32(save_p);
+		mobj->extravalue1 = READINT32(save->p);
 	if (diff2 & MD2_EXTVAL2)
-		mobj->extravalue2 = READINT32(save_p);
+		mobj->extravalue2 = READINT32(save->p);
 	if (diff2 & MD2_HNEXT)
-		mobj->hnext = (mobj_t *)(size_t)READUINT32(save_p);
+		mobj->hnext = (mobj_t *)(size_t)READUINT32(save->p);
 	if (diff2 & MD2_HPREV)
-		mobj->hprev = (mobj_t *)(size_t)READUINT32(save_p);
+		mobj->hprev = (mobj_t *)(size_t)READUINT32(save->p);
 	if (diff2 & MD2_ITNEXT)
-		mobj->itnext = (mobj_t *)(size_t)READUINT32(save_p);
+		mobj->itnext = (mobj_t *)(size_t)READUINT32(save->p);
 	if (diff2 & MD2_SLOPE)
-		mobj->standingslope = P_SlopeById(READUINT16(save_p));
+		mobj->standingslope = P_SlopeById(READUINT16(save->p));
 	if (diff2 & MD2_COLORIZED)
-		mobj->colorized = READUINT8(save_p);
+		mobj->colorized = READUINT8(save->p);
 	if (diff2 & MD2_MIRRORED)
-		mobj->mirrored = READUINT8(save_p);
+		mobj->mirrored = READUINT8(save->p);
 	if (diff2 & MD2_ROLLANGLE)
-		mobj->rollangle = READANGLE(save_p);
+		mobj->rollangle = READANGLE(save->p);
 	if (diff2 & MD2_SHADOWSCALE)
 	{
-		mobj->shadowscale = READFIXED(save_p);
-		mobj->whiteshadow = READUINT8(save_p);
+		mobj->shadowscale = READFIXED(save->p);
+		mobj->whiteshadow = READUINT8(save->p);
 	}
 	if (diff2 & MD2_RENDERFLAGS)
-		mobj->renderflags = READUINT32(save_p);
+		mobj->renderflags = READUINT32(save->p);
 	if (diff2 & MD2_SPRITEXSCALE)
-		mobj->spritexscale = READFIXED(save_p);
+		mobj->spritexscale = READFIXED(save->p);
 	else
 		mobj->spritexscale = FRACUNIT;
 	if (diff2 & MD2_SPRITEYSCALE)
-		mobj->spriteyscale = READFIXED(save_p);
+		mobj->spriteyscale = READFIXED(save->p);
 	else
 		mobj->spriteyscale = FRACUNIT;
 	if (diff2 & MD2_SPRITEXOFFSET)
-		mobj->spritexoffset = READFIXED(save_p);
+		mobj->spritexoffset = READFIXED(save->p);
 	if (diff2 & MD2_SPRITEYOFFSET)
-		mobj->spriteyoffset = READFIXED(save_p);
+		mobj->spriteyoffset = READFIXED(save->p);
 	if (diff2 & MD2_FLOORSPRITESLOPE)
 	{
 		pslope_t *slope = (pslope_t *)P_CreateFloorSpriteSlope(mobj);
 
-		slope->zdelta = READFIXED(save_p);
-		slope->zangle = READANGLE(save_p);
-		slope->xydirection = READANGLE(save_p);
+		slope->zdelta = READFIXED(save->p);
+		slope->zangle = READANGLE(save->p);
+		slope->xydirection = READANGLE(save->p);
 
-		slope->o.x = READFIXED(save_p);
-		slope->o.y = READFIXED(save_p);
-		slope->o.z = READFIXED(save_p);
+		slope->o.x = READFIXED(save->p);
+		slope->o.y = READFIXED(save->p);
+		slope->o.z = READFIXED(save->p);
 
-		slope->d.x = READFIXED(save_p);
-		slope->d.y = READFIXED(save_p);
+		slope->d.x = READFIXED(save->p);
+		slope->d.y = READFIXED(save->p);
 
-		slope->normal.x = READFIXED(save_p);
-		slope->normal.y = READFIXED(save_p);
-		slope->normal.z = READFIXED(save_p);
+		slope->normal.x = READFIXED(save->p);
+		slope->normal.y = READFIXED(save->p);
+		slope->normal.z = READFIXED(save->p);
 
 		P_UpdateSlopeLightOffset(slope);
 	}
 	if (diff2 & MD2_HITLAG)
 	{
-		mobj->hitlag = READINT32(save_p);
+		mobj->hitlag = READINT32(save->p);
 	}
 	if (diff2 & MD2_WATERSKIP)
 	{
-		mobj->waterskip = READUINT8(save_p);
+		mobj->waterskip = READUINT8(save->p);
 	}
 	if (diff2 & MD2_DISPOFFSET)
 	{
-		mobj->dispoffset = READINT32(save_p);
+		mobj->dispoffset = READINT32(save->p);
 	}
 	if (diff2 & MD2_LASTMOMZ)
 	{
-		mobj->lastmomz = READINT32(save_p);
+		mobj->lastmomz = READINT32(save->p);
 	}
 	if (diff2 & MD2_TERRAIN)
 	{
-		mobj->terrain = (terrain_t *)(size_t)READUINT32(save_p);
-		mobj->terrainOverlay = (mobj_t *)(size_t)READUINT32(save_p);
+		mobj->terrain = (terrain_t *)(size_t)READUINT32(save->p);
+		mobj->terrainOverlay = (mobj_t *)(size_t)READUINT32(save->p);
 	}
 	else
 	{
@@ -3450,7 +3449,7 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	// set sprev, snext, bprev, bnext, subsector
 	P_SetThingPosition(mobj);
 
-	mobj->mobjnum = READUINT32(save_p);
+	mobj->mobjnum = READUINT32(save->p);
 
 	if (mobj->player)
 	{
@@ -3486,25 +3485,25 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 	return &mobj->thinker;
 }
 
-static thinker_t* LoadNoEnemiesThinker(actionf_p1 thinker)
+static thinker_t* LoadNoEnemiesThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	noenemies_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
+	ht->sourceline = LoadLine(READUINT32(save->p));
 	return &ht->thinker;
 }
 
-static thinker_t* LoadBounceCheeseThinker(actionf_p1 thinker)
+static thinker_t* LoadBounceCheeseThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	bouncecheese_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->speed = READFIXED(save_p);
-	ht->distance = READFIXED(save_p);
-	ht->floorwasheight = READFIXED(save_p);
-	ht->ceilingwasheight = READFIXED(save_p);
-	ht->low = READCHAR(save_p);
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->speed = READFIXED(save->p);
+	ht->distance = READFIXED(save->p);
+	ht->floorwasheight = READFIXED(save->p);
+	ht->ceilingwasheight = READFIXED(save->p);
+	ht->low = READCHAR(save->p);
 
 	if (ht->sector)
 		ht->sector->ceilingdata = ht;
@@ -3512,16 +3511,16 @@ static thinker_t* LoadBounceCheeseThinker(actionf_p1 thinker)
 	return &ht->thinker;
 }
 
-static thinker_t* LoadContinuousFallThinker(actionf_p1 thinker)
+static thinker_t* LoadContinuousFallThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	continuousfall_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->speed = READFIXED(save_p);
-	ht->direction = READINT32(save_p);
-	ht->floorstartheight = READFIXED(save_p);
-	ht->ceilingstartheight = READFIXED(save_p);
-	ht->destheight = READFIXED(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->speed = READFIXED(save->p);
+	ht->direction = READINT32(save->p);
+	ht->floorstartheight = READFIXED(save->p);
+	ht->ceilingstartheight = READFIXED(save->p);
+	ht->destheight = READFIXED(save->p);
 
 	if (ht->sector)
 	{
@@ -3532,16 +3531,16 @@ static thinker_t* LoadContinuousFallThinker(actionf_p1 thinker)
 	return &ht->thinker;
 }
 
-static thinker_t* LoadMarioBlockThinker(actionf_p1 thinker)
+static thinker_t* LoadMarioBlockThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	mariothink_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->speed = READFIXED(save_p);
-	ht->direction = READINT32(save_p);
-	ht->floorstartheight = READFIXED(save_p);
-	ht->ceilingstartheight = READFIXED(save_p);
-	ht->tag = READINT16(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->speed = READFIXED(save->p);
+	ht->direction = READINT32(save->p);
+	ht->floorstartheight = READFIXED(save->p);
+	ht->ceilingstartheight = READFIXED(save->p);
+	ht->tag = READINT16(save->p);
 
 	if (ht->sector)
 	{
@@ -3552,29 +3551,29 @@ static thinker_t* LoadMarioBlockThinker(actionf_p1 thinker)
 	return &ht->thinker;
 }
 
-static thinker_t* LoadMarioCheckThinker(actionf_p1 thinker)
+static thinker_t* LoadMarioCheckThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	mariocheck_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->sector = LoadSector(READUINT32(save_p));
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->sector = LoadSector(READUINT32(save->p));
 	return &ht->thinker;
 }
 
-static thinker_t* LoadThwompThinker(actionf_p1 thinker)
+static thinker_t* LoadThwompThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	thwomp_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->crushspeed = READFIXED(save_p);
-	ht->retractspeed = READFIXED(save_p);
-	ht->direction = READINT32(save_p);
-	ht->floorstartheight = READFIXED(save_p);
-	ht->ceilingstartheight = READFIXED(save_p);
-	ht->delay = READINT32(save_p);
-	ht->tag = READINT16(save_p);
-	ht->sound = READUINT16(save_p);
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->crushspeed = READFIXED(save->p);
+	ht->retractspeed = READFIXED(save->p);
+	ht->direction = READINT32(save->p);
+	ht->floorstartheight = READFIXED(save->p);
+	ht->ceilingstartheight = READFIXED(save->p);
+	ht->delay = READINT32(save->p);
+	ht->tag = READINT16(save->p);
+	ht->sound = READUINT16(save->p);
 
 	if (ht->sector)
 	{
@@ -3585,163 +3584,163 @@ static thinker_t* LoadThwompThinker(actionf_p1 thinker)
 	return &ht->thinker;
 }
 
-static thinker_t* LoadFloatThinker(actionf_p1 thinker)
+static thinker_t* LoadFloatThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	floatthink_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->tag = READINT16(save_p);
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->tag = READINT16(save->p);
 	return &ht->thinker;
 }
 
-static thinker_t* LoadEachTimeThinker(actionf_p1 thinker)
+static thinker_t* LoadEachTimeThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	size_t i;
 	eachtime_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
+	ht->sourceline = LoadLine(READUINT32(save->p));
 	for (i = 0; i < MAXPLAYERS; i++)
 	{
-		ht->playersInArea[i] = READCHAR(save_p);
+		ht->playersInArea[i] = READCHAR(save->p);
 	}
-	ht->triggerOnExit = READCHAR(save_p);
+	ht->triggerOnExit = READCHAR(save->p);
 	return &ht->thinker;
 }
 
-static thinker_t* LoadRaiseThinker(actionf_p1 thinker)
+static thinker_t* LoadRaiseThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	raise_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->tag = READINT16(save_p);
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->ceilingbottom = READFIXED(save_p);
-	ht->ceilingtop = READFIXED(save_p);
-	ht->basespeed = READFIXED(save_p);
-	ht->extraspeed = READFIXED(save_p);
-	ht->shaketimer = READUINT8(save_p);
-	ht->flags = READUINT8(save_p);
+	ht->tag = READINT16(save->p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->ceilingbottom = READFIXED(save->p);
+	ht->ceilingtop = READFIXED(save->p);
+	ht->basespeed = READFIXED(save->p);
+	ht->extraspeed = READFIXED(save->p);
+	ht->shaketimer = READUINT8(save->p);
+	ht->flags = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static thinker_t* LoadCeilingThinker(actionf_p1 thinker)
+static thinker_t* LoadCeilingThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	ceiling_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->type = READUINT8(save_p);
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->bottomheight = READFIXED(save_p);
-	ht->topheight = READFIXED(save_p);
-	ht->speed = READFIXED(save_p);
-	ht->delay = READFIXED(save_p);
-	ht->delaytimer = READFIXED(save_p);
-	ht->crush = READUINT8(save_p);
-	ht->texture = READINT32(save_p);
-	ht->direction = READINT32(save_p);
-	ht->tag = READINT16(save_p);
-	ht->origspeed = READFIXED(save_p);
-	ht->sourceline = READFIXED(save_p);
+	ht->type = READUINT8(save->p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->bottomheight = READFIXED(save->p);
+	ht->topheight = READFIXED(save->p);
+	ht->speed = READFIXED(save->p);
+	ht->delay = READFIXED(save->p);
+	ht->delaytimer = READFIXED(save->p);
+	ht->crush = READUINT8(save->p);
+	ht->texture = READINT32(save->p);
+	ht->direction = READINT32(save->p);
+	ht->tag = READINT16(save->p);
+	ht->origspeed = READFIXED(save->p);
+	ht->sourceline = READFIXED(save->p);
 	if (ht->sector)
 		ht->sector->ceilingdata = ht;
 	return &ht->thinker;
 }
 
-static thinker_t* LoadFloormoveThinker(actionf_p1 thinker)
+static thinker_t* LoadFloormoveThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	floormove_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->type = READUINT8(save_p);
-	ht->crush = READUINT8(save_p);
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->direction = READINT32(save_p);
-	ht->texture = READINT32(save_p);
-	ht->floordestheight = READFIXED(save_p);
-	ht->speed = READFIXED(save_p);
-	ht->origspeed = READFIXED(save_p);
-	ht->delay = READFIXED(save_p);
-	ht->delaytimer = READFIXED(save_p);
-	ht->tag = READINT16(save_p);
-	ht->sourceline = READFIXED(save_p);
+	ht->type = READUINT8(save->p);
+	ht->crush = READUINT8(save->p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->direction = READINT32(save->p);
+	ht->texture = READINT32(save->p);
+	ht->floordestheight = READFIXED(save->p);
+	ht->speed = READFIXED(save->p);
+	ht->origspeed = READFIXED(save->p);
+	ht->delay = READFIXED(save->p);
+	ht->delaytimer = READFIXED(save->p);
+	ht->tag = READINT16(save->p);
+	ht->sourceline = READFIXED(save->p);
 	if (ht->sector)
 		ht->sector->floordata = ht;
 	return &ht->thinker;
 }
 
-static thinker_t* LoadLightflashThinker(actionf_p1 thinker)
+static thinker_t* LoadLightflashThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	lightflash_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->maxlight = READINT32(save_p);
-	ht->minlight = READINT32(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->maxlight = READINT32(save->p);
+	ht->minlight = READINT32(save->p);
 	if (ht->sector)
 		ht->sector->lightingdata = ht;
 	return &ht->thinker;
 }
 
-static thinker_t* LoadStrobeThinker(actionf_p1 thinker)
+static thinker_t* LoadStrobeThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	strobe_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->count = READINT32(save_p);
-	ht->minlight = READINT16(save_p);
-	ht->maxlight = READINT16(save_p);
-	ht->darktime = READINT32(save_p);
-	ht->brighttime = READINT32(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->count = READINT32(save->p);
+	ht->minlight = READINT16(save->p);
+	ht->maxlight = READINT16(save->p);
+	ht->darktime = READINT32(save->p);
+	ht->brighttime = READINT32(save->p);
 	if (ht->sector)
 		ht->sector->lightingdata = ht;
 	return &ht->thinker;
 }
 
-static thinker_t* LoadGlowThinker(actionf_p1 thinker)
+static thinker_t* LoadGlowThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	glow_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->minlight = READINT16(save_p);
-	ht->maxlight = READINT16(save_p);
-	ht->direction = READINT16(save_p);
-	ht->speed = READINT16(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->minlight = READINT16(save->p);
+	ht->maxlight = READINT16(save->p);
+	ht->direction = READINT16(save->p);
+	ht->speed = READINT16(save->p);
 	if (ht->sector)
 		ht->sector->lightingdata = ht;
 	return &ht->thinker;
 }
 
-static thinker_t* LoadFireflickerThinker(actionf_p1 thinker)
+static thinker_t* LoadFireflickerThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	fireflicker_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->count = READINT32(save_p);
-	ht->resetcount = READINT32(save_p);
-	ht->maxlight = READINT16(save_p);
-	ht->minlight = READINT16(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->count = READINT32(save->p);
+	ht->resetcount = READINT32(save->p);
+	ht->maxlight = READINT16(save->p);
+	ht->minlight = READINT16(save->p);
 	if (ht->sector)
 		ht->sector->lightingdata = ht;
 	return &ht->thinker;
 }
 
-static thinker_t* LoadElevatorThinker(actionf_p1 thinker, boolean setplanedata)
+static thinker_t* LoadElevatorThinker(savebuffer_t *save, actionf_p1 thinker, boolean setplanedata)
 {
 	elevator_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->type = READUINT8(save_p);
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->actionsector = LoadSector(READUINT32(save_p));
-	ht->direction = READINT32(save_p);
-	ht->floordestheight = READFIXED(save_p);
-	ht->ceilingdestheight = READFIXED(save_p);
-	ht->speed = READFIXED(save_p);
-	ht->origspeed = READFIXED(save_p);
-	ht->low = READFIXED(save_p);
-	ht->high = READFIXED(save_p);
-	ht->distance = READFIXED(save_p);
-	ht->delay = READFIXED(save_p);
-	ht->delaytimer = READFIXED(save_p);
-	ht->floorwasheight = READFIXED(save_p);
-	ht->ceilingwasheight = READFIXED(save_p);
-	ht->sourceline = LoadLine(READUINT32(save_p));
+	ht->type = READUINT8(save->p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->actionsector = LoadSector(READUINT32(save->p));
+	ht->direction = READINT32(save->p);
+	ht->floordestheight = READFIXED(save->p);
+	ht->ceilingdestheight = READFIXED(save->p);
+	ht->speed = READFIXED(save->p);
+	ht->origspeed = READFIXED(save->p);
+	ht->low = READFIXED(save->p);
+	ht->high = READFIXED(save->p);
+	ht->distance = READFIXED(save->p);
+	ht->delay = READFIXED(save->p);
+	ht->delaytimer = READFIXED(save->p);
+	ht->floorwasheight = READFIXED(save->p);
+	ht->ceilingwasheight = READFIXED(save->p);
+	ht->sourceline = LoadLine(READUINT32(save->p));
 
 	if (ht->sector && setplanedata)
 	{
@@ -3752,21 +3751,21 @@ static thinker_t* LoadElevatorThinker(actionf_p1 thinker, boolean setplanedata)
 	return &ht->thinker;
 }
 
-static thinker_t* LoadCrumbleThinker(actionf_p1 thinker)
+static thinker_t* LoadCrumbleThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	crumble_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->actionsector = LoadSector(READUINT32(save_p));
-	ht->player = LoadPlayer(READUINT32(save_p));
-	ht->direction = READINT32(save_p);
-	ht->origalpha = READINT32(save_p);
-	ht->timer = READINT32(save_p);
-	ht->speed = READFIXED(save_p);
-	ht->floorwasheight = READFIXED(save_p);
-	ht->ceilingwasheight = READFIXED(save_p);
-	ht->flags = READUINT8(save_p);
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->actionsector = LoadSector(READUINT32(save->p));
+	ht->player = LoadPlayer(READUINT32(save->p));
+	ht->direction = READINT32(save->p);
+	ht->origalpha = READINT32(save->p);
+	ht->timer = READINT32(save->p);
+	ht->speed = READFIXED(save->p);
+	ht->floorwasheight = READFIXED(save->p);
+	ht->ceilingwasheight = READFIXED(save->p);
+	ht->flags = READUINT8(save->p);
 
 	if (ht->sector)
 		ht->sector->floordata = ht;
@@ -3774,123 +3773,123 @@ static thinker_t* LoadCrumbleThinker(actionf_p1 thinker)
 	return &ht->thinker;
 }
 
-static thinker_t* LoadScrollThinker(actionf_p1 thinker)
+static thinker_t* LoadScrollThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	scroll_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->dx = READFIXED(save_p);
-	ht->dy = READFIXED(save_p);
-	ht->affectee = READINT32(save_p);
-	ht->control = READINT32(save_p);
-	ht->last_height = READFIXED(save_p);
-	ht->vdx = READFIXED(save_p);
-	ht->vdy = READFIXED(save_p);
-	ht->accel = READINT32(save_p);
-	ht->exclusive = READINT32(save_p);
-	ht->type = READUINT8(save_p);
+	ht->dx = READFIXED(save->p);
+	ht->dy = READFIXED(save->p);
+	ht->affectee = READINT32(save->p);
+	ht->control = READINT32(save->p);
+	ht->last_height = READFIXED(save->p);
+	ht->vdx = READFIXED(save->p);
+	ht->vdy = READFIXED(save->p);
+	ht->accel = READINT32(save->p);
+	ht->exclusive = READINT32(save->p);
+	ht->type = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadFrictionThinker(actionf_p1 thinker)
+static inline thinker_t* LoadFrictionThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	friction_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->friction = READINT32(save_p);
-	ht->movefactor = READINT32(save_p);
-	ht->affectee = READINT32(save_p);
-	ht->referrer = READINT32(save_p);
-	ht->roverfriction = READUINT8(save_p);
+	ht->friction = READINT32(save->p);
+	ht->movefactor = READINT32(save->p);
+	ht->affectee = READINT32(save->p);
+	ht->referrer = READINT32(save->p);
+	ht->roverfriction = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static thinker_t* LoadPusherThinker(actionf_p1 thinker)
+static thinker_t* LoadPusherThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	pusher_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->type = READUINT8(save_p);
-	ht->x_mag = READFIXED(save_p);
-	ht->y_mag = READFIXED(save_p);
-	ht->z_mag = READFIXED(save_p);
-	ht->affectee = READINT32(save_p);
-	ht->roverpusher = READUINT8(save_p);
-	ht->referrer = READINT32(save_p);
-	ht->exclusive = READINT32(save_p);
-	ht->slider = READINT32(save_p);
+	ht->type = READUINT8(save->p);
+	ht->x_mag = READFIXED(save->p);
+	ht->y_mag = READFIXED(save->p);
+	ht->z_mag = READFIXED(save->p);
+	ht->affectee = READINT32(save->p);
+	ht->roverpusher = READUINT8(save->p);
+	ht->referrer = READINT32(save->p);
+	ht->exclusive = READINT32(save->p);
+	ht->slider = READINT32(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadLaserThinker(actionf_p1 thinker)
+static inline thinker_t* LoadLaserThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	laserthink_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->tag = READINT16(save_p);
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->nobosses = READUINT8(save_p);
+	ht->tag = READINT16(save->p);
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->nobosses = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadLightlevelThinker(actionf_p1 thinker)
+static inline thinker_t* LoadLightlevelThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	lightlevel_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->sourcelevel = READINT16(save_p);
-	ht->destlevel = READINT16(save_p);
-	ht->fixedcurlevel = READFIXED(save_p);
-	ht->fixedpertic = READFIXED(save_p);
-	ht->timer = READINT32(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->sourcelevel = READINT16(save->p);
+	ht->destlevel = READINT16(save->p);
+	ht->fixedcurlevel = READFIXED(save->p);
+	ht->fixedpertic = READFIXED(save->p);
+	ht->timer = READINT32(save->p);
 	if (ht->sector)
 		ht->sector->lightingdata = ht;
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadExecutorThinker(actionf_p1 thinker)
+static inline thinker_t* LoadExecutorThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	executor_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->line = LoadLine(READUINT32(save_p));
-	ht->caller = LoadMobj(READUINT32(save_p));
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->timer = READINT32(save_p);
+	ht->line = LoadLine(READUINT32(save->p));
+	ht->caller = LoadMobj(READUINT32(save->p));
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->timer = READINT32(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadDisappearThinker(actionf_p1 thinker)
+static inline thinker_t* LoadDisappearThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	disappear_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->appeartime = READUINT32(save_p);
-	ht->disappeartime = READUINT32(save_p);
-	ht->offset = READUINT32(save_p);
-	ht->timer = READUINT32(save_p);
-	ht->affectee = READINT32(save_p);
-	ht->sourceline = READINT32(save_p);
-	ht->exists = READINT32(save_p);
+	ht->appeartime = READUINT32(save->p);
+	ht->disappeartime = READUINT32(save->p);
+	ht->offset = READUINT32(save->p);
+	ht->timer = READUINT32(save->p);
+	ht->affectee = READINT32(save->p);
+	ht->sourceline = READINT32(save->p);
+	ht->exists = READINT32(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadFadeThinker(actionf_p1 thinker)
+static inline thinker_t* LoadFadeThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	sector_t *ss;
 	fade_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->dest_exc = GetNetColormapFromList(READUINT32(save_p));
-	ht->sectornum = READUINT32(save_p);
-	ht->ffloornum = READUINT32(save_p);
-	ht->alpha = READINT32(save_p);
-	ht->sourcevalue = READINT16(save_p);
-	ht->destvalue = READINT16(save_p);
-	ht->destlightlevel = READINT16(save_p);
-	ht->speed = READINT16(save_p);
-	ht->ticbased = (boolean)READUINT8(save_p);
-	ht->timer = READINT32(save_p);
-	ht->doexists = READUINT8(save_p);
-	ht->dotranslucent = READUINT8(save_p);
-	ht->dolighting = READUINT8(save_p);
-	ht->docolormap = READUINT8(save_p);
-	ht->docollision = READUINT8(save_p);
-	ht->doghostfade = READUINT8(save_p);
-	ht->exactalpha = READUINT8(save_p);
+	ht->dest_exc = GetNetColormapFromList(READUINT32(save->p));
+	ht->sectornum = READUINT32(save->p);
+	ht->ffloornum = READUINT32(save->p);
+	ht->alpha = READINT32(save->p);
+	ht->sourcevalue = READINT16(save->p);
+	ht->destvalue = READINT16(save->p);
+	ht->destlightlevel = READINT16(save->p);
+	ht->speed = READINT16(save->p);
+	ht->ticbased = (boolean)READUINT8(save->p);
+	ht->timer = READINT32(save->p);
+	ht->doexists = READUINT8(save->p);
+	ht->dotranslucent = READUINT8(save->p);
+	ht->dolighting = READUINT8(save->p);
+	ht->docolormap = READUINT8(save->p);
+	ht->docollision = READUINT8(save->p);
+	ht->doghostfade = READUINT8(save->p);
+	ht->exactalpha = READUINT8(save->p);
 
 	ss = LoadSector(ht->sectornum);
 	if (ss)
@@ -3911,176 +3910,176 @@ static inline thinker_t* LoadFadeThinker(actionf_p1 thinker)
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadFadeColormapThinker(actionf_p1 thinker)
+static inline thinker_t* LoadFadeColormapThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	fadecolormap_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->sector = LoadSector(READUINT32(save_p));
-	ht->source_exc = GetNetColormapFromList(READUINT32(save_p));
-	ht->dest_exc = GetNetColormapFromList(READUINT32(save_p));
-	ht->ticbased = (boolean)READUINT8(save_p);
-	ht->duration = READINT32(save_p);
-	ht->timer = READINT32(save_p);
+	ht->sector = LoadSector(READUINT32(save->p));
+	ht->source_exc = GetNetColormapFromList(READUINT32(save->p));
+	ht->dest_exc = GetNetColormapFromList(READUINT32(save->p));
+	ht->ticbased = (boolean)READUINT8(save->p);
+	ht->duration = READINT32(save->p);
+	ht->timer = READINT32(save->p);
 	if (ht->sector)
 		ht->sector->fadecolormapdata = ht;
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPlaneDisplaceThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPlaneDisplaceThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	planedisplace_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
 
-	ht->affectee = READINT32(save_p);
-	ht->control = READINT32(save_p);
-	ht->last_height = READFIXED(save_p);
-	ht->speed = READFIXED(save_p);
-	ht->type = READUINT8(save_p);
+	ht->affectee = READINT32(save->p);
+	ht->control = READINT32(save->p);
+	ht->last_height = READFIXED(save->p);
+	ht->speed = READFIXED(save->p);
+	ht->type = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadDynamicLineSlopeThinker(actionf_p1 thinker)
+static inline thinker_t* LoadDynamicLineSlopeThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	dynlineplanethink_t* ht = Z_Malloc(sizeof(*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
 
-	ht->type = READUINT8(save_p);
-	ht->slope = LoadSlope(READUINT32(save_p));
-	ht->sourceline = LoadLine(READUINT32(save_p));
-	ht->extent = READFIXED(save_p);
+	ht->type = READUINT8(save->p);
+	ht->slope = LoadSlope(READUINT32(save->p));
+	ht->sourceline = LoadLine(READUINT32(save->p));
+	ht->extent = READFIXED(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadDynamicVertexSlopeThinker(actionf_p1 thinker)
+static inline thinker_t* LoadDynamicVertexSlopeThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	size_t i;
 	dynvertexplanethink_t* ht = Z_Malloc(sizeof(*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
 
-	ht->slope = LoadSlope(READUINT32(save_p));
+	ht->slope = LoadSlope(READUINT32(save->p));
 	for (i = 0; i < 3; i++)
-		ht->secs[i] = LoadSector(READUINT32(save_p));
-	READMEM(save_p, ht->vex, sizeof(ht->vex));
-	READMEM(save_p, ht->origsecheights, sizeof(ht->origsecheights));
-	READMEM(save_p, ht->origvecheights, sizeof(ht->origvecheights));
-	ht->relative = READUINT8(save_p);
+		ht->secs[i] = LoadSector(READUINT32(save->p));
+	READMEM(save->p, ht->vex, sizeof(ht->vex));
+	READMEM(save->p, ht->origsecheights, sizeof(ht->origsecheights));
+	READMEM(save->p, ht->origvecheights, sizeof(ht->origvecheights));
+	ht->relative = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPolyrotatetThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyrotatetThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polyrotate_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->speed = READINT32(save_p);
-	ht->distance = READINT32(save_p);
-	ht->turnobjs = READUINT8(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->speed = READINT32(save->p);
+	ht->distance = READINT32(save->p);
+	ht->turnobjs = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static thinker_t* LoadPolymoveThinker(actionf_p1 thinker)
+static thinker_t* LoadPolymoveThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polymove_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->speed = READINT32(save_p);
-	ht->momx = READFIXED(save_p);
-	ht->momy = READFIXED(save_p);
-	ht->distance = READINT32(save_p);
-	ht->angle = READANGLE(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->speed = READINT32(save->p);
+	ht->momx = READFIXED(save->p);
+	ht->momy = READFIXED(save->p);
+	ht->distance = READINT32(save->p);
+	ht->angle = READANGLE(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPolywaypointThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolywaypointThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polywaypoint_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->speed = READINT32(save_p);
-	ht->sequence = READINT32(save_p);
-	ht->pointnum = READINT32(save_p);
-	ht->direction = READINT32(save_p);
-	ht->returnbehavior = READUINT8(save_p);
-	ht->continuous = READUINT8(save_p);
-	ht->stophere = READUINT8(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->speed = READINT32(save->p);
+	ht->sequence = READINT32(save->p);
+	ht->pointnum = READINT32(save->p);
+	ht->direction = READINT32(save->p);
+	ht->returnbehavior = READUINT8(save->p);
+	ht->continuous = READUINT8(save->p);
+	ht->stophere = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPolyslidedoorThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyslidedoorThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polyslidedoor_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->delay = READINT32(save_p);
-	ht->delayCount = READINT32(save_p);
-	ht->initSpeed = READINT32(save_p);
-	ht->speed = READINT32(save_p);
-	ht->initDistance = READINT32(save_p);
-	ht->distance = READINT32(save_p);
-	ht->initAngle = READUINT32(save_p);
-	ht->angle = READUINT32(save_p);
-	ht->revAngle = READUINT32(save_p);
-	ht->momx = READFIXED(save_p);
-	ht->momy = READFIXED(save_p);
-	ht->closing = READUINT8(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->delay = READINT32(save->p);
+	ht->delayCount = READINT32(save->p);
+	ht->initSpeed = READINT32(save->p);
+	ht->speed = READINT32(save->p);
+	ht->initDistance = READINT32(save->p);
+	ht->distance = READINT32(save->p);
+	ht->initAngle = READUINT32(save->p);
+	ht->angle = READUINT32(save->p);
+	ht->revAngle = READUINT32(save->p);
+	ht->momx = READFIXED(save->p);
+	ht->momy = READFIXED(save->p);
+	ht->closing = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPolyswingdoorThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyswingdoorThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polyswingdoor_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->delay = READINT32(save_p);
-	ht->delayCount = READINT32(save_p);
-	ht->initSpeed = READINT32(save_p);
-	ht->speed = READINT32(save_p);
-	ht->initDistance = READINT32(save_p);
-	ht->distance = READINT32(save_p);
-	ht->closing = READUINT8(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->delay = READINT32(save->p);
+	ht->delayCount = READINT32(save->p);
+	ht->initSpeed = READINT32(save->p);
+	ht->speed = READINT32(save->p);
+	ht->initDistance = READINT32(save->p);
+	ht->distance = READINT32(save->p);
+	ht->closing = READUINT8(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPolydisplaceThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolydisplaceThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polydisplace_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->controlSector = LoadSector(READUINT32(save_p));
-	ht->dx = READFIXED(save_p);
-	ht->dy = READFIXED(save_p);
-	ht->oldHeights = READFIXED(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->controlSector = LoadSector(READUINT32(save->p));
+	ht->dx = READFIXED(save->p);
+	ht->dy = READFIXED(save->p);
+	ht->oldHeights = READFIXED(save->p);
 	return &ht->thinker;
 }
 
-static inline thinker_t* LoadPolyrotdisplaceThinker(actionf_p1 thinker)
+static inline thinker_t* LoadPolyrotdisplaceThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polyrotdisplace_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->controlSector = LoadSector(READUINT32(save_p));
-	ht->rotscale = READFIXED(save_p);
-	ht->turnobjs = READUINT8(save_p);
-	ht->oldHeights = READFIXED(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->controlSector = LoadSector(READUINT32(save->p));
+	ht->rotscale = READFIXED(save->p);
+	ht->turnobjs = READUINT8(save->p);
+	ht->oldHeights = READFIXED(save->p);
 	return &ht->thinker;
 }
 
-static thinker_t* LoadPolyfadeThinker(actionf_p1 thinker)
+static thinker_t* LoadPolyfadeThinker(savebuffer_t *save, actionf_p1 thinker)
 {
 	polyfade_t *ht = Z_Malloc(sizeof (*ht), PU_LEVSPEC, NULL);
 	ht->thinker.function.acp1 = thinker;
-	ht->polyObjNum = READINT32(save_p);
-	ht->sourcevalue = READINT32(save_p);
-	ht->destvalue = READINT32(save_p);
-	ht->docollision = (boolean)READUINT8(save_p);
-	ht->doghostfade = (boolean)READUINT8(save_p);
-	ht->ticbased = (boolean)READUINT8(save_p);
-	ht->duration = READINT32(save_p);
-	ht->timer = READINT32(save_p);
+	ht->polyObjNum = READINT32(save->p);
+	ht->sourcevalue = READINT32(save->p);
+	ht->destvalue = READINT32(save->p);
+	ht->docollision = (boolean)READUINT8(save->p);
+	ht->doghostfade = (boolean)READUINT8(save->p);
+	ht->ticbased = (boolean)READUINT8(save->p);
+	ht->duration = READINT32(save->p);
+	ht->timer = READINT32(save->p);
 	return &ht->thinker;
 }
 
-static void P_NetUnArchiveThinkers(void)
+static void P_NetUnArchiveThinkers(savebuffer_t *save)
 {
 	thinker_t *currentthinker;
 	thinker_t *next;
@@ -4089,7 +4088,7 @@ static void P_NetUnArchiveThinkers(void)
 	UINT32 i;
 	UINT32 numloaded = 0;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_THINKERS)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_THINKERS)
 		I_Error("Bad $$$.sav at archive block Thinkers");
 
 	// remove all the current thinkers
@@ -4127,7 +4126,7 @@ static void P_NetUnArchiveThinkers(void)
 		for (;;)
 		{
 			thinker_t* th = NULL;
-			tclass = READUINT8(save_p);
+			tclass = READUINT8(save->p);
 
 			if (tclass == tc_end)
 				break; // leave the saved thinker reading loop
@@ -4136,167 +4135,167 @@ static void P_NetUnArchiveThinkers(void)
 			switch (tclass)
 			{
 				case tc_mobj:
-					th = LoadMobjThinker((actionf_p1)P_MobjThinker);
+					th = LoadMobjThinker(save, (actionf_p1)P_MobjThinker);
 					break;
 
 				case tc_ceiling:
-					th = LoadCeilingThinker((actionf_p1)T_MoveCeiling);
+					th = LoadCeilingThinker(save, (actionf_p1)T_MoveCeiling);
 					break;
 
 				case tc_crushceiling:
-					th = LoadCeilingThinker((actionf_p1)T_CrushCeiling);
+					th = LoadCeilingThinker(save, (actionf_p1)T_CrushCeiling);
 					break;
 
 				case tc_floor:
-					th = LoadFloormoveThinker((actionf_p1)T_MoveFloor);
+					th = LoadFloormoveThinker(save, (actionf_p1)T_MoveFloor);
 					break;
 
 				case tc_flash:
-					th = LoadLightflashThinker((actionf_p1)T_LightningFlash);
+					th = LoadLightflashThinker(save, (actionf_p1)T_LightningFlash);
 					break;
 
 				case tc_strobe:
-					th = LoadStrobeThinker((actionf_p1)T_StrobeFlash);
+					th = LoadStrobeThinker(save, (actionf_p1)T_StrobeFlash);
 					break;
 
 				case tc_glow:
-					th = LoadGlowThinker((actionf_p1)T_Glow);
+					th = LoadGlowThinker(save, (actionf_p1)T_Glow);
 					break;
 
 				case tc_fireflicker:
-					th = LoadFireflickerThinker((actionf_p1)T_FireFlicker);
+					th = LoadFireflickerThinker(save, (actionf_p1)T_FireFlicker);
 					break;
 
 				case tc_elevator:
-					th = LoadElevatorThinker((actionf_p1)T_MoveElevator, true);
+					th = LoadElevatorThinker(save, (actionf_p1)T_MoveElevator, true);
 					break;
 
 				case tc_continuousfalling:
-					th = LoadContinuousFallThinker((actionf_p1)T_ContinuousFalling);
+					th = LoadContinuousFallThinker(save, (actionf_p1)T_ContinuousFalling);
 					break;
 
 				case tc_thwomp:
-					th = LoadThwompThinker((actionf_p1)T_ThwompSector);
+					th = LoadThwompThinker(save, (actionf_p1)T_ThwompSector);
 					break;
 
 				case tc_noenemies:
-					th = LoadNoEnemiesThinker((actionf_p1)T_NoEnemiesSector);
+					th = LoadNoEnemiesThinker(save, (actionf_p1)T_NoEnemiesSector);
 					break;
 
 				case tc_eachtime:
-					th = LoadEachTimeThinker((actionf_p1)T_EachTimeThinker);
+					th = LoadEachTimeThinker(save, (actionf_p1)T_EachTimeThinker);
 					break;
 
 				case tc_raisesector:
-					th = LoadRaiseThinker((actionf_p1)T_RaiseSector);
+					th = LoadRaiseThinker(save, (actionf_p1)T_RaiseSector);
 					break;
 
 				case tc_camerascanner:
-					th = LoadElevatorThinker((actionf_p1)T_CameraScanner, false);
+					th = LoadElevatorThinker(save, (actionf_p1)T_CameraScanner, false);
 					break;
 
 				case tc_bouncecheese:
-					th = LoadBounceCheeseThinker((actionf_p1)T_BounceCheese);
+					th = LoadBounceCheeseThinker(save, (actionf_p1)T_BounceCheese);
 					break;
 
 				case tc_startcrumble:
-					th = LoadCrumbleThinker((actionf_p1)T_StartCrumble);
+					th = LoadCrumbleThinker(save, (actionf_p1)T_StartCrumble);
 					break;
 
 				case tc_marioblock:
-					th = LoadMarioBlockThinker((actionf_p1)T_MarioBlock);
+					th = LoadMarioBlockThinker(save, (actionf_p1)T_MarioBlock);
 					break;
 
 				case tc_marioblockchecker:
-					th = LoadMarioCheckThinker((actionf_p1)T_MarioBlockChecker);
+					th = LoadMarioCheckThinker(save, (actionf_p1)T_MarioBlockChecker);
 					break;
 
 				case tc_floatsector:
-					th = LoadFloatThinker((actionf_p1)T_FloatSector);
+					th = LoadFloatThinker(save, (actionf_p1)T_FloatSector);
 					break;
 
 				case tc_laserflash:
-					th = LoadLaserThinker((actionf_p1)T_LaserFlash);
+					th = LoadLaserThinker(save, (actionf_p1)T_LaserFlash);
 					break;
 
 				case tc_lightfade:
-					th = LoadLightlevelThinker((actionf_p1)T_LightFade);
+					th = LoadLightlevelThinker(save, (actionf_p1)T_LightFade);
 					break;
 
 				case tc_executor:
-					th = LoadExecutorThinker((actionf_p1)T_ExecutorDelay);
+					th = LoadExecutorThinker(save, (actionf_p1)T_ExecutorDelay);
 					restoreNum = true;
 					break;
 
 				case tc_disappear:
-					th = LoadDisappearThinker((actionf_p1)T_Disappear);
+					th = LoadDisappearThinker(save, (actionf_p1)T_Disappear);
 					break;
 
 				case tc_fade:
-					th = LoadFadeThinker((actionf_p1)T_Fade);
+					th = LoadFadeThinker(save, (actionf_p1)T_Fade);
 					break;
 
 				case tc_fadecolormap:
-					th = LoadFadeColormapThinker((actionf_p1)T_FadeColormap);
+					th = LoadFadeColormapThinker(save, (actionf_p1)T_FadeColormap);
 					break;
 
 				case tc_planedisplace:
-					th = LoadPlaneDisplaceThinker((actionf_p1)T_PlaneDisplace);
+					th = LoadPlaneDisplaceThinker(save, (actionf_p1)T_PlaneDisplace);
 					break;
 				case tc_polyrotate:
-					th = LoadPolyrotatetThinker((actionf_p1)T_PolyObjRotate);
+					th = LoadPolyrotatetThinker(save, (actionf_p1)T_PolyObjRotate);
 					break;
 
 				case tc_polymove:
-					th = LoadPolymoveThinker((actionf_p1)T_PolyObjMove);
+					th = LoadPolymoveThinker(save, (actionf_p1)T_PolyObjMove);
 					break;
 
 				case tc_polywaypoint:
-					th = LoadPolywaypointThinker((actionf_p1)T_PolyObjWaypoint);
+					th = LoadPolywaypointThinker(save, (actionf_p1)T_PolyObjWaypoint);
 					break;
 
 				case tc_polyslidedoor:
-					th = LoadPolyslidedoorThinker((actionf_p1)T_PolyDoorSlide);
+					th = LoadPolyslidedoorThinker(save, (actionf_p1)T_PolyDoorSlide);
 					break;
 
 				case tc_polyswingdoor:
-					th = LoadPolyswingdoorThinker((actionf_p1)T_PolyDoorSwing);
+					th = LoadPolyswingdoorThinker(save, (actionf_p1)T_PolyDoorSwing);
 					break;
 
 				case tc_polyflag:
-					th = LoadPolymoveThinker((actionf_p1)T_PolyObjFlag);
+					th = LoadPolymoveThinker(save, (actionf_p1)T_PolyObjFlag);
 					break;
 
 				case tc_polydisplace:
-					th = LoadPolydisplaceThinker((actionf_p1)T_PolyObjDisplace);
+					th = LoadPolydisplaceThinker(save, (actionf_p1)T_PolyObjDisplace);
 					break;
 
 				case tc_polyrotdisplace:
-					th = LoadPolyrotdisplaceThinker((actionf_p1)T_PolyObjRotDisplace);
+					th = LoadPolyrotdisplaceThinker(save, (actionf_p1)T_PolyObjRotDisplace);
 					break;
 
 				case tc_polyfade:
-					th = LoadPolyfadeThinker((actionf_p1)T_PolyObjFade);
+					th = LoadPolyfadeThinker(save, (actionf_p1)T_PolyObjFade);
 					break;
 
 				case tc_dynslopeline:
-					th = LoadDynamicLineSlopeThinker((actionf_p1)T_DynamicSlopeLine);
+					th = LoadDynamicLineSlopeThinker(save, (actionf_p1)T_DynamicSlopeLine);
 					break;
 
 				case tc_dynslopevert:
-					th = LoadDynamicVertexSlopeThinker((actionf_p1)T_DynamicSlopeVert);
+					th = LoadDynamicVertexSlopeThinker(save, (actionf_p1)T_DynamicSlopeVert);
 					break;
 
 				case tc_scroll:
-					th = LoadScrollThinker((actionf_p1)T_Scroll);
+					th = LoadScrollThinker(save, (actionf_p1)T_Scroll);
 					break;
 
 				case tc_friction:
-					th = LoadFrictionThinker((actionf_p1)T_Friction);
+					th = LoadFrictionThinker(save, (actionf_p1)T_Friction);
 					break;
 
 				case tc_pusher:
-					th = LoadPusherThinker((actionf_p1)T_Pusher);
+					th = LoadPusherThinker(save, (actionf_p1)T_Pusher);
 					break;
 
 				default:
@@ -4332,29 +4331,29 @@ static void P_NetUnArchiveThinkers(void)
 #define PD_FLAGS  0x01
 #define PD_TRANS   0x02
 
-static inline void P_ArchivePolyObj(polyobj_t *po)
+static inline void P_ArchivePolyObj(savebuffer_t *save, polyobj_t *po)
 {
 	UINT8 diff = 0;
-	WRITEINT32(save_p, po->id);
-	WRITEANGLE(save_p, po->angle);
+	WRITEINT32(save->p, po->id);
+	WRITEANGLE(save->p, po->angle);
 
-	WRITEFIXED(save_p, po->spawnSpot.x);
-	WRITEFIXED(save_p, po->spawnSpot.y);
+	WRITEFIXED(save->p, po->spawnSpot.x);
+	WRITEFIXED(save->p, po->spawnSpot.y);
 
 	if (po->flags != po->spawnflags)
 		diff |= PD_FLAGS;
 	if (po->translucency != po->spawntrans)
 		diff |= PD_TRANS;
 
-	WRITEUINT8(save_p, diff);
+	WRITEUINT8(save->p, diff);
 
 	if (diff & PD_FLAGS)
-		WRITEINT32(save_p, po->flags);
+		WRITEINT32(save->p, po->flags);
 	if (diff & PD_TRANS)
-		WRITEINT32(save_p, po->translucency);
+		WRITEINT32(save->p, po->translucency);
 }
 
-static inline void P_UnArchivePolyObj(polyobj_t *po)
+static inline void P_UnArchivePolyObj(savebuffer_t *save, polyobj_t *po)
 {
 	INT32 id;
 	UINT32 angle;
@@ -4366,19 +4365,19 @@ static inline void P_UnArchivePolyObj(polyobj_t *po)
 	// when they first start to run.
 	po->thinker = NULL;
 
-	id = READINT32(save_p);
+	id = READINT32(save->p);
 
-	angle = READANGLE(save_p);
+	angle = READANGLE(save->p);
 
-	x = READFIXED(save_p);
-	y = READFIXED(save_p);
+	x = READFIXED(save->p);
+	y = READFIXED(save->p);
 
-	diff = READUINT8(save_p);
+	diff = READUINT8(save->p);
 
 	if (diff & PD_FLAGS)
-		po->flags = READINT32(save_p);
+		po->flags = READINT32(save->p);
 	if (diff & PD_TRANS)
-		po->translucency = READINT32(save_p);
+		po->translucency = READINT32(save->p);
 
 	// if the object is bad or isn't in the id hash, we can do nothing more
 	// with it, so return now
@@ -4389,33 +4388,33 @@ static inline void P_UnArchivePolyObj(polyobj_t *po)
 	Polyobj_MoveOnLoad(po, angle, x, y);
 }
 
-static inline void P_ArchivePolyObjects(void)
+static inline void P_ArchivePolyObjects(savebuffer_t *save)
 {
 	INT32 i;
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_POBJS);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_POBJS);
 
 	// save number of polyobjects
-	WRITEINT32(save_p, numPolyObjects);
+	WRITEINT32(save->p, numPolyObjects);
 
 	for (i = 0; i < numPolyObjects; ++i)
-		P_ArchivePolyObj(&PolyObjects[i]);
+		P_ArchivePolyObj(save, &PolyObjects[i]);
 }
 
-static inline void P_UnArchivePolyObjects(void)
+static inline void P_UnArchivePolyObjects(savebuffer_t *save)
 {
 	INT32 i, numSavedPolys;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_POBJS)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_POBJS)
 		I_Error("Bad $$$.sav at archive block Pobjs");
 
-	numSavedPolys = READINT32(save_p);
+	numSavedPolys = READINT32(save->p);
 
 	if (numSavedPolys != numPolyObjects)
 		I_Error("P_UnArchivePolyObjects: polyobj count inconsistency\n");
 
 	for (i = 0; i < numSavedPolys; ++i)
-		P_UnArchivePolyObj(&PolyObjects[i]);
+		P_UnArchivePolyObj(save, &PolyObjects[i]);
 }
 
 static inline void P_FinishMobjs(void)
@@ -4586,11 +4585,11 @@ static void P_RelinkPointers(void)
 	}
 }
 
-static inline void P_NetArchiveSpecials(void)
+static inline void P_NetArchiveSpecials(savebuffer_t *save)
 {
 	size_t i, z;
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_SPECIALS);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_SPECIALS);
 
 	// itemrespawn queue for deathmatch
 	i = iquetail;
@@ -4600,53 +4599,53 @@ static inline void P_NetArchiveSpecials(void)
 		{
 			if (&mapthings[z] == itemrespawnque[i])
 			{
-				WRITEUINT32(save_p, z);
+				WRITEUINT32(save->p, z);
 				break;
 			}
 		}
-		WRITEUINT32(save_p, itemrespawntime[i]);
+		WRITEUINT32(save->p, itemrespawntime[i]);
 		i = (i + 1) & (ITEMQUESIZE-1);
 	}
 
 	// end delimiter
-	WRITEUINT32(save_p, 0xffffffff);
+	WRITEUINT32(save->p, 0xffffffff);
 
 	// Sky number
-	WRITESTRINGN(save_p, globallevelskytexture, 9);
+	WRITESTRINGN(save->p, globallevelskytexture, 9);
 
 	// Current global weather type
-	WRITEUINT8(save_p, globalweather);
+	WRITEUINT8(save->p, globalweather);
 
 	if (metalplayback) // Is metal sonic running?
 	{
-		WRITEUINT8(save_p, 0x01);
-		G_SaveMetal(&save_p);
+		WRITEUINT8(save->p, 0x01);
+		G_SaveMetal(&save->p);
 	}
 	else
-		WRITEUINT8(save_p, 0x00);
+		WRITEUINT8(save->p, 0x00);
 }
 
-static void P_NetUnArchiveSpecials(void)
+static void P_NetUnArchiveSpecials(savebuffer_t *save)
 {
 	char skytex[9];
 	size_t i;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_SPECIALS)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_SPECIALS)
 		I_Error("Bad $$$.sav at archive block Specials");
 
 	// BP: added save itemrespawn queue for deathmatch
 	iquetail = iquehead = 0;
-	while ((i = READUINT32(save_p)) != 0xffffffff)
+	while ((i = READUINT32(save->p)) != 0xffffffff)
 	{
 		itemrespawnque[iquehead] = &mapthings[i];
-		itemrespawntime[iquehead++] = READINT32(save_p);
+		itemrespawntime[iquehead++] = READINT32(save->p);
 	}
 
-	READSTRINGN(save_p, skytex, sizeof(skytex));
+	READSTRINGN(save->p, skytex, sizeof(skytex));
 	if (strcmp(skytex, globallevelskytexture))
 		P_SetupLevelSky(skytex, true);
 
-	globalweather = READUINT8(save_p);
+	globalweather = READUINT8(save->p);
 
 	if (globalweather)
 	{
@@ -4661,14 +4660,14 @@ static void P_NetUnArchiveSpecials(void)
 			P_SwitchWeather(globalweather);
 	}
 
-	if (READUINT8(save_p) == 0x01) // metal sonic
-		G_LoadMetal(&save_p);
+	if (READUINT8(save->p) == 0x01) // metal sonic
+		G_LoadMetal(&save->p);
 }
 
 // =======================================================================
 //          Misc
 // =======================================================================
-static inline void P_ArchiveMisc(INT16 mapnum)
+static inline void P_ArchiveMisc(savebuffer_t *save, INT16 mapnum)
 {
 	//lastmapsaved = mapnum;
 	lastmaploaded = mapnum;
@@ -4676,16 +4675,16 @@ static inline void P_ArchiveMisc(INT16 mapnum)
 	if (gamecomplete)
 		mapnum |= 8192;
 
-	WRITEINT16(save_p, mapnum);
-	WRITEUINT16(save_p, emeralds+357);
-	WRITESTRINGN(save_p, timeattackfolder, sizeof(timeattackfolder));
+	WRITEINT16(save->p, mapnum);
+	WRITEUINT16(save->p, emeralds+357);
+	WRITESTRINGN(save->p, timeattackfolder, sizeof(timeattackfolder));
 }
 
-static inline void P_UnArchiveSPGame(INT16 mapoverride)
+static inline void P_UnArchiveSPGame(savebuffer_t *save, INT16 mapoverride)
 {
 	char testname[sizeof(timeattackfolder)];
 
-	gamemap = READINT16(save_p);
+	gamemap = READINT16(save->p);
 
 	if (mapoverride != 0)
 	{
@@ -4703,9 +4702,9 @@ static inline void P_UnArchiveSPGame(INT16 mapoverride)
 	//lastmapsaved = gamemap;
 	lastmaploaded = gamemap;
 
-	savedata.emeralds = READUINT16(save_p)-357;
+	savedata.emeralds = READUINT16(save->p)-357;
 
-	READSTRINGN(save_p, testname, sizeof(testname));
+	READSTRINGN(save->p, testname, sizeof(testname));
 
 	if (strcmp(testname, timeattackfolder))
 	{
@@ -4719,27 +4718,27 @@ static inline void P_UnArchiveSPGame(INT16 mapoverride)
 	playeringame[consoleplayer] = true;
 }
 
-static void P_NetArchiveMisc(boolean resending)
+static void P_NetArchiveMisc(savebuffer_t *save, boolean resending)
 {
 	size_t i, j;
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_MISC);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_MISC);
 
 	if (resending)
-		WRITEUINT32(save_p, gametic);
-	WRITEINT16(save_p, gamemap);
+		WRITEUINT32(save->p, gametic);
+	WRITEINT16(save->p, gamemap);
 
 	if (gamestate != GS_LEVEL)
-		WRITEINT16(save_p, GS_WAITINGPLAYERS); // nice hack to put people back into waitingplayers
+		WRITEINT16(save->p, GS_WAITINGPLAYERS); // nice hack to put people back into waitingplayers
 	else
-		WRITEINT16(save_p, gamestate);
-	WRITEINT16(save_p, gametype);
+		WRITEINT16(save->p, gamestate);
+	WRITEINT16(save->p, gametype);
 
 	{
 		UINT32 pig = 0;
 		for (i = 0; i < MAXPLAYERS; i++)
 			pig |= (playeringame[i] != 0)<<i;
-		WRITEUINT32(save_p, pig);
+		WRITEUINT32(save->p, pig);
 	}
 
 	for (i = 0; i < MAXUNLOCKABLES;)
@@ -4747,143 +4746,142 @@ static void P_NetArchiveMisc(boolean resending)
 		UINT8 btemp = 0;
 		for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
 			btemp |= (netUnlocked[j+i] << j);
-		WRITEUINT8(save_p, btemp);
+		WRITEUINT8(save->p, btemp);
 		i += j;
 	}
 
-	WRITEUINT8(save_p, encoremode);
+	WRITEUINT8(save->p, encoremode);
 
-	WRITEUINT32(save_p, leveltime);
-	WRITEINT16(save_p, lastmap);
-	WRITEUINT16(save_p, bossdisabled);
+	WRITEUINT32(save->p, leveltime);
+	WRITEINT16(save->p, lastmap);
+	WRITEUINT16(save->p, bossdisabled);
 
 	for (i = 0; i < 4; i++)
 	{
-		WRITEINT16(save_p, votelevels[i][0]);
-		WRITEINT16(save_p, votelevels[i][1]);
+		WRITEINT16(save->p, votelevels[i][0]);
+		WRITEINT16(save->p, votelevels[i][1]);
 	}
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		WRITESINT8(save_p, votes[i]);
+		WRITESINT8(save->p, votes[i]);
 
-	WRITESINT8(save_p, pickedvote);
+	WRITESINT8(save->p, pickedvote);
 
-	WRITEUINT16(save_p, emeralds);
+	WRITEUINT16(save->p, emeralds);
 	{
 		UINT8 globools = 0;
 		if (stagefailed)
 			globools |= 1;
 		if (stoppedclock)
 			globools |= (1<<1);
-		WRITEUINT8(save_p, globools);
+		WRITEUINT8(save->p, globools);
 	}
 
-	WRITEUINT32(save_p, bluescore);
-	WRITEUINT32(save_p, redscore);
+	WRITEUINT32(save->p, bluescore);
+	WRITEUINT32(save->p, redscore);
 
-	WRITEUINT16(save_p, skincolor_redteam);
-	WRITEUINT16(save_p, skincolor_blueteam);
-	WRITEUINT16(save_p, skincolor_redring);
-	WRITEUINT16(save_p, skincolor_bluering);
+	WRITEUINT16(save->p, skincolor_redteam);
+	WRITEUINT16(save->p, skincolor_blueteam);
+	WRITEUINT16(save->p, skincolor_redring);
+	WRITEUINT16(save->p, skincolor_bluering);
 
-	WRITEINT32(save_p, modulothing);
+	WRITEINT32(save->p, modulothing);
 
-	WRITEINT16(save_p, autobalance);
-	WRITEINT16(save_p, teamscramble);
+	WRITEINT16(save->p, autobalance);
+	WRITEINT16(save->p, teamscramble);
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		WRITEINT16(save_p, scrambleplayers[i]);
+		WRITEINT16(save->p, scrambleplayers[i]);
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		WRITEINT16(save_p, scrambleteams[i]);
+		WRITEINT16(save->p, scrambleteams[i]);
 
-	WRITEINT16(save_p, scrambletotal);
-	WRITEINT16(save_p, scramblecount);
+	WRITEINT16(save->p, scrambletotal);
+	WRITEINT16(save->p, scramblecount);
 
-	WRITEUINT32(save_p, racecountdown);
-	WRITEUINT32(save_p, exitcountdown);
+	WRITEUINT32(save->p, racecountdown);
+	WRITEUINT32(save->p, exitcountdown);
 
-	WRITEFIXED(save_p, gravity);
-	WRITEFIXED(save_p, mapobjectscale);
+	WRITEFIXED(save->p, gravity);
+	WRITEFIXED(save->p, mapobjectscale);
 
 	// SRB2kart
-	WRITEINT32(save_p, numgotboxes);
-	WRITEUINT8(save_p, numtargets);
-	WRITEUINT8(save_p, battlecapsules);
+	WRITEINT32(save->p, numgotboxes);
+	WRITEUINT8(save->p, numtargets);
+	WRITEUINT8(save->p, battlecapsules);
 
-	WRITEUINT8(save_p, gamespeed);
-	WRITEUINT8(save_p, numlaps);
-	WRITEUINT8(save_p, franticitems);
+	WRITEUINT8(save->p, gamespeed);
+	WRITEUINT8(save->p, numlaps);
+	WRITEUINT8(save->p, franticitems);
 
-	WRITESINT8(save_p, speedscramble);
-	WRITESINT8(save_p, encorescramble);
+	WRITESINT8(save->p, speedscramble);
+	WRITESINT8(save->p, encorescramble);
 
 	for (i = 0; i < 4; i++)
-		WRITESINT8(save_p, battlewanted[i]);
+		WRITESINT8(save->p, battlewanted[i]);
 
 	// battleovertime_t
-	WRITEUINT16(save_p, battleovertime.enabled);
-	WRITEFIXED(save_p, battleovertime.radius);
-	WRITEFIXED(save_p, battleovertime.x);
-	WRITEFIXED(save_p, battleovertime.y);
-	WRITEFIXED(save_p, battleovertime.z);
+	WRITEUINT16(save->p, battleovertime.enabled);
+	WRITEFIXED(save->p, battleovertime.radius);
+	WRITEFIXED(save->p, battleovertime.x);
+	WRITEFIXED(save->p, battleovertime.y);
+	WRITEFIXED(save->p, battleovertime.z);
 
-	WRITEUINT32(save_p, wantedcalcdelay);
+	WRITEUINT32(save->p, wantedcalcdelay);
 	for (i = 0; i < NUMKARTITEMS-1; i++)
-		WRITEUINT32(save_p, itemCooldowns[i]);
-	WRITEUINT32(save_p, mapreset);
+		WRITEUINT32(save->p, itemCooldowns[i]);
+	WRITEUINT32(save->p, mapreset);
 
-	WRITEUINT8(save_p, spectateGriefed);
+	WRITEUINT8(save->p, spectateGriefed);
 
-	WRITEUINT8(save_p, thwompsactive);
-	WRITEUINT8(save_p, lastLowestLap);
-	WRITESINT8(save_p, spbplace);
-	WRITEUINT8(save_p, rainbowstartavailable);
-	WRITEUINT8(save_p, inDuel);
+	WRITEUINT8(save->p, thwompsactive);
+	WRITEUINT8(save->p, lastLowestLap);
+	WRITESINT8(save->p, spbplace);
+	WRITEUINT8(save->p, rainbowstartavailable);
+	WRITEUINT8(save->p, inDuel);
 
-	WRITEUINT32(save_p, introtime);
-	WRITEUINT32(save_p, starttime);
-	WRITEUINT8(save_p, numbulbs);
+	WRITEUINT32(save->p, introtime);
+	WRITEUINT32(save->p, starttime);
+	WRITEUINT8(save->p, numbulbs);
 
-	WRITEUINT32(save_p, timelimitintics);
-	WRITEUINT32(save_p, extratimeintics);
-	WRITEUINT32(save_p, secretextratime);
+	WRITEUINT32(save->p, timelimitintics);
+	WRITEUINT32(save->p, extratimeintics);
+	WRITEUINT32(save->p, secretextratime);
 
 	// Is it paused?
 	if (paused)
-		WRITEUINT8(save_p, 0x2f);
+		WRITEUINT8(save->p, 0x2f);
 	else
-		WRITEUINT8(save_p, 0x2e);
+		WRITEUINT8(save->p, 0x2e);
 
-	WRITEUINT32(save_p, livestudioaudience_timer);
+	WRITEUINT32(save->p, livestudioaudience_timer);
 
 	// Only the server uses this, but it
 	// needs synched for remote admins anyway.
-	WRITEUINT32(save_p, schedule_len);
+	WRITEUINT32(save->p, schedule_len);
 	for (i = 0; i < schedule_len; i++)
 	{
 		scheduleTask_t *task = schedule[i];
-		WRITEINT16(save_p, task->basetime);
-		WRITEINT16(save_p, task->timer);
-		WRITESTRING(save_p, task->command);
+		WRITEINT16(save->p, task->basetime);
+		WRITEINT16(save->p, task->timer);
+		WRITESTRING(save->p, task->command);
 	}
 
-	WRITEUINT32(save_p, cht_debug);
+	WRITEUINT32(save->p, cht_debug);
 }
 
-static inline boolean P_NetUnArchiveMisc(boolean reloading)
+static inline boolean P_NetUnArchiveMisc(savebuffer_t *save, boolean reloading)
 {
 	size_t i, j;
 	size_t numTasks;
-	UINT8 *old_save_p;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_MISC)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_MISC)
 		I_Error("Bad $$$.sav at archive block Misc");
 
 	if (reloading)
-		gametic = READUINT32(save_p);
+		gametic = READUINT32(save->p);
 
-	gamemap = READINT16(save_p);
+	gamemap = READINT16(save->p);
 
 	// gamemap changed; we assume that its map header is always valid,
 	// so make it so
@@ -4895,12 +4893,12 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading)
 	if (!reloading)
 		mapmusflags |= MUSIC_RELOADRESET;
 
-	G_SetGamestate(READINT16(save_p));
+	G_SetGamestate(READINT16(save->p));
 
-	gametype = READINT16(save_p);
+	gametype = READINT16(save->p);
 
 	{
-		UINT32 pig = READUINT32(save_p);
+		UINT32 pig = READUINT32(save->p);
 		for (i = 0; i < MAXPLAYERS; i++)
 		{
 			playeringame[i] = (pig & (1<<i)) != 0;
@@ -4910,16 +4908,13 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading)
 
 	for (i = 0; i < MAXUNLOCKABLES;)
 	{
-		UINT8 rtemp = READUINT8(save_p);
+		UINT8 rtemp = READUINT8(save->p);
 		for (j = 0; j < 8 && j+i < MAXUNLOCKABLES; ++j)
 			netUnlocked[j+i] = ((rtemp >> j) & 1);
 		i += j;
 	}
 
-	encoremode = (boolean)READUINT8(save_p);
-
-	// FIXME: save_p should not be global!!!
-	old_save_p = save_p;
+	encoremode = (boolean)READUINT8(save->p);
 
 	if (!P_LoadLevel(true, reloading))
 	{
@@ -4927,132 +4922,130 @@ static inline boolean P_NetUnArchiveMisc(boolean reloading)
 		return false;
 	}
 
-	save_p = old_save_p;
-
 	// get the time
-	leveltime = READUINT32(save_p);
-	lastmap = READINT16(save_p);
-	bossdisabled = READUINT16(save_p);
+	leveltime = READUINT32(save->p);
+	lastmap = READINT16(save->p);
+	bossdisabled = READUINT16(save->p);
 
 	for (i = 0; i < 4; i++)
 	{
-		votelevels[i][0] = READINT16(save_p);
-		votelevels[i][1] = READINT16(save_p);
+		votelevels[i][0] = READINT16(save->p);
+		votelevels[i][1] = READINT16(save->p);
 	}
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		votes[i] = READSINT8(save_p);
+		votes[i] = READSINT8(save->p);
 
-	pickedvote = READSINT8(save_p);
+	pickedvote = READSINT8(save->p);
 
-	emeralds = READUINT16(save_p);
+	emeralds = READUINT16(save->p);
 	{
-		UINT8 globools = READUINT8(save_p);
+		UINT8 globools = READUINT8(save->p);
 		stagefailed = !!(globools & 1);
 		stoppedclock = !!(globools & (1<<1));
 	}
 
-	bluescore = READUINT32(save_p);
-	redscore = READUINT32(save_p);
+	bluescore = READUINT32(save->p);
+	redscore = READUINT32(save->p);
 
-	skincolor_redteam = READUINT16(save_p);
-	skincolor_blueteam = READUINT16(save_p);
-	skincolor_redring = READUINT16(save_p);
-	skincolor_bluering = READUINT16(save_p);
+	skincolor_redteam = READUINT16(save->p);
+	skincolor_blueteam = READUINT16(save->p);
+	skincolor_redring = READUINT16(save->p);
+	skincolor_bluering = READUINT16(save->p);
 
-	modulothing = READINT32(save_p);
+	modulothing = READINT32(save->p);
 
-	autobalance = READINT16(save_p);
-	teamscramble = READINT16(save_p);
+	autobalance = READINT16(save->p);
+	teamscramble = READINT16(save->p);
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		scrambleplayers[i] = READINT16(save_p);
+		scrambleplayers[i] = READINT16(save->p);
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		scrambleteams[i] = READINT16(save_p);
+		scrambleteams[i] = READINT16(save->p);
 
-	scrambletotal = READINT16(save_p);
-	scramblecount = READINT16(save_p);
+	scrambletotal = READINT16(save->p);
+	scramblecount = READINT16(save->p);
 
-	racecountdown = READUINT32(save_p);
-	exitcountdown = READUINT32(save_p);
+	racecountdown = READUINT32(save->p);
+	exitcountdown = READUINT32(save->p);
 
-	gravity = READFIXED(save_p);
-	mapobjectscale = READFIXED(save_p);
+	gravity = READFIXED(save->p);
+	mapobjectscale = READFIXED(save->p);
 
 	// SRB2kart
-	numgotboxes = READINT32(save_p);
-	numtargets = READUINT8(save_p);
-	battlecapsules = (boolean)READUINT8(save_p);
+	numgotboxes = READINT32(save->p);
+	numtargets = READUINT8(save->p);
+	battlecapsules = (boolean)READUINT8(save->p);
 
-	gamespeed = READUINT8(save_p);
-	numlaps = READUINT8(save_p);
-	franticitems = (boolean)READUINT8(save_p);
+	gamespeed = READUINT8(save->p);
+	numlaps = READUINT8(save->p);
+	franticitems = (boolean)READUINT8(save->p);
 
-	speedscramble = READSINT8(save_p);
-	encorescramble = READSINT8(save_p);
+	speedscramble = READSINT8(save->p);
+	encorescramble = READSINT8(save->p);
 
 	for (i = 0; i < 4; i++)
-		battlewanted[i] = READSINT8(save_p);
+		battlewanted[i] = READSINT8(save->p);
 
 	// battleovertime_t
-	battleovertime.enabled = READUINT16(save_p);
-	battleovertime.radius = READFIXED(save_p);
-	battleovertime.x = READFIXED(save_p);
-	battleovertime.y = READFIXED(save_p);
-	battleovertime.z = READFIXED(save_p);
+	battleovertime.enabled = READUINT16(save->p);
+	battleovertime.radius = READFIXED(save->p);
+	battleovertime.x = READFIXED(save->p);
+	battleovertime.y = READFIXED(save->p);
+	battleovertime.z = READFIXED(save->p);
 
-	wantedcalcdelay = READUINT32(save_p);
+	wantedcalcdelay = READUINT32(save->p);
 	for (i = 0; i < NUMKARTITEMS-1; i++)
-		itemCooldowns[i] = READUINT32(save_p);
-	mapreset = READUINT32(save_p);
+		itemCooldowns[i] = READUINT32(save->p);
+	mapreset = READUINT32(save->p);
 
-	spectateGriefed = READUINT8(save_p);
+	spectateGriefed = READUINT8(save->p);
 
-	thwompsactive = (boolean)READUINT8(save_p);
-	lastLowestLap = READUINT8(save_p);
-	spbplace = READSINT8(save_p);
-	rainbowstartavailable = (boolean)READUINT8(save_p);
-	inDuel = (boolean)READUINT8(save_p);
+	thwompsactive = (boolean)READUINT8(save->p);
+	lastLowestLap = READUINT8(save->p);
+	spbplace = READSINT8(save->p);
+	rainbowstartavailable = (boolean)READUINT8(save->p);
+	inDuel = (boolean)READUINT8(save->p);
 
-	introtime = READUINT32(save_p);
-	starttime = READUINT32(save_p);
-	numbulbs = READUINT8(save_p);
+	introtime = READUINT32(save->p);
+	starttime = READUINT32(save->p);
+	numbulbs = READUINT8(save->p);
 
-	timelimitintics = READUINT32(save_p);
-	extratimeintics = READUINT32(save_p);
-	secretextratime = READUINT32(save_p);
+	timelimitintics = READUINT32(save->p);
+	extratimeintics = READUINT32(save->p);
+	secretextratime = READUINT32(save->p);
 
 	// Is it paused?
-	if (READUINT8(save_p) == 0x2f)
+	if (READUINT8(save->p) == 0x2f)
 		paused = true;
 
-	livestudioaudience_timer = READUINT32(save_p);
+	livestudioaudience_timer = READUINT32(save->p);
 
 	// Only the server uses this, but it
 	// needs synched for remote admins anyway.
 	Schedule_Clear();
 
-	numTasks = READUINT32(save_p);
+	numTasks = READUINT32(save->p);
 	for (i = 0; i < numTasks; i++)
 	{
 		INT16 basetime;
 		INT16 timer;
 		char command[MAXTEXTCMD];
 
-		basetime = READINT16(save_p);
-		timer = READINT16(save_p);
-		READSTRING(save_p, command);
+		basetime = READINT16(save->p);
+		timer = READINT16(save->p);
+		READSTRING(save->p, command);
 
 		Schedule_Add(basetime, timer, command);
 	}
 
-	cht_debug = READUINT32(save_p);
+	cht_debug = READUINT32(save->p);
 
 	return true;
 }
 
-static inline void P_ArchiveLuabanksAndConsistency(void)
+static inline void P_ArchiveLuabanksAndConsistency(savebuffer_t *save)
 {
 	UINT8 i, banksinuse = NUM_LUABANKS;
 
@@ -5061,30 +5054,30 @@ static inline void P_ArchiveLuabanksAndConsistency(void)
 
 	if (banksinuse)
 	{
-		WRITEUINT8(save_p, 0xb7); // luabanks marker
-		WRITEUINT8(save_p, banksinuse);
+		WRITEUINT8(save->p, 0xb7); // luabanks marker
+		WRITEUINT8(save->p, banksinuse);
 		for (i = 0; i < banksinuse; i++)
-			WRITEINT32(save_p, luabanks[i]);
+			WRITEINT32(save->p, luabanks[i]);
 	}
 
-	WRITEUINT8(save_p, 0x1d); // consistency marker
+	WRITEUINT8(save->p, 0x1d); // consistency marker
 }
 
-static inline boolean P_UnArchiveLuabanksAndConsistency(void)
+static inline boolean P_UnArchiveLuabanksAndConsistency(savebuffer_t *save)
 {
-	switch (READUINT8(save_p))
+	switch (READUINT8(save->p))
 	{
 		case 0xb7: // luabanks marker
 			{
-				UINT8 i, banksinuse = READUINT8(save_p);
+				UINT8 i, banksinuse = READUINT8(save->p);
 				if (banksinuse > NUM_LUABANKS)
 				{
 					CONS_Alert(CONS_ERROR, M_GetText("Corrupt Luabanks! (Too many banks in use)\n"));
 					return false;
 				}
 				for (i = 0; i < banksinuse; i++)
-					luabanks[i] = READINT32(save_p);
-				if (READUINT8(save_p) != 0x1d) // consistency marker
+					luabanks[i] = READINT32(save->p);
+				if (READUINT8(save->p) != 0x1d) // consistency marker
 				{
 					CONS_Alert(CONS_ERROR, M_GetText("Corrupt Luabanks! (Failed consistency check)\n"));
 					return false;
@@ -5100,50 +5093,50 @@ static inline boolean P_UnArchiveLuabanksAndConsistency(void)
 	return true;
 }
 
-static void P_NetArchiveRNG(void)
+static void P_NetArchiveRNG(savebuffer_t *save)
 {
 	size_t i;
 
-	WRITEUINT32(save_p, ARCHIVEBLOCK_RNG);
+	WRITEUINT32(save->p, ARCHIVEBLOCK_RNG);
 
 	for (i = 0; i < PRNUMCLASS; i++)
 	{
-		WRITEUINT32(save_p, P_GetInitSeed(i));
-		WRITEUINT32(save_p, P_GetRandSeed(i));
+		WRITEUINT32(save->p, P_GetInitSeed(i));
+		WRITEUINT32(save->p, P_GetRandSeed(i));
 	}
 }
 
-static inline void P_NetUnArchiveRNG(void)
+static inline void P_NetUnArchiveRNG(savebuffer_t *save)
 {
 	size_t i;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_RNG)
+	if (READUINT32(save->p) != ARCHIVEBLOCK_RNG)
 		I_Error("Bad $$$.sav at archive block RNG");
 
 	for (i = 0; i < PRNUMCLASS; i++)
 	{
-		UINT32 init = READUINT32(save_p);
-		UINT32 seed = READUINT32(save_p);
+		UINT32 init = READUINT32(save->p);
+		UINT32 seed = READUINT32(save->p);
 
 		P_SetRandSeedNet(i, init, seed);
 	}
 }
 
-void P_SaveGame(INT16 mapnum)
+void P_SaveGame(savebuffer_t *save, INT16 mapnum)
 {
-	P_ArchiveMisc(mapnum);
-	P_ArchivePlayer();
-	P_ArchiveLuabanksAndConsistency();
+	P_ArchiveMisc(save, mapnum);
+	P_ArchivePlayer(save);
+	P_ArchiveLuabanksAndConsistency(save);
 }
 
-void P_SaveNetGame(boolean resending)
+void P_SaveNetGame(savebuffer_t *save, boolean resending)
 {
 	thinker_t *th;
 	mobj_t *mobj;
 	INT32 i = 1; // don't start from 0, it'd be confused with a blank pointer otherwise
 
-	CV_SaveNetVars(&save_p);
-	P_NetArchiveMisc(resending);
+	CV_SaveNetVars(&save->p);
+	P_NetArchiveMisc(save, resending);
 
 	// Assign the mobjnumber for pointer tracking
 	if (gamestate == GS_LEVEL)
@@ -5160,25 +5153,25 @@ void P_SaveNetGame(boolean resending)
 		}
 	}
 
-	P_NetArchivePlayers();
+	P_NetArchivePlayers(save);
 	if (gamestate == GS_LEVEL)
 	{
-		P_NetArchiveWorld();
-		P_ArchivePolyObjects();
-		P_NetArchiveThinkers();
-		P_NetArchiveSpecials();
-		P_NetArchiveColormaps();
-		P_NetArchiveTubeWaypoints();
-		P_NetArchiveWaypoints();
+		P_NetArchiveWorld(save);
+		P_ArchivePolyObjects(save);
+		P_NetArchiveThinkers(save);
+		P_NetArchiveSpecials(save);
+		P_NetArchiveColormaps(save);
+		P_NetArchiveTubeWaypoints(save);
+		P_NetArchiveWaypoints(save);
 	}
-	LUA_Archive(&save_p);
+	LUA_Archive(&save->p, true);
 
-	P_NetArchiveRNG();
+	P_NetArchiveRNG(save);
 
-	P_ArchiveLuabanksAndConsistency();
+	P_ArchiveLuabanksAndConsistency(save);
 }
 
-boolean P_LoadGame(INT16 mapoverride)
+boolean P_LoadGame(savebuffer_t *save, INT16 mapoverride)
 {
 	if (gamestate == GS_INTERMISSION)
 		Y_EndIntermission();
@@ -5186,10 +5179,10 @@ boolean P_LoadGame(INT16 mapoverride)
 		Y_EndVote();
 	G_SetGamestate(GS_NULL); // should be changed in P_UnArchiveMisc
 
-	P_UnArchiveSPGame(mapoverride);
-	P_UnArchivePlayer();
+	P_UnArchiveSPGame(save, mapoverride);
+	P_UnArchivePlayer(save);
 
-	if (!P_UnArchiveLuabanksAndConsistency())
+	if (!P_UnArchiveLuabanksAndConsistency(save))
 		return false;
 
 	// Only do this after confirming savegame is ok
@@ -5199,31 +5192,31 @@ boolean P_LoadGame(INT16 mapoverride)
 	return true;
 }
 
-boolean P_LoadNetGame(boolean reloading)
+boolean P_LoadNetGame(savebuffer_t *save, boolean reloading)
 {
-	CV_LoadNetVars(&save_p);
+	CV_LoadNetVars(&save->p);
 
-	if (!P_NetUnArchiveMisc(reloading))
+	if (!P_NetUnArchiveMisc(save, reloading))
 		return false;
 
-	P_NetUnArchivePlayers();
+	P_NetUnArchivePlayers(save);
 
 	if (gamestate == GS_LEVEL)
 	{
-		P_NetUnArchiveWorld();
-		P_UnArchivePolyObjects();
-		P_NetUnArchiveThinkers();
-		P_NetUnArchiveSpecials();
-		P_NetUnArchiveColormaps();
-		P_NetUnArchiveTubeWaypoints();
-		P_NetUnArchiveWaypoints();
+		P_NetUnArchiveWorld(save);
+		P_UnArchivePolyObjects(save);
+		P_NetUnArchiveThinkers(save);
+		P_NetUnArchiveSpecials(save);
+		P_NetUnArchiveColormaps(save);
+		P_NetUnArchiveTubeWaypoints(save);
+		P_NetUnArchiveWaypoints(save);
 		P_RelinkPointers();
 		P_FinishMobjs();
 	}
 
-	LUA_UnArchive(&save_p);
+	LUA_UnArchive(&save->p, true);
 
-	P_NetUnArchiveRNG();
+	P_NetUnArchiveRNG(save);
 
 	// The precipitation would normally be spawned in P_SetupLevel, which is called by
 	// P_NetUnArchiveMisc above. However, that would place it up before P_NetUnArchiveThinkers,
@@ -5231,5 +5224,5 @@ boolean P_LoadNetGame(boolean reloading)
 	// precipitation when loading a netgame save. Instead, precip has to be spawned here.
 	// This is done in P_NetUnArchiveSpecials now.
 
-	return P_UnArchiveLuabanksAndConsistency();
+	return P_UnArchiveLuabanksAndConsistency(save);
 }
diff --git a/src/p_saveg.h b/src/p_saveg.h
index b7ca6527f..18e343509 100644
--- a/src/p_saveg.h
+++ b/src/p_saveg.h
@@ -21,10 +21,10 @@
 // Persistent storage/archiving.
 // These are the load / save game routines.
 
-void P_SaveGame(INT16 mapnum);
-void P_SaveNetGame(boolean resending);
-boolean P_LoadGame(INT16 mapoverride);
-boolean P_LoadNetGame(boolean reloading);
+void P_SaveGame(savebuffer_t *save, INT16 mapnum);
+void P_SaveNetGame(savebuffer_t *save, boolean resending);
+boolean P_LoadGame(savebuffer_t *save, INT16 mapoverride);
+boolean P_LoadNetGame(savebuffer_t *save, boolean reloading);
 
 mobj_t *P_FindNewPosition(UINT32 oldposition);
 
@@ -38,6 +38,11 @@ struct savedata_t
 };
 
 extern savedata_t savedata;
-extern UINT8 *save_p;
+
+struct savebuffer_t
+{
+	UINT8 *buffer;
+	UINT8 *p;
+};
 
 #endif
diff --git a/src/p_setup.c b/src/p_setup.c
index 61c2a9ec3..b32c5126c 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -722,12 +722,12 @@ void P_WriteThings(void)
 	const char * filename;
 	size_t i, length;
 	mapthing_t *mt;
-	UINT8 *savebuffer, *savebuf_p;
+	savebuffer_t save;
 	INT16 temp;
 
-	savebuf_p = savebuffer = (UINT8 *)malloc(nummapthings * sizeof (mapthing_t));
+	save.p = save.buffer = (UINT8 *)malloc(nummapthings * sizeof (mapthing_t));
 
-	if (!savebuf_p)
+	if (!save.p)
 	{
 		CONS_Alert(CONS_ERROR, M_GetText("No more free memory for thing writing!\n"));
 		return;
@@ -736,23 +736,23 @@ void P_WriteThings(void)
 	mt = mapthings;
 	for (i = 0; i < nummapthings; i++, mt++)
 	{
-		WRITEINT16(savebuf_p, mt->x);
-		WRITEINT16(savebuf_p, mt->y);
+		WRITEINT16(save.p, mt->x);
+		WRITEINT16(save.p, mt->y);
 
-		WRITEINT16(savebuf_p, mt->angle);
+		WRITEINT16(save.p, mt->angle);
 
 		temp = (INT16)(mt->type + ((INT16)mt->extrainfo << 12));
-		WRITEINT16(savebuf_p, temp);
-		WRITEUINT16(savebuf_p, mt->options);
+		WRITEINT16(save.p, temp);
+		WRITEUINT16(save.p, mt->options);
 	}
 
-	length = savebuf_p - savebuffer;
+	length = save.p - save.buffer;
 
 	filename = va("newthings-%s.lmp", G_BuildMapName(gamemap));
 
-	FIL_WriteFile(filename, savebuffer, length);
-	free(savebuffer);
-	savebuf_p = NULL;
+	FIL_WriteFile(filename, save.buffer, length);
+	free(save.buffer);
+	save.p = NULL;
 
 	CONS_Printf(M_GetText("%s saved.\n"), filename);
 }
diff --git a/src/typedef.h b/src/typedef.h
index 34c652f5e..c5c4cfc40 100644
--- a/src/typedef.h
+++ b/src/typedef.h
@@ -258,6 +258,7 @@ TYPEDEF (polyfadedata_t);
 
 // p_saveg.h
 TYPEDEF (savedata_t);
+TYPEDEF (savebuffer_t);
 
 // p_setup.h
 TYPEDEF (levelflat_t);