From 317dfe5ae0261a8279d763d68cd9255d0e3784c1 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 00:24:29 -0500
Subject: [PATCH 01/30] Bots brake earlier

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

diff --git a/src/k_bot.c b/src/k_bot.c
index 32270b419..331309f9a 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -1053,7 +1053,7 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 			finishBeamLine->v1->x, finishBeamLine->v1->y,
 			finishBeamLine->v2->x, finishBeamLine->v2->y,
 			player->mo->x, player->mo->y
-		);
+		) - player->speed;
 
 		// Don't run the spindash code at all until we're in the right place
 		trySpindash = false;

From 5ac116dc12fc9dcf4b9389879ee7ff3842e050ed Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 00:31:13 -0500
Subject: [PATCH 02/30] Don't use rings during POSITION

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

diff --git a/src/k_botitem.c b/src/k_botitem.c
index a871c2305..c82c9808c 100644
--- a/src/k_botitem.c
+++ b/src/k_botitem.c
@@ -971,7 +971,7 @@ void K_BotItemUsage(player_t *player, ticcmd_t *cmd, INT16 turnamt)
 	{
 		// Use rings!
 
-		if (!player->exiting)
+		if (leveltime > starttime && !player->exiting)
 		{
 			K_BotItemRings(player, cmd);
 		}

From 43a92892e95111a396ab030084d73bb531978ae6 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 01:58:13 -0500
Subject: [PATCH 03/30] New turning towards objects style

---
 src/k_bot.c       |   8 +-
 src/k_bot.h       |   4 +-
 src/k_botsearch.c | 227 +++++++++++++++++++++-------------------------
 3 files changed, 109 insertions(+), 130 deletions(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index 1abe44913..c1fc11b6c 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -936,6 +936,9 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 		else
 		{
 			predict = K_CreateBotPrediction(player);
+
+			K_NudgePredictionTowardsObjects(predict, player);
+
 			destangle = R_PointToAngle2(player->mo->x, player->mo->y, predict->x, predict->y);
 		}
 
@@ -1033,11 +1036,6 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 				cmd->forwardmove /= 2;
 				cmd->buttons |= BT_BRAKE;
 			}
-			else if (dirdist <= realrad)
-			{
-				// Steer towards/away from objects!
-				turnamt += K_BotFindObjects(player, turnamt);
-			}
 		}
 	}
 
diff --git a/src/k_bot.h b/src/k_bot.h
index 2cb1ae460..f5187ece6 100644
--- a/src/k_bot.h
+++ b/src/k_bot.h
@@ -198,7 +198,7 @@ fixed_t K_BotReducePrediction(player_t *player);
 
 
 /*--------------------------------------------------
-	INT16 K_BotFindObjects(player_t *player, INT16 turn);
+	void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player);
 
 		Generates a sum for objects to steer towards/away from.
 
@@ -210,7 +210,7 @@ fixed_t K_BotReducePrediction(player_t *player);
 		Turn amount sum to add to final product.
 --------------------------------------------------*/
 
-INT16 K_BotFindObjects(player_t *player, INT16 turn);
+void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player);
 
 
 /*--------------------------------------------------
diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 5d6425127..0708bf411 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -31,12 +31,16 @@
 struct globalsmuggle
 {
 	mobj_t *botmo;
+	botprediction_t *predict;
 	fixed_t distancetocheck;
 
-	fixed_t closestlinedist;
+	INT64 gotoAvgX, gotoAvgY;
+	UINT32 gotoObjs;
 
-	INT16 curturn;
-	INT16 steer;
+	INT64 avoidAvgX, avoidAvgY;
+	UINT32 avoidObjs;
+
+	fixed_t closestlinedist;
 
 	fixed_t eggboxx, eggboxy;
 	UINT8 randomitems;
@@ -419,83 +423,7 @@ fixed_t K_BotReducePrediction(player_t *player)
 }
 
 /*--------------------------------------------------
-	static void K_SteerFromObject(mobj_t *bot, mobj_t *thing, fixed_t fulldist, fixed_t xdist, boolean towards, INT16 amount)
-
-		Handles steering away/towards the specified object.
-
-	Input Arguments:-
-		bot - Bot's mobj.
-		thing - Mobj to steer towards/away from.
-		fulldist - Distance away from object.
-		xdist - Horizontal distance away from object.
-		towards - If true, steer towards the object. Otherwise, steer away.
-		amount - How hard to turn.
-
-	Return:-
-		None
---------------------------------------------------*/
-static void K_SteerFromObject(mobj_t *bot, mobj_t *thing, fixed_t fulldist, fixed_t xdist, boolean towards, INT16 amount)
-{
-	angle_t destangle = R_PointToAngle2(bot->x, bot->y, thing->x, thing->y);
-	angle_t angle;
-	SINT8 flip = 1;
-
-	amount = (amount * FixedDiv(globalsmuggle.distancetocheck - fulldist, globalsmuggle.distancetocheck)) / FRACUNIT;
-
-	if (amount == 0)
-	{
-		// Shouldn't happen
-		return;
-	}
-
-	if (towards)
-	{
-		if (xdist < FixedHypot(bot->radius, thing->radius))
-		{
-			// Don't need to turn any harder!
-
-			if (abs(globalsmuggle.steer) <= amount)
-			{
-				globalsmuggle.steer = 0;
-			}
-			else
-			{
-				if (globalsmuggle.steer > 0)
-				{
-					globalsmuggle.steer -= amount;
-				}
-				else if (globalsmuggle.steer < 0)
-				{
-					globalsmuggle.steer += amount;
-				}
-			}
-
-			return;
-		}
-
-		// Still turning towards it, flip.
-		flip = -flip;
-	}
-
-	angle = (bot->angle - destangle);
-	if (angle < ANGLE_180)
-	{
-		flip = -flip;
-	}
-
-	// If going in the opposite direction of where you wanted to turn,
-	// then reduce the amount that you can turn in that direction.
-	if ((flip == 1 && globalsmuggle.curturn < 0)
-	|| (flip == -1 && globalsmuggle.curturn > 0))
-	{
-		amount /= 4;
-	}
-
-	globalsmuggle.steer += amount * flip;
-}
-
-/*--------------------------------------------------
-	static boolean K_BotSteerObjects(mobj_t *thing)
+	static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 		Blockmap search function.
 		Finds objects around the bot to steer towards/away from.
@@ -506,20 +434,18 @@ static void K_SteerFromObject(mobj_t *bot, mobj_t *thing, fixed_t fulldist, fixe
 	Return:-
 		true continues searching, false ends the search early.
 --------------------------------------------------*/
-static boolean K_BotSteerObjects(mobj_t *thing)
+static boolean K_FindObjectsForNudging(mobj_t *thing)
 {
 	INT16 anglediff;
-	fixed_t xdist, ydist, fulldist;
-	angle_t destangle, angle;
-	INT16 attack = ((9 - globalsmuggle.botmo->player->kartspeed) * KART_FULLTURN) / 8; // Acceleration chars are more aggressive
-	INT16 dodge = ((9 - globalsmuggle.botmo->player->kartweight) * KART_FULLTURN) / 8; // Handling chars dodge better
+	fixed_t fulldist;
+	angle_t destangle, angle, predictangle;
 
 	if (!globalsmuggle.botmo || P_MobjWasRemoved(globalsmuggle.botmo) || !globalsmuggle.botmo->player)
 	{
 		return false;
 	}
 
-	if (!thing->health)
+	if (thing->health <= 0)
 	{
 		return true;
 	}
@@ -529,19 +455,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 		return true;
 	}
 
-	xdist = K_DistanceOfLineFromPoint(
-		globalsmuggle.botmo->x, globalsmuggle.botmo->y,
-		globalsmuggle.botmo->x + FINECOSINE(globalsmuggle.botmo->angle >> ANGLETOFINESHIFT), globalsmuggle.botmo->y + FINESINE(globalsmuggle.botmo->angle >> ANGLETOFINESHIFT),
-		thing->x, thing->y
-	) / 2; // weight x dist more heavily than y dist
-
-	ydist = K_DistanceOfLineFromPoint(
-		globalsmuggle.botmo->x, globalsmuggle.botmo->y,
-		globalsmuggle.botmo->x + FINECOSINE((globalsmuggle.botmo->angle + ANGLE_90) >> ANGLETOFINESHIFT), globalsmuggle.botmo->y + FINESINE((globalsmuggle.botmo->angle + ANGLE_90) >> ANGLETOFINESHIFT),
-		thing->x, thing->y
-	);
-
-	fulldist = FixedHypot(xdist, ydist);
+	fulldist = R_PointToDist2(globalsmuggle.predict->x, globalsmuggle.predict->y, thing->x, thing->y);
 
 	if (fulldist > globalsmuggle.distancetocheck)
 	{
@@ -553,8 +467,9 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 		return true;
 	}
 
+	predictangle = R_PointToAngle2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, globalsmuggle.predict->x, globalsmuggle.predict->y);
 	destangle = R_PointToAngle2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y);
-	angle = (globalsmuggle.botmo->angle - destangle);
+	angle = (predictangle - destangle);
 
 	if (angle < ANGLE_180)
 	{
@@ -567,14 +482,24 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 
 	anglediff = abs(anglediff);
 
+#define AddAttackObj(thing) \
+	globalsmuggle.gotoAvgX += thing->x / mapobjectscale; \
+	globalsmuggle.gotoAvgY += thing->y / mapobjectscale; \
+	globalsmuggle.gotoObjs++;
+
+#define AddDodgeObj(thing) \
+	globalsmuggle.avoidAvgX += thing->x / mapobjectscale; \
+	globalsmuggle.avoidAvgY += thing->y / mapobjectscale; \
+	globalsmuggle.avoidObjs++;
+
 #define PlayerAttackSteer(botcond, thingcond) \
 	if ((botcond) && !(thingcond)) \
 	{ \
-		K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, 2 * (KART_FULLTURN + attack)); \
+		AddAttackObj(thing) \
 	} \
 	else if ((thingcond) && !(botcond)) \
 	{ \
-		K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge)); \
+		AddDodgeObj(thing) \
 	}
 
 	switch (thing->type)
@@ -593,7 +518,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 		case MT_BALLHOG:
 		case MT_SPB:
 		case MT_BUBBLESHIELDTRAP:
-			K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge));
+			AddDodgeObj(thing)
 			break;
 		case MT_RANDOMITEM:
 			if (anglediff >= 60)
@@ -603,7 +528,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 
 			if (P_CanPickupItem(globalsmuggle.botmo->player, 1))
 			{
-				K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, KART_FULLTURN + attack);
+				AddAttackObj(thing)
 			}
 			break;
 		case MT_EGGMANITEM:
@@ -619,11 +544,11 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 
 				if (stealth >= requiredstealth)
 				{
-					K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, 2 * (KART_FULLTURN + attack));
+					AddAttackObj(thing)
 				}
 				else
 				{
-					K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge));
+					AddDodgeObj(thing)
 				}
 			}
 			break;
@@ -635,7 +560,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 
 			if (P_CanPickupItem(globalsmuggle.botmo->player, 3))
 			{
-				K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, KART_FULLTURN + attack);
+				AddAttackObj(thing)
 			}
 			break;
 		case MT_RING:
@@ -650,11 +575,7 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 				&& !thing->extravalue1
 				&& (globalsmuggle.botmo->player->kartstuff[k_itemtype] != KITEM_THUNDERSHIELD))
 			{
-				K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true,
-					(RINGTOTAL(globalsmuggle.botmo->player) < 3
-					? (4 * (KART_FULLTURN + attack))
-					: (KART_FULLTURN + attack))
-				);
+				AddAttackObj(thing)
 			}
 			break;
 		case MT_PLAYER:
@@ -716,11 +637,11 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 
 					if (weightdiff > mapobjectscale)
 					{
-						K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, KART_FULLTURN + attack);
+						AddAttackObj(thing)
 					}
 					else
 					{
-						K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, KART_FULLTURN + dodge);
+						AddDodgeObj(thing)
 					}
 				}
 			}
@@ -733,16 +654,16 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 
 			if (thing->extravalue1 == 0)
 			{
-				K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, thing->extravalue2 * (KART_FULLTURN + dodge));
+				AddDodgeObj(thing)
 			}
 			{
-				K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, true, thing->extravalue2 * (KART_FULLTURN + attack));
+				AddAttackObj(thing)
 			}
 			break;
 		default:
 			if (thing->flags & (MF_SOLID|MF_ENEMY|MF_BOSS|MF_PAIN|MF_MISSILE))
 			{
-				K_SteerFromObject(globalsmuggle.botmo, thing, fulldist, xdist, false, 2 * (KART_FULLTURN + dodge));
+				AddDodgeObj(thing)
 			}
 			break;
 	}
@@ -751,19 +672,31 @@ static boolean K_BotSteerObjects(mobj_t *thing)
 }
 
 /*--------------------------------------------------
-	INT16 K_BotFindObjects(player_t *player, INT16 turn)
+	void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 
 		See header file for description.
 --------------------------------------------------*/
-INT16 K_BotFindObjects(player_t *player, INT16 turn)
+void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 {
 	INT32 xl, xh, yl, yh, bx, by;
 
-	globalsmuggle.steer = 0;
+	const fixed_t baseNudge = 8 * mapobjectscale;
+	fixed_t avgX = 0, avgY = 0;
+	fixed_t avgDist = 0;
+	fixed_t nudgeDist = 0;
+	angle_t nudgeDir = 0;
+
 	globalsmuggle.botmo = player->mo;
-	globalsmuggle.curturn = turn;
+	globalsmuggle.predict = predict;
+
 	globalsmuggle.distancetocheck = (player->mo->radius * 32) + (player->speed * 4);
 
+	globalsmuggle.gotoAvgX = globalsmuggle.gotoAvgY = 0;
+	globalsmuggle.gotoObjs = 0;
+
+	globalsmuggle.avoidAvgX = globalsmuggle.avoidAvgY = 0;
+	globalsmuggle.avoidObjs = 0;
+
 	xl = (unsigned)(globalsmuggle.botmo->x - globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT;
 	xh = (unsigned)(globalsmuggle.botmo->x + globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT;
 	yl = (unsigned)(globalsmuggle.botmo->y - globalsmuggle.distancetocheck - bmaporgy)>>MAPBLOCKSHIFT;
@@ -775,9 +708,57 @@ INT16 K_BotFindObjects(player_t *player, INT16 turn)
 	{
 		for (by = yl; by <= yh; by++)
 		{
-			P_BlockThingsIterator(bx, by, K_BotSteerObjects);
+			P_BlockThingsIterator(bx, by, K_FindObjectsForNudging);
 		}
 	}
 
-	return globalsmuggle.steer;
+	if (globalsmuggle.avoidObjs > 0)
+	{
+		avgX = (globalsmuggle.avoidAvgX / globalsmuggle.avoidObjs) * mapobjectscale;
+		avgY = (globalsmuggle.avoidAvgY / globalsmuggle.avoidObjs) * mapobjectscale;
+
+		avgDist = R_PointToDist2(
+			globalsmuggle.avoidAvgX, globalsmuggle.avoidAvgY,
+			predict->x, predict->y
+		);
+
+		nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
+
+		nudgeDir = R_PointToAngle2(
+			globalsmuggle.avoidAvgX, globalsmuggle.avoidAvgY,
+			predict->x, predict->y
+		);
+
+		predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));
+		predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
+	}
+
+	if (globalsmuggle.gotoObjs > 0)
+	{
+		avgX = (globalsmuggle.gotoAvgX / globalsmuggle.gotoObjs) * mapobjectscale;
+		avgY = (globalsmuggle.gotoAvgY / globalsmuggle.gotoObjs) * mapobjectscale;
+
+		avgDist = R_PointToDist2(
+			predict->x, predict->y,
+			globalsmuggle.gotoAvgX, globalsmuggle.gotoAvgY
+		);
+
+		nudgeDist = ((9 - globalsmuggle.botmo->player->kartspeed) + 1) * baseNudge;
+
+		if (avgDist <= nudgeDist)
+		{
+			predict->x = avgX;
+			predict->y = avgY;
+		}
+		else
+		{
+			nudgeDir = R_PointToAngle2(
+				predict->x, predict->y,
+				globalsmuggle.gotoAvgX, globalsmuggle.gotoAvgY
+			);
+
+			predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));
+			predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
+		}
+	}
 }

From 4b158c44cde6ecdf3880075b26a90296cc820b50 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 02:41:41 -0500
Subject: [PATCH 04/30] Add debug command to show the bot's prediction

---
 src/d_netcmd.c |  1 +
 src/d_netcmd.h |  2 +-
 src/k_bot.c    | 22 ++++++++++++++++++++++
 src/k_kart.c   |  1 +
 4 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/d_netcmd.c b/src/d_netcmd.c
index 233252536..9f63023d6 100644
--- a/src/d_netcmd.c
+++ b/src/d_netcmd.c
@@ -432,6 +432,7 @@ consvar_t cv_kartdebugdistribution = CVAR_INIT ("kartdebugdistribution", "Off",
 consvar_t cv_kartdebughuddrop = CVAR_INIT ("kartdebughuddrop", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL);
 static CV_PossibleValue_t kartdebugwaypoint_cons_t[] = {{0, "Off"}, {1, "Forwards"}, {2, "Backwards"}, {0, NULL}};
 consvar_t cv_kartdebugwaypoints = CVAR_INIT ("kartdebugwaypoints", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, kartdebugwaypoint_cons_t, NULL);
+consvar_t cv_kartdebugbotpredict = CVAR_INIT ("kartdebugbotpredict", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL);
 
 consvar_t cv_kartdebugcheckpoint = CVAR_INIT ("kartdebugcheckpoint", "Off", CV_NOSHOWHELP, CV_OnOff, NULL);
 consvar_t cv_kartdebugnodes = CVAR_INIT ("kartdebugnodes", "Off", CV_NOSHOWHELP, CV_OnOff, NULL);
diff --git a/src/d_netcmd.h b/src/d_netcmd.h
index bd435c49e..288f8eb94 100644
--- a/src/d_netcmd.h
+++ b/src/d_netcmd.h
@@ -93,7 +93,7 @@ extern consvar_t cv_votetime;
 
 extern consvar_t cv_kartdebugitem, cv_kartdebugamount, cv_kartallowgiveitem, cv_kartdebugshrink, cv_kartdebugdistribution, cv_kartdebughuddrop;
 extern consvar_t cv_kartdebugcheckpoint, cv_kartdebugnodes, cv_kartdebugcolorize;
-extern consvar_t cv_kartdebugwaypoints;
+extern consvar_t cv_kartdebugwaypoints, cv_kartdebugbotpredict;
 
 extern consvar_t cv_itemfinder;
 
diff --git a/src/k_bot.c b/src/k_bot.c
index c1fc11b6c..3e2ed52ab 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -837,6 +837,23 @@ static INT16 K_FindBotController(mobj_t *mo)
 	return -1;
 }
 
+static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
+{
+	mobj_t *debugmobj = NULL;
+
+	debugmobj = P_SpawnMobj(predict->x, predict->y, player->mo->z, MT_SPARK);
+	P_SetMobjState(debugmobj, S_THOK);
+
+	debugmobj->frame &= ~FF_TRANSMASK;
+	debugmobj->frame |= FF_TRANS20;
+
+	debugmobj->color = SKINCOLOR_ORANGE;
+	debugmobj->scale *= 2;
+
+	debugmobj->state->tics = 2;
+	debugmobj->state->nextstate = S_NULL;
+}
+
 /*--------------------------------------------------
 	void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 
@@ -1158,6 +1175,11 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 		}
 	}
 
+	if (cv_kartdebugbotpredict.value == 1 && player - players == displayplayers[0])
+	{
+		K_DrawPredictionDebug(predict, player);
+	}
+
 	// Free the prediction we made earlier
 	if (predict != NULL)
 	{
diff --git a/src/k_kart.c b/src/k_kart.c
index 6621042d8..341aa8f94 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -252,6 +252,7 @@ void K_RegisterKartStuff(void)
 	CV_RegisterVar(&cv_kartdebugdistribution);
 	CV_RegisterVar(&cv_kartdebughuddrop);
 	CV_RegisterVar(&cv_kartdebugwaypoints);
+	CV_RegisterVar(&cv_kartdebugbotpredict);
 
 	CV_RegisterVar(&cv_kartdebugcheckpoint);
 	CV_RegisterVar(&cv_kartdebugnodes);

From 0fb97a1b1611d24dc9ffe2c2dddd38aef5583817 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 02:50:20 -0500
Subject: [PATCH 05/30] Use the proper variable for the average position

---
 src/k_botsearch.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 0708bf411..dbfadc5fe 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -462,7 +462,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 		return true;
 	}
 
-	if (!P_CheckSight(globalsmuggle.botmo, thing))
+	if (P_CheckSight(globalsmuggle.botmo, thing) == false)
 	{
 		return true;
 	}
@@ -718,14 +718,14 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		avgY = (globalsmuggle.avoidAvgY / globalsmuggle.avoidObjs) * mapobjectscale;
 
 		avgDist = R_PointToDist2(
-			globalsmuggle.avoidAvgX, globalsmuggle.avoidAvgY,
+			avgX, avgY,
 			predict->x, predict->y
 		);
 
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
 
 		nudgeDir = R_PointToAngle2(
-			globalsmuggle.avoidAvgX, globalsmuggle.avoidAvgY,
+			avgX, avgY,
 			predict->x, predict->y
 		);
 
@@ -740,7 +740,7 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 
 		avgDist = R_PointToDist2(
 			predict->x, predict->y,
-			globalsmuggle.gotoAvgX, globalsmuggle.gotoAvgY
+			avgX, avgY
 		);
 
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartspeed) + 1) * baseNudge;
@@ -754,7 +754,7 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		{
 			nudgeDir = R_PointToAngle2(
 				predict->x, predict->y,
-				globalsmuggle.gotoAvgX, globalsmuggle.gotoAvgY
+				avgX, avgY
 			);
 
 			predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));

From 7eac54a749c424616611781241abb8da7b378e54 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 03:21:33 -0500
Subject: [PATCH 06/30] Adjust nudging to values that feel nice

---
 src/k_botsearch.c | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index dbfadc5fe..c9997b3a6 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -455,7 +455,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 		return true;
 	}
 
-	fulldist = R_PointToDist2(globalsmuggle.predict->x, globalsmuggle.predict->y, thing->x, thing->y);
+	fulldist = R_PointToDist2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y);
 
 	if (fulldist > globalsmuggle.distancetocheck)
 	{
@@ -680,16 +680,17 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 {
 	INT32 xl, xh, yl, yh, bx, by;
 
-	const fixed_t baseNudge = 8 * mapobjectscale;
 	fixed_t avgX = 0, avgY = 0;
 	fixed_t avgDist = 0;
+
+	const fixed_t baseNudge = 48 * mapobjectscale;
 	fixed_t nudgeDist = 0;
 	angle_t nudgeDir = 0;
 
 	globalsmuggle.botmo = player->mo;
 	globalsmuggle.predict = predict;
 
-	globalsmuggle.distancetocheck = (player->mo->radius * 32) + (player->speed * 4);
+	globalsmuggle.distancetocheck = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
 
 	globalsmuggle.gotoAvgX = globalsmuggle.gotoAvgY = 0;
 	globalsmuggle.gotoObjs = 0;
@@ -722,8 +723,15 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 			predict->x, predict->y
 		);
 
+		// Light-weight characters dodge better
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
 
+		if (nudgeDist > predict->radius)
+		{
+			nudgeDist = predict->radius;
+		}
+
+		// Point away
 		nudgeDir = R_PointToAngle2(
 			avgX, avgY,
 			predict->x, predict->y
@@ -743,8 +751,14 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 			avgX, avgY
 		);
 
+		// Acceleration characters are more aggressive
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartspeed) + 1) * baseNudge;
 
+		if (nudgeDist > predict->radius)
+		{
+			nudgeDist = predict->radius;
+		}
+
 		if (avgDist <= nudgeDist)
 		{
 			predict->x = avgX;
@@ -752,6 +766,7 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		}
 		else
 		{
+			// Point towards
 			nudgeDir = R_PointToAngle2(
 				predict->x, predict->y,
 				avgX, avgY

From 6142963ff9a8f650aa20cc681eb3f24ac6f717ba Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 03:30:52 -0500
Subject: [PATCH 07/30] Add minimum distance to prediction

---
 src/k_bot.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index 3e2ed52ab..b4dfb7a45 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -572,7 +572,9 @@ static botprediction_t *K_CreateBotPrediction(player_t *player)
 
 	const tic_t futuresight = (TICRATE * normal) / max(1, handling); // How far ahead into the future to try and predict
 	const fixed_t speed = max(P_AproxDistance(player->mo->momx, player->mo->momy), K_GetKartSpeed(player, false) / 4);
-	const INT32 distance = (FixedMul(speed, distreduce) / FRACUNIT) * futuresight;
+
+	const INT32 startDist = (DEFAULT_WAYPOINT_RADIUS * mapobjectscale) / FRACUNIT;
+	const INT32 distance = ((FixedMul(speed, distreduce) / FRACUNIT) * futuresight) + startDist;
 
 	botprediction_t *predict = Z_Calloc(sizeof(botprediction_t), PU_LEVEL, NULL);
 	waypoint_t *wp = player->nextwaypoint;

From ffaa4e2aa2ef4fc42473e815a35dae081daa3f8c Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 04:26:50 -0500
Subject: [PATCH 08/30] Differentiate between which side an object is on

This means that if there's objects on both sides of the bot, then the tie is broken by which side has the most objects. Before, it would average out to the middle, so they wouldn't swerve at all, which is kind of stupid for rings, but can ruin the bot's performance for dodging items & players especially!
---
 src/k_botsearch.c | 84 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 64 insertions(+), 20 deletions(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index c9997b3a6..328ffdcfa 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -34,11 +34,11 @@ struct globalsmuggle
 	botprediction_t *predict;
 	fixed_t distancetocheck;
 
-	INT64 gotoAvgX, gotoAvgY;
-	UINT32 gotoObjs;
+	INT64 gotoAvgX[2], gotoAvgY[2];
+	UINT32 gotoObjs[2];
 
-	INT64 avoidAvgX, avoidAvgY;
-	UINT32 avoidObjs;
+	INT64 avoidAvgX[2], avoidAvgY[2];
+	UINT32 avoidObjs[2];
 
 	fixed_t closestlinedist;
 
@@ -439,6 +439,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 	INT16 anglediff;
 	fixed_t fulldist;
 	angle_t destangle, angle, predictangle;
+	UINT8 side = 0;
 
 	if (!globalsmuggle.botmo || P_MobjWasRemoved(globalsmuggle.botmo) || !globalsmuggle.botmo->player)
 	{
@@ -478,6 +479,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 	else 
 	{
 		anglediff = 360-(AngleFixed(angle)>>FRACBITS);
+		side = 1;
 	}
 
 	anglediff = abs(anglediff);
@@ -491,6 +493,9 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 	globalsmuggle.avoidAvgX += thing->x / mapobjectscale; \
 	globalsmuggle.avoidAvgY += thing->y / mapobjectscale; \
 	globalsmuggle.avoidObjs++;
+	globalsmuggle.avoidAvgX[side] += thing->x / mapobjectscale; \
+	globalsmuggle.avoidAvgY[side] += thing->y / mapobjectscale; \
+	globalsmuggle.avoidObjs[side]++; \
 
 #define PlayerAttackSteer(botcond, thingcond) \
 	if ((botcond) && !(thingcond)) \
@@ -521,7 +526,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			AddDodgeObj(thing)
 			break;
 		case MT_RANDOMITEM:
-			if (anglediff >= 60)
+			if (anglediff >= 45)
 			{
 				break;
 			}
@@ -532,7 +537,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			}
 			break;
 		case MT_EGGMANITEM:
-			if (anglediff >= 60)
+			if (anglediff >= 45)
 			{
 				break;
 			}
@@ -553,7 +558,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			}
 			break;
 		case MT_FLOATINGITEM:
-			if (anglediff >= 60)
+			if (anglediff >= 45)
 			{
 				break;
 			}
@@ -565,7 +570,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			break;
 		case MT_RING:
 		case MT_FLINGRING:
-			if (anglediff >= 60)
+			if (anglediff >= 45)
 			{
 				break;
 			}
@@ -647,7 +652,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			}
 			break;
 		case MT_BOTHINT:
-			if (anglediff >= 60)
+			if (anglediff >= 45)
 			{
 				break;
 			}
@@ -687,16 +692,22 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 	fixed_t nudgeDist = 0;
 	angle_t nudgeDir = 0;
 
+	SINT8 gotoSide = -1;
+	UINT8 i;
+
 	globalsmuggle.botmo = player->mo;
 	globalsmuggle.predict = predict;
 
 	globalsmuggle.distancetocheck = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
 
-	globalsmuggle.gotoAvgX = globalsmuggle.gotoAvgY = 0;
-	globalsmuggle.gotoObjs = 0;
+	for (i = 0; i < 2; i++)
+	{
+		globalsmuggle.gotoAvgX[i] = globalsmuggle.gotoAvgY[i] = 0;
+		globalsmuggle.gotoObjs[i] = 0;
 
-	globalsmuggle.avoidAvgX = globalsmuggle.avoidAvgY = 0;
-	globalsmuggle.avoidObjs = 0;
+		globalsmuggle.avoidAvgX[i] = globalsmuggle.avoidAvgY[i] = 0;
+		globalsmuggle.avoidObjs[i] = 0;
+	}
 
 	xl = (unsigned)(globalsmuggle.botmo->x - globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT;
 	xh = (unsigned)(globalsmuggle.botmo->x + globalsmuggle.distancetocheck - bmaporgx)>>MAPBLOCKSHIFT;
@@ -713,17 +724,27 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		}
 	}
 
-	if (globalsmuggle.avoidObjs > 0)
+	// Handle dodge characters
+	if (globalsmuggle.avoidObjs[1] > 0 || globalsmuggle.avoidObjs[0] > 0)
 	{
-		avgX = (globalsmuggle.avoidAvgX / globalsmuggle.avoidObjs) * mapobjectscale;
-		avgY = (globalsmuggle.avoidAvgY / globalsmuggle.avoidObjs) * mapobjectscale;
+		if (globalsmuggle.avoidObjs[1] > globalsmuggle.avoidObjs[0])
+		{
+			gotoSide = 1;
+		}
+		else
+		{
+			gotoSide = 0;
+		}
+
+		avgX = (globalsmuggle.avoidAvgX[gotoSide] / globalsmuggle.avoidObjs[gotoSide]) * mapobjectscale;
+		avgY = (globalsmuggle.avoidAvgY[gotoSide] / globalsmuggle.avoidObjs[gotoSide]) * mapobjectscale;
 
 		avgDist = R_PointToDist2(
 			avgX, avgY,
 			predict->x, predict->y
 		);
 
-		// Light-weight characters dodge better
+		// High handling characters dodge better
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
 
 		if (nudgeDist > predict->radius)
@@ -741,10 +762,33 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
 	}
 
-	if (globalsmuggle.gotoObjs > 0)
+	if (gotoSide == -1)
 	{
-		avgX = (globalsmuggle.gotoAvgX / globalsmuggle.gotoObjs) * mapobjectscale;
-		avgY = (globalsmuggle.gotoAvgY / globalsmuggle.gotoObjs) * mapobjectscale;
+		// Pick a side here if there were no objects to dodge.
+		// We don't want to pick contradictory sides, so keep the old side otherwise,
+		// even if there's more to grab on the other side.
+
+		if (globalsmuggle.gotoObjs[1] > globalsmuggle.gotoObjs[0])
+		{
+			gotoSide = 1;
+		}
+		else
+		{
+			gotoSide = 0;
+		}
+	}
+
+	// Check if our side is invalid, if so, don't do the code below.
+	if (gotoSide != -1 && globalsmuggle.gotoObjs[gotoSide] == 0)
+	{
+		// Do not use a side 
+		gotoSide = -1;
+	}
+
+	if (gotoSide != -1)
+	{
+		avgX = (globalsmuggle.gotoAvgX[gotoSide] / globalsmuggle.gotoObjs[gotoSide]) * mapobjectscale;
+		avgY = (globalsmuggle.gotoAvgY[gotoSide] / globalsmuggle.gotoObjs[gotoSide]) * mapobjectscale;
 
 		avgDist = R_PointToDist2(
 			predict->x, predict->y,

From dc1fbb2e9a5372f5e76eef475cf3b05f7a1da154 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 05:42:59 -0500
Subject: [PATCH 09/30] Fix bug that caused bots to go into ring debt a lot

---
 src/k_botitem.c | 2 +-
 src/k_kart.c    | 4 ++--
 src/k_kart.h    | 2 +-
 src/p_enemy.c   | 4 ++--
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/k_botitem.c b/src/k_botitem.c
index c82c9808c..070f927c8 100644
--- a/src/k_botitem.c
+++ b/src/k_botitem.c
@@ -909,7 +909,7 @@ static void K_BotItemFlame(player_t *player, ticcmd_t *cmd)
 --------------------------------------------------*/
 static void K_BotItemRings(player_t *player, ticcmd_t *cmd)
 {
-	INT32 saferingsval = 16 - K_GetKartRingPower(player);
+	INT32 saferingsval = 16 - K_GetKartRingPower(player, false);
 
 	if (player->speed < K_GetKartSpeed(player, false)/2 // Being slowed down too much
 		|| player->kartstuff[k_speedboost] > (FRACUNIT/5)) // Have another type of boost (tethering)
diff --git a/src/k_kart.c b/src/k_kart.c
index 341aa8f94..91335cdcb 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -6939,11 +6939,11 @@ void K_UpdateDistanceFromFinishLine(player_t *const player)
 	}
 }
 
-INT32 K_GetKartRingPower(player_t *player)
+INT32 K_GetKartRingPower(player_t *player, boolean boosted)
 {
 	INT32 ringPower = ((9 - player->kartspeed) + (9 - player->kartweight)) / 2;
 
-	if (K_PlayerUsesBotMovement(player))
+	if (boosted == true && K_PlayerUsesBotMovement(player))
 	{
 		// Double for Lv. 9
 		ringPower += (player->botvars.difficulty * ringPower) / MAXBOTDIFFICULTY;
diff --git a/src/k_kart.h b/src/k_kart.h
index c91bba806..bde845a22 100644
--- a/src/k_kart.h
+++ b/src/k_kart.h
@@ -69,7 +69,7 @@ void K_UpdateHnextList(player_t *player, boolean clean);
 void K_DropHnextList(player_t *player, boolean keepshields);
 void K_RepairOrbitChain(mobj_t *orbit);
 player_t *K_FindJawzTarget(mobj_t *actor, player_t *source);
-INT32 K_GetKartRingPower(player_t *player);
+INT32 K_GetKartRingPower(player_t *player, boolean boosted);
 void K_UpdateDistanceFromFinishLine(player_t *const player);
 boolean K_CheckPlayersRespawnColliding(INT32 playernum, fixed_t x, fixed_t y);
 INT16 K_GetKartTurnValue(player_t *player, INT16 turnvalue);
diff --git a/src/p_enemy.c b/src/p_enemy.c
index c96bf979f..ce3186442 100644
--- a/src/p_enemy.c
+++ b/src/p_enemy.c
@@ -4159,7 +4159,7 @@ void A_AttractChase(mobj_t *actor)
 				angle_t offset = FixedAngle(18<<FRACBITS);
 
 				// Base add is 3 tics for 9,9, adds 1 tic for each point closer to the 1,1 end
-				actor->target->player->kartstuff[k_ringboost] += K_GetKartRingPower(actor->target->player)+3;
+				actor->target->player->kartstuff[k_ringboost] += K_GetKartRingPower(actor->target->player, true) + 3;
 				S_StartSound(actor->target, sfx_s1b5);
 
 				sparkle = P_SpawnMobj(actor->target->x, actor->target->y, actor->target->z, MT_RINGSPARKS);
@@ -4187,7 +4187,7 @@ void A_AttractChase(mobj_t *actor)
 			if (actor->extravalue1 >= 16)
 			{
 				if (!P_GivePlayerRings(actor->target->player, 1)) // returns 0 if addition failed
-					actor->target->player->kartstuff[k_ringboost] += K_GetKartRingPower(actor->target->player)+3;
+					actor->target->player->kartstuff[k_ringboost] += K_GetKartRingPower(actor->target->player, true) + 3;
 
 				if (actor->cvmem) // caching
 					S_StartSound(actor->target, sfx_s1c5);

From c7e061155a6c1447dd8a948b7a5354be281e9b3a Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 05:44:57 -0500
Subject: [PATCH 10/30] Add weighting system back into prediction nudging

Simply adds the same object to the list several times. Necessary because otherwise rings are over-prioritized.
---
 src/k_botsearch.c | 191 ++++++++++++++++++++++++++++++++++------------
 1 file changed, 143 insertions(+), 48 deletions(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 328ffdcfa..81f31229e 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -422,6 +422,102 @@ fixed_t K_BotReducePrediction(player_t *player)
 	return FixedDiv(globalsmuggle.closestlinedist, globalsmuggle.distancetocheck);
 }
 
+/*--------------------------------------------------
+	static void K_AddAttackObject(mobj_t *thing, UINT8 side, UINT8 weight)
+
+		Adds an object to the list that the bot wants to go towards.
+
+	Input Arguments:-
+		thing - Object to move towards.
+		side - Which side -- 0 for left, 1 for right
+		weight - How important this object is.
+
+	Return:-
+		N/A
+--------------------------------------------------*/
+static void K_AddAttackObject(mobj_t *thing, UINT8 side, UINT8 weight)
+{
+	UINT8 i;
+
+	I_Assert(side <= 1);
+
+	if (weight == 0)
+	{
+		return;
+	}
+
+	for (i = 0; i < weight; i++)
+	{
+		globalsmuggle.gotoAvgX[side] += thing->x / mapobjectscale;
+		globalsmuggle.gotoAvgY[side] += thing->y / mapobjectscale;
+		globalsmuggle.gotoObjs[side]++;
+	}
+}
+
+/*--------------------------------------------------
+	static void K_AddDodgeObject(mobj_t *thing, UINT8 side, UINT8 weight)
+
+		Adds an object to the list that the bot wants to dodge.
+
+	Input Arguments:-
+		thing - Object to move away from.
+		side - Which side -- 0 for left, 1 for right
+		weight - How important this object is.
+
+	Return:-
+		N/A
+--------------------------------------------------*/
+static void K_AddDodgeObject(mobj_t *thing, UINT8 side, UINT8 weight)
+{
+	UINT8 i;
+
+	I_Assert(side <= 1);
+
+	if (weight == 0)
+	{
+		return;
+	}
+
+	for (i = 0; i < weight; i++)
+	{
+		globalsmuggle.gotoAvgX[side] += thing->x / mapobjectscale;
+		globalsmuggle.gotoAvgY[side] += thing->y / mapobjectscale;
+		globalsmuggle.gotoObjs[side]++;
+	}
+}
+
+/*--------------------------------------------------
+	static boolean K_PlayerAttackSteer(mobj_t *thing, UINT8 side, UINT8 weight, boolean attackCond, boolean dodgeCond)
+
+		Checks two conditions to determine if the object should be
+		attacked or dodged.
+
+	Input Arguments:-
+		thing - Object to move towards/away from.
+		side - Which side -- 0 for left, 1 for right
+		weight - How important this object is.
+		attackCond - If this is true, and dodgeCond isn't, then we go towards the object.
+		dodgeCond - If this is true, and attackCond isn't, then we move away from the object.
+
+	Return:-
+		true if either condition is successful.
+--------------------------------------------------*/
+static boolean K_PlayerAttackSteer(mobj_t *thing, UINT8 side, UINT8 weight, boolean attackCond, boolean dodgeCond)
+{
+	if (attackCond == true && dodgeCond == false)
+	{
+		K_AddAttackObject(thing, side, weight);
+		return true;
+	}
+	else if (dodgeCond == true && attackCond == false)
+	{
+		K_AddDodgeObject(thing, side, weight);
+		return true;
+	}
+
+	return false;
+}
+
 /*--------------------------------------------------
 	static boolean K_FindObjectsForNudging(mobj_t *thing)
 
@@ -484,29 +580,6 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 	anglediff = abs(anglediff);
 
-#define AddAttackObj(thing) \
-	globalsmuggle.gotoAvgX += thing->x / mapobjectscale; \
-	globalsmuggle.gotoAvgY += thing->y / mapobjectscale; \
-	globalsmuggle.gotoObjs++;
-
-#define AddDodgeObj(thing) \
-	globalsmuggle.avoidAvgX += thing->x / mapobjectscale; \
-	globalsmuggle.avoidAvgY += thing->y / mapobjectscale; \
-	globalsmuggle.avoidObjs++;
-	globalsmuggle.avoidAvgX[side] += thing->x / mapobjectscale; \
-	globalsmuggle.avoidAvgY[side] += thing->y / mapobjectscale; \
-	globalsmuggle.avoidObjs[side]++; \
-
-#define PlayerAttackSteer(botcond, thingcond) \
-	if ((botcond) && !(thingcond)) \
-	{ \
-		AddAttackObj(thing) \
-	} \
-	else if ((thingcond) && !(botcond)) \
-	{ \
-		AddDodgeObj(thing) \
-	}
-
 	switch (thing->type)
 	{
 		case MT_BANANA:
@@ -523,7 +596,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 		case MT_BALLHOG:
 		case MT_SPB:
 		case MT_BUBBLESHIELDTRAP:
-			AddDodgeObj(thing)
+			K_AddDodgeObject(thing, side, 20);
 			break;
 		case MT_RANDOMITEM:
 			if (anglediff >= 45)
@@ -533,7 +606,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 			if (P_CanPickupItem(globalsmuggle.botmo->player, 1))
 			{
-				AddAttackObj(thing)
+				K_AddAttackObject(thing, side, 10);
 			}
 			break;
 		case MT_EGGMANITEM:
@@ -549,11 +622,11 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 				if (stealth >= requiredstealth)
 				{
-					AddAttackObj(thing)
+					K_AddAttackObject(thing, side, 10);
 				}
 				else
 				{
-					AddDodgeObj(thing)
+					K_AddDodgeObject(thing, side, 10);
 				}
 			}
 			break;
@@ -565,7 +638,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 			if (P_CanPickupItem(globalsmuggle.botmo->player, 3))
 			{
-				AddAttackObj(thing)
+				K_AddAttackObject(thing, side, 20);
 			}
 			break;
 		case MT_RING:
@@ -580,7 +653,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 				&& !thing->extravalue1
 				&& (globalsmuggle.botmo->player->kartstuff[k_itemtype] != KITEM_THUNDERSHIELD))
 			{
-				AddAttackObj(thing)
+				K_AddAttackObject(thing, side, (RINGTOTAL(globalsmuggle.botmo->player) < 3) ? 5 : 1);
 			}
 			break;
 		case MT_PLAYER:
@@ -590,40 +663,61 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			{
 				// There REALLY ought to be a better way to handle this logic, right?!
 				// Squishing
-				PlayerAttackSteer(
+				if (K_PlayerAttackSteer(thing, side, 20,
 					globalsmuggle.botmo->scale > thing->scale + (mapobjectscale/8),
 					thing->scale > globalsmuggle.botmo->scale + (mapobjectscale/8)
-				)
+				))
+				{
+					break;
+				}
 				// Invincibility
-				else PlayerAttackSteer(
+				else if (K_PlayerAttackSteer(thing, side, 20,
 					globalsmuggle.botmo->player->kartstuff[k_invincibilitytimer],
 					thing->player->kartstuff[k_invincibilitytimer]
-				)
+				))
+				{
+					break;
+				}
 				// Thunder Shield
-				else PlayerAttackSteer(
+				else if (K_PlayerAttackSteer(thing, side, 20,
 					globalsmuggle.botmo->player->kartstuff[k_itemtype] == KITEM_THUNDERSHIELD,
 					thing->player->kartstuff[k_itemtype] == KITEM_THUNDERSHIELD
-				)
+				))
+				{
+					break;
+				}
 				// Bubble Shield
-				else PlayerAttackSteer(
+				else if (K_PlayerAttackSteer(thing, side, 20,
 					globalsmuggle.botmo->player->kartstuff[k_itemtype] == KITEM_BUBBLESHIELD,
 					thing->player->kartstuff[k_itemtype] == KITEM_BUBBLESHIELD
-				)
+				))
+				{
+					break;
+				}
 				// Flame Shield
-				else PlayerAttackSteer(
+				else if (K_PlayerAttackSteer(thing, side, 20,
 					globalsmuggle.botmo->player->kartstuff[k_itemtype] == KITEM_FLAMESHIELD,
 					thing->player->kartstuff[k_itemtype] == KITEM_FLAMESHIELD
-				)
+				))
+				{
+					break;
+				}
 				// Has held item shield
-				else PlayerAttackSteer(
+				else if (K_PlayerAttackSteer(thing, side, 20,
 					(globalsmuggle.botmo->player->kartstuff[k_itemheld] || globalsmuggle.botmo->player->kartstuff[k_eggmanheld]),
 					(thing->player->kartstuff[k_itemheld] || thing->player->kartstuff[k_eggmanheld])
-				)
+				))
+				{
+					break;
+				}
 				// Ring Sting
-				else PlayerAttackSteer(
+				else if (K_PlayerAttackSteer(thing, side, 20,
 					thing->player->rings <= 0,
 					globalsmuggle.botmo->player->rings <= 0
-				)
+				))
+				{
+					break;
+				}
 				else
 				{
 					// After ALL of that, we can do standard bumping
@@ -642,11 +736,11 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 					if (weightdiff > mapobjectscale)
 					{
-						AddAttackObj(thing)
+						K_AddAttackObject(thing, side, 20);
 					}
 					else
 					{
-						AddDodgeObj(thing)
+						K_AddDodgeObject(thing, side, 20);
 					}
 				}
 			}
@@ -659,16 +753,17 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 
 			if (thing->extravalue1 == 0)
 			{
-				AddDodgeObj(thing)
+				K_AddDodgeObject(thing, side, (UINT8)thing->extravalue2);
 			}
+			else
 			{
-				AddAttackObj(thing)
+				K_AddAttackObject(thing, side, (UINT8)thing->extravalue2);
 			}
 			break;
 		default:
 			if (thing->flags & (MF_SOLID|MF_ENEMY|MF_BOSS|MF_PAIN|MF_MISSILE))
 			{
-				AddDodgeObj(thing)
+				K_AddDodgeObject(thing, side, 20);
 			}
 			break;
 	}

From df13b9fcfa6a967fdfbbe942f885270a659dd48b Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 05:58:33 -0500
Subject: [PATCH 11/30] Show prediction's radius on the prediction debugger

---
 src/k_bot.c | 45 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index b4dfb7a45..7767a9f60 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -839,21 +839,64 @@ static INT16 K_FindBotController(mobj_t *mo)
 	return -1;
 }
 
+/*--------------------------------------------------
+	static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
+
+		Draws objects to show where the viewpoint bot is trying to go.
+
+	Input Arguments:-
+		predict - The prediction to visualize.
+		player - The bot player this prediction is for.
+
+	Return:-
+		N/A
+--------------------------------------------------*/
 static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
 {
+	const angle_t sideAngle = player->mo->angle + ANGLE_90;
+
 	mobj_t *debugmobj = NULL;
+	UINT8 i = UINT8_MAX;
 
 	debugmobj = P_SpawnMobj(predict->x, predict->y, player->mo->z, MT_SPARK);
 	P_SetMobjState(debugmobj, S_THOK);
 
 	debugmobj->frame &= ~FF_TRANSMASK;
-	debugmobj->frame |= FF_TRANS20;
+	debugmobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
 
 	debugmobj->color = SKINCOLOR_ORANGE;
 	debugmobj->scale *= 2;
 
 	debugmobj->state->tics = 2;
 	debugmobj->state->nextstate = S_NULL;
+
+	for (i = 0; i < 2; i++)
+	{
+		fixed_t radiusX = predict->x, radiusY = predict->y;
+
+		if (i & 1)
+		{
+			radiusX -= FixedMul(predict->radius, FINECOSINE(sideAngle >> ANGLETOFINESHIFT));
+			radiusY -= FixedMul(predict->radius, FINESINE(sideAngle >> ANGLETOFINESHIFT));
+		}
+		else
+		{
+			radiusX += FixedMul(predict->radius, FINECOSINE(sideAngle >> ANGLETOFINESHIFT));
+			radiusY += FixedMul(predict->radius, FINESINE(sideAngle >> ANGLETOFINESHIFT));
+		}
+
+		debugmobj = P_SpawnMobj(radiusX, radiusY, player->mo->z, MT_SPARK);
+		P_SetMobjState(debugmobj, S_THOK);
+
+		debugmobj->frame &= ~FF_TRANSMASK;
+		debugmobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
+
+		debugmobj->color = SKINCOLOR_YELLOW;
+		debugmobj->scale /= 2;
+
+		debugmobj->state->tics = 2;
+		debugmobj->state->nextstate = S_NULL;
+	}
 }
 
 /*--------------------------------------------------

From 59fa615cc8812a9e2f3750aee88df3a61e78d593 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 06:12:19 -0500
Subject: [PATCH 12/30] Update comment

---
 src/k_bot.c       | 2 +-
 src/k_bot.h       | 6 +++---
 src/k_botsearch.c | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index 7767a9f60..ec981ef44 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -849,7 +849,7 @@ static INT16 K_FindBotController(mobj_t *mo)
 		player - The bot player this prediction is for.
 
 	Return:-
-		N/A
+		None
 --------------------------------------------------*/
 static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
 {
diff --git a/src/k_bot.h b/src/k_bot.h
index f5187ece6..38408c6af 100644
--- a/src/k_bot.h
+++ b/src/k_bot.h
@@ -200,14 +200,14 @@ fixed_t K_BotReducePrediction(player_t *player);
 /*--------------------------------------------------
 	void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player);
 
-		Generates a sum for objects to steer towards/away from.
+		Moves the bot's prediction, based on objects around the bot.
 
 	Input Arguments:-
+		predict - The bot's prediction to nudge.
 		player - Player to compare.
-		turn - Turn value before object steering.
 
 	Return:-
-		Turn amount sum to add to final product.
+		None
 --------------------------------------------------*/
 
 void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player);
diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 81f31229e..dbf80f586 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -433,7 +433,7 @@ fixed_t K_BotReducePrediction(player_t *player)
 		weight - How important this object is.
 
 	Return:-
-		N/A
+		None
 --------------------------------------------------*/
 static void K_AddAttackObject(mobj_t *thing, UINT8 side, UINT8 weight)
 {
@@ -465,7 +465,7 @@ static void K_AddAttackObject(mobj_t *thing, UINT8 side, UINT8 weight)
 		weight - How important this object is.
 
 	Return:-
-		N/A
+		None
 --------------------------------------------------*/
 static void K_AddDodgeObject(mobj_t *thing, UINT8 side, UINT8 weight)
 {

From bbfad3a5445b197eda52b635d04fc65422aa71cc Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 19:04:24 -0500
Subject: [PATCH 13/30] Adjust wall detection

Wall detection range was doubled, how much the prediction is adjusted was halved. This is a much nicer middle-ground compared to what it was doing before.
---
 src/k_bot.c       | 2 +-
 src/k_botsearch.c | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index ec981ef44..510c71cc4 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -573,7 +573,7 @@ static botprediction_t *K_CreateBotPrediction(player_t *player)
 	const tic_t futuresight = (TICRATE * normal) / max(1, handling); // How far ahead into the future to try and predict
 	const fixed_t speed = max(P_AproxDistance(player->mo->momx, player->mo->momy), K_GetKartSpeed(player, false) / 4);
 
-	const INT32 startDist = (DEFAULT_WAYPOINT_RADIUS * mapobjectscale) / FRACUNIT;
+	const INT32 startDist = (768 * mapobjectscale) / FRACUNIT;
 	const INT32 distance = ((FixedMul(speed, distreduce) / FRACUNIT) * futuresight) + startDist;
 
 	botprediction_t *predict = Z_Calloc(sizeof(botprediction_t), PU_LEVEL, NULL);
diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index dbf80f586..92deb70ce 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -387,7 +387,7 @@ fixed_t K_BotReducePrediction(player_t *player)
 	INT32 xl, xh, yl, yh, bx, by;
 
 	globalsmuggle.botmo = player->mo;
-	globalsmuggle.distancetocheck = (player->mo->radius * 16);
+	globalsmuggle.distancetocheck = (player->mo->radius * 32);
 	globalsmuggle.closestlinedist = INT32_MAX;
 
 	tmx = player->mo->x;
@@ -419,7 +419,7 @@ fixed_t K_BotReducePrediction(player_t *player)
 		return FRACUNIT;
 	}
 
-	return FixedDiv(globalsmuggle.closestlinedist, globalsmuggle.distancetocheck);
+	return (FRACUNIT/2) + (FixedDiv(globalsmuggle.closestlinedist, globalsmuggle.distancetocheck) / 2);
 }
 
 /*--------------------------------------------------

From 9f91c2dcdc61110d5a2fbbd7a3647841820db485 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 19:28:49 -0500
Subject: [PATCH 14/30] Buff the object nudging now that wall detection doesn't
 step on its toes :)

---
 src/k_botsearch.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 92deb70ce..7362fe849 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -780,10 +780,12 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 {
 	INT32 xl, xh, yl, yh, bx, by;
 
+	fixed_t distToPredict = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
+
 	fixed_t avgX = 0, avgY = 0;
 	fixed_t avgDist = 0;
 
-	const fixed_t baseNudge = 48 * mapobjectscale;
+	const fixed_t baseNudge = 128 * mapobjectscale;
 	fixed_t nudgeDist = 0;
 	angle_t nudgeDir = 0;
 
@@ -793,7 +795,7 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 	globalsmuggle.botmo = player->mo;
 	globalsmuggle.predict = predict;
 
-	globalsmuggle.distancetocheck = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
+	globalsmuggle.distancetocheck = distToPredict;
 
 	for (i = 0; i < 2; i++)
 	{
@@ -842,9 +844,9 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		// High handling characters dodge better
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
 
-		if (nudgeDist > predict->radius)
+		if (nudgeDist > distToPredict)
 		{
-			nudgeDist = predict->radius;
+			nudgeDist = distToPredict;
 		}
 
 		// Point away
@@ -855,6 +857,8 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 
 		predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));
 		predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
+
+		distToPredict = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
 	}
 
 	if (gotoSide == -1)
@@ -893,9 +897,9 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		// Acceleration characters are more aggressive
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartspeed) + 1) * baseNudge;
 
-		if (nudgeDist > predict->radius)
+		if (nudgeDist > distToPredict)
 		{
-			nudgeDist = predict->radius;
+			nudgeDist = distToPredict;
 		}
 
 		if (avgDist <= nudgeDist)
@@ -913,6 +917,8 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 
 			predict->x += FixedMul(nudgeDist, FINECOSINE(nudgeDir >> ANGLETOFINESHIFT));
 			predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
+
+			//distToPredict = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
 		}
 	}
 }

From 00227ee7f053e6fdf53286df2d5631453ccf21ab Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 19:42:08 -0500
Subject: [PATCH 15/30] Don't ever go too far behind the bot

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

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 7362fe849..1cda1cb1f 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -786,6 +786,7 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 	fixed_t avgDist = 0;
 
 	const fixed_t baseNudge = 128 * mapobjectscale;
+	fixed_t maxNudge = distToPredict;
 	fixed_t nudgeDist = 0;
 	angle_t nudgeDir = 0;
 
@@ -844,9 +845,10 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		// High handling characters dodge better
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartweight) + 1) * baseNudge;
 
-		if (nudgeDist > distToPredict)
+		maxNudge = max(distToPredict - predict->radius, predict->radius);
+		if (nudgeDist > maxNudge)
 		{
-			nudgeDist = distToPredict;
+			nudgeDist = maxNudge;
 		}
 
 		// Point away
@@ -897,9 +899,10 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		// Acceleration characters are more aggressive
 		nudgeDist = ((9 - globalsmuggle.botmo->player->kartspeed) + 1) * baseNudge;
 
-		if (nudgeDist > distToPredict)
+		maxNudge = max(distToPredict - predict->radius, predict->radius);
+		if (nudgeDist > maxNudge)
 		{
-			nudgeDist = distToPredict;
+			nudgeDist = maxNudge;
 		}
 
 		if (avgDist <= nudgeDist)

From ebaef5d0afd05e0fe9b050af289dbd3f5b5b8eab Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 19:46:52 -0500
Subject: [PATCH 16/30] Flip side properly for objects to go towards.

---
 src/k_botsearch.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 1cda1cb1f..30948b0b4 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -861,6 +861,16 @@ void K_NudgePredictionTowardsObjects(botprediction_t *predict, player_t *player)
 		predict->y += FixedMul(nudgeDist, FINESINE(nudgeDir >> ANGLETOFINESHIFT));
 
 		distToPredict = R_PointToDist2(player->mo->x, player->mo->y, predict->x, predict->y);
+
+		// Flip side, since we want to check for objects to steer towards on the side we're NOT dodging.
+		if (gotoSide == 0)
+		{
+			gotoSide = 1;
+		}
+		else
+		{
+			gotoSide = 0;
+		}
 	}
 
 	if (gotoSide == -1)

From d2dd5629198d221150ca4482ef357ed9ccbfd993 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 21:37:14 -0500
Subject: [PATCH 17/30] Bots shouldn't try to do anything during the camera
 spin-around intro.

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

diff --git a/src/k_bot.c b/src/k_bot.c
index 510c71cc4..0bca9d979 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -925,6 +925,7 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 		gamestate != GS_LEVEL
 		|| player->mo->scale <= 1
 		|| player->playerstate == PST_DEAD
+		|| leveltime <= introtime
 		)
 	{
 		// No need to do anything else.

From 17de1d5ff3a5cdc5a109d2d396021f23362bc86c Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 21:55:20 -0500
Subject: [PATCH 18/30] Don't modify the states table for kartdebugwaypoints or
 kartdebugbotpredict

Also makes debugwaypoints fullbright so it's a little easier to see in dark levels.
---
 src/k_bot.c      |  6 ++----
 src/k_waypoint.c | 17 ++++++++---------
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index 0bca9d979..584231a1c 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -867,8 +867,7 @@ static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
 	debugmobj->color = SKINCOLOR_ORANGE;
 	debugmobj->scale *= 2;
 
-	debugmobj->state->tics = 2;
-	debugmobj->state->nextstate = S_NULL;
+	debugmobj->tics = 2;
 
 	for (i = 0; i < 2; i++)
 	{
@@ -894,8 +893,7 @@ static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
 		debugmobj->color = SKINCOLOR_YELLOW;
 		debugmobj->scale /= 2;
 
-		debugmobj->state->tics = 2;
-		debugmobj->state->nextstate = S_NULL;
+		debugmobj->tics = 2;
 	}
 }
 
diff --git a/src/k_waypoint.c b/src/k_waypoint.c
index ae6841a34..73eb82bfa 100644
--- a/src/k_waypoint.c
+++ b/src/k_waypoint.c
@@ -535,9 +535,9 @@ static void K_DebugWaypointsSpawnLine(waypoint_t *const waypoint1, waypoint_t *c
 		{
 			spawnedmobj = P_SpawnMobj(x, y, z, MT_SPARK);
 			P_SetMobjState(spawnedmobj, S_THOK);
-			spawnedmobj->state->nextstate = S_NULL;
-			spawnedmobj->state->tics = 1;
-			spawnedmobj->frame = spawnedmobj->frame & ~FF_TRANSMASK;
+			spawnedmobj->tics = 1;
+			spawnedmobj->frame &= ~FF_TRANSMASK;
+			spawnedmobj->frame |= FF_FULLBRIGHT;
 			spawnedmobj->color = linkcolour;
 			spawnedmobj->scale = FixedMul(spawnedmobj->scale, FixedMul(FRACUNIT/4, FixedDiv((15 - ((leveltime + n) % 16))*FRACUNIT, 15*FRACUNIT)));
 		}
@@ -582,9 +582,9 @@ static void K_DebugWaypointDrawRadius(waypoint_t *const waypoint)
 
 		radiusOrb = P_SpawnMobj(spawnX, spawnY, spawnZ, MT_SPARK);
 		P_SetMobjState(radiusOrb, S_THOK);
-		radiusOrb->state->nextstate = S_NULL;
-		radiusOrb->state->tics = 1;
-		radiusOrb->frame = radiusOrb->frame & ~FF_TRANSMASK;
+		radiusOrb->tics = 1;
+		radiusOrb->frame &= ~FF_TRANSMASK;
+		radiusOrb->frame |= FF_FULLBRIGHT;
 		radiusOrb->color = SKINCOLOR_PURPLE;
 		radiusOrb->scale = radiusOrb->scale / 4;
 	}
@@ -623,7 +623,7 @@ void K_DebugWaypointsVisualise(void)
 		P_SetMobjState(debugmobj, S_THOK);
 
 		debugmobj->frame &= ~FF_TRANSMASK;
-		debugmobj->frame |= FF_TRANS20;
+		debugmobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
 
 		// There's a waypoint setup for this mobj! So draw that it's a valid waypoint and draw lines to its connections
 		if (waypoint != NULL)
@@ -683,8 +683,7 @@ void K_DebugWaypointsVisualise(void)
 		{
 			debugmobj->color = SKINCOLOR_RED;
 		}
-		debugmobj->state->tics = 1;
-		debugmobj->state->nextstate = S_NULL;
+		debugmobj->tics = 1;
 	}
 }
 

From 78592de14f0c27fef618e0d6f21eed39426ac6f5 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 22:13:21 -0500
Subject: [PATCH 19/30] Since this gets definitely freed by us later, this
 should probably be PU_STATIC

---
 src/k_bot.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index 584231a1c..ad63f4b45 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -576,7 +576,7 @@ static botprediction_t *K_CreateBotPrediction(player_t *player)
 	const INT32 startDist = (768 * mapobjectscale) / FRACUNIT;
 	const INT32 distance = ((FixedMul(speed, distreduce) / FRACUNIT) * futuresight) + startDist;
 
-	botprediction_t *predict = Z_Calloc(sizeof(botprediction_t), PU_LEVEL, NULL);
+	botprediction_t *predict = Z_Calloc(sizeof(botprediction_t), PU_STATIC, NULL);
 	waypoint_t *wp = player->nextwaypoint;
 
 	INT32 distanceleft = distance;
@@ -988,7 +988,7 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 			destangle = FixedAngle(sides[controllerLine->sidenum[0]].textureoffset);
 
 			// Overwritten prediction
-			predict = Z_Calloc(sizeof(botprediction_t), PU_LEVEL, NULL);
+			predict = Z_Calloc(sizeof(botprediction_t), PU_STATIC, NULL);
 
 			predict->x = player->mo->x + FixedMul(dist, FINECOSINE(destangle >> ANGLETOFINESHIFT));
 			predict->y = player->mo->y + FixedMul(dist, FINESINE(destangle >> ANGLETOFINESHIFT));
@@ -1219,14 +1219,14 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 		}
 	}
 
-	if (cv_kartdebugbotpredict.value == 1 && player - players == displayplayers[0])
-	{
-		K_DrawPredictionDebug(predict, player);
-	}
-
 	// Free the prediction we made earlier
 	if (predict != NULL)
 	{
+		if (cv_kartdebugbotpredict.value != 0 && player - players == displayplayers[0])
+		{
+			K_DrawPredictionDebug(predict, player);
+		}
+
 		Z_Free(predict);
 	}
 }

From b7f827825252b59fc7e0955b3b66c9a18ea1ecc0 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 22:15:43 -0500
Subject: [PATCH 20/30] Some asserts in K_DrawPredictionDebug

---
 src/k_bot.c | 40 +++++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/src/k_bot.c b/src/k_bot.c
index ad63f4b45..13eb9c1fe 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -853,24 +853,30 @@ static INT16 K_FindBotController(mobj_t *mo)
 --------------------------------------------------*/
 static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
 {
-	const angle_t sideAngle = player->mo->angle + ANGLE_90;
-
-	mobj_t *debugmobj = NULL;
+	mobj_t *debugMobj = NULL;
+	angle_t sideAngle = ANGLE_MAX;
 	UINT8 i = UINT8_MAX;
 
-	debugmobj = P_SpawnMobj(predict->x, predict->y, player->mo->z, MT_SPARK);
-	P_SetMobjState(debugmobj, S_THOK);
+	I_Assert(predict != NULL);
+	I_Assert(player != NULL);
+	I_Assert(player->mo != NULL && P_MobjWasRemoved(player->mo) == false);
 
-	debugmobj->frame &= ~FF_TRANSMASK;
-	debugmobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
+	sideAngle = player->mo->angle + ANGLE_90;
 
-	debugmobj->color = SKINCOLOR_ORANGE;
-	debugmobj->scale *= 2;
+	debugMobj = P_SpawnMobj(predict->x, predict->y, player->mo->z, MT_SPARK);
+	P_SetMobjState(debugMobj, S_THOK);
 
-	debugmobj->tics = 2;
+	debugMobj->frame &= ~FF_TRANSMASK;
+	debugMobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
+
+	debugMobj->color = SKINCOLOR_ORANGE;
+	debugMobj->scale *= 2;
+
+	debugMobj->tics = 2;
 
 	for (i = 0; i < 2; i++)
 	{
+		mobj_t *radiusMobj = NULL;
 		fixed_t radiusX = predict->x, radiusY = predict->y;
 
 		if (i & 1)
@@ -884,16 +890,16 @@ static void K_DrawPredictionDebug(botprediction_t *predict, player_t *player)
 			radiusY += FixedMul(predict->radius, FINESINE(sideAngle >> ANGLETOFINESHIFT));
 		}
 
-		debugmobj = P_SpawnMobj(radiusX, radiusY, player->mo->z, MT_SPARK);
-		P_SetMobjState(debugmobj, S_THOK);
+		radiusMobj = P_SpawnMobj(radiusX, radiusY, player->mo->z, MT_SPARK);
+		P_SetMobjState(radiusMobj, S_THOK);
 
-		debugmobj->frame &= ~FF_TRANSMASK;
-		debugmobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
+		radiusMobj->frame &= ~FF_TRANSMASK;
+		radiusMobj->frame |= FF_TRANS20|FF_FULLBRIGHT;
 
-		debugmobj->color = SKINCOLOR_YELLOW;
-		debugmobj->scale /= 2;
+		radiusMobj->color = SKINCOLOR_YELLOW;
+		radiusMobj->scale /= 2;
 
-		debugmobj->tics = 2;
+		radiusMobj->tics = 2;
 	}
 }
 

From 03c13052e894e3ed136bbc9aa13c939b55d66ad0 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 22:37:46 -0500
Subject: [PATCH 21/30] Fix bot hint weighting

---
 src/k_botsearch.c | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index 30948b0b4..ae84dac4b 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -750,14 +750,23 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 			{
 				break;
 			}
-
-			if (thing->extravalue1 == 0)
-			{
-				K_AddDodgeObject(thing, side, (UINT8)thing->extravalue2);
-			}
 			else
 			{
-				K_AddAttackObject(thing, side, (UINT8)thing->extravalue2);
+				UINT8 weight = 20;
+
+				if (thing->extravalue2 > 0)
+				{
+					weight = thing->extravalue2 * 5;
+				}
+
+				if (thing->extravalue1 == 0)
+				{
+					K_AddDodgeObject(thing, side, weight);
+				}
+				else
+				{
+					K_AddAttackObject(thing, side, weight);
+				}
 			}
 			break;
 		default:

From cb655f863cdebf7d08492711ce2225cbc3aae2d4 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 22:43:10 -0500
Subject: [PATCH 22/30] Reduce object distance by its radius

Just gives bot hint size a purpose again, even if it's minor.
---
 src/k_botsearch.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/k_botsearch.c b/src/k_botsearch.c
index ae84dac4b..880eb5ef9 100644
--- a/src/k_botsearch.c
+++ b/src/k_botsearch.c
@@ -552,7 +552,7 @@ static boolean K_FindObjectsForNudging(mobj_t *thing)
 		return true;
 	}
 
-	fulldist = R_PointToDist2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y);
+	fulldist = R_PointToDist2(globalsmuggle.botmo->x, globalsmuggle.botmo->y, thing->x, thing->y) - thing->radius;
 
 	if (fulldist > globalsmuggle.distancetocheck)
 	{

From cbe14d74c8e82f93ca66acd457a3cd8552f3b984 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Fri, 26 Feb 2021 22:56:59 -0500
Subject: [PATCH 23/30] Increase default hint weight

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

diff --git a/src/p_mobj.c b/src/p_mobj.c
index 6a58fc907..653b934d6 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -11769,7 +11769,7 @@ static boolean P_SetupSpawnedMapThing(mapthing_t *mthing, mobj_t *mobj, boolean
 		// Steering amount
 		if (mthing->args[1] == 0)
 		{
-			mobj->extravalue2 = 2;
+			mobj->extravalue2 = 4;
 		}
 		else
 		{

From ec0071039633cb68adf6e7e7d5683548a20c9d83 Mon Sep 17 00:00:00 2001
From: James R <justsomejames2@gmail.com>
Date: Sat, 31 Oct 2020 19:41:38 -0700
Subject: [PATCH 24/30] Use 2.2's version of the -warp parameter

---
 src/d_main.c | 73 ++++++++++++++++++++++++++--------------------------
 1 file changed, 36 insertions(+), 37 deletions(-)

diff --git a/src/d_main.c b/src/d_main.c
index 3936559d5..6edcbada3 100644
--- a/src/d_main.c
+++ b/src/d_main.c
@@ -1316,43 +1316,6 @@ void D_SRB2Main(void)
 	if (M_CheckParm("-server") || dedicated)
 		netgame = server = true;
 
-	if (M_CheckParm("-warp") && M_IsNextParm())
-	{
-		const char *word = M_GetNextParm();
-		char ch; // use this with sscanf to catch non-digits with
-		if (fastncmp(word, "MAP", 3)) // MAPxx name
-			pstartmap = M_MapNumber(word[3], word[4]);
-		else if (sscanf(word, "%d%c", &pstartmap, &ch) != 1) // a plain number
-			I_Error("Cannot warp to map %s (invalid map name)\n", word);
-		// Don't check if lump exists just yet because the wads haven't been loaded!
-		// Just do a basic range check here.
-		if (pstartmap < 1 || pstartmap > NUMMAPS)
-			I_Error("Cannot warp to map %d (out of range)\n", pstartmap);
-		else
-		{
-			if (!M_CheckParm("-server"))
-			{
-				G_SetGameModified(true, true);
-
-				// Start up a "minor" grand prix session
-				memset(&grandprixinfo, 0, sizeof(struct grandprixinfo));
-
-				grandprixinfo.gamespeed = KARTSPEED_NORMAL;
-				grandprixinfo.encore = false;
-				grandprixinfo.masterbots = false;
-
-				grandprixinfo.gp = true;
-				grandprixinfo.roundnum = 0;
-				grandprixinfo.cup = NULL;
-				grandprixinfo.wonround = false;
-
-				grandprixinfo.initalize = true;
-			}
-
-			autostart = true;
-		}
-	}
-
 	// adapt tables to SRB2's needs, including extra slots for dehacked file support
 	P_PatchInfoTables();
 
@@ -1550,6 +1513,42 @@ void D_SRB2Main(void)
 
 	//------------------------------------------------ COMMAND LINE PARAMS
 
+	// this must be done after loading gamedata,
+	// to avoid setting off the corrupted gamedata code in G_LoadGameData if a SOC with custom gamedata is added
+	// -- Monster Iestyn 20/02/20
+	if (M_CheckParm("-warp") && M_IsNextParm())
+	{
+		const char *word = M_GetNextParm();
+
+		pstartmap = G_FindMapByNameOrCode(word, 0);
+
+		if (! pstartmap)
+			I_Error("Cannot find a map remotely named '%s'\n", word);
+		else
+		{
+			if (!M_CheckParm("-server"))
+			{
+				G_SetGameModified(true, true);
+
+				// Start up a "minor" grand prix session
+				memset(&grandprixinfo, 0, sizeof(struct grandprixinfo));
+
+				grandprixinfo.gamespeed = KARTSPEED_NORMAL;
+				grandprixinfo.encore = false;
+				grandprixinfo.masterbots = false;
+
+				grandprixinfo.gp = true;
+				grandprixinfo.roundnum = 0;
+				grandprixinfo.cup = NULL;
+				grandprixinfo.wonround = false;
+
+				grandprixinfo.initalize = true;
+			}
+
+			autostart = true;
+		}
+	}
+
 	// this must be done after loading gamedata,
 	// to avoid setting off the corrupted gamedata code in G_LoadGameData if a SOC with custom gamedata is added
 	// -- Monster Iestyn 20/02/20

From 0be122189fd8a2e770b9aec56d854058eab70599 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Mon, 1 Mar 2021 12:39:42 -0500
Subject: [PATCH 25/30] Remove turn easing code

Vanilla holdover lots of people complain about & tbh just doesn't need to exist
---
 src/g_demo.c |  1 -
 src/g_game.c | 38 ++++++++++++--------------------------
 src/m_menu.c |  1 -
 src/p_user.c | 31 ++++++++++---------------------
 4 files changed, 22 insertions(+), 49 deletions(-)

diff --git a/src/g_demo.c b/src/g_demo.c
index fc9181717..8f2a111dc 100644
--- a/src/g_demo.c
+++ b/src/g_demo.c
@@ -3658,7 +3658,6 @@ void G_StopDemo(void)
 	democam.soundmobj = NULL;
 	democam.localangle = 0;
 	democam.localaiming = 0;
-	democam.turnheld = false;
 	democam.keyboardlook = false;
 
 	if (gamestate == GS_INTERMISSION)
diff --git a/src/g_game.c b/src/g_game.c
index 9a766dc42..c018ef746 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -867,8 +867,6 @@ static void G_HandleAxisDeadZone(UINT8 splitnum, joystickvector2_t *joystickvect
 INT32 localaiming[MAXSPLITSCREENPLAYERS];
 angle_t localangle[MAXSPLITSCREENPLAYERS];
 
-static INT32 angleturn[2] = {KART_FULLTURN, KART_FULLTURN / 4}; // + slow turn
-
 void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 {
 	const UINT8 forplayer = ssplayer-1;
@@ -879,11 +877,10 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	const boolean gamepadjoystickmove = cv_usejoystick[forplayer].value && Joystick[forplayer].bGamepadStyle;
 	const boolean usejoystick = (analogjoystickmove || gamepadjoystickmove);
 
-	static INT32 turnheld[MAXSPLITSCREENPLAYERS]; // for accelerative turning
 	static boolean keyboard_look[MAXSPLITSCREENPLAYERS]; // true if lookup/down using keyboard
 	static boolean resetdown[MAXSPLITSCREENPLAYERS]; // don't cam reset every frame
 
-	INT32 tspeed, forward, axis;
+	INT32 forward, axis;
 
 	joystickvector2_t joystickvector;
 
@@ -891,11 +888,12 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 
 	player_t *player = &players[g_localplayers[forplayer]];
 	camera_t *thiscam = &camera[forplayer];
-	INT32 *th = &turnheld[forplayer];
 	boolean *kbl = &keyboard_look[forplayer];
 	boolean *rd = &resetdown[forplayer];
 	const boolean mouseaiming = player->spectator;
 
+	(void)realtics;
+
 	if (demo.playback) return;
 
 	// Is there any reason this can't just be I_BaseTiccmd?
@@ -958,39 +956,27 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	}
 	forward = 0;
 
-	// use two stage accelerative turning
-	// on the keyboard and joystick
-	if (turnleft || turnright)
-		*th += realtics;
-	else
-		*th = 0;
-
-	if (*th < SLOWTURNTICS)
-		tspeed = 1; // slow turn
-	else
-		tspeed = 0;
-
 	cmd->turning = 0;
 
 	// let movement keys cancel each other out
 	if (turnright && !(turnleft))
 	{
-		cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
+		cmd->turning -= KART_FULLTURN;
 	}
 	else if (turnleft && !(turnright))
 	{
-		cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
+		cmd->turning += KART_FULLTURN;
 	}
 
 	if (analogjoystickmove && joystickvector.xaxis != 0)
 	{
-		cmd->turning = (INT16)(cmd->turning - (((joystickvector.xaxis * angleturn[0]) >> 10)));
+		cmd->turning -= (joystickvector.xaxis * KART_FULLTURN) >> 10;
 	}
 
 	// Specator mouse turning
 	if (player->spectator)
 	{
-		cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
+		cmd->turning -= (mousex * 8) * (encoremode ? -1 : 1);
 	}
 
 	if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls
@@ -1125,7 +1111,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 
 	cmd->forwardmove += (SINT8)forward;
 
-	cmd->latency = modeattacking ? 0 : (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations
+	cmd->latency = (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations
 	cmd->flags = 0;
 
 	if (chat_on || CON_Ready())
@@ -1156,10 +1142,10 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	else if (cmd->forwardmove < -MAXPLMOVE)
 		cmd->forwardmove = -MAXPLMOVE;
 
-	if (cmd->turning > (angleturn[0]))
-		cmd->turning = (angleturn[0]);
-	else if (cmd->turning < (-angleturn[0]))
-		cmd->turning = (-angleturn[0]);
+	if (cmd->turning > KART_FULLTURN)
+		cmd->turning = KART_FULLTURN;
+	else if (cmd->turning < -KART_FULLTURN)
+		cmd->turning = -KART_FULLTURN;
 
 	// Reset away view if a command is given.
 	if ((cmd->forwardmove || cmd->buttons)
diff --git a/src/m_menu.c b/src/m_menu.c
index 28570c699..1a3c54738 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -6146,7 +6146,6 @@ static void M_PlaybackToggleFreecam(INT32 choice)
 		demo.freecam = false;
 		// reset democam vars:
 		democam.cam = NULL;
-		democam.turnheld = false;
 		democam.keyboardlook = false;	// reset only these. localangle / aiming gets set before the cam does anything anyway
 	}
 }
diff --git a/src/p_user.c b/src/p_user.c
index 7b79d5627..10cb61335 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -2771,9 +2771,7 @@ fixed_t t_cam_rotate[MAXSPLITSCREENPLAYERS] = {-42,-42,-42,-42};
 
 // Heavily simplified version of G_BuildTicCmd that only takes the local first player's control input and converts it to readable ticcmd_t
 // we then throw that ticcmd garbage in the camera and make it move
-
-// redefine this
-static fixed_t angleturn[2] = {KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
+// TODO: please just use the normal ticcmd function somehow
 
 static ticcmd_t cameracmd;
 
@@ -2787,7 +2785,7 @@ void P_InitCameraCmd(void)
 
 static ticcmd_t *P_CameraCmd(camera_t *cam)
 {
-	INT32 th, tspeed, forward, axis; //i
+	INT32 forward, axis; //i
 	// these ones used for multiple conditions
 	boolean turnleft, turnright, mouseaiming;
 	boolean invertmouse, lookaxis, usejoystick, kbl;
@@ -2800,7 +2798,6 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 	if (!demo.playback)
 		return cmd;	// empty cmd, no.
 
-	th = democam.turnheld;
 	kbl = democam.keyboardlook;
 
 	G_CopyTiccmd(cmd, I_BaseTiccmd(), 1); // empty, or external driver
@@ -2830,31 +2827,19 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 	}
 	forward = 0;
 
-	// use two stage accelerative turning
-	// on the keyboard and joystick
-	if (turnleft || turnright)
-		th += 1;
-	else
-		th = 0;
-
-	if (th < SLOWTURNTICS)
-		tspeed = 1; // slow turn
-	else
-		tspeed = 0;
-
 	cmd->turning = 0;
 
 	// let movement keys cancel each other out
 	if (turnright && !(turnleft))
 	{
-		cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
+		cmd->turning -= KART_FULLTURN;
 	}
 	else if (turnleft && !(turnright))
 	{
-		cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
+		cmd->turning += KART_FULLTURN;
 	}
 
-	cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
+	cmd->turning -= (mousex * 8) * (encoremode ? -1 : 1);
 
 	axis = PlayerJoyAxis(1, AXISMOVE);
 	if (PlayerInputDown(1, gc_accelerate) || (usejoystick && axis > 0))
@@ -2912,7 +2897,11 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 	else if (cmd->forwardmove < -MAXPLMOVE)
 		cmd->forwardmove = -MAXPLMOVE;
 
-	democam.turnheld = th;
+	if (cmd->turning > KART_FULLTURN)
+		cmd->turning = KART_FULLTURN;
+	else if (cmd->turning < -KART_FULLTURN)
+		cmd->turning = -KART_FULLTURN;
+
 	democam.keyboardlook = kbl;
 
 	return cmd;

From 017c5a363f0beefe841821b5fa9bfa54d5f64bda Mon Sep 17 00:00:00 2001
From: James R <justsomejames2@gmail.com>
Date: Mon, 1 Mar 2021 19:49:44 -0800
Subject: [PATCH 26/30] Fix casing

---
 extras/conf/udb/{includes => Includes}/Game_Kart2.cfg     | 0
 extras/conf/udb/{includes => Includes}/Kart2_common.cfg   | 0
 extras/conf/udb/{includes => Includes}/Kart2_linedefs.cfg | 0
 extras/conf/udb/{includes => Includes}/Kart2_misc.cfg     | 0
 extras/conf/udb/{includes => Includes}/Kart2_sectors.cfg  | 0
 extras/conf/udb/{includes => Includes}/Kart2_things.cfg   | 0
 6 files changed, 0 insertions(+), 0 deletions(-)
 rename extras/conf/udb/{includes => Includes}/Game_Kart2.cfg (100%)
 rename extras/conf/udb/{includes => Includes}/Kart2_common.cfg (100%)
 rename extras/conf/udb/{includes => Includes}/Kart2_linedefs.cfg (100%)
 rename extras/conf/udb/{includes => Includes}/Kart2_misc.cfg (100%)
 rename extras/conf/udb/{includes => Includes}/Kart2_sectors.cfg (100%)
 rename extras/conf/udb/{includes => Includes}/Kart2_things.cfg (100%)

diff --git a/extras/conf/udb/includes/Game_Kart2.cfg b/extras/conf/udb/Includes/Game_Kart2.cfg
similarity index 100%
rename from extras/conf/udb/includes/Game_Kart2.cfg
rename to extras/conf/udb/Includes/Game_Kart2.cfg
diff --git a/extras/conf/udb/includes/Kart2_common.cfg b/extras/conf/udb/Includes/Kart2_common.cfg
similarity index 100%
rename from extras/conf/udb/includes/Kart2_common.cfg
rename to extras/conf/udb/Includes/Kart2_common.cfg
diff --git a/extras/conf/udb/includes/Kart2_linedefs.cfg b/extras/conf/udb/Includes/Kart2_linedefs.cfg
similarity index 100%
rename from extras/conf/udb/includes/Kart2_linedefs.cfg
rename to extras/conf/udb/Includes/Kart2_linedefs.cfg
diff --git a/extras/conf/udb/includes/Kart2_misc.cfg b/extras/conf/udb/Includes/Kart2_misc.cfg
similarity index 100%
rename from extras/conf/udb/includes/Kart2_misc.cfg
rename to extras/conf/udb/Includes/Kart2_misc.cfg
diff --git a/extras/conf/udb/includes/Kart2_sectors.cfg b/extras/conf/udb/Includes/Kart2_sectors.cfg
similarity index 100%
rename from extras/conf/udb/includes/Kart2_sectors.cfg
rename to extras/conf/udb/Includes/Kart2_sectors.cfg
diff --git a/extras/conf/udb/includes/Kart2_things.cfg b/extras/conf/udb/Includes/Kart2_things.cfg
similarity index 100%
rename from extras/conf/udb/includes/Kart2_things.cfg
rename to extras/conf/udb/Includes/Kart2_things.cfg

From e18a3a1be038f9c49c7286e9902a534095098791 Mon Sep 17 00:00:00 2001
From: James R <justsomejames2@gmail.com>
Date: Mon, 1 Mar 2021 22:04:13 -0800
Subject: [PATCH 27/30] Multiply thing scale by mobjscale

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

diff --git a/src/p_setup.c b/src/p_setup.c
index 2f8b746eb..b9b4dc88d 100644
--- a/src/p_setup.c
+++ b/src/p_setup.c
@@ -1675,7 +1675,7 @@ static void ParseTextmapThingParameter(UINT32 i, char *param, char *val)
 	else if (fastcmp(param, "type"))
 		mapthings[i].type = atol(val);
 	else if (fastcmp(param, "scale") || fastcmp(param, "scalex") || fastcmp(param, "scaley"))
-		mapthings[i].scale = FLOAT_TO_FIXED(atof(val));
+		mapthings[i].scale = FixedMul(mapobjectscale, FLOAT_TO_FIXED(atof(val)));
 	// Flags
 	else if (fastcmp(param, "extra") && fastcmp("true", val))
 		mapthings[i].options |= MTF_EXTRA;

From 0a10396c8481cb1f50b04deae7a6ac2d33aa9d22 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Tue, 9 Mar 2021 17:28:20 -0500
Subject: [PATCH 28/30] Spindash shortcut button

---
 src/g_game.c  |   6 +++
 src/g_game.h  |   1 +
 src/g_input.c |   6 +--
 src/g_input.h |   7 +--
 src/m_menu.c  | 129 +++++++++++++++++++++++++-------------------------
 5 files changed, 79 insertions(+), 70 deletions(-)

diff --git a/src/g_game.c b/src/g_game.c
index c018ef746..62cfed320 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -1041,6 +1041,12 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	if (PlayerInputDown(ssplayer, gc_drift) || (usejoystick && axis > 0))
 		cmd->buttons |= BT_DRIFT;
 
+	// Spindash with any button/key
+	// Simply holds all of the inputs for you.
+	axis = PlayerJoyAxis(ssplayer, AXISSPINDASH);
+	if (PlayerInputDown(ssplayer, gc_spindash) || (usejoystick && axis > 0))
+		cmd->buttons |= (BT_ACCELERATE|BT_BRAKE|BT_DRIFT);
+
 	// rear view with any button/key
 	axis = PlayerJoyAxis(ssplayer, AXISLOOKBACK);
 	if (PlayerInputDown(ssplayer, gc_lookback) || (usejoystick && axis > 0))
diff --git a/src/g_game.h b/src/g_game.h
index 28321adc5..7f461f583 100644
--- a/src/g_game.h
+++ b/src/g_game.h
@@ -109,6 +109,7 @@ typedef enum
 
 	AXISFIRE = AXISDIGITAL,
 	AXISDRIFT,
+	AXISSPINDASH,
 	AXISLOOKBACK,
 	AXISAIM,
 } axis_input_e;
diff --git a/src/g_input.c b/src/g_input.c
index 0e10ae8a9..a85219a7e 100644
--- a/src/g_input.c
+++ b/src/g_input.c
@@ -52,11 +52,11 @@ const INT32 gcl_brake[num_gcl_brake] = { gc_brake };
 const INT32 gcl_drift[num_gcl_drift] = { gc_drift };
 
 const INT32 gcl_spindash[num_gcl_spindash] = {
-	gc_accelerate, gc_drift, gc_brake
+	gc_accelerate, gc_drift, gc_brake, gc_spindash
 };
 
 const INT32 gcl_movement[num_gcl_movement] = {
-	gc_accelerate, gc_drift, gc_brake, gc_turnleft, gc_turnright
+	gc_accelerate, gc_drift, gc_brake, gc_spindash, gc_turnleft, gc_turnright
 };
 
 const INT32 gcl_item[num_gcl_item] = {
@@ -64,7 +64,7 @@ const INT32 gcl_item[num_gcl_item] = {
 };
 
 const INT32 gcl_full[num_gcl_full] = {
-	gc_accelerate, gc_drift, gc_brake, gc_turnleft, gc_turnright,
+	gc_accelerate, gc_drift, gc_brake, gc_spindash, gc_turnleft, gc_turnright,
 	gc_fire, gc_aimforward, gc_aimbackward,
 	gc_lookback
 };
diff --git a/src/g_input.h b/src/g_input.h
index 651f95324..57941d6c1 100644
--- a/src/g_input.h
+++ b/src/g_input.h
@@ -78,6 +78,7 @@ typedef enum
 	gc_accelerate,
 	gc_drift,
 	gc_brake,
+	gc_spindash,
 	gc_fire,
 	gc_lookback,
 	gc_camreset,
@@ -129,10 +130,10 @@ extern INT32 gamecontroldefault[MAXSPLITSCREENPLAYERS][num_gamecontrolschemes][n
 #define num_gcl_accelerate 1
 #define num_gcl_brake 1
 #define num_gcl_drift 1
-#define num_gcl_spindash 3
-#define num_gcl_movement 5
+#define num_gcl_spindash 4
+#define num_gcl_movement 6
 #define num_gcl_item 3
-#define num_gcl_full 9
+#define num_gcl_full 10
 
 extern const INT32 gcl_accelerate[num_gcl_accelerate];
 extern const INT32 gcl_brake[num_gcl_brake];
diff --git a/src/m_menu.c b/src/m_menu.c
index 1a3c54738..b020f1555 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -1142,6 +1142,7 @@ static menuitem_t OP_AllControlsMenu[] =
 	{IT_CONTROL, NULL, "Turn Right",            M_ChangeControl, gc_turnright  },
 	{IT_CONTROL, NULL, "Drift",                 M_ChangeControl, gc_drift      },
 	{IT_CONTROL, NULL, "Brake",                 M_ChangeControl, gc_brake      },
+	{IT_CONTROL, NULL, "Spindash",              M_ChangeControl, gc_spindash   },
 	{IT_CONTROL, NULL, "Use/Throw Item",        M_ChangeControl, gc_fire       },
 	{IT_CONTROL, NULL, "Aim Forward",           M_ChangeControl, gc_aimforward },
 	{IT_CONTROL, NULL, "Aim Backward",          M_ChangeControl, gc_aimbackward},
@@ -10403,22 +10404,22 @@ static void M_Setup1PControlsMenu(INT32 choice)
 	OP_AllControlsMenu[0].itemaction = &OP_Joystick1Def;
 
 	// Unhide P1-only controls
-	OP_AllControlsMenu[15].status = IT_CONTROL; // Chat
-	//OP_AllControlsMenu[16].status = IT_CONTROL; // Team-chat
-	OP_AllControlsMenu[16].status = IT_CONTROL; // Rankings
-	//OP_AllControlsMenu[17].status = IT_CONTROL; // Viewpoint
-	// 18 is Reset Camera, 19 is Toggle Chasecam
-	OP_AllControlsMenu[20].status = IT_CONTROL; // Pause
-	OP_AllControlsMenu[21].status = IT_CONTROL; // Screenshot
-	OP_AllControlsMenu[22].status = IT_CONTROL; // GIF
-	OP_AllControlsMenu[23].status = IT_CONTROL; // System Menu
-	OP_AllControlsMenu[24].status = IT_CONTROL; // Console
-	/*OP_AllControlsMenu[25].status = IT_HEADER; // Spectator Controls header
-	OP_AllControlsMenu[26].status = IT_SPACE; // Spectator Controls space
-	OP_AllControlsMenu[27].status = IT_CONTROL; // Spectate
-	OP_AllControlsMenu[28].status = IT_CONTROL; // Look Up
-	OP_AllControlsMenu[29].status = IT_CONTROL; // Look Down
-	OP_AllControlsMenu[30].status = IT_CONTROL; // Center View
+	OP_AllControlsMenu[16].status = IT_CONTROL; // Chat
+	//OP_AllControlsMenu[17].status = IT_CONTROL; // Team-chat
+	OP_AllControlsMenu[17].status = IT_CONTROL; // Rankings
+	//OP_AllControlsMenu[18].status = IT_CONTROL; // Viewpoint
+	// 19 is Reset Camera, 20 is Toggle Chasecam
+	OP_AllControlsMenu[21].status = IT_CONTROL; // Pause
+	OP_AllControlsMenu[22].status = IT_CONTROL; // Screenshot
+	OP_AllControlsMenu[23].status = IT_CONTROL; // GIF
+	OP_AllControlsMenu[24].status = IT_CONTROL; // System Menu
+	OP_AllControlsMenu[25].status = IT_CONTROL; // Console
+	/*OP_AllControlsMenu[26].status = IT_HEADER; // Spectator Controls header
+	OP_AllControlsMenu[27].status = IT_SPACE; // Spectator Controls space
+	OP_AllControlsMenu[28].status = IT_CONTROL; // Spectate
+	OP_AllControlsMenu[29].status = IT_CONTROL; // Look Up
+	OP_AllControlsMenu[30].status = IT_CONTROL; // Look Down
+	OP_AllControlsMenu[31].status = IT_CONTROL; // Center View
 	*/
 
 	M_SetupNextMenu(&OP_AllControlsDef);
@@ -10435,22 +10436,22 @@ static void M_Setup2PControlsMenu(INT32 choice)
 	OP_AllControlsMenu[0].itemaction = &OP_Joystick2Def;
 
 	// Hide P1-only controls
-	OP_AllControlsMenu[15].status = IT_GRAYEDOUT2; // Chat
-	//OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Team-chat
-	OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Rankings
-	//OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Viewpoint
-	// 18 is Reset Camera, 19 is Toggle Chasecam
-	OP_AllControlsMenu[20].status = IT_GRAYEDOUT2; // Pause
-	OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Screenshot
-	OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // GIF
-	OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // System Menu
-	OP_AllControlsMenu[24].status = IT_GRAYEDOUT2; // Console
-	/*OP_AllControlsMenu[25].status = IT_GRAYEDOUT2; // Spectator Controls header
-	OP_AllControlsMenu[26].status = IT_GRAYEDOUT2; // Spectator Controls space
-	OP_AllControlsMenu[27].status = IT_GRAYEDOUT2; // Spectate
-	OP_AllControlsMenu[28].status = IT_GRAYEDOUT2; // Look Up
-	OP_AllControlsMenu[29].status = IT_GRAYEDOUT2; // Look Down
-	OP_AllControlsMenu[30].status = IT_GRAYEDOUT2; // Center View
+	OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Chat
+	//OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Team-chat
+	OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Rankings
+	//OP_AllControlsMenu[18].status = IT_GRAYEDOUT2; // Viewpoint
+	// 19 is Reset Camera, 20 is Toggle Chasecam
+	OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Pause
+	OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // Screenshot
+	OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // GIF
+	OP_AllControlsMenu[24].status = IT_GRAYEDOUT2; // System Menu
+	OP_AllControlsMenu[25].status = IT_GRAYEDOUT2; // Console
+	/*OP_AllControlsMenu[26].status = IT_GRAYEDOUT2; // Spectator Controls header
+	OP_AllControlsMenu[27].status = IT_GRAYEDOUT2; // Spectator Controls space
+	OP_AllControlsMenu[28].status = IT_GRAYEDOUT2; // Spectate
+	OP_AllControlsMenu[29].status = IT_GRAYEDOUT2; // Look Up
+	OP_AllControlsMenu[30].status = IT_GRAYEDOUT2; // Look Down
+	OP_AllControlsMenu[31].status = IT_GRAYEDOUT2; // Center View
 	*/
 
 	M_SetupNextMenu(&OP_AllControlsDef);
@@ -10467,22 +10468,22 @@ static void M_Setup3PControlsMenu(INT32 choice)
 	OP_AllControlsMenu[0].itemaction = &OP_Joystick3Def;
 
 	// Hide P1-only controls
-	OP_AllControlsMenu[15].status = IT_GRAYEDOUT2; // Chat
-	//OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Team-chat
-	OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Rankings
-	//OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Viewpoint
-	// 18 is Reset Camera, 19 is Toggle Chasecam
-	OP_AllControlsMenu[20].status = IT_GRAYEDOUT2; // Pause
-	OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Screenshot
-	OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // GIF
-	OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // System Menu
-	OP_AllControlsMenu[24].status = IT_GRAYEDOUT2; // Console
-	/*OP_AllControlsMenu[25].status = IT_GRAYEDOUT2; // Spectator Controls header
-	OP_AllControlsMenu[26].status = IT_GRAYEDOUT2; // Spectator Controls space
-	OP_AllControlsMenu[27].status = IT_GRAYEDOUT2; // Spectate
-	OP_AllControlsMenu[28].status = IT_GRAYEDOUT2; // Look Up
-	OP_AllControlsMenu[29].status = IT_GRAYEDOUT2; // Look Down
-	OP_AllControlsMenu[30].status = IT_GRAYEDOUT2; // Center View
+	OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Chat
+	//OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Team-chat
+	OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Rankings
+	//OP_AllControlsMenu[18].status = IT_GRAYEDOUT2; // Viewpoint
+	// 19 is Reset Camera, 20 is Toggle Chasecam
+	OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Pause
+	OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // Screenshot
+	OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // GIF
+	OP_AllControlsMenu[24].status = IT_GRAYEDOUT2; // System Menu
+	OP_AllControlsMenu[25].status = IT_GRAYEDOUT2; // Console
+	/*OP_AllControlsMenu[26].status = IT_GRAYEDOUT2; // Spectator Controls header
+	OP_AllControlsMenu[27].status = IT_GRAYEDOUT2; // Spectator Controls space
+	OP_AllControlsMenu[28].status = IT_GRAYEDOUT2; // Spectate
+	OP_AllControlsMenu[29].status = IT_GRAYEDOUT2; // Look Up
+	OP_AllControlsMenu[30].status = IT_GRAYEDOUT2; // Look Down
+	OP_AllControlsMenu[31].status = IT_GRAYEDOUT2; // Center View
 	*/
 
 	M_SetupNextMenu(&OP_AllControlsDef);
@@ -10499,22 +10500,22 @@ static void M_Setup4PControlsMenu(INT32 choice)
 	OP_AllControlsMenu[0].itemaction = &OP_Joystick4Def;
 
 	// Hide P1-only controls
-	OP_AllControlsMenu[15].status = IT_GRAYEDOUT2; // Chat
-	//OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Team-chat
-	OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Rankings
-	//OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Viewpoint
-	// 18 is Reset Camera, 19 is Toggle Chasecam
-	OP_AllControlsMenu[20].status = IT_GRAYEDOUT2; // Pause
-	OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Screenshot
-	OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // GIF
-	OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // System Menu
-	OP_AllControlsMenu[24].status = IT_GRAYEDOUT2; // Console
-	/*OP_AllControlsMenu[25].status = IT_GRAYEDOUT2; // Spectator Controls header
-	OP_AllControlsMenu[26].status = IT_GRAYEDOUT2; // Spectator Controls space
-	OP_AllControlsMenu[27].status = IT_GRAYEDOUT2; // Spectate
-	OP_AllControlsMenu[28].status = IT_GRAYEDOUT2; // Look Up
-	OP_AllControlsMenu[29].status = IT_GRAYEDOUT2; // Look Down
-	OP_AllControlsMenu[30].status = IT_GRAYEDOUT2; // Center View
+	OP_AllControlsMenu[16].status = IT_GRAYEDOUT2; // Chat
+	//OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Team-chat
+	OP_AllControlsMenu[17].status = IT_GRAYEDOUT2; // Rankings
+	//OP_AllControlsMenu[18].status = IT_GRAYEDOUT2; // Viewpoint
+	// 19 is Reset Camera, 20 is Toggle Chasecam
+	OP_AllControlsMenu[21].status = IT_GRAYEDOUT2; // Pause
+	OP_AllControlsMenu[22].status = IT_GRAYEDOUT2; // Screenshot
+	OP_AllControlsMenu[23].status = IT_GRAYEDOUT2; // GIF
+	OP_AllControlsMenu[24].status = IT_GRAYEDOUT2; // System Menu
+	OP_AllControlsMenu[25].status = IT_GRAYEDOUT2; // Console
+	/*OP_AllControlsMenu[26].status = IT_GRAYEDOUT2; // Spectator Controls header
+	OP_AllControlsMenu[27].status = IT_GRAYEDOUT2; // Spectator Controls space
+	OP_AllControlsMenu[28].status = IT_GRAYEDOUT2; // Spectate
+	OP_AllControlsMenu[29].status = IT_GRAYEDOUT2; // Look Up
+	OP_AllControlsMenu[30].status = IT_GRAYEDOUT2; // Look Down
+	OP_AllControlsMenu[31].status = IT_GRAYEDOUT2; // Center View
 	*/
 
 	M_SetupNextMenu(&OP_AllControlsDef);

From 8ebfb656cc9c57f5067ad12492ee274d09027ed2 Mon Sep 17 00:00:00 2001
From: Sally Coolatta <tehrealsalt@gmail.com>
Date: Thu, 11 Mar 2021 15:03:30 -0500
Subject: [PATCH 29/30] Fuck the gamma shortcut, replace it with a fullscreen
 toggle

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

diff --git a/src/m_menu.c b/src/m_menu.c
index 1a3c54738..e9b24e7ab 100644
--- a/src/m_menu.c
+++ b/src/m_menu.c
@@ -2703,8 +2703,8 @@ boolean M_Responder(event_t *ev)
 				M_QuitSRB2(0);
 				return true;
 
-			case KEY_F11: // Gamma Level
-				CV_AddValue(&cv_globalgamma, 1);
+			case KEY_F11: // Fullscreen
+				CV_AddValue(&cv_fullscreen, 1);
 				return true;
 
 			// Spymode on F12 handled in game logic

From 5e70789cdaf30f8abc1dc9d9b7db177757d35db9 Mon Sep 17 00:00:00 2001
From: toaster <rollerorbital@gmail.com>
Date: Wed, 17 Mar 2021 18:39:19 +0000
Subject: [PATCH 30/30] Prevent hitlag from eating death events (resolves
 #112).

I could've used the existing `boolean force` here to skip over the check, but I think the MF_SHOOTABLE check is appropriate, and the DMG_CANTHURTSELF flag will be respected this way too.

Also, clean up a ridiculously long statement.
* `k_spinouttype` will never have the value of 2. This might've been a check for KSPIN_IFRAMES, but
    * that already controls `pw_flashing` earlier in the check
    * completely unlabeled, so it's nonsense that needs to be stripped
* `k_squishedtimer` wa mou shinderu.
---
 src/p_inter.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/p_inter.c b/src/p_inter.c
index 541d1a890..d29b687ec 100644
--- a/src/p_inter.c
+++ b/src/p_inter.c
@@ -1863,7 +1863,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
 		if (!(target->flags & MF_SHOOTABLE))
 			return false; // shouldn't happen...
 
-		if (target->hitlag > 0)
+		if (!(damagetype & DMG_DEATHMASK) && target->hitlag > 0)
 			return false;
 	}
 
@@ -1947,7 +1947,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
 
 				if (combo == false)
 				{
-					if (player->powers[pw_flashing] > 0 || player->kartstuff[k_squishedtimer] > 0 || (player->kartstuff[k_spinouttimer] > 0 && player->kartstuff[k_spinouttype] != 2))
+					if (player->powers[pw_flashing] > 0)
 					{
 						// Post-hit invincibility
 						K_DoInstashield(player);