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

Alright, take it or leave it

Browse source
This commit is contained in:
GenericHeroGuy 2026-02-08 01:05:54 +01:00
parent 38f9419fc2
commit d738ad5957
6 changed files with 40 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/d_main.cpp
View file

@ -93,7 +93,7 @@
#define ASSET_HASH_TEXTURES_KART 0xb4211b2f32b6a291
#define ASSET_HASH_CHARS_KART 0x1e68a3e01aa5c68b
#define ASSET_HASH_MAPS_KART 0x38558ed00da41ce9
#define ASSET_HASH_MAIN_PK3 0x0000000000000000
#define ASSET_HASH_MAIN_PK3 0xc3e04c64e2048a84
#define ASSET_HASH_MAPPATCH_PK3 0xbbc2c6a7a685da3a
#define ASSET_HASH_BONUSCHARS_KART 0x60e6f13d822a7461
#ifdef USE_PATCH_FILE

3
src/d_player.h
View file

@ -688,9 +688,8 @@ struct player_t
UINT8 ringvolume; // When consuming lots of rings, lower the sound a little.
UINT8 ringtransparency; // When consuming lots of rings, fade out the rings again.
INT32 airdroppredelay; // In light airdrop, handles the delay before it can be activated once going airborne.
INT32 airdroppredelay; // Handles the delay before airdrop can be activated once going airborne.
INT32 airdroptime; // Tracks how long the player has been in airdrop.
INT32 airdropbuffer; // Time during which heavy air drop will instantly trigger upon going airborne.
p_airdropflags_t airdropflags; // Airdrop-exclusive bitflags.
mobj_t *shieldtracer; // Blankart: Shield mobj

95
src/k_kart.c
View file

@ -5003,6 +5003,7 @@ void K_DoSneaker(player_t *player, INT32 type)
void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound)
{
fixed_t objscale = mo->scale;
boolean airdropbounce = false;
if (mo->player)
{
@ -5011,6 +5012,9 @@ void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound)
// so the game handles springs as such.
// Alt. Shrink *especially* needs this change!
objscale = max(mo->scale, mapobjectscale);
// sproing!
airdropbounce = mo->player->airdropflags & PAF_AIRDROP_HEAVY;
}
const fixed_t vscale = mapobjectscale + (objscale - mapobjectscale);
@ -5048,6 +5052,8 @@ void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound)
else if (mo->player->flamestore)
thrust = FixedMul(thrust, 9*FRACUNIT/8);
}
if (airdropbounce)
thrust *= 2;
}
else
{
@ -5067,7 +5073,7 @@ void K_DoPogoSpring(mobj_t *mo, fixed_t vertispeed, UINT8 sound)
mo->momz = (117 * mo->momz) / 200;
if (sound)
S_StartSound(mo, (sound == 1 ? sfx_kc2f : sfx_kpogos));
S_StartSound(mo, sound == 1 ? (airdropbounce ? sfx_sprong : sfx_kc2f) : sfx_kpogos);
}
void K_ResetPogoSpring(player_t *player)
@ -6998,32 +7004,18 @@ static void K_AirDrop(player_t *player, ticcmd_t *cmd)
const INT32 heavydrophi = TICRATE/3;
const INT32 airbrakedelay = TICRATE/3;
if (player->airdropbuffer > 0)
{
player->airdropbuffer--;
}
if ((cmd->buttons & BT_BRAKE))
{
if (!(player->airdropflags & PAF_AIRDROPINPUT))
{
player->airdropflags |= PAF_WANTSAIRDROP|PAF_AIRDROPINPUT;
if (P_IsObjectOnGround(player->mo))
player->airdropbuffer = 2;
}
// don't buffer heavy airdrops on the ground to prevent silly mistakes
if ((!P_IsObjectOnGround(player->mo) && !(player->airdropflags & PAF_AIRDROPINPUT))
|| (airdropactive != AIRDROP_HEAVY && !(airdropactive == AIRDROP_FUSION && !(cmd->buttons & BT_ACCELERATE))))
player->airdropflags |= PAF_WANTSAIRDROP;
player->airdropflags |= PAF_AIRDROPINPUT;
}
else
{
player->airdropflags &= ~PAF_AIRDROPINPUT;
if (airdropactive == AIRDROP_LIGHT || airdropactive == AIRDROP_FUSION)
{
player->airdropflags &= ~PAF_WANTSAIRDROP;
}
}
if (P_IsObjectOnGround(player->mo) && player->airdropbuffer == 0)
{
player->airdropflags &= ~PAF_WANTSAIRDROP;
player->airdropflags &= ~(PAF_WANTSAIRDROP|PAF_AIRDROPINPUT);
}
if (!(player->airdropflags & PAF_AIRDROP_HEAVY))
@ -7038,21 +7030,11 @@ static void K_AirDrop(player_t *player, ticcmd_t *cmd)
player->karthud[khud_postdropcam]--;
}
if (K_AirDropActive() && P_IsObjectOnGround(player->mo))
if (K_AirDropActive() && P_IsObjectOnGround(player->mo) && player->pogospring == 0)
{
if ((player->airdropflags & PAF_AIRDROP_HEAVY))
{
if (player->rings > 0 && player->airdroptime > TICRATE/4)
{
P_PlayerRingBurst(player, min(2, player->rings));
}
if (player->airdroptime > 1)
{
player->startboost = TICRATE/4 + min(TICRATE, ((FixedDiv(player->airdroptime, TICRATE) * TICRATE) / FRACUNIT));
// Take off!
S_StartSound(player->mo, sfx_shrpgo);
}
P_PlayerRingBurst(player, CLAMP(player->rings, 0, 3));
// POOMP!
S_StartSound(player->mo, sfx_doord2);
@ -7063,7 +7045,7 @@ static void K_AirDrop(player_t *player, ticcmd_t *cmd)
if (!K_AirDropActive() || P_IsObjectOnGround(player->mo)
|| P_PlayerInPain(player) || player->loop.radius
|| (player->mo->tracer && player->mo->tracer->type == MT_TUBEWAYPOINT)
|| player->carry == CR_ZOOMTUBE
|| player->respawn
)
{
@ -7075,7 +7057,10 @@ static void K_AirDrop(player_t *player, ticcmd_t *cmd)
if (player->airdropflags & PAF_WANTSAIRDROP)
{
if ((airdropactive == AIRDROP_LIGHT) || (airdropactive == AIRDROP_FUSION && (cmd->buttons & BT_ACCELERATE)))
if (player->airdroppredelay < airbrakedelay)
{
}
else if ((airdropactive == AIRDROP_LIGHT) || (airdropactive == AIRDROP_FUSION && (cmd->buttons & BT_ACCELERATE)))
{
player->airdropflags |= PAF_AIRDROP_LIGHT;
}
@ -7083,7 +7068,6 @@ static void K_AirDrop(player_t *player, ticcmd_t *cmd)
{
player->airdropflags |= PAF_AIRDROP_HEAVY;
player->airdroptime = 0;
player->airdropbuffer = 0;
// TODO: heavy air drop should allow keeping current boost stack
S_StartSound(player->mo, sfx_s3k77);
@ -7091,47 +7075,38 @@ static void K_AirDrop(player_t *player, ticcmd_t *cmd)
player->mo->momx = FixedMul(player->mo->momx, 90*FRACUNIT/100);
player->mo->momy = FixedMul(player->mo->momy, 90*FRACUNIT/100);
player->mo->momz -= 12*P_MobjFlip(player->mo)*mapobjectscale;
player->mo->momz -= 8*P_MobjFlip(player->mo)*mapobjectscale;
}
}
else
{
if (airdropactive == AIRDROP_LIGHT || airdropactive == AIRDROP_FUSION)
{
player->airdropflags &= ~PAF_AIRDROP_LIGHT;
if (!(player->airdropflags & PAF_AIRDROP_HEAVY))
player->airdroptime = 0;
}
player->airdropflags &= ~PAF_AIRDROP_LIGHT;
if (!(player->airdropflags & PAF_AIRDROP_HEAVY))
player->airdroptime = 0;
}
// heavy air drop always overrides light air drop
if (player->airdropflags & PAF_AIRDROP_HEAVY)
{
K_SpawnFallLines(player, false);
if (player->airdroptime <= heavydrophi)
{
player->mo->momz -= FixedMul(5*gravity, mapobjectscale)*P_MobjFlip(player->mo);
K_SpawnAirdropTrail(player);
}
else
{
player->mo->momz -= FixedMul(2*gravity, mapobjectscale)*P_MobjFlip(player->mo);
}
const boolean high = player->airdroptime <= heavydrophi/* && player->airdropflags & PAF_AIRDROPINPUT*/;
player->mo->momx = FixedMul(player->mo->momx, (high ? 98 : 99)*FRACUNIT/100);
player->mo->momy = FixedMul(player->mo->momy, (high ? 98 : 99)*FRACUNIT/100);
player->mo->momz -= FixedMul((high ? 4 : 2)*gravity, mapobjectscale)*P_MobjFlip(player->mo);
K_SpawnFallLines(player, high);
if (player->karthud[khud_heavydropcam] < TICRATE)
player->karthud[khud_heavydropcam]++;
K_SpawnAirdropTrail(player);
player->airdroptime++;
}
else if (player->airdropflags & PAF_AIRDROP_LIGHT)
{
if (player->airdroppredelay >= airbrakedelay)
{
player->mo->momz -= FixedMul(gravity, mapobjectscale)*P_MobjFlip(player->mo);
K_SpawnFallLines(player, false);
K_SpawnAirdropTrail(player);
}
player->mo->momz -= FixedMul(gravity, mapobjectscale)*P_MobjFlip(player->mo);
K_SpawnFallLines(player, false);
if (leveltime & 1)
K_SpawnAirdropTrail(player);
player->airdroptime++;
}

14
src/lua_playerlib.c
View file

@ -392,9 +392,7 @@ static int lib_lenLocalplayers(lua_State *L)
X(ringtransparency) \
X(airdroppredelay) \
X(airdroptime) \
X(airdropbuffer) \
X(airdropflags) \
X(ringdrop) \
X(shieldtracer) \
X(bubblecool) \
X(bubbleblowup) \
@ -838,15 +836,9 @@ static int player_get(lua_State *L)
case player_airdroptime:
lua_pushinteger(L, plr->airdroptime);
break;
case player_airdropbuffer:
lua_pushinteger(L, plr->airdropbuffer);
break;
case player_airdropflags:
lua_pushinteger(L, plr->airdropflags);
break;
/*case player_ringdrop:
lua_pushinteger(L, plr->ringdrop);
break;*/
case player_shieldtracer:
LUA_PushUserdata(L, plr->shieldtracer, META_MOBJ);
break;
@ -1628,15 +1620,9 @@ static int player_set(lua_State *L)
case player_airdroptime:
plr->airdroptime = luaL_checkinteger(L, 3);
break;
case player_airdropbuffer:
plr->airdropbuffer = luaL_checkinteger(L, 3);
break;
case player_airdropflags:
plr->airdropflags = luaL_checkinteger(L, 3);
break;
/*case player_ringdrop:
plr->ringdrop = luaL_checkinteger(L, 3);
break;*/
case player_shieldtracer:
return NOSET;
case player_bubblecool:

22
src/p_enemy.c
View file

@ -3229,28 +3229,12 @@ void A_AttractChase(void *thing)
if (actor->extravalue1 >= 21)
{
/*if (actor->extravalue3 && !P_IsObjectOnGround(actor->target))
{
actor->target->momz -= (FixedMul(gravity, mapobjectscale))*P_MobjFlip(actor->target);
actor->target->player->ringboost += 7;
actor->target->player->ringtime += 7;
actor->target->player->ringdrop = true;
}
else*/
{
// Base add is 4 tics for 9,9, adds 1 tic for each point closer to the 1,1 end
actor->target->player->ringboost += K_GetKartRingPower(actor->target->player, true);
actor->target->player->ringtime += K_GetKartRingPower(actor->target->player, true);
}
// Base add is 4 tics for 9,9, adds 1 tic for each point closer to the 1,1 end
actor->target->player->ringboost += K_GetKartRingPower(actor->target->player, true);
actor->target->player->ringtime += K_GetKartRingPower(actor->target->player, true);
S_StartSoundAtVolume(actor->target, sfx_s1b5, actor->target->player->ringvolume);
if (actor->extravalue3 && !P_IsObjectOnGround(actor->target))
{
actor->target->momz -= (FixedMul(gravity, mapobjectscale)/2 + FixedMul(gravity, mapobjectscale)/4)*P_MobjFlip(actor->target);
}
if (actor->target->player->rings <= 10)
{
S_StartSoundAtVolume(actor->target, sfx_ringlw, 255 - actor->target->player->rings*10);

1
src/p_saveg.c
View file

@ -714,7 +714,6 @@ static void P_NetSyncPlayers(savebuffer_t *save)
SYNC(players[i].airdroppredelay);
SYNC(players[i].airdroptime);
SYNC(players[i].airdropbuffer);
SYNC(players[i].airdropflags);
RSYNC(players[i].shieldtracer);