From 08a7fcbe8db5629a8dbd57602b8cd44dc9abe593 Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 20:26:57 +0100
Subject: [PATCH 01/11] Split off FOF archiving-related code into their own
 functions

---
 src/p_saveg.c | 173 +++++++++++++++++++++++++++-----------------------
 1 file changed, 93 insertions(+), 80 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index f6e31fc3a..15e11a27b 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -772,6 +772,95 @@ static void P_NetUnArchiveColormaps(void)
 #define LD_S2BOTTEX 0x04
 #define LD_S2MIDTEX 0x08
 
+#define FD_FLAGS 0x01
+#define FD_ALPHA 0x02
+
+// Check if any of the sector's FOFs differ from how they spawned
+static boolean CheckFFloorDiff(sector_t *ss)
+{
+	ffloor_t *rover;
+
+	for (rover = ss->ffloors; rover; rover = rover->next)
+	{
+		if (rover->flags != rover->spawnflags
+		|| rover->alpha != rover->spawnalpha)
+			{
+				return true; // we found an FOF that changed!
+				// don't bother checking for more, we do that later
+			}
+	}
+	return false;
+}
+
+// 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(UINT8 *put, sector_t *ss)
+{
+	size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
+	ffloor_t *rover;
+	UINT8 fflr_diff;
+	for (rover = ss->ffloors; rover; rover = rover->next)
+	{
+		fflr_diff = 0; // reset diff flags
+		if (rover->flags != rover->spawnflags)
+			fflr_diff |= FD_FLAGS;
+		if (rover->alpha != rover->spawnalpha)
+			fflr_diff |= FD_ALPHA;
+
+		if (fflr_diff)
+		{
+			WRITEUINT16(put, j); // save ffloor "number"
+			WRITEUINT8(put, fflr_diff);
+			if (fflr_diff & FD_FLAGS)
+				WRITEUINT32(put, rover->flags);
+			if (fflr_diff & FD_ALPHA)
+				WRITEINT16(put, rover->alpha);
+		}
+		j++;
+	}
+	WRITEUINT16(put, 0xffff);
+}
+
+static void UnArchiveFFloors(UINT8 *get, sector_t *ss)
+{
+	UINT16 j = 0; // number of current ffloor in loop
+	UINT16 fflr_i; // saved ffloor "number" of next modified ffloor
+	UINT16 fflr_diff; // saved ffloor diff
+	ffloor_t *rover;
+
+	rover = ss->ffloors;
+	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(get); // 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
+			break;
+		// should NEVER need to be checked
+		//if (rover == NULL)
+			//break;
+		if (j != fflr_i) // this ffloor was not modified
+		{
+			j++;
+			rover = rover->next;
+			continue;
+		}
+
+		fflr_diff = READUINT8(get);
+
+		if (fflr_diff & FD_FLAGS)
+			rover->flags = READUINT32(get);
+		if (fflr_diff & FD_ALPHA)
+			rover->alpha = READINT16(get);
+
+		fflr_i = READUINT16(get); // get next ffloor "number" ready
+
+		j++;
+		rover = rover->next;
+	}
+}
+
 //
 // P_NetArchiveWorld
 //
@@ -838,20 +927,8 @@ static void P_NetArchiveWorld(void)
 		if (ss->crumblestate)
 			diff3 |= SD_CRUMBLESTATE;
 
-		// Check if any of the sector's FOFs differ from how they spawned
-		if (ss->ffloors)
-		{
-			ffloor_t *rover;
-			for (rover = ss->ffloors; rover; rover = rover->next)
-			{
-				if (rover->flags != rover->spawnflags
-				|| rover->alpha != rover->spawnalpha)
-					{
-						diff |= SD_FFLOORS; // we found an FOF that changed!
-						break; // don't bother checking for more, we do that later
-					}
-			}
-		}
+		if (ss->ffloors && CheckFFloorDiff(ss))
+			diff |= SD_FFLOORS;
 
 		if (diff3)
 			diff2 |= SD_DIFF3;
@@ -906,35 +983,8 @@ static void P_NetArchiveWorld(void)
 					// returns existing index if already added, or appends to net_colormaps and returns new index
 			if (diff3 & SD_CRUMBLESTATE)
 				WRITEINT32(put, ss->crumblestate);
-
-			// 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
 			if (diff & SD_FFLOORS)
-			{
-				size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
-				ffloor_t *rover;
-				UINT8 fflr_diff;
-				for (rover = ss->ffloors; rover; rover = rover->next)
-				{
-					fflr_diff = 0; // reset diff flags
-					if (rover->flags != rover->spawnflags)
-						fflr_diff |= 1;
-					if (rover->alpha != rover->spawnalpha)
-						fflr_diff |= 2;
-
-					if (fflr_diff)
-					{
-						WRITEUINT16(put, j); // save ffloor "number"
-						WRITEUINT8(put, fflr_diff);
-						if (fflr_diff & 1)
-							WRITEUINT32(put, rover->flags);
-						if (fflr_diff & 2)
-							WRITEINT16(put, rover->alpha);
-					}
-					j++;
-				}
-				WRITEUINT16(put, 0xffff);
-			}
+				ArchiveFFloors(put, ss);
 		}
 	}
 
@@ -1114,44 +1164,7 @@ static void P_NetUnArchiveWorld(void)
 			sectors[i].crumblestate = READINT32(get);
 
 		if (diff & SD_FFLOORS)
-		{
-			UINT16 j = 0; // number of current ffloor in loop
-			UINT16 fflr_i; // saved ffloor "number" of next modified ffloor
-			UINT16 fflr_diff; // saved ffloor diff
-			ffloor_t *rover;
-
-			rover = sectors[i].ffloors;
-			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(get); // 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
-					break;
-				// should NEVER need to be checked
-				//if (rover == NULL)
-					//break;
-				if (j != fflr_i) // this ffloor was not modified
-				{
-					j++;
-					rover = rover->next;
-					continue;
-				}
-
-				fflr_diff = READUINT8(get);
-
-				if (fflr_diff & 1)
-					rover->flags = READUINT32(get);
-				if (fflr_diff & 2)
-					rover->alpha = READINT16(get);
-
-				fflr_i = READUINT16(get); // get next ffloor "number" ready
-
-				j++;
-				rover = rover->next;
-			}
-		}
+			UnArchiveFFloors(get, sectors[i]);
 	}
 
 	for (;;)

From 2d45decbb0de5964f86c5dfc57f9167b17f3a71a Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 20:28:01 +0100
Subject: [PATCH 02/11] remove statsec and statline as they appear to be
 entirely unused

---
 src/p_saveg.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index 15e11a27b..e5f6cc75d 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -867,7 +867,6 @@ static void UnArchiveFFloors(UINT8 *get, sector_t *ss)
 static void P_NetArchiveWorld(void)
 {
 	size_t i;
-	INT32 statsec = 0, statline = 0;
 	const line_t *li = lines;
 	const line_t *spawnli = spawnlines;
 	const side_t *si;
@@ -938,8 +937,6 @@ static void P_NetArchiveWorld(void)
 
 		if (diff)
 		{
-			statsec++;
-
 			WRITEUINT16(put, i);
 			WRITEUINT8(put, diff);
 			if (diff & SD_DIFF2)
@@ -1033,7 +1030,6 @@ static void P_NetArchiveWorld(void)
 
 		if (diff)
 		{
-			statline++;
 			WRITEINT16(put, i);
 			WRITEUINT8(put, diff);
 			if (diff & LD_DIFF2)

From c1d2b8301b064b30ef1f4ac0e7f079fc61b313cb Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 20:40:50 +0100
Subject: [PATCH 03/11] split sector/lines archiving-related code into their
 own functions too

---
 src/p_saveg.c | 242 +++++++++++++++++++++++++++-----------------------
 1 file changed, 133 insertions(+), 109 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index e5f6cc75d..860e3b86a 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -861,28 +861,13 @@ static void UnArchiveFFloors(UINT8 *get, sector_t *ss)
 	}
 }
 
-//
-// P_NetArchiveWorld
-//
-static void P_NetArchiveWorld(void)
+static void ArchiveSectors(UINT8 *put)
 {
 	size_t i;
-	const line_t *li = lines;
-	const line_t *spawnli = spawnlines;
-	const side_t *si;
-	const side_t *spawnsi;
-	UINT8 *put;
-
 	const sector_t *ss = sectors;
 	const sector_t *spawnss = spawnsectors;
 	UINT8 diff, diff2, diff3;
 
-	// initialize colormap vars because paranoia
-	ClearNetColormaps();
-
-	WRITEUINT32(save_p, ARCHIVEBLOCK_WORLD);
-	put = save_p;
-
 	for (i = 0; i < numsectors; i++, ss++, spawnss++)
 	{
 		diff = diff2 = diff3 = 0;
@@ -986,8 +971,90 @@ static void P_NetArchiveWorld(void)
 	}
 
 	WRITEUINT16(put, 0xffff);
+}
+
+static void UnArchiveSectors(UINT8 *get)
+{
+	UINT16 i;
+	UINT8 diff, diff2, diff3;
+	for (;;)
+	{
+		i = READUINT16(get);
+
+		if (i == 0xffff)
+			break;
+
+		if (i > numsectors)
+			I_Error("Invalid sector number %u from server (expected end at %s)", i, sizeu1(numsectors));
+
+		diff = READUINT8(get);
+		if (diff & SD_DIFF2)
+			diff2 = READUINT8(get);
+		else
+			diff2 = 0;
+		if (diff2 & SD_DIFF3)
+			diff3 = READUINT8(get);
+		else
+			diff3 = 0;
+
+		if (diff & SD_FLOORHT)
+			sectors[i].floorheight = READFIXED(get);
+		if (diff & SD_CEILHT)
+			sectors[i].ceilingheight = READFIXED(get);
+		if (diff & SD_FLOORPIC)
+		{
+			sectors[i].floorpic = P_AddLevelFlatRuntime((char *)get);
+			get += 8;
+		}
+		if (diff & SD_CEILPIC)
+		{
+			sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)get);
+			get += 8;
+		}
+		if (diff & SD_LIGHT)
+			sectors[i].lightlevel = READINT16(get);
+		if (diff & SD_SPECIAL)
+			sectors[i].special = READINT16(get);
+
+		if (diff2 & SD_FXOFFS)
+			sectors[i].floor_xoffs = READFIXED(get);
+		if (diff2 & SD_FYOFFS)
+			sectors[i].floor_yoffs = READFIXED(get);
+		if (diff2 & SD_CXOFFS)
+			sectors[i].ceiling_xoffs = READFIXED(get);
+		if (diff2 & SD_CYOFFS)
+			sectors[i].ceiling_yoffs = READFIXED(get);
+		if (diff2 & SD_FLOORANG)
+			sectors[i].floorpic_angle  = READANGLE(get);
+		if (diff2 & SD_CEILANG)
+			sectors[i].ceilingpic_angle = READANGLE(get);
+		if (diff2 & SD_TAG)
+			sectors[i].tag = READINT16(get); // DON'T use P_ChangeSectorTag
+		if (diff3 & SD_TAGLIST)
+		{
+			sectors[i].firsttag = READINT32(get);
+			sectors[i].nexttag = READINT32(get);
+		}
+
+		if (diff3 & SD_COLORMAP)
+			sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(get));
+		if (diff3 & SD_CRUMBLESTATE)
+			sectors[i].crumblestate = READINT32(get);
+
+		if (diff & SD_FFLOORS)
+			UnArchiveFFloors(get, sectors[i]);
+	}
+}
+
+static void ArchiveLines(UINT8 *put)
+{
+	size_t i;
+	const line_t *li = lines;
+	const line_t *spawnli = spawnlines;
+	const side_t *si;
+	const side_t *spawnsi;
+	UINT8 diff, diff2, diff3;
 
-	// do lines
 	for (i = 0; i < numlines; i++, spawnli++, li++)
 	{
 		diff = diff2 = diff3 = 0;
@@ -1063,106 +1130,15 @@ static void P_NetArchiveWorld(void)
 		}
 	}
 	WRITEUINT16(put, 0xffff);
-	R_ClearTextureNumCache(false);
-
-	save_p = put;
 }
 
-//
-// P_NetUnArchiveWorld
-//
-static void P_NetUnArchiveWorld(void)
+static void UnArchiveLines(UINT8 *get)
 {
 	UINT16 i;
 	line_t *li;
 	side_t *si;
-	UINT8 *get;
 	UINT8 diff, diff2, diff3;
 
-	if (READUINT32(save_p) != ARCHIVEBLOCK_WORLD)
-		I_Error("Bad $$$.sav at archive block World");
-
-	// initialize colormap vars because paranoia
-	ClearNetColormaps();
-
-	// count the level's ffloors so that colormap loading can have an upper limit
-	for (i = 0; i < numsectors; i++)
-	{
-		ffloor_t *rover;
-		for (rover = sectors[i].ffloors; rover; rover = rover->next)
-			num_ffloors++;
-	}
-
-	get = save_p;
-
-	for (;;)
-	{
-		i = READUINT16(get);
-
-		if (i == 0xffff)
-			break;
-
-		if (i > numsectors)
-			I_Error("Invalid sector number %u from server (expected end at %s)", i, sizeu1(numsectors));
-
-		diff = READUINT8(get);
-		if (diff & SD_DIFF2)
-			diff2 = READUINT8(get);
-		else
-			diff2 = 0;
-		if (diff2 & SD_DIFF3)
-			diff3 = READUINT8(get);
-		else
-			diff3 = 0;
-
-		if (diff & SD_FLOORHT)
-			sectors[i].floorheight = READFIXED(get);
-		if (diff & SD_CEILHT)
-			sectors[i].ceilingheight = READFIXED(get);
-		if (diff & SD_FLOORPIC)
-		{
-			sectors[i].floorpic = P_AddLevelFlatRuntime((char *)get);
-			get += 8;
-		}
-		if (diff & SD_CEILPIC)
-		{
-			sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)get);
-			get += 8;
-		}
-		if (diff & SD_LIGHT)
-			sectors[i].lightlevel = READINT16(get);
-		if (diff & SD_SPECIAL)
-			sectors[i].special = READINT16(get);
-
-		if (diff2 & SD_FXOFFS)
-			sectors[i].floor_xoffs = READFIXED(get);
-		if (diff2 & SD_FYOFFS)
-			sectors[i].floor_yoffs = READFIXED(get);
-		if (diff2 & SD_CXOFFS)
-			sectors[i].ceiling_xoffs = READFIXED(get);
-		if (diff2 & SD_CYOFFS)
-			sectors[i].ceiling_yoffs = READFIXED(get);
-		if (diff2 & SD_FLOORANG)
-			sectors[i].floorpic_angle  = READANGLE(get);
-		if (diff2 & SD_CEILANG)
-			sectors[i].ceilingpic_angle = READANGLE(get);
-		if (diff2 & SD_TAG)
-			sectors[i].tag = READINT16(get); // DON'T use P_ChangeSectorTag
-		if (diff3 & SD_TAGLIST)
-		{
-			sectors[i].firsttag = READINT32(get);
-			sectors[i].nexttag = READINT32(get);
-		}
-
-		if (diff3 & SD_COLORMAP)
-			sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(get));
-		if (diff3 & SD_CRUMBLESTATE)
-			sectors[i].crumblestate = READINT32(get);
-
-		if (diff & SD_FFLOORS)
-			UnArchiveFFloors(get, sectors[i]);
-	}
-
 	for (;;)
 	{
 		i = READUINT16(get);
@@ -1209,6 +1185,54 @@ static void P_NetUnArchiveWorld(void)
 		if (diff2 & LD_S2MIDTEX)
 			si->midtexture = READINT32(get);
 	}
+}
+
+//
+// P_NetArchiveWorld
+//
+static void P_NetArchiveWorld(void)
+{
+	UINT8 *put;
+
+	// initialize colormap vars because paranoia
+	ClearNetColormaps();
+
+	WRITEUINT32(save_p, ARCHIVEBLOCK_WORLD);
+	put = save_p;
+
+	ArchiveSectors(put);
+	ArchiveLines(put);
+	R_ClearTextureNumCache(false);
+
+	save_p = put;
+}
+
+//
+// P_NetUnArchiveWorld
+//
+static void P_NetUnArchiveWorld(void)
+{
+	UINT16 i;
+	UINT8 *get;
+
+	if (READUINT32(save_p) != ARCHIVEBLOCK_WORLD)
+		I_Error("Bad $$$.sav at archive block World");
+
+	// initialize colormap vars because paranoia
+	ClearNetColormaps();
+
+	// count the level's ffloors so that colormap loading can have an upper limit
+	for (i = 0; i < numsectors; i++)
+	{
+		ffloor_t *rover;
+		for (rover = sectors[i].ffloors; rover; rover = rover->next)
+			num_ffloors++;
+	}
+
+	get = save_p;
+
+	UnArchiveSectors(get);
+	UnArchiveLines(get);
 
 	save_p = get;
 }

From 1e61229cb7fe76961a89b18f85f49124b10ab0ef Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 20:57:48 +0100
Subject: [PATCH 04/11] we don't actually need put/get pointers at all (plus
 with everything put into functions they wouldn't work properly anyway)

---
 src/p_saveg.c | 202 ++++++++++++++++++++++++--------------------------
 1 file changed, 96 insertions(+), 106 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index 860e3b86a..e2bc9dd61 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -794,7 +794,7 @@ static boolean CheckFFloorDiff(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(UINT8 *put, sector_t *ss)
+static void ArchiveFFloors(sector_t *ss)
 {
 	size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
 	ffloor_t *rover;
@@ -809,19 +809,19 @@ static void ArchiveFFloors(UINT8 *put, sector_t *ss)
 
 		if (fflr_diff)
 		{
-			WRITEUINT16(put, j); // save ffloor "number"
-			WRITEUINT8(put, fflr_diff);
+			WRITEUINT16(save_p, j); // save ffloor "number"
+			WRITEUINT8(save_p, fflr_diff);
 			if (fflr_diff & FD_FLAGS)
-				WRITEUINT32(put, rover->flags);
+				WRITEUINT32(save_p, rover->flags);
 			if (fflr_diff & FD_ALPHA)
-				WRITEINT16(put, rover->alpha);
+				WRITEINT16(save_p, rover->alpha);
 		}
 		j++;
 	}
-	WRITEUINT16(put, 0xffff);
+	WRITEUINT16(save_p, 0xffff);
 }
 
-static void UnArchiveFFloors(UINT8 *get, sector_t *ss)
+static void UnArchiveFFloors(sector_t *ss)
 {
 	UINT16 j = 0; // number of current ffloor in loop
 	UINT16 fflr_i; // saved ffloor "number" of next modified ffloor
@@ -832,7 +832,7 @@ static void UnArchiveFFloors(UINT8 *get, 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(get); // 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
@@ -847,21 +847,21 @@ static void UnArchiveFFloors(UINT8 *get, sector_t *ss)
 			continue;
 		}
 
-		fflr_diff = READUINT8(get);
+		fflr_diff = READUINT8(save_p);
 
 		if (fflr_diff & FD_FLAGS)
-			rover->flags = READUINT32(get);
+			rover->flags = READUINT32(save_p);
 		if (fflr_diff & FD_ALPHA)
-			rover->alpha = READINT16(get);
+			rover->alpha = READINT16(save_p);
 
-		fflr_i = READUINT16(get); // get next ffloor "number" ready
+		fflr_i = READUINT16(save_p); // get next ffloor "number" ready
 
 		j++;
 		rover = rover->next;
 	}
 }
 
-static void ArchiveSectors(UINT8 *put)
+static void ArchiveSectors(void)
 {
 	size_t i;
 	const sector_t *ss = sectors;
@@ -922,64 +922,64 @@ static void ArchiveSectors(UINT8 *put)
 
 		if (diff)
 		{
-			WRITEUINT16(put, i);
-			WRITEUINT8(put, diff);
+			WRITEUINT16(save_p, i);
+			WRITEUINT8(save_p, diff);
 			if (diff & SD_DIFF2)
-				WRITEUINT8(put, diff2);
+				WRITEUINT8(save_p, diff2);
 			if (diff2 & SD_DIFF3)
-				WRITEUINT8(put, diff3);
+				WRITEUINT8(save_p, diff3);
 			if (diff & SD_FLOORHT)
-				WRITEFIXED(put, ss->floorheight);
+				WRITEFIXED(save_p, ss->floorheight);
 			if (diff & SD_CEILHT)
-				WRITEFIXED(put, ss->ceilingheight);
+				WRITEFIXED(save_p, ss->ceilingheight);
 			if (diff & SD_FLOORPIC)
-				WRITEMEM(put, levelflats[ss->floorpic].name, 8);
+				WRITEMEM(save_p, levelflats[ss->floorpic].name, 8);
 			if (diff & SD_CEILPIC)
-				WRITEMEM(put, levelflats[ss->ceilingpic].name, 8);
+				WRITEMEM(save_p, levelflats[ss->ceilingpic].name, 8);
 			if (diff & SD_LIGHT)
-				WRITEINT16(put, ss->lightlevel);
+				WRITEINT16(save_p, ss->lightlevel);
 			if (diff & SD_SPECIAL)
-				WRITEINT16(put, ss->special);
+				WRITEINT16(save_p, ss->special);
 			if (diff2 & SD_FXOFFS)
-				WRITEFIXED(put, ss->floor_xoffs);
+				WRITEFIXED(save_p, ss->floor_xoffs);
 			if (diff2 & SD_FYOFFS)
-				WRITEFIXED(put, ss->floor_yoffs);
+				WRITEFIXED(save_p, ss->floor_yoffs);
 			if (diff2 & SD_CXOFFS)
-				WRITEFIXED(put, ss->ceiling_xoffs);
+				WRITEFIXED(save_p, ss->ceiling_xoffs);
 			if (diff2 & SD_CYOFFS)
-				WRITEFIXED(put, ss->ceiling_yoffs);
+				WRITEFIXED(save_p, ss->ceiling_yoffs);
 			if (diff2 & SD_FLOORANG)
-				WRITEANGLE(put, ss->floorpic_angle);
+				WRITEANGLE(save_p, ss->floorpic_angle);
 			if (diff2 & SD_CEILANG)
-				WRITEANGLE(put, ss->ceilingpic_angle);
+				WRITEANGLE(save_p, ss->ceilingpic_angle);
 			if (diff2 & SD_TAG) // save only the tag
-				WRITEINT16(put, ss->tag);
+				WRITEINT16(save_p, ss->tag);
 			if (diff3 & SD_TAGLIST) // save both firsttag and nexttag
 			{ // either of these could be changed even if tag isn't
-				WRITEINT32(put, ss->firsttag);
-				WRITEINT32(put, ss->nexttag);
+				WRITEINT32(save_p, ss->firsttag);
+				WRITEINT32(save_p, ss->nexttag);
 			}
 
 			if (diff3 & SD_COLORMAP)
-				WRITEUINT32(put, 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(put, ss->crumblestate);
+				WRITEINT32(save_p, ss->crumblestate);
 			if (diff & SD_FFLOORS)
-				ArchiveFFloors(put, ss);
+				ArchiveFFloors(save_p, ss);
 		}
 	}
 
-	WRITEUINT16(put, 0xffff);
+	WRITEUINT16(save_p, 0xffff);
 }
 
-static void UnArchiveSectors(UINT8 *get)
+static void UnArchiveSectors(void)
 {
 	UINT16 i;
 	UINT8 diff, diff2, diff3;
 	for (;;)
 	{
-		i = READUINT16(get);
+		i = READUINT16(save_p);
 
 		if (i == 0xffff)
 			break;
@@ -987,66 +987,66 @@ static void UnArchiveSectors(UINT8 *get)
 		if (i > numsectors)
 			I_Error("Invalid sector number %u from server (expected end at %s)", i, sizeu1(numsectors));
 
-		diff = READUINT8(get);
+		diff = READUINT8(save_p);
 		if (diff & SD_DIFF2)
-			diff2 = READUINT8(get);
+			diff2 = READUINT8(save_p);
 		else
 			diff2 = 0;
 		if (diff2 & SD_DIFF3)
-			diff3 = READUINT8(get);
+			diff3 = READUINT8(save_p);
 		else
 			diff3 = 0;
 
 		if (diff & SD_FLOORHT)
-			sectors[i].floorheight = READFIXED(get);
+			sectors[i].floorheight = READFIXED(save_p);
 		if (diff & SD_CEILHT)
-			sectors[i].ceilingheight = READFIXED(get);
+			sectors[i].ceilingheight = READFIXED(save_p);
 		if (diff & SD_FLOORPIC)
 		{
-			sectors[i].floorpic = P_AddLevelFlatRuntime((char *)get);
-			get += 8;
+			sectors[i].floorpic = P_AddLevelFlatRuntime((char *)save_p);
+			save_p += 8;
 		}
 		if (diff & SD_CEILPIC)
 		{
-			sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)get);
-			get += 8;
+			sectors[i].ceilingpic = P_AddLevelFlatRuntime((char *)save_p);
+			save_p += 8;
 		}
 		if (diff & SD_LIGHT)
-			sectors[i].lightlevel = READINT16(get);
+			sectors[i].lightlevel = READINT16(save_p);
 		if (diff & SD_SPECIAL)
-			sectors[i].special = READINT16(get);
+			sectors[i].special = READINT16(save_p);
 
 		if (diff2 & SD_FXOFFS)
-			sectors[i].floor_xoffs = READFIXED(get);
+			sectors[i].floor_xoffs = READFIXED(save_p);
 		if (diff2 & SD_FYOFFS)
-			sectors[i].floor_yoffs = READFIXED(get);
+			sectors[i].floor_yoffs = READFIXED(save_p);
 		if (diff2 & SD_CXOFFS)
-			sectors[i].ceiling_xoffs = READFIXED(get);
+			sectors[i].ceiling_xoffs = READFIXED(save_p);
 		if (diff2 & SD_CYOFFS)
-			sectors[i].ceiling_yoffs = READFIXED(get);
+			sectors[i].ceiling_yoffs = READFIXED(save_p);
 		if (diff2 & SD_FLOORANG)
-			sectors[i].floorpic_angle  = READANGLE(get);
+			sectors[i].floorpic_angle  = READANGLE(save_p);
 		if (diff2 & SD_CEILANG)
-			sectors[i].ceilingpic_angle = READANGLE(get);
+			sectors[i].ceilingpic_angle = READANGLE(save_p);
 		if (diff2 & SD_TAG)
-			sectors[i].tag = READINT16(get); // DON'T use P_ChangeSectorTag
+			sectors[i].tag = READINT16(save_p); // DON'T use P_ChangeSectorTag
 		if (diff3 & SD_TAGLIST)
 		{
-			sectors[i].firsttag = READINT32(get);
-			sectors[i].nexttag = READINT32(get);
+			sectors[i].firsttag = READINT32(save_p);
+			sectors[i].nexttag = READINT32(save_p);
 		}
 
 		if (diff3 & SD_COLORMAP)
-			sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(get));
+			sectors[i].extra_colormap = GetNetColormapFromList(READUINT32(save_p));
 		if (diff3 & SD_CRUMBLESTATE)
-			sectors[i].crumblestate = READINT32(get);
+			sectors[i].crumblestate = READINT32(save_p);
 
 		if (diff & SD_FFLOORS)
-			UnArchiveFFloors(get, sectors[i]);
+			UnArchiveFFloors(save_p, sectors[i]);
 	}
 }
 
-static void ArchiveLines(UINT8 *put)
+static void ArchiveLines(void)
 {
 	size_t i;
 	const line_t *li = lines;
@@ -1097,42 +1097,42 @@ static void ArchiveLines(UINT8 *put)
 
 		if (diff)
 		{
-			WRITEINT16(put, i);
-			WRITEUINT8(put, diff);
+			WRITEINT16(save_p, i);
+			WRITEUINT8(save_p, diff);
 			if (diff & LD_DIFF2)
-				WRITEUINT8(put, diff2);
+				WRITEUINT8(save_p, diff2);
 			if (diff & LD_FLAG)
-				WRITEINT16(put, li->flags);
+				WRITEINT16(save_p, li->flags);
 			if (diff & LD_SPECIAL)
-				WRITEINT16(put, li->special);
+				WRITEINT16(save_p, li->special);
 			if (diff & LD_CLLCOUNT)
-				WRITEINT16(put, li->callcount);
+				WRITEINT16(save_p, li->callcount);
 
 			si = &sides[li->sidenum[0]];
 			if (diff & LD_S1TEXOFF)
-				WRITEFIXED(put, si->textureoffset);
+				WRITEFIXED(save_p, si->textureoffset);
 			if (diff & LD_S1TOPTEX)
-				WRITEINT32(put, si->toptexture);
+				WRITEINT32(save_p, si->toptexture);
 			if (diff & LD_S1BOTTEX)
-				WRITEINT32(put, si->bottomtexture);
+				WRITEINT32(save_p, si->bottomtexture);
 			if (diff & LD_S1MIDTEX)
-				WRITEINT32(put, si->midtexture);
+				WRITEINT32(save_p, si->midtexture);
 
 			si = &sides[li->sidenum[1]];
 			if (diff2 & LD_S2TEXOFF)
-				WRITEFIXED(put, si->textureoffset);
+				WRITEFIXED(save_p, si->textureoffset);
 			if (diff2 & LD_S2TOPTEX)
-				WRITEINT32(put, si->toptexture);
+				WRITEINT32(save_p, si->toptexture);
 			if (diff2 & LD_S2BOTTEX)
-				WRITEINT32(put, si->bottomtexture);
+				WRITEINT32(save_p, si->bottomtexture);
 			if (diff2 & LD_S2MIDTEX)
-				WRITEINT32(put, si->midtexture);
+				WRITEINT32(save_p, si->midtexture);
 		}
 	}
-	WRITEUINT16(put, 0xffff);
+	WRITEUINT16(save_p, 0xffff);
 }
 
-static void UnArchiveLines(UINT8 *get)
+static void UnArchiveLines(void)
 {
 	UINT16 i;
 	line_t *li;
@@ -1141,49 +1141,49 @@ static void UnArchiveLines(UINT8 *get)
 
 	for (;;)
 	{
-		i = READUINT16(get);
+		i = READUINT16(save_p);
 
 		if (i == 0xffff)
 			break;
 		if (i > numlines)
 			I_Error("Invalid line number %u from server", i);
 
-		diff = READUINT8(get);
+		diff = READUINT8(save_p);
 		li = &lines[i];
 
 		if (diff & LD_DIFF2)
-			diff2 = READUINT8(get);
+			diff2 = READUINT8(save_p);
 		else
 			diff2 = 0;
 
 		diff3 = 0;
 
 		if (diff & LD_FLAG)
-			li->flags = READINT16(get);
+			li->flags = READINT16(save_p);
 		if (diff & LD_SPECIAL)
-			li->special = READINT16(get);
+			li->special = READINT16(save_p);
 		if (diff & LD_CLLCOUNT)
-			li->callcount = READINT16(get);
+			li->callcount = READINT16(save_p);
 
 		si = &sides[li->sidenum[0]];
 		if (diff & LD_S1TEXOFF)
-			si->textureoffset = READFIXED(get);
+			si->textureoffset = READFIXED(save_p);
 		if (diff & LD_S1TOPTEX)
-			si->toptexture = READINT32(get);
+			si->toptexture = READINT32(save_p);
 		if (diff & LD_S1BOTTEX)
-			si->bottomtexture = READINT32(get);
+			si->bottomtexture = READINT32(save_p);
 		if (diff & LD_S1MIDTEX)
-			si->midtexture = READINT32(get);
+			si->midtexture = READINT32(save_p);
 
 		si = &sides[li->sidenum[1]];
 		if (diff2 & LD_S2TEXOFF)
-			si->textureoffset = READFIXED(get);
+			si->textureoffset = READFIXED(save_p);
 		if (diff2 & LD_S2TOPTEX)
-			si->toptexture = READINT32(get);
+			si->toptexture = READINT32(save_p);
 		if (diff2 & LD_S2BOTTEX)
-			si->bottomtexture = READINT32(get);
+			si->bottomtexture = READINT32(save_p);
 		if (diff2 & LD_S2MIDTEX)
-			si->midtexture = READINT32(get);
+			si->midtexture = READINT32(save_p);
 	}
 }
 
@@ -1192,19 +1192,14 @@ static void UnArchiveLines(UINT8 *get)
 //
 static void P_NetArchiveWorld(void)
 {
-	UINT8 *put;
-
 	// initialize colormap vars because paranoia
 	ClearNetColormaps();
 
 	WRITEUINT32(save_p, ARCHIVEBLOCK_WORLD);
-	put = save_p;
 
-	ArchiveSectors(put);
-	ArchiveLines(put);
+	ArchiveSectors();
+	ArchiveLines();
 	R_ClearTextureNumCache(false);
-
-	save_p = put;
 }
 
 //
@@ -1213,7 +1208,6 @@ static void P_NetArchiveWorld(void)
 static void P_NetUnArchiveWorld(void)
 {
 	UINT16 i;
-	UINT8 *get;
 
 	if (READUINT32(save_p) != ARCHIVEBLOCK_WORLD)
 		I_Error("Bad $$$.sav at archive block World");
@@ -1229,12 +1223,8 @@ static void P_NetUnArchiveWorld(void)
 			num_ffloors++;
 	}
 
-	get = save_p;
-
-	UnArchiveSectors(get);
-	UnArchiveLines(get);
-
-	save_p = get;
+	UnArchiveSectors();
+	UnArchiveLines();
 }
 
 //

From e406a7bef5b029dc49b8861f89557644f8649c2c Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 20:58:38 +0100
Subject: [PATCH 05/11] no diff3 needed for line archiving

---
 src/p_saveg.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index e2bc9dd61..541b42426 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -1053,11 +1053,11 @@ static void ArchiveLines(void)
 	const line_t *spawnli = spawnlines;
 	const side_t *si;
 	const side_t *spawnsi;
-	UINT8 diff, diff2, diff3;
+	UINT8 diff, diff2; // no diff3
 
 	for (i = 0; i < numlines; i++, spawnli++, li++)
 	{
-		diff = diff2 = diff3 = 0;
+		diff = diff2 = 0;
 
 		if (li->special != spawnli->special)
 			diff |= LD_SPECIAL;
@@ -1137,7 +1137,7 @@ static void UnArchiveLines(void)
 	UINT16 i;
 	line_t *li;
 	side_t *si;
-	UINT8 diff, diff2, diff3;
+	UINT8 diff, diff2; // no diff3
 
 	for (;;)
 	{
@@ -1156,8 +1156,6 @@ static void UnArchiveLines(void)
 		else
 			diff2 = 0;
 
-		diff3 = 0;
-
 		if (diff & LD_FLAG)
 			li->flags = READINT16(save_p);
 		if (diff & LD_SPECIAL)

From 7dda5f6b946079925e86f83325c0889a16e842d3 Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 22:29:41 +0100
Subject: [PATCH 06/11] created P_GetFFloorID to get an "ID" of an FOF in its
 target sector (an opposite to P_GetFFloorByID you could say!), rewrote
 floor/ceiling rover archiving code to use both P_GetFFloorID and
 P_GetFFloorByID

---
 src/p_saveg.c | 66 ++++++++-------------------------------------------
 src/p_spec.c  | 31 +++++++++++++++++++++++-
 src/p_spec.h  |  1 +
 3 files changed, 41 insertions(+), 57 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index 541b42426..e63409386 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -1518,42 +1518,14 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
 
 	if (diff2 & MD2_FLOORROVER)
 	{
-		ffloor_t *rover;
-		size_t i = 0;
-		UINT32 roverindex = 0;
-
-		for (rover = mobj->floorrover->target->ffloors; rover; rover = rover->next)
-		{
-			if (rover == mobj->floorrover)
-			{
-				roverindex = i;
-				break;
-			}
-			i++;
-		}
-
-		WRITEUINT32(save_p, (UINT32)(mobj->floorrover->target - sectors));
-		WRITEUINT32(save_p, rover ? roverindex : i); // store max index to denote invalid ffloor ref
+		WRITEUINT32(save_p, SaveSector(mobj->floorrover->target));
+		WRITEUINT16(save_p, P_GetFFloorID(mobj->floorrover));
 	}
 
 	if (diff2 & MD2_CEILINGROVER)
 	{
-		ffloor_t *rover;
-		size_t i = 0;
-		UINT32 roverindex = 0;
-
-		for (rover = mobj->ceilingrover->target->ffloors; rover; rover = rover->next)
-		{
-			if (rover == mobj->ceilingrover)
-			{
-				roverindex = i;
-				break;
-			}
-			i++;
-		}
-
-		WRITEUINT32(save_p, (UINT32)(mobj->ceilingrover->target - sectors));
-		WRITEUINT32(save_p, rover ? roverindex : i); // store max index to denote invalid ffloor ref
+		WRITEUINT32(save_p, SaveSector(mobj->ceilingrover->target));
+		WRITEUINT16(save_p, P_GetFFloorID(mobj->ceilingrover));
 	}
 
 	if (diff & MD_SPAWNPOINT)
@@ -2634,34 +2606,16 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 
 	if (diff2 & MD2_FLOORROVER)
 	{
-		size_t floor_sectornum = (size_t)READUINT32(save_p);
-		size_t floor_rovernum = (size_t)READUINT32(save_p);
-		ffloor_t *rover = NULL;
-		size_t rovernum = 0;
-
-		for (rover = sectors[floor_sectornum].ffloors; rover; rover = rover->next)
-		{
-			if (rovernum == floor_rovernum)
-				break;
-			rovernum++;
-		}
-		floorrover = rover;
+		sector_t *sec = LoadSector(READUINT32(save_p));
+		UINT16 id = READUINT16(save_p);
+		floorrover = P_GetFFloorByID(sec, id);
 	}
 
 	if (diff2 & MD2_CEILINGROVER)
 	{
-		size_t ceiling_sectornum = (size_t)READUINT32(save_p);
-		size_t ceiling_rovernum = (size_t)READUINT32(save_p);
-		ffloor_t *rover = NULL;
-		size_t rovernum = 0;
-
-		for (rover = sectors[ceiling_sectornum].ffloors; rover; rover = rover->next)
-		{
-			if (rovernum == ceiling_rovernum)
-				break;
-			rovernum++;
-		}
-		ceilingrover = rover;
+		sector_t *sec = LoadSector(READUINT32(save_p));
+		UINT16 id = READUINT16(save_p);
+		ceilingrover = P_GetFFloorByID(sec, id);
 	}
 
 	if (diff & MD_SPAWNPOINT)
diff --git a/src/p_spec.c b/src/p_spec.c
index 6456cc514..96ae5522b 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -5678,6 +5678,35 @@ void P_UpdateSpecials(void)
 	}
 }
 
+//
+// Floor over floors (FOFs), 3Dfloors, 3Dblocks, fake floors (ffloors), rovers, or whatever you want to call them
+//
+
+/** Gets the ID number for a 3Dfloor in its target sector.
+  *
+  * \param fflr The 3Dfloor we want an ID for.
+  * \return ID of 3Dfloor in target sector. Note that the first FOF's ID is 0. UINT16_MAX is given if invalid.
+  * \sa P_GetFFloorByID
+  */
+UINT16 P_GetFFloorID(ffloor_t *fflr)
+{
+	ffloor_t *rover;
+	sector_t *sec;
+	UINT16 i = 0;
+
+	if (!rover)
+		return UINT16_MAX;
+
+	sec = rover->target;
+
+	if (!sec->ffloors)
+		return UINT16_MAX;
+	for (rover = sec->ffloors; rover; rover = rover->next, i++)
+		if (rover == fflr)
+			return i;
+	return UINT16_MAX;
+}
+
 /** Gets a 3Dfloor by control sector.
   *
   * \param sec  Target sector.
@@ -5702,7 +5731,7 @@ static inline ffloor_t *P_GetFFloorBySec(sector_t *sec, sector_t *sec2)
   * \param sec Target sector.
   * \param id  ID of 3Dfloor in target sector. Note that the first FOF's ID is 0.
   * \return Pointer to found 3Dfloor, or NULL.
-  * \sa P_GetFFloorBySec
+  * \sa P_GetFFloorBySec, P_GetFFloorID
   */
 ffloor_t *P_GetFFloorByID(sector_t *sec, UINT16 id)
 {
diff --git a/src/p_spec.h b/src/p_spec.h
index e243e3a61..8e778b9ed 100644
--- a/src/p_spec.h
+++ b/src/p_spec.h
@@ -74,6 +74,7 @@ void P_RunDeNightserizeExecutors(mobj_t *actor);
 void P_RunNightsLapExecutors(mobj_t *actor);
 void P_RunNightsCapsuleTouchExecutors(mobj_t *actor, boolean entering, boolean enoughspheres);
 
+UINT16 P_GetFFloorID(ffloor_t *fflr);
 ffloor_t *P_GetFFloorByID(sector_t *sec, UINT16 id);
 
 //

From 49cceda15bce75c0c54301c8747e413ee3f436e0 Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Fri, 24 Apr 2020 22:43:23 +0100
Subject: [PATCH 07/11] Do the same with writing ARCH_FFLOOR values in Lua
 archiving code (reading was already dealt with years ago)

---
 src/lua_script.c | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/lua_script.c b/src/lua_script.c
index 7adf62fcc..6b7b122f0 100644
--- a/src/lua_script.c
+++ b/src/lua_script.c
@@ -1010,16 +1010,8 @@ static UINT8 ArchiveValue(int TABLESINDEX, int myindex)
 			if (!rover)
 				WRITEUINT8(save_p, ARCH_NULL);
 			else {
-				ffloor_t *r2;
-				UINT16 i = 0;
-				// search for id
-				for (r2 = rover->target->ffloors; r2; r2 = r2->next)
-				{
-					if (r2 == rover)
-						break;
-					i++;
-				}
-				if (!r2)
+				UINT16 i = P_GetFFloorID(rover);
+				if (i == UINT16_MAX) // invalid ID
 					WRITEUINT8(save_p, ARCH_NULL);
 				else
 				{

From 049a7db877ce52b08981137ea435f2cb3c3df361 Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Sat, 25 Apr 2020 16:52:11 +0100
Subject: [PATCH 08/11] whoops

---
 src/p_spec.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/p_spec.c b/src/p_spec.c
index 96ae5522b..f15741479 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -5694,7 +5694,7 @@ UINT16 P_GetFFloorID(ffloor_t *fflr)
 	sector_t *sec;
 	UINT16 i = 0;
 
-	if (!rover)
+	if (!fflr)
 		return UINT16_MAX;
 
 	sec = rover->target;

From 7034e2537a9db7024b26dc85b78a93c8fe1eb728 Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Sat, 25 Apr 2020 16:53:52 +0100
Subject: [PATCH 09/11] whoops the sequel

---
 src/p_spec.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/p_spec.c b/src/p_spec.c
index f15741479..e84619c7f 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -5697,7 +5697,7 @@ UINT16 P_GetFFloorID(ffloor_t *fflr)
 	if (!fflr)
 		return UINT16_MAX;
 
-	sec = rover->target;
+	sec = fflr->target;
 
 	if (!sec->ffloors)
 		return UINT16_MAX;

From d89d2505bb64c82c5e5192149aed0e5066006a3e Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Wed, 29 Apr 2020 14:45:52 +0100
Subject: [PATCH 10/11] Whoops the third

---
 src/p_saveg.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index e63409386..239fa47df 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -966,7 +966,7 @@ static void ArchiveSectors(void)
 			if (diff3 & SD_CRUMBLESTATE)
 				WRITEINT32(save_p, ss->crumblestate);
 			if (diff & SD_FFLOORS)
-				ArchiveFFloors(save_p, ss);
+				ArchiveFFloors(ss);
 		}
 	}
 
@@ -1042,7 +1042,7 @@ static void UnArchiveSectors(void)
 			sectors[i].crumblestate = READINT32(save_p);
 
 		if (diff & SD_FFLOORS)
-			UnArchiveFFloors(save_p, sectors[i]);
+			UnArchiveFFloors(sectors[i]);
 	}
 }
 

From 2f0bf3860f1ba456c9b2f5ef3d975fd19c2289d5 Mon Sep 17 00:00:00 2001
From: Monster Iestyn <iestynjealous@ntlworld.com>
Date: Wed, 29 Apr 2020 15:24:28 +0100
Subject: [PATCH 11/11] Don't discard const, added missing &

---
 src/p_saveg.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/p_saveg.c b/src/p_saveg.c
index 239fa47df..aee160859 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -776,7 +776,7 @@ static void P_NetUnArchiveColormaps(void)
 #define FD_ALPHA 0x02
 
 // Check if any of the sector's FOFs differ from how they spawned
-static boolean CheckFFloorDiff(sector_t *ss)
+static boolean CheckFFloorDiff(const sector_t *ss)
 {
 	ffloor_t *rover;
 
@@ -794,7 +794,7 @@ static boolean CheckFFloorDiff(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(sector_t *ss)
+static void ArchiveFFloors(const sector_t *ss)
 {
 	size_t j = 0; // ss->ffloors is saved as ffloor #0, ss->ffloors->next is #1, etc
 	ffloor_t *rover;
@@ -821,7 +821,7 @@ static void ArchiveFFloors(sector_t *ss)
 	WRITEUINT16(save_p, 0xffff);
 }
 
-static void UnArchiveFFloors(sector_t *ss)
+static void UnArchiveFFloors(const sector_t *ss)
 {
 	UINT16 j = 0; // number of current ffloor in loop
 	UINT16 fflr_i; // saved ffloor "number" of next modified ffloor
@@ -1042,7 +1042,7 @@ static void UnArchiveSectors(void)
 			sectors[i].crumblestate = READINT32(save_p);
 
 		if (diff & SD_FFLOORS)
-			UnArchiveFFloors(sectors[i]);
+			UnArchiveFFloors(&sectors[i]);
 	}
 }