diff --git a/src/d_player.h b/src/d_player.h
index 2c75fd1df32ddedf4c95cadd7a707b5c6c9cacbf..d9c716bc7af1c87a59c254adf8cbd658c5f528e4 100644
--- a/src/d_player.h
+++ b/src/d_player.h
@@ -253,6 +253,7 @@ typedef enum
 	k_spinouttype,		// Determines whether to thrust forward or not while spinning out; 0 = move forwards, 1 = stay still
 
 	k_drift,			// Drifting Left or Right, plus a bigger counter = sharper turn
+	k_driftangle,		// Stores player turn angle for drifting
 	k_driftcharge,		// Charge your drift so you can release a burst of speed
 	k_driftboost,		// Boost you get from drifting
 	k_boostcharge,		// Charge-up for boosting at the start of the race, or when Lakitu drops you
diff --git a/src/doomdef.h b/src/doomdef.h
index b6fc6abf7f0ed97a73314b6aaa7c3cc269463c3d..317b63e3f6c38ae599185c8d278a813623bed04d 100644
--- a/src/doomdef.h
+++ b/src/doomdef.h
@@ -140,19 +140,19 @@
 extern FILE *logstream;
 #endif
 
-#define DEVELOP // Disable this for release builds to remove excessive cheat commands and enable MD5 checking and stuff, all in one go. :3
+//#define DEVELOP // Disable this for release builds to remove excessive cheat commands and enable MD5 checking and stuff, all in one go. :3
 #ifdef DEVELOP
 #define VERSION    101 // Game version
-#define SUBVERSION 2 // more precise version number
+#define SUBVERSION 3 // more precise version number
 #define VERSIONSTRING "Development EXE"
-#define VERSIONSTRINGW "v1.1.02"
+#define VERSIONSTRINGW "v1.1.03"
 // most interface strings are ignored in development mode.
 // we use comprevision and compbranch instead.
 #else
 #define VERSION    101 // Game version
-#define SUBVERSION 2  // more precise version number
-#define VERSIONSTRING "DevEXE v1.1.02"
-#define VERSIONSTRINGW L"v1.1.02"
+#define SUBVERSION 3  // more precise version number
+#define VERSIONSTRING "DevEXE v1.1.03"
+#define VERSIONSTRINGW L"v1.1.03"
 // Hey! If you change this, add 1 to the MODVERSION below!
 // Otherwise we can't force updates!
 #endif
diff --git a/src/g_game.c b/src/g_game.c
index 5dc2381efc4916292a2b81d14c1e8fd47162e0ad..843de1b707851daca3c64cab48500d9d52a6ec8c 100644
--- a/src/g_game.c
+++ b/src/g_game.c
@@ -941,7 +941,7 @@ angle_t localangle, localangle2;
 
 static fixed_t forwardmove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16};
 static fixed_t sidemove[2] = {25<<FRACBITS>>16, 50<<FRACBITS>>16}; // faster!
-static fixed_t angleturn[3] = {400/NEWTICRATERATIO, 800/NEWTICRATERATIO, 200/NEWTICRATERATIO}; // + slow turn
+static fixed_t angleturn[3] = {400, 800, 200}; // + slow turn
 
 void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics)
 {
@@ -1267,7 +1267,7 @@ void G_BuildTiccmd(ticcmd_t *cmd, INT32 realtics)
 	}
 	else
 	{
-		cmd->angleturn = K_GetKartTurnValue(cmd, player);
+		cmd->angleturn = K_GetKartTurnValue(player, cmd);
 
 		//cmd->angleturn = FixedMul(cmd->angleturn, FixedDiv(80 - (players[consoleplayer].speed >> 16), 80));
 
diff --git a/src/k_kart.c b/src/k_kart.c
index 69d569bf7a4a3665431596c709d4cc3a7e8a09ce..2e321e5dd4e1fd62c9cf556966321ea484a00e07 100644
--- a/src/k_kart.c
+++ b/src/k_kart.c
@@ -947,9 +947,9 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
 {
 	K_UpdateOffroad(player);
 
-	// This spawns the drift sparks when k_driftcharge hits 30. Its own AI handles life/death and color
+	// This spawns the drift sparks when k_driftcharge hits 26 + player->kartspeed. Its own AI handles life/death and color
 	if ((player->kartstuff[k_drift] >= 1 || player->kartstuff[k_drift] <= -1)
-		&& player->kartstuff[k_driftcharge] == 30)
+		&& player->kartstuff[k_driftcharge] == (26 + player->kartspeed))
 		P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_DRIFT)->target = player->mo;
 
 	if (player->kartstuff[k_itemclose])
@@ -1124,14 +1124,15 @@ fixed_t K_GetKartBoostPower(player_t *player, boolean speedonly)
 		boostvalue += 11; // 11/8 speed (*1.375)
 		numboosts++;
 	}
-	if (player->kartstuff[k_driftboost])
+	if ((player->kartstuff[k_driftboost] && speedonly)
+		|| (player->kartstuff[k_driftboost] && !player->kartstuff[k_mushroomtimer]))
 	{												// Drift Boost
 		boostvalue += 12; // 12/8 speed (*1.500)
 		numboosts++;
 	}
 	if (player->kartstuff[k_mushroomtimer] && speedonly)
 	{												// Mushroom
-		boostvalue += 14; // 14/8 speed (*1.750)
+		boostvalue += 12; // 12/8 speed (*1.500)
 		numboosts++;
 	}
 	if (numboosts) // If any of the above apply...
@@ -1142,27 +1143,30 @@ fixed_t K_GetKartBoostPower(player_t *player, boolean speedonly)
 
 	return boostpower;
 }
-fixed_t K_GetKartSpeed(player_t *player)
+fixed_t K_GetKartSpeed(player_t *player, boolean doboostpower)
 {
 	fixed_t k_speed = 151;
-	fixed_t g_cc;
+	fixed_t g_cc = FRACUNIT;
+	fixed_t xspd = 3072;		// 4.6875 aka 3/64
 
 	switch (cv_kartcc.value)
 	{
 		case 50:
-			g_cc = 27*FRACUNIT/32; //  50cc - 0.84375
+			g_cc = 53248 + xspd; //  50cc =  81.25 + 4.69 =  85.94%
 			break;
 		case 150:
-			g_cc = 39*FRACUNIT/32; // 150cc - 1.21875
+			g_cc = 77824 + xspd; // 150cc = 118.75 + 4.69 = 123.44%
 			break;
 		default:
-			g_cc = 33*FRACUNIT/32; // 100cc - 1.03125
+			g_cc = 65536 + xspd; // 100cc = 100.00 + 4.69 = 104.69%
 			break;
 	}
 
 	k_speed += player->kartspeed; // 152 - 160
 
-	return FixedMul(FixedMul(k_speed<<14, g_cc), K_GetKartBoostPower(player, true));
+	if (doboostpower)
+		return FixedMul(FixedMul(k_speed<<14, g_cc), K_GetKartBoostPower(player, true));
+	return FixedMul(k_speed<<14, g_cc);
 }
 fixed_t K_GetKartAccel(player_t *player)
 {
@@ -1178,7 +1182,7 @@ fixed_t K_3dKartMovement(player_t *player, boolean onground, boolean forwardmove
 
 	fixed_t accelmax = 4000;
 	fixed_t newspeed, oldspeed, finalspeed;
-	fixed_t p_speed = K_GetKartSpeed(player);
+	fixed_t p_speed = K_GetKartSpeed(player, true);
 	fixed_t p_accel = K_GetKartAccel(player);
 
 	// ACCELCODE!!!1!11!
@@ -1213,8 +1217,8 @@ void K_SpinPlayer(player_t *player, mobj_t *source)
 		else
 			player->kartstuff[k_spinouttimer] = 3*TICRATE/2;
 
-		if (player->speed < K_GetKartSpeed(player)/4) // player->normalspeed/4)
-			P_InstaThrust(player->mo, player->mo->angle, FixedMul(K_GetKartSpeed(player)/4, player->mo->scale)); // FixedMul(player->normalspeed/4, player->mo->scale));
+		if (player->speed < K_GetKartSpeed(player, true)/4) // player->normalspeed/4)
+			P_InstaThrust(player->mo, player->mo->angle, FixedMul(K_GetKartSpeed(player, true)/4, player->mo->scale)); // FixedMul(player->normalspeed/4, player->mo->scale));
 
 		S_StartSound(player->mo, sfx_slip);
 	}
@@ -1777,32 +1781,43 @@ void K_DoLightning(player_t *player, boolean bluelightning)
 	player->kartstuff[k_sounds] = 50;
 }
 
-fixed_t K_GetKartTurnValue(ticcmd_t *cmd, player_t *player)
+fixed_t K_GetKartTurnValue(player_t *player, ticcmd_t *cmd)
 {
 	fixed_t p_angle = cmd->angleturn;
+	fixed_t p_maxspeed = K_GetKartSpeed(player, false);
+	
+	p_maxspeed = FixedMul(p_maxspeed, 2*FRACUNIT + FRACUNIT/4);
 
-	p_angle = FixedMul(p_angle, FixedDiv(80 - (player->speed >> 16), 80));
+	p_angle = FixedMul(p_angle, FixedDiv((p_maxspeed>>16) - (player->speed>>16), 
+		(p_maxspeed>>16) + player->kartweight)); // Weight has a small effect on turning
 
 	if (player->kartstuff[k_startimer] || player->kartstuff[k_mushroomtimer] || player->kartstuff[k_growshrinktimer] > 0)
 		p_angle = FixedMul(p_angle, FixedDiv(5*FRACUNIT, 4*FRACUNIT));
 
+	player->kartstuff[k_driftangle] = p_angle;
+
 	return p_angle;
 }
 
-fixed_t K_GetKartDriftValue(fixed_t turntype)
+fixed_t K_GetKartDriftValue(player_t *player, fixed_t turntype)
 {
 	fixed_t driftangle = FRACUNIT;
+	fixed_t p_angle = player->kartstuff[k_driftangle];
+	fixed_t driftweight = player->kartweight*10;
+
+	if (player->kartstuff[k_drift] <= -1)
+		p_angle *= -1;
 
 	switch (turntype)
 	{
 		case 1:
-			driftangle = 600*FRACUNIT;	// Drifting outward
+			driftangle = (p_angle + 300 - driftweight*1)*FRACUNIT;	// Drifting outward
 			break;
 		case 2:
-			driftangle = 225*FRACUNIT;	// Drifting inward
+			driftangle = (p_angle + 700 - driftweight*3)*FRACUNIT;	// Drifting inward
 			break;
 		case 3:
-			driftangle = 450*FRACUNIT;	// Drifting with no input
+			driftangle = (      0 + 500 - driftweight*2)*FRACUNIT;	// Drifting with no input
 			break;
 	}
 
@@ -1811,6 +1826,9 @@ fixed_t K_GetKartDriftValue(fixed_t turntype)
 
 void K_KartDrift(player_t *player, ticcmd_t *cmd, boolean onground)
 {
+	fixed_t dsone = 26 + player->kartspeed;
+	fixed_t dstwo = 52 + player->kartspeed*2;
+	
 	// Drifting is actually straffing + automatic turning.
 	// Holding the Jump button will enable drifting.
 	if (cmd->buttons & BT_DRIFTRIGHT)
@@ -1823,7 +1841,7 @@ void K_KartDrift(player_t *player, ticcmd_t *cmd, boolean onground)
 	// Drift Release (Moved here so you can't "chain" drifts)
 	if ((player->kartstuff[k_drift] == 0)
 		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& player->kartstuff[k_driftcharge] < 30
+		&& player->kartstuff[k_driftcharge] < dsone
 		&& onground)
 	{
 		player->kartstuff[k_drift] = 0;
@@ -1831,7 +1849,7 @@ void K_KartDrift(player_t *player, ticcmd_t *cmd, boolean onground)
 	}
 	else if ((player->kartstuff[k_drift] == 0)
 		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& (player->kartstuff[k_driftcharge] >= 30 && player->kartstuff[k_driftcharge] < 60)
+		&& (player->kartstuff[k_driftcharge] >= dsone && player->kartstuff[k_driftcharge] < dstwo)
 		&& onground)
 	{
 		player->kartstuff[k_driftboost] = 20;
@@ -1841,7 +1859,7 @@ void K_KartDrift(player_t *player, ticcmd_t *cmd, boolean onground)
 	}
 	else if ((player->kartstuff[k_drift] == 0)
 		// || (player->kartstuff[k_drift] >= 1 && player->kartstuff[k_turndir] != 1) || (player->kartstuff[k_drift] <= -1 && player->kartstuff[k_turndir] != -1))
-		&& player->kartstuff[k_driftcharge] >= 60
+		&& player->kartstuff[k_driftcharge] >= dstwo
 		&& onground)
 	{
 		player->kartstuff[k_driftboost] = 40;
@@ -1877,17 +1895,22 @@ void K_KartDrift(player_t *player, ticcmd_t *cmd, boolean onground)
 			if (player == &players[consoleplayer])
 			{
 				if (player->kartstuff[k_turndir] == -1)     // Turning Left  while Drifting Right
-					localangle -= K_GetKartDriftValue(1);
+					localangle -= K_GetKartDriftValue(player, 1);
 				else if (player->kartstuff[k_turndir] == 1) // Turning Right while Drifting Right
-					localangle -= K_GetKartDriftValue(2);
+					localangle -= K_GetKartDriftValue(player, 2);
 				else                                        // No Direction  while Drifting Right
-					localangle -= K_GetKartDriftValue(3);
+					localangle -= K_GetKartDriftValue(player, 3);
 			}
 
 			// Player 2
 			if (splitscreen	&& player == &players[secondarydisplayplayer])
 			{
-
+				if (player->kartstuff[k_turndir] == -1)     // Turning Left  while Drifting Right
+					localangle2 -= K_GetKartDriftValue(player, 1);
+				else if (player->kartstuff[k_turndir] == 1) // Turning Right while Drifting Right
+					localangle2 -= K_GetKartDriftValue(player, 2);
+				else                                        // No Direction  while Drifting Right
+					localangle2 -= K_GetKartDriftValue(player, 3);
 			}
 		}
 		else if (player->kartstuff[k_drift] <= -1) // Drifting to the Left
@@ -1901,18 +1924,24 @@ void K_KartDrift(player_t *player, ticcmd_t *cmd, boolean onground)
 			if (player == &players[consoleplayer])
 			{
 				if (player->kartstuff[k_turndir] == 1)       // Turning Right while Drifting Left
-					localangle += K_GetKartDriftValue(1);
+					localangle += K_GetKartDriftValue(player, 1);
 				else if (player->kartstuff[k_turndir] == -1) // Turning Left  while Drifting Left
-					localangle += K_GetKartDriftValue(2);
+					localangle += K_GetKartDriftValue(player, 2);
 				else                                         // No Direction  while Drifting Left
-					localangle += K_GetKartDriftValue(3);
+					localangle += K_GetKartDriftValue(player, 3);
 			}
 
 			// Player 2
-			if (splitscreen	&& player == &players[secondarydisplayplayer] && player->kartstuff[k_turndir] == 1)
-				localangle2 += (300+192)*FRACUNIT;
-			else if (splitscreen && player == &players[secondarydisplayplayer])
-				localangle2 += (300)*FRACUNIT;
+			// Player 2
+			if (splitscreen	&& player == &players[secondarydisplayplayer])
+			{
+				if (player->kartstuff[k_turndir] == 1)       // Turning Right while Drifting Left
+					localangle2 += K_GetKartDriftValue(player, 1);
+				else if (player->kartstuff[k_turndir] == -1) // Turning Left  while Drifting Left
+					localangle2 += K_GetKartDriftValue(player, 2);
+				else                                         // No Direction  while Drifting Left
+					localangle2 += K_GetKartDriftValue(player, 3);
+			}
 		}
 	}
 
diff --git a/src/k_kart.h b/src/k_kart.h
index 71a7e0f67eec1ff6932af1ae3ed96faa916c8a73..553d0366299533c619bc5baa18ddf9b5c48f4b31 100644
--- a/src/k_kart.h
+++ b/src/k_kart.h
@@ -22,8 +22,8 @@ void K_ExplodePlayer(player_t *player, mobj_t *source);
 void K_SpawnKartExplosion(fixed_t x, fixed_t y, fixed_t z, fixed_t radius, INT32 number, mobjtype_t type, angle_t rotangle, boolean spawncenter, boolean ghostit);
 void K_SpawnDriftTrail(player_t *player);
 void K_DoMushroom(player_t *player, boolean doPFlag);
-fixed_t K_GetKartTurnValue(ticcmd_t *cmd, player_t *player);
-fixed_t K_GetKartSpeed(player_t *player);
+fixed_t K_GetKartTurnValue(player_t *player, ticcmd_t *cmd);
+fixed_t K_GetKartSpeed(player_t *player, boolean doboostpower);
 fixed_t K_3dKartMovement(player_t *player, boolean onground, boolean forwardmovement);
 void K_MoveKartPlayer(player_t *player, ticcmd_t *cmd, boolean onground);
 
diff --git a/src/p_mobj.c b/src/p_mobj.c
index b7f2b22954343aa26e9d9fb41efdb80a22abe9cf..e83b3256cb8884f741235d9e353033c297f34b73 100644
--- a/src/p_mobj.c
+++ b/src/p_mobj.c
@@ -6360,7 +6360,7 @@ void P_MobjThinker(mobj_t *mobj)
 			//{ SRB2kart mobs
 			case MT_DRIFT:
 				if ((mobj->target && mobj->target->player && mobj->target->player->mo && mobj->target->player->health > 0 && !mobj->target->player->spectator)
-					&& (mobj->type == MT_DRIFT && mobj->target->player->kartstuff[k_driftcharge] >= 30))
+					&& (mobj->type == MT_DRIFT && mobj->target->player->kartstuff[k_driftcharge] >= (26 + mobj->target->player->kartspeed)))
 				{
 					INT32 HEIGHT;
 					fixed_t radius;
@@ -6389,7 +6389,7 @@ void P_MobjThinker(mobj_t *mobj)
 
 					// Switch blue flames to red flames
 					if (mobj->target->player && mobj->type == MT_DRIFT
-					&& mobj->target->player->kartstuff[k_driftcharge] > 60
+					&& mobj->target->player->kartstuff[k_driftcharge] > 52 + (mobj->target->player->kartspeed*2)
 					&& !(mobj->state >= &states[S_DRIFTSPARK4] && mobj->state <= &states[S_DRIFTSPARK6]))
 						P_SetMobjStateNF(mobj, S_DRIFTSPARK4);
 
diff --git a/src/p_user.c b/src/p_user.c
index 56367cfb647f03404ee611d9171856a48445290d..10bcfe464f7728a157e3171b7837242d8e2810c9 100644
--- a/src/p_user.c
+++ b/src/p_user.c
@@ -4539,6 +4539,7 @@ static void P_3dMovement(player_t *player)
 	fixed_t movepushforward = 0, movepushside = 0;
 	INT32 mforward = 0, mbackward = 0;
 	angle_t dangle; // replaces old quadrants bits
+	boolean dangleflip = false; // SRB2kart - toaster
 	fixed_t normalspd = FixedMul(player->normalspeed, player->mo->scale);
 	boolean analogmove = false;
 	fixed_t oldMagnitude, newMagnitude;
@@ -4619,7 +4620,10 @@ static void P_3dMovement(player_t *player)
 	// Get delta angle from rmom angle and player angle first
 	dangle = R_PointToAngle2(0,0, player->rmomx, player->rmomy) - player->mo->angle;
 	if (dangle > ANGLE_180) //flip to keep to one side
+	{
 		dangle = InvAngle(dangle);
+		dangleflip = true;
+	}
 
 	// now use it to determine direction!
 	if (dangle <= ANGLE_45) // angles 0-45 or 315-360
@@ -4629,6 +4633,24 @@ static void P_3dMovement(player_t *player)
 
 	// anything else will leave both at 0, so no need to do anything else
 
+	//{ SRB2kart 220217 - Toaster Code for misplaced thrust
+	/*
+	if (!player->kartstuff[k_drift]) // Not Drifting
+	{
+		angle_t difference = dangle/2;
+		boolean reverse = (dangle >= ANGLE_90);
+ 
+		if (dangleflip)
+			difference = InvAngle(difference);
+ 
+		if (reverse)
+			difference += ANGLE_180;
+ 
+		P_InstaThrust(player->mo, player->mo->angle + difference, player->speed);
+	}
+	*/
+	//}
+
 	// When sliding, don't allow forward/back
 	if (player->pflags & PF_SLIDING)
 		cmd->forwardmove = 0;
@@ -4831,7 +4853,7 @@ static void P_3dMovement(player_t *player)
 			movepushside >>= 2;
 
 			// Reduce movepushslide even more if over "max" flight speed
-			if (player->powers[pw_tailsfly] && player->speed > K_GetKartSpeed(player)) //topspeed)
+			if (player->powers[pw_tailsfly] && player->speed > K_GetKartSpeed(player, true)) //topspeed)
 				movepushside >>= 2;
 		}
 
@@ -4888,10 +4910,10 @@ static void P_3dMovement(player_t *player)
 	// If "no" to 1, we're not reaching any limits yet, so ignore this entirely!
 	// -Shadow Hog
 	newMagnitude = R_PointToDist2(player->mo->momx - player->cmomx, player->mo->momy - player->cmomy, 0, 0);
-	if (newMagnitude > K_GetKartSpeed(player)) //topspeed)
+	if (newMagnitude > K_GetKartSpeed(player, true)) //topspeed)
 	{
 		fixed_t tempmomx, tempmomy;
-		if (oldMagnitude > K_GetKartSpeed(player)) //topspeed)
+		if (oldMagnitude > K_GetKartSpeed(player, true)) //topspeed)
 		{
 			if (newMagnitude > oldMagnitude)
 			{
@@ -4904,8 +4926,8 @@ static void P_3dMovement(player_t *player)
 		}
 		else
 		{
-			tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), K_GetKartSpeed(player)); //topspeed)
-			tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), K_GetKartSpeed(player)); //topspeed)
+			tempmomx = FixedMul(FixedDiv(player->mo->momx - player->cmomx, newMagnitude), K_GetKartSpeed(player, true)); //topspeed)
+			tempmomy = FixedMul(FixedDiv(player->mo->momy - player->cmomy, newMagnitude), K_GetKartSpeed(player, true)); //topspeed)
 			player->mo->momx = tempmomx + player->cmomx;
 			player->mo->momy = tempmomy + player->cmomy;
 		}