incidentalstoat/blankart
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove tumble.

Browse source
This commit is contained in:
NepDisk 2024-07-29 03:40:28 -04:00
parent 8f3b2db7d3
commit 48871a8b68
14 changed files with 13 additions and 282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/d_player.h
View file

@ -93,8 +93,8 @@ typedef enum
PF_AIRFAILSAFE = 1<<22, // Whenever or not try the air boost
PF_TRICKDELAY = 1<<23, // Prevent tricks until control stick is neutral
PF_TUMBLELASTBOUNCE = 1<<24, // One more time for the funny
PF_TUMBLESOUND = 1<<25, // Don't play more than once
//free = 1<<24,
//free = 1<<25,
PF_HITFINISHLINE = 1<<26, // Already hit the finish line this tic
PF_WRONGWAY = 1<<27, // Moving the wrong way with respect to waypoints?
@ -265,9 +265,6 @@ typedef enum
#define TRICKLAG (9)
#define TRICKDELAY (TICRATE/4)
#define TUMBLEBOUNCES 3
#define TUMBLEGRAVITY (4*FRACUNIT)
#define TRIPWIRETIME (TICRATE)
//}
@ -415,8 +412,6 @@ typedef struct player_s
UINT8 instashield; // Instashield no-damage animation timer
UINT8 wipeoutslow; // Timer before you slowdown when getting wiped out
UINT8 justbumped; // Prevent players from endlessly bumping into each other
UINT8 tumbleBounces;
UINT16 tumbleHeight; // In *mobjscaled* fracunits, or mfu, not raw fu
UINT8 justDI; // Turn-lockout timer to briefly prevent unintended turning after DI, resets when actionable or no input
boolean flipDI; // Bananas flip the DI direction. Was a bug, but it made bananas much more interesting.

4
src/deh_tables.c
View file

@ -5710,9 +5710,6 @@ const char *const PLAYERFLAG_LIST[] = {
"AIRFAILSAFE", // Whenever or not try the air boost
"TRICKDELAY", // Prevent tricks until control stick is neutral
"TUMBLELASTBOUNCE", // One more time for the funny
"TUMBLESOUND", // Don't play more than once
"HITFINISHLINE", // Already hit the finish line this tic
"WRONGWAY", // Moving the wrong way with respect to waypoints?
@ -6353,7 +6350,6 @@ struct int_const_s const INT_CONST[] = {
{"DMG_NORMAL",DMG_NORMAL},
{"DMG_WIPEOUT",DMG_WIPEOUT},
{"DMG_EXPLODE",DMG_EXPLODE},
{"DMG_TUMBLE",DMG_TUMBLE},
{"DMG_STING",DMG_STING},
{"DMG_KARMA",DMG_KARMA},
//// Death types

6
src/k_collide.c
View file

@ -466,7 +466,7 @@ boolean K_LandMineCollide(mobj_t *t1, mobj_t *t2)
else
{
// Player Damage
P_DamageMobj(t2, t1, t1->target, 1, DMG_TUMBLE);
P_DamageMobj(t2, t1, t1->target, 1, DMG_EXPLODE);
}
P_KillMobj(t1, t2, t2, DMG_NORMAL);
@ -852,12 +852,12 @@ boolean K_PvPTouchDamage(mobj_t *t1, mobj_t *t2)
}
else if (t1Condition == true && t2Condition == false)
{
P_DamageMobj(t2, t1, t1, 1, DMG_TUMBLE);
P_DamageMobj(t2, t1, t1, 1, DMG_WIPEOUT);
return true;
}
else if (t1Condition == false && t2Condition == true)
{
P_DamageMobj(t1, t2, t2, 1, DMG_TUMBLE);
P_DamageMobj(t1, t2, t2, 1, DMG_WIPEOUT);
return true;
}

173
src/k_kart.c
View file

@ -3596,139 +3596,6 @@ static void K_RemoveGrowShrink(player_t *player)
P_RestoreMusic(player);
}
static fixed_t K_TumbleZ(mobj_t *mo, fixed_t input)
{
// Scales base tumble gravity to FRACUNIT
const fixed_t baseGravity = FixedMul(DEFAULT_GRAVITY, TUMBLEGRAVITY);
// Adapt momz w/ gravity
fixed_t gravityAdjust = FixedDiv(P_GetMobjGravity(mo), baseGravity);
if (mo->eflags & MFE_UNDERWATER)
{
// Reverse doubled falling speed.
gravityAdjust /= 2;
}
return FixedMul(input, -gravityAdjust);
}
void K_TumblePlayer(player_t *player, mobj_t *inflictor, mobj_t *source)
{
(void)source;
K_DirectorFollowAttack(player, inflictor, source);
player->tumbleBounces = 1;
if (player->tripwireState == TRIPSTATE_PASSED)
{
player->tumbleHeight = 50;
}
else
{
player->mo->momx = 2 * player->mo->momx / 3;
player->mo->momy = 2 * player->mo->momy / 3;
player->tumbleHeight = 30;
}
player->pflags &= ~PF_TUMBLESOUND;
if (inflictor && !P_MobjWasRemoved(inflictor))
{
const fixed_t addHeight = FixedHypot(FixedHypot(inflictor->momx, inflictor->momy) / 2, FixedHypot(player->mo->momx, player->mo->momy) / 2);
player->tumbleHeight += (addHeight / player->mo->scale);
}
S_StartSound(player->mo, sfx_s3k9b);
player->mo->momz = K_TumbleZ(player->mo, player->tumbleHeight * FRACUNIT);
P_SetPlayerMobjState(player->mo, S_KART_SPINOUT);
if (P_IsDisplayPlayer(player))
P_StartQuake(64<<FRACBITS, 10);
}
static boolean K_LastTumbleBounceCondition(player_t *player)
{
return (player->tumbleBounces > TUMBLEBOUNCES && player->tumbleHeight < 60);
}
static void K_HandleTumbleBounce(player_t *player)
{
player->tumbleBounces++;
player->tumbleHeight = (player->tumbleHeight * ((player->tumbleHeight > 100) ? 3 : 4)) / 5;
player->pflags &= ~PF_TUMBLESOUND;
if (player->tumbleHeight < 10)
{
// 10 minimum bounce height
player->tumbleHeight = 10;
}
if (K_LastTumbleBounceCondition(player))
{
// Leave tumble state when below 40 height, and have bounced off the ground enough
if (player->pflags & PF_TUMBLELASTBOUNCE)
{
// End tumble state
player->tumbleBounces = 0;
player->pflags &= ~PF_TUMBLELASTBOUNCE; // Reset for next time
return;
}
else
{
// One last bounce at the minimum height, to reset the animation
player->tumbleHeight = 10;
player->pflags |= PF_TUMBLELASTBOUNCE;
player->mo->rollangle = 0; // p_user.c will stop rotating the player automatically
}
}
if (P_IsDisplayPlayer(player) && player->tumbleHeight >= 40)
P_StartQuake((player->tumbleHeight*3/2)<<FRACBITS, 6); // funny earthquakes for the FEEL
S_StartSound(player->mo, (player->tumbleHeight < 40) ? sfx_s3k5d : sfx_s3k5f); // s3k5d is bounce < 50, s3k5f otherwise!
player->mo->momx = player->mo->momx / 2;
player->mo->momy = player->mo->momy / 2;
// and then modulate momz like that...
player->mo->momz = K_TumbleZ(player->mo, player->tumbleHeight * FRACUNIT);
}
// Play a falling sound when you start falling while tumbling and you're nowhere near done bouncing
static void K_HandleTumbleSound(player_t *player)
{
fixed_t momz;
momz = player->mo->momz * P_MobjFlip(player->mo);
if (!K_LastTumbleBounceCondition(player) &&
!(player->pflags & PF_TUMBLESOUND) && momz < -10*player->mo->scale)
{
S_StartSound(player->mo, sfx_s3k51);
player->pflags |= PF_TUMBLESOUND;
}
}
void K_TumbleInterrupt(player_t *player)
{
// If player was tumbling, set variables so that they don't tumble like crazy after they're done respawning
if (player->tumbleBounces > 0)
{
player->tumbleBounces = 0; // MAXBOUNCES-1;
player->pflags &= ~PF_TUMBLELASTBOUNCE;
//players->tumbleHeight = 20;
players->mo->rollangle = 0;
player->spinouttype = KSPIN_WIPEOUT;
player->spinouttimer = player->wipeoutslow = TICRATE+2;
}
}
void K_ApplyTripWire(player_t *player, tripwirestate_t state)
{
if (state == TRIPSTATE_PASSED)
@ -3737,12 +3604,6 @@ void K_ApplyTripWire(player_t *player, tripwirestate_t state)
S_StartSound(player->mo, sfx_kc40);
player->tripwireState = state;
if (state == TRIPSTATE_PASSED && player->spinouttimer &&
player->speed > 2 * K_GetKartSpeed(player, false, true))
{
K_TumblePlayer(player, NULL, NULL);
}
}
INT32 K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source) // A bit of a hack, we just throw the player up higher here and extend their spinout timer
@ -7533,13 +7394,6 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
if (player->tiregrease)
player->tiregrease--;
if (player->tumbleBounces > 0)
{
K_HandleTumbleSound(player);
if (P_IsObjectOnGround(player->mo) && player->mo->momz * P_MobjFlip(player->mo) <= 0)
K_HandleTumbleBounce(player);
}
K_UpdateTripwire(player);
K_KartPlayerHUDUpdate(player);
@ -9417,7 +9271,6 @@ void K_AdjustPlayerFriction(player_t *player)
// K_trickPanelTimingVisual
// Spawns the timing visual for trick panels depending on the given player's momz.
// If the player has tricked, this will send the half circles flying out.
// if you tumble, they'll fall off instead.
//
#define RADIUSSCALING 6
@ -9452,14 +9305,6 @@ static void K_trickPanelTimingVisual(player_t *player, fixed_t momz)
flame->sprite = SPR_TRCK;
flame->frame = i|FF_FULLBRIGHT;
if (player->trickpanel <= 1 && !player->tumbleBounces)
{
flame->tics = 2;
flame->momx = player->mo->momx;
flame->momy = player->mo->momy;
flame->momz = player->mo->momz;
}
else
{
flame->tics = TICRATE;
@ -10280,18 +10125,8 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
// debug shit
//CONS_Printf("%d\n", player->mo->momz / mapobjectscale);
if (momz < -10*FRACUNIT) // :youfuckedup:
{
// tumble if you let your chance pass!!
player->tumbleBounces = 1;
player->pflags &= ~PF_TUMBLESOUND;
player->tumbleHeight = 30; // Base tumble bounce height
player->trickpanel = 0;
K_trickPanelTimingVisual(player, momz); // fail trick visual
P_SetPlayerMobjState(player->mo, S_KART_SPINOUT);
}
else if (!(player->pflags & PF_TRICKDELAY)) // don't allow tricking at the same frame you tumble obv
else if (!(player->pflags & PF_TRICKDELAY)) // don't allow tricking
{
INT16 aimingcompare = abs(cmd->throwdir) - abs(cmd->turning);
@ -10589,12 +10424,6 @@ void K_HandleDirectionalInfluence(player_t *player)
inputLen = KART_FULLTURN;
}
if (player->tumbleBounces > 0)
{
// Very strong DI for tumble.
strength *= 3;
}
sideAngle = player->mo->angle - ANGLE_90;
diX = FixedMul(inputX, FINECOSINE(player->mo->angle >> ANGLETOFINESHIFT)) + FixedMul(inputY, FINECOSINE(sideAngle >> ANGLETOFINESHIFT));

2
src/k_kart.h
View file

@ -67,8 +67,6 @@ void K_DoInstashield(player_t *player);
void K_DoPowerClash(player_t *t1, player_t *t2);
void K_BattleAwardHit(player_t *player, player_t *victim, mobj_t *inflictor, UINT8 bumpersRemoved);
void K_SpinPlayer(player_t *player, mobj_t *inflictor, mobj_t *source, INT32 type);
void K_TumblePlayer(player_t *player, mobj_t *inflictor, mobj_t *source);
void K_TumbleInterrupt(player_t *player);
INT32 K_ExplodePlayer(player_t *player, mobj_t *inflictor, mobj_t *source);
void K_DebtStingPlayer(player_t *player, mobj_t *source);
void K_HandleBumperChanges(player_t *player, UINT8 prevBumpers);

3
src/k_respawn.c
View file

@ -151,8 +151,7 @@ void K_DoIngameRespawn(player_t *player)
player->ringboost = 0;
player->driftboost = player->strongdriftboost = 0;
K_TumbleInterrupt(player);
P_ResetPlayer(player);
// Set up respawn position if invalid

17
src/lua_baselib.c
View file

@ -3485,22 +3485,6 @@ static int lib_kSpinPlayer(lua_State *L)
return 0;
}
static int lib_kTumblePlayer(lua_State *L)
{
player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
mobj_t *inflictor = NULL;
mobj_t *source = NULL;
NOHUD
if (!player)
return LUA_ErrInvalid(L, "player_t");
if (!lua_isnone(L, 2) && lua_isuserdata(L, 2))
inflictor = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
if (!lua_isnone(L, 3) && lua_isuserdata(L, 3))
source = *((mobj_t **)luaL_checkudata(L, 3, META_MOBJ));
K_TumblePlayer(player, inflictor, source);
return 0;
}
static int lib_kExplodePlayer(lua_State *L)
{
player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
@ -4046,7 +4030,6 @@ static luaL_Reg lib[] = {
{"K_DoInstashield",lib_kDoInstashield},
{"K_SpawnBattlePoints",lib_kSpawnBattlePoints},
{"K_SpinPlayer",lib_kSpinPlayer},
{"K_TumblePlayer",lib_kTumblePlayer},
{"K_ExplodePlayer",lib_kExplodePlayer},
{"K_TakeBumpersFromPlayer",lib_kTakeBumpersFromPlayer},
{"K_SpawnMineExplosion",lib_kSpawnMineExplosion},

8
src/lua_playerlib.c
View file

@ -234,10 +234,6 @@ static int player_get(lua_State *L)
lua_pushinteger(L, plr->wipeoutslow);
else if (fastcmp(field,"justbumped"))
lua_pushinteger(L, plr->justbumped);
else if (fastcmp(field,"tumbleBounces"))
lua_pushinteger(L, plr->tumbleBounces);
else if (fastcmp(field,"tumbleHeight"))
lua_pushinteger(L, plr->tumbleHeight);
else if (fastcmp(field,"justDI"))
lua_pushinteger(L, plr->justDI);
else if (fastcmp(field,"flipDI"))
@ -596,10 +592,6 @@ static int player_set(lua_State *L)
plr->wipeoutslow = luaL_checkinteger(L, 3);
else if (fastcmp(field,"justbumped"))
plr->justbumped = luaL_checkinteger(L, 3);
else if (fastcmp(field,"tumbleBounces"))
plr->tumbleBounces = luaL_checkinteger(L, 3);
else if (fastcmp(field,"tumbleHeight"))
plr->tumbleHeight = luaL_checkinteger(L, 3);
else if (fastcmp(field,"justDI"))
plr->justDI = luaL_checkinteger(L, 3);
else if (fastcmp(field,"flipDI"))

14
src/p_inter.c
View file

@ -1896,7 +1896,7 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
else
{
const UINT8 type = (damagetype & DMG_TYPEMASK);
const boolean hardhit = (type == DMG_EXPLODE || type == DMG_KARMA || type == DMG_TUMBLE); // This damage type can do evil stuff like ALWAYS combo
const boolean hardhit = (type == DMG_EXPLODE || type == DMG_KARMA); // This damage type can do evil stuff like ALWAYS combo
INT16 ringburst = 5;
// Check if the player is allowed to be damaged!
@ -1933,14 +1933,6 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
// Check if we should allow wombo combos (hard hits by default, inverted by the presence of DMG_WOMBO).
boolean allowcombo = (hardhit == !(damagetype & DMG_WOMBO));
// Tumble is a special case.
if (type == DMG_TUMBLE)
{
// don't allow constant combo
if (player->tumbleBounces == 1 && (P_MobjFlip(target)*target->momz > 0))
allowcombo = false;
}
if ((allowcombo == false) && player->flashing > 0)
{
// Post-hit invincibility
@ -2036,10 +2028,6 @@ boolean P_DamageMobj(mobj_t *target, mobj_t *inflictor, mobj_t *source, INT32 da
K_KartPainEnergyFling(player);
ringburst = 0;
break;
case DMG_TUMBLE:
K_TumblePlayer(player, inflictor, source);
ringburst = 10;
break;
case DMG_EXPLODE:
case DMG_KARMA:
ringburst = K_ExplodePlayer(player, inflictor, source);

2
src/p_local.h
View file

@ -481,7 +481,7 @@ typedef struct BasicFF_s
#define DMG_NORMAL 0x00
#define DMG_WIPEOUT 0x01 // Normal, but with extra flashy effects
#define DMG_EXPLODE 0x02
#define DMG_TUMBLE 0x03
//#define DMG_SQUISH 0x03
#define DMG_STING 0x04
#define DMG_KARMA 0x05 // Karma Bomb explosion -- works like DMG_EXPLODE, but steals half of their bumpers & deletes the rest
//// Death types - cannot be combined with damage types

15
src/p_map.c
View file

@ -417,7 +417,6 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
P_SetTarget(&spring->target, object);
}
K_TumbleInterrupt(object->player);
P_ResetPlayer(object->player);
object->player->springstars = max(vertispeed, horizspeed) / FRACUNIT / 2;
@ -453,18 +452,6 @@ boolean P_DoSpring(mobj_t *spring, mobj_t *object)
object->player->trickpanel = 1;
object->player->pflags |= PF_TRICKDELAY;
}
else
{
raisestate = spring->info->seestate;
object->player->tumbleBounces = 1;
object->player->pflags &= ~PF_TUMBLESOUND;
object->player->tumbleHeight = 50;
P_SetPlayerMobjState(object->player->mo, S_KART_SPINOUT);
// FIXME: try to compensate tumbling gravity
object->momz = 3 * object->momz / 2;
}
spring->reactiontime++;
}
@ -1357,7 +1344,7 @@ static BlockItReturn_t PIT_CheckThing(mobj_t *thing)
// collide
if (tmthing->z < thing->z && thing->momz < 0)
P_DamageMobj(tmthing, thing, thing, 1, DMG_TUMBLE);
;//P_DamageMobj(tmthing, thing, thing, 1, DMG_SQUISH);
else
{
if ((K_KartSolidBounce(tmthing, thing) == true) && (thing->flags2 & MF2_AMBUSH))

7
src/p_mobj.c
View file

@ -1128,11 +1128,6 @@ fixed_t P_GetMobjGravity(mobj_t *mo)
gravityadd = (5*gravityadd)/2;
}
if (mo->player->tumbleBounces > 0)
{
gravityadd = FixedMul(TUMBLEGRAVITY, gravityadd);
}
if (mo->player->fastfall != 0)
{
// Fast falling
@ -2777,7 +2772,7 @@ void P_PlayerZMovement(mobj_t *mo)
K_UpdateMobjTerrain(mo, (mo->eflags & MFE_VERTICALFLIP ? tmceilingpic : tmfloorpic));
// Get up if you fell.
if (mo->player->panim == PA_HURT && mo->player->spinouttimer == 0 && mo->player->tumbleBounces == 0)
if (mo->player->panim == PA_HURT && mo->player->spinouttimer == 0)
{
P_SetPlayerMobjState(mo, S_KART_STILL);
}

4
src/p_saveg.c
View file

@ -251,8 +251,6 @@ static void P_NetArchivePlayers(void)
WRITEUINT8(save_p, players[i].instashield);
WRITEUINT8(save_p, players[i].wipeoutslow);
WRITEUINT8(save_p, players[i].justbumped);
WRITEUINT8(save_p, players[i].tumbleBounces);
WRITEUINT16(save_p, players[i].tumbleHeight);
WRITEUINT8(save_p, players[i].justDI);
WRITEUINT8(save_p, players[i].flipDI);
@ -536,8 +534,6 @@ static void P_NetUnArchivePlayers(void)
players[i].instashield = READUINT8(save_p);
players[i].wipeoutslow = READUINT8(save_p);
players[i].justbumped = READUINT8(save_p);
players[i].tumbleBounces = READUINT8(save_p);
players[i].tumbleHeight = READUINT16(save_p);
players[i].justDI = READUINT8(save_p);
players[i].flipDI = (boolean)READUINT8(save_p);

31
src/p_user.c
View file

@ -453,7 +453,7 @@ UINT8 P_FindHighestLap(void)
//
boolean P_PlayerInPain(player_t *player)
{
if (player->spinouttimer || (player->tumbleBounces > 0) || (player->pflags & PF_FAULT))
if (player->spinouttimer || (player->pflags & PF_FAULT))
return true;
return false;
@ -2153,34 +2153,7 @@ void P_MovePlayer(player_t *player)
player->justDI = 0;
}
// Kart frames
if (player->tumbleBounces > 0)
{
fixed_t playerSpeed = P_AproxDistance(player->mo->momx, player->mo->momy); // maybe momz too?
const UINT8 minSpinSpeed = 4;
UINT8 spinSpeed = max(minSpinSpeed, min(8 + minSpinSpeed, (playerSpeed / player->mo->scale) * 2));
UINT8 rollSpeed = max(1, min(8, player->tumbleHeight / 10));
if (player->pflags & PF_TUMBLELASTBOUNCE)
spinSpeed = 2;
P_SetPlayerMobjState(player->mo, S_KART_SPINOUT);
player->drawangle -= (ANGLE_11hh * spinSpeed);
player->mo->rollangle -= (ANGLE_11hh * rollSpeed);
if (player->pflags & PF_TUMBLELASTBOUNCE)
{
if (abs((signed)(player->mo->angle - player->drawangle)) < ANGLE_22h)
player->drawangle = player->mo->angle;
if (abs((signed)player->mo->rollangle) < ANGLE_22h)
player->mo->rollangle = 0;
}
}
else if (player->carry == CR_SLIDING)
if (player->carry == CR_SLIDING)
{
P_SetPlayerMobjState(player->mo, S_KART_SPINOUT);
player->drawangle -= ANGLE_22h;