Get rings from any itembox, expose more functions to lua and battle related things

src/d_player.h

@@ -603,6 +603,7 @@ struct player_t
 	UINT8 tripwireReboundDelay; // When failing Tripwire, brieftly lock out speed-based tripwire pass (anti-cheese)
 
 	UINT16 itemroulette;	// Used for the roulette when deciding what item to give you (was "pw_kartitem")
+	UINT16 previtemroulette;	// Used determining when to give rings after hitting item boxes
 	UINT16 itemblink;				// Item flashing after roulette, serves as a mashing indicator. Also prevents item from being stolen.
 	UINT16 itemblinkmode;			// Type of flashing: 0 = white (normal), 1 = red (mashing), 2 = rainbow (enhanced items)
 	UINT8 roulettetype;		// Used for the roulette, for deciding type (0 = normal, 1 = better, 2 = eggman mark)

src/deh_tables.c

@@ -28,6 +28,7 @@
 #include "k_boss.h" // spottype_t (for lua)
 #include "k_follower.h" // followermode_t (for lua)
 #include "g_input.h" // Game controls (for lua)
+#include "k_kart.h" // awardscaledrings_t
 
 #include "deh_tables.h"
 
@@ -1485,6 +1486,21 @@ struct int_const_s const INT_CONST[] = {
 	{"FEATURE_INTERMISSIONHUD",1}, // This is to trick kart luas that look for this since its already here.
 	{"FEATURE_VOTEHUD",1},
 
+	// tripwirestate_t
+	{"TRIPSTATE_NONE", TRIPSTATE_NONE},
+	{"TRIPSTATE_PASSED", TRIPSTATE_PASSED},
+	{"TRIPSTATE_BLOCKED", TRIPSTATE_BLOCKED},
+
+	// tripwirepass_t
+	{"TRIPWIRE_NONE", TRIPWIRE_NONE},
+	{"TRIPWIRE_IGNORE", TRIPWIRE_IGNORE},
+	{"TRIPWIRE_BOOST", TRIPWIRE_BOOST},
+	{"TRIPWIRE_BLASTER", TRIPWIRE_BLASTER},
+
+	// awardscaledrings_t
+	{"ASR_ITEMBOX", ASR_ITEMBOX},
+	{"ASR_SUPERRING", ASR_SUPERRING},
+
 	{NULL,0}
 };
 

src/k_hud.c

@@ -2478,6 +2478,10 @@ static void K_drawKartWanted(void)
 			basey += 16; // slight adjust for 3P
 			basex -= 6;
 		}
+		else if (!r_splitscreen)
+		{
+			basex -= 48;
+		}
 	}
 	else if (r_splitscreen == 3) // 4P splitscreen...
 	{
@@ -4620,7 +4624,7 @@ void K_drawKartHUD(void)
 				K_drawRingMeter();
 			}
 
-			if ((cv_showinput.value > 0) || (modeattacking && !bossinfo.boss))
+			if (cv_showinput.value > 0)
 			{
 				// Draw the input UI
 				if (LUA_HudEnabled(hud_position))

src/k_kart.c

@@ -1599,7 +1599,9 @@ static void K_KartItemRoulette(player_t *player, ticcmd_t *cmd)
 
 	// SPECIAL CASE No. 4:
 	// Record Attack / alone mashing behavior
-	if ((modeattacking || pingame == 1) && ((gametyperules & GTR_RACEODDS) || (gametyperules & GTR_BATTLEODDS)))
+	if ((modeattacking || pingame == 1)
+		&& ((gametyperules & GTR_RACEODDS)
+		|| ((gametyperules & GTR_BATTLEODDS) && (itembreaker || bossinfo.boss))))
 	{
 		if ((gametyperules & GTR_RACEODDS))
 		{
@@ -7233,6 +7235,37 @@ static void K_HandleRingDeincrement(player_t *player, boolean chainnerf)
 	player->ringboost = max(0, player->ringboost - finalringtimer);
 }
 
+// Handles the gaining of rings in a scaled way based on player position
+void K_AwardScaledPlayerRings(player_t *player, SINT8 mode)
+{
+	if (!player)
+	{
+		// There is no player here, don't award rings.
+		return;
+	}
+
+	if ((mode == ASR_ITEMBOX) && (K_RingsActive() == false))
+	{
+		// Rings aren't enabled
+		// (and this isn't a super ring)
+		// don't award rings.
+		return;
+	}
+
+	// Let Ring-less maps in on the rings fun as well!
+	SINT8 awardamount = (mode == ASR_SUPERRING) ? 15 : 10;
+	if (player->position == ASR_SUPERRING)
+	{
+		awardamount = (mode == ASR_SUPERRING) ? 5 : 3;
+	}
+	else if(!K_IsPlayerLosing(player))
+	{
+		awardamount = (mode == ASR_SUPERRING) ? 10 : 5;
+	}
+
+	K_AwardPlayerRings(player, awardamount, (mode == ASR_SUPERRING) ? true : false);
+}
+
 /**	\brief	Decreases various kart timers and powers per frame. Called in P_PlayerThink in p_user.c
 
 	\param	player	player object passed from P_PlayerThink
@@ -7635,6 +7668,15 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
 	// Roulette Code
 	K_KartItemRoulette(player, cmd);
 
+	// Gain rings when roulette starts.
+	if (player->itemroulette > 0 && player->previtemroulette == 0)
+	{
+		K_AwardScaledPlayerRings(player, ASR_ITEMBOX);
+	}
+
+	// set prev state for roulette gain effects
+	player->previtemroulette = player->itemroulette;
+
 	// Handle invincibility sfx
 	K_UpdateInvincibilitySounds(player); // Also thanks, VAda!
 
@@ -10366,19 +10408,8 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
 						case KITEM_SUPERRING:
 							if (ATTACK_IS_DOWN && !HOLDING_ITEM && NO_HYUDORO)
 							{
-								SINT8 awardamount = 15;
-
 								player->itemamount--;
-								if (player->position == 1)
-								{
-									awardamount = 5;
-								}
-								else if(!K_IsPlayerLosing(player))
-								{
-									awardamount = 10;
-								}
-
-								K_AwardPlayerRings(player, awardamount, true);
+								K_AwardScaledPlayerRings(player, ASR_SUPERRING);
 								player->botvars.itemconfirm = 0;
 							}
 							break;

src/k_kart.h

@@ -249,6 +249,14 @@ void K_UpdateMobjItemOverlay(mobj_t *part, SINT8 itemType, UINT8 itemCount);
 void K_DoBoost(player_t *player, fixed_t speedboost, fixed_t accelboost, boolean stack, boolean visible);
 void K_ClearBoost(player_t *player);
 
+typedef enum
+{
+	ASR_ITEMBOX = 0,
+	ASR_SUPERRING = 1,
+} awardscaledrings_t;
+
+void K_AwardScaledPlayerRings(player_t *player, SINT8 mode);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

src/lua_baselib.c

@@ -4094,6 +4094,107 @@ static int lib_kChainOrDeincrementTime(lua_State *L)
 	return 1;
 }
 
+static int lib_kGetNewSpeed(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	lua_pushinteger(L, K_GetNewSpeed(player));
+	return 1;
+}
+
+static int lib_k3dKartMovement(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	boolean onground = lua_optboolean(L, 2);
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	lua_pushinteger(L, K_3dKartMovement(player, onground));
+	return 1;
+}
+
+static int lib_kMomentumAngle(lua_State *L)
+{
+	mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
+
+	//HUDSAFE
+	if (!mo)
+		return LUA_ErrInvalid(L, "mobj_t");
+	lua_pushinteger(L, K_MomentumAngle(mo));
+	return 1;
+}
+
+static int lib_kGetKartSpeedFromStat(lua_State *L)
+{
+	UINT16 kartspeed = luaL_checkinteger(L, 1);
+
+	//HUDSAFE
+	lua_pushinteger(L, K_GetKartSpeedFromStat(kartspeed));
+	return 1;
+}
+
+static int lib_kKartKickstart(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	lua_pushboolean(L, K_KartKickstart(player));
+	return 1;
+}
+
+static int lib_kGetKartButtons(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	lua_pushinteger(L, K_GetKartButtons(player));
+	return 1;
+}
+
+static int lib_kGetForwardMove(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	lua_pushinteger(L, K_GetForwardMove(player));
+	return 1;
+}
+
+static int lib_kAwardPlayerRings(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	UINT16 rings = luaL_checkinteger(L, 2);
+	boolean overload = lua_optboolean(L, 3);
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	K_AwardPlayerRings(player, rings, overload);
+	return 0;
+}
+
+static int lib_kAwardScaledPlayerRings(lua_State *L)
+{
+	player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
+	SINT8 mode = luaL_checkinteger(L, 2);
+
+	//HUDSAFE
+	if (!player)
+		return LUA_ErrInvalid(L, "player_t");
+	K_AwardScaledPlayerRings(player, mode);
+	return 0;
+}
+
 static int lib_getTimeMicros(lua_State *L)
 {
 	lua_pushinteger(L, I_GetPreciseTime() / (I_GetPrecisePrecision() / 1000000));
@@ -4404,7 +4505,15 @@ static luaL_Reg lib[] = {
 	{"K_ClearBoost",lib_kClearBoost},
 	{"K_BoostChain",lib_kBoostChain},
 	{"K_ChainOrDeincrementTime",lib_kChainOrDeincrementTime},
-
+	{"K_GetNewSpeed", lib_kGetNewSpeed},
+	{"K_3dKartMovement", lib_k3dKartMovement},
+	{"K_MomentumAngle", lib_kMomentumAngle},
+	{"K_GetKartSpeedFromStat", lib_kGetKartSpeedFromStat},
+	{"K_KartKickstart", lib_kKartKickstart},
+	{"K_GetKartButtons", lib_kGetKartButtons},
+	{"K_GetForwardMove", lib_kGetForwardMove},
+	{"K_AwardPlayerRings", lib_kAwardPlayerRings},
+	{"K_AwardScaledPlayerRings", lib_kAwardScaledPlayerRings},
 
 	// k_boss
 	{"K_InitBossHealthBar", lib_kInitBossHealthBar},

src/p_enemy.c

@@ -10698,22 +10698,6 @@ void A_ItemPop(mobj_t *actor)
 
 	}
 
-	// Let Ring-less maps in on the rings fun as well!
-	if ((K_RingsActive() == true) )
-	{
-		SINT8 awardamount = 10;
-		if (actor->target->player->position == 1)
-		{
-			awardamount = 3;
-		}
-		else if(!K_IsPlayerLosing(actor->target->player))
-		{
-			awardamount = 5;
-		}
-
-		K_AwardPlayerRings(actor->target->player, awardamount, false);
-	}
-
 	remains->flags2 &= ~MF2_AMBUSH;
 
 	// Here at mapload in battle?

src/p_saveg.c

@@ -289,6 +289,7 @@ static void P_NetArchivePlayers(savebuffer_t *save)
 		WRITEUINT8(save->p, players[i].tripwireReboundDelay);
 
 		WRITEUINT16(save->p, players[i].itemroulette);
+		WRITEUINT16(save->p, players[i].previtemroulette);
 		WRITEUINT16(save->p, players[i].itemblink);
 		WRITEUINT16(save->p, players[i].itemblinkmode);
 		WRITEUINT8(save->p, players[i].roulettetype);
@@ -605,6 +606,7 @@ static void P_NetUnArchivePlayers(savebuffer_t *save)
 		players[i].tripwireReboundDelay = READUINT8(save->p);
 
 		players[i].itemroulette = READUINT16(save->p);
+		players[i].previtemroulette = READUINT16(save->p);
 		players[i].itemblink = READUINT16(save->p);
 		players[i].itemblinkmode = READUINT16(save->p);
 		players[i].roulettetype = READUINT8(save->p);