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

De-jank all existing calls to K_FlipFromObject/K_MatchGenericExtraFlags

Browse source 
- New funcs K_MatchFlipFlags, K_FlipFromObjectNoInterp, K_MatchGenericExtraFlagsNoInterp
- Renamed K_GenericExtraFlagsNoZAdjust to K_MatchGenericExtraFlagsNoZAdjust
- Went over each individual spot that called any of this suite to figure out what they actually wanted, and give it to them without having to work around a bad function
- I'm 95% confident there's no regressions, but I don't think I'll get that 5% by testing internally. Might just have to hand this out with RC2 with an asterisk in the changelog
This commit is contained in:
toaster 2025-09-16 23:18:02 +01:00
parent c69d162775
commit 4bc99d3806
16 changed files with 221 additions and 212 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/k_battle.c
View file

@ -620,12 +620,12 @@ void K_RunPaperItemSpawners(void)
flip = P_MobjFlip(spotList[r]);
drop = K_SpawnSphereBox(
spotList[r]->x, spotList[r]->y, spotList[r]->z + (128 * mapobjectscale * flip),
spotList[r]->x, spotList[r]->y, spotList[r]->z + (128 * mapobjectscale),
FixedAngle(P_RandomRange(PR_ITEM_SPAWNER, 0, 359) * FRACUNIT), flip,
10
);
K_FlipFromObject(drop, spotList[r]);
K_FlipFromObjectNoInterp(drop, spotList[r]);
spotCount--;
if (key != spotCount)

8
src/k_follower.c
View file

@ -516,7 +516,7 @@ void K_HandleFollower(player_t *player)
player->follower->colorized = player->mo->colorized;
P_SetScale(player->follower, FixedMul(fl->scale, player->mo->scale));
K_GenericExtraFlagsNoZAdjust(player->follower, player->mo); // Not K_MatchGenericExtraFlag because the Z adjust it has only works properly if master & mo have the same Z height.
K_MatchGenericExtraFlagsNoZAdjust(player->follower, player->mo); // Not K_MatchGenericExtraFlag because the Z adjust it has only works properly if master & mo have the same Z height.
// Match how the player is being drawn
player->follower->renderflags = player->mo->renderflags;
@ -623,7 +623,7 @@ void K_HandleFollower(player_t *player)
P_MoveOrigin(bmobj, player->follower->x, player->follower->y, player->follower->z);
P_SetScale(bmobj, FixedMul(bubble, player->mo->scale));
K_GenericExtraFlagsNoZAdjust(bmobj, player->follower);
K_MatchGenericExtraFlagsNoZAdjust(bmobj, player->follower);
bmobj->renderflags = player->mo->renderflags;
if (player->follower->threshold)
@ -712,7 +712,7 @@ void K_HandleFollower(player_t *player)
player->follower->z + player->follower->height
);
K_FlipFromObject(honk, player->follower);
K_FlipFromObjectNoInterp(honk, player->follower);
honk->angle = R_PointToAngle2(
player->mo->x,
@ -856,7 +856,7 @@ void K_FollowerHornTaunt(player_t *taunter, player_t *victim, boolean mysticmelo
P_SetTarget(&taunter->follower->hprev, honk);
P_SetTarget(&honk->target, taunter->follower);
K_FlipFromObject(honk, taunter->follower);
K_FlipFromObjectNoInterp(honk, taunter->follower);
honk->color = taunter->skincolor;

192
src/k_kart.c
View file

@ -1862,11 +1862,22 @@ void K_KartPainEnergyFling(player_t *player)
}
}
// Adds gravity flipping to an object relative to its master and shifts the z coordinate accordingly.
void K_FlipFromObject(mobj_t *mo, mobj_t *master)
void K_MatchFlipFlags(mobj_t *mo, mobj_t *master)
{
mo->eflags = (mo->eflags & ~MFE_VERTICALFLIP)|(master->eflags & MFE_VERTICALFLIP);
mo->flags2 = (mo->flags2 & ~MF2_OBJECTFLIP)|(master->flags2 & MF2_OBJECTFLIP);
}
static void K_MatchRenderFlags(mobj_t *mo, mobj_t *master)
{
// visibility (usually for hyudoro)
mo->renderflags = (mo->renderflags & ~RF_DONTDRAW) | (master->renderflags & RF_DONTDRAW);
}
// Adds gravity flipping to an object relative to its master and shifts the z coordinate accordingly.
void K_FlipFromObject(mobj_t *mo, mobj_t *master)
{
K_MatchFlipFlags(mo, master);
if (mo->eflags & MFE_VERTICALFLIP)
{
@ -1884,25 +1895,30 @@ void K_FlipFromObject(mobj_t *mo, mobj_t *master)
}
}
void K_FlipFromObjectNoInterp(mobj_t *mo, mobj_t *master)
{
K_FlipFromObject(mo, master);
mo->old_z = mo->z;
}
void K_MatchGenericExtraFlags(mobj_t *mo, mobj_t *master)
{
// flipping
// handle z shifting from there too. This is here since there's no reason not to flip us if needed when we do this anyway;
K_FlipFromObject(mo, master);
K_MatchRenderFlags(mo, master);
}
// visibility (usually for hyudoro)
mo->renderflags = (mo->renderflags & ~RF_DONTDRAW) | (master->renderflags & RF_DONTDRAW);
// Also sets old_z. useful for on spawn or hard teleport
void K_MatchGenericExtraFlagsNoInterp(mobj_t *mo, mobj_t *master)
{
K_FlipFromObjectNoInterp(mo, master);
K_MatchRenderFlags(mo, master);
}
// same as above, but does not adjust Z height when flipping
void K_GenericExtraFlagsNoZAdjust(mobj_t *mo, mobj_t *master)
void K_MatchGenericExtraFlagsNoZAdjust(mobj_t *mo, mobj_t *master)
{
// flipping
mo->eflags = (mo->eflags & ~MFE_VERTICALFLIP)|(master->eflags & MFE_VERTICALFLIP);
mo->flags2 = (mo->flags2 & ~MF2_OBJECTFLIP)|(master->flags2 & MF2_OBJECTFLIP);
// visibility (usually for hyudoro)
mo->renderflags = (mo->renderflags & ~RF_DONTDRAW) | (master->renderflags & RF_DONTDRAW);
K_MatchFlipFlags(mo, master);
K_MatchRenderFlags(mo, master);
}
@ -1944,7 +1960,7 @@ void K_SpawnDashDustRelease(player_t *player)
dust->momy = 3*player->mo->momy/5;
dust->momz = 3*P_GetMobjZMovement(player->mo)/5;
K_MatchGenericExtraFlags(dust, player->mo);
K_MatchGenericExtraFlagsNoInterp(dust, player->mo);
}
}
@ -1972,7 +1988,7 @@ static void K_SpawnBrakeDriftSparks(player_t *player) // Be sure to update the m
sparks = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_BRAKEDRIFT);
P_SetTarget(&sparks->target, player->mo);
P_SetScale(sparks, (sparks->destscale = FixedMul(K_GetBrakeFXScale(player, 3*FRACUNIT), player->mo->scale)));
K_MatchGenericExtraFlags(sparks, player->mo);
K_MatchGenericExtraFlagsNoInterp(sparks, player->mo);
sparks->renderflags |= RF_DONTDRAW;
}
@ -2057,18 +2073,12 @@ void K_SpawnDriftBoostClip(player_t *player)
mobj_t *clip;
fixed_t scale = 115*FRACUNIT/100;
fixed_t momz = P_GetMobjZMovement(player->mo);
fixed_t z;
if (( player->mo->eflags & MFE_VERTICALFLIP ))
z = player->mo->z;
else
z = player->mo->z + player->mo->height;
clip = P_SpawnMobj(player->mo->x, player->mo->y, z, MT_DRIFTCLIP);
clip = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_DRIFTCLIP);
P_SetTarget(&clip->target, player->mo);
P_SetScale(clip, ( clip->destscale = FixedMul(scale, player->mo->scale) ));
K_MatchGenericExtraFlags(clip, player->mo);
K_MatchGenericExtraFlagsNoInterp(clip, player->mo);
clip->fuse = 105;
clip->momz = 7 * P_MobjFlip(clip) * clip->scale;
@ -2092,7 +2102,7 @@ void K_SpawnDriftBoostClipSpark(mobj_t *clip)
P_SetTarget(&spark->target, clip);
P_SetScale(spark, ( spark->destscale = clip->scale ));
K_MatchGenericExtraFlags(spark, clip);
K_MatchGenericExtraFlagsNoInterp(spark, clip);
spark->momx = clip->momx/2;
spark->momy = clip->momx/2;
@ -2233,7 +2243,7 @@ void K_SpawnInvincibilitySpeedLines(mobj_t *mo)
fast->momy = 3*mo->momy/4;
fast->momz = 3*P_GetMobjZMovement(mo)/4;
K_MatchGenericExtraFlags(fast, mo);
K_MatchGenericExtraFlagsNoZAdjust(fast, mo);
P_SetTarget(&fast->owner, mo);
fast->renderflags |= RF_REDUCEVFX;
@ -2301,7 +2311,7 @@ static void K_SpawnGrowShrinkParticles(mobj_t *mo, INT32 timer)
particle->momy = mo->momy;
particle->momz = P_GetMobjZMovement(mo);
K_MatchGenericExtraFlags(particle, mo);
K_MatchGenericExtraFlagsNoZAdjust(particle, mo);
particleScale = FixedMul((shrink ? SHRINK_PHYSICS_SCALE : GROW_PHYSICS_SCALE), mapobjectscale);
particleSpeed = mo->scale * 4 * P_MobjFlip(mo); // NOT particleScale
@ -6041,7 +6051,7 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
mobj_t *truc;
INT32 speed, speed2;
K_MatchGenericExtraFlags(smoldering, source);
K_MatchGenericExtraFlagsNoInterp(smoldering, source);
smoldering->tics = TICRATE*3;
smoldering->hitlag += delay;
radius = source->radius>>FRACBITS;
@ -6073,7 +6083,7 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
truc = P_SpawnMobj(source->x + rand_x*FRACUNIT,
source->y + rand_y*FRACUNIT,
source->z + rand_z*FRACUNIT, MT_BOOMEXPLODE);
K_MatchGenericExtraFlags(truc, source);
K_MatchGenericExtraFlagsNoInterp(truc, source);
P_SetScale(truc, source->scale);
truc->destscale = source->scale*6;
truc->scalespeed = source->scale/12;
@ -6118,7 +6128,7 @@ void K_SpawnMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
truc = P_SpawnMobj(source->x + rand_x*FRACUNIT,
source->y + rand_y*FRACUNIT,
source->z + rand_z*FRACUNIT, MT_BOOMPARTICLE);
K_MatchGenericExtraFlags(truc, source);
K_MatchGenericExtraFlagsNoInterp(truc, source);
P_SetScale(truc, source->scale);
truc->destscale = source->scale*5;
truc->scalespeed = source->scale/12;
@ -6164,7 +6174,7 @@ void K_SpawnLandMineExplosion(mobj_t *source, skincolornum_t color, tic_t delay)
expl->hitlag = delay;
expl->renderflags |= RF_DONTDRAW;
//K_MatchGenericExtraFlags(expl, actor);
K_MatchGenericExtraFlagsNoInterp(expl, source);
P_SetScale(expl, source->scale*4);
expl->momx = P_RandomRange(PR_EXPLOSION, -3, 3)*source->scale/2;
@ -6305,12 +6315,11 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
x = source->x + source->momx + FixedMul(finalspeed, FINECOSINE(an>>ANGLETOFINESHIFT));
y = source->y + source->momy + FixedMul(finalspeed, FINESINE(an>>ANGLETOFINESHIFT));
z = P_GetZAt(source->standingslope, x, y, source->z); // spawn on the ground please
z = source->z + (P_IsObjectFlipped(source) ? source->height : 0);
z = P_GetZAt(source->standingslope, x, y, z); // spawn on the ground please
th = P_SpawnMobj(x, y, z, type); // this will never return null because collision isn't processed here
K_FlipFromObject(th, source);
th->flags2 |= flags2;
th->threshold = 10;
@ -6322,6 +6331,10 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
P_SetScale(th, finalscale);
th->destscale = finalscale;
K_MatchFlipFlags(th, source);
if (P_IsObjectFlipped(th))
z -= th->height;
th->angle = an;
th->momx = FixedMul(finalspeed, FINECOSINE(an>>ANGLETOFINESHIFT));
@ -6420,6 +6433,9 @@ static mobj_t *K_SpawnKartMissile(mobj_t *source, mobjtype_t type, angle_t an, I
x = x + P_ReturnThrustX(source, an, source->radius + th->radius);
y = y + P_ReturnThrustY(source, an, source->radius + th->radius);
throwmo = P_SpawnMobj(x, y, z, MT_FIREDITEM);
K_MatchFlipFlags(throwmo, source);
if (P_IsObjectFlipped(throwmo))
throwmo->z -= (throwmo->height - th->height);
throwmo->movecount = 1;
throwmo->movedir = source->angle - an;
P_SetTarget(&throwmo->target, source);
@ -6541,7 +6557,7 @@ static void K_SpawnDriftElectricity(player_t *player)
spark->momy = mo->momy;
spark->momz = mo->momz;
spark->color = color;
K_GenericExtraFlagsNoZAdjust(spark, mo);
K_MatchGenericExtraFlagsNoZAdjust(spark, mo);
P_SetTarget(&spark->owner, mo);
spark->renderflags |= RF_REDUCEVFX;
@ -6765,7 +6781,7 @@ static void K_SpawnDriftSparks(player_t *player)
if (trail > 0)
spark->tics += trail;
K_MatchGenericExtraFlags(spark, player->mo);
K_MatchGenericExtraFlagsNoInterp(spark, player->mo);
P_SetTarget(&spark->owner, player->mo);
spark->renderflags |= RF_REDUCEVFX;
}
@ -6815,7 +6831,7 @@ static void K_SpawnAIZDust(player_t *player)
spark->momy = (6*player->mo->momy)/5;
spark->momz = P_GetMobjZMovement(player->mo);
K_MatchGenericExtraFlags(spark, player->mo);
K_MatchGenericExtraFlagsNoInterp(spark, player->mo);
}
}
@ -6856,7 +6872,7 @@ void K_SpawnBoostTrail(player_t *player)
newz -= FixedMul(mobjinfo[MT_SNEAKERTRAIL].height, player->mo->scale);
}
flame = P_SpawnMobj(newx, newy, ground, MT_SNEAKERTRAIL);
flame = P_SpawnMobj(newx, newy, newz, MT_SNEAKERTRAIL);
P_SetTarget(&flame->target, player->mo);
flame->angle = travelangle;
@ -6864,7 +6880,7 @@ void K_SpawnBoostTrail(player_t *player)
flame->destscale = player->mo->scale;
P_SetScale(flame, player->mo->scale);
// not K_MatchGenericExtraFlags so that a stolen sneaker can be seen
K_FlipFromObject(flame, player->mo);
K_MatchFlipFlags(flame, player->mo);
flame->momx = 8;
P_XYMovement(flame);
@ -6915,7 +6931,7 @@ void K_SpawnSparkleTrail(mobj_t *mo)
sparkle->extravalue2 = P_RandomRange(PR_DECORATION, 0, 1) ? 1 : -1; // Rotation direction?
sparkle->cvmem = P_RandomRange(PR_DECORATION, -25, 25)*mo->scale; // Vertical "angle"
K_FlipFromObject(sparkle, mo);
K_FlipFromObjectNoInterp(sparkle, mo);
P_SetTarget(&sparkle->target, mo);
sparkle->destscale = mo->destscale;
@ -6964,7 +6980,7 @@ void K_SpawnWipeoutTrail(mobj_t *mo)
dust->angle = K_MomentumAngle(mo);
dust->destscale = mo->scale;
P_SetScale(dust, mo->scale);
K_FlipFromObject(dust, mo);
K_FlipFromObjectNoInterp(dust, mo);
}
void K_SpawnFireworkTrail(mobj_t *mo)
@ -6991,7 +7007,7 @@ void K_SpawnFireworkTrail(mobj_t *mo)
dust->destscale = 2*mo->scale;
dust->scalespeed = mo->scale/2;
K_FlipFromObject(dust, mo);
//K_FlipFromObjectNoInterp(dust, mo); -- no, P_SpawnMobjFromMobj does this
}
void K_SpawnDraftDust(mobj_t *mo)
@ -7057,7 +7073,7 @@ void K_SpawnDraftDust(mobj_t *mo)
dust->angle = ang - (ANGLE_90 * sign); // point completely perpendicular from the player
dust->destscale = mo->scale;
P_SetScale(dust, mo->scale);
K_FlipFromObject(dust, mo);
K_FlipFromObjectNoInterp(dust, mo);
if (leveltime & 1)
dust->tics++; // "randomize" animation
@ -7139,7 +7155,7 @@ void K_DriftDustHandling(mobj_t *spawner)
S_StartSound(spawner, sfx_screec);
}
K_MatchGenericExtraFlags(dust, spawner);
K_MatchGenericExtraFlagsNoInterp(dust, spawner);
// Sparkle-y warning for when you're about to change drift sparks!
if (spawner->player && spawner->player->drift)
@ -7339,13 +7355,7 @@ mobj_t *K_ThrowKartItemEx(player_t *player, boolean missile, mobjtype_t mapthing
mo->angle = player->mo->angle;
}
// These are really weird so let's make it a very specific case to make SURE it works...
if (player->mo->eflags & MFE_VERTICALFLIP)
{
mo->z -= player->mo->height;
mo->eflags |= MFE_VERTICALFLIP;
mo->flags2 |= (player->mo->flags2 & MF2_OBJECTFLIP);
}
K_FlipFromObjectNoInterp(mo, player->mo);
mo->threshold = 10;
P_SetTarget(&mo->target, player->mo);
@ -7411,13 +7421,7 @@ mobj_t *K_ThrowKartItemEx(player_t *player, boolean missile, mobjtype_t mapthing
// this is the small graphic effect that plops in you when you throw an item:
throwmo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z + player->mo->height/2, MT_FIREDITEM);
P_SetTarget(&throwmo->target, player->mo);
// Ditto:
if (player->mo->eflags & MFE_VERTICALFLIP)
{
throwmo->z -= player->mo->height;
throwmo->eflags |= MFE_VERTICALFLIP;
mo->flags2 |= (player->mo->flags2 & MF2_OBJECTFLIP);
}
K_FlipFromObjectNoInterp(throwmo, player->mo);
throwmo->movecount = 0; // above player
@ -7468,7 +7472,7 @@ mobj_t *K_ThrowKartItemEx(player_t *player, boolean missile, mobjtype_t mapthing
mo = P_SpawnMobj(newx, newy, newz, mapthing); // this will never return null because collision isn't processed here
mo->angle = newangle;
}
K_FlipFromObject(mo, player->mo);
K_FlipFromObjectNoInterp(mo, player->mo);
mo->threshold = 10;
P_SetTarget(&mo->target, player->mo);
@ -7789,7 +7793,7 @@ void K_DoSneaker(player_t *player, INT32 type)
P_SetTarget(&overlay->target, cur);
P_SetTarget(&cur->tracer, overlay);
P_SetScale(overlay, (overlay->destscale = 3*cur->scale/4));
K_FlipFromObject(overlay, cur);
K_FlipFromObjectNoInterp(overlay, cur);
}
cur = cur->hnext;
}
@ -7800,7 +7804,7 @@ void K_DoSneaker(player_t *player, INT32 type)
mobj_t *overlay = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_BOOSTFLAME);
P_SetTarget(&overlay->target, player->mo);
P_SetScale(overlay, (overlay->destscale = player->mo->scale));
K_FlipFromObject(overlay, player->mo);
K_FlipFromObjectNoInterp(overlay, player->mo);
}
}
@ -8010,7 +8014,7 @@ static void K_ThrowLandMine(player_t *player)
mobj_t *throwmo;
landMine = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z + player->mo->height/2, MT_LANDMINE);
K_FlipFromObject(landMine, player->mo);
K_FlipFromObjectNoInterp(landMine, player->mo);
landMine->threshold = 10;
if (landMine->info->seesound)
@ -8538,7 +8542,7 @@ void K_DropPaperItem(player_t *player, UINT8 itemtype, UINT16 itemamount)
itemtype, itemamount
);
K_FlipFromObject(drop, player->mo);
K_FlipFromObjectNoInterp(drop, player->mo);
}
// For getting EXTRA hit!
@ -8878,8 +8882,7 @@ static void K_MoveHeldObjects(player_t *player)
cur->flags &= ~MF_NOCLIPTHING;
if ((player->mo->eflags & MFE_VERTICALFLIP) != (cur->eflags & MFE_VERTICALFLIP))
K_FlipFromObject(cur, player->mo);
K_MatchFlipFlags(cur, player->mo);
if (!cur->health)
{
@ -9020,26 +9023,21 @@ static void K_MoveHeldObjects(player_t *player)
{ // bobbing, copy pasted from my kimokawaiii entry
fixed_t sine = FixedMul(player->mo->scale, 8 * FINESINE((((M_TAU_FIXED * (4*TICRATE)) * leveltime) >> ANGLETOFINESHIFT) & FINEMASK));
targz = (player->mo->z + (player->mo->height/2)) + sine;
if (player->mo->eflags & MFE_VERTICALFLIP)
targz += (player->mo->height/2 - 32*player->mo->scale)*6;
}
if (cur->tracer && !P_MobjWasRemoved(cur->tracer))
{
fixed_t diffx, diffy, diffz;
diffx = targx - cur->x;
diffy = targy - cur->y;
diffz = targz - cur->z;
P_MoveOrigin(cur->tracer, cur->tracer->x + diffx + P_ReturnThrustX(cur, cur->angle + angoffset, 6*cur->scale),
cur->tracer->y + diffy + P_ReturnThrustY(cur, cur->angle + angoffset, 6*cur->scale), cur->tracer->z + diffz);
P_SetScale(cur->tracer, (cur->tracer->destscale = 3*cur->scale/4));
}
P_MoveOrigin(cur, targx, targy, targz);
K_FlipFromObject(cur, player->mo); // Update graviflip in real time thanks.
if (cur->tracer && !P_MobjWasRemoved(cur->tracer))
{
P_MoveOrigin(cur->tracer,
targx + P_ReturnThrustX(cur, cur->angle + angoffset, 6*cur->scale),
targy + P_ReturnThrustY(cur, cur->angle + angoffset, 6*cur->scale),
cur->z);
P_SetScale(cur->tracer, (cur->tracer->destscale = 3*cur->scale/4));
K_FlipFromObject(cur->tracer, cur);
}
cur->roll = player->mo->roll;
cur->pitch = player->mo->pitch;
@ -9902,25 +9900,21 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
// GROSS. In order to have a transparent version of this for a splitscreen local player, we actually need to spawn two!
for (doubler = 0; doubler < 2; doubler++)
{
fixed_t heightOffset = player->mo->height + (24*player->mo->scale);
if (P_IsObjectFlipped(player->mo))
{
// This counteracts the offset added by K_FlipFromObject so it looks seamless from non-flipped.
heightOffset += player->mo->height - FixedMul(player->mo->scale, player->mo->height);
heightOffset *= P_MobjFlip(player->mo); // Fleep.
}
mobj_t *debtflag = P_SpawnMobj(player->mo->x + player->mo->momx, player->mo->y + player->mo->momy,
player->mo->z + P_GetMobjZMovement(player->mo) + heightOffset, MT_THOK);
player->mo->z + player->mo->height + (24*player->mo->scale), MT_THOK);
debtflag->old_x = player->mo->old_x;
debtflag->old_y = player->mo->old_y;
debtflag->old_z = player->mo->old_z + P_GetMobjZMovement(player->mo) + heightOffset;
P_SetMobjState(debtflag, S_RINGDEBT);
P_SetScale(debtflag, (debtflag->destscale = player->mo->scale));
K_MatchGenericExtraFlags(debtflag, player->mo);
K_MatchGenericExtraFlagsNoInterp(debtflag, player->mo);
debtflag->z += P_GetMobjZMovement(player->mo);
debtflag->old_z = debtflag->z + (player->mo->old_z - player->mo->z);
debtflag->frame += (leveltime % 4);
if ((leveltime/12) & 1)
@ -10100,7 +10094,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
mobj_t *spdl = P_SpawnMobjFromMobj(player->mo, sx, sy, 0, MT_DOWNLINE);
spdl->colorized = true;
spdl->color = player->skincolor;
K_MatchGenericExtraFlags(spdl, player->mo);
K_MatchGenericExtraFlagsNoZAdjust(spdl, player->mo);
P_SetTarget(&spdl->owner, player->mo);
spdl->renderflags |= RF_REDUCEVFX;
P_InstaScale(spdl, 4*player->mo->scale/2);
@ -10663,7 +10657,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
sparkle->momx = 3*pmo->momx/4;
sparkle->momy = 3*pmo->momy/4;
sparkle->momz = 3*P_GetMobjZMovement(pmo)/4;
K_MatchGenericExtraFlags(sparkle, pmo);
K_MatchGenericExtraFlagsNoInterp(sparkle, pmo);
sparkle->renderflags = (pmo->renderflags & ~RF_TRANSMASK);//|RF_TRANS20|RF_ADD;
}
@ -11318,7 +11312,7 @@ void K_KartPlayerThink(player_t *player, ticcmd_t *cmd)
//player->flashing = 0;
eggsexplode = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_SPBEXPLOSION);
eggsexplode->height = 2 * player->mo->height;
K_FlipFromObject(eggsexplode, player->mo);
K_FlipFromObjectNoInterp(eggsexplode, player->mo);
S_StopSoundByID(player->mo, sfx_s3k53);
S_StopSoundByID(player->mo, sfx_kc51);
@ -12698,7 +12692,7 @@ void K_SpawnDriftBoostExplosion(player_t *player, int stage)
overlay->angle = K_MomentumAngle(player->mo);
P_SetTarget(&overlay->target, player->mo);
P_SetScale(overlay, (overlay->destscale = player->mo->scale));
K_FlipFromObject(overlay, player->mo);
K_FlipFromObjectNoInterp(overlay, player->mo);
switch (stage)
{
@ -13687,7 +13681,7 @@ void K_KartEbrakeVisuals(player_t *p)
spdl = P_SpawnMobj(sx, sy, p->mo->z, MT_DOWNLINE);
spdl->colorized = true;
spdl->color = SKINCOLOR_WHITE;
K_MatchGenericExtraFlags(spdl, p->mo);
K_MatchGenericExtraFlagsNoInterp(spdl, p->mo);
P_SetTarget(&spdl->owner, p->mo);
spdl->renderflags |= RF_REDUCEVFX;
P_SetScale(spdl, p->mo->scale);
@ -13848,7 +13842,7 @@ static void K_KartSpindashWind(mobj_t *parent)
wind->momy = 3 * parent->momy / 4;
wind->momz = 3 * P_GetMobjZMovement(parent) / 4;
K_MatchGenericExtraFlags(wind, parent);
K_MatchGenericExtraFlagsNoZAdjust(wind, parent);
P_SetTarget(&wind->owner, parent);
wind->renderflags |= RF_REDUCEVFX;
}
@ -14744,7 +14738,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
P_SetTarget(&player->whip, whip);
P_SetScale(whip, player->mo->scale);
P_SetTarget(&whip->target, player->mo);
K_MatchGenericExtraFlags(whip, player->mo);
K_MatchGenericExtraFlagsNoInterp(whip, player->mo);
P_SpawnFakeShadow(whip, 20);
whip->fuse = INSTAWHIP_DURATION;
player->flashing = max(player->flashing, INSTAWHIP_DURATION);
@ -14991,7 +14985,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
for (moloop = 0; moloop < 2; moloop++)
{
mo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_ROCKETSNEAKER);
K_MatchGenericExtraFlags(mo, player->mo);
K_MatchGenericExtraFlagsNoInterp(mo, player->mo);
mo->flags |= MF_NOCLIPTHING;
mo->angle = player->mo->angle;
mo->threshold = 10;
@ -15070,7 +15064,7 @@ void K_MoveKartPlayer(player_t *player, boolean onground)
mo = P_SpawnMobj(player->mo->x, player->mo->y, player->mo->z, MT_EGGMANITEM_SHIELD);
if (mo)
{
K_FlipFromObject(mo, player->mo);
K_FlipFromObjectNoInterp(mo, player->mo);
mo->flags |= MF_NOCLIPTHING;
mo->threshold = 10;
mo->movecount = 1;

5
src/k_kart.h
View file

@ -163,9 +163,12 @@ void K_PlayerJustBumped(player_t *player);
boolean K_KartBouncing(mobj_t *mobj1, mobj_t *mobj2);
boolean K_KartSolidBounce(mobj_t *bounceMobj, mobj_t *solidMobj);
void K_KartPainEnergyFling(player_t *player);
void K_MatchFlipFlags(mobj_t *mo, mobj_t *master);
void K_FlipFromObject(mobj_t *mo, mobj_t *master);
void K_FlipFromObjectNoInterp(mobj_t *mo, mobj_t *master);
void K_MatchGenericExtraFlags(mobj_t *mo, mobj_t *master);
void K_GenericExtraFlagsNoZAdjust(mobj_t *mo, mobj_t *master);
void K_MatchGenericExtraFlagsNoInterp(mobj_t *mo, mobj_t *master);
void K_MatchGenericExtraFlagsNoZAdjust(mobj_t *mo, mobj_t *master);
void K_SpawnDashDustRelease(player_t *player);
void K_SpawnDriftBoostClip(player_t *player);
void K_SpawnDriftBoostClipSpark(mobj_t *clip);

69
src/lua_baselib.c
View file

@ -3766,18 +3766,6 @@ static int lib_kKartPainEnergyFling(lua_State *L)
return 0;
}
static int lib_kFlipFromObject(lua_State *L)
{
mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
mobj_t *master = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
NOHUD
INLEVEL
if (!mo || !master)
return LUA_ErrInvalid(L, "mobj_t");
K_FlipFromObject(mo, master);
return 0;
}
static int lib_kKartSolidBounce(lua_State *L)
{
mobj_t *bounceMobj = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
@ -3792,6 +3780,30 @@ static int lib_kKartSolidBounce(lua_State *L)
return 1;
}
static int lib_kFlipFromObject(lua_State *L)
{
mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
mobj_t *master = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
NOHUD
INLEVEL
if (!mo || !master)
return LUA_ErrInvalid(L, "mobj_t");
K_FlipFromObject(mo, master);
return 0;
}
static int lib_kFlipFromObjectNoInterp(lua_State *L)
{
mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
mobj_t *master = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
NOHUD
INLEVEL
if (!mo || !master)
return LUA_ErrInvalid(L, "mobj_t");
K_FlipFromObjectNoInterp(mo, master);
return 0;
}
static int lib_kMatchGenericExtraFlags(lua_State *L)
{
mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
@ -3805,6 +3817,32 @@ static int lib_kMatchGenericExtraFlags(lua_State *L)
return 0;
}
static int lib_kMatchGenericExtraFlagsNoInterp(lua_State *L)
{
mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
mobj_t *master = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
NOHUD
if (!mo)
return LUA_ErrInvalid(L, "mobj_t");
if (!master)
return LUA_ErrInvalid(L, "mobj_t");
K_MatchGenericExtraFlagsNoInterp(mo, master);
return 0;
}
static int lib_kMatchGenericExtraFlagsNoZAdjust(lua_State *L)
{
mobj_t *mo = *((mobj_t **)luaL_checkudata(L, 1, META_MOBJ));
mobj_t *master = *((mobj_t **)luaL_checkudata(L, 2, META_MOBJ));
NOHUD
if (!mo)
return LUA_ErrInvalid(L, "mobj_t");
if (!master)
return LUA_ErrInvalid(L, "mobj_t");
K_MatchGenericExtraFlagsNoZAdjust(mo, master);
return 0;
}
static int lib_kSpawnDashDustRelease(lua_State *L)
{
player_t *player = *((player_t **)luaL_checkudata(L, 1, META_PLAYER));
@ -3904,7 +3942,7 @@ static int lib_kGenericExtraFlagsNoZAdjust(lua_State *L)
INLEVEL
if (!mo || !master)
return LUA_ErrInvalid(L, "mobj_t");
K_GenericExtraFlagsNoZAdjust(mo, master);
K_MatchGenericExtraFlagsNoZAdjust(mo, master);
return 0;
}
@ -6719,8 +6757,11 @@ static luaL_Reg lib[] = {
{"K_KartBouncing",lib_kKartBouncing},
{"K_KartPainEnergyFling",lib_kKartPainEnergyFling},
{"K_FlipFromObject",lib_kFlipFromObject},
{"K_FlipFromObjectNoInterp",lib_kFlipFromObjectNoInterp},
{"K_KartSolidBounce",lib_kKartSolidBounce},
{"K_MatchGenericExtraFlags",lib_kMatchGenericExtraFlags},
{"K_MatchGenericExtraFlagsNoInterp",lib_kMatchGenericExtraFlagsNoInterp},
{"K_MatchGenericExtraFlagsNoZAdjust",lib_kMatchGenericExtraFlagsNoZAdjust},
{"K_SpawnDashDustRelease",lib_kSpawnDashDustRelease},
{"K_SpawnDriftBoostClip",lib_kSpawnDriftBoostClip},
{"K_SpawnDriftBoostClipSpark",lib_kSpawnDriftBoostClipSpark},
@ -6728,7 +6769,7 @@ static luaL_Reg lib[] = {
{"K_SpawnGardenTopSpeedLines",lib_kSpawnGardenTopSpeedLines},
{"K_SpawnInvincibilitySpeedLines",lib_kSpawnInvincibilitySpeedLines},
{"K_SpawnBumpEffect",lib_kSpawnBumpEffect},
{"K_GenericExtraFlagsNoZAdjust",lib_kGenericExtraFlagsNoZAdjust},
{"K_MatchGenericExtraFlagsNoZAdjust",lib_kGenericExtraFlagsNoZAdjust},
{"K_PressingEBrake",lib_kPressingEBrake},
{"K_MomentumAngleEx",lib_kMomentumAngleEx},
{"K_MomentumAngleReal",lib_kMomentumAngleReal},

5
src/objects/gardentop.c
View file

@ -407,8 +407,7 @@ anchor
const fixed_t x = P_ReturnThrustX(us, angle, radius);
const fixed_t y = P_ReturnThrustY(us, angle, radius);
/* FIXME: THIS FUNCTION FUCKING SUCKS */
K_FlipFromObject(us, them);
K_MatchFlipFlags(us, them);
P_MoveOrigin(us, them->x + x, them->y + y,
them->z + K_FlipZOffset(us, them));
@ -439,7 +438,7 @@ anchor_top (mobj_t *top)
anchor(top, rider, rider->angle, 0);
K_GenericExtraFlagsNoZAdjust(top, rider);
K_MatchGenericExtraFlagsNoZAdjust(top, rider);
/* Copying the Z momentum lets the Top squash and stretch
as it falls with the player. Don't copy the X/Y

2
src/objects/monitor.c
View file

@ -467,7 +467,7 @@ adjust_monitor_drop
drop->momz *= 8;
}
K_FlipFromObject(drop, monitor);
K_FlipFromObjectNoInterp(drop, monitor);
return drop;
}

6
src/objects/powerup-aura.cpp
View file

@ -92,11 +92,9 @@ struct Aura : mobj_t
{
return;
}
K_FlipFromObject(this, origin());
fixed_t flipoffset = P_IsObjectFlipped(origin()) ? origin()->height : 0;
P_MoveOrigin(this, origin()->x, origin()->y, origin()->z - flipoffset);
P_MoveOrigin(this, origin()->x, origin()->y, origin()->z);
K_FlipFromObject(this, origin());
P_InstaScale(this, 11 * origin()->scale / 10);
translate();

3
src/objects/ring-shooter.c
View file

@ -171,6 +171,7 @@ static void UpdateRingShooterParts(mobj_t *mo)
part = mo->tracer;
part->z = mo->z + FixedMul(refNipple->height, rs_base_yscale(mo));
MovePart(part, mo, refNipple);
K_FlipFromObject(part, mo);
ScalePart(part, mo);
}
@ -516,7 +517,7 @@ static void SpawnRingShooter(player_t *player)
rs_base_karted(base) = -(RS_KARTED_INC * TICRATE); // wait for "3"
rs_base_grabberdist(base) = RS_GRABBER_START;
K_FlipFromObject(base, mo);
K_FlipFromObjectNoInterp(base, mo);
P_SetScale(base, base->destscale = FixedMul(base->destscale, scale));
base->angle = mo->angle;
base->scalespeed = FRACUNIT/2;

23
src/objects/servant-hand.c
View file

@ -28,26 +28,17 @@ void Obj_ServantHandSpawning(player_t *player)
{
player->handtimer++;
if (player->hand == NULL && player->handtimer == TICRATE)
{
fixed_t heightOffset = player->mo->height + 30*mapobjectscale;
if (P_IsObjectFlipped(player->mo))
{
// This counteracts the offset added by K_FlipFromObject so it looks seamless from non-flipped.
heightOffset += player->mo->height - FixedMul(player->mo->scale, player->mo->height);
heightOffset *= P_MobjFlip(player->mo); // Fleep.
}
{
mobj_t *hand = P_SpawnMobj(
player->mo->x,
player->mo->y,
player->mo->z + heightOffset,
player->mo->z + player->mo->height + 30*mapobjectscale,
MT_SERVANTHAND
);
if (hand)
{
K_FlipFromObject(hand, player->mo);
hand->old_z = hand->z;
K_FlipFromObjectNoInterp(hand, player->mo);
P_SetTarget(&hand->target, player->mo);
P_SetTarget(&player->hand, hand);
@ -124,16 +115,12 @@ void Obj_ServantHandThink(mobj_t *hand)
hand->color = player->skincolor;
hand->angle = player->besthanddirection;
fixed_t heightOffset = player->mo->height + 30*mapobjectscale;
if (P_IsObjectFlipped(player->mo))
heightOffset *= P_MobjFlip(player->mo); // Fleep.
K_FlipFromObject(hand, player->mo);
P_MoveOrigin(hand,
player->mo->x + xoffs,
player->mo->y + yoffs,
player->mo->z + heightOffset
player->mo->z + player->mo->height + 30*mapobjectscale
);
K_FlipFromObject(hand, player->mo);
hand->sprzoff = player->mo->sprzoff;

6
src/objects/spb.c
View file

@ -182,7 +182,7 @@ static void SpawnSPBDust(mobj_t *spb)
dust->angle = spb->angle - FixedAngle(FRACUNIT*90 - FRACUNIT*180*i); // The first one will spawn to the right of the spb, the second one to the left.
P_Thrust(dust, dust->angle, 6*dust->scale);
K_MatchGenericExtraFlags(dust, spb);
K_MatchGenericExtraFlagsNoZAdjust(dust, spb);
sa += ANG1*120; // Add 120 degrees to get to mo->angle + ANG1*60
}
@ -229,7 +229,7 @@ static void SpawnSPBSliptide(mobj_t *spb, SINT8 dir)
spark->momx = (6*spb->momx)/5;
spark->momy = (6*spb->momy)/5;
K_MatchGenericExtraFlags(spark, spb);
K_MatchGenericExtraFlagsNoZAdjust(spark, spb);
}
}
@ -253,7 +253,7 @@ static void SpawnSPBSpeedLines(mobj_t *spb)
fast->color = SKINCOLOR_RED;
fast->colorized = true;
K_MatchGenericExtraFlags(fast, spb);
K_MatchGenericExtraFlagsNoZAdjust(fast, spb);
}
static fixed_t SPBDist(mobj_t *a, mobj_t *b)

7
src/objects/stone-shoe.cpp
View file

@ -272,10 +272,7 @@ private:
sprzoff(30 * scale());
if (is_flipped() != follow()->is_flipped())
{
K_FlipFromObject(this, follow());
}
K_MatchFlipFlags(this, follow());
}
void move_chain()
@ -297,7 +294,7 @@ private:
while (Mobj::valid(node))
{
node->move_origin({p, pz});
K_FlipFromObject(node, this);
K_MatchFlipFlags(node, this);
node->sprzoff(sprzoff());
// Let chain flicker like shoe does

8
src/objects/super-flicky.cpp
View file

@ -95,6 +95,10 @@ sine_bob
hyu->sprzoff = FixedMul(kBobHeight,
sineofs + FINESINE(a >> ANGLETOFINESHIFT)) * P_MobjFlip(hyu);
// todo I think this is slightly wrong
// but I am literally fixing every single
// K_FlipFromObject in the code at once
// and this is impossible in basegame rn
if (P_IsObjectFlipped(hyu))
hyu->sprzoff -= hyu->height;
}
@ -306,7 +310,7 @@ struct Flicky : mobj_t
color = super_color();
}
K_FlipFromObject(this, source());
K_MatchFlipFlags(this, source());
bob_in_place(this, phase() * 8, 32);
}
@ -401,7 +405,7 @@ struct Flicky : mobj_t
fast->colorized = true;
fast->renderflags |= RF_ADD;
K_MatchGenericExtraFlags(fast, this);
K_MatchGenericExtraFlagsNoZAdjust(fast, this);
}
void range_check()

4
src/objects/ufo.c
View file

@ -101,7 +101,7 @@ static void SpawnUFOSpeedLines(mobj_t *ufo)
fast->color = SKINCOLOR_WHITE;
fast->colorized = true;
K_MatchGenericExtraFlags(fast, ufo);
K_MatchGenericExtraFlagsNoZAdjust(fast, ufo);
}
static void SpawnEmeraldSpeedLines(mobj_t *mo)
@ -124,7 +124,7 @@ static void SpawnEmeraldSpeedLines(mobj_t *mo)
fast->momy = 3*mo->momy/4;
fast->momz = 3*P_GetMobjZMovement(mo)/4;
K_MatchGenericExtraFlags(fast, mo);
K_MatchGenericExtraFlagsNoZAdjust(fast, mo);
P_SetTarget(&fast->owner, mo);
fast->renderflags |= RF_REDUCEVFX;

4
src/p_enemy.c
View file

@ -3567,7 +3567,7 @@ void A_AttractChase(mobj_t *actor)
fixed_t offsZ = FixedMul(actor->movefactor, offsFrac);
//P_SetScale(actor, (actor->destscale = actor->target->scale));
K_MatchGenericExtraFlags(actor, actor->target);
K_MatchGenericExtraFlagsNoZAdjust(actor, actor->target);
P_MoveOrigin(
actor,
@ -3604,7 +3604,7 @@ void A_AttractChase(mobj_t *actor)
P_SetScale(actor, (actor->destscale = mapobjectscale - ((mapobjectscale/14) * actor->extravalue1)));
actor->z = actor->target->z;
K_MatchGenericExtraFlags(actor, actor->target);
K_MatchGenericExtraFlagsNoZAdjust(actor, actor->target);
P_MoveOrigin(actor,
actor->target->x + FixedMul(dist, FINECOSINE(actor->angle >> ANGLETOFINESHIFT)),
actor->target->y + FixedMul(dist, FINESINE(actor->angle >> ANGLETOFINESHIFT)),

87
src/p_mobj.c
View file

@ -4372,7 +4372,7 @@ static void P_RingThinker(mobj_t *mobj)
{
mobj->renderflags &= ~RF_DONTDRAW;
spark = P_SpawnMobj(mobj->x, mobj->y, mobj->z, MT_SIGNSPARKLE); // Spawn a fancy sparkle
K_MatchGenericExtraFlags(spark, mobj);
K_MatchGenericExtraFlagsNoInterp(spark, mobj);
spark->colorized = true;
spark->color = mobj->color ? mobj->color : SKINCOLOR_YELLOW; // Use yellow if the ring doesn't use a skin color. (It should be red for SPB rings, but let normal rings look fancy too!)
P_RemoveMobj(mobj); // Adieu, monde cruel!
@ -4423,7 +4423,7 @@ static void P_ItemCapsulePartThinker(mobj_t *mobj)
if (mobj->flags2 & MF2_CLASSICPUSH) // centered items should not be flipped
mobj->renderflags = (mobj->renderflags & ~RF_DONTDRAW) | (target->renderflags & RF_DONTDRAW);
else
K_GenericExtraFlagsNoZAdjust(mobj, target);
K_MatchGenericExtraFlagsNoZAdjust(mobj, target);
x = target->x + target->sprxoff;
y = target->y + target->spryoff;
@ -6164,7 +6164,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
fixed_t z = P_RandomRange(PR_SMOLDERING, 0, 70)*mobj->scale;
mobj_t *smoke = P_SpawnMobj(mobj->x + x, mobj->y + y, mobj->z + z, MT_SMOKE);
P_SetMobjState(smoke, S_OPAQUESMOKE1);
K_MatchGenericExtraFlags(smoke, mobj);
K_MatchGenericExtraFlagsNoInterp(smoke, mobj);
smoke->scale = mobj->scale * 2;
smoke->destscale = mobj->scale * 6;
smoke->momz = P_RandomRange(PR_SMOLDERING, 4, 9)*mobj->scale*P_MobjFlip(smoke);
@ -6178,11 +6178,11 @@ static void P_MobjSceneryThink(mobj_t *mobj)
{
fixed_t x = P_RandomRange(PR_EXPLOSION, -16, 16)*mobj->scale;
fixed_t y = P_RandomRange(PR_EXPLOSION, -16, 16)*mobj->scale;
fixed_t z = P_RandomRange(PR_EXPLOSION, 0, 32)*mobj->scale*P_MobjFlip(mobj);
fixed_t z = P_RandomRange(PR_EXPLOSION, 0, 32)*mobj->scale;
if (leveltime % 2 == 0)
{
mobj_t *smoke = P_SpawnMobj(mobj->x + x, mobj->y + y, mobj->z + z, MT_BOSSEXPLODE);
K_MatchGenericExtraFlags(smoke, mobj);
K_MatchGenericExtraFlagsNoInterp(smoke, mobj);
P_SetMobjState(smoke, S_QUICKBOOM1);
smoke->scale = mobj->scale/2;
smoke->destscale = mobj->scale;
@ -6192,7 +6192,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
{
mobj_t *smoke = P_SpawnMobj(mobj->x + x, mobj->y + y, mobj->z + z, MT_SMOKE);
P_SetMobjState(smoke, S_OPAQUESMOKE1);
K_MatchGenericExtraFlags(smoke, mobj);
K_MatchGenericExtraFlagsNoInterp(smoke, mobj);
smoke->scale = mobj->scale;
smoke->destscale = mobj->scale*2;
}
@ -6808,8 +6808,7 @@ static void P_MobjSceneryThink(mobj_t *mobj)
P_SetScale(mobj, (mobj->destscale = myscale));
P_MoveOrigin(mobj, mobj->target->x, mobj->target->y, mobj->target->z + mobj->target->height/2);
// Taken from K_FlipFromObject. We just want to flip the visual according to its target, but that's it.
mobj->eflags = (mobj->eflags & ~MFE_VERTICALFLIP)|(mobj->target->eflags & MFE_VERTICALFLIP);
K_MatchFlipFlags(mobj, mobj->target);
mobj->extravalue1++;
@ -8043,8 +8042,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
target->y + FixedMul(xofs, cos) + FixedMul(frontoffset, sin),
target->z + zofs + (target->height / 2));
mobj->angle = facing + ANGLE_90 + (mobj->extravalue1 ? ANGLE_45 : -1*ANGLE_45);
K_MatchGenericExtraFlags(mobj, target);
P_InstaScale(mobj, FixedMul(target->scale, easedscale));
K_MatchGenericExtraFlagsNoInterp(mobj, target);
UINT8 maxtranslevel = NUMTRANSMAPS - 2;
UINT8 trans = FixedInt(FixedMul(percentvisible, FRACUNIT*(maxtranslevel+1)));
@ -8194,6 +8193,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_MoveOrigin(mobj, mobj->target->x + P_ReturnThrustX(mobj, mobj->angle+ANGLE_180, mobj->target->radius),
mobj->target->y + P_ReturnThrustY(mobj, mobj->angle+ANGLE_180, mobj->target->radius), mobj->target->z);
P_SetScale(mobj, mobj->target->scale);
K_FlipFromObject(mobj, mobj->target);
mobj->roll = mobj->target->roll;
mobj->pitch = mobj->target->pitch;
@ -8219,6 +8219,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
fixed_t rand_angle;
fixed_t rand_move;
mobj_t *smoke = P_SpawnMobj(mobj->x, mobj->y, mobj->z+(8<<FRACBITS), MT_BOOSTSMOKE);
K_FlipFromObjectNoInterp(smoke, mobj);
P_SetScale(smoke, mobj->target->scale/2);
smoke->destscale = 3*mobj->target->scale/2;
@ -8345,8 +8346,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
if (mobj->movefactor < mobj->target->height)
mobj->movefactor = mobj->target->height;
}
K_MatchGenericExtraFlags(mobj, mobj->target);
P_MoveOrigin(mobj, mobj->target->x, mobj->target->y, mobj->target->z + (mobj->target->height/2) + mobj->movefactor);
K_MatchGenericExtraFlags(mobj, mobj->target);
break;
case MT_RINGSPARKS:
if (!mobj->target || P_MobjWasRemoved(mobj->target))
@ -8357,11 +8358,10 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
mobj->z = mobj->target->z;
K_MatchGenericExtraFlags(mobj, mobj->target);
P_MoveOrigin(mobj, mobj->target->x + FINECOSINE(mobj->angle >> ANGLETOFINESHIFT),
mobj->target->y + FINESINE(mobj->angle >> ANGLETOFINESHIFT),
mobj->z + (mobj->target->height * P_MobjFlip(mobj)));
mobj->z + mobj->target->height);
K_MatchGenericExtraFlags(mobj, mobj->target);
break;
case MT_GAINAX:
{
@ -8396,20 +8396,19 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
}
mobj->angle = mobj->target->player->drawangle;
mobj->z = mobj->target->z;
P_MoveOrigin(mobj, mobj->target->x + FixedMul(34 * mapobjectscale, FINECOSINE((mobj->angle + mobj->movedir) >> ANGLETOFINESHIFT)),
mobj->target->y + FixedMul(34 * mapobjectscale, FINESINE((mobj->angle + mobj->movedir) >> ANGLETOFINESHIFT)),
mobj->z + (32 * mapobjectscale));
K_MatchGenericExtraFlags(mobj, mobj->target);
mobj->renderflags = (mobj->renderflags & ~RF_DONTDRAW)|K_GetPlayerDontDrawFlag(mobj->target->player);
if (vfx)
{
mobj->renderflags ^= INT32_MAX;
P_MoveOrigin(mobj, mobj->target->x + FixedMul(34 * mapobjectscale, FINECOSINE((mobj->angle + mobj->movedir) >> ANGLETOFINESHIFT)),
mobj->target->y + FixedMul(34 * mapobjectscale, FINESINE((mobj->angle + mobj->movedir) >> ANGLETOFINESHIFT)),
mobj->z + (32 * mapobjectscale * P_MobjFlip(mobj)));
if (vfx)
break;
}
{
statenum_t gainaxstate = mobj->state-states;
@ -8442,22 +8441,20 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
return false;
}
mobj->z = mobj->target->z;
K_MatchGenericExtraFlags(mobj, mobj->target);
{
INT32 perpendicular = ((mobj->extravalue1 & 1) ? -ANGLE_90 : ANGLE_90);
const INT32 perpendicular = ((mobj->extravalue1 & 1) ? -ANGLE_90 : ANGLE_90);
fixed_t newx = mobj->target->x + P_ReturnThrustX(NULL, mobj->target->angle + perpendicular, 8*mobj->target->scale);
fixed_t newy = mobj->target->y + P_ReturnThrustY(NULL, mobj->target->angle + perpendicular, 8*mobj->target->scale);
P_MoveOrigin(mobj, newx, newy, mobj->target->z);
K_MatchGenericExtraFlags(mobj, mobj->target);
if (mobj->extravalue1 & 1)
mobj->angle = mobj->target->angle - ANGLE_45;
else
mobj->angle = mobj->target->angle + ANGLE_45;
}
break;
case MT_TIREGREASE:
if (!mobj->target || P_MobjWasRemoved(mobj->target) || !mobj->target->player
@ -8467,12 +8464,9 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
return false;
}
K_MatchGenericExtraFlags(mobj, mobj->target);
{
const angle_t off = FixedAngle(40*FRACUNIT);
angle_t ang = K_MomentumAngle(mobj->target);
fixed_t z;
UINT8 trans = (mobj->target->player->tiregrease * (NUMTRANSMAPS+1)) / greasetics;
if (trans > NUMTRANSMAPS)
@ -8480,10 +8474,6 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
trans = NUMTRANSMAPS - trans;
z = mobj->target->z;
if (mobj->eflags & MFE_VERTICALFLIP)
z += mobj->target->height;
if (mobj->extravalue1)
ang = (signed)(ang - off);
else
@ -8492,7 +8482,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_MoveOrigin(mobj,
mobj->target->x - FixedMul(mobj->target->radius, FINECOSINE(ang >> ANGLETOFINESHIFT)),
mobj->target->y - FixedMul(mobj->target->radius, FINESINE(ang >> ANGLETOFINESHIFT)),
z);
mobj->target->z);
K_MatchGenericExtraFlags(mobj, mobj->target);
mobj->angle = ang;
if (!P_IsObjectOnGround(mobj->target))
@ -8632,12 +8623,9 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
return false;
}
statenum_t stateindex = mobj->target->state - states;
mobj->x = mobj->target->x;
mobj->y = mobj->target->y;
mobj->z = mobj->target->z + mobj->target->height/4;
const statenum_t stateindex = mobj->target->state - states;
P_MoveOrigin(mobj, mobj->target->x, mobj->target->y, mobj->target->z + mobj->target->height/4);
K_MatchGenericExtraFlags(mobj, mobj->target);
mobj->color = mobj->target->color;
@ -8830,8 +8818,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_SetScale(mobj, (mobj->destscale = (5*mobj->target->scale)>>2));
P_MoveOrigin(mobj, mobj->target->x, mobj->target->y, mobj->target->z + mobj->target->height/2);
// Taken from K_FlipFromObject. We just want to flip the visual according to its target, but that's it.
mobj->eflags = (mobj->eflags & ~MFE_VERTICALFLIP)|(mobj->target->eflags & MFE_VERTICALFLIP);
K_FlipFromObject(mobj, mobj->target);
break;
}
@ -9033,7 +9020,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
fast->momy = 3*mobj->target->momy/4;
fast->momz = 3*P_GetMobjZMovement(mobj->target)/4;
K_MatchGenericExtraFlags(fast, mobj);
K_MatchGenericExtraFlagsNoInterp(fast, mobj);
P_SetMobjState(fast, S_FLAMESHIELDLINE1 + i);
}
}
@ -9062,9 +9049,8 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
}
}
// Taken from K_FlipFromObject. We just want to flip the visual according to its target, but that's it.
mobj->eflags = (mobj->eflags & ~MFE_VERTICALFLIP)|(mobj->target->eflags & MFE_VERTICALFLIP);
P_MoveOrigin(mobj, mobj->target->x, mobj->target->y, mobj->target->z + mobj->target->height/2);
K_MatchFlipFlags(mobj, mobj->target);
mobj->angle = K_MomentumAngle(mobj->target);
if (underlayst != S_NULL)
@ -9279,8 +9265,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
}
// Update mobj antigravity status:
mobj->eflags = (mobj->eflags & ~MFE_VERTICALFLIP)|(mobj->target->eflags & MFE_VERTICALFLIP);
mobj->flags2 = (mobj->flags2 & ~MF2_OBJECTFLIP)|(mobj->target->flags2 & MF2_OBJECTFLIP);
K_MatchFlipFlags(mobj, mobj->target);
// Now for the wheels
{
@ -10058,7 +10043,7 @@ static boolean P_MobjRegularThink(mobj_t *mobj)
P_SetTarget(&wave->target, mobj);
wave->angle = mobj->angle - (ANGLE_90 * sign); // point completely perpendicular from the bubble
K_FlipFromObject(wave, mobj);
K_FlipFromObjectNoInterp(wave, mobj);
P_Thrust(wave, wave->angle, 4*mobj->scale);
}
@ -12789,31 +12774,31 @@ void P_SpawnPlayer(INT32 playernum)
mobj_t *ring = P_SpawnMobj(p->mo->x, p->mo->y, p->mo->z, MT_BLOCKRING);
P_SetTarget(&ring->target, p->mo);
P_SetScale(ring, p->mo->scale);
K_MatchGenericExtraFlags(ring, p->mo);
K_MatchGenericExtraFlagsNoInterp(ring, p->mo);
ring->renderflags &= ~RF_DONTDRAW;
mobj_t *body = P_SpawnMobj(p->mo->x, p->mo->y, p->mo->z, MT_BLOCKBODY);
P_SetTarget(&body->target, p->mo);
P_SetScale(body, p->mo->scale);
K_MatchGenericExtraFlags(body, p->mo);
K_MatchGenericExtraFlagsNoInterp(body, p->mo);
body->renderflags |= RF_DONTDRAW;
mobj_t *aring = P_SpawnMobj(p->mo->x, p->mo->y, p->mo->z, MT_AMPRING);
P_SetTarget(&aring->target, p->mo);
P_SetScale(aring, p->mo->scale);
K_MatchGenericExtraFlags(aring, p->mo);
K_MatchGenericExtraFlagsNoInterp(aring, p->mo);
aring->renderflags |= RF_DONTDRAW;
mobj_t *abody = P_SpawnMobj(p->mo->x, p->mo->y, p->mo->z, MT_AMPBODY);
P_SetTarget(&abody->target, p->mo);
P_SetScale(abody, p->mo->scale);
K_MatchGenericExtraFlags(abody, p->mo);
K_MatchGenericExtraFlagsNoInterp(abody, p->mo);
abody->renderflags |= RF_DONTDRAW;
mobj_t *aaura = P_SpawnMobj(p->mo->x, p->mo->y, p->mo->z, MT_AMPAURA);
P_SetTarget(&aaura->target, p->mo);
P_SetScale(aaura, p->mo->scale);
K_MatchGenericExtraFlags(aaura, p->mo);
K_MatchGenericExtraFlagsNoInterp(aaura, p->mo);
aaura->renderflags |= RF_DONTDRAW;
if (K_PlayerGuard(p))