From 31a97adbf29eaa50b055184de59246828b835b88 Mon Sep 17 00:00:00 2001 From: JugadorXEI Date: Sun, 13 Oct 2024 17:14:59 +0200 Subject: [PATCH] Implement itemlist_t in itemroulette_t for better Lua integration itemList -> itemList.items itemListLen -> itemList.len itemListCap -> itemList.cap --- src/d_player.h | 22 +++++++++++--------- src/k_botitem.cpp | 8 ++++---- src/k_hud.cpp | 14 ++++++------- src/k_roulette.c | 52 +++++++++++++++++++++++------------------------ src/p_saveg.cpp | 48 +++++++++++++++++++++---------------------- 5 files changed, 73 insertions(+), 71 deletions(-) diff --git a/src/d_player.h b/src/d_player.h index d440ecbfe..9a4f42f9e 100644 --- a/src/d_player.h +++ b/src/d_player.h @@ -506,23 +506,25 @@ struct skybox_t { }; // player_t struct for item roulette variables - // Doing this the right way is causing problems. // so FINE, it's a static length now. #define ITEM_LIST_SIZE (NUMKARTRESULTS << 3) +typedef struct itemlist_t +{ + size_t len; +#ifdef ITEM_LIST_SIZE + SINT8 items[ITEM_LIST_SIZE]; +#else + SINT8 *items; + size_t cap; +#endif +} itemlist_t; + struct itemroulette_t { boolean active; - -#ifdef ITEM_LIST_SIZE - size_t itemListLen; - SINT8 itemList[ITEM_LIST_SIZE]; -#else - size_t itemListCap; - size_t itemListLen; - SINT8 *itemList; -#endif + itemlist_t itemList; UINT8 playing, exiting; UINT32 preexpdist, dist, baseDist; diff --git a/src/k_botitem.cpp b/src/k_botitem.cpp index d042f0faa..360c80c31 100644 --- a/src/k_botitem.cpp +++ b/src/k_botitem.cpp @@ -1863,7 +1863,7 @@ static void K_UpdateBotGameplayVarsItemUsageMash(player_t *player) else { botItemPriority_e currentPriority = K_GetBotItemPriority( - static_cast( player->itemRoulette.itemList[ player->itemRoulette.index ] ) + static_cast( player->itemRoulette.itemList.items[ player->itemRoulette.index ] ) ); if (player->botvars.roulettePriority == currentPriority) @@ -1877,7 +1877,7 @@ static void K_UpdateBotGameplayVarsItemUsageMash(player_t *player) // reduce priority until we get to a valid one. player->botvars.rouletteTimeout++; - if (player->botvars.rouletteTimeout > player->itemRoulette.itemListLen * player->itemRoulette.speed) + if (player->botvars.rouletteTimeout > player->itemRoulette.itemList.len * player->itemRoulette.speed) { player->botvars.roulettePriority--; player->botvars.rouletteTimeout = 0; @@ -1995,9 +1995,9 @@ void K_BotPickItemPriority(player_t *player) player->botvars.rouletteTimeout = 0; // Check for items that are extremely high priority. - for (i = 0; i < player->itemRoulette.itemListLen; i++) + for (i = 0; i < player->itemRoulette.itemList.len; i++) { - botItemPriority_e priority = K_GetBotItemPriority( static_cast( player->itemRoulette.itemList[i] ) ); + botItemPriority_e priority = K_GetBotItemPriority( static_cast( player->itemRoulette.itemList.items[i] ) ); if (priority < BOT_ITEM_PR__OVERRIDES) { diff --git a/src/k_hud.cpp b/src/k_hud.cpp index 5bfc23d9f..c70078181 100644 --- a/src/k_hud.cpp +++ b/src/k_hud.cpp @@ -1619,15 +1619,15 @@ static void K_drawKartItem(void) boolean flashOnOne = false; boolean flashOnTwo = false; - if (stplyr->itemRoulette.itemListLen > 0) + if (stplyr->itemRoulette.itemList.len > 0) { // Init with item roulette stuff. for (i = 0; i < 3; i++) { const SINT8 indexOfs = i-1; - const size_t index = (stplyr->itemRoulette.itemListLen + (stplyr->itemRoulette.index + indexOfs)) % stplyr->itemRoulette.itemListLen; + const size_t index = (stplyr->itemRoulette.itemList.len + (stplyr->itemRoulette.index + indexOfs)) % stplyr->itemRoulette.itemList.len; - const SINT8 result = stplyr->itemRoulette.itemList[index]; + const SINT8 result = stplyr->itemRoulette.itemList.items[index]; const SINT8 item = K_ItemResultToType(result); const boolean usingDebugItemAmount = cv_kartdebugitem.value != KITEM_NONE && cv_kartdebugitem.value == item && cv_kartdebugamount.value > 1; const UINT8 amt = usingDebugItemAmount ? cv_kartdebugamount.value : K_ItemResultToAmount(result, &stplyr->itemRoulette); @@ -2133,15 +2133,15 @@ static void K_drawKartSlotMachine(void) vector2_t rouletteCrop = {10, 10}; INT32 i; - if (stplyr->itemRoulette.itemListLen > 0) + if (stplyr->itemRoulette.itemList.len > 0) { // Init with item roulette stuff. for (i = 0; i < 3; i++) { const SINT8 indexOfs = i-1; - const size_t index = (stplyr->itemRoulette.itemListLen + (stplyr->itemRoulette.index + indexOfs)) % stplyr->itemRoulette.itemListLen; + const size_t index = (stplyr->itemRoulette.itemList.len + (stplyr->itemRoulette.index + indexOfs)) % stplyr->itemRoulette.itemList.len; - const SINT8 result = stplyr->itemRoulette.itemList[index]; + const SINT8 result = stplyr->itemRoulette.itemList.items[index]; localpatch[i] = K_GetCachedSlotMachinePatch(result, offset); } @@ -7053,7 +7053,7 @@ static void K_drawDistributionDebugger(void) V_DrawRightAlignedThinString(320-(x >> FRACBITS), 100+58, V_SNAPTOTOP|V_SNAPTORIGHT, va("secondToFirst = %u", rouletteData.secondToFirst)); #ifndef ITEM_LIST_SIZE - Z_Free(rouletteData.itemList); + Z_Free(rouletteData.itemList.items); #endif } diff --git a/src/k_roulette.c b/src/k_roulette.c index 0ec6a8a71..7b88c9cac 100644 --- a/src/k_roulette.c +++ b/src/k_roulette.c @@ -773,23 +773,23 @@ static void K_InitRoulette(itemroulette_t *const roulette) size_t i; #ifndef ITEM_LIST_SIZE - if (roulette->itemList == NULL) + if (roulette->itemList.items == NULL) { - roulette->itemListCap = 8; - roulette->itemList = Z_Calloc( - sizeof(SINT8) * roulette->itemListCap, + roulette->itemList.cap = 8; + roulette->itemList.items = Z_Calloc( + sizeof(SINT8) * roulette->itemList.cap, PU_STATIC, - &roulette->itemList + &roulette->itemList.items ); - if (roulette->itemList == NULL) + if (roulette->itemList.items == NULL) { I_Error("Not enough memory for item roulette list\n"); } } #endif - roulette->itemListLen = 0; + roulette->itemList.len = 0; roulette->index = 0; roulette->baseDist = roulette->dist = 0; @@ -876,33 +876,33 @@ static void K_InitRoulette(itemroulette_t *const roulette) static void K_PushToRouletteItemList(itemroulette_t *const roulette, INT32 item) { #ifdef ITEM_LIST_SIZE - if (roulette->itemListLen >= ITEM_LIST_SIZE) + if (roulette->itemList.len >= ITEM_LIST_SIZE) { I_Error("Out of space for item reel! Go and make ITEM_LIST_SIZE bigger I guess?\n"); return; } #else - I_Assert(roulette->itemList != NULL); + I_Assert(roulette->itemList.items != NULL); - if (roulette->itemListLen >= roulette->itemListCap) + if (roulette->itemList.len >= roulette->itemList.cap) { - roulette->itemListCap *= 2; - roulette->itemList = Z_Realloc( - roulette->itemList, - sizeof(SINT8) * roulette->itemListCap, + roulette->itemList.cap *= 2; + roulette->itemList.items = Z_Realloc( + roulette->itemList.items, + sizeof(SINT8) * roulette->itemList.cap, PU_STATIC, - &roulette->itemList + &roulette->itemList.items ); - if (roulette->itemList == NULL) + if (roulette->itemList.items == NULL) { I_Error("Not enough memory for item roulette list\n"); } } #endif - roulette->itemList[ roulette->itemListLen ] = item; - roulette->itemListLen++; + roulette->itemList.items[ roulette->itemList.len ] = item; + roulette->itemList.len++; } /*-------------------------------------------------- @@ -1767,7 +1767,7 @@ void K_StartItemRoulette(player_t *const player, boolean ringbox) K_FillItemRouletteData(player, roulette, ringbox, false); if (roulette->autoroulette) - roulette->index = P_RandomRange(PR_AUTOROULETTE, 0, roulette->itemListLen - 1); + roulette->index = P_RandomRange(PR_AUTOROULETTE, 0, roulette->itemList.len - 1); if (K_PlayerUsesBotMovement(player) == true) { @@ -1776,9 +1776,9 @@ void K_StartItemRoulette(player_t *const player, boolean ringbox) // Prevent further duplicates of items that // are intended to only have one out at a time. - for (i = 0; i < roulette->itemListLen; i++) + for (i = 0; i < roulette->itemList.len; i++) { - kartitems_t item = roulette->itemList[i]; + kartitems_t item = roulette->itemList.items[i]; if (K_ItemSingularity(item) == true) { K_SetItemCooldown(item, TICRATE<<4); @@ -1907,9 +1907,9 @@ void K_KartItemRoulette(player_t *const player, ticcmd_t *const cmd) return; } - if (roulette->itemListLen == 0 + if (roulette->itemList.len == 0 #ifndef ITEM_LIST_SIZE - || roulette->itemList == NULL + || roulette->itemList.items == NULL #endif ) { @@ -1972,7 +1972,7 @@ void K_KartItemRoulette(player_t *const player, ticcmd_t *const cmd) if (fudgedDelay > gap) // Did the roulette tick over in-flight? { fudgedDelay = fudgedDelay - gap; // We're compensating for this gap's worth of delay, so cut it down. - roulette->index = roulette->index == 0 ? roulette->itemListLen - 1 : roulette->index - 1; // Roll the roulette index back... + roulette->index = roulette->index == 0 ? roulette->itemList.len - 1 : roulette->index - 1; // Roll the roulette index back... roulette->tics = 0; // And just in case our delay is SO high that a fast roulette needs to roll back again... } else @@ -1984,7 +1984,7 @@ void K_KartItemRoulette(player_t *const player, ticcmd_t *const cmd) // And one more nudge for the remaining delay. roulette->tics = (roulette->tics + fudgedDelay) % roulette->speed; - INT32 finalItem = roulette->itemList[ roulette->index ]; + INT32 finalItem = roulette->itemList.items[ roulette->index ]; if (roulette->ringbox == true) { @@ -2029,7 +2029,7 @@ void K_KartItemRoulette(player_t *const player, ticcmd_t *const cmd) if (roulette->tics == 0) { - roulette->index = (roulette->index + 1) % roulette->itemListLen; + roulette->index = (roulette->index + 1) % roulette->itemList.len; roulette->tics = roulette->speed; // This makes the roulette produce the random noises. diff --git a/src/p_saveg.cpp b/src/p_saveg.cpp index 2351cc64b..fe8f3045d 100644 --- a/src/p_saveg.cpp +++ b/src/p_saveg.cpp @@ -774,33 +774,33 @@ static void P_NetArchivePlayers(savebuffer_t *save) WRITEUINT8(save->p, players[i].itemRoulette.active); #ifdef ITEM_LIST_SIZE - WRITEUINT32(save->p, players[i].itemRoulette.itemListLen); + WRITEUINT32(save->p, players[i].itemRoulette.itemList.len); for (q = 0; q < ITEM_LIST_SIZE; q++) { - if (q >= players[i].itemRoulette.itemListLen) + if (q >= players[i].itemRoulette.itemList.len) { WRITESINT8(save->p, KITEM_NONE); } else { - WRITESINT8(save->p, players[i].itemRoulette.itemList[q]); + WRITESINT8(save->p, players[i].itemRoulette.itemList.items[q]); } } #else - if (players[i].itemRoulette.itemList == NULL) + if (players[i].itemRoulette.itemList.items == NULL) { WRITEUINT32(save->p, 0); WRITEUINT32(save->p, 0); } else { - WRITEUINT32(save->p, players[i].itemRoulette.itemListCap); - WRITEUINT32(save->p, players[i].itemRoulette.itemListLen); + WRITEUINT32(save->p, players[i].itemRoulette.itemList.cap); + WRITEUINT32(save->p, players[i].itemRoulette.itemList.len); - for (q = 0; q < players[i].itemRoulette.itemListLen; q++) + for (q = 0; q < players[i].itemRoulette.itemList.len; q++) { - WRITESINT8(save->p, players[i].itemRoulette.itemList[q]); + WRITESINT8(save->p, players[i].itemRoulette.itemList.items[q]); } } #endif @@ -1435,44 +1435,44 @@ static void P_NetUnArchivePlayers(savebuffer_t *save) players[i].itemRoulette.active = (boolean)READUINT8(save->p); #ifdef ITEM_LIST_SIZE - players[i].itemRoulette.itemListLen = (size_t)READUINT32(save->p); + players[i].itemRoulette.itemList.len = (size_t)READUINT32(save->p); for (q = 0; q < ITEM_LIST_SIZE; q++) { - players[i].itemRoulette.itemList[q] = READSINT8(save->p); + players[i].itemRoulette.itemList.items[q] = READSINT8(save->p); } #else - players[i].itemRoulette.itemListCap = (size_t)READUINT32(save->p); - players[i].itemRoulette.itemListLen = (size_t)READUINT32(save->p); + players[i].itemRoulette.itemList.cap = (size_t)READUINT32(save->p); + players[i].itemRoulette.itemList.len = (size_t)READUINT32(save->p); - if (players[i].itemRoulette.itemListCap > 0) + if (players[i].itemRoulette.itemList.cap > 0) { - if (players[i].itemRoulette.itemList == NULL) + if (players[i].itemRoulette.itemList.items == NULL) { - players[i].itemRoulette.itemList = Z_Calloc( - sizeof(SINT8) * players[i].itemRoulette.itemListCap, + players[i].itemRoulette.itemList.items = Z_Calloc( + sizeof(SINT8) * players[i].itemRoulette.itemList.cap, PU_STATIC, - &players[i].itemRoulette.itemList + &players[i].itemRoulette.itemList.items ); } else { - players[i].itemRoulette.itemList = Z_Realloc( - players[i].itemRoulette.itemList, - sizeof(SINT8) * players[i].itemRoulette.itemListCap, + players[i].itemRoulette.itemList.items = Z_Realloc( + players[i].itemRoulette.itemList.items, + sizeof(SINT8) * players[i].itemRoulette.itemList.cap, PU_STATIC, - &players[i].itemRoulette.itemList + &players[i].itemRoulette.itemList.items ); } - if (players[i].itemRoulette.itemList == NULL) + if (players[i].itemRoulette.itemList.items == NULL) { I_Error("Not enough memory for item roulette list\n"); } - for (q = 0; q < players[i].itemRoulette.itemListLen; q++) + for (q = 0; q < players[i].itemRoulette.itemList.len; q++) { - players[i].itemRoulette.itemList[q] = READSINT8(save->p); + players[i].itemRoulette.itemList.items[q] = READSINT8(save->p); } } #endif