From 24f8d4ef519a8541e24df3b47a2c9293d053ff11 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Mon, 23 Dec 2019 21:17:12 +0100
Subject: [PATCH 01/10] Made a mapthing-independent version of
 P_GetMobjSpawnHeight so P_SpawnHoopsAndRings subfunctions can use it instead
 of duplicating code.

---
 src/p_mobj.c | 144 +++++++++++++++++----------------------------------
 1 file changed, 48 insertions(+), 96 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 1acecbb76..54e603fe9 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -11559,10 +11559,39 @@ void P_MovePlayerToStarpost(INT32 playernum)
 mapthing_t *huntemeralds[MAXHUNTEMERALDS];
 INT32 numhuntemeralds;
 
-
-static fixed_t P_GetMobjSpawnHeight(const mobjtype_t mobjtype, const mapthing_t* mthing, const fixed_t x, const fixed_t y)
+static fixed_t P_GetMobjSpawnHeight(const mobjtype_t mobjtype, const fixed_t x, const fixed_t y, const fixed_t offset, const boolean flip)
 {
 	const subsector_t *ss = R_PointInSubsector(x, y);
+
+	// Axis objects snap to the floor.
+	if (mobjtype == MT_AXIS || mobjtype == MT_AXISTRANSFER || mobjtype == MT_AXISTRANSFERLINE)
+		return ONFLOORZ;
+
+	if (!offset) // Snap to the surfaces when there's no offset set.
+	{
+		if (flip)
+			return ONCEILINGZ;
+		else
+			return ONFLOORZ;
+	}
+
+	// Establish height.
+	if (flip)
+		return (
+#ifdef ESLOPE
+			ss->sector->c_slope ? P_GetZAt(ss->sector->c_slope, x, y) :
+#endif
+			ss->sector->ceilingheight) - offset - mobjinfo[mobjtype].height;
+	else
+		return (
+#ifdef ESLOPE
+			ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
+#endif
+			ss->sector->floorheight) + offset;
+}
+
+static fixed_t P_GetMapThingSpawnHeight(const mobjtype_t mobjtype, const mapthing_t* mthing, const fixed_t x, const fixed_t y)
+{
 	fixed_t offset = mthing->z << FRACBITS;
 	boolean flip = (!!(mobjinfo[mobjtype].flags & MF_SPAWNCEILING) ^ !!(mthing->options & MTF_OBJECTFLIP));
 
@@ -11573,12 +11602,6 @@ static fixed_t P_GetMobjSpawnHeight(const mobjtype_t mobjtype, const mapthing_t*
 		flip = false;
 		break;
 
-	// Axis objects snap to the floor.
-	case MT_AXIS:
-	case MT_AXISTRANSFER:
-	case MT_AXISTRANSFERLINE:
-		return ONFLOORZ;
-
 	// Objects with a non-zero default height.
 	case MT_CRAWLACOMMANDER:
 	case MT_DETON:
@@ -11626,27 +11649,7 @@ static fixed_t P_GetMobjSpawnHeight(const mobjtype_t mobjtype, const mapthing_t*
 			offset += mthing->options & MTF_AMBUSH ? 24*FRACUNIT : 0;
 	}
 
-	if (!offset) // Snap to the surfaces when there's no offset set.
-	{
-		if (flip)
-			return ONCEILINGZ;
-		else
-			return ONFLOORZ;
-	}
-
-	// Establish height.
-	if (flip)
-		return (
-#ifdef ESLOPE
-			ss->sector->c_slope ? P_GetZAt(ss->sector->c_slope, x, y) :
-#endif
-			ss->sector->ceilingheight) - offset - mobjinfo[mobjtype].height;
-	else
-		return (
-#ifdef ESLOPE
-			ss->sector->f_slope ? P_GetZAt(ss->sector->f_slope, x, y) :
-#endif
-			ss->sector->floorheight) + offset;
+	return P_GetMobjSpawnHeight(mobjtype, x, y, offset, flip);
 }
 
 static boolean P_SpawnNonMobjMapThing(mapthing_t *mthing)
@@ -13022,7 +13025,7 @@ void P_SpawnMapThing(mapthing_t *mthing)
 	// spawn it
 	x = mthing->x << FRACBITS;
 	y = mthing->y << FRACBITS;
-	z = P_GetMobjSpawnHeight(i, mthing, x, y);
+	z = P_GetMapThingSpawnHeight(i, mthing, x, y);
 
 	mobj = P_SpawnMobj(x, y, z, i);
 	mobj->spawnpoint = mthing;
@@ -13074,7 +13077,7 @@ void P_SpawnMapThing(mapthing_t *mthing)
 		mobj->flags2 |= MF2_DONTDRAW;
 }
 
-static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, sector_t* sec, INT32 hoopsize, fixed_t sizefactor)
+static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT32 hoopsize, fixed_t sizefactor)
 {
 	mobj_t *mobj = NULL;
 	mobj_t *nextmobj = NULL;
@@ -13085,11 +13088,7 @@ static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, sec
 	angle_t fa;
 	TVector v, *res;
 
-	z +=
-#ifdef ESLOPE
-		sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
-		sec->floorheight;
+	z = P_GetMobjSpawnHeight(MT_HOOP, x, y, z, false);
 
 	hoopcenter = P_SpawnMobj(x, y, z, MT_HOOPCENTER);
 	hoopcenter->spawnpoint = mthing;
@@ -13209,7 +13208,7 @@ static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bo
 			ringthing = (gametype == GT_CTF) ? MT_BLUETEAMRING : MT_RING;
 	}
 
-	z = P_GetMobjSpawnHeight(ringthing, mthing, x, y);
+	z = P_GetMapThingSpawnHeight(ringthing, mthing, x, y);
 	mobj = P_SpawnMobj(x, y, z, ringthing);
 	mobj->spawnpoint = mthing;
 
@@ -13230,11 +13229,10 @@ static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bo
 		P_SetMobjState(mobj, mobj->info->seestate);
 }
 
-static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y, sector_t* sec, boolean nightsreplace)
+static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, boolean nightsreplace)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t* mobj = NULL;
-	fixed_t z;
 	INT32 r;
 
 	INT32 dist = 64*FRACUNIT;
@@ -13247,26 +13245,7 @@ static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y,
 	if (nightsreplace)
 		ringthing = MT_NIGHTSSTAR;
 
-	if (mthing->options & MTF_OBJECTFLIP)
-	{
-		z = (
-#ifdef ESLOPE
-			sec->c_slope ? P_GetZAt(sec->c_slope, x, y) :
-#endif
-			sec->ceilingheight) - mobjinfo[ringthing].height;
-		if (mthing->z)
-			z -= (mthing->z << FRACBITS);
-	}
-	else
-	{
-		z = (
-#ifdef ESLOPE
-			sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
-			sec->floorheight);
-		if (mthing->z)
-			z += (mthing->z << FRACBITS);
-	}
+	z = P_GetMobjSpawnHeight(ringthing, x, y, z, mthing->options & MTF_OBJECTFLIP);
 
 	for (r = 1; r <= 5; r++)
 	{
@@ -13292,11 +13271,10 @@ static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y,
 	}
 }
 
-static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y, sector_t* sec, boolean nightsreplace)
+static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, boolean nightsreplace)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
-	fixed_t z;
 	INT32 r;
 	angle_t closestangle, fa;
 
@@ -13313,26 +13291,7 @@ static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y,
 	closestangle = FixedAngle(mthing->angle << FRACBITS);
 	fa = (closestangle >> ANGLETOFINESHIFT);
 
-	if (mthing->options & MTF_OBJECTFLIP)
-	{
-		z = (
-#ifdef ESLOPE
-			sec->c_slope ? P_GetZAt(sec->c_slope, x, y) :
-#endif
-			sec->ceilingheight) - mobjinfo[ringthing].height;
-		if (mthing->z)
-			z -= (mthing->z << FRACBITS);
-	}
-	else
-	{
-		z = (
-#ifdef ESLOPE
-			sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
-			sec->floorheight);
-		if (mthing->z)
-			z += (mthing->z << FRACBITS);
-	}
+	z = P_GetMobjSpawnHeight(ringthing, x, y, z, mthing->options & MTF_OBJECTFLIP);
 
 	for (r = 1; r <= iterations; r++)
 	{
@@ -13361,11 +13320,11 @@ static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y,
 	}
 }
 
-static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, sector_t* sec, boolean bonustime, boolean nightsreplace)
+static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, boolean bonustime, boolean nightsreplace)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
-	fixed_t z, finalx, finaly, finalz;
+	fixed_t finalx, finaly, finalz;
 	angle_t closestangle, fa;
 	INT32 i;
 	TVector v, *res;
@@ -13378,13 +13337,7 @@ static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, sector_t
 		size = 192*FRACUNIT;
 	}
 
-	z =
-#ifdef ESLOPE
-		sec->f_slope ? P_GetZAt(sec->f_slope, x, y) :
-#endif
-		sec->floorheight;
-	if (mthing->z)
-		z += (mthing->z << FRACBITS);
+	z = P_GetMobjSpawnHeight(ringthing, x, y, z, false);
 
 	closestangle = FixedAngle(mthing->angle << FRACBITS);
 
@@ -13462,7 +13415,6 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 	fixed_t x = mthing->x << FRACBITS;
 	fixed_t y = mthing->y << FRACBITS;
 	fixed_t z = mthing->z << FRACBITS;
-	sector_t *sec = R_PointInSubsector(x, y)->sector;
 	boolean nightsreplace = ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap));
 
 	switch (mthing->type)
@@ -13470,11 +13422,11 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 	// Special placement patterns
 	case 600: // 5 vertical rings (yellow spring)
 	case 601: // 5 vertical rings (red spring)
-		P_SpawnVerticalSpringRings(mthing, x, y, sec, nightsreplace);
+		P_SpawnVerticalSpringRings(mthing, x, y, z, nightsreplace);
 		return;
 	case 602: // 5 diagonal rings (yellow spring)
 	case 603: // 10 diagonal rings (red spring)
-		P_SpawnDiagonalSpringRings(mthing, x, y, sec, nightsreplace);
+		P_SpawnDiagonalSpringRings(mthing, x, y, z, nightsreplace);
 		return;
 	case 604: // Circle of rings (8 items)
 	case 605: // Circle of rings (16 bits)
@@ -13482,16 +13434,16 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 	case 607: // Circle of blue spheres (16 items)
 	case 608: // Circle of rings and blue spheres (8 items)
 	case 609: // Circle of rings and blue spheres (16 items)
-		P_SpawnItemCircle(mthing, x, y, sec, bonustime, nightsreplace);
+		P_SpawnItemCircle(mthing, x, y, z, bonustime, nightsreplace);
 		return;
 	// Hoops
 	case 1705: // Generic NiGHTS hoop
-		P_SpawnHoop(mthing, x, y, z, sec, 24, 4*FRACUNIT);
+		P_SpawnHoop(mthing, x, y, z, 24, 4*FRACUNIT);
 		return;
 	case 1713: // Customizable NiGHTS hoop
 		// For each flag add 16 fracunits to the size
 		// Default (0 flags) is 32 fracunits
-		P_SpawnHoop(mthing, x, y, z, sec, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
+		P_SpawnHoop(mthing, x, y, z, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
 		return;
 	default: // All manners of rings and coins
 		P_SpawnRingItem(mthing, x, y, bonustime, nightsreplace);

From 6939da01641bc950f99b0080055d9729e16c2c3b Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Mon, 23 Dec 2019 21:35:03 +0100
Subject: [PATCH 02/10] Turned nightsreplace into a macro so we have don't have
 to keep dragging it along as a function parameter

---
 src/p_mobj.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 54e603fe9..aa19716df 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -13182,7 +13182,9 @@ static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT
 	} while (hoopsize >= 8);
 }
 
-static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bonustime, boolean nightsreplace)
+#define nightsreplace ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap))
+
+static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bonustime)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
@@ -13229,7 +13231,7 @@ static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bo
 		P_SetMobjState(mobj, mobj->info->seestate);
 }
 
-static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, boolean nightsreplace)
+static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t* mobj = NULL;
@@ -13271,7 +13273,7 @@ static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y,
 	}
 }
 
-static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, boolean nightsreplace)
+static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
@@ -13320,7 +13322,7 @@ static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y,
 	}
 }
 
-static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, boolean bonustime, boolean nightsreplace)
+static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, boolean bonustime)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
@@ -13415,18 +13417,17 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 	fixed_t x = mthing->x << FRACBITS;
 	fixed_t y = mthing->y << FRACBITS;
 	fixed_t z = mthing->z << FRACBITS;
-	boolean nightsreplace = ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap));
 
 	switch (mthing->type)
 	{
 	// Special placement patterns
 	case 600: // 5 vertical rings (yellow spring)
 	case 601: // 5 vertical rings (red spring)
-		P_SpawnVerticalSpringRings(mthing, x, y, z, nightsreplace);
+		P_SpawnVerticalSpringRings(mthing, x, y, z);
 		return;
 	case 602: // 5 diagonal rings (yellow spring)
 	case 603: // 10 diagonal rings (red spring)
-		P_SpawnDiagonalSpringRings(mthing, x, y, z, nightsreplace);
+		P_SpawnDiagonalSpringRings(mthing, x, y, z);
 		return;
 	case 604: // Circle of rings (8 items)
 	case 605: // Circle of rings (16 bits)
@@ -13434,7 +13435,7 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 	case 607: // Circle of blue spheres (16 items)
 	case 608: // Circle of rings and blue spheres (8 items)
 	case 609: // Circle of rings and blue spheres (16 items)
-		P_SpawnItemCircle(mthing, x, y, z, bonustime, nightsreplace);
+		P_SpawnItemCircle(mthing, x, y, z, bonustime);
 		return;
 	// Hoops
 	case 1705: // Generic NiGHTS hoop
@@ -13446,7 +13447,7 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 		P_SpawnHoop(mthing, x, y, z, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
 		return;
 	default: // All manners of rings and coins
-		P_SpawnRingItem(mthing, x, y, bonustime, nightsreplace);
+		P_SpawnRingItem(mthing, x, y, bonustime);
 	}
 }
 

From 50dd0a71db5a38ad4ccb1d2c0bee3b112b0ca8bf Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Mon, 23 Dec 2019 22:58:58 +0100
Subject: [PATCH 03/10] Turn size and number of items for item circle into
 function parameters (in preparation for UDMF)

---
 src/p_mobj.c | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index aa19716df..b4ac43e21 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -13322,7 +13322,7 @@ static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y,
 	}
 }
 
-static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, boolean bonustime)
+static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t size, boolean bonustime)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
@@ -13330,14 +13330,6 @@ static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t
 	angle_t closestangle, fa;
 	INT32 i;
 	TVector v, *res;
-	INT32 numitems = 8;
-	INT32 size = 96*FRACUNIT;
-
-	if (mthing->type & 1)
-	{
-		numitems = 16;
-		size = 192*FRACUNIT;
-	}
 
 	z = P_GetMobjSpawnHeight(ringthing, x, y, z, false);
 
@@ -13430,13 +13422,17 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 		P_SpawnDiagonalSpringRings(mthing, x, y, z);
 		return;
 	case 604: // Circle of rings (8 items)
-	case 605: // Circle of rings (16 bits)
+	case 605: // Circle of rings (16 items)
 	case 606: // Circle of blue spheres (8 items)
 	case 607: // Circle of blue spheres (16 items)
 	case 608: // Circle of rings and blue spheres (8 items)
 	case 609: // Circle of rings and blue spheres (16 items)
-		P_SpawnItemCircle(mthing, x, y, z, bonustime);
+	{
+		INT32 numitems = (mthing->type & 1) ? 16 : 8;
+		fixed_t size = (mthing->type & 1) ? 192*FRACUNIT : 96*FRACUNIT;
+		P_SpawnItemCircle(mthing, x, y, z, numitems, size, bonustime);
 		return;
+	}
 	// Hoops
 	case 1705: // Generic NiGHTS hoop
 		P_SpawnHoop(mthing, x, y, z, 24, 4*FRACUNIT);

From ffd6cf4acad17ba5f1c60a42dcf19d56e2f75db3 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 00:10:29 +0100
Subject: [PATCH 04/10] Replaced functions for spawning premade rows of rings
 with a function for spawning a generic row of rings (groundwork for UDMF)

---
 src/p_mobj.c | 76 ++++++++++------------------------------------------
 1 file changed, 14 insertions(+), 62 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index b4ac43e21..f25690ed8 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -13231,58 +13231,13 @@ static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bo
 		P_SetMobjState(mobj, mobj->info->seestate);
 }
 
-static void P_SpawnVerticalSpringRings(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z)
-{
-	mobjtype_t ringthing = MT_RING;
-	mobj_t* mobj = NULL;
-	INT32 r;
-
-	INT32 dist = 64*FRACUNIT;
-	if (mthing->type == 601)
-		dist = 128*FRACUNIT;
-
-	if (ultimatemode)
-		return; // No rings in Ultimate!
-
-	if (nightsreplace)
-		ringthing = MT_NIGHTSSTAR;
-
-	z = P_GetMobjSpawnHeight(ringthing, x, y, z, mthing->options & MTF_OBJECTFLIP);
-
-	for (r = 1; r <= 5; r++)
-	{
-		if (mthing->options & MTF_OBJECTFLIP)
-			z -= dist;
-		else
-			z += dist;
-
-		mobj = P_SpawnMobj(x, y, z, ringthing);
-
-		if (mthing->options & MTF_OBJECTFLIP)
-		{
-			mobj->eflags |= MFE_VERTICALFLIP;
-			mobj->flags2 |= MF2_OBJECTFLIP;
-		}
-
-		mobj->angle = FixedAngle(mthing->angle << FRACBITS);
-		if (mthing->options & MTF_AMBUSH)
-			mobj->flags2 |= MF2_AMBUSH;
-
-		if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
-			P_SetMobjState(mobj, mobj->info->seestate);
-	}
-}
-
-static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z)
+static void P_SpawnItemRow(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
 	INT32 r;
-	angle_t closestangle, fa;
-
-	INT32 iterations = 5;
-	if (mthing->type == 603)
-		iterations = 10;
+	angle_t angle = FixedAngle(fixedangle << FRACBITS);
+	angle_t fineangle = (angle >> ANGLETOFINESHIFT) & FINEMASK;
 
 	if (ultimatemode)
 		return; // No rings in Ultimate!
@@ -13290,20 +13245,13 @@ static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y,
 	if (nightsreplace)
 		ringthing = MT_NIGHTSSTAR;
 
-	closestangle = FixedAngle(mthing->angle << FRACBITS);
-	fa = (closestangle >> ANGLETOFINESHIFT);
-
 	z = P_GetMobjSpawnHeight(ringthing, x, y, z, mthing->options & MTF_OBJECTFLIP);
 
-	for (r = 1; r <= iterations; r++)
+	for (r = 0; r < numitems; r++)
 	{
-		x += FixedMul(64*FRACUNIT, FINECOSINE(fa));
-		y += FixedMul(64*FRACUNIT, FINESINE(fa));
-
-		if (mthing->options & MTF_OBJECTFLIP)
-			z -= 64*FRACUNIT;
-		else
-			z += 64*FRACUNIT;
+		x += FixedMul(horizontalspacing, FINECOSINE(fineangle));
+		y += FixedMul(horizontalspacing, FINESINE(fineangle));
+		z += (mthing->options & MTF_OBJECTFLIP) ? -verticalspacing : verticalspacing;
 
 		mobj = P_SpawnMobj(x, y, z, ringthing);
 
@@ -13313,7 +13261,7 @@ static void P_SpawnDiagonalSpringRings(mapthing_t* mthing, fixed_t x, fixed_t y,
 			mobj->flags2 |= MF2_OBJECTFLIP;
 		}
 
-		mobj->angle = closestangle;
+		mobj->angle = angle;
 		if (mthing->options & MTF_AMBUSH)
 			mobj->flags2 |= MF2_AMBUSH;
 
@@ -13414,12 +13362,16 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 	{
 	// Special placement patterns
 	case 600: // 5 vertical rings (yellow spring)
+		P_SpawnItemRow(mthing, x, y, z, 5, 0, 64*FRACUNIT, 0);
+		return;
 	case 601: // 5 vertical rings (red spring)
-		P_SpawnVerticalSpringRings(mthing, x, y, z);
+		P_SpawnItemRow(mthing, x, y, z, 5, 0, 128*FRACUNIT, 0);
 		return;
 	case 602: // 5 diagonal rings (yellow spring)
+		P_SpawnItemRow(mthing, x, y, z, 5, 64*FRACUNIT, 64*FRACUNIT, mthing->angle);
+		return;
 	case 603: // 10 diagonal rings (red spring)
-		P_SpawnDiagonalSpringRings(mthing, x, y, z);
+		P_SpawnItemRow(mthing, x, y, z, 10, 64*FRACUNIT, 64*FRACUNIT, mthing->angle);
 		return;
 	case 604: // Circle of rings (8 items)
 	case 605: // Circle of rings (16 items)

From dd01fce1a84710a772a04521378dd6945fac991e Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 10:50:49 +0100
Subject: [PATCH 05/10] Separate P_SpawnHoopsAndRings into different functions:
 -Hoops are spawned in P_SpawnHoop -Item patterns are spawned in
 P_SpawnItemPattern -Ring-like items are spawned normally via P_SpawnMapThing
 -Bonus time items are spawned via P_SpawnBonusTimeItem, which is a wrapper
 for P_SpawnMapThing

---
 src/m_cheat.c |  32 ++++-------
 src/p_mobj.c  | 152 +++++++++++++++++++++++---------------------------
 src/p_mobj.h  |   6 +-
 src/p_saveg.c |   2 +-
 src/p_setup.c |  43 ++++++--------
 5 files changed, 102 insertions(+), 133 deletions(-)

diff --git a/src/m_cheat.c b/src/m_cheat.c
index 0451a5fb3..3d1fe5b7e 100644
--- a/src/m_cheat.c
+++ b/src/m_cheat.c
@@ -1186,7 +1186,7 @@ void OP_NightsObjectplace(player_t *player)
 		mt->options = (mt->options & ~(UINT16)cv_opflags.value) | (UINT16)cv_ophoopflags.value;
 		mt->angle = (INT16)(mt->angle+(INT16)((FixedInt(FixedDiv(temp*FRACUNIT, 360*(FRACUNIT/256))))<<8));
 
-		P_SpawnHoopsAndRings(mt, false);
+		P_SpawnHoop(mt);
 	}
 
 	// This places a bumper!
@@ -1249,7 +1249,7 @@ void OP_NightsObjectplace(player_t *player)
 			return;
 
 		mt = OP_CreateNewMapThing(player, (UINT16)mobjinfo[MT_BLUESPHERE].doomednum, false);
-		P_SpawnHoopsAndRings(mt, false);
+		P_SpawnMapThing(mt);
 	}
 
 	// This places a ring!
@@ -1260,7 +1260,7 @@ void OP_NightsObjectplace(player_t *player)
 			return;
 
 		mt = OP_CreateNewMapThing(player, (UINT16)mobjinfo[MT_RING].doomednum, false);
-		P_SpawnHoopsAndRings(mt, false);
+		P_SpawnMapThing(mt);
 	}
 
 	// This places a custom object as defined in the console cv_mapthingnum.
@@ -1292,15 +1292,10 @@ void OP_NightsObjectplace(player_t *player)
 		mt = OP_CreateNewMapThing(player, (UINT16)cv_mapthingnum.value, false);
 		mt->angle = angle;
 
-		if (mt->type == 300 // Ring
-		|| mt->type == 308 || mt->type == 309 // Team Rings
-		|| mt->type == 1706 // Sphere
-		|| (mt->type >= 600 && mt->type <= 609) // Placement patterns
-		|| mt->type == 1705 || mt->type == 1713 // NiGHTS Hoops
-		|| mt->type == 1800) // Mario Coin
-		{
-			P_SpawnHoopsAndRings(mt, false);
-		}
+		if (mt->type >= 600 && mt->type <= 609) // Placement patterns
+			P_SpawnItemPattern(mt, false);
+		else if (mt->type == 1705 || mt->type == 1713) // NiGHTS Hoops
+			P_SpawnHoop(mt);
 		else
 			P_SpawnMapThing(mt);
 	}
@@ -1437,15 +1432,10 @@ void OP_ObjectplaceMovement(player_t *player)
 			return;
 
 		mt = OP_CreateNewMapThing(player, (UINT16)spawnthing, ceiling);
-		if (mt->type == 300 // Ring
-		|| mt->type == 308 || mt->type == 309 // Team Rings
-		|| mt->type == 1706 // Nights Wing
-		|| (mt->type >= 600 && mt->type <= 609) // Placement patterns
-		|| mt->type == 1705 || mt->type == 1713 // NiGHTS Hoops
-		|| mt->type == 1800) // Mario Coin
-		{
-			P_SpawnHoopsAndRings(mt, false);
-		}
+		if (mt->type >= 600 && mt->type <= 609) // Placement patterns
+			P_SpawnItemPattern(mt, false);
+		else if (mt->type == 1705 || mt->type == 1713) // NiGHTS Hoops
+			P_SpawnHoop(mt);
 		else
 			P_SpawnMapThing(mt);
 
diff --git a/src/p_mobj.c b/src/p_mobj.c
index f25690ed8..606c65014 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -11711,15 +11711,6 @@ static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
 {
 	switch (i)
 	{
-	case MT_RING:
-	case MT_COIN:
-	case MT_REDTEAMRING:
-	case MT_BLUETEAMRING:
-	case MT_BLUESPHERE:
-	case MT_BOMBSPHERE:
-	case MT_NIGHTSSTAR:
-	case MT_NIGHTSCHIP:
-		return false; // These are handled in P_SpawnHoopsAndRings().
 	case MT_EMERALD1:
 	case MT_EMERALD2:
 	case MT_EMERALD3:
@@ -11786,8 +11777,12 @@ static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
 	}
 
 	if (metalrecording) // Metal Sonic can't use these things.
-		if (mobjinfo[i].flags & (MF_ENEMY|MF_BOSS) || i == MT_TOKEN || i == MT_STARPOST)
+	{
+		if ((mobjinfo[i].flags & (MF_ENEMY|MF_BOSS)) || i == MT_TOKEN || i == MT_STARPOST
+			|| i == MT_RING || i == MT_BLUETEAMRING || i == MT_REDTEAMRING || i == MT_COIN
+			|| i == MT_BLUESPHERE || i == MT_BOMBSPHERE || i == MT_NIGHTSCHIP || i == MT_NIGHTSSTAR)
 			return false;
+	}
 
 	if (!G_PlatformGametype())
 	{
@@ -11825,7 +11820,9 @@ static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
 
 	if (ultimatemode)
 	{
-		if (i == MT_PITY_BOX || i == MT_ELEMENTAL_BOX || i == MT_ATTRACT_BOX
+		if (i == MT_RING || i == MT_REDTEAMRING || i == MT_BLUETEAMRING
+			|| i == MT_COIN || i == MT_NIGHTSSTAR || i == MT_NIGHTSCHIP
+			|| i == MT_PITY_BOX || i == MT_ELEMENTAL_BOX || i == MT_ATTRACT_BOX
 			|| i == MT_FORCE_BOX || i == MT_ARMAGEDDON_BOX || i == MT_WHIRLWIND_BOX
 			|| i == MT_FLAMEAURA_BOX || i == MT_BUBBLEWRAP_BOX || i == MT_THUNDERCOIN_BOX
 			|| i == MT_RING_BOX || i == MT_STARPOST)
@@ -11838,6 +11835,8 @@ static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
 	return true;
 }
 
+#define nightsreplace ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap))
+
 static mobjtype_t P_GetMobjtypeSubstitute(mapthing_t *mthing, mobjtype_t i)
 {
 	// Altering monitor spawns via cvars
@@ -11881,8 +11880,23 @@ static mobjtype_t P_GetMobjtypeSubstitute(mapthing_t *mthing, mobjtype_t i)
 		}
 	}
 
-	if (gametype != GT_CTF && (i == MT_RING_BLUEBOX || i == MT_RING_REDBOX))
-		return MT_RING_BOX;
+	if (nightsreplace)
+	{
+		if (i == MT_RING || i == MT_REDTEAMRING || i == MT_BLUETEAMRING || i == MT_COIN)
+			return MT_NIGHTSSTAR;
+
+		if (i == MT_BLUESPHERE)
+			return MT_NIGHTSCHIP;
+	}
+
+	if (gametype != GT_CTF)
+	{
+		if (i == MT_BLUETEAMRING || i == MT_REDTEAMRING)
+			return MT_RING;
+
+		if (i == MT_RING_BLUEBOX || i == MT_RING_REDBOX)
+			return MT_RING_BOX;
+	}
 
 	if (modeattacking && i == MT_1UP_BOX) // 1UPs -->> Score TVs
 	{
@@ -12920,6 +12934,10 @@ static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean
 		if (G_IsSpecialStage(gamemap))
 			P_SetMobjState(mobj, (mobj->type == MT_PUSH) ? S_GRAVWELLGREEN : S_GRAVWELLRED);
 		break;
+	case MT_NIGHTSSTAR:
+		if (maptol & TOL_XMAS)
+			P_SetMobjState(mobj, mobj->info->seestate);
+		break;
 	default:
 		break;
 	}
@@ -12991,21 +13009,21 @@ static void P_SetObjectSpecial(mobj_t *mobj)
 // The fields of the mapthing should
 // already be in host byte order.
 //
-void P_SpawnMapThing(mapthing_t *mthing)
+mobj_t *P_SpawnMapThing(mapthing_t *mthing)
 {
 	mobjtype_t i;
-	mobj_t *mobj;
+	mobj_t *mobj = NULL;
 	fixed_t x, y, z;
 	boolean doangle = true;
 
 	if (!mthing->type)
-		return; // Ignore type-0 things as NOPs
+		return mobj; // Ignore type-0 things as NOPs
 
 	if (mthing->type == 3328) // 3D Mode start Thing
-		return;
+		return mobj;
 
 	if (!objectplacing && P_SpawnNonMobjMapThing(mthing))
-		return;
+		return mobj;
 
 	i = P_GetMobjtype(mthing->type);
 	if (i == MT_UNKNOWN)
@@ -13015,11 +13033,11 @@ void P_SpawnMapThing(mapthing_t *mthing)
 	if (!objectplacing)
 	{
 		if (!P_AllowMobjSpawn(mthing, i))
-			return;
+			return mobj;
 
 		i = P_GetMobjtypeSubstitute(mthing, i);
 		if (i == MT_NULL) // Don't spawn mobj
-			return;
+			return mobj;
 	}
 
 	// spawn it
@@ -13031,7 +13049,7 @@ void P_SpawnMapThing(mapthing_t *mthing)
 	mobj->spawnpoint = mthing;
 
 	if (!P_SetupSpawnedMapThing(mthing, mobj, &doangle))
-		return;
+		return mobj;
 
 	if (doangle)
 		mobj->angle = FixedAngle(mthing->angle<<FRACBITS);
@@ -13040,7 +13058,7 @@ void P_SpawnMapThing(mapthing_t *mthing)
 
 	// ignore MTF_ flags and return early
 	if (i == MT_NIGHTSBUMPER)
-		return;
+		return mobj;
 
 	if ((mthing->options & MTF_AMBUSH)
 	&& (mthing->options & MTF_OBJECTSPECIAL)
@@ -13075,9 +13093,11 @@ void P_SpawnMapThing(mapthing_t *mthing)
 	// Final set of not being able to draw nightsitems.
 	if (mobj->flags & MF_NIGHTSITEM)
 		mobj->flags2 |= MF2_DONTDRAW;
+
+	return mobj;
 }
 
-static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT32 hoopsize, fixed_t sizefactor)
+static void P_SpawnHoopInternal(mapthing_t *mthing, INT32 hoopsize, fixed_t sizefactor)
 {
 	mobj_t *mobj = NULL;
 	mobj_t *nextmobj = NULL;
@@ -13087,8 +13107,9 @@ static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT
 	INT32 i;
 	angle_t fa;
 	TVector v, *res;
-
-	z = P_GetMobjSpawnHeight(MT_HOOP, x, y, z, false);
+	fixed_t x = mthing->x << FRACBITS;
+	fixed_t y = mthing->y << FRACBITS;
+	fixed_t z = P_GetMobjSpawnHeight(MT_HOOP, x, y, mthing->z << FRACBITS, false);
 
 	hoopcenter = P_SpawnMobj(x, y, z, MT_HOOPCENTER);
 	hoopcenter->spawnpoint = mthing;
@@ -13182,56 +13203,27 @@ static void P_SpawnHoop(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT
 	} while (hoopsize >= 8);
 }
 
-#define nightsreplace ((maptol & TOL_NIGHTS) && !G_IsSpecialStage(gamemap))
-
-static void P_SpawnRingItem(mapthing_t *mthing, fixed_t x, fixed_t y, boolean bonustime)
+void P_SpawnHoop(mapthing_t *mthing)
 {
-	mobjtype_t ringthing = MT_RING;
-	mobj_t *mobj = NULL;
-	fixed_t z;
+	if (metalrecording)
+		return;
 
-	// Which ringthing to use
-	if (mthing->type == mobjinfo[MT_BLUESPHERE].doomednum)
-		ringthing = (nightsreplace) ? MT_NIGHTSCHIP : MT_BLUESPHERE;
-	else if (mthing->type == mobjinfo[MT_BOMBSPHERE].doomednum)
-		ringthing = MT_BOMBSPHERE;
-	else
-	{
-		if (ultimatemode)
-			return; // No rings in Ultimate!
-
-		if (nightsreplace)
-			ringthing = MT_NIGHTSSTAR;
-		else if (mthing->type == mobjinfo[MT_COIN].doomednum)
-			ringthing = MT_COIN;
-		else if (mthing->type == mobjinfo[MT_REDTEAMRING].doomednum) // No team rings in non-CTF
-			ringthing = (gametype == GT_CTF) ? MT_REDTEAMRING : MT_RING;
-		else if (mthing->type == mobjinfo[MT_BLUETEAMRING].doomednum) // Ditto
-			ringthing = (gametype == GT_CTF) ? MT_BLUETEAMRING : MT_RING;
-	}
-
-	z = P_GetMapThingSpawnHeight(ringthing, mthing, x, y);
-	mobj = P_SpawnMobj(x, y, z, ringthing);
-	mobj->spawnpoint = mthing;
-
-	if (mthing->options & MTF_OBJECTFLIP)
-	{
-		mobj->eflags |= MFE_VERTICALFLIP;
-		mobj->flags2 |= MF2_OBJECTFLIP;
-	}
-
-	mobj->angle = FixedAngle(mthing->angle << FRACBITS);
-	mthing->mobj = mobj;
-	if (mthing->options & MTF_AMBUSH)
-		mobj->flags2 |= MF2_AMBUSH;
-
-	if (bonustime && (ringthing == MT_BLUESPHERE || ringthing == MT_NIGHTSCHIP))
-		P_SetMobjState(mobj, mobj->info->raisestate);
-	else if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
-		P_SetMobjState(mobj, mobj->info->seestate);
+	if (mthing->type == 1705) // Generic hoop
+		P_SpawnHoopInternal(mthing, 24, 4*FRACUNIT);
+	else // Customizable hoop
+		// For each flag add 16 fracunits to the size
+		// Default (0 flags) is 32 fracunits
+		P_SpawnHoopInternal(mthing, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
 }
 
-static void P_SpawnItemRow(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle)
+void P_SpawnBonusTimeItem(mapthing_t *mthing)
+{
+	mobj_t *mobj = P_SpawnMapThing(mthing);
+	if (mobj && (mobj->type == MT_BLUESPHERE || mobj->type == MT_NIGHTSCHIP))
+		P_SetMobjState(mobj, mobj->info->raisestate);
+}
+
+static void P_SpawnItemRow(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
@@ -13270,7 +13262,7 @@ static void P_SpawnItemRow(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z,
 	}
 }
 
-static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t size, boolean bonustime)
+static void P_SpawnItemCircle(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t size, boolean bonustime)
 {
 	mobjtype_t ringthing = MT_RING;
 	mobj_t *mobj = NULL;
@@ -13352,12 +13344,15 @@ static void P_SpawnItemCircle(mapthing_t* mthing, fixed_t x, fixed_t y, fixed_t
 	}
 }
 
-void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
+void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime)
 {
 	fixed_t x = mthing->x << FRACBITS;
 	fixed_t y = mthing->y << FRACBITS;
 	fixed_t z = mthing->z << FRACBITS;
 
+	if (metalrecording)
+		return;
+
 	switch (mthing->type)
 	{
 	// Special placement patterns
@@ -13385,17 +13380,8 @@ void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime)
 		P_SpawnItemCircle(mthing, x, y, z, numitems, size, bonustime);
 		return;
 	}
-	// Hoops
-	case 1705: // Generic NiGHTS hoop
-		P_SpawnHoop(mthing, x, y, z, 24, 4*FRACUNIT);
+	default:
 		return;
-	case 1713: // Customizable NiGHTS hoop
-		// For each flag add 16 fracunits to the size
-		// Default (0 flags) is 32 fracunits
-		P_SpawnHoop(mthing, x, y, z, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
-		return;
-	default: // All manners of rings and coins
-		P_SpawnRingItem(mthing, x, y, bonustime);
 	}
 }
 
diff --git a/src/p_mobj.h b/src/p_mobj.h
index 40d850f16..9b015d23c 100644
--- a/src/p_mobj.h
+++ b/src/p_mobj.h
@@ -456,8 +456,10 @@ void P_MovePlayerToSpawn(INT32 playernum, mapthing_t *mthing);
 void P_MovePlayerToStarpost(INT32 playernum);
 void P_AfterPlayerSpawn(INT32 playernum);
 
-void P_SpawnMapThing(mapthing_t *mthing);
-void P_SpawnHoopsAndRings(mapthing_t *mthing, boolean bonustime);
+mobj_t *P_SpawnMapThing(mapthing_t *mthing);
+void P_SpawnHoop(mapthing_t *mthing);
+void P_SpawnBonusTimeItem(mapthing_t *mthing);
+void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime);
 void P_SpawnHoopOfSomething(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, angle_t rotangle);
 void P_SpawnPrecipitation(void);
 void P_SpawnParaloop(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, statenum_t nstate, angle_t rotangle, boolean spawncenter);
diff --git a/src/p_saveg.c b/src/p_saveg.c
index c876713e4..86224d936 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -2545,7 +2545,7 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
 
 		if (mapthings[spawnpointnum].type == 1705 || mapthings[spawnpointnum].type == 1713) // NiGHTS Hoop special case
 		{
-			P_SpawnHoopsAndRings(&mapthings[spawnpointnum], false);
+			P_SpawnHoop(&mapthings[spawnpointnum]);
 			return NULL;
 		}
 
diff --git a/src/p_setup.c b/src/p_setup.c
index bc736588e..46fe118c4 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -765,7 +765,7 @@ static void P_LoadRawNodes(UINT8 *data)
 
 //
 // P_ReloadRings
-// Used by NiGHTS, clears all ring/wing/etc items and respawns them
+// Used by NiGHTS, clears all ring/sphere/hoop/etc items and respawns them
 //
 void P_ReloadRings(void)
 {
@@ -812,18 +812,21 @@ void P_ReloadRings(void)
 	{
 		// Notice an omission? We handle hoops differently.
 		if (mt->type == mobjinfo[MT_RING].doomednum || mt->type == mobjinfo[MT_COIN].doomednum
-		 || mt->type == mobjinfo[MT_REDTEAMRING].doomednum || mt->type == mobjinfo[MT_BLUETEAMRING].doomednum
-		 || mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum
-		 || (mt->type >= 600 && mt->type <= 609)) // circles and diagonals
+			|| mt->type == mobjinfo[MT_REDTEAMRING].doomednum || mt->type == mobjinfo[MT_BLUETEAMRING].doomednum
+			|| mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum)
 		{
 			mt->mobj = NULL;
-
-			P_SpawnHoopsAndRings(mt, true);
+			P_SpawnBonusTimeItem(mt);
+		}
+		else if (mt->type >= 600 && mt->type <= 609) // Item patterns
+		{
+			mt->mobj = NULL;
+			P_SpawnItemPattern(mt, true);
 		}
 	}
 	for (i = 0; i < numHoops; i++)
 	{
-		P_SpawnHoopsAndRings(hoopsToRespawn[i], false);
+		P_SpawnHoop(hoopsToRespawn[i]);
 	}
 }
 
@@ -1017,30 +1020,18 @@ static void P_LoadThings(boolean loademblems)
 			continue;
 
 		mt->mobj = NULL;
-		P_SpawnMapThing(mt);
+
+		if (mt->type >= 600 && mt->type <= 609) // item patterns
+			P_SpawnItemPattern(mt, false);
+		else if (mt->type == 1705 || mt->type == 1713) // hoops
+			P_SpawnHoop(mt);
+		else // Everything else
+			P_SpawnMapThing(mt);
 	}
 
 	// random emeralds for hunt
 	if (numhuntemeralds)
 		P_SpawnEmeraldHunt();
-
-	if (metalrecording) // Metal Sonic gets no rings to distract him.
-		return;
-
-	// Run through the list of mapthings again to spawn hoops and rings
-	mt = mapthings;
-	for (i = 0; i < nummapthings; i++, mt++)
-	{
-		if (mt->type == mobjinfo[MT_RING].doomednum || mt->type == mobjinfo[MT_COIN].doomednum
-		 || mt->type == mobjinfo[MT_REDTEAMRING].doomednum || mt->type == mobjinfo[MT_BLUETEAMRING].doomednum
-		 || mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum
-		 || (mt->type >= 600 && mt->type <= 609) // circles and diagonals
-		 || mt->type == 1705 || mt->type == 1713) // hoops
-		{
-			mt->mobj = NULL;
-			P_SpawnHoopsAndRings(mt, false);
-		}
-	}
 }
 
 // Experimental groovy write function!

From 2dac47a54c4757871f5b8ee907ddd96b2daaf664 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 12:19:13 +0100
Subject: [PATCH 06/10] Allow P_SpawnItemRow to spawn arbitrary mobjtypes (will
 be used in UDMF)

---
 src/p_mobj.c | 173 +++++++++++++++++++++++++++------------------------
 1 file changed, 90 insertions(+), 83 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 606c65014..427f3526d 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -11567,14 +11567,6 @@ static fixed_t P_GetMobjSpawnHeight(const mobjtype_t mobjtype, const fixed_t x,
 	if (mobjtype == MT_AXIS || mobjtype == MT_AXISTRANSFER || mobjtype == MT_AXISTRANSFERLINE)
 		return ONFLOORZ;
 
-	if (!offset) // Snap to the surfaces when there's no offset set.
-	{
-		if (flip)
-			return ONCEILINGZ;
-		else
-			return ONFLOORZ;
-	}
-
 	// Establish height.
 	if (flip)
 		return (
@@ -11649,6 +11641,14 @@ static fixed_t P_GetMapThingSpawnHeight(const mobjtype_t mobjtype, const mapthin
 			offset += mthing->options & MTF_AMBUSH ? 24*FRACUNIT : 0;
 	}
 
+	if (!offset) // Snap to the surfaces when there's no offset set.
+	{
+		if (flip)
+			return ONCEILINGZ;
+		else
+			return ONFLOORZ;
+	}
+
 	return P_GetMobjSpawnHeight(mobjtype, x, y, offset, flip);
 }
 
@@ -11703,6 +11703,13 @@ static boolean P_SpawnNonMobjMapThing(mapthing_t *mthing)
 		     || (mthing->type >= 600 && mthing->type <= 609) // Special placement patterns
 		     || mthing->type == 1705 || mthing->type == 1713) // Hoops
 		return true; // These are handled elsewhere.
+	else if (mthing->type == mobjinfo[MT_EMERHUNT].doomednum)
+	{
+		// Emerald Hunt is Coop only. Don't spawn the emerald yet, but save the spawnpoint for later.
+		if (gametype == GT_COOP && numhuntemeralds < MAXHUNTEMERALDS)
+			huntemeralds[numhuntemeralds++] = mthing;
+		return true;
+	}
 
 	return false;
 }
@@ -11728,14 +11735,6 @@ static boolean P_AllowMobjSpawn(mapthing_t* mthing, mobjtype_t i)
 			return false;
 
 		break;
-	case MT_EMERHUNT:
-		// Emerald Hunt is Coop only.
-		if (gametype != GT_COOP)
-			return false;
-
-		if (numhuntemeralds < MAXHUNTEMERALDS)
-			huntemeralds[numhuntemeralds++] = mthing;
-		return false;
 	case MT_EMERALDSPAWN:
 		if (!cv_powerstones.value)
 			return false;
@@ -13004,47 +13003,12 @@ static void P_SetObjectSpecial(mobj_t *mobj)
 		mobj->flags |= MF_BOUNCE;
 	}
 }
-//
-// P_SpawnMapThing
-// The fields of the mapthing should
-// already be in host byte order.
-//
-mobj_t *P_SpawnMapThing(mapthing_t *mthing)
+
+mobj_t *P_SpawnMobjFromMapThing(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, mobjtype_t i)
 {
-	mobjtype_t i;
 	mobj_t *mobj = NULL;
-	fixed_t x, y, z;
 	boolean doangle = true;
 
-	if (!mthing->type)
-		return mobj; // Ignore type-0 things as NOPs
-
-	if (mthing->type == 3328) // 3D Mode start Thing
-		return mobj;
-
-	if (!objectplacing && P_SpawnNonMobjMapThing(mthing))
-		return mobj;
-
-	i = P_GetMobjtype(mthing->type);
-	if (i == MT_UNKNOWN)
-		CONS_Alert(CONS_WARNING, M_GetText("Unknown thing type %d placed at (%d, %d)\n"), mthing->type, mthing->x, mthing->y);
-
-	// Skip all returning/substitution code in objectplace.
-	if (!objectplacing)
-	{
-		if (!P_AllowMobjSpawn(mthing, i))
-			return mobj;
-
-		i = P_GetMobjtypeSubstitute(mthing, i);
-		if (i == MT_NULL) // Don't spawn mobj
-			return mobj;
-	}
-
-	// spawn it
-	x = mthing->x << FRACBITS;
-	y = mthing->y << FRACBITS;
-	z = P_GetMapThingSpawnHeight(i, mthing, x, y);
-
 	mobj = P_SpawnMobj(x, y, z, i);
 	mobj->spawnpoint = mthing;
 
@@ -13052,7 +13016,7 @@ mobj_t *P_SpawnMapThing(mapthing_t *mthing)
 		return mobj;
 
 	if (doangle)
-		mobj->angle = FixedAngle(mthing->angle<<FRACBITS);
+		mobj->angle = FixedAngle(mthing->angle << FRACBITS);
 
 	mthing->mobj = mobj;
 
@@ -13061,8 +13025,8 @@ mobj_t *P_SpawnMapThing(mapthing_t *mthing)
 		return mobj;
 
 	if ((mthing->options & MTF_AMBUSH)
-	&& (mthing->options & MTF_OBJECTSPECIAL)
-	&& (mobj->flags & MF_PUSHABLE))
+		&& (mthing->options & MTF_OBJECTSPECIAL)
+		&& (mobj->flags & MF_PUSHABLE))
 		mobj->flags2 |= MF2_CLASSICPUSH;
 	else
 	{
@@ -13097,6 +13061,47 @@ mobj_t *P_SpawnMapThing(mapthing_t *mthing)
 	return mobj;
 }
 
+//
+// P_SpawnMapThing
+// The fields of the mapthing should
+// already be in host byte order.
+//
+mobj_t *P_SpawnMapThing(mapthing_t *mthing)
+{
+	mobjtype_t i;
+	mobj_t *mobj = NULL;
+	fixed_t x, y, z;
+
+	if (!mthing->type)
+		return mobj; // Ignore type-0 things as NOPs
+
+	if (mthing->type == 3328) // 3D Mode start Thing
+		return mobj;
+
+	if (!objectplacing && P_SpawnNonMobjMapThing(mthing))
+		return mobj;
+
+	i = P_GetMobjtype(mthing->type);
+	if (i == MT_UNKNOWN)
+		CONS_Alert(CONS_WARNING, M_GetText("Unknown thing type %d placed at (%d, %d)\n"), mthing->type, mthing->x, mthing->y);
+
+	// Skip all returning/substitution code in objectplace.
+	if (!objectplacing)
+	{
+		if (!P_AllowMobjSpawn(mthing, i))
+			return mobj;
+
+		i = P_GetMobjtypeSubstitute(mthing, i);
+		if (i == MT_NULL) // Don't spawn mobj
+			return mobj;
+	}
+
+	x = mthing->x << FRACBITS;
+	y = mthing->y << FRACBITS;
+	z = P_GetMapThingSpawnHeight(i, mthing, x, y);
+	return P_SpawnMobjFromMapThing(mthing, x, y, z, i);
+}
+
 static void P_SpawnHoopInternal(mapthing_t *mthing, INT32 hoopsize, fixed_t sizefactor)
 {
 	mobj_t *mobj = NULL;
@@ -13223,21 +13228,29 @@ void P_SpawnBonusTimeItem(mapthing_t *mthing)
 		P_SetMobjState(mobj, mobj->info->raisestate);
 }
 
-static void P_SpawnItemRow(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle)
+static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t itemtype, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
 {
-	mobjtype_t ringthing = MT_RING;
+	mapthing_t dummything = *mthing;
 	mobj_t *mobj = NULL;
+	fixed_t x = mthing->x << FRACBITS;
+	fixed_t y = mthing->y << FRACBITS;
+	fixed_t z = mthing->z << FRACBITS;
 	INT32 r;
 	angle_t angle = FixedAngle(fixedangle << FRACBITS);
 	angle_t fineangle = (angle >> ANGLETOFINESHIFT) & FINEMASK;
 
-	if (ultimatemode)
-		return; // No rings in Ultimate!
+	dummything.type = mobjinfo[itemtype].doomednum;
+	// Skip all returning/substitution code in objectplace.
+	if (!objectplacing)
+	{
+		if (!P_AllowMobjSpawn(&dummything, itemtype))
+			return;
 
-	if (nightsreplace)
-		ringthing = MT_NIGHTSSTAR;
-
-	z = P_GetMobjSpawnHeight(ringthing, x, y, z, mthing->options & MTF_OBJECTFLIP);
+		itemtype = P_GetMobjtypeSubstitute(&dummything, itemtype);
+		if (itemtype == MT_NULL) // Don't spawn
+			return;
+	}
+	z = P_GetMobjSpawnHeight(itemtype, x, y, z, mthing->options & MTF_OBJECTFLIP);
 
 	for (r = 0; r < numitems; r++)
 	{
@@ -13245,20 +13258,14 @@ static void P_SpawnItemRow(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z,
 		y += FixedMul(horizontalspacing, FINESINE(fineangle));
 		z += (mthing->options & MTF_OBJECTFLIP) ? -verticalspacing : verticalspacing;
 
-		mobj = P_SpawnMobj(x, y, z, ringthing);
+		mobj = P_SpawnMobjFromMapThing(&dummything, x, y, z, itemtype);
 
-		if (mthing->options & MTF_OBJECTFLIP)
-		{
-			mobj->eflags |= MFE_VERTICALFLIP;
-			mobj->flags2 |= MF2_OBJECTFLIP;
-		}
+		if (!mobj)
+			continue;
 
-		mobj->angle = angle;
-		if (mthing->options & MTF_AMBUSH)
-			mobj->flags2 |= MF2_AMBUSH;
-
-		if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
-			P_SetMobjState(mobj, mobj->info->seestate);
+		mobj->spawnpoint = NULL;
+		if (bonustime && (mobj->type == MT_BLUESPHERE || mobj->type == MT_NIGHTSCHIP))
+			P_SetMobjState(mobj, mobj->info->raisestate);
 	}
 }
 
@@ -13271,6 +13278,9 @@ static void P_SpawnItemCircle(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t
 	INT32 i;
 	TVector v, *res;
 
+	if (metalrecording)
+		return;
+
 	z = P_GetMobjSpawnHeight(ringthing, x, y, z, false);
 
 	closestangle = FixedAngle(mthing->angle << FRACBITS);
@@ -13350,23 +13360,20 @@ void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime)
 	fixed_t y = mthing->y << FRACBITS;
 	fixed_t z = mthing->z << FRACBITS;
 
-	if (metalrecording)
-		return;
-
 	switch (mthing->type)
 	{
 	// Special placement patterns
 	case 600: // 5 vertical rings (yellow spring)
-		P_SpawnItemRow(mthing, x, y, z, 5, 0, 64*FRACUNIT, 0);
+		P_SpawnItemRow(mthing, MT_RING, 5, 0, 64*FRACUNIT, 0, bonustime);
 		return;
 	case 601: // 5 vertical rings (red spring)
-		P_SpawnItemRow(mthing, x, y, z, 5, 0, 128*FRACUNIT, 0);
+		P_SpawnItemRow(mthing, MT_RING, 5, 0, 128*FRACUNIT, 0, bonustime);
 		return;
 	case 602: // 5 diagonal rings (yellow spring)
-		P_SpawnItemRow(mthing, x, y, z, 5, 64*FRACUNIT, 64*FRACUNIT, mthing->angle);
+		P_SpawnItemRow(mthing, MT_RING, 5, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
 		return;
 	case 603: // 10 diagonal rings (red spring)
-		P_SpawnItemRow(mthing, x, y, z, 10, 64*FRACUNIT, 64*FRACUNIT, mthing->angle);
+		P_SpawnItemRow(mthing, MT_RING, 10, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
 		return;
 	case 604: // Circle of rings (8 items)
 	case 605: // Circle of rings (16 items)

From 72a1571937a6c4e33fb80b23969018b241769c71 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 12:38:16 +0100
Subject: [PATCH 07/10] Allow P_SpawnItemCircle to spawn arbitrary mobjtypes
 (will be used in UDMF)

---
 src/p_mobj.c | 113 ++++++++++++++++++++-------------------------------
 1 file changed, 45 insertions(+), 68 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 427f3526d..a72c59421 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -13269,97 +13269,66 @@ static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t itemtype, INT32 numite
 	}
 }
 
-static void P_SpawnItemCircle(mapthing_t *mthing, fixed_t x, fixed_t y, fixed_t z, INT32 numitems, fixed_t size, boolean bonustime)
+static void P_SpawnItemCircle(mapthing_t *mthing, mobjtype_t *itemtypes, UINT8 numitemtypes, INT32 numitems, fixed_t size, boolean bonustime)
 {
-	mobjtype_t ringthing = MT_RING;
-	mobj_t *mobj = NULL;
-	fixed_t finalx, finaly, finalz;
-	angle_t closestangle, fa;
+	mapthing_t dummything;
+	mobj_t* mobj = NULL;
+	fixed_t x = mthing->x << FRACBITS;
+	fixed_t y = mthing->y << FRACBITS;
+	fixed_t z = mthing->z << FRACBITS;
+	angle_t angle = FixedAngle(mthing->angle << FRACBITS);
+	angle_t fa;
 	INT32 i;
 	TVector v, *res;
 
-	if (metalrecording)
-		return;
-
-	z = P_GetMobjSpawnHeight(ringthing, x, y, z, false);
-
-	closestangle = FixedAngle(mthing->angle << FRACBITS);
-
-	switch (mthing->type)
+	for (i = 0; i < numitemtypes; i++)
 	{
-	case 604:
-	case 605:
-		if (ultimatemode)
-			return; // No rings in Ultimate!
-		if (nightsreplace)
-			ringthing = MT_NIGHTSSTAR;
-		break;
-	case 608:
-	case 609:
-		/*ringthing = (i & 1) ? MT_RING : MT_BLUESPHERE; -- i == 0 is bluesphere
-		break;*/
-	case 606:
-	case 607:
-		ringthing = (nightsreplace) ? MT_NIGHTSCHIP : MT_BLUESPHERE;
-		break;
-	default:
-		break;
-	}
+		dummything = *mthing;
+		dummything.type = mobjinfo[itemtypes[i]].doomednum;
+		// Skip all returning/substitution code in objectplace.
+		if (!objectplacing)
+		{
+			if (!P_AllowMobjSpawn(&dummything, itemtypes[i]))
+			{
+				itemtypes[i] = MT_NULL;
+				continue;
+			}
+
+			itemtypes[i] = P_GetMobjtypeSubstitute(&dummything, itemtypes[i]);
+		}
+	}
+	z = P_GetMobjSpawnHeight(itemtypes[0], x, y, z, false);
 
-	// Create the hoop!
 	for (i = 0; i < numitems; i++)
 	{
-		if (mthing->type == 608 || mthing->type == 609)
-		{
-			if (i & 1)
-			{
-				if (ultimatemode)
-					continue; // No rings in Ultimate!
-				ringthing = (nightsreplace) ? MT_NIGHTSSTAR : MT_RING;
-			}
-			else
-				ringthing = (nightsreplace) ? MT_NIGHTSCHIP : MT_BLUESPHERE;
-		}
+		mobjtype_t itemtype = itemtypes[i % numitemtypes];
+		if (itemtype == MT_NULL)
+			continue;
+		dummything.type = mobjinfo[itemtype].doomednum;
 
-		fa = i * FINEANGLES/numitems;
+		fa = i*FINEANGLES/numitems;
 		v[0] = FixedMul(FINECOSINE(fa), size);
 		v[1] = 0;
 		v[2] = FixedMul(FINESINE(fa), size);
 		v[3] = FRACUNIT;
 
-		res = VectorMatrixMultiply(v, *RotateZMatrix(closestangle));
+		res = VectorMatrixMultiply(v, *RotateZMatrix(angle));
 		M_Memcpy(&v, res, sizeof(v));
 
-		finalx = x + v[0];
-		finaly = y + v[1];
-		finalz = z + v[2];
+		mobj = P_SpawnMobjFromMapThing(&dummything, x + v[0], y + v[1], z + v[2], itemtype);
+
+		if (!mobj)
+			continue;
 
-		mobj = P_SpawnMobj(finalx, finaly, finalz, ringthing);
 		mobj->z -= mobj->height/2;
-
-		if (mthing->options & MTF_OBJECTFLIP)
-		{
-			mobj->eflags |= MFE_VERTICALFLIP;
-			mobj->flags2 |= MF2_OBJECTFLIP;
-		}
-
-		mobj->angle = closestangle;
-		if (mthing->options & MTF_AMBUSH)
-			mobj->flags2 |= MF2_AMBUSH;
-
-		if (bonustime && (ringthing == MT_BLUESPHERE || ringthing == MT_NIGHTSCHIP))
+		mobj->spawnpoint = NULL;
+		if (bonustime && (mobj->type == MT_BLUESPHERE || mobj->type == MT_NIGHTSCHIP))
 			P_SetMobjState(mobj, mobj->info->raisestate);
-		else if ((maptol & TOL_XMAS) && (ringthing == MT_NIGHTSSTAR))
-			P_SetMobjState(mobj, mobj->info->seestate);
 	}
 }
 
 void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime)
 {
-	fixed_t x = mthing->x << FRACBITS;
-	fixed_t y = mthing->y << FRACBITS;
-	fixed_t z = mthing->z << FRACBITS;
-
 	switch (mthing->type)
 	{
 	// Special placement patterns
@@ -13379,12 +13348,20 @@ void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime)
 	case 605: // Circle of rings (16 items)
 	case 606: // Circle of blue spheres (8 items)
 	case 607: // Circle of blue spheres (16 items)
+	{
+		INT32 numitems = (mthing->type & 1) ? 16 : 8;
+		fixed_t size = (mthing->type & 1) ? 192*FRACUNIT : 96*FRACUNIT;
+		mobjtype_t itemtypes[1] = { (mthing->type & 1) ? MT_RING : MT_BLUESPHERE };
+		P_SpawnItemCircle(mthing, itemtypes, 1, numitems, size, bonustime);
+		return;
+	}
 	case 608: // Circle of rings and blue spheres (8 items)
 	case 609: // Circle of rings and blue spheres (16 items)
 	{
 		INT32 numitems = (mthing->type & 1) ? 16 : 8;
 		fixed_t size = (mthing->type & 1) ? 192*FRACUNIT : 96*FRACUNIT;
-		P_SpawnItemCircle(mthing, x, y, z, numitems, size, bonustime);
+		mobjtype_t itemtypes[2] = { MT_RING, MT_BLUESPHERE };
+		P_SpawnItemCircle(mthing, itemtypes, 2, numitems, size, bonustime);
 		return;
 	}
 	default:

From ac3a57aaf54802b0942c4b4b9c97a940136fbb35 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 12:47:44 +0100
Subject: [PATCH 08/10] Allow P_SpawnItemRow to spawn different item types in
 the same row

---
 src/p_mobj.c | 46 +++++++++++++++++++++++++++++++---------------
 1 file changed, 31 insertions(+), 15 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index a72c59421..88397e43b 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -13228,9 +13228,9 @@ void P_SpawnBonusTimeItem(mapthing_t *mthing)
 		P_SetMobjState(mobj, mobj->info->raisestate);
 }
 
-static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t itemtype, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
+static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t* itemtypes, UINT8 numitemtypes, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
 {
-	mapthing_t dummything = *mthing;
+	mapthing_t dummything;
 	mobj_t *mobj = NULL;
 	fixed_t x = mthing->x << FRACBITS;
 	fixed_t y = mthing->y << FRACBITS;
@@ -13239,21 +13239,31 @@ static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t itemtype, INT32 numite
 	angle_t angle = FixedAngle(fixedangle << FRACBITS);
 	angle_t fineangle = (angle >> ANGLETOFINESHIFT) & FINEMASK;
 
-	dummything.type = mobjinfo[itemtype].doomednum;
-	// Skip all returning/substitution code in objectplace.
-	if (!objectplacing)
+	for (r = 0; r < numitemtypes; r++)
 	{
-		if (!P_AllowMobjSpawn(&dummything, itemtype))
-			return;
+		dummything = *mthing;
+		dummything.type = mobjinfo[itemtypes[r]].doomednum;
+		// Skip all returning/substitution code in objectplace.
+		if (!objectplacing)
+		{
+			if (!P_AllowMobjSpawn(&dummything, itemtypes[r]))
+			{
+				itemtypes[r] = MT_NULL;
+				continue;
+			}
 
-		itemtype = P_GetMobjtypeSubstitute(&dummything, itemtype);
-		if (itemtype == MT_NULL) // Don't spawn
-			return;
+			itemtypes[r] = P_GetMobjtypeSubstitute(&dummything, itemtypes[r]);
+		}
 	}
-	z = P_GetMobjSpawnHeight(itemtype, x, y, z, mthing->options & MTF_OBJECTFLIP);
+	z = P_GetMobjSpawnHeight(itemtypes[0], x, y, z, mthing->options & MTF_OBJECTFLIP);
 
 	for (r = 0; r < numitems; r++)
 	{
+		mobjtype_t itemtype = itemtypes[r % numitemtypes];
+		if (itemtype == MT_NULL)
+			continue;
+		dummything.type = mobjinfo[itemtype].doomednum;
+
 		x += FixedMul(horizontalspacing, FINECOSINE(fineangle));
 		y += FixedMul(horizontalspacing, FINESINE(fineangle));
 		z += (mthing->options & MTF_OBJECTFLIP) ? -verticalspacing : verticalspacing;
@@ -13269,6 +13279,12 @@ static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t itemtype, INT32 numite
 	}
 }
 
+static void P_SpawnSingularItemRow(mapthing_t* mthing, mobjtype_t itemtype, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
+{
+	mobjtype_t itemtypes[1] = { itemtype };
+	return P_SpawnItemRow(mthing, itemtypes, 1, numitems, horizontalspacing, verticalspacing, fixedangle, bonustime);
+}
+
 static void P_SpawnItemCircle(mapthing_t *mthing, mobjtype_t *itemtypes, UINT8 numitemtypes, INT32 numitems, fixed_t size, boolean bonustime)
 {
 	mapthing_t dummything;
@@ -13333,16 +13349,16 @@ void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime)
 	{
 	// Special placement patterns
 	case 600: // 5 vertical rings (yellow spring)
-		P_SpawnItemRow(mthing, MT_RING, 5, 0, 64*FRACUNIT, 0, bonustime);
+		P_SpawnSingularItemRow(mthing, MT_RING, 5, 0, 64*FRACUNIT, 0, bonustime);
 		return;
 	case 601: // 5 vertical rings (red spring)
-		P_SpawnItemRow(mthing, MT_RING, 5, 0, 128*FRACUNIT, 0, bonustime);
+		P_SpawnSingularItemRow(mthing, MT_RING, 5, 0, 128*FRACUNIT, 0, bonustime);
 		return;
 	case 602: // 5 diagonal rings (yellow spring)
-		P_SpawnItemRow(mthing, MT_RING, 5, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
+		P_SpawnSingularItemRow(mthing, MT_RING, 5, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
 		return;
 	case 603: // 10 diagonal rings (red spring)
-		P_SpawnItemRow(mthing, MT_RING, 10, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
+		P_SpawnSingularItemRow(mthing, MT_RING, 10, 64*FRACUNIT, 64*FRACUNIT, mthing->angle, bonustime);
 		return;
 	case 604: // Circle of rings (8 items)
 	case 605: // Circle of rings (16 items)

From a57f903933fd232dea79f3c3e02eaaa28e4ae355 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 12:52:43 +0100
Subject: [PATCH 09/10] Move bonus time handling into new function
 P_SetBonusTime()

---
 src/p_mobj.c  | 20 ++++++++++++--------
 src/p_mobj.h  |  2 +-
 src/p_setup.c |  2 +-
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 88397e43b..866ffaf70 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -13221,11 +13221,15 @@ void P_SpawnHoop(mapthing_t *mthing)
 		P_SpawnHoopInternal(mthing, 8 + (4*(mthing->options & 0xF)), 4*FRACUNIT);
 }
 
-void P_SpawnBonusTimeItem(mapthing_t *mthing)
+void P_SetBonusTime(mobj_t *mobj)
 {
-	mobj_t *mobj = P_SpawnMapThing(mthing);
-	if (mobj && (mobj->type == MT_BLUESPHERE || mobj->type == MT_NIGHTSCHIP))
-		P_SetMobjState(mobj, mobj->info->raisestate);
+	if (!mobj)
+		return;
+
+	if (mobj->type != MT_BLUESPHERE && mobj->type != MT_NIGHTSCHIP)
+		return;
+
+	P_SetMobjState(mobj, mobj->info->raisestate);
 }
 
 static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t* itemtypes, UINT8 numitemtypes, INT32 numitems, fixed_t horizontalspacing, fixed_t verticalspacing, INT16 fixedangle, boolean bonustime)
@@ -13274,8 +13278,8 @@ static void P_SpawnItemRow(mapthing_t *mthing, mobjtype_t* itemtypes, UINT8 numi
 			continue;
 
 		mobj->spawnpoint = NULL;
-		if (bonustime && (mobj->type == MT_BLUESPHERE || mobj->type == MT_NIGHTSCHIP))
-			P_SetMobjState(mobj, mobj->info->raisestate);
+		if (bonustime)
+			P_SetBonusTime(mobj);
 	}
 }
 
@@ -13338,8 +13342,8 @@ static void P_SpawnItemCircle(mapthing_t *mthing, mobjtype_t *itemtypes, UINT8 n
 
 		mobj->z -= mobj->height/2;
 		mobj->spawnpoint = NULL;
-		if (bonustime && (mobj->type == MT_BLUESPHERE || mobj->type == MT_NIGHTSCHIP))
-			P_SetMobjState(mobj, mobj->info->raisestate);
+		if (bonustime)
+			P_SetBonusTime(mobj);
 	}
 }
 
diff --git a/src/p_mobj.h b/src/p_mobj.h
index 9b015d23c..a272003c1 100644
--- a/src/p_mobj.h
+++ b/src/p_mobj.h
@@ -458,7 +458,7 @@ void P_AfterPlayerSpawn(INT32 playernum);
 
 mobj_t *P_SpawnMapThing(mapthing_t *mthing);
 void P_SpawnHoop(mapthing_t *mthing);
-void P_SpawnBonusTimeItem(mapthing_t *mthing);
+void P_SetBonusTime(mobj_t *mobj);
 void P_SpawnItemPattern(mapthing_t *mthing, boolean bonustime);
 void P_SpawnHoopOfSomething(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, angle_t rotangle);
 void P_SpawnPrecipitation(void);
diff --git a/src/p_setup.c b/src/p_setup.c
index 46fe118c4..41d61704f 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -816,7 +816,7 @@ void P_ReloadRings(void)
 			|| mt->type == mobjinfo[MT_BLUESPHERE].doomednum || mt->type == mobjinfo[MT_BOMBSPHERE].doomednum)
 		{
 			mt->mobj = NULL;
-			P_SpawnBonusTimeItem(mt);
+			P_SetBonusTime(P_SpawnMapThing(mt));
 		}
 		else if (mt->type >= 600 && mt->type <= 609) // Item patterns
 		{

From 13eb71e1ee5910f07eeae15931d2873f4ed9d576 Mon Sep 17 00:00:00 2001
From: MascaraSnake <jonassauer27@gmail.com>
Date: Tue, 24 Dec 2019 12:58:12 +0100
Subject: [PATCH 10/10] Fixed missing break in offset handling for horizontal
 springs

---
 src/p_mobj.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 866ffaf70..13f75b94a 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -11618,6 +11618,7 @@ static fixed_t P_GetMapThingSpawnHeight(const mobjtype_t mobjtype, const mapthin
 	case MT_REDHORIZ:
 	case MT_BLUEHORIZ:
 		offset += mthing->options & MTF_AMBUSH ? 16*FRACUNIT : 0;
+		break;
 
 	// Ring-like items, may float additional units with MTF_AMBUSH.
 	case MT_SPIKEBALL: