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

Merge branch 'grow-shrink-shoe-polish' into 'master'

Browse source 
More extremely scaled grow & shrink players!

See merge request KartKrew/Kart!534
This commit is contained in:
SteelT 2022-01-23 18:59:39 +00:00
commit a793af47c5
13 changed files with 341 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
src/d_netcmd.c
View file

@ -423,7 +423,7 @@ consvar_t cv_kartallowgiveitem = CVAR_INIT ("kartallowgiveitem",
#endif
CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_YesNo, NULL
);
consvar_t cv_kartdebugshrink = CVAR_INIT ("kartdebugshrink", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL);
consvar_t cv_kartdebugdistribution = CVAR_INIT ("kartdebugdistribution", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL);
consvar_t cv_kartdebughuddrop = CVAR_INIT ("kartdebughuddrop", "Off", CV_NETVAR|CV_CHEAT|CV_NOSHOWHELP, CV_OnOff, NULL);
static CV_PossibleValue_t kartdebugwaypoint_cons_t[] = {{0, "Off"}, {1, "Forwards"}, {2, "Backwards"}, {0, NULL}};
@ -935,6 +935,7 @@ void D_RegisterClientCommands(void)
for (i = 0; i < MAXSPLITSCREENPLAYERS; i++)
{
CV_RegisterVar(&cv_kickstartaccel[i]);
CV_RegisterVar(&cv_shrinkme[i]);
CV_RegisterVar(&cv_turnaxis[i]);
CV_RegisterVar(&cv_moveaxis[i]);
CV_RegisterVar(&cv_brakeaxis[i]);
@ -1636,10 +1637,13 @@ void SendWeaponPref(UINT8 n)
UINT8 buf[1];
buf[0] = 0;
// Player option cvars that need to be synched go HERE
if (cv_kickstartaccel[n].value)
buf[0] |= 1;
if (cv_shrinkme[n].value)
buf[0] |= 2;
SendNetXCmdForPlayer(n, XD_WEAPONPREF, buf, 1);
}
@ -1647,11 +1651,22 @@ static void Got_WeaponPref(UINT8 **cp,INT32 playernum)
{
UINT8 prefs = READUINT8(*cp);
// Player option cvars that need to be synched go HERE
players[playernum].pflags &= ~(PF_KICKSTARTACCEL);
players[playernum].pflags &= ~(PF_KICKSTARTACCEL|PF_SHRINKME);
if (prefs & 1)
players[playernum].pflags |= PF_KICKSTARTACCEL;
if (prefs & 2)
players[playernum].pflags |= PF_SHRINKME;
if (leveltime < 2)
{
// BAD HACK: No other place I tried to slot this in
// made it work for the host when they initally host,
// so this will have to do.
K_UpdateShrinkCheat(&players[playernum]);
}
// SEE ALSO g_demo.c
demo_extradata[playernum] |= DXD_WEAPONPREF;
}

2
src/d_netcmd.h
View file

@ -86,7 +86,7 @@ extern consvar_t cv_kartusepwrlv;
extern consvar_t cv_votetime;
extern consvar_t cv_kartdebugitem, cv_kartdebugamount, cv_kartallowgiveitem, cv_kartdebugshrink, cv_kartdebugdistribution, cv_kartdebughuddrop;
extern consvar_t cv_kartdebugitem, cv_kartdebugamount, cv_kartallowgiveitem, cv_kartdebugdistribution, cv_kartdebughuddrop;
extern consvar_t cv_kartdebugcheckpoint, cv_kartdebugnodes, cv_kartdebugcolorize;
extern consvar_t cv_kartdebugwaypoints, cv_kartdebugbotpredict;

16
src/d_player.h
View file

@ -59,10 +59,10 @@ typedef enum
typedef enum
{
// True if button down last tic.
PF_ATTACKDOWN = 1,
PF_ACCELDOWN = 1<<1,
PF_BRAKEDOWN = 1<<2,
PF_LOOKDOWN = 1<<3,
PF_ATTACKDOWN = 1,
PF_ACCELDOWN = 1<<1,
PF_BRAKEDOWN = 1<<2,
PF_LOOKDOWN = 1<<3,
// Accessibility and cheats
PF_KICKSTARTACCEL = 1<<4, // Is accelerate in kickstart mode?
@ -99,6 +99,9 @@ typedef enum
PF_HITFINISHLINE = 1<<26, // Already hit the finish line this tic
PF_WRONGWAY = 1<<27, // Moving the wrong way with respect to waypoints?
PF_SHRINKME = 1<<28, // "Shrink me" cheat preference
PF_SHRINKACTIVE = 1<<29, // "Shrink me" cheat is in effect. (Can't be disabled mid-race)
// up to 1<<31 is free
} pflags_t;
@ -260,6 +263,10 @@ typedef enum
// for kickstartaccel
#define ACCEL_KICKSTART 35
#define ITEMSCALE_NORMAL 0
#define ITEMSCALE_GROW 1
#define ITEMSCALE_SHRINK 2
// player_t struct for all respawn variables
typedef struct respawnvars_s
{
@ -436,6 +443,7 @@ typedef struct player_s
SINT8 itemtype; // KITEM_ constant for item number
UINT8 itemamount; // Amount of said item
SINT8 throwdir; // Held dir of controls; 1 = forward, 0 = none, -1 = backward (was "player->heldDir")
UINT8 itemscale; // Item scale value, from when an item was taken out. (0 for normal, 1 for grow, 2 for shrink.)
UINT8 sadtimer; // How long you've been sad

4
src/deh_tables.c
View file

@ -5912,6 +5912,10 @@ const char *const PLAYERFLAG_LIST[] = {
"HITFINISHLINE", // Already hit the finish line this tic
"WRONGWAY", // Moving the wrong way with respect to waypoints?
"SHRINKME",
"SHRINKACTIVE",
NULL // stop loop here.
};

59
src/g_demo.c
View file

@ -122,8 +122,9 @@ demoghost *ghosts = NULL;
#define DF_ENCORE 0x40
#define DF_MULTIPLAYER 0x80 // This demo was recorded in multiplayer mode!
#define DEMO_SPECTATOR 0x40
#define DEMO_KICKSTART 0x20
#define DEMO_SPECTATOR 0x01
#define DEMO_KICKSTART 0x02
#define DEMO_SHRINKME 0x04
// For demos
#define ZT_FWD 0x01
@ -351,9 +352,20 @@ void G_ReadDemoExtraData(void)
if (extradata & DXD_WEAPONPREF)
{
i = READUINT8(demo_p);
players[p].pflags &= ~(PF_KICKSTARTACCEL);
players[p].pflags &= ~(PF_KICKSTARTACCEL|PF_SHRINKME);
if (i & 1)
players[p].pflags |= PF_KICKSTARTACCEL;
if (i & 2)
players[p].pflags |= PF_SHRINKME;
if (leveltime < 2)
{
// BAD HACK: No other place I tried to slot this in
// made it work for the host when they initally host,
// so this will have to do.
K_UpdateShrinkCheat(&players[p]);
}
//CONS_Printf("weaponpref is %d for player %d\n", i, p);
}
@ -466,6 +478,8 @@ void G_WriteDemoExtraData(void)
UINT8 prefs = 0;
if (players[i].pflags & PF_KICKSTARTACCEL)
prefs |= 1;
if (players[i].pflags & PF_SHRINKME)
prefs |= 2;
WRITEUINT8(demo_p, prefs);
}
}
@ -2015,12 +2029,15 @@ void G_BeginRecording(void)
for (p = 0; p < MAXPLAYERS; p++) {
if (playeringame[p]) {
player = &players[p];
WRITEUINT8(demo_p, p);
i = p;
if (player->pflags & PF_KICKSTARTACCEL)
i |= DEMO_KICKSTART;
i = 0;
if (player->spectator)
i |= DEMO_SPECTATOR;
if (player->pflags & PF_KICKSTARTACCEL)
i |= DEMO_KICKSTART;
if (player->pflags & PF_SHRINKME)
i |= DEMO_SHRINKME;
WRITEUINT8(demo_p, i);
// Name
@ -2672,7 +2689,7 @@ void G_DoPlayDemo(char *defdemoname)
UINT32 randseed;
char msg[1024];
boolean spectator, kickstart;
boolean spectator, kickstart, shrinkme;
UINT8 slots[MAXPLAYERS], kartspeed[MAXPLAYERS], kartweight[MAXPLAYERS], numslots = 0;
#if defined(SKIPERRORS) && !defined(DEVELOP)
@ -2943,9 +2960,13 @@ void G_DoPlayDemo(char *defdemoname)
while (p != 0xFF)
{
if ((spectator = !!(p & DEMO_SPECTATOR)))
UINT8 flags = READUINT8(demo_p);
spectator = kickstart = shrinkme = false;
if ((spectator = !!(flags & DEMO_SPECTATOR)) == true)
{
p &= ~DEMO_SPECTATOR;
flags &= ~DEMO_SPECTATOR;
if (modeattacking)
{
@ -2960,10 +2981,14 @@ void G_DoPlayDemo(char *defdemoname)
}
}
if ((kickstart = (p & DEMO_KICKSTART)))
p &= ~DEMO_KICKSTART;
if ((kickstart = !!(flags & DEMO_KICKSTART)) == true)
flags &= ~DEMO_KICKSTART;
slots[numslots] = p; numslots++;
if ((shrinkme = !!(flags & DEMO_SHRINKME)) == true)
flags &= ~DEMO_SHRINKME;
slots[numslots] = p;
numslots++;
if (modeattacking && numslots > 1)
{
@ -2982,11 +3007,19 @@ void G_DoPlayDemo(char *defdemoname)
playeringame[p] = true;
players[p].spectator = spectator;
if (kickstart)
players[p].pflags |= PF_KICKSTARTACCEL;
else
players[p].pflags &= ~PF_KICKSTARTACCEL;
if (shrinkme)
players[p].pflags |= PF_SHRINKME;
else
players[p].pflags &= ~PF_SHRINKME;
K_UpdateShrinkCheat(&players[p]);
// Name
M_Memcpy(player_names[p],demo_p,16);
demo_p += 16;
@ -3245,7 +3278,7 @@ void G_AddGhost(char *defdemoname)
return;
}
if ((READUINT8(p) & ~DEMO_KICKSTART) != 0)
if ((READUINT8(p) & ~(DEMO_KICKSTART|DEMO_SHRINKME)) != 0)
{
CONS_Alert(CONS_NOTICE, M_GetText("Failed to add ghost %s: Invalid player slot.\n"), pdemoname);
Z_Free(pdemoname);

34
src/g_game.c
View file

@ -342,10 +342,10 @@ INT16 prevmap, nextmap;
static UINT8 *savebuffer;
static void kickstartaccel_OnChange(void);
static void kickstartaccel2_OnChange(void);
static void kickstartaccel3_OnChange(void);
static void kickstartaccel4_OnChange(void);
static void weaponPrefChange(void);
static void weaponPrefChange2(void);
static void weaponPrefChange3(void);
static void weaponPrefChange4(void);
static CV_PossibleValue_t joyaxis_cons_t[] = {{0, "None"},
{1, "X-Axis"}, {2, "Y-Axis"}, {-1, "X-Axis-"}, {-2, "Y-Axis-"},
@ -406,10 +406,17 @@ consvar_t cv_resetspecialmusic = CVAR_INIT ("resetspecialmusic", "Yes", CV_SAVE,
consvar_t cv_resume = CVAR_INIT ("resume", "Yes", CV_SAVE, CV_YesNo, NULL);
consvar_t cv_kickstartaccel[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("kickstartaccel", "Off", CV_SAVE|CV_CALL, CV_OnOff, kickstartaccel_OnChange),
CVAR_INIT ("kickstartaccel2", "Off", CV_SAVE|CV_CALL, CV_OnOff, kickstartaccel2_OnChange),
CVAR_INIT ("kickstartaccel3", "Off", CV_SAVE|CV_CALL, CV_OnOff, kickstartaccel3_OnChange),
CVAR_INIT ("kickstartaccel4", "Off", CV_SAVE|CV_CALL, CV_OnOff, kickstartaccel4_OnChange)
CVAR_INIT ("kickstartaccel", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange),
CVAR_INIT ("kickstartaccel2", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange2),
CVAR_INIT ("kickstartaccel3", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange3),
CVAR_INIT ("kickstartaccel4", "Off", CV_SAVE|CV_CALL, CV_OnOff, weaponPrefChange4)
};
consvar_t cv_shrinkme[MAXSPLITSCREENPLAYERS] = {
CVAR_INIT ("shrinkme", "Off", CV_CALL, CV_OnOff, weaponPrefChange),
CVAR_INIT ("shrinkme2", "Off", CV_CALL, CV_OnOff, weaponPrefChange2),
CVAR_INIT ("shrinkme3", "Off", CV_CALL, CV_OnOff, weaponPrefChange3),
CVAR_INIT ("shrinkme4", "Off", CV_CALL, CV_OnOff, weaponPrefChange4)
};
consvar_t cv_turnaxis[MAXSPLITSCREENPLAYERS] = {
@ -1183,22 +1190,22 @@ ticcmd_t *G_MoveTiccmd(ticcmd_t* dest, const ticcmd_t* src, const size_t n)
return dest;
}
static void kickstartaccel_OnChange(void)
static void weaponPrefChange(void)
{
SendWeaponPref(0);
}
static void kickstartaccel2_OnChange(void)
static void weaponPrefChange2(void)
{
SendWeaponPref(1);
}
static void kickstartaccel3_OnChange(void)
static void weaponPrefChange3(void)
{
SendWeaponPref(2);
}
static void kickstartaccel4_OnChange(void)
static void weaponPrefChange4(void)
{
SendWeaponPref(3);
}
@ -2164,7 +2171,7 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
botdiffincrease = players[player].botvars.diffincrease;
botrival = players[player].botvars.rival;
pflags = (players[player].pflags & (PF_WANTSTOJOIN|PF_KICKSTARTACCEL));
pflags = (players[player].pflags & (PF_WANTSTOJOIN|PF_KICKSTARTACCEL|PF_SHRINKME|PF_SHRINKACTIVE));
// SRB2kart
if (betweenmaps || leveltime < introtime)
@ -2235,7 +2242,6 @@ void G_PlayerReborn(INT32 player, boolean betweenmaps)
if (!(netgame || multiplayer))
pflags |= (players[player].pflags & (PF_GODMODE|PF_NOCLIP));
// Obliterate follower from existence
P_SetTarget(&players[player].follower, NULL);

2
src/g_game.h
View file

@ -55,6 +55,8 @@ extern consvar_t cv_pauseifunfocused;
extern consvar_t cv_invertmouse;
extern consvar_t cv_kickstartaccel[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_shrinkme[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_turnaxis[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_moveaxis[MAXSPLITSCREENPLAYERS];
extern consvar_t cv_brakeaxis[MAXSPLITSCREENPLAYERS];

265
src/k_kart.c
View file

@ -250,7 +250,6 @@ void K_RegisterKartStuff(void)
CV_RegisterVar(&cv_kartdebugitem);
CV_RegisterVar(&cv_kartdebugamount);
CV_RegisterVar(&cv_kartdebugshrink);
CV_RegisterVar(&cv_kartallowgiveitem);
CV_RegisterVar(&cv_kartdebugdistribution);
CV_RegisterVar(&cv_kartdebughuddrop);
@ -2903,6 +2902,28 @@ static void K_GetKartBoostPower(player_t *player)
player->numboosts = numboosts;
}
fixed_t K_GrowShrinkSpeedMul(player_t *player)
{
fixed_t scaleDiff = player->mo->scale - mapobjectscale;
fixed_t playerScale = FixedDiv(player->mo->scale, mapobjectscale);
fixed_t speedMul = FRACUNIT;
if (scaleDiff > 0)
{
// Grown
// Change x2 speed into x1.5
speedMul = FixedDiv(FixedMul(playerScale, GROW_PHYSICS_SCALE), GROW_SCALE);
}
else if (scaleDiff < 0)
{
// Shrunk
// Change x0.5 speed into x0.75
speedMul = FixedDiv(FixedMul(playerScale, SHRINK_PHYSICS_SCALE), SHRINK_SCALE);
}
return speedMul;
}
// Returns kart speed from a stat. Boost power and scale are NOT taken into account, no player or object is necessary.
fixed_t K_GetKartSpeedFromStat(UINT8 kartspeed)
{
@ -2919,9 +2940,8 @@ fixed_t K_GetKartSpeedFromStat(UINT8 kartspeed)
fixed_t K_GetKartSpeed(player_t *player, boolean doboostpower)
{
fixed_t finalspeed;
finalspeed = K_GetKartSpeedFromStat(player->kartspeed);
const boolean mobjValid = (player->mo != NULL && P_MobjWasRemoved(player->mo) == false);
fixed_t finalspeed = K_GetKartSpeedFromStat(player->kartspeed);
if (player->spheres > 0)
{
@ -2942,17 +2962,22 @@ fixed_t K_GetKartSpeed(player_t *player, boolean doboostpower)
}
}
if (player->mo && !P_MobjWasRemoved(player->mo))
finalspeed = FixedMul(finalspeed, player->mo->scale);
finalspeed = FixedMul(finalspeed, mapobjectscale);
if (doboostpower)
if (doboostpower == true)
{
if (mobjValid == true)
{
// Scale with the player.
finalspeed = FixedMul(finalspeed, K_GrowShrinkSpeedMul(player));
}
if (K_PlayerUsesBotMovement(player))
{
finalspeed = FixedMul(finalspeed, K_BotTopSpeedRubberband(player));
}
return FixedMul(finalspeed, player->boostpower+player->speedboost);
finalspeed = FixedMul(finalspeed, player->boostpower + player->speedboost);
}
return finalspeed;
@ -2992,6 +3017,34 @@ UINT16 K_GetKartFlashing(player_t *player)
return tics;
}
boolean K_PlayerShrinkCheat(player_t *player)
{
return (
(player->pflags & PF_SHRINKACTIVE)
&& (player->bot == false)
&& (modeattacking == false) // Anyone want to make another record attack category?
);
}
void K_UpdateShrinkCheat(player_t *player)
{
const boolean mobjValid = (player->mo != NULL && P_MobjWasRemoved(player->mo) == false);
if (player->pflags & PF_SHRINKME)
{
player->pflags |= PF_SHRINKACTIVE;
}
else
{
player->pflags &= ~PF_SHRINKACTIVE;
}
if (mobjValid == true && K_PlayerShrinkCheat(player) == true)
{
player->mo->destscale = FixedMul(mapobjectscale, SHRINK_SCALE);
}
}
boolean K_KartKickstart(player_t *player)
{
return ((player->pflags & PF_KICKSTARTACCEL)
@ -3262,8 +3315,11 @@ static void K_RemoveGrowShrink(player_t *player)
player->mo->scalespeed = mapobjectscale/TICRATE;
player->mo->destscale = mapobjectscale;
if (cv_kartdebugshrink.value && !modeattacking && !player->bot)
player->mo->destscale = (6*player->mo->destscale)/8;
if (K_PlayerShrinkCheat(player) == true)
{
player->mo->destscale = FixedMul(player->mo->destscale, SHRINK_SCALE);
}
}
player->growshrinktimer = 0;
@ -3787,24 +3843,56 @@ void K_SpawnMineExplosion(mobj_t *source, UINT8 color)
#undef MINEQUAKEDIST
fixed_t K_ItemScaleForPlayer(player_t *player)
{
switch (player->itemscale)
{
case ITEMSCALE_GROW:
return FixedMul(GROW_SCALE, mapobjectscale);
case ITEMSCALE_SHRINK:
return FixedMul(SHRINK_SCALE, mapobjectscale);
default:
return mapobjectscale;
}
}
static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, INT32 flags2, fixed_t speed)
{
mobj_t *th;
fixed_t x, y, z;
fixed_t finalspeed = speed;
fixed_t finalscale = mapobjectscale;
mobj_t *throwmo;
if (source->player && source->player->speed > K_GetKartSpeed(source->player, false))
if (source->player != NULL)
{
angle_t input = source->angle - an;
boolean invert = (input > ANGLE_180);
if (invert)
input = InvAngle(input);
if (source->player->itemscale == ITEMSCALE_SHRINK)
{
// Nerf the base item speed a bit.
finalspeed = FixedMul(finalspeed, SHRINK_PHYSICS_SCALE);
}
finalspeed = max(speed, FixedMul(speed, FixedMul(
FixedDiv(source->player->speed, K_GetKartSpeed(source->player, false)), // Multiply speed to be proportional to your own, boosted maxspeed.
(((180<<FRACBITS) - AngleFixed(input)) / 180) // multiply speed based on angle diff... i.e: don't do this for firing backward :V
)));
if (source->player->speed > K_GetKartSpeed(source->player, false))
{
angle_t input = source->angle - an;
boolean invert = (input > ANGLE_180);
if (invert)
input = InvAngle(input);
finalspeed = max(speed, FixedMul(speed, FixedMul(
FixedDiv(source->player->speed, K_GetKartSpeed(source->player, false)), // Multiply speed to be proportional to your own, boosted maxspeed.
(((180<<FRACBITS) - AngleFixed(input)) / 180) // multiply speed based on angle diff... i.e: don't do this for firing backward :V
)));
}
finalscale = K_ItemScaleForPlayer(source->player);
}
if (type == MT_BUBBLESHIELDTRAP)
{
finalscale = source->scale;
}
x = source->x + source->momx + FixedMul(finalspeed, FINECOSINE(an>>ANGLETOFINESHIFT));
@ -3823,8 +3911,8 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
P_SetTarget(&th->target, source);
P_SetScale(th, source->scale);
th->destscale = source->destscale;
P_SetScale(th, finalscale);
th->destscale = finalscale;
if (P_IsObjectOnGround(source))
{
@ -3850,6 +3938,11 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
th->momy = FixedMul(finalspeed, FINESINE(an>>ANGLETOFINESHIFT));
th->momz = source->momz;
if (source->player != NULL)
{
th->cusval = source->player->itemscale;
}
switch (type)
{
case MT_ORBINAUT:
@ -4744,13 +4837,15 @@ mobj_t *K_ThrowKartItem(player_t *player, boolean missile, mobjtype_t mapthing,
}
else
{
fixed_t finalscale = K_ItemScaleForPlayer(player);
player->bananadrag = 0; // RESET timer, for multiple bananas
if (dir > 0)
{
// Shoot forward
mo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z + player->mo->height/2, mapthing);
//K_FlipFromObject(mo, player->mo);
// These are really weird so let's make it a very specific case to make SURE it works...
if (player->mo->eflags & MFE_VERTICALFLIP)
{
@ -4777,6 +4872,9 @@ mobj_t *K_ThrowKartItem(player_t *player, boolean missile, mobjtype_t mapthing,
if (mo->eflags & MFE_UNDERWATER)
mo->momz = (117 * mo->momz) / 200;
P_SetScale(mo, finalscale);
mo->destscale = finalscale;
}
// this is the small graphic effect that plops in you when you throw an item:
@ -4791,6 +4889,9 @@ mobj_t *K_ThrowKartItem(player_t *player, boolean missile, mobjtype_t mapthing,
}
throwmo->movecount = 0; // above player
P_SetScale(throwmo, finalscale);
throwmo->destscale = finalscale;
}
else
{
@ -4828,8 +4929,8 @@ mobj_t *K_ThrowKartItem(player_t *player, boolean missile, mobjtype_t mapthing,
mo->threshold = 10;
P_SetTarget(&mo->target, player->mo);
P_SetScale(mo, player->mo->scale);
mo->destscale = player->mo->destscale;
P_SetScale(mo, finalscale);
mo->destscale = finalscale;
if (P_IsObjectOnGround(player->mo))
{
@ -4899,6 +5000,10 @@ void K_PuntMine(mobj_t *origMine, mobj_t *punter)
mine->floorz = origMine->floorz;
mine->ceilingz = origMine->ceilingz;
P_SetScale(mine, origMine->scale);
mine->destscale = origMine->destscale;
mine->scalespeed = origMine->scalespeed;
// Copy interp data
mine->old_angle = origMine->old_angle;
mine->old_x = origMine->old_x;
@ -4907,8 +5012,7 @@ void K_PuntMine(mobj_t *origMine, mobj_t *punter)
// Since we aren't using P_KillMobj, we need to clean up the hnext reference
P_SetTarget(&mineOwner->hnext, NULL);
mineOwner->player->bananadrag = 0;
mineOwner->player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(mineOwner->player);
if (mineOwner->player->itemamount)
{
@ -5065,7 +5169,7 @@ static void K_DoHyudoroSteal(player_t *player)
player->itemtype = KITEM_KITCHENSINK;
player->itemamount = 1;
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
return;
}
else if ((gametype == GT_RACE && player->position == 1) || numplayers == 0) // No-one can be stolen from? Oh well...
@ -5091,11 +5195,11 @@ static void K_DoHyudoroSteal(player_t *player)
player->itemtype = players[stealplayer].itemtype;
player->itemamount = players[stealplayer].itemamount;
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
players[stealplayer].itemtype = KITEM_NONE;
players[stealplayer].itemamount = 0;
players[stealplayer].pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(&players[stealplayer]);
if (P_IsDisplayPlayer(&players[stealplayer]) && !r_splitscreen)
S_StartSound(NULL, sfx_s3k92);
@ -5201,9 +5305,13 @@ static void K_DoShrink(player_t *user)
if (players[i].mo && !P_MobjWasRemoved(players[i].mo))
{
players[i].mo->scalespeed = mapobjectscale/TICRATE;
players[i].mo->destscale = (6*mapobjectscale)/8;
if (cv_kartdebugshrink.value && !modeattacking && !players[i].bot)
players[i].mo->destscale = (6*players[i].mo->destscale)/8;
players[i].mo->destscale = FixedMul(mapobjectscale, SHRINK_SCALE);
if (K_PlayerShrinkCheat(&players[i]) == true)
{
players[i].mo->destscale = FixedMul(players[i].mo->destscale, SHRINK_SCALE);
}
S_StartSound(players[i].mo, sfx_kc59);
}
}
@ -5414,7 +5522,7 @@ void K_DropHnextList(player_t *player, boolean keepshields)
player->curshield = KSHIELD_NONE;
player->itemtype = KITEM_NONE;
player->itemamount = 0;
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
}
nextwork = work->hnext;
@ -5463,6 +5571,10 @@ void K_DropHnextList(player_t *player, boolean keepshields)
dropwork->angle = work->angle;
P_SetScale(dropwork, work->scale);
dropwork->destscale = work->destscale;
dropwork->scalespeed = work->scalespeed;
dropwork->flags |= MF_NOCLIPTHING;
dropwork->flags2 = work->flags2;
dropwork->eflags = work->eflags;
@ -5552,7 +5664,7 @@ void K_DropHnextList(player_t *player, boolean keepshields)
&& (dropall || (--player->itemamount <= 0)))
{
player->itemamount = 0;
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
player->itemtype = KITEM_NONE;
}
}
@ -5927,6 +6039,8 @@ static void K_CalculateBananaSlope(mobj_t *mobj, fixed_t x, fixed_t y, fixed_t z
// Move the hnext chain!
static void K_MoveHeldObjects(player_t *player)
{
fixed_t finalscale = INT32_MAX;
if (!player->mo)
return;
@ -5938,7 +6052,7 @@ static void K_MoveHeldObjects(player_t *player)
else if (player->pflags & PF_ITEMOUT)
{
player->itemamount = 0;
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
player->itemtype = KITEM_NONE;
}
return;
@ -5954,12 +6068,14 @@ static void K_MoveHeldObjects(player_t *player)
else if (player->pflags & PF_ITEMOUT)
{
player->itemamount = 0;
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
player->itemtype = KITEM_NONE;
}
return;
}
finalscale = K_ItemScaleForPlayer(player);
switch (player->mo->hnext->type)
{
case MT_ORBINAUT_SHIELD: // Kart orbit items
@ -5998,7 +6114,7 @@ static void K_MoveHeldObjects(player_t *player)
cur->eflags &= ~MFE_VERTICALFLIP;
// Shrink your items if the player shrunk too.
P_SetScale(cur, (cur->destscale = FixedMul(FixedDiv(cur->extravalue1, radius), player->mo->scale)));
P_SetScale(cur, (cur->destscale = FixedMul(FixedDiv(cur->extravalue1, radius), finalscale)));
if (P_MobjFlip(cur) > 0)
z = player->mo->z;
@ -6029,7 +6145,7 @@ static void K_MoveHeldObjects(player_t *player)
}
// Center it during the scale up animation
z += (FixedMul(mobjinfo[cur->type].height, player->mo->scale - cur->scale)>>1) * P_MobjFlip(cur);
z += (FixedMul(mobjinfo[cur->type].height, finalscale - cur->scale)>>1) * P_MobjFlip(cur);
cur->z = z;
cur->momx = cur->momy = 0;
@ -6091,7 +6207,7 @@ static void K_MoveHeldObjects(player_t *player)
continue;
// Shrink your items if the player shrunk too.
P_SetScale(cur, (cur->destscale = FixedMul(FixedDiv(cur->extravalue1, radius), player->mo->scale)));
P_SetScale(cur, (cur->destscale = FixedMul(FixedDiv(cur->extravalue1, radius), finalscale)));
ang = targ->angle;
targx = targ->x + P_ReturnThrustX(cur, ang + ANGLE_180, dist);
@ -8682,6 +8798,31 @@ static void K_trickPanelTimingVisual(player_t *player, fixed_t momz)
#undef RADIUSSCALING
#undef MINRADIUS
void K_SetItemOut(player_t *player)
{
player->pflags |= PF_ITEMOUT;
if (player->mo->scale >= FixedMul(GROW_PHYSICS_SCALE, mapobjectscale))
{
player->itemscale = ITEMSCALE_GROW;
}
else if (player->mo->scale <= FixedMul(SHRINK_PHYSICS_SCALE, mapobjectscale))
{
player->itemscale = ITEMSCALE_SHRINK;
}
else
{
player->itemscale = ITEMSCALE_NORMAL;
}
}
void K_UnsetItemOut(player_t *player)
{
player->pflags &= ~PF_ITEMOUT;
player->itemscale = ITEMSCALE_NORMAL;
player->bananadrag = 0;
}
//
// K_MoveKartPlayer
//
@ -8782,7 +8923,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
}
else if (player->itemamount == 0)
{
player->pflags &= ~PF_ITEMOUT;
K_UnsetItemOut(player);
}
else
{
@ -8857,7 +8998,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mobj_t *prev = player->mo;
//K_PlayAttackTaunt(player->mo);
player->pflags |= PF_ITEMOUT;
K_SetItemOut(player);
S_StartSound(player->mo, sfx_s254);
for (moloop = 0; moloop < player->itemamount; moloop++)
@ -8872,6 +9013,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo->threshold = 10;
mo->movecount = player->itemamount;
mo->movedir = moloop+1;
mo->cusval = player->itemscale;
P_SetTarget(&mo->target, player->mo);
P_SetTarget(&mo->hprev, prev);
P_SetTarget(&prev->hnext, mo);
@ -8901,6 +9043,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo->threshold = 10;
mo->movecount = 1;
mo->movedir = 1;
mo->cusval = player->itemscale;
P_SetTarget(&mo->target, player->mo);
P_SetTarget(&player->mo->hnext, mo);
}
@ -8915,7 +9058,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mobj_t *prev = player->mo;
//K_PlayAttackTaunt(player->mo);
player->pflags |= PF_ITEMOUT;
K_SetItemOut(player);
S_StartSound(player->mo, sfx_s3k3a);
for (moloop = 0; moloop < player->itemamount; moloop++)
@ -8933,6 +9076,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo->movecount = player->itemamount;
mo->movedir = mo->lastlook = moloop+1;
mo->color = player->skincolor;
mo->cusval = player->itemscale;
P_SetTarget(&mo->target, player->mo);
P_SetTarget(&mo->hprev, prev);
P_SetTarget(&prev->hnext, mo);
@ -8956,7 +9100,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mobj_t *prev = player->mo;
//K_PlayAttackTaunt(player->mo);
player->pflags |= PF_ITEMOUT;
K_SetItemOut(player);
S_StartSound(player->mo, sfx_s3k3a);
for (moloop = 0; moloop < player->itemamount; moloop++)
@ -8973,6 +9117,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo->threshold = 10;
mo->movecount = player->itemamount;
mo->movedir = mo->lastlook = moloop+1;
mo->cusval = player->itemscale;
P_SetTarget(&mo->target, player->mo);
P_SetTarget(&mo->hprev, prev);
P_SetTarget(&prev->hnext, mo);
@ -8994,7 +9139,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
if (ATTACK_IS_DOWN && !HOLDING_ITEM && NO_HYUDORO)
{
mobj_t *mo;
player->pflags |= PF_ITEMOUT;
K_SetItemOut(player);
S_StartSound(player->mo, sfx_s254);
mo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_SSMINE_SHIELD);
if (mo)
@ -9003,6 +9148,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo->threshold = 10;
mo->movecount = 1;
mo->movedir = 1;
mo->cusval = player->itemscale;
P_SetTarget(&mo->target, player->mo);
P_SetTarget(&player->mo->hnext, mo);
}
@ -9043,23 +9189,39 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
case KITEM_GROW:
if (ATTACK_IS_DOWN && !HOLDING_ITEM && NO_HYUDORO)
{
if (player->growshrinktimer < 0) // If you're shrunk, then "grow" will just make you normal again.
if (player->growshrinktimer < 0)
{
// If you're shrunk, then "grow" will just make you normal again.
K_RemoveGrowShrink(player);
}
else
{
K_PlayPowerGloatSound(player->mo);
player->mo->scalespeed = mapobjectscale/TICRATE;
player->mo->destscale = (3*mapobjectscale)/2;
if (cv_kartdebugshrink.value && !modeattacking && !player->bot)
player->mo->destscale = (6*player->mo->destscale)/8;
player->mo->destscale = FixedMul(mapobjectscale, GROW_SCALE);
if (K_PlayerShrinkCheat(player) == true)
{
player->mo->destscale = FixedMul(player->mo->destscale, SHRINK_SCALE);
}
player->growshrinktimer = itemtime+(4*TICRATE); // 12 seconds
if (P_IsLocalPlayer(player))
if (P_IsLocalPlayer(player) == true)
{
S_ChangeMusicSpecial("kgrow");
if (! P_IsDisplayPlayer(player))
}
if (P_IsDisplayPlayer(player) == false)
{
S_StartSound(player->mo, (cv_kartinvinsfx.value ? sfx_alarmg : sfx_kgrow));
}
P_RestoreMusic(player);
S_StartSound(player->mo, sfx_kc5a);
}
player->itemamount--;
}
break;
@ -9236,7 +9398,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
if (ATTACK_IS_DOWN && !HOLDING_ITEM && NO_HYUDORO)
{
mobj_t *mo;
player->pflags |= PF_ITEMOUT;
K_SetItemOut(player);
S_StartSound(player->mo, sfx_s254);
mo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_SINK_SHIELD);
if (mo)
@ -9245,6 +9407,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo->threshold = 10;
mo->movecount = 1;
mo->movedir = 1;
mo->cusval = player->itemscale;
P_SetTarget(&mo->target, player->mo);
P_SetTarget(&player->mo->hnext, mo);
}

13
src/k_kart.h
View file

@ -22,6 +22,12 @@ Make sure this matches the actual number of states
#define MAXHITLAGTICS 18 //12
#define HITLAGJITTERS (FRACUNIT / 20)
#define GROW_SCALE (2*FRACUNIT)
#define SHRINK_SCALE (FRACUNIT/2)
#define GROW_PHYSICS_SCALE (3*FRACUNIT/2)
#define SHRINK_PHYSICS_SCALE (3*FRACUNIT/4)
player_t *K_GetItemBoxPlayer(mobj_t *mobj);
angle_t K_ReflectAngle(angle_t angle, angle_t against, fixed_t maxspeed, fixed_t yourspeed);
@ -115,10 +121,13 @@ boolean K_WaterRun(player_t *player);
void K_ApplyTripWire(player_t *player, tripwirestate_t state);
INT16 K_GetSpindashChargeTime(player_t *player);
fixed_t K_GetSpindashChargeSpeed(player_t *player);
fixed_t K_GrowShrinkSpeedMul(player_t *player);
fixed_t K_GetKartSpeedFromStat(UINT8 kartspeed);
fixed_t K_GetKartSpeed(player_t *player, boolean doboostpower);
fixed_t K_GetKartAccel(player_t *player);
UINT16 K_GetKartFlashing(player_t *player);
boolean K_PlayerShrinkCheat(player_t *player);
void K_UpdateShrinkCheat(player_t *player);
boolean K_KartKickstart(player_t *player);
UINT16 K_GetKartButtons(player_t *player);
SINT8 K_GetForwardMove(player_t *player);
@ -141,5 +150,9 @@ void K_PlayPainSound(mobj_t *source);
void K_PlayHitEmSound(mobj_t *source);
void K_PlayPowerGloatSound(mobj_t *source);
fixed_t K_ItemScaleForPlayer(player_t *player);
void K_SetItemOut(player_t *player);
void K_UnsetItemOut(player_t *player);
// =========================================================================
#endif // __K_KART__

6
src/k_respawn.c
View file

@ -672,11 +672,11 @@ static void K_HandleDropDash(player_t *player)
if (player->growshrinktimer < 0)
{
player->mo->scalespeed = mapobjectscale/TICRATE;
player->mo->destscale = (6*mapobjectscale)/8;
player->mo->destscale = FixedMul(mapobjectscale, SHRINK_SCALE);
if (cv_kartdebugshrink.value && !modeattacking && !player->bot)
if (K_PlayerShrinkCheat(player) == true)
{
player->mo->destscale = (6*player->mo->destscale)/8;
player->mo->destscale = FixedMul(player->mo->destscale, SHRINK_SCALE);
}
}

2
src/p_enemy.c
View file

@ -14107,7 +14107,7 @@ void A_SSMineExplode(mobj_t *actor)
INT32 d;
INT32 locvar1 = var1;
mobjtype_t type;
explodedist = FixedMul((3*actor->info->painchance)/2, mapobjectscale);
explodedist = FixedMul((3*actor->info->painchance)/2, actor->scale);
if (LUA_CallAction(A_SSMINEEXPLODE, actor))
return;

7
src/p_mobj.c
View file

@ -10874,9 +10874,12 @@ void P_SpawnPlayer(INT32 playernum)
P_SetTarget(&p->follower, NULL); // cleanse follower from existence
if (K_PlayerShrinkCheat(p) == true)
{
mobj->destscale = FixedMul(mobj->destscale, SHRINK_SCALE);
}
// set the scale to the mobj's destscale so settings get correctly set. if we don't, they sometimes don't.
if (cv_kartdebugshrink.value && !modeattacking && !p->bot)
mobj->destscale = 6*mobj->destscale/8;
P_SetScale(mobj, mobj->destscale);
P_FlashPal(p, 0, 0); // Resets

1
src/p_setup.c
View file

@ -3465,6 +3465,7 @@ static void P_InitLevelSettings(void)
players[i].lives = 3;
G_PlayerReborn(i, true);
K_UpdateShrinkCheat(&players[i]);
}
racecountdown = exitcountdown = exitfadestarted = 0;