diff --git a/src/d_clisrv.c b/src/d_clisrv.c
index 81af6b8ff..e08a5e709 100644
--- a/src/d_clisrv.c
+++ b/src/d_clisrv.c
@@ -426,7 +426,7 @@ static void D_Clearticcmd(tic_t tic)
 	D_FreeTextcmd(tic);
 
 	for (i = 0; i < MAXPLAYERS; i++)
-		netcmds[tic%TICQUEUE][i].angleturn = 0;
+		netcmds[tic%TICQUEUE][i].flags = 0;
 
 	DEBFILE(va("clear tic %5u (%2u)\n", tic, tic%TICQUEUE));
 }
@@ -527,9 +527,7 @@ static inline void resynch_write_player(resynch_pak *rsp, const size_t i)
 	rsp->pflags = (UINT32)LONG(players[i].pflags); //pflags_t
 	rsp->panim  = (UINT8)players[i].panim; //panim_t
 
-	rsp->angleturn = (INT16)SHORT(players[i].angleturn);
-	rsp->oldrelangleturn = (INT16)SHORT(players[i].oldrelangleturn);
-
+	rsp->angleturn = (angle_t)LONG(players[i].angleturn);
 	rsp->aiming = (angle_t)LONG(players[i].aiming);
 
 	for (j = 0; j < NUMPOWERS; ++j)
@@ -673,9 +671,7 @@ static void resynch_read_player(resynch_pak *rsp)
 	players[i].pflags = (UINT32)LONG(rsp->pflags); //pflags_t
 	players[i].panim  = (UINT8)rsp->panim; //panim_t
 
-	players[i].angleturn = (INT16)SHORT(rsp->angleturn);
-	players[i].oldrelangleturn = (INT16)SHORT(rsp->oldrelangleturn);
-
+	players[i].angleturn = (angle_t)LONG(rsp->angleturn);
 	players[i].aiming = (angle_t)LONG(rsp->aiming);
 
 	for (j = 0; j < NUMPOWERS; ++j)
@@ -3675,8 +3671,7 @@ static void Got_AddPlayer(UINT8 **p, INT32 playernum)
 			DEBFILE("spawning me\n");
 		}
 
-		ticcmd_oldangleturn[splitscreenplayer] = newplayer->oldrelangleturn;
-		P_ForceLocalAngle(newplayer, (angle_t)(newplayer->angleturn << 16));
+		P_ForceLocalAngle(newplayer, newplayer->angleturn);
 
 		D_SendPlayerConfig();
 		addedtogame = true;
@@ -4485,7 +4480,7 @@ static void HandlePacketFromAwayNode(SINT8 node)
 static boolean CheckForSpeedHacks(UINT8 p)
 {
 	if (netcmds[maketic%TICQUEUE][p].forwardmove > MAXPLMOVE || netcmds[maketic%TICQUEUE][p].forwardmove < -MAXPLMOVE
-		|| netcmds[maketic%TICQUEUE][p].driftturn > KART_FULLTURN || netcmds[maketic%TICQUEUE][p].driftturn < -KART_FULLTURN)
+		|| netcmds[maketic%TICQUEUE][p].turning > KART_FULLTURN || netcmds[maketic%TICQUEUE][p].turning < -KART_FULLTURN)
 	{
 		CONS_Alert(CONS_WARNING, M_GetText("Illegal movement value received from node %d\n"), playernode[p]);
 		//D_Clearticcmd(k);
@@ -5445,22 +5440,22 @@ static void Local_Maketic(INT32 realtics)
 
 	// translate inputs (keyboard/mouse/joystick) into game controls
 	G_BuildTiccmd(&localcmds[0], realtics, 1);
-	localcmds[0].angleturn |= TICCMD_RECEIVED;
+	localcmds[0].flags |= TICCMD_RECEIVED;
 
 	if (splitscreen)
 	{
 		G_BuildTiccmd(&localcmds[1], realtics, 2);
-		localcmds[1].angleturn |= TICCMD_RECEIVED;
+		localcmds[1].flags |= TICCMD_RECEIVED;
 
 		if (splitscreen > 1)
 		{
 			G_BuildTiccmd(&localcmds[2], realtics, 3);
-			localcmds[2].angleturn |= TICCMD_RECEIVED;
+			localcmds[2].flags |= TICCMD_RECEIVED;
 
 			if (splitscreen > 2)
 			{
 				G_BuildTiccmd(&localcmds[3], realtics, 4);
-				localcmds[3].angleturn |= TICCMD_RECEIVED;
+				localcmds[3].flags |= TICCMD_RECEIVED;
 			}
 		}
 	}
@@ -5483,25 +5478,23 @@ static void SV_Maketic(void)
 		}
 
 		// We didn't receive this tic
-		if ((netcmds[maketic % TICQUEUE][i].angleturn & TICCMD_RECEIVED) == 0)
+		if ((netcmds[maketic % TICQUEUE][i].flags & TICCMD_RECEIVED) == 0)
 		{
 			ticcmd_t *    ticcmd = &netcmds[(maketic    ) % BACKUPTICS][i];
 			ticcmd_t *prevticcmd = &netcmds[(maketic - 1) % BACKUPTICS][i];
 
 			if (players[i].quittime)
 			{
-				// Copy the angle/aiming from the previous tic
-				// and empty the other inputs
+				// empty inputs but consider recieved
 				memset(ticcmd, 0, sizeof(netcmds[0][0]));
-				ticcmd->angleturn = prevticcmd->angleturn | TICCMD_RECEIVED;
-				ticcmd->aiming = prevticcmd->aiming;
+				ticcmd->flags = prevticcmd->flags | TICCMD_RECEIVED;
 			}
 			else
 			{
 				DEBFILE(va("MISS tic%4d for player %d\n", maketic, i));
 				// Copy the input from the previous tic
 				*ticcmd = *prevticcmd;
-				ticcmd->angleturn &= ~TICCMD_RECEIVED;
+				ticcmd->flags &= ~TICCMD_RECEIVED;
 			}
 		}
 	}
diff --git a/src/d_clisrv.h b/src/d_clisrv.h
index bca6a0721..a54209bec 100644
--- a/src/d_clisrv.h
+++ b/src/d_clisrv.h
@@ -208,9 +208,7 @@ typedef struct
 	UINT32 pflags; // pflags_t
 	UINT8 panim; // panim_t
 
-	INT16 angleturn;
-	INT16 oldrelangleturn;
-
+	angle_t angleturn;
 	angle_t aiming;
 	UINT16 powers[NUMPOWERS];
 
diff --git a/src/d_player.h b/src/d_player.h
index 98d47f41d..283196e4d 100644
--- a/src/d_player.h
+++ b/src/d_player.h
@@ -486,8 +486,7 @@ typedef struct player_s
 
 	angle_t viewrollangle;
 
-	INT16 angleturn;
-	INT16 oldrelangleturn;
+	angle_t angleturn;
 
 	// Mouse aiming, where the guy is looking at!
 	// It is updated with cmd->aiming.
@@ -505,8 +504,6 @@ typedef struct player_s
 	// SRB2kart stuff
 	INT32 kartstuff[NUMKARTSTUFF];
 	INT32 karthud[NUMKARTHUD];
-	INT16 lturn_max[MAXPREDICTTICS]; // What's the expected turn value for full-left for a number of frames back (to account for netgame latency)?
-	INT16 rturn_max[MAXPREDICTTICS]; // Ditto but for full-right
 	UINT32 distancetofinish;
 	waypoint_t *nextwaypoint;
 	respawnvars_t respawn; // Respawn info
diff --git a/src/d_ticcmd.h b/src/d_ticcmd.h
index d4a8013ca..ed72659e5 100644
--- a/src/d_ticcmd.h
+++ b/src/d_ticcmd.h
@@ -27,7 +27,7 @@
 typedef enum
 {
 	BT_ACCELERATE	= 1,		// Accelerate
-	BT_DRIFT		= 1<<2,		// Drift (direction is cmd->driftturn)
+	BT_DRIFT		= 1<<2,		// Drift (direction is cmd->turning)
 	BT_BRAKE		= 1<<3,		// Brake
 	BT_ATTACK		= 1<<4,		// Use Item
 	BT_FORWARD		= 1<<5,		// Aim Item Forward
@@ -49,9 +49,11 @@ typedef enum
 // Mainly movements/button commands per game tick,
 // plus a checksum for internal state consistency.
 
-// bits in angleturn
+// ticcmd turning bits
+#define TICCMD_REDUCE 16
+
+// ticcmd flags
 #define TICCMD_RECEIVED 1
-#define TICCMD_XY 2
 
 #if defined(_MSC_VER)
 #pragma pack(1)
@@ -60,11 +62,11 @@ typedef enum
 typedef struct
 {
 	SINT8 forwardmove; // -MAXPLMOVE to MAXPLMOVE (50)
-	INT16 angleturn; // <<16 for angle delta - saved as 1 byte into demos
+	INT16 turning; // Turn speed
 	INT16 aiming; // vertical aiming, see G_BuildTicCmd
 	UINT16 buttons;
-	INT16 driftturn; // SRB2Kart: Used for getting drift turn speed
 	UINT8 latency; // Netgames: how many tics ago was this ticcmd generated from this player's end?
+	UINT8 flags;
 } ATTRPACK ticcmd_t;
 
 #if defined(_MSC_VER)
diff --git a/src/g_demo.c b/src/g_demo.c
index dc1aa4112..559867531 100644
--- a/src/g_demo.c
+++ b/src/g_demo.c
@@ -123,11 +123,11 @@ demoghost *ghosts = NULL;
 // For demos
 #define ZT_FWD     0x01
 #define ZT_SIDE    0x02
-#define ZT_ANGLE   0x04
+#define ZT_TURNING 0x04
 #define ZT_BUTTONS 0x08
 #define ZT_AIMING  0x10
-#define ZT_DRIFT   0x20
-#define ZT_LATENCY 0x40
+#define ZT_LATENCY 0x20
+#define ZT_FLAGS   0x40
 #define DEMOMARKER 0x80 // demoend
 
 UINT8 demo_extradata[MAXPLAYERS];
@@ -483,19 +483,18 @@ void G_ReadDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
 
 	if (ziptic & ZT_FWD)
 		oldcmd[playernum].forwardmove = READSINT8(demo_p);
-	if (ziptic & ZT_ANGLE)
-		oldcmd[playernum].angleturn = READINT16(demo_p);
+	if (ziptic & ZT_TURNING)
+		oldcmd[playernum].turning = READINT16(demo_p);
 	if (ziptic & ZT_BUTTONS)
 		oldcmd[playernum].buttons = READUINT16(demo_p);
 	if (ziptic & ZT_AIMING)
 		oldcmd[playernum].aiming = READINT16(demo_p);
-	if (ziptic & ZT_DRIFT)
-		oldcmd[playernum].driftturn = READINT16(demo_p);
 	if (ziptic & ZT_LATENCY)
 		oldcmd[playernum].latency = READUINT8(demo_p);
+	if (ziptic & ZT_FLAGS)
+		oldcmd[playernum].latency = READUINT8(demo_p);
 
 	G_CopyTiccmd(cmd, &oldcmd[playernum], 1);
-	players[playernum].angleturn = cmd->angleturn;
 
 	if (!(demoflags & DF_GHOST) && *demo_p == DEMOMARKER)
 	{
@@ -522,11 +521,11 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
 		ziptic |= ZT_FWD;
 	}
 
-	if (cmd->angleturn != oldcmd[playernum].angleturn)
+	if (cmd->turning != oldcmd[playernum].turning)
 	{
-		WRITEINT16(demo_p,cmd->angleturn);
-		oldcmd[playernum].angleturn = cmd->angleturn;
-		ziptic |= ZT_ANGLE;
+		WRITEINT16(demo_p,cmd->turning);
+		oldcmd[playernum].turning = cmd->turning;
+		ziptic |= ZT_TURNING;
 	}
 
 	if (cmd->buttons != oldcmd[playernum].buttons)
@@ -543,13 +542,6 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
 		ziptic |= ZT_AIMING;
 	}
 
-	if (cmd->driftturn != oldcmd[playernum].driftturn)
-	{
-		WRITEINT16(demo_p,cmd->driftturn);
-		oldcmd[playernum].driftturn = cmd->driftturn;
-		ziptic |= ZT_DRIFT;
-	}
-
 	if (cmd->latency != oldcmd[playernum].latency)
 	{
 		WRITEUINT8(demo_p,cmd->latency);
@@ -557,6 +549,13 @@ void G_WriteDemoTiccmd(ticcmd_t *cmd, INT32 playernum)
 		ziptic |= ZT_LATENCY;
 	}
 
+	if (cmd->flags != oldcmd[playernum].flags)
+	{
+		WRITEUINT8(demo_p,cmd->flags);
+		oldcmd[playernum].flags = cmd->flags;
+		ziptic |= ZT_FLAGS;
+	}
+
 	*ziptic_p = ziptic;
 
 	// attention here for the ticcmd size!
@@ -1086,16 +1085,16 @@ void G_GhostTicker(void)
 
 		if (ziptic & ZT_FWD)
 			g->p++;
-		if (ziptic & ZT_ANGLE)
+		if (ziptic & ZT_TURNING)
 			g->p += 2;
 		if (ziptic & ZT_BUTTONS)
 			g->p += 2;
 		if (ziptic & ZT_AIMING)
 			g->p += 2;
-		if (ziptic & ZT_DRIFT)
-			g->p += 2;
 		if (ziptic & ZT_LATENCY)
 			g->p += 1;
+		if (ziptic & ZT_FLAGS)
+			g->p += 1;
 
 		// Grab ghost data.
 		ziptic = READUINT8(g->p);
diff --git a/src/g_game.c b/src/g_game.c
index 80bdc56fd..ac65aae81 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -853,15 +853,11 @@ static void G_HandleAxisDeadZone(UINT8 splitnum, joystickvector2_t *joystickvect
 INT32 localaiming[MAXSPLITSCREENPLAYERS];
 angle_t localangle[MAXSPLITSCREENPLAYERS];
 
-static INT32 forwardmove = 50<<FRACBITS>>16;
-static INT32 angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
-
-INT16 ticcmd_oldangleturn[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;
-	const INT32 speed = 1;
 
 	const INT32 lookaxis = cv_lookaxis[forplayer].value;
 	const boolean invertmouse = cv_invertmouse.value;
@@ -881,7 +877,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 
 	player_t *player = &players[g_localplayers[forplayer]];
 	camera_t *thiscam = &camera[forplayer];
-	angle_t *myangle = &localangle[forplayer];
 	INT32 *laim = &localaiming[forplayer];
 	INT32 *th = &turnheld[forplayer];
 	boolean *kbl = &keyboard_look[forplayer];
@@ -913,7 +908,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	// Kart, don't build a ticcmd if someone is resynching or the server is stopped too so we don't fly off course in bad conditions
 	if (paused || P_AutoPause() || (gamestate == GS_LEVEL && player->playerstate == PST_REBORN) || hu_resynching)
 	{
-		cmd->angleturn = ticcmd_oldangleturn[forplayer];
 		cmd->aiming = G_ClipAimingPitch(laim);
 		return;
 	}
@@ -954,36 +948,31 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		*th = 0;
 
 	if (*th < SLOWTURNTICS)
-		tspeed = 2; // slow turn
+		tspeed = 1; // slow turn
 	else
-		tspeed = speed;
+		tspeed = 0;
 
-	cmd->driftturn = 0;
+	cmd->turning = 0;
 
 	// let movement keys cancel each other out
 	if (turnright && !(turnleft))
 	{
-		cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed]));
-		cmd->driftturn = (INT16)(cmd->driftturn - (angleturn[tspeed]));
+		cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
 	}
 	else if (turnleft && !(turnright))
 	{
-		cmd->angleturn = (INT16)(cmd->angleturn + (angleturn[tspeed]));
-		cmd->driftturn = (INT16)(cmd->driftturn + (angleturn[tspeed]));
+		cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
 	}
 
 	if (analogjoystickmove && joystickvector.xaxis != 0)
 	{
-		// JOYAXISRANGE should be 1023 (divide by 1024)
-		cmd->angleturn = (INT16)(cmd->angleturn - (((joystickvector.xaxis * angleturn[1]) >> 10))); // ANALOG!
-		cmd->driftturn = (INT16)(cmd->driftturn - (((joystickvector.xaxis * angleturn[1]) >> 10)));
+		cmd->turning = (INT16)(cmd->turning - (((joystickvector.xaxis * angleturn[0]) >> 10)));
 	}
 
 	// Specator mouse turning
 	if (player->spectator)
 	{
-		cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8)));
-		cmd->driftturn = (INT16)(cmd->driftturn - ((mousex*(encoremode ? -1 : 1)*8)));
+		cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
 	}
 
 	if (player->spectator || objectplacing) // SRB2Kart: spectators need special controls
@@ -996,9 +985,9 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 			cmd->buttons |= BT_BRAKE;
 		axis = PlayerJoyAxis(ssplayer, AXISAIM);
 		if (PlayerInputDown(ssplayer, gc_aimforward) || (usejoystick && axis < 0))
-			forward += forwardmove;
+			forward += MAXPLMOVE;
 		if (PlayerInputDown(ssplayer, gc_aimbackward) || (usejoystick && axis > 0))
-			forward -= forwardmove;
+			forward -= MAXPLMOVE;
 	}
 	else
 	{
@@ -1007,13 +996,13 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		if (PlayerInputDown(ssplayer, gc_accelerate) || (gamepadjoystickmove && axis > 0) || player->kartstuff[k_sneakertimer])
 		{
 			cmd->buttons |= BT_ACCELERATE;
-			forward = forwardmove;	// 50
+			forward = MAXPLMOVE; // 50
 		}
 		else if (analogjoystickmove && axis > 0)
 		{
 			cmd->buttons |= BT_ACCELERATE;
 			// JOYAXISRANGE is supposed to be 1023 (divide by 1024)
-			forward += ((axis * forwardmove) >> 10);
+			forward += ((axis * MAXPLMOVE) >> 10);
 		}
 
 		axis = PlayerJoyAxis(ssplayer, AXISBRAKE);
@@ -1021,14 +1010,14 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		{
 			cmd->buttons |= BT_BRAKE;
 			if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0)
-				forward -= forwardmove;
+				forward -= MAXPLMOVE;
 		}
 		else if (analogjoystickmove && axis > 0)
 		{
 			cmd->buttons |= BT_BRAKE;
 			// JOYAXISRANGE is supposed to be 1023 (divide by 1024)
 			if (cmd->buttons & BT_ACCELERATE || cmd->forwardmove <= 0)
-				forward -= ((axis * forwardmove) >> 10);
+				forward -= ((axis * MAXPLMOVE) >> 10);
 		}
 
 		// But forward/backward IS used for aiming.
@@ -1124,35 +1113,8 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 
 	cmd->forwardmove += (SINT8)forward;
 
-	if (cmd->forwardmove > MAXPLMOVE)
-		cmd->forwardmove = MAXPLMOVE;
-	else if (cmd->forwardmove < -MAXPLMOVE)
-		cmd->forwardmove = -MAXPLMOVE;
-
-	//{ SRB2kart - Drift support
-	// Not grouped with the rest of turn stuff because it needs to know what buttons you're pressing for rubber-burn turn
-	// limit turning to angleturn[1] to stop mouselook letting you look too fast
-	if (cmd->angleturn > (angleturn[1]))
-		cmd->angleturn = (angleturn[1]);
-	else if (cmd->angleturn < (-angleturn[1]))
-		cmd->angleturn = (-angleturn[1]);
-
-	if (cmd->driftturn > (angleturn[1]))
-		cmd->driftturn = (angleturn[1]);
-	else if (cmd->driftturn < (-angleturn[1]))
-		cmd->driftturn = (-angleturn[1]);
-
-	if (player->mo)
-		cmd->angleturn = K_GetKartTurnValue(player, cmd->angleturn);
-
-	cmd->angleturn *= realtics;
-
-	if (!hu_stopped)
-	{
-		*myangle += (cmd->angleturn<<16);
-	}
-
 	cmd->latency = modeattacking ? 0 : (leveltime & 0xFF); // Send leveltime when this tic was generated to the server for control lag calculations
+	cmd->flags = 0;
 
 	/* 	Lua: Allow this hook to overwrite ticcmd.
 		We check if we're actually in a level because for some reason this Hook would run in menus and on the titlescreen otherwise.
@@ -1167,7 +1129,17 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 	if (gamestate == GS_LEVEL)
 		LUAh_PlayerCmd(player, cmd);
 
-	//Reset away view if a command is given.
+	if (cmd->forwardmove > MAXPLMOVE)
+		cmd->forwardmove = MAXPLMOVE;
+	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]);
+
+	// Reset away view if a command is given.
 	if ((cmd->forwardmove || cmd->buttons)
 		&& !r_splitscreen && displayplayers[0] != consoleplayer && ssplayer == 1)
 	{
@@ -1176,9 +1148,6 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer)
 		LUAh_ViewpointSwitch(player, &players[consoleplayer], true);
 		displayplayers[0] = consoleplayer;
 	}
-
-	cmd->angleturn = (INT16)(cmd->angleturn + ticcmd_oldangleturn[forplayer]);
-	ticcmd_oldangleturn[forplayer] = cmd->angleturn;
 }
 
 ticcmd_t *G_CopyTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
@@ -1192,11 +1161,11 @@ ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
 	for (i = 0; i < n; i++)
 	{
 		dest[i].forwardmove = src[i].forwardmove;
-		dest[i].angleturn = SHORT(src[i].angleturn);
+		dest[i].turning = (INT16)SHORT(src[i].turning);
 		dest[i].aiming = (INT16)SHORT(src[i].aiming);
 		dest[i].buttons = (UINT16)SHORT(src[i].buttons);
-		dest[i].driftturn = SHORT(src[i].driftturn);
 		dest[i].latency = src[i].latency;
+		dest[i].flags = src[i].flags;
 	}
 	return dest;
 }
@@ -1878,7 +1847,7 @@ void G_Ticker(boolean run)
 				G_CopyTiccmd(cmd, &netcmds[buf][i], 1);
 
 				// Use the leveltime sent in the player's ticcmd to determine control lag
-				if (modeattacking || K_PlayerUsesBotMovement(&players[i]))
+				if (K_PlayerUsesBotMovement(&players[i]))
 				{
 					// Never has lag
 					cmd->latency = 0;
@@ -1888,10 +1857,6 @@ void G_Ticker(boolean run)
 					//@TODO add a cvar to allow setting this max
 					cmd->latency = min(((leveltime & 0xFF) - cmd->latency) & 0xFF, MAXPREDICTTICS-1);
 				}
-
-				players[i].angleturn += players[i].cmd.angleturn - players[i].oldrelangleturn;
-				players[i].oldrelangleturn = players[i].cmd.angleturn;
-				players[i].cmd.angleturn = players[i].angleturn;
 			}
 		}
 	}
@@ -2089,8 +2054,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
 	UINT8 botdifficulty;
 
 	INT16 rings;
-	INT16 playerangleturn;
-	INT16 oldrelangleturn;
+	angle_t playerangleturn;
 
 	UINT8 botdiffincrease;
 	boolean botrival;
@@ -2126,7 +2090,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
 	pflags = (players[player].pflags & (PF_WANTSTOJOIN|PF_GAMETYPEOVER));
 
 	playerangleturn = players[player].angleturn;
-	oldrelangleturn = players[player].oldrelangleturn;
 
 	// As long as we're not in multiplayer, carry over cheatcodes from map to map
 	if (!(netgame || multiplayer))
@@ -2227,7 +2190,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
 	p->splitscreenindex = splitscreenindex;
 	p->spectator = spectator;
 	p->angleturn = playerangleturn;
-	p->oldrelangleturn = oldrelangleturn;
 
 	// save player config truth reborn
 	p->skincolor = skincolor;
diff --git a/src/g_game.h b/src/g_game.h
index 8e3515119..00ffbf134 100644
--- a/src/g_game.h
+++ b/src/g_game.h
@@ -82,7 +82,6 @@ extern consvar_t cv_resume;
 // build an internal map name MAPxx from map number
 const char *G_BuildMapName(INT32 map);
 
-extern INT16 ticcmd_oldangleturn[MAXSPLITSCREENPLAYERS];
 void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics, UINT8 ssplayer);
 
 // copy ticcmd_t to and fro the normal way
diff --git a/src/k_bot.c b/src/k_bot.c
index 762ff7ee5..c36891de2 100644
--- a/src/k_bot.c
+++ b/src/k_bot.c
@@ -28,8 +28,6 @@
 #include "r_things.h" // numskins
 
 
-static INT16 bot_oldangleturn[MAXPLAYERS];
-
 /*--------------------------------------------------
 	boolean K_AddBot(UINT8 skin, UINT8 difficulty, UINT8 *p)
 
@@ -864,8 +862,7 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 		if (abs(player->botvars.turnconfirm) >= BOTTURNCONFIRM)
 		{
 			// You're commiting to your turn, you're allowed!
-			cmd->driftturn = turnamt;
-			cmd->angleturn += K_GetKartTurnValue(player, turnamt);
+			cmd->turning = turnamt;
 		}
 	}
 
@@ -874,8 +871,5 @@ void K_BuildBotTiccmd(player_t *player, ticcmd_t *cmd)
 	{
 		Z_Free(predict);
 	}
-
-	cmd->angleturn = (INT16)(cmd->angleturn + bot_oldangleturn[player - players]);
-	bot_oldangleturn[player - players] = cmd->angleturn;
 }
 
diff --git a/src/k_hud.c b/src/k_hud.c
index e89d28796..02c45f3a1 100644
--- a/src/k_hud.c
+++ b/src/k_hud.c
@@ -3394,13 +3394,13 @@ static void K_drawKartFirstPerson(void)
 			splitflags |= (stplyr->mo->frame & FF_TRANSMASK);
 	}
 
-	if (cmd->driftturn > 400) // strong left turn
+	if (cmd->turning > 400) // strong left turn
 		target = 2;
-	else if (cmd->driftturn < -400) // strong right turn
+	else if (cmd->turning < -400) // strong right turn
 		target = -2;
-	else if (cmd->driftturn > 0) // weak left turn
+	else if (cmd->turning > 0) // weak left turn
 		target = 1;
-	else if (cmd->driftturn < 0) // weak right turn
+	else if (cmd->turning < 0) // weak right turn
 		target = -1;
 	else // forward
 		target = 0;
@@ -3423,8 +3423,8 @@ static void K_drawKartFirstPerson(void)
 	x <<= FRACBITS;
 	y <<= FRACBITS;
 
-	if (tn != cmd->driftturn/50)
-		tn -= (tn - (cmd->driftturn/50))/8;
+	if (tn != cmd->turning/50)
+		tn -= (tn - (cmd->turning/50))/8;
 
 	if (dr != stplyr->kartstuff[k_drift]*16)
 		dr -= (dr - (stplyr->kartstuff[k_drift]*16))/8;
@@ -3546,14 +3546,14 @@ static void K_drawInput(void)
 
 	y -= 1;
 
-	if (!cmd->driftturn) // no turn
+	if (!cmd->turning) // no turn
 		target = 0;
 	else // turning of multiple strengths!
 	{
-		target = ((abs(cmd->driftturn) - 1)/125)+1;
+		target = ((abs(cmd->turning) - 1)/125)+1;
 		if (target > 4)
 			target = 4;
-		if (cmd->driftturn < 0)
+		if (cmd->turning < 0)
 			target = -target;
 	}
 
diff --git a/src/k_kart.c b/src/k_kart.c
index 93b184c2d..2fb56ca2d 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -1712,11 +1712,11 @@ void K_KartMoveAnimation(player_t *player)
 	ticcmd_t *cmd = &player->cmd;
 	const boolean spinningwheels = ((cmd->buttons & BT_ACCELERATE) || (onground && player->speed > 0));
 
-	if (cmd->driftturn < -minturn)
+	if (cmd->turning < -minturn)
 	{
 		turndir = -1;
 	}
-	else if (cmd->driftturn > minturn)
+	else if (cmd->turning > minturn)
 	{
 		turndir = 1;
 	}
@@ -3029,8 +3029,8 @@ static void K_SpawnDriftSparks(player_t *player)
 			}
 		}
 
-		if ((player->kartstuff[k_drift] > 0 && player->cmd.driftturn > 0) // Inward drifts
-			|| (player->kartstuff[k_drift] < 0 && player->cmd.driftturn < 0))
+		if ((player->kartstuff[k_drift] > 0 && player->cmd.turning > 0) // Inward drifts
+			|| (player->kartstuff[k_drift] < 0 && player->cmd.turning < 0))
 		{
 			if ((player->kartstuff[k_drift] < 0 && (i & 1))
 				|| (player->kartstuff[k_drift] > 0 && !(i & 1)))
@@ -3043,8 +3043,8 @@ static void K_SpawnDriftSparks(player_t *player)
 				size--;
 			}
 		}
-		else if ((player->kartstuff[k_drift] > 0 && player->cmd.driftturn < 0) // Outward drifts
-			|| (player->kartstuff[k_drift] < 0 && player->cmd.driftturn > 0))
+		else if ((player->kartstuff[k_drift] > 0 && player->cmd.turning < 0) // Outward drifts
+			|| (player->kartstuff[k_drift] < 0 && player->cmd.turning > 0))
 		{
 			if ((player->kartstuff[k_drift] < 0 && (i & 1))
 				|| (player->kartstuff[k_drift] > 0 && !(i & 1)))
@@ -6401,14 +6401,14 @@ static void K_KartDrift(player_t *player, boolean onground)
 	}
 
 	// Drifting: left or right?
-	if ((player->cmd.driftturn > 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
+	if ((player->cmd.turning > 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
 		&& (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != 1)
 	{
 		// Starting left drift
 		player->kartstuff[k_drift] = 1;
 		player->kartstuff[k_driftend] = player->kartstuff[k_driftcharge] = 0;
 	}
-	else if ((player->cmd.driftturn < 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
+	else if ((player->cmd.turning < 0) && player->speed > minspeed && player->kartstuff[k_jmp] == 1
 		&& (player->kartstuff[k_drift] == 0 || player->kartstuff[k_driftend] == 1)) // && player->kartstuff[k_drift] != -1)
 	{
 		// Starting right drift
@@ -6453,10 +6453,10 @@ static void K_KartDrift(player_t *player, boolean onground)
 				if (player->kartstuff[k_drift] > 5)
 					player->kartstuff[k_drift] = 5;
 
-				if (player->cmd.driftturn > 0) // Inward
-					driftadditive += abs(player->cmd.driftturn)/100;
-				if (player->cmd.driftturn < 0) // Outward
-					driftadditive -= abs(player->cmd.driftturn)/75;
+				if (player->cmd.turning > 0) // Inward
+					driftadditive += abs(player->cmd.turning)/100;
+				if (player->cmd.turning < 0) // Outward
+					driftadditive -= abs(player->cmd.turning)/75;
 			}
 			else if (player->kartstuff[k_drift] <= -1) // Drifting to the right
 			{
@@ -6464,10 +6464,10 @@ static void K_KartDrift(player_t *player, boolean onground)
 				if (player->kartstuff[k_drift] < -5)
 					player->kartstuff[k_drift] = -5;
 
-				if (player->cmd.driftturn < 0) // Inward
-					driftadditive += abs(player->cmd.driftturn)/100;
-				if (player->cmd.driftturn > 0) // Outward
-					driftadditive -= abs(player->cmd.driftturn)/75;
+				if (player->cmd.turning < 0) // Inward
+					driftadditive += abs(player->cmd.turning)/100;
+				if (player->cmd.turning > 0) // Outward
+					driftadditive -= abs(player->cmd.turning)/75;
 			}
 
 			// Disable drift-sparks until you're going fast enough
@@ -6531,9 +6531,9 @@ static void K_KartDrift(player_t *player, boolean onground)
 	}
 
 	if ((player->kartstuff[k_handleboost] == 0)
-	|| (!player->cmd.driftturn)
+	|| (!player->cmd.turning)
 	|| (!player->kartstuff[k_aizdriftstrat])
-	|| (player->cmd.driftturn > 0) != (player->kartstuff[k_aizdriftstrat] > 0))
+	|| (player->cmd.turning > 0) != (player->kartstuff[k_aizdriftstrat] > 0))
 	{
 		if (!player->kartstuff[k_drift])
 			player->kartstuff[k_aizdriftstrat] = 0;
@@ -6747,7 +6747,7 @@ static void K_KartSpindash(player_t *player)
 
 	if (player->speed < 6*mapobjectscale && player->powers[pw_flashing] == 0)
 	{
-		if (cmd->driftturn != 0 && leveltime % 8 == 0)
+		if (cmd->turning != 0 && leveltime % 8 == 0)
 			S_StartSound(player->mo, sfx_ruburn);
 
 		if ((cmd->buttons & (BT_DRIFT|BT_BRAKE)) == (BT_DRIFT|BT_BRAKE))
diff --git a/src/lua_playerlib.c b/src/lua_playerlib.c
index 798c44704..9dbfa4d07 100644
--- a/src/lua_playerlib.c
+++ b/src/lua_playerlib.c
@@ -816,6 +816,7 @@ static int kartstuff_len(lua_State *L)
 }
 
 #define NOFIELD luaL_error(L, LUA_QL("ticcmd_t") " has no field named " LUA_QS, field)
+#define NOSET luaL_error(L, LUA_QL("ticcmd_t") " field " LUA_QS " cannot be set.", field)
 
 static int ticcmd_get(lua_State *L)
 {
@@ -826,16 +827,16 @@ static int ticcmd_get(lua_State *L)
 
 	if (fastcmp(field,"forwardmove"))
 		lua_pushinteger(L, cmd->forwardmove);
-	else if (fastcmp(field,"angleturn"))
-		lua_pushinteger(L, cmd->angleturn);
+	else if (fastcmp(field,"turning"))
+		lua_pushinteger(L, cmd->turning);
 	else if (fastcmp(field,"aiming"))
 		lua_pushinteger(L, cmd->aiming);
 	else if (fastcmp(field,"buttons"))
 		lua_pushinteger(L, cmd->buttons);
-	else if (fastcmp(field,"driftturn"))
-		lua_pushinteger(L, cmd->driftturn);
 	else if (fastcmp(field,"latency"))
 		lua_pushinteger(L, cmd->latency);
+	else if (fastcmp(field,"flags"))
+		lua_pushinteger(L, cmd->flags);
 	else
 		return NOFIELD;
 
@@ -854,14 +855,16 @@ static int ticcmd_set(lua_State *L)
 
 	if (fastcmp(field,"forwardmove"))
 		cmd->forwardmove = (SINT8)luaL_checkinteger(L, 3);
-	else if (fastcmp(field,"angleturn"))
-		cmd->angleturn = (INT16)luaL_checkinteger(L, 3);
+	else if (fastcmp(field,"turning"))
+		cmd->turning = (INT16)luaL_checkinteger(L, 3);
 	else if (fastcmp(field,"aiming"))
 		cmd->aiming = (INT16)luaL_checkinteger(L, 3);
 	else if (fastcmp(field,"buttons"))
 		cmd->buttons = (UINT16)luaL_checkinteger(L, 3);
-	else if (fastcmp(field,"driftturn"))
-		cmd->driftturn = (INT16)luaL_checkinteger(L, 3);
+	else if (fastcmp(field,"latency"))
+		return NOSET;
+	else if (fastcmp(field,"flags"))
+		return NOSET;
 	else
 		return NOFIELD;
 
diff --git a/src/m_cheat.c b/src/m_cheat.c
index e86db331d..261f98157 100644
--- a/src/m_cheat.c
+++ b/src/m_cheat.c
@@ -1033,10 +1033,10 @@ void OP_ObjectplaceMovement(player_t *player)
 {
 	ticcmd_t *cmd = &player->cmd;
 
-	player->drawangle = player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
+	player->drawangle = player->mo->angle = player->angleturn;
 
 	ticruned++;
-	if (!(cmd->angleturn & TICCMD_RECEIVED))
+	if (!(cmd->flags & TICCMD_RECEIVED))
 		ticmiss++;
 
 	if (cmd->buttons & BT_ACCELERATE)
diff --git a/src/p_mobj.c b/src/p_mobj.c
index 5b9120e40..0b30b38ff 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -5890,7 +5890,7 @@ static void P_TracerAngleThink(mobj_t *mobj)
 	// mobj->cvmem - Failure timer
 
 	if (mobj->player)
-		looking = ( mobj->player->cmd.angleturn << 16 );/* fixes CS_LMAOGALOG */
+		looking = mobj->player->angleturn;
 	else
 		looking = mobj->angle;
 
@@ -7662,7 +7662,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 				break;
 			}
 
-			if (abs(player->cmd.driftturn) > 100)
+			if (abs(player->cmd.turning) > 100)
 			{
 				INT32 lastsign = 0;
 				if (mobj->lastlook > 0)
@@ -7670,15 +7670,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 				else if (mobj->lastlook < 0)
 					lastsign = -1;
 
-				if ((player->cmd.driftturn > 0 && lastsign < 0)
-					|| (player->cmd.driftturn < 0 && lastsign > 0))
+				if ((player->cmd.turning > 0 && lastsign < 0)
+					|| (player->cmd.turning < 0 && lastsign > 0))
 				{
 					mobj->movecount += (TICRATE/2);
 					mobj->threshold = 16*lastsign;
 					S_StartSound(mobj, sfx_s1ab);
 				}
 
-				mobj->lastlook = player->cmd.driftturn;
+				mobj->lastlook = player->cmd.turning;
 			}
 
 			mobj->movecount++;
@@ -7818,7 +7818,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 				break;
 			}
 
-			if (abs(player->cmd.driftturn) > 100)
+			if (abs(player->cmd.turning) > 100)
 			{
 				INT32 lastsign = 0;
 				if (mobj->lastlook > 0)
@@ -7826,15 +7826,15 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
 				else if (mobj->lastlook < 0)
 					lastsign = -1;
 
-				if ((player->cmd.driftturn > 0 && lastsign < 0)
-					|| (player->cmd.driftturn < 0 && lastsign > 0))
+				if ((player->cmd.turning > 0 && lastsign < 0)
+					|| (player->cmd.turning < 0 && lastsign > 0))
 				{
 					mobj->movecount += (TICRATE/2);
 					mobj->cvmem = 8*lastsign;
 					S_StartSound(mobj, sfx_s3k7a);
 				}
 
-				mobj->lastlook = player->cmd.driftturn;
+				mobj->lastlook = player->cmd.turning;
 			}
 
 			mobj->movecount++;
diff --git a/src/p_polyobj.c b/src/p_polyobj.c
index 3f457499f..c79580259 100644
--- a/src/p_polyobj.c
+++ b/src/p_polyobj.c
@@ -1153,7 +1153,7 @@ static void Polyobj_rotateThings(polyobj_t *po, vector2_t origin, angle_t delta,
 					if (turnthings == 2 || (turnthings == 1 && !mo->player)) {
 						mo->angle += delta;
 						if (mo->player)
-							P_SetPlayerAngle(mo->player, (angle_t)(mo->player->angleturn << 16) + delta);
+							P_SetPlayerAngle(mo->player, mo->player->angleturn + delta);
 					}
 				}
 			}
diff --git a/src/p_saveg.c b/src/p_saveg.c
index 204c8cc3b..974ff4b96 100644
--- a/src/p_saveg.c
+++ b/src/p_saveg.c
@@ -102,8 +102,7 @@ static void P_NetArchivePlayers(void)
 
 		// no longer send ticcmds, player name, skin, or color
 
-		WRITEINT16(save_p, players[i].angleturn);
-		WRITEINT16(save_p, players[i].oldrelangleturn);
+		WRITEANGLE(save_p, players[i].angleturn);
 		WRITEANGLE(save_p, players[i].aiming);
 		WRITEANGLE(save_p, players[i].drawangle);
 		WRITEANGLE(save_p, players[i].viewrollangle);
@@ -251,12 +250,6 @@ static void P_NetArchivePlayers(void)
 		for (j = 0; j < NUMKARTSTUFF; j++)
 			WRITEINT32(save_p, players[i].kartstuff[j]);
 
-		for (j = 0; j < MAXPREDICTTICS; j++)
-		{
-			WRITEINT16(save_p, players[i].lturn_max[j]);
-			WRITEINT16(save_p, players[i].rturn_max[j]);
-		}
-
 		WRITEUINT32(save_p, players[i].distancetofinish);
 		WRITEUINT32(save_p, K_GetWaypointHeapIndex(players[i].nextwaypoint));
 		WRITEUINT32(save_p, players[i].airtime);
@@ -302,8 +295,7 @@ static void P_NetUnArchivePlayers(void)
 		// sending player names, skin and color should not be necessary at all!
 		// (that data is handled in the server config now)
 
-		players[i].angleturn = READINT16(save_p);
-		players[i].oldrelangleturn = READINT16(save_p);
+		players[i].angleturn = READANGLE(save_p);
 		players[i].aiming = READANGLE(save_p);
 		players[i].drawangle = READANGLE(save_p);
 		players[i].viewrollangle = READANGLE(save_p);
@@ -443,12 +435,6 @@ static void P_NetUnArchivePlayers(void)
 		for (j = 0; j < NUMKARTSTUFF; j++)
 			players[i].kartstuff[j] = READINT32(save_p);
 
-		for (j = 0; j < MAXPREDICTTICS; j++)
-		{
-			players[i].lturn_max[j] = READINT16(save_p);
-			players[i].rturn_max[j] = READINT16(save_p);
-		}
-
 		players[i].distancetofinish = READUINT32(save_p);
 		players[i].nextwaypoint = (waypoint_t *)(size_t)READUINT32(save_p);
 		players[i].airtime = READUINT32(save_p);
diff --git a/src/p_spec.c b/src/p_spec.c
index 58921d046..7e08bca7a 100644
--- a/src/p_spec.c
+++ b/src/p_spec.c
@@ -8695,7 +8695,7 @@ void T_Pusher(pusher_t *p)
 
 				if (!demo.playback)
 				{
-					angle_t angle = thing->player->angleturn << 16;
+					angle_t angle = thing->player->angleturn;
 					if (thing->angle - angle > ANGLE_180)
 						P_SetPlayerAngle(thing->player, angle - (angle - thing->angle) / 8);
 					else
diff --git a/src/p_tick.c b/src/p_tick.c
index 3cbd68f4d..6f1a89702 100644
--- a/src/p_tick.c
+++ b/src/p_tick.c
@@ -722,10 +722,6 @@ void P_PreTicker(INT32 frames)
 				// (and disrupt demo recording and other things !!)
 				memcpy(&temptic, &players[i].cmd, sizeof(ticcmd_t));
 				memset(&players[i].cmd, 0, sizeof(ticcmd_t));
-				// correct angle on spawn...
-				players[i].angleturn += temptic.angleturn - players[i].oldrelangleturn;
-				players[i].oldrelangleturn = temptic.angleturn;
-				players[i].cmd.angleturn = players[i].angleturn;
 
 				P_PlayerThink(&players[i]);
 
diff --git a/src/p_user.c b/src/p_user.c
index 1169e6042..6ef7d653a 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -2062,10 +2062,10 @@ static void P_SpectatorMovement(player_t *player)
 {
 	ticcmd_t *cmd = &player->cmd;
 
-	player->mo->angle = (cmd->angleturn<<16 /* not FRACBITS */);
+	player->mo->angle = player->angleturn;
 
 	ticruned++;
-	if (!(cmd->angleturn & TICCMD_RECEIVED))
+	if (!(cmd->flags & TICCMD_RECEIVED))
 		ticmiss++;
 
 	if (cmd->buttons & BT_ACCELERATE)
@@ -2133,52 +2133,13 @@ void P_MovePlayer(player_t *player)
 	// MOVEMENT CODE	//
 	//////////////////////
 
-	{
-		INT16 angle_diff, max_left_turn, max_right_turn;
-		boolean add_delta = true;
+	player->mo->angle = player->angleturn;
 
-		// Kart: store the current turn range for later use
-		player->lturn_max[leveltime%MAXPREDICTTICS] = K_GetKartTurnValue(player, KART_FULLTURN)+1;
-		player->rturn_max[leveltime%MAXPREDICTTICS] = K_GetKartTurnValue(player, -KART_FULLTURN)-1;
+	ticruned++;
+	if (!(cmd->flags & TICCMD_RECEIVED))
+		ticmiss++;
 
-		if (leveltime >= introtime)
-		{
-			// KART: Don't directly apply angleturn! It may have been either A) forged by a malicious client, or B) not be a smooth turn due to a player dropping frames.
-			// Instead, turn the player only up to the amount they're supposed to turn accounting for latency. Allow exactly 1 extra turn unit to try to keep old replays synced.
-			angle_diff = cmd->angleturn - (player->mo->angle>>16);
-			max_left_turn = player->lturn_max[(leveltime + MAXPREDICTTICS - cmd->latency) % MAXPREDICTTICS];
-			max_right_turn = player->rturn_max[(leveltime + MAXPREDICTTICS - cmd->latency) % MAXPREDICTTICS];
-
-			//CONS_Printf("----------------\nangle diff: %d - turning options: %d to %d - ", angle_diff, max_left_turn, max_right_turn);
-
-			if (angle_diff > max_left_turn)
-				angle_diff = max_left_turn;
-			else if (angle_diff < max_right_turn)
-				angle_diff = max_right_turn;
-			else
-			{
-				// Try to keep normal turning as accurate to 1.0.1 as possible to reduce replay desyncs.
-				player->mo->angle = cmd->angleturn<<16;
-				add_delta = false;
-			}
-			//CONS_Printf("applied turn: %d\n", angle_diff);
-
-			if (add_delta) {
-				player->mo->angle += angle_diff<<16;
-				player->mo->angle &= ~0xFFFF; // Try to keep the turning somewhat similar to how it was before?
-				//CONS_Printf("leftover turn (%s): %5d or %4d%%\n",
-				//				player_names[player-players],
-				//				(INT16) (cmd->angleturn - (player->mo->angle>>16)),
-				//				(INT16) (cmd->angleturn - (player->mo->angle>>16)) * 100 / (angle_diff ? angle_diff : 1));
-			}
-		}
-
-		ticruned++;
-		if ((cmd->angleturn & TICCMD_RECEIVED) == 0)
-			ticmiss++;
-
-		P_3dMovement(player);
-	}
+	P_3dMovement(player);
 
 	// Kart frames
 	if (player->kartstuff[k_squishedtimer] > 0)
@@ -2772,8 +2733,7 @@ fixed_t t_cam_rotate[MAXSPLITSCREENPLAYERS] = {-42,-42,-42,-42};
 // we then throw that ticcmd garbage in the camera and make it move
 
 // redefine this
-static fixed_t forwardmove = MAXPLMOVE<<FRACBITS>>16;
-static fixed_t angleturn[3] = {KART_FULLTURN/2, KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
+static fixed_t angleturn[2] = {KART_FULLTURN, KART_FULLTURN/4}; // + slow turn
 
 static ticcmd_t cameracmd;
 
@@ -2788,7 +2748,6 @@ void P_InitCameraCmd(void)
 static ticcmd_t *P_CameraCmd(camera_t *cam)
 {
 	INT32 laim, th, tspeed, forward, axis; //i
-	const INT32 speed = 1;
 	// these ones used for multiple conditions
 	boolean turnleft, turnright, mouseaiming;
 	boolean invertmouse, lookaxis, usejoystick, kbl;
@@ -2809,7 +2768,7 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 
 	G_CopyTiccmd(cmd, I_BaseTiccmd(), 1); // empty, or external driver
 
-	cmd->angleturn = (INT16)(lang >> 16);
+	//cmd->turning = (INT16)(lang >> 16);
 	cmd->aiming = G_ClipAimingPitch(&laim);
 
 	mouseaiming = true;
@@ -2845,21 +2804,23 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 		th = 0;
 
 	if (th < SLOWTURNTICS)
-		tspeed = 2; // slow turn
+		tspeed = 1; // slow turn
 	else
-		tspeed = speed;
+		tspeed = 0;
+
+	cmd->turning = 0;
 
 	// let movement keys cancel each other out
 	if (turnright && !(turnleft))
 	{
-		cmd->angleturn = (INT16)(cmd->angleturn - (angleturn[tspeed]));
+		cmd->turning = (INT16)(cmd->turning - (angleturn[tspeed]));
 	}
 	else if (turnleft && !(turnright))
 	{
-		cmd->angleturn = (INT16)(cmd->angleturn + (angleturn[tspeed]));
+		cmd->turning = (INT16)(cmd->turning + (angleturn[tspeed]));
 	}
 
-	cmd->angleturn = (INT16)(cmd->angleturn - ((mousex*(encoremode ? -1 : 1)*8)));
+	cmd->turning = (INT16)(cmd->turning - ((mousex*(encoremode ? -1 : 1)*8)));
 
 	axis = PlayerJoyAxis(1, AXISMOVE);
 	if (PlayerInputDown(1, gc_accelerate) || (usejoystick && axis > 0))
@@ -2869,9 +2830,9 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 		cmd->buttons |= BT_BRAKE;
 	axis = PlayerJoyAxis(1, AXISAIM);
 	if (PlayerInputDown(1, gc_aimforward) || (usejoystick && axis < 0))
-		forward += forwardmove;
+		forward += MAXPLMOVE;
 	if (PlayerInputDown(1, gc_aimbackward) || (usejoystick && axis > 0))
-		forward -= forwardmove;
+		forward -= MAXPLMOVE;
 
 	// fire with any button/key
 	axis = PlayerJoyAxis(1, AXISFIRE);
@@ -2919,7 +2880,7 @@ static ticcmd_t *P_CameraCmd(camera_t *cam)
 	else if (cmd->forwardmove < -MAXPLMOVE)
 		cmd->forwardmove = -MAXPLMOVE;
 
-	lang += (cmd->angleturn<<16);
+	lang += (cmd->turning << TICCMD_REDUCE);
 
 	democam.localangle = lang;
 	democam.localaiming = laim;
@@ -2945,7 +2906,7 @@ void P_DemoCameraMovement(camera_t *cam)
 	cmd = P_CameraCmd(cam);
 
 	cam->aiming = cmd->aiming<<FRACBITS;
-	cam->angle = cmd->angleturn<<16;
+	//cam->angle = cmd->angleturn << TICCMD_REDUCE;
 
 	// camera movement:
 
@@ -4273,6 +4234,12 @@ void P_PlayerThink(player_t *player)
 
 	cmd = &player->cmd;
 
+	{
+		angle_t angleChange = K_GetKartTurnValue(player, cmd->turning) << TICCMD_REDUCE;
+		player->angleturn += angleChange;
+		P_SetLocalAngle(player, P_GetLocalAngle(player) + angleChange);
+	}
+
 	// SRB2kart
 	// Save the dir the player is holding
 	//  to allow items to be thrown forward or backward.
@@ -4699,27 +4666,17 @@ void P_PlayerAfterThink(player_t *player)
 
 void P_SetPlayerAngle(player_t *player, angle_t angle)
 {
-	INT16 delta = (INT16)(angle >> 16) - player->angleturn;
+	angle_t delta = angle - player->angleturn;
 
-	P_ForceLocalAngle(player, P_GetLocalAngle(player) + (delta << 16));
+	P_ForceLocalAngle(player, P_GetLocalAngle(player) + delta);
 	player->angleturn += delta;
 }
 
 void P_SetLocalAngle(player_t *player, angle_t angle)
 {
-	INT16 delta = (INT16)((angle - P_GetLocalAngle(player)) >> 16);
-	UINT8 i;
+	angle_t delta = (angle - P_GetLocalAngle(player));
 
-	P_ForceLocalAngle(player, P_GetLocalAngle(player) + (angle_t)(delta << 16));
-
-	for (i = 0; i <= splitscreen; i++)
-	{
-		if (player == &players[g_localplayers[i]])
-		{
-			ticcmd_oldangleturn[i] += delta;
-			break;
-		}
-	}
+	P_ForceLocalAngle(player, P_GetLocalAngle(player) + delta);
 }
 
 angle_t P_GetLocalAngle(player_t *player)