thirdpartymirrors/RingRacers
1
0
Fork 0
mirror of https://github.com/KartKrewDev/RingRacers.git synced 2026-04-22 02:00:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Implement itemlist_t in itemroulette_t for better Lua integration

Browse source 
itemList -> itemList.items
itemListLen -> itemList.len
itemListCap -> itemList.cap
This commit is contained in:
JugadorXEI 2024-10-13 17:14:59 +02:00 • committed by Antonio Martinez
parent 5e92d74f81
commit 31a97adbf2
5 changed files with 73 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/d_player.h
View file

@ -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;

8
src/k_botitem.cpp
View file

@ -1863,7 +1863,7 @@ static void K_UpdateBotGameplayVarsItemUsageMash(player_t *player)
else
{
botItemPriority_e currentPriority = K_GetBotItemPriority(
static_cast<kartitems_t>( player->itemRoulette.itemList[ player->itemRoulette.index ] )
static_cast<kartitems_t>( 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<kartitems_t>( player->itemRoulette.itemList[i] ) );
botItemPriority_e priority = K_GetBotItemPriority( static_cast<kartitems_t>( player->itemRoulette.itemList.items[i] ) );
if (priority < BOT_ITEM_PR__OVERRIDES)
{

14
src/k_hud.cpp
View file

@ -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
}

52
src/k_roulette.c
View file

@ -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.

48
src/p_saveg.cpp
View file

@ -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