From 741097888293eb1ea655365f22fb36394f85db18 Mon Sep 17 00:00:00 2001 From: Ashnal Date: Sun, 22 Jun 2025 23:36:21 -0400 Subject: [PATCH] Cleanup No functionality changes --- src/doomdef.h | 6 +++--- src/k_kart.c | 34 +++++++++++++++++----------------- src/k_podium.cpp | 14 +++++++------- src/k_rank.cpp | 12 ++++++------ src/k_tally.cpp | 2 +- 5 files changed, 34 insertions(+), 34 deletions(-) diff --git a/src/doomdef.h b/src/doomdef.h index 3ff5c274b..2842e4d80 100644 --- a/src/doomdef.h +++ b/src/doomdef.h @@ -747,9 +747,9 @@ extern int // Exp #define EXP_STABLERATE 3*FRACUNIT/10 // how low is your placement before losing XP? 4*FRACUNIT/10 = top 40% of race will gain #define EXP_POWER 3*FRACUNIT/100 // adjust to change overall xp volatility -#define MINEXP 25 // The min value target -#define TARGETEXP 120 // Used for grading ... -#define MAXEXP 120 // The max value displayed by the hud and in the tally screen and GP results screen +#define EXP_MIN 25 // The min value target +#define EXP_TARGET 120 // Used for grading ... +#define EXP_MAX 120 // The max value displayed by the hud and in the tally screen and GP results screen #ifdef __cplusplus } // extern "C" diff --git a/src/k_kart.c b/src/k_kart.c index 84c2cceae..5ac1ba0ad 100644 --- a/src/k_kart.c +++ b/src/k_kart.c @@ -15995,9 +15995,9 @@ static UINT8 K_Opponents(player_t *player) return opponents; } -static fixed_t K_EXPPower(player_t *player) +static fixed_t K_GradingFactorPower(player_t *player) { - fixed_t power = EXP_POWER; // adjust to change overall xp volatility + fixed_t power = EXP_POWER; // adjust to change overall exp volatility UINT8 opponents = K_Opponents(player); if (g_teamplay) @@ -16009,16 +16009,16 @@ static fixed_t K_EXPPower(player_t *player) return power; } -static fixed_t K_EXPGainPerWin(player_t *player) +static fixed_t K_GradingFactorGainPerWin(player_t *player) { - return K_EXPPower(player); + return K_GradingFactorPower(player); } -static fixed_t K_EXPDrainPerCheckpoint(player_t *player) +static fixed_t K_GradingFactorDrainPerCheckpoint(player_t *player) { - // EXP_STABLERATE: How low do you have to place before losing XP? 4*FRACUNIT/10 = top 40% of race gains, 60% loses. + // EXP_STABLERATE: How low do you have to place before losing gradingfactor? 4*FRACUNIT/10 = top 40% of race gains, 60% loses. UINT8 opponents = K_Opponents(player); - fixed_t power = K_EXPPower(player); + fixed_t power = K_GradingFactorPower(player); return FixedMul(power, FixedMul(opponents*FRACUNIT, FRACUNIT - EXP_STABLERATE)); } @@ -16026,35 +16026,35 @@ fixed_t K_GetGradingFactorAdjustment(player_t *player) { fixed_t result = 0; - // Increase XP for each player you're beating... + // Increase gradingfactor for each player you're beating... for (INT32 i = 0; i < MAXPLAYERS; i++) { if (!K_IsValidOpponent(player, &players[i])) continue; if (player->position < players[i].position) - result += K_EXPGainPerWin(player); + result += K_GradingFactorGainPerWin(player); } - // ...then take all of the XP you could possibly have earned, + // ...then take all of the gradingfactor you could possibly have earned, // and lose it proportional to the stable rate. If you're below - // the stable threshold, this results in you losing XP. - result -= K_EXPDrainPerCheckpoint(player); + // the stable threshold, this results in you losing gradingfactor + result -= K_GradingFactorDrainPerCheckpoint(player); return result; } fixed_t K_GetGradingFactorMinMax(player_t *player, boolean max) { - fixed_t factor = FRACUNIT; // Starting EXP. + fixed_t factor = FRACUNIT; // Starting gradingfactor UINT8 opponents = K_Opponents(player); UINT8 winning = (max) ? opponents : 0; for (UINT8 i = 0; i < player->gradingpointnum; i++) // For each gradingpoint you've reached... { for (UINT8 j = 0; j < winning; j++) - factor += K_EXPGainPerWin(player); // If max, increase EXP for each player you could have been beating. - factor -= K_EXPDrainPerCheckpoint(player); // Then, drain like usual. + factor += K_GradingFactorGainPerWin(player); // If max, increase gradingfactor for each player you could have been beating. + factor -= K_GradingFactorDrainPerCheckpoint(player); // Then, drain like usual. } return factor; @@ -16063,8 +16063,8 @@ fixed_t K_GetGradingFactorMinMax(player_t *player, boolean max) UINT16 K_GetEXP(player_t *player) { UINT32 numgradingpoints = K_GetNumGradingPoints(); - fixed_t targetminexp = (MINEXP*player->gradingpointnum<gradingpointnum<gradingpointnum<gradingpointnum<totalExp = TARGETEXP; + lvl->totalExp = EXP_TARGET; texp += lvl->totalExp * rank.numPlayers; break; } @@ -203,7 +203,7 @@ void podiumData_s::Init(void) dta->rings = M_RandomRange(0, 20); rgs += dta->rings; - dta->exp = M_RandomRange(MINEXP, MAXEXP); + dta->exp = M_RandomRange(EXP_MIN, EXP_MAX); pexp += dta->exp; } @@ -727,8 +727,8 @@ void podiumData_s::Draw(void) // Colorize the crystal, just like we do for hud skincolornum_t overlaycolor = SKINCOLOR_MUSTARD; fixed_t stablerateinverse = FRACUNIT - EXP_STABLERATE; - INT16 exp_range = MAXEXP-MINEXP; - INT16 exp_offset = dta->exp-MINEXP; + INT16 exp_range = EXP_MAX-EXP_MIN; + INT16 exp_offset = dta->exp-EXP_MIN; fixed_t factor = (exp_offset*FRACUNIT) / exp_range; // 0.0 to 1.0 in fixed // amount of blue is how much factor is above EXP_STABLERATE, and amount of red is how much factor is below // assume that EXP_STABLERATE is within 0.0 to 1.0 in fixed @@ -892,9 +892,9 @@ void podiumData_s::Draw(void) .patch("K_STEXP"); // Colorize the crystal for the totals, just like we do for in race hud - fixed_t extraexpfactor = (MAXEXP*FRACUNIT) / TARGETEXP; + fixed_t extraexpfactor = (EXP_MAX*FRACUNIT) / EXP_TARGET; INT16 totalExpMax = FixedMul(rank.totalExp*FRACUNIT, extraexpfactor) / FRACUNIT; // im just going to calculate it from target lol - INT16 totalExpMin = rank.numPlayers*MINEXP; + INT16 totalExpMin = rank.numPlayers*EXP_MIN; skincolornum_t overlaycolor = SKINCOLOR_MUSTARD; fixed_t stablerateinverse = FRACUNIT - EXP_STABLERATE; INT16 exp_range = totalExpMax-totalExpMin; diff --git a/src/k_rank.cpp b/src/k_rank.cpp index c2e222158..3ca026fc8 100644 --- a/src/k_rank.cpp +++ b/src/k_rank.cpp @@ -322,7 +322,7 @@ void gpRank_t::Init(void) // (Should this account for all coop players?) for (i = 0; i < numHumans; i++) { - totalPoints += grandprixinfo.cup->numlevels * K_CalculateGPRankPoints(MAXEXP, i+1, totalPlayers); + totalPoints += grandprixinfo.cup->numlevels * K_CalculateGPRankPoints(EXP_MAX, i+1, totalPlayers); } totalRings = grandprixinfo.cup->numlevels * numHumans * 20; @@ -332,7 +332,7 @@ void gpRank_t::Init(void) const INT32 cupLevelNum = grandprixinfo.cup->cachedlevels[i]; if (cupLevelNum < nummapheaders && mapheaderinfo[cupLevelNum] != NULL) { - exp += TARGETEXP; + exp += EXP_TARGET; } } @@ -372,7 +372,7 @@ void gpRank_t::Rejigger(UINT16 removedmap, UINT16 removedgt, UINT16 addedmap, UI { for (i = 0; i < numPlayers; i++) { - deltaPoints += K_CalculateGPRankPoints(MAXEXP, i + 1, totalPlayers); + deltaPoints += K_CalculateGPRankPoints(EXP_MAX, i + 1, totalPlayers); } if (addedgt == GT_RACE) totalPoints += deltaPoints; @@ -391,7 +391,7 @@ void gpRank_t::Rejigger(UINT16 removedmap, UINT16 removedgt, UINT16 addedmap, UI { if (removedgt == GT_RACE) { - deltaExp -= TARGETEXP; + deltaExp -= EXP_TARGET; } if ((gametypes[removedgt]->rules & GTR_SPHERES) == 0) { @@ -408,7 +408,7 @@ void gpRank_t::Rejigger(UINT16 removedmap, UINT16 removedgt, UINT16 addedmap, UI { if (addedgt == GT_RACE) { - deltaExp += TARGETEXP; + deltaExp += EXP_TARGET; } if ((gametypes[addedgt]->rules & GTR_SPHERES) == 0) { @@ -492,7 +492,7 @@ void gpRank_t::Update(void) lvl->time = UINT32_MAX; - lvl->totalExp = TARGETEXP; + lvl->totalExp = EXP_TARGET; lvl->totalPrisons = maptargets; UINT8 i; diff --git a/src/k_tally.cpp b/src/k_tally.cpp index f8e91b46c..ba17f4153 100644 --- a/src/k_tally.cpp +++ b/src/k_tally.cpp @@ -347,7 +347,7 @@ void level_tally_t::Init(player_t *player) if (player->exp) { exp = player->exp; - totalExp = TARGETEXP; + totalExp = EXP_TARGET; } }