From 105eb85bd32f7e99f0487a8ec824f972fe7243fa Mon Sep 17 00:00:00 2001 From: NepDisk Date: Mon, 21 Apr 2025 19:24:32 -0400 Subject: [PATCH] Get rings from any itembox, expose more functions to lua and battle related things --- src/d_player.h | 1 + src/deh_tables.c | 16 +++++++ src/k_hud.c | 6 ++- src/k_kart.c | 57 ++++++++++++++++++------ src/k_kart.h | 8 ++++ src/lua_baselib.c | 111 +++++++++++++++++++++++++++++++++++++++++++++- src/p_enemy.c | 16 ------- src/p_saveg.c | 2 + 8 files changed, 186 insertions(+), 31 deletions(-) diff --git a/src/d_player.h b/src/d_player.h index 6b7d4bad1..1a56efb59 100644 --- a/src/d_player.h +++ b/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) diff --git a/src/deh_tables.c b/src/deh_tables.c index f77b8a0d9..8e94269d4 100644 --- a/src/deh_tables.c +++ b/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} }; diff --git a/src/k_hud.c b/src/k_hud.c index a4475ed13..a564f8a8b 100644 --- a/src/k_hud.c +++ b/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)) diff --git a/src/k_kart.c b/src/k_kart.c index ec5a15cca..69dbffa01 100644 --- a/src/k_kart.c +++ b/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; diff --git a/src/k_kart.h b/src/k_kart.h index c416de4c4..f4f3d3f2e 100644 --- a/src/k_kart.h +++ b/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 diff --git a/src/lua_baselib.c b/src/lua_baselib.c index 971c6c023..3380da3ef 100644 --- a/src/lua_baselib.c +++ b/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}, diff --git a/src/p_enemy.c b/src/p_enemy.c index ffc0819f8..3c9d2e223 100644 --- a/src/p_enemy.c +++ b/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? diff --git a/src/p_saveg.c b/src/p_saveg.c index 6eba37486..caee0bacd 100644 --- a/src/p_saveg.c +++ b/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);