mirror of
https://git.do.srb2.org/STJr/SRB2.git
synced 2024-11-14 17:01:07 +00:00
Revert "Improve slope physics on solid middle textures"
This reverts commit e67e225ff2
.
This commit is contained in:
parent
6bf58ce870
commit
3d4c9eedf8
10 changed files with 35 additions and 189 deletions
|
@ -399,7 +399,6 @@ extern camera_t *mapcampointer;
|
|||
extern fixed_t tmx;
|
||||
extern fixed_t tmy;
|
||||
extern pslope_t *tmfloorslope, *tmceilingslope;
|
||||
extern line_t *tmfloorline, *tmceilingline;
|
||||
|
||||
/* cphipps 2004/08/30 */
|
||||
extern void P_MapStart(void);
|
||||
|
|
27
src/p_map.c
27
src/p_map.c
|
@ -55,7 +55,6 @@ mobj_t *tmfloorthing; // the thing corresponding to tmfloorz or NULL if tmfloorz
|
|||
mobj_t *tmhitthing; // the solid thing you bumped into (for collisions)
|
||||
ffloor_t *tmfloorrover, *tmceilingrover;
|
||||
pslope_t *tmfloorslope, *tmceilingslope;
|
||||
line_t *tmfloorline, *tmceilingline;
|
||||
|
||||
// keep track of the line that lowers the ceiling,
|
||||
// so missiles don't explode against sky hack walls
|
||||
|
@ -1761,7 +1760,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
|
|||
tmfloorz = thing->z + thing->height;
|
||||
tmfloorrover = NULL;
|
||||
tmfloorslope = NULL;
|
||||
tmfloorline = NULL;
|
||||
}
|
||||
return CHECKTHING_COLLIDE;
|
||||
}
|
||||
|
@ -1781,7 +1779,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
|
|||
tmfloorz = tmceilingz = topz; // block while in air
|
||||
tmceilingrover = NULL;
|
||||
tmceilingslope = NULL;
|
||||
tmceilingline = NULL;
|
||||
tmfloorthing = thing; // needed for side collision
|
||||
|
||||
collide = CHECKTHING_COLLIDE;
|
||||
|
@ -1791,7 +1788,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
|
|||
tmceilingz = topz;
|
||||
tmceilingrover = NULL;
|
||||
tmceilingslope = NULL;
|
||||
tmceilingline = NULL;
|
||||
tmfloorthing = thing; // thing we may stand on
|
||||
|
||||
collide = CHECKTHING_COLLIDE;
|
||||
|
@ -1809,7 +1805,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
|
|||
tmceilingz = thing->z;
|
||||
tmceilingrover = NULL;
|
||||
tmceilingslope = NULL;
|
||||
tmceilingline = NULL;
|
||||
}
|
||||
return CHECKTHING_COLLIDE;
|
||||
}
|
||||
|
@ -1829,7 +1824,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
|
|||
tmfloorz = tmceilingz = topz; // block while in air
|
||||
tmfloorrover = NULL;
|
||||
tmfloorslope = NULL;
|
||||
tmfloorline = NULL;
|
||||
tmfloorthing = thing; // needed for side collision
|
||||
|
||||
collide = CHECKTHING_COLLIDE;
|
||||
|
@ -1839,7 +1833,6 @@ static unsigned PIT_DoCheckThing(mobj_t *thing)
|
|||
tmfloorz = topz;
|
||||
tmfloorrover = NULL;
|
||||
tmfloorslope = NULL;
|
||||
tmfloorline = NULL;
|
||||
tmfloorthing = thing; // thing we may stand on
|
||||
|
||||
collide = CHECKTHING_COLLIDE;
|
||||
|
@ -2007,7 +2000,6 @@ static boolean PIT_CheckLine(line_t *ld)
|
|||
ceilingline = ld;
|
||||
tmceilingrover = openceilingrover;
|
||||
tmceilingslope = opentopslope;
|
||||
tmceilingline = opentopline;
|
||||
}
|
||||
|
||||
if (openbottom > tmfloorz)
|
||||
|
@ -2015,7 +2007,6 @@ static boolean PIT_CheckLine(line_t *ld)
|
|||
tmfloorz = openbottom;
|
||||
tmfloorrover = openfloorrover;
|
||||
tmfloorslope = openbottomslope;
|
||||
tmfloorline = openbottomline;
|
||||
}
|
||||
|
||||
if (highceiling > tmdrpoffceilz)
|
||||
|
@ -2066,8 +2057,6 @@ boolean P_CheckPosition(mobj_t *thing, fixed_t x, fixed_t y)
|
|||
tmceilingz = P_GetCeilingZ(thing, newsubsec->sector, x, y, NULL); //newsubsec->sector->ceilingheight;
|
||||
tmfloorrover = NULL;
|
||||
tmceilingrover = NULL;
|
||||
tmfloorline = NULL;
|
||||
tmceilingline = NULL;
|
||||
tmfloorslope = newsubsec->sector->f_slope;
|
||||
tmceilingslope = newsubsec->sector->c_slope;
|
||||
|
||||
|
@ -2653,8 +2642,6 @@ boolean PIT_PushableMoved(mobj_t *thing)
|
|||
ffloor_t *oldceilrover = tmceilingrover;
|
||||
pslope_t *oldfslope = tmfloorslope;
|
||||
pslope_t *oldcslope = tmceilingslope;
|
||||
line_t *oldfline = tmfloorline;
|
||||
line_t *oldcline = tmceilingline;
|
||||
|
||||
// Move the player
|
||||
P_TryMove(thing, thing->x+stand->momx, thing->y+stand->momy, true);
|
||||
|
@ -2671,8 +2658,6 @@ boolean PIT_PushableMoved(mobj_t *thing)
|
|||
tmceilingrover = oldceilrover;
|
||||
tmfloorslope = oldfslope;
|
||||
tmceilingslope = oldcslope;
|
||||
tmfloorline = oldfline;
|
||||
tmceilingline = oldcline;
|
||||
thing->momz = stand->momz;
|
||||
}
|
||||
else
|
||||
|
@ -2914,12 +2899,11 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
|||
// Assign thing's standingslope if needed
|
||||
if (thing->z <= tmfloorz && !(thing->eflags & MFE_VERTICALFLIP)) {
|
||||
if (!startingonground && tmfloorslope)
|
||||
P_HandleSlopeLanding(thing, tmfloorslope, tmfloorline);
|
||||
P_HandleSlopeLanding(thing, tmfloorslope);
|
||||
|
||||
if (thing->momz <= 0)
|
||||
{
|
||||
thing->standingslope = tmfloorslope;
|
||||
thing->standingline = tmfloorline;
|
||||
P_SetPitchRollFromSlope(thing, thing->standingslope);
|
||||
|
||||
if (thing->momz == 0 && thing->player && !startingonground)
|
||||
|
@ -2928,12 +2912,11 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
|||
}
|
||||
else if (thing->z+thing->height >= tmceilingz && (thing->eflags & MFE_VERTICALFLIP)) {
|
||||
if (!startingonground && tmceilingslope)
|
||||
P_HandleSlopeLanding(thing, tmceilingslope, tmceilingline);
|
||||
P_HandleSlopeLanding(thing, tmceilingslope);
|
||||
|
||||
if (thing->momz >= 0)
|
||||
{
|
||||
thing->standingslope = tmceilingslope;
|
||||
thing->standingline = tmceilingline;
|
||||
P_SetPitchRollFromSlope(thing, thing->standingslope);
|
||||
|
||||
if (thing->momz == 0 && thing->player && !startingonground)
|
||||
|
@ -2941,12 +2924,8 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y, boolean allowdropoff)
|
|||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// don't set standingslope or standingline if you're not going to clip against them
|
||||
else // don't set standingslope if you're not going to clip against it
|
||||
thing->standingslope = NULL;
|
||||
thing->standingline = NULL;
|
||||
}
|
||||
|
||||
thing->x = x;
|
||||
thing->y = y;
|
||||
|
|
|
@ -280,7 +280,6 @@ fixed_t P_InterceptVector(divline_t *v2, divline_t *v1)
|
|||
fixed_t opentop, openbottom, openrange, lowfloor, highceiling;
|
||||
pslope_t *opentopslope, *openbottomslope;
|
||||
ffloor_t *openfloorrover, *openceilingrover;
|
||||
line_t *opentopline, *openbottomline;
|
||||
|
||||
// P_CameraLineOpening
|
||||
// P_LineOpening, but for camera
|
||||
|
@ -441,8 +440,6 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
|||
I_Assert(back != NULL);
|
||||
|
||||
openfloorrover = openceilingrover = NULL;
|
||||
opentopline = openbottomline = NULL;
|
||||
|
||||
if (linedef->polyobj)
|
||||
{
|
||||
// set these defaults so that polyobjects don't interfere with collision above or below them
|
||||
|
@ -547,7 +544,6 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
|||
if ((linedef->flags & ML_MIDPEG) != 0) {
|
||||
opentopslope = openbottomslope;
|
||||
}
|
||||
opentopline = linedef;
|
||||
}
|
||||
} else { // Above
|
||||
if (openbottom < textop) {
|
||||
|
@ -555,7 +551,6 @@ void P_LineOpening(line_t *linedef, mobj_t *mobj)
|
|||
if ((linedef->flags & ML_MIDPEG) == 0) {
|
||||
openbottomslope = opentopslope;
|
||||
}
|
||||
openbottomline = linedef;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -57,7 +57,6 @@ boolean P_SceneryTryMove(mobj_t *thing, fixed_t x, fixed_t y);
|
|||
extern fixed_t opentop, openbottom, openrange, lowfloor, highceiling;
|
||||
extern pslope_t *opentopslope, *openbottomslope;
|
||||
extern ffloor_t *openfloorrover, *openceilingrover;
|
||||
extern line_t *opentopline, *openbottomline;
|
||||
|
||||
void P_LineOpening(line_t *plinedef, mobj_t *mobj);
|
||||
|
||||
|
|
31
src/p_mobj.c
31
src/p_mobj.c
|
@ -1672,7 +1672,6 @@ void P_XYMovement(mobj_t *mo)
|
|||
fixed_t oldx, oldy; // reducing bobbing/momentum on ice when up against walls
|
||||
boolean moved;
|
||||
pslope_t *oldslope = NULL;
|
||||
line_t *oldstandingline = NULL;
|
||||
vector3_t slopemom = {0,0,0};
|
||||
fixed_t predictedz = 0;
|
||||
|
||||
|
@ -1705,10 +1704,7 @@ void P_XYMovement(mobj_t *mo)
|
|||
oldy = mo->y;
|
||||
|
||||
if (mo->flags & MF_NOCLIPHEIGHT)
|
||||
{
|
||||
mo->standingslope = NULL;
|
||||
mo->standingline = NULL;
|
||||
}
|
||||
|
||||
// adjust various things based on slope
|
||||
if (mo->standingslope && abs(mo->standingslope->zdelta) > FRACUNIT>>8) {
|
||||
|
@ -1720,7 +1716,7 @@ void P_XYMovement(mobj_t *mo)
|
|||
slopemom.x = xmove;
|
||||
slopemom.y = ymove;
|
||||
slopemom.z = 0;
|
||||
P_QuantizeObjectMomentumToSlope(mo, &slopemom);
|
||||
P_QuantizeMomentumToSlope(&slopemom, mo->standingslope);
|
||||
|
||||
xmove = slopemom.x;
|
||||
ymove = slopemom.y;
|
||||
|
@ -1728,7 +1724,6 @@ void P_XYMovement(mobj_t *mo)
|
|||
predictedz = mo->z + slopemom.z; // We'll use this later...
|
||||
|
||||
oldslope = mo->standingslope;
|
||||
oldstandingline = mo->standingline;
|
||||
}
|
||||
} else if (P_IsObjectOnGround(mo) && !mo->momz)
|
||||
predictedz = mo->z;
|
||||
|
@ -1804,16 +1799,12 @@ void P_XYMovement(mobj_t *mo)
|
|||
{ // try to slide along it
|
||||
// Wall transfer part 1.
|
||||
pslope_t *transferslope = NULL;
|
||||
line_t *transferline = NULL;
|
||||
fixed_t transfermomz = 0;
|
||||
if (oldslope && (P_MobjFlip(mo)*(predictedz - mo->z) > 0)) // Only for moving up (relative to gravity), otherwise there's a failed launch when going down slopes and hitting walls
|
||||
{
|
||||
angle_t zangle;
|
||||
transferslope = ((mo->standingslope) ? mo->standingslope : oldslope);
|
||||
transferline = ((mo->standingline) ? mo->standingline : oldstandingline);
|
||||
zangle = P_GetStandingSlopeZAngle(transferslope, transferline);
|
||||
if (((zangle < ANGLE_180) ? zangle : InvAngle(zangle)) >= ANGLE_45) // Prevent some weird stuff going on on shallow slopes.
|
||||
transfermomz = P_GetWallTransferMomZ(mo, transferslope, transferline);
|
||||
if (((transferslope->zangle < ANGLE_180) ? transferslope->zangle : InvAngle(transferslope->zangle)) >= ANGLE_45) // Prevent some weird stuff going on on shallow slopes.
|
||||
transfermomz = P_GetWallTransferMomZ(mo, transferslope);
|
||||
}
|
||||
|
||||
P_SlideMove(mo);
|
||||
|
@ -1826,7 +1817,7 @@ void P_XYMovement(mobj_t *mo)
|
|||
{
|
||||
angle_t relation; // Scale transfer momentum based on how head-on it is to the slope.
|
||||
if (mo->momx || mo->momy) // "Guess" the angle of the wall you hit using new momentum
|
||||
relation = P_GetStandingSlopeDirection(transferslope, transferline) - R_PointToAngle2(0, 0, mo->momx, mo->momy);
|
||||
relation = transferslope->xydirection - R_PointToAngle2(0, 0, mo->momx, mo->momy);
|
||||
else // Give it for free, I guess.
|
||||
relation = ANGLE_90;
|
||||
transfermomz = FixedMul(transfermomz,
|
||||
|
@ -1835,7 +1826,6 @@ void P_XYMovement(mobj_t *mo)
|
|||
{
|
||||
mo->momz = transfermomz;
|
||||
mo->standingslope = NULL;
|
||||
mo->standingline = NULL;
|
||||
if (player)
|
||||
{
|
||||
player->powers[pw_justlaunched] = 2;
|
||||
|
@ -1885,7 +1875,7 @@ void P_XYMovement(mobj_t *mo)
|
|||
oldangle = FixedMul((signed)oldslope->zangle, FINECOSINE((moveangle - oldslope->xydirection) >> ANGLETOFINESHIFT));
|
||||
|
||||
if (mo->standingslope)
|
||||
newangle = FixedMul((signed)P_GetObjectStandingSlopeZAngle(mo), FINECOSINE((moveangle - P_GetObjectStandingSlopeDirection(mo)) >> ANGLETOFINESHIFT));
|
||||
newangle = FixedMul((signed)mo->standingslope->zangle, FINECOSINE((moveangle - mo->standingslope->xydirection) >> ANGLETOFINESHIFT));
|
||||
else
|
||||
newangle = 0;
|
||||
|
||||
|
@ -1909,7 +1899,7 @@ void P_XYMovement(mobj_t *mo)
|
|||
}
|
||||
} else if (moved && mo->standingslope && predictedz) {
|
||||
angle_t moveangle = R_PointToAngle2(0, 0, mo->momx, mo->momy);
|
||||
angle_t newangle = FixedMul((signed)P_GetObjectStandingSlopeZAngle(mo), FINECOSINE((moveangle - P_GetObjectStandingSlopeDirection(mo)) >> ANGLETOFINESHIFT));
|
||||
angle_t newangle = FixedMul((signed)mo->standingslope->zangle, FINECOSINE((moveangle - mo->standingslope->xydirection) >> ANGLETOFINESHIFT));
|
||||
|
||||
/*CONS_Printf("flat to angle %f - predicted z of %f\n",
|
||||
FIXED_TO_FLOAT(AngleFixed(ANGLE_MAX-newangle)),
|
||||
|
@ -2442,9 +2432,8 @@ boolean P_ZMovement(mobj_t *mo)
|
|||
if (((mo->eflags & MFE_VERTICALFLIP) ? tmceilingslope : tmfloorslope) && (mo->type != MT_STEAM))
|
||||
{
|
||||
mo->standingslope = (mo->eflags & MFE_VERTICALFLIP) ? tmceilingslope : tmfloorslope;
|
||||
mo->standingline = (mo->eflags & MFE_VERTICALFLIP) ? tmceilingline : tmfloorline;
|
||||
P_SetPitchRollFromSlope(mo, mo->standingslope);
|
||||
P_ReverseQuantizeObjectMomentumToSlope(mo, &mom);
|
||||
P_ReverseQuantizeMomentumToSlope(&mom, mo->standingslope);
|
||||
}
|
||||
|
||||
// hit the floor
|
||||
|
@ -2590,7 +2579,7 @@ boolean P_ZMovement(mobj_t *mo)
|
|||
mom.z = tmfloorthing->momz;
|
||||
|
||||
if (mo->standingslope) { // MT_STEAM will never have a standingslope, see above.
|
||||
P_QuantizeObjectMomentumToSlope(mo, &mom);
|
||||
P_QuantizeMomentumToSlope(&mom, mo->standingslope);
|
||||
}
|
||||
|
||||
mo->momx = mom.x;
|
||||
|
@ -2836,9 +2825,7 @@ void P_PlayerZMovement(mobj_t *mo)
|
|||
|
||||
if (!mo->standingslope && (mo->eflags & MFE_VERTICALFLIP ? tmceilingslope : tmfloorslope)) {
|
||||
// Handle landing on slope during Z movement
|
||||
P_HandleSlopeLanding(mo,
|
||||
(mo->eflags & MFE_VERTICALFLIP ? tmceilingslope : tmfloorslope),
|
||||
(mo->eflags & MFE_VERTICALFLIP ? tmceilingline : tmfloorline));
|
||||
P_HandleSlopeLanding(mo, (mo->eflags & MFE_VERTICALFLIP ? tmceilingslope : tmfloorslope));
|
||||
}
|
||||
|
||||
if (P_MobjFlip(mo)*mo->momz < 0) // falling
|
||||
|
|
|
@ -412,9 +412,7 @@ typedef struct mobj_s
|
|||
INT32 cusval;
|
||||
INT32 cvmem;
|
||||
|
||||
struct pslope_s *standingslope; // The slope that the object is standing on (shouldn't need synced in savegames, right?) (it does)
|
||||
|
||||
struct line_s *standingline; // The line that the object is standing on
|
||||
struct pslope_s *standingslope; // The slope that the object is standing on (shouldn't need synced in savegames, right?)
|
||||
|
||||
boolean resetinterp; // if true, some fields should not be interpolated (see R_InterpolateMobjState implementation)
|
||||
boolean colorized; // Whether the mobj uses the rainbow colormap
|
||||
|
|
|
@ -1746,8 +1746,7 @@ typedef enum
|
|||
MD2_DISPOFFSET = 1<<23,
|
||||
MD2_DRAWONLYFORPLAYER = 1<<24,
|
||||
MD2_DONTDRAWFORVIEWMOBJ = 1<<25,
|
||||
MD2_TRANSLATION = 1<<26,
|
||||
MD2_STANDINGLINE = 1<<27
|
||||
MD2_TRANSLATION = 1<<26
|
||||
} mobj_diff2_t;
|
||||
|
||||
typedef enum
|
||||
|
@ -1954,8 +1953,6 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
|
|||
diff2 |= MD2_CEILINGROVER;
|
||||
if (mobj->standingslope)
|
||||
diff2 |= MD2_SLOPE;
|
||||
if (mobj->standingline)
|
||||
diff2 |= MD2_STANDINGLINE;
|
||||
if (mobj->colorized)
|
||||
diff2 |= MD2_COLORIZED;
|
||||
if (mobj->mirrored)
|
||||
|
@ -2128,8 +2125,6 @@ static void SaveMobjThinker(const thinker_t *th, const UINT8 type)
|
|||
WRITEUINT32(save_p, mobj->hprev->mobjnum);
|
||||
if (diff2 & MD2_SLOPE)
|
||||
WRITEUINT16(save_p, mobj->standingslope->id);
|
||||
if (diff2 & MD2_STANDINGLINE)
|
||||
WRITEUINT32(save_p, SaveLine(mobj->standingline));
|
||||
if (diff2 & MD2_COLORIZED)
|
||||
WRITEUINT8(save_p, mobj->colorized);
|
||||
if (diff2 & MD2_MIRRORED)
|
||||
|
@ -3186,8 +3181,6 @@ static thinker_t* LoadMobjThinker(actionf_p1 thinker)
|
|||
mobj->hprev = (mobj_t *)(size_t)READUINT32(save_p);
|
||||
if (diff2 & MD2_SLOPE)
|
||||
mobj->standingslope = P_SlopeById(READUINT16(save_p));
|
||||
if (diff2 & MD2_STANDINGLINE)
|
||||
mobj->standingline = LoadLine(READUINT32(save_p));
|
||||
if (diff2 & MD2_COLORIZED)
|
||||
mobj->colorized = READUINT8(save_p);
|
||||
if (diff2 & MD2_MIRRORED)
|
||||
|
|
130
src/p_slopes.c
130
src/p_slopes.c
|
@ -859,10 +859,11 @@ fixed_t P_GetLightZAt(const lightlist_t *light, fixed_t x, fixed_t y)
|
|||
// When given a vector, rotates it and aligns it to a slope
|
||||
void P_QuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope)
|
||||
{
|
||||
vector3_t axis; // Fuck you, C90.
|
||||
|
||||
if (slope->flags & SL_NOPHYSICS)
|
||||
return; // No physics, no quantizing.
|
||||
|
||||
vector3_t axis;
|
||||
axis.x = -slope->d.y;
|
||||
axis.y = slope->d.x;
|
||||
axis.z = 0;
|
||||
|
@ -876,91 +877,9 @@ void P_QuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope)
|
|||
// When given a vector, rotates and aligns it to a flat surface (from being relative to a given slope)
|
||||
void P_ReverseQuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope)
|
||||
{
|
||||
if (slope->flags & SL_NOPHYSICS)
|
||||
return; // No physics, no quantizing.
|
||||
|
||||
vector3_t axis;
|
||||
axis.x = -slope->d.y;
|
||||
axis.y = slope->d.x;
|
||||
axis.z = 0;
|
||||
|
||||
FV3_Rotate(momentum, &axis, InvAngle(slope->zangle) >> ANGLETOFINESHIFT);
|
||||
}
|
||||
|
||||
angle_t P_GetStandingSlopeZAngle(pslope_t *slope, line_t *line)
|
||||
{
|
||||
angle_t zangle = slope->zangle;
|
||||
|
||||
if (line)
|
||||
{
|
||||
zangle = R_PointToAngle2(0, P_GetSlopeZAt(slope, line->v1->x, line->v1->y),
|
||||
R_PointToDist2(line->v1->x, line->v1->y, line->v2->x, line->v2->y), P_GetSlopeZAt(slope, line->v2->x, line->v2->y));
|
||||
}
|
||||
|
||||
return zangle;
|
||||
}
|
||||
|
||||
angle_t P_GetStandingSlopeDirection(pslope_t *slope, line_t *line)
|
||||
{
|
||||
angle_t xydirection = slope->xydirection;
|
||||
|
||||
if (line)
|
||||
{
|
||||
xydirection = R_PointToAngle2(line->v1->x, line->v1->y, line->v2->x, line->v2->y);
|
||||
}
|
||||
|
||||
return xydirection;
|
||||
}
|
||||
|
||||
angle_t P_GetObjectStandingSlopeZAngle(mobj_t *mo)
|
||||
{
|
||||
return P_GetStandingSlopeZAngle(mo->standingslope, mo->standingline);
|
||||
}
|
||||
|
||||
angle_t P_GetObjectStandingSlopeDirection(mobj_t *mo)
|
||||
{
|
||||
return P_GetStandingSlopeDirection(mo->standingslope, mo->standingline);
|
||||
}
|
||||
|
||||
static void QuantizeMomentumToSlope(pslope_t *slope, line_t *line, vector3_t *momentum, boolean reverse)
|
||||
{
|
||||
if (!slope || slope->flags & SL_NOPHYSICS)
|
||||
return;
|
||||
|
||||
angle_t zangle = P_GetStandingSlopeZAngle(slope, line);
|
||||
|
||||
if (reverse)
|
||||
zangle = InvAngle(zangle);
|
||||
|
||||
vector3_t axis;
|
||||
axis.z = 0;
|
||||
|
||||
if (line)
|
||||
{
|
||||
fixed_t len = R_PointToDist2(0, 0, line->dx, line->dy);
|
||||
axis.x = FixedDiv(line->dy, len);
|
||||
axis.y = -FixedDiv(line->dx, len);
|
||||
}
|
||||
else
|
||||
{
|
||||
axis.x = -slope->d.y;
|
||||
axis.y = slope->d.x;
|
||||
}
|
||||
|
||||
FV3_Rotate(momentum, &axis, zangle >> ANGLETOFINESHIFT);
|
||||
}
|
||||
|
||||
// Given a vector of the object's momentum, rotates it and aligns it to the slope the object is standing on
|
||||
void P_QuantizeObjectMomentumToSlope(mobj_t *mo, vector3_t *momentum)
|
||||
{
|
||||
QuantizeMomentumToSlope(mo->standingslope, mo->standingline, momentum, false);
|
||||
}
|
||||
|
||||
// Given a vector of the object's momentum, rotates and aligns it to a flat surface
|
||||
// (from being relative to the slope the object is standing on)
|
||||
void P_ReverseQuantizeObjectMomentumToSlope(mobj_t *mo, vector3_t *momentum)
|
||||
{
|
||||
QuantizeMomentumToSlope(mo->standingslope, mo->standingline, momentum, true);
|
||||
slope->zangle = InvAngle(slope->zangle);
|
||||
P_QuantizeMomentumToSlope(momentum, slope);
|
||||
slope->zangle = InvAngle(slope->zangle);
|
||||
}
|
||||
|
||||
//
|
||||
|
@ -980,7 +899,7 @@ void P_SlopeLaunch(mobj_t *mo)
|
|||
slopemom.x = mo->momx;
|
||||
slopemom.y = mo->momy;
|
||||
slopemom.z = mo->momz*2;
|
||||
P_QuantizeObjectMomentumToSlope(mo, &slopemom);
|
||||
P_QuantizeMomentumToSlope(&slopemom, mo->standingslope);
|
||||
|
||||
mo->momx = slopemom.x;
|
||||
mo->momy = slopemom.y;
|
||||
|
@ -1000,7 +919,7 @@ void P_SlopeLaunch(mobj_t *mo)
|
|||
// It would be nice to have a single function that does everything necessary for slope-to-wall transfer.
|
||||
// However, it needs to be seperated out in P_XYMovement to take into account momentum before and after hitting the wall.
|
||||
// This just performs the necessary calculations for getting the base vertical momentum; the horizontal is already reasonably calculated by P_SlideMove.
|
||||
fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope, line_t *line)
|
||||
fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope)
|
||||
{
|
||||
vector3_t slopemom, axis;
|
||||
angle_t ang;
|
||||
|
@ -1008,30 +927,18 @@ fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope, line_t *line)
|
|||
if (slope->flags & SL_NOPHYSICS)
|
||||
return 0;
|
||||
|
||||
angle_t zangle = P_GetStandingSlopeZAngle(slope, line);
|
||||
|
||||
// If there's physics, time for launching.
|
||||
// Doesn't kill the vertical momentum as much as P_SlopeLaunch does.
|
||||
ang = zangle + ANG15*((zangle > 0) ? 1 : -1);
|
||||
ang = slope->zangle + ANG15*((slope->zangle > 0) ? 1 : -1);
|
||||
if (ang > ANGLE_90 && ang < ANGLE_180)
|
||||
ang = ((zangle > 0) ? ANGLE_90 : InvAngle(ANGLE_90)); // hard cap of directly upwards
|
||||
ang = ((slope->zangle > 0) ? ANGLE_90 : InvAngle(ANGLE_90)); // hard cap of directly upwards
|
||||
|
||||
slopemom.x = mo->momx;
|
||||
slopemom.y = mo->momy;
|
||||
slopemom.z = 3*(mo->momz/2);
|
||||
|
||||
if (line)
|
||||
{
|
||||
fixed_t len = R_PointToDist2(0, 0, line->dx, line->dy);
|
||||
axis.x = FixedDiv(line->dy, len);
|
||||
axis.y = -FixedDiv(line->dx, len);
|
||||
}
|
||||
else
|
||||
{
|
||||
axis.x = -slope->d.y;
|
||||
axis.y = slope->d.x;
|
||||
}
|
||||
|
||||
axis.x = -slope->d.y;
|
||||
axis.y = slope->d.x;
|
||||
axis.z = 0;
|
||||
|
||||
FV3_Rotate(&slopemom, &axis, ang >> ANGLETOFINESHIFT);
|
||||
|
@ -1040,7 +947,7 @@ fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope, line_t *line)
|
|||
}
|
||||
|
||||
// Function to help handle landing on slopes
|
||||
void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope, line_t *line)
|
||||
void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope)
|
||||
{
|
||||
vector3_t mom; // Ditto.
|
||||
if (slope->flags & SL_NOPHYSICS || (slope->normal.x == 0 && slope->normal.y == 0)) { // No physics, no need to make anything complicated.
|
||||
|
@ -1059,13 +966,12 @@ void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope, line_t *line)
|
|||
mom.y = thing->momy;
|
||||
mom.z = thing->momz*2;
|
||||
|
||||
QuantizeMomentumToSlope(slope, line, &mom, true);
|
||||
P_ReverseQuantizeMomentumToSlope(&mom, slope);
|
||||
|
||||
if (P_MobjFlip(thing)*mom.z < 0) { // falling, land on slope
|
||||
thing->momx = mom.x;
|
||||
thing->momy = mom.y;
|
||||
thing->standingslope = slope;
|
||||
thing->standingline = line;
|
||||
P_SetPitchRollFromSlope(thing, slope);
|
||||
if (!thing->player || !(thing->player->pflags & PF_BOUNCING))
|
||||
thing->momz = -P_MobjFlip(thing);
|
||||
|
@ -1077,7 +983,6 @@ void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope, line_t *line)
|
|||
void P_ButteredSlope(mobj_t *mo)
|
||||
{
|
||||
fixed_t thrust;
|
||||
angle_t zangle, xydirection;
|
||||
|
||||
if (!mo->standingslope)
|
||||
return;
|
||||
|
@ -1096,15 +1001,12 @@ void P_ButteredSlope(mobj_t *mo)
|
|||
return; // Allow the player to stand still on slopes below a certain steepness
|
||||
}
|
||||
|
||||
zangle = P_GetStandingSlopeZAngle(mo->standingslope, mo->standingline);
|
||||
xydirection = P_GetStandingSlopeDirection(mo->standingslope, mo->standingline);
|
||||
|
||||
thrust = FINESINE(zangle>>ANGLETOFINESHIFT) * 3 / 2 * (mo->eflags & MFE_VERTICALFLIP ? 1 : -1);
|
||||
thrust = FINESINE(mo->standingslope->zangle>>ANGLETOFINESHIFT) * 3 / 2 * (mo->eflags & MFE_VERTICALFLIP ? 1 : -1);
|
||||
|
||||
if (mo->player && (mo->player->pflags & PF_SPINNING)) {
|
||||
fixed_t mult = 0;
|
||||
if (mo->momx || mo->momy) {
|
||||
angle_t angle = R_PointToAngle2(0, 0, mo->momx, mo->momy) - xydirection;
|
||||
angle_t angle = R_PointToAngle2(0, 0, mo->momx, mo->momy) - mo->standingslope->xydirection;
|
||||
|
||||
if (P_MobjFlip(mo) * mo->standingslope->zdelta < 0)
|
||||
angle ^= ANGLE_180;
|
||||
|
@ -1125,5 +1027,5 @@ void P_ButteredSlope(mobj_t *mo)
|
|||
// ... and its friction against the ground for good measure (divided by original friction to keep behaviour for normal slopes the same).
|
||||
thrust = FixedMul(thrust, FixedDiv(mo->friction, ORIG_FRICTION));
|
||||
|
||||
P_Thrust(mo, xydirection, thrust);
|
||||
P_Thrust(mo, mo->standingslope->xydirection, thrust);
|
||||
}
|
||||
|
|
|
@ -84,15 +84,9 @@ fixed_t P_GetLightZAt(const lightlist_t *light, fixed_t x, fixed_t y);
|
|||
// Lots of physics-based bullshit
|
||||
void P_QuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope);
|
||||
void P_ReverseQuantizeMomentumToSlope(vector3_t *momentum, pslope_t *slope);
|
||||
void P_QuantizeObjectMomentumToSlope(mobj_t *mo, vector3_t *momentum);
|
||||
void P_ReverseQuantizeObjectMomentumToSlope(mobj_t *mo, vector3_t *momentum);
|
||||
angle_t P_GetStandingSlopeZAngle(pslope_t *slope, line_t *line);
|
||||
angle_t P_GetStandingSlopeDirection(pslope_t *slope, line_t *line);
|
||||
angle_t P_GetObjectStandingSlopeZAngle(mobj_t *mo);
|
||||
angle_t P_GetObjectStandingSlopeDirection(mobj_t *mo);
|
||||
void P_SlopeLaunch(mobj_t *mo);
|
||||
fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope, line_t *line);
|
||||
void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope, line_t *line);
|
||||
fixed_t P_GetWallTransferMomZ(mobj_t *mo, pslope_t *slope);
|
||||
void P_HandleSlopeLanding(mobj_t *thing, pslope_t *slope);
|
||||
void P_ButteredSlope(mobj_t *mo);
|
||||
|
||||
pslope_t *P_MakeSlopeViaEquationConstants(const double a, const double b, const double c, const double d);
|
||||
|
|
|
@ -6257,15 +6257,15 @@ static void P_3dMovement(player_t *player)
|
|||
&& player->mo->standingslope && (!(player->mo->standingslope->flags & SL_NOPHYSICS)) && abs(player->mo->standingslope->zdelta) > FRACUNIT/2) {
|
||||
// Factor thrust to slope, but only for the part pushing up it!
|
||||
// The rest is unaffected.
|
||||
angle_t thrustangle = R_PointToAngle2(0, 0, totalthrust.x, totalthrust.y)-P_GetObjectStandingSlopeDirection(player->mo);
|
||||
angle_t thrustangle = R_PointToAngle2(0, 0, totalthrust.x, totalthrust.y)-player->mo->standingslope->xydirection;
|
||||
|
||||
if (player->mo->standingslope->zdelta < 0) { // Direction goes down, so thrustangle needs to face toward
|
||||
if (thrustangle < ANGLE_90 || thrustangle > ANGLE_270) {
|
||||
P_QuantizeObjectMomentumToSlope(player->mo, &totalthrust);
|
||||
P_QuantizeMomentumToSlope(&totalthrust, player->mo->standingslope);
|
||||
}
|
||||
} else { // Direction goes up, so thrustangle needs to face away
|
||||
if (thrustangle > ANGLE_90 && thrustangle < ANGLE_270) {
|
||||
P_QuantizeObjectMomentumToSlope(player->mo, &totalthrust);
|
||||
P_QuantizeMomentumToSlope(&totalthrust, player->mo->standingslope);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue