mirror of
https://github.com/ZDoom/qzdoom.git
synced 2024-11-11 07:11:54 +00:00
- refactored p_mobj.cpp and the first half of p_map.cpp.
This commit is contained in:
parent
7658111566
commit
7ea3e49332
6 changed files with 403 additions and 360 deletions
31
src/actor.h
31
src/actor.h
|
@ -1252,6 +1252,33 @@ public:
|
|||
fixedvec3 ret = { X(), Y(), Z() };
|
||||
return ret;
|
||||
}
|
||||
fixedvec3 PosRelative(AActor *other) const
|
||||
{
|
||||
fixedvec3 ret = { X(), Y(), Z() };
|
||||
return ret;
|
||||
}
|
||||
fixedvec3 PosRelative(sector_t *sec) const
|
||||
{
|
||||
fixedvec3 ret = { X(), Y(), Z() };
|
||||
return ret;
|
||||
}
|
||||
fixedvec3 PosRelative(line_t *line) const
|
||||
{
|
||||
fixedvec3 ret = { X(), Y(), Z() };
|
||||
return ret;
|
||||
}
|
||||
fixed_t SoundX() const
|
||||
{
|
||||
return X();
|
||||
}
|
||||
fixed_t SoundY() const
|
||||
{
|
||||
return Y();
|
||||
}
|
||||
fixed_t SoundZ() const
|
||||
{
|
||||
return Z();
|
||||
}
|
||||
fixedvec3 InterpolatedPosition(fixed_t ticFrac) const
|
||||
{
|
||||
fixedvec3 ret;
|
||||
|
@ -1418,6 +1445,10 @@ inline fixedvec2 Vec2Angle(fixed_t length, angle_t angle)
|
|||
return ret;
|
||||
}
|
||||
|
||||
inline fixedvec3 PosRelative(const fixedvec3 &pos, line_t *line, sector_t *refsec = NULL)
|
||||
{
|
||||
return pos;
|
||||
}
|
||||
|
||||
void PrintMiscActorInfo(AActor * query);
|
||||
|
||||
|
|
336
src/p_map.cpp
336
src/p_map.cpp
|
@ -581,7 +581,7 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
|
|||
friction = FRICTION_FLY;
|
||||
}
|
||||
else if ((!(mo->flags & MF_NOGRAVITY) && mo->waterlevel > 1) ||
|
||||
(mo->waterlevel == 1 && mo->z > mo->floorz + 6 * FRACUNIT))
|
||||
(mo->waterlevel == 1 && mo->Z() > mo->floorz + 6 * FRACUNIT))
|
||||
{
|
||||
friction = secfriction(mo->Sector);
|
||||
movefactor = secmovefac(mo->Sector) >> 1;
|
||||
|
@ -593,8 +593,8 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
|
|||
if (!(rover->flags & FF_EXISTS)) continue;
|
||||
if (!(rover->flags & FF_SWIMMABLE)) continue;
|
||||
|
||||
if (mo->z > rover->top.plane->ZatPoint(mo) ||
|
||||
mo->z < rover->bottom.plane->ZatPoint(mo))
|
||||
if (mo->Z() > rover->top.plane->ZatPoint(mo) ||
|
||||
mo->Z() < rover->bottom.plane->ZatPoint(mo))
|
||||
continue;
|
||||
|
||||
newfriction = secfriction(rover->model, rover->top.isceiling);
|
||||
|
@ -623,13 +623,13 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
|
|||
if (rover->flags & FF_SOLID)
|
||||
{
|
||||
// Must be standing on a solid floor
|
||||
if (mo->z != rover->top.plane->ZatPoint(mo)) continue;
|
||||
if (mo->Z() != rover->top.plane->ZatPoint(mo)) continue;
|
||||
}
|
||||
else if (rover->flags & FF_SWIMMABLE)
|
||||
{
|
||||
// Or on or inside a swimmable floor (e.g. in shallow water)
|
||||
if (mo->z > rover->top.plane->ZatPoint(mo) ||
|
||||
(mo->z + mo->height) < rover->bottom.plane->ZatPoint(mo))
|
||||
if (mo->Z() > rover->top.plane->ZatPoint(mo) ||
|
||||
(mo->Top()) < rover->bottom.plane->ZatPoint(mo))
|
||||
continue;
|
||||
}
|
||||
else
|
||||
|
@ -650,9 +650,9 @@ int P_GetFriction(const AActor *mo, int *frictionfactor)
|
|||
}
|
||||
newfriction = secfriction(sec);
|
||||
if ((newfriction < friction || friction == ORIG_FRICTION) &&
|
||||
(mo->z <= sec->floorplane.ZatPoint(mo) ||
|
||||
(mo->Z() <= sec->floorplane.ZatPoint(mo) ||
|
||||
(sec->GetHeightSec() != NULL &&
|
||||
mo->z <= sec->heightsec->floorplane.ZatPoint(mo))))
|
||||
mo->Z() <= sec->heightsec->floorplane.ZatPoint(mo))))
|
||||
{
|
||||
friction = newfriction;
|
||||
movefactor = secmovefac(sec);
|
||||
|
@ -768,6 +768,7 @@ bool PIT_CheckLine(line_t *ld, const FBoundingBox &box, FCheckPosition &tm)
|
|||
bool NotBlocked = ((tm.thing->flags3 & MF3_NOBLOCKMONST)
|
||||
|| ((i_compatflags & COMPATF_NOBLOCKFRIENDS) && (tm.thing->flags & MF_FRIENDLY)));
|
||||
|
||||
fixedvec3 pos = tm.thing->PosRelative(ld);
|
||||
if (!(Projectile) || (ld->flags & (ML_BLOCKEVERYTHING | ML_BLOCKPROJECTILE)))
|
||||
{
|
||||
if (ld->flags & ML_RAILING)
|
||||
|
@ -786,7 +787,7 @@ bool PIT_CheckLine(line_t *ld, const FBoundingBox &box, FCheckPosition &tm)
|
|||
}
|
||||
tm.thing->BlockingLine = ld;
|
||||
// Calculate line side based on the actor's original position, not the new one.
|
||||
CheckForPushSpecial(ld, P_PointOnLineSide(tm.thing->x, tm.thing->y, ld), tm.thing, false);
|
||||
CheckForPushSpecial(ld, P_PointOnLineSide(pos.x, pos.y, ld), tm.thing, false);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -797,8 +798,8 @@ bool PIT_CheckLine(line_t *ld, const FBoundingBox &box, FCheckPosition &tm)
|
|||
{
|
||||
secplane_t frontplane, backplane;
|
||||
// Check 3D floors as well
|
||||
frontplane = P_FindFloorPlane(ld->frontsector, tm.thing->x, tm.thing->y, tm.thing->floorz);
|
||||
backplane = P_FindFloorPlane(ld->backsector, tm.thing->x, tm.thing->y, tm.thing->floorz);
|
||||
frontplane = P_FindFloorPlane(ld->frontsector, pos.x, pos.y, tm.thing->floorz);
|
||||
backplane = P_FindFloorPlane(ld->backsector, pos.x, pos.y, tm.thing->floorz);
|
||||
if (frontplane.c < STEEPSLOPE || backplane.c < STEEPSLOPE)
|
||||
{
|
||||
const msecnode_t *node = tm.thing->touching_sectorlist;
|
||||
|
@ -853,7 +854,7 @@ bool PIT_CheckLine(line_t *ld, const FBoundingBox &box, FCheckPosition &tm)
|
|||
}
|
||||
else if (r >= (1 << 24))
|
||||
{
|
||||
P_LineOpening(open, tm.thing, ld, sx = ld->v2->x, sy = ld->v2->y, tm.thing->x, tm.thing->y);
|
||||
P_LineOpening(open, tm.thing, ld, sx = ld->v2->x, sy = ld->v2->y, pos.x, pos.y);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1031,8 +1032,9 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
if (!((thing->flags & (MF_SOLID | MF_SPECIAL | MF_SHOOTABLE)) || thing->flags6 & MF6_TOUCHY))
|
||||
return true; // can't hit thing
|
||||
|
||||
fixedvec3 thingpos = thing->PosRelative(tm.thing);
|
||||
fixed_t blockdist = thing->radius + tm.thing->radius;
|
||||
if (abs(thing->x - tm.x) >= blockdist || abs(thing->y - tm.y) >= blockdist)
|
||||
if (abs(thingpos.x - tm.thing->X()) >= blockdist || abs(thingpos.y - tm.thing->Y()) >= blockdist)
|
||||
return true;
|
||||
|
||||
if ((thing->flags2 | tm.thing->flags2) & MF2_THRUACTORS)
|
||||
|
@ -1042,13 +1044,13 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
return true;
|
||||
|
||||
tm.thing->BlockingMobj = thing;
|
||||
topz = thing->z + thing->height;
|
||||
topz = thing->Top();
|
||||
if (!(i_compatflags & COMPATF_NO_PASSMOBJ) && !(tm.thing->flags & (MF_FLOAT | MF_MISSILE | MF_SKULLFLY | MF_NOGRAVITY)) &&
|
||||
(thing->flags & MF_SOLID) && (thing->flags4 & MF4_ACTLIKEBRIDGE))
|
||||
{
|
||||
// [RH] Let monsters walk on actors as well as floors
|
||||
if ((tm.thing->flags3 & MF3_ISMONSTER) &&
|
||||
topz >= tm.floorz && topz <= tm.thing->z + tm.thing->MaxStepHeight)
|
||||
topz >= tm.floorz && topz <= tm.thing->Z() + tm.thing->MaxStepHeight)
|
||||
{
|
||||
// The commented-out if is an attempt to prevent monsters from walking off a
|
||||
// thing further than they would walk off a ledge. I can't think of an easy
|
||||
|
@ -1071,12 +1073,12 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
{
|
||||
// Both actors already overlap. To prevent them from remaining stuck allow the move if it
|
||||
// takes them further apart or the move does not change the position (when called from P_ChangeSector.)
|
||||
if (tm.x == tm.thing->x && tm.y == tm.thing->y)
|
||||
if (tm.x == tm.thing->X() && tm.y == tm.thing->Y())
|
||||
{
|
||||
unblocking = true;
|
||||
}
|
||||
else if (abs(thing->x - tm.thing->x) < (thing->radius+tm.thing->radius) &&
|
||||
abs(thing->y - tm.thing->y) < (thing->radius+tm.thing->radius))
|
||||
else if (abs(thingpos.x - tm.thing->X()) < (thing->radius+tm.thing->radius) &&
|
||||
abs(thingpos.y - tm.thing->Y()) < (thing->radius+tm.thing->radius))
|
||||
|
||||
{
|
||||
fixed_t newdist = thing->AproxDistance(tm.x, tm.y, tm.thing);
|
||||
|
@ -1085,8 +1087,8 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
if (newdist > olddist)
|
||||
{
|
||||
// ... but not if they did not overlap in z-direction before but would after the move.
|
||||
unblocking = !((tm.thing->z >= thing->z + thing->height && tm.z < thing->z + thing->height) ||
|
||||
(tm.thing->z + tm.thing->height <= thing->z && tm.z + tm.thing->height > thing->z));
|
||||
unblocking = !((tm.thing->Z() >= thingpos.z + thing->height && tm.z < thingpos.z + thing->height) ||
|
||||
(tm.thing->Top() <= thingpos.z && tm.thing->Top() > thingpos.z));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1104,7 +1106,7 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
{ // Some things prefer not to overlap each other, if possible
|
||||
return unblocking;
|
||||
}
|
||||
if ((tm.thing->z >= topz) || (tm.thing->z + tm.thing->height <= thing->z))
|
||||
if ((tm.thing->Z() >= topz) || (tm.thing->Top() <= thing->Z()))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
@ -1120,7 +1122,7 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
// or different species if DONTHARMSPECIES
|
||||
(!(thing->flags6 & MF6_DONTHARMSPECIES) || thing->GetSpecies() != tm.thing->GetSpecies()) &&
|
||||
// touches vertically
|
||||
thing->z + thing->height >= tm.thing->z && tm.thing->z + tm.thing->height >= thing->z &&
|
||||
topz >= tm.thing->Z() && tm.thing->Z() + tm.thing->height >= thingpos.z &&
|
||||
// prevents lost souls from exploding when fired by pain elementals
|
||||
(thing->master != tm.thing && tm.thing->master != thing))
|
||||
// Difference with MBF: MBF hardcodes the LS/PE check and lets actors of the same species
|
||||
|
@ -1223,11 +1225,11 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
}
|
||||
|
||||
// Check if it went over / under
|
||||
if (tm.thing->z > thing->z + clipheight)
|
||||
if (tm.thing->Z() > thingpos.z + clipheight)
|
||||
{ // Over thing
|
||||
return true;
|
||||
}
|
||||
if (tm.thing->z + tm.thing->height < thing->z)
|
||||
if (tm.thing->Top() < thingpos.z)
|
||||
{ // Under thing
|
||||
return true;
|
||||
}
|
||||
|
@ -1335,7 +1337,7 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
!(tm.thing->flags3 & MF3_BLOODLESSIMPACT) &&
|
||||
(pr_checkthing() < 192))
|
||||
{
|
||||
P_BloodSplatter(tm.thing->x, tm.thing->y, tm.thing->z, thing);
|
||||
P_BloodSplatter(tm.thing->X(), tm.thing->Y(), tm.thing->Z(), thing);
|
||||
}
|
||||
if (!(tm.thing->flags3 & MF3_BLOODLESSIMPACT))
|
||||
{
|
||||
|
@ -1377,7 +1379,7 @@ bool PIT_CheckThing(AActor *thing, FCheckPosition &tm)
|
|||
// [RH] The next condition is to compensate for the extra height
|
||||
// that gets added by P_CheckPosition() so that you cannot pick
|
||||
// up things that are above your true height.
|
||||
&& thing->z < tm.thing->z + tm.thing->height - tm.thing->MaxStepHeight)
|
||||
&& thingpos.z < tm.thing->Top() - tm.thing->MaxStepHeight)
|
||||
{ // Can be picked up by tmthing
|
||||
P_TouchSpecialThing(thing, tm.thing); // can remove thing
|
||||
}
|
||||
|
@ -1464,7 +1466,7 @@ bool P_CheckPosition(AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm, bo
|
|||
F3DFloor* rover;
|
||||
fixed_t delta1;
|
||||
fixed_t delta2;
|
||||
int thingtop = thing->z + (thing->height == 0 ? 1 : thing->height);
|
||||
int thingtop = thing->Z() + (thing->height == 0 ? 1 : thing->height);
|
||||
|
||||
for (unsigned i = 0; i<newsec->e->XFloor.ffloors.Size(); i++)
|
||||
{
|
||||
|
@ -1474,7 +1476,7 @@ bool P_CheckPosition(AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm, bo
|
|||
fixed_t ff_bottom = rover->bottom.plane->ZatPoint(x, y);
|
||||
fixed_t ff_top = rover->top.plane->ZatPoint(x, y);
|
||||
|
||||
delta1 = thing->z - (ff_bottom + ((ff_top - ff_bottom) / 2));
|
||||
delta1 = thing->Z() - (ff_bottom + ((ff_top - ff_bottom) / 2));
|
||||
delta2 = thingtop - (ff_bottom + ((ff_top - ff_bottom) / 2));
|
||||
|
||||
if (ff_top > tm.floorz && abs(delta1) < abs(delta2))
|
||||
|
@ -1526,17 +1528,17 @@ bool P_CheckPosition(AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm, bo
|
|||
return false;
|
||||
}
|
||||
else if (!BlockingMobj->player && !(thing->flags & (MF_FLOAT | MF_MISSILE | MF_SKULLFLY)) &&
|
||||
BlockingMobj->z + BlockingMobj->height - thing->z <= thing->MaxStepHeight)
|
||||
BlockingMobj->Top() - thing->Z() <= thing->MaxStepHeight)
|
||||
{
|
||||
if (thingblocker == NULL ||
|
||||
BlockingMobj->z > thingblocker->z)
|
||||
BlockingMobj->Z() > thingblocker->Z())
|
||||
{
|
||||
thingblocker = BlockingMobj;
|
||||
}
|
||||
thing->BlockingMobj = NULL;
|
||||
}
|
||||
else if (thing->player &&
|
||||
thing->z + thing->height - BlockingMobj->z <= thing->MaxStepHeight)
|
||||
thing->Top() - BlockingMobj->Z() <= thing->MaxStepHeight)
|
||||
{
|
||||
if (thingblocker)
|
||||
{ // There is something to step up on. Return this thing as
|
||||
|
@ -1629,10 +1631,10 @@ bool P_TestMobjLocation(AActor *mobj)
|
|||
|
||||
flags = mobj->flags;
|
||||
mobj->flags &= ~MF_PICKUP;
|
||||
if (P_CheckPosition(mobj, mobj->x, mobj->y))
|
||||
if (P_CheckPosition(mobj, mobj->X(), mobj->Y()))
|
||||
{ // XY is ok, now check Z
|
||||
mobj->flags = flags;
|
||||
if ((mobj->z < mobj->floorz) || (mobj->z + mobj->height > mobj->ceilingz))
|
||||
if ((mobj->Z() < mobj->floorz) || (mobj->Top() > mobj->ceilingz))
|
||||
{ // Bad Z
|
||||
return false;
|
||||
}
|
||||
|
@ -1656,10 +1658,10 @@ AActor *P_CheckOnmobj(AActor *thing)
|
|||
bool good;
|
||||
AActor *onmobj;
|
||||
|
||||
oldz = thing->z;
|
||||
oldz = thing->Z();
|
||||
P_FakeZMovement(thing);
|
||||
good = P_TestMobjZ(thing, false, &onmobj);
|
||||
thing->z = oldz;
|
||||
thing->SetZ(oldz);
|
||||
|
||||
return good ? NULL : onmobj;
|
||||
}
|
||||
|
@ -1679,7 +1681,7 @@ bool P_TestMobjZ(AActor *actor, bool quick, AActor **pOnmobj)
|
|||
return true;
|
||||
}
|
||||
|
||||
FBlockThingsIterator it(FBoundingBox(actor->x, actor->y, actor->radius));
|
||||
FBlockThingsIterator it(FBoundingBox(actor->X(), actor->Y(), actor->radius));
|
||||
AActor *thing;
|
||||
|
||||
while ((thing = it.Next()))
|
||||
|
@ -1721,15 +1723,15 @@ bool P_TestMobjZ(AActor *actor, bool quick, AActor **pOnmobj)
|
|||
{ // Don't clip against whoever shot the missile.
|
||||
continue;
|
||||
}
|
||||
if (actor->z > thing->z + thing->height)
|
||||
if (actor->Z() > thing->Top())
|
||||
{ // over thing
|
||||
continue;
|
||||
}
|
||||
else if (actor->z + actor->height <= thing->z)
|
||||
else if (actor->Top() <= thing->Z())
|
||||
{ // under thing
|
||||
continue;
|
||||
}
|
||||
else if (!quick && onmobj != NULL && thing->z + thing->height < onmobj->z + onmobj->height)
|
||||
else if (!quick && onmobj != NULL && thing->Top() < onmobj->Top())
|
||||
{ // something higher is in the way
|
||||
continue;
|
||||
}
|
||||
|
@ -1753,35 +1755,35 @@ void P_FakeZMovement(AActor *mo)
|
|||
//
|
||||
// adjust height
|
||||
//
|
||||
mo->z += mo->velz;
|
||||
mo->AddZ(mo->velz);
|
||||
if ((mo->flags&MF_FLOAT) && mo->target)
|
||||
{ // float down towards target if too close
|
||||
if (!(mo->flags & MF_SKULLFLY) && !(mo->flags & MF_INFLOAT))
|
||||
{
|
||||
fixed_t dist = mo->AproxDistance(mo->target);
|
||||
fixed_t delta = (mo->target->z + (mo->height >> 1)) - mo->z;
|
||||
fixed_t delta = (mo->target->Z() + (mo->height >> 1)) - mo->Z();
|
||||
if (delta < 0 && dist < -(delta * 3))
|
||||
mo->z -= mo->FloatSpeed;
|
||||
mo->AddZ(-mo->FloatSpeed);
|
||||
else if (delta > 0 && dist < (delta * 3))
|
||||
mo->z += mo->FloatSpeed;
|
||||
mo->AddZ(mo->FloatSpeed);
|
||||
}
|
||||
}
|
||||
if (mo->player && mo->flags&MF_NOGRAVITY && (mo->z > mo->floorz) && !mo->IsNoClip2())
|
||||
if (mo->player && mo->flags&MF_NOGRAVITY && (mo->Z() > mo->floorz) && !mo->IsNoClip2())
|
||||
{
|
||||
mo->z += finesine[(FINEANGLES / 80 * level.maptime)&FINEMASK] / 8;
|
||||
mo->AddZ(finesine[(FINEANGLES / 80 * level.maptime)&FINEMASK] / 8);
|
||||
}
|
||||
|
||||
//
|
||||
// clip movement
|
||||
//
|
||||
if (mo->z <= mo->floorz)
|
||||
if (mo->Z() <= mo->floorz)
|
||||
{ // hit the floor
|
||||
mo->z = mo->floorz;
|
||||
mo->SetZ(mo->floorz);
|
||||
}
|
||||
|
||||
if (mo->z + mo->height > mo->ceilingz)
|
||||
if (mo->Top() > mo->ceilingz)
|
||||
{ // hit the ceiling
|
||||
mo->z = mo->ceilingz - mo->height;
|
||||
mo->SetZ(mo->ceilingz - mo->height);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1802,8 +1804,8 @@ static void CheckForPushSpecial(line_t *line, int side, AActor *mobj, bool windo
|
|||
fixed_t fzb = line->frontsector->floorplane.ZatPoint(mobj);
|
||||
fixed_t bzt = line->backsector->ceilingplane.ZatPoint(mobj);
|
||||
fixed_t bzb = line->backsector->floorplane.ZatPoint(mobj);
|
||||
if (fzt >= mobj->z + mobj->height && bzt >= mobj->z + mobj->height &&
|
||||
fzb <= mobj->z && bzb <= mobj->z)
|
||||
if (fzt >= mobj->Top() && bzt >= mobj->Top() &&
|
||||
fzb <= mobj->Z() && bzb <= mobj->Z())
|
||||
{
|
||||
// we must also check if some 3D floor in the backsector may be blocking
|
||||
for (unsigned int i = 0; i<line->backsector->e->XFloor.ffloors.Size(); i++)
|
||||
|
@ -1815,7 +1817,7 @@ static void CheckForPushSpecial(line_t *line, int side, AActor *mobj, bool windo
|
|||
fixed_t ff_bottom = rover->bottom.plane->ZatPoint(mobj);
|
||||
fixed_t ff_top = rover->top.plane->ZatPoint(mobj);
|
||||
|
||||
if (ff_bottom < mobj->z + mobj->height && ff_top > mobj->z)
|
||||
if (ff_bottom < mobj->Top() && ff_top > mobj->Z())
|
||||
{
|
||||
goto isblocking;
|
||||
}
|
||||
|
@ -1858,8 +1860,8 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
FCheckPosition &tm,
|
||||
bool missileCheck) // [GZ] Fired missiles ignore the drop-off test
|
||||
{
|
||||
fixed_t oldx;
|
||||
fixed_t oldy;
|
||||
fixedvec3 oldpos;
|
||||
sector_t *oldsector;
|
||||
fixed_t oldz;
|
||||
int side;
|
||||
int oldside;
|
||||
|
@ -1868,10 +1870,10 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
sector_t* newsec;
|
||||
|
||||
tm.floatok = false;
|
||||
oldz = thing->z;
|
||||
oldz = thing->Z();
|
||||
if (onfloor)
|
||||
{
|
||||
thing->z = onfloor->ZatPoint(x, y);
|
||||
thing->SetZ(onfloor->ZatPoint(x, y));
|
||||
}
|
||||
thing->flags6 |= MF6_INTRYMOVE;
|
||||
if (!P_CheckPosition(thing, x, y, tm))
|
||||
|
@ -1888,19 +1890,16 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
{
|
||||
goto pushline;
|
||||
}
|
||||
else if (BlockingMobj->z + BlockingMobj->height - thing->z
|
||||
> thing->MaxStepHeight
|
||||
|| (BlockingMobj->Sector->ceilingplane.ZatPoint(x, y)
|
||||
- (BlockingMobj->z + BlockingMobj->height) < thing->height)
|
||||
|| (tm.ceilingz - (BlockingMobj->z + BlockingMobj->height)
|
||||
< thing->height))
|
||||
else if (BlockingMobj->Top() - thing->Z() > thing->MaxStepHeight
|
||||
|| (BlockingMobj->Sector->ceilingplane.ZatPoint(x, y) - (BlockingMobj->Top()) < thing->height)
|
||||
|| (tm.ceilingz - (BlockingMobj->Top()) < thing->height))
|
||||
{
|
||||
goto pushline;
|
||||
}
|
||||
}
|
||||
if (!(tm.thing->flags2 & MF2_PASSMOBJ) || (i_compatflags & COMPATF_NO_PASSMOBJ))
|
||||
{
|
||||
thing->z = oldz;
|
||||
thing->SetZ(oldz);
|
||||
thing->flags6 &= ~MF6_INTRYMOVE;
|
||||
return false;
|
||||
}
|
||||
|
@ -1908,16 +1907,16 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
|
||||
if (thing->flags3 & MF3_FLOORHUGGER)
|
||||
{
|
||||
thing->z = tm.floorz;
|
||||
thing->SetZ(tm.floorz);
|
||||
}
|
||||
else if (thing->flags3 & MF3_CEILINGHUGGER)
|
||||
{
|
||||
thing->z = tm.ceilingz - thing->height;
|
||||
thing->SetZ(tm.ceilingz - thing->height);
|
||||
}
|
||||
|
||||
if (onfloor && tm.floorsector == thing->floorsector)
|
||||
{
|
||||
thing->z = tm.floorz;
|
||||
thing->SetZ(tm.floorz);
|
||||
}
|
||||
if (!(thing->flags & MF_NOCLIP))
|
||||
{
|
||||
|
@ -1929,7 +1928,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
tm.floatok = true;
|
||||
|
||||
if (!(thing->flags & MF_TELEPORT)
|
||||
&& tm.ceilingz - thing->z < thing->height
|
||||
&& tm.ceilingz - thing->Z() < thing->height
|
||||
&& !(thing->flags3 & MF3_CEILINGHUGGER)
|
||||
&& (!(thing->flags2 & MF2_FLY) || !(thing->flags & MF_NOGRAVITY)))
|
||||
{
|
||||
|
@ -1938,17 +1937,17 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
if (thing->flags2 & MF2_FLY && thing->flags & MF_NOGRAVITY)
|
||||
{
|
||||
#if 1
|
||||
if (thing->z + thing->height > tm.ceilingz)
|
||||
if (thing->Top() > tm.ceilingz)
|
||||
goto pushline;
|
||||
#else
|
||||
// When flying, slide up or down blocking lines until the actor
|
||||
// is not blocked.
|
||||
if (thing->z + thing->height > tm.ceilingz)
|
||||
if (thing->Top() > tm.ceilingz)
|
||||
{
|
||||
thing->velz = -8 * FRACUNIT;
|
||||
goto pushline;
|
||||
}
|
||||
else if (thing->z < tm.floorz && tm.floorz - tm.dropoffz > thing->MaxDropOffHeight)
|
||||
else if (thing->Z() < tm.floorz && tm.floorz - tm.dropoffz > thing->MaxDropOffHeight)
|
||||
{
|
||||
thing->velz = 8 * FRACUNIT;
|
||||
goto pushline;
|
||||
|
@ -1957,28 +1956,28 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
}
|
||||
if (!(thing->flags & MF_TELEPORT) && !(thing->flags3 & MF3_FLOORHUGGER))
|
||||
{
|
||||
if ((thing->flags & MF_MISSILE) && !(thing->flags6 & MF6_STEPMISSILE) && tm.floorz > thing->z)
|
||||
if ((thing->flags & MF_MISSILE) && !(thing->flags6 & MF6_STEPMISSILE) && tm.floorz > thing->Z())
|
||||
{ // [RH] Don't let normal missiles climb steps
|
||||
goto pushline;
|
||||
}
|
||||
if (tm.floorz - thing->z > thing->MaxStepHeight)
|
||||
if (tm.floorz - thing->Z() > thing->MaxStepHeight)
|
||||
{ // too big a step up
|
||||
goto pushline;
|
||||
}
|
||||
else if (thing->z < tm.floorz)
|
||||
else if (thing->Z() < tm.floorz)
|
||||
{ // [RH] Check to make sure there's nothing in the way for the step up
|
||||
fixed_t savedz = thing->z;
|
||||
fixed_t savedz = thing->Z();
|
||||
bool good;
|
||||
thing->z = tm.floorz;
|
||||
thing->SetZ(tm.floorz);
|
||||
good = P_TestMobjZ(thing);
|
||||
thing->z = savedz;
|
||||
thing->SetZ(savedz);
|
||||
if (!good)
|
||||
{
|
||||
goto pushline;
|
||||
}
|
||||
if (thing->flags6 & MF6_STEPMISSILE)
|
||||
{
|
||||
thing->z = tm.floorz;
|
||||
thing->SetZ(tm.floorz);
|
||||
// If moving down, cancel vertical component of the velocity
|
||||
if (thing->velz < 0)
|
||||
{
|
||||
|
@ -2004,7 +2003,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
}
|
||||
|
||||
if (dropoff == 2 && // large jump down (e.g. dogs)
|
||||
(tm.floorz - tm.dropoffz > 128 * FRACUNIT || thing->target == NULL || thing->target->z >tm.dropoffz))
|
||||
(tm.floorz - tm.dropoffz > 128 * FRACUNIT || thing->target == NULL || thing->target->Z() >tm.dropoffz))
|
||||
{
|
||||
dropoff = false;
|
||||
}
|
||||
|
@ -2020,14 +2019,14 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
// This is so that it does not walk off of things onto a drop off.
|
||||
if (thing->flags2 & MF2_ONMOBJ)
|
||||
{
|
||||
floorz = MAX(thing->z, tm.floorz);
|
||||
floorz = MAX(thing->Z(), tm.floorz);
|
||||
}
|
||||
|
||||
if (floorz - tm.dropoffz > thing->MaxDropOffHeight &&
|
||||
!(thing->flags2 & MF2_BLASTED) && !missileCheck)
|
||||
{ // Can't move over a dropoff unless it's been blasted
|
||||
// [GZ] Or missile-spawned
|
||||
thing->z = oldz;
|
||||
thing->SetZ(oldz);
|
||||
thing->flags6 &= ~MF6_INTRYMOVE;
|
||||
return false;
|
||||
}
|
||||
|
@ -2046,9 +2045,9 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
}
|
||||
if (thing->flags2 & MF2_CANTLEAVEFLOORPIC
|
||||
&& (tm.floorpic != thing->floorpic
|
||||
|| tm.floorz - thing->z != 0))
|
||||
|| tm.floorz - thing->Z() != 0))
|
||||
{ // must stay within a sector of a certain floor type
|
||||
thing->z = oldz;
|
||||
thing->SetZ(oldz);
|
||||
thing->flags6 &= ~MF6_INTRYMOVE;
|
||||
return false;
|
||||
}
|
||||
|
@ -2063,7 +2062,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
thing->player->Bot->dest = NULL;
|
||||
thing->velx = 0;
|
||||
thing->vely = 0;
|
||||
thing->z = oldz;
|
||||
thing->SetZ(oldz);
|
||||
thing->flags6 &= ~MF6_INTRYMOVE;
|
||||
return false;
|
||||
}
|
||||
|
@ -2090,7 +2089,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
// Borrowed from MBF:
|
||||
if (thing->BounceFlags & BOUNCE_MBF && // killough 8/13/98
|
||||
!(thing->flags & (MF_MISSILE | MF_NOGRAVITY)) &&
|
||||
!thing->IsSentient() && tm.floorz - thing->z > 16 * FRACUNIT)
|
||||
!thing->IsSentient() && tm.floorz - thing->Z() > 16 * FRACUNIT)
|
||||
{ // too big a step up for MBF bouncers under gravity
|
||||
thing->flags6 &= ~MF6_INTRYMOVE;
|
||||
return false;
|
||||
|
@ -2099,8 +2098,8 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
// the move is ok, so link the thing into its new position
|
||||
thing->UnlinkFromWorld();
|
||||
|
||||
oldx = thing->x;
|
||||
oldy = thing->y;
|
||||
oldpos = thing->Pos();
|
||||
oldsector = thing->Sector;
|
||||
thing->floorz = tm.floorz;
|
||||
thing->ceilingz = tm.ceilingz;
|
||||
thing->dropoffz = tm.dropoffz; // killough 11/98: keep track of dropoffs
|
||||
|
@ -2109,8 +2108,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
thing->floorsector = tm.floorsector;
|
||||
thing->ceilingpic = tm.ceilingpic;
|
||||
thing->ceilingsector = tm.ceilingsector;
|
||||
thing->x = x;
|
||||
thing->y = y;
|
||||
thing->SetXY(x, y);
|
||||
|
||||
thing->LinkToWorld();
|
||||
|
||||
|
@ -2124,9 +2122,11 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
{
|
||||
while (spechit.Pop(ld))
|
||||
{
|
||||
fixedvec3 thingpos = thing->PosRelative(ld);
|
||||
fixedvec3 oldrelpos = PosRelative(oldpos, ld, oldsector);
|
||||
// see if the line was crossed
|
||||
side = P_PointOnLineSide(thing->x, thing->y, ld);
|
||||
oldside = P_PointOnLineSide(oldx, oldy, ld);
|
||||
side = P_PointOnLineSide(thingpos.x, thingpos.y, ld);
|
||||
oldside = P_PointOnLineSide(oldrelpos.x, oldrelpos.y, ld);
|
||||
if (side != oldside && ld->special && !(thing->flags6 & MF6_NOTRIGGER))
|
||||
{
|
||||
if (thing->player && (thing->player->cheats & CF_PREDICTING))
|
||||
|
@ -2171,7 +2171,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
if (newsec->heightsec && oldsec->heightsec && newsec->SecActTarget)
|
||||
{
|
||||
const sector_t *hs = newsec->heightsec;
|
||||
fixed_t eyez = thing->z + viewheight;
|
||||
fixed_t eyez = thing->Z() + viewheight;
|
||||
fixed_t fakez = hs->floorplane.ZatPoint(x, y);
|
||||
|
||||
if (!oldAboveFakeFloor && eyez > fakez)
|
||||
|
@ -2211,7 +2211,7 @@ pushline:
|
|||
return false;
|
||||
}
|
||||
|
||||
thing->z = oldz;
|
||||
thing->SetZ(oldz);
|
||||
if (!(thing->flags&(MF_TELEPORT | MF_NOCLIP)))
|
||||
{
|
||||
int numSpecHitTemp;
|
||||
|
@ -2225,7 +2225,8 @@ pushline:
|
|||
{
|
||||
// see which lines were pushed
|
||||
ld = spechit[--numSpecHitTemp];
|
||||
side = P_PointOnLineSide(thing->x, thing->y, ld);
|
||||
fixedvec3 pos = thing->PosRelative(ld);
|
||||
side = P_PointOnLineSide(pos.x, pos.y, ld);
|
||||
CheckForPushSpecial(ld, side, thing, true);
|
||||
}
|
||||
}
|
||||
|
@ -2252,7 +2253,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
|
|||
bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y)
|
||||
{
|
||||
FCheckPosition tm;
|
||||
fixed_t newz = thing->z;
|
||||
fixed_t newz = thing->Z();
|
||||
|
||||
if (!P_CheckPosition(thing, x, y, tm))
|
||||
{
|
||||
|
@ -2284,7 +2285,7 @@ bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y)
|
|||
}
|
||||
if (thing->flags2 & MF2_FLY && thing->flags & MF_NOGRAVITY)
|
||||
{
|
||||
if (thing->z + thing->height > tm.ceilingz)
|
||||
if (thing->Top() > tm.ceilingz)
|
||||
return false;
|
||||
}
|
||||
if (!(thing->flags & MF_TELEPORT) && !(thing->flags3 & MF3_FLOORHUGGER))
|
||||
|
@ -2299,10 +2300,10 @@ bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y)
|
|||
}
|
||||
else if (newz < tm.floorz)
|
||||
{ // [RH] Check to make sure there's nothing in the way for the step up
|
||||
fixed_t savedz = thing->z;
|
||||
thing->z = newz = tm.floorz;
|
||||
fixed_t savedz = thing->Z();
|
||||
thing->SetZ(newz = tm.floorz);
|
||||
bool good = P_TestMobjZ(thing);
|
||||
thing->z = savedz;
|
||||
thing->SetZ(savedz);
|
||||
if (!good)
|
||||
{
|
||||
return false;
|
||||
|
@ -2383,7 +2384,7 @@ void FSlide::HitSlideLine(line_t* ld)
|
|||
icyfloor =
|
||||
(P_AproxDistance(tmxmove, tmymove) > 4 * FRACUNIT) &&
|
||||
var_friction && // killough 8/28/98: calc friction on demand
|
||||
slidemo->z <= slidemo->floorz &&
|
||||
slidemo->Z() <= slidemo->floorz &&
|
||||
P_GetFriction(slidemo, NULL) > ORIG_FRICTION;
|
||||
|
||||
if (ld->dx == 0)
|
||||
|
@ -2421,7 +2422,8 @@ void FSlide::HitSlideLine(line_t* ld)
|
|||
// The wall is angled. Bounce if the angle of approach is // phares
|
||||
// less than 45 degrees. // phares
|
||||
|
||||
side = P_PointOnLineSide(slidemo->x, slidemo->y, ld);
|
||||
fixedvec3 pos = slidemo->PosRelative(ld);
|
||||
side = P_PointOnLineSide(pos.x, pos.y, ld);
|
||||
|
||||
lineangle = R_PointToAngle2(0, 0, ld->dx, ld->dy);
|
||||
|
||||
|
@ -2473,8 +2475,8 @@ void FSlide::HitSlideLine(line_t* ld)
|
|||
|
||||
P_MakeDivline(ld, &dll);
|
||||
|
||||
dlv.x = slidemo->x;
|
||||
dlv.y = slidemo->y;
|
||||
dlv.x = pos.x;
|
||||
dlv.y = pos.y;
|
||||
dlv.dx = dll.dy;
|
||||
dlv.dy = -dll.dx;
|
||||
|
||||
|
@ -2526,7 +2528,8 @@ void FSlide::SlideTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_t
|
|||
|
||||
if (!(li->flags & ML_TWOSIDED) || !li->backsector)
|
||||
{
|
||||
if (P_PointOnLineSide(slidemo->x, slidemo->y, li))
|
||||
fixedvec3 pos = slidemo->PosRelative(li);
|
||||
if (P_PointOnLineSide(pos.x, pos.y, li))
|
||||
{
|
||||
// don't hit the back side
|
||||
continue;
|
||||
|
@ -2554,19 +2557,19 @@ void FSlide::SlideTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_t
|
|||
if (open.range < slidemo->height)
|
||||
goto isblocking; // doesn't fit
|
||||
|
||||
if (open.top - slidemo->z < slidemo->height)
|
||||
if (open.top - slidemo->Z() < slidemo->height)
|
||||
goto isblocking; // mobj is too high
|
||||
|
||||
if (open.bottom - slidemo->z > slidemo->MaxStepHeight)
|
||||
if (open.bottom - slidemo->Z() > slidemo->MaxStepHeight)
|
||||
{
|
||||
goto isblocking; // too big a step up
|
||||
}
|
||||
else if (slidemo->z < open.bottom)
|
||||
else if (slidemo->Z() < open.bottom)
|
||||
{ // [RH] Check to make sure there's nothing in the way for the step up
|
||||
fixed_t savedz = slidemo->z;
|
||||
slidemo->z = open.bottom;
|
||||
fixed_t savedz = slidemo->Z();
|
||||
slidemo->SetZ(open.bottom);
|
||||
bool good = P_TestMobjZ(slidemo);
|
||||
slidemo->z = savedz;
|
||||
slidemo->SetZ(savedz);
|
||||
if (!good)
|
||||
{
|
||||
goto isblocking;
|
||||
|
@ -2627,24 +2630,24 @@ retry:
|
|||
// trace along the three leading corners
|
||||
if (tryx > 0)
|
||||
{
|
||||
leadx = mo->x + mo->radius;
|
||||
trailx = mo->x - mo->radius;
|
||||
leadx = mo->X() + mo->radius;
|
||||
trailx = mo->X() - mo->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
leadx = mo->x - mo->radius;
|
||||
trailx = mo->x + mo->radius;
|
||||
leadx = mo->X() - mo->radius;
|
||||
trailx = mo->X() + mo->radius;
|
||||
}
|
||||
|
||||
if (tryy > 0)
|
||||
{
|
||||
leady = mo->y + mo->radius;
|
||||
traily = mo->y - mo->radius;
|
||||
leady = mo->Y() + mo->radius;
|
||||
traily = mo->Y() - mo->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
leady = mo->y - mo->radius;
|
||||
traily = mo->y + mo->radius;
|
||||
leady = mo->Y() - mo->radius;
|
||||
traily = mo->Y() + mo->radius;
|
||||
}
|
||||
|
||||
bestslidefrac = FRACUNIT + 1;
|
||||
|
@ -2661,11 +2664,11 @@ retry:
|
|||
// killough 3/15/98: Allow objects to drop off ledges
|
||||
xmove = 0, ymove = tryy;
|
||||
walkplane = P_CheckSlopeWalk(mo, xmove, ymove);
|
||||
if (!P_TryMove(mo, mo->x + xmove, mo->y + ymove, true, walkplane))
|
||||
if (!P_TryMove(mo, mo->X() + xmove, mo->Y() + ymove, true, walkplane))
|
||||
{
|
||||
xmove = tryx, ymove = 0;
|
||||
walkplane = P_CheckSlopeWalk(mo, xmove, ymove);
|
||||
P_TryMove(mo, mo->x + xmove, mo->y + ymove, true, walkplane);
|
||||
P_TryMove(mo, mo->X() + xmove, mo->Y() + ymove, true, walkplane);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
@ -2682,7 +2685,7 @@ retry:
|
|||
const fixed_t startvely = mo->vely;
|
||||
|
||||
// killough 3/15/98: Allow objects to drop off ledges
|
||||
if (!P_TryMove(mo, mo->x + newx, mo->y + newy, true))
|
||||
if (!P_TryMove(mo, mo->X() + newx, mo->Y() + newy, true))
|
||||
goto stairstep;
|
||||
|
||||
if (mo->velx != startvelx || mo->vely != startvely)
|
||||
|
@ -2716,7 +2719,7 @@ retry:
|
|||
walkplane = P_CheckSlopeWalk(mo, tmxmove, tmymove);
|
||||
|
||||
// killough 3/15/98: Allow objects to drop off ledges
|
||||
if (!P_TryMove(mo, mo->x + tmxmove, mo->y + tmymove, true, walkplane))
|
||||
if (!P_TryMove(mo, mo->X() + tmxmove, mo->Y() + tmymove, true, walkplane))
|
||||
{
|
||||
goto retry;
|
||||
}
|
||||
|
@ -2752,7 +2755,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
|
|||
|
||||
fixed_t thisplanez = rover->top.plane->ZatPoint(actor);
|
||||
|
||||
if (thisplanez>planezhere && thisplanez <= actor->z + actor->MaxStepHeight)
|
||||
if (thisplanez>planezhere && thisplanez <= actor->Z() + actor->MaxStepHeight)
|
||||
{
|
||||
copyplane = *rover->top.plane;
|
||||
if (copyplane.c<0) copyplane.FlipVert();
|
||||
|
@ -2770,7 +2773,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
|
|||
|
||||
fixed_t thisplanez = rover->top.plane->ZatPoint(actor);
|
||||
|
||||
if (thisplanez>planezhere && thisplanez <= actor->z + actor->MaxStepHeight)
|
||||
if (thisplanez>planezhere && thisplanez <= actor->Z() + actor->MaxStepHeight)
|
||||
{
|
||||
copyplane = *rover->top.plane;
|
||||
if (copyplane.c<0) copyplane.FlipVert();
|
||||
|
@ -2787,7 +2790,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
|
|||
return NULL;
|
||||
}
|
||||
|
||||
if (actor->z - planezhere > FRACUNIT)
|
||||
if (actor->Z() - planezhere > FRACUNIT)
|
||||
{ // not on floor
|
||||
return NULL;
|
||||
}
|
||||
|
@ -2797,9 +2800,9 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
|
|||
fixed_t destx, desty;
|
||||
fixed_t t;
|
||||
|
||||
destx = actor->x + xmove;
|
||||
desty = actor->y + ymove;
|
||||
t = TMulScale16(plane->a, destx, plane->b, desty, plane->c, actor->z) + plane->d;
|
||||
destx = actor->X() + xmove;
|
||||
desty = actor->Y() + ymove;
|
||||
t = TMulScale16(plane->a, destx, plane->b, desty, plane->c, actor->Z()) + plane->d;
|
||||
if (t < 0)
|
||||
{ // Desired location is behind (below) the plane
|
||||
// (i.e. Walking up the plane)
|
||||
|
@ -2821,7 +2824,7 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
|
|||
const sector_t *sec = node->m_sector;
|
||||
if (sec->floorplane.c >= STEEPSLOPE)
|
||||
{
|
||||
if (sec->floorplane.ZatPoint(destx, desty) >= actor->z - actor->MaxStepHeight)
|
||||
if (sec->floorplane.ZatPoint(destx, desty) >= actor->Z() - actor->MaxStepHeight)
|
||||
{
|
||||
dopush = false;
|
||||
break;
|
||||
|
@ -2841,19 +2844,19 @@ const secplane_t * P_CheckSlopeWalk(AActor *actor, fixed_t &xmove, fixed_t &ymov
|
|||
// so that it lies on the plane's surface
|
||||
destx -= FixedMul(plane->a, t);
|
||||
desty -= FixedMul(plane->b, t);
|
||||
xmove = destx - actor->x;
|
||||
ymove = desty - actor->y;
|
||||
xmove = destx - actor->X();
|
||||
ymove = desty - actor->Y();
|
||||
return (actor->floorsector == actor->Sector) ? plane : NULL;
|
||||
}
|
||||
else if (t > 0)
|
||||
{ // Desired location is in front of (above) the plane
|
||||
if (planezhere == actor->z)
|
||||
if (planezhere == actor->Z())
|
||||
{ // Actor's current spot is on/in the plane, so walk down it
|
||||
// Same principle as walking up, except reversed
|
||||
destx += FixedMul(plane->a, t);
|
||||
desty += FixedMul(plane->b, t);
|
||||
xmove = destx - actor->x;
|
||||
ymove = desty - actor->y;
|
||||
xmove = destx - actor->X();
|
||||
ymove = desty - actor->Y();
|
||||
return (actor->floorsector == actor->Sector) ? plane : NULL;
|
||||
}
|
||||
}
|
||||
|
@ -2892,7 +2895,7 @@ bool FSlide::BounceTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_
|
|||
}
|
||||
if (!(li->flags&ML_TWOSIDED) || !li->backsector)
|
||||
{
|
||||
if (P_PointOnLineSide(slidemo->x, slidemo->y, li))
|
||||
if (P_PointOnLineSide(slidemo->X(), slidemo->Y(), li))
|
||||
continue; // don't hit the back side
|
||||
goto bounceblocking;
|
||||
}
|
||||
|
@ -2903,10 +2906,10 @@ bool FSlide::BounceTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_
|
|||
if (open.range < slidemo->height)
|
||||
goto bounceblocking; // doesn't fit
|
||||
|
||||
if (open.top - slidemo->z < slidemo->height)
|
||||
if (open.top - slidemo->Z() < slidemo->height)
|
||||
goto bounceblocking; // mobj is too high
|
||||
|
||||
if (open.bottom > slidemo->z)
|
||||
if (open.bottom > slidemo->Z())
|
||||
goto bounceblocking; // mobj is too low
|
||||
|
||||
continue; // this line doesn't block movement
|
||||
|
@ -2950,26 +2953,26 @@ bool FSlide::BounceWall(AActor *mo)
|
|||
//
|
||||
if (mo->velx > 0)
|
||||
{
|
||||
leadx = mo->x + mo->radius;
|
||||
leadx = mo->X() + mo->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
leadx = mo->x - mo->radius;
|
||||
leadx = mo->X() - mo->radius;
|
||||
}
|
||||
if (mo->vely > 0)
|
||||
{
|
||||
leady = mo->y + mo->radius;
|
||||
leady = mo->Y() + mo->radius;
|
||||
}
|
||||
else
|
||||
{
|
||||
leady = mo->y - mo->radius;
|
||||
leady = mo->Y() - mo->radius;
|
||||
}
|
||||
bestslidefrac = FRACUNIT + 1;
|
||||
bestslideline = mo->BlockingLine;
|
||||
if (BounceTraverse(leadx, leady, leadx + mo->velx, leady + mo->vely) && mo->BlockingLine == NULL)
|
||||
{ // Could not find a wall, so bounce off the floor/ceiling instead.
|
||||
fixed_t floordist = mo->z - mo->floorz;
|
||||
fixed_t ceildist = mo->ceilingz - mo->z;
|
||||
fixed_t floordist = mo->Z() - mo->floorz;
|
||||
fixed_t ceildist = mo->ceilingz - mo->Z();
|
||||
if (floordist <= ceildist)
|
||||
{
|
||||
mo->FloorBounceMissile(mo->Sector->floorplane);
|
||||
|
@ -3000,7 +3003,7 @@ bool FSlide::BounceWall(AActor *mo)
|
|||
return true;
|
||||
}
|
||||
|
||||
side = P_PointOnLineSide(mo->x, mo->y, line);
|
||||
side = P_PointOnLineSide(mo->X(), mo->Y(), line);
|
||||
lineangle = R_PointToAngle2(0, 0, line->dx, line->dy);
|
||||
if (side == 1)
|
||||
{
|
||||
|
@ -3015,11 +3018,14 @@ bool FSlide::BounceWall(AActor *mo)
|
|||
movelen = fixed_t(sqrt(double(mo->velx)*mo->velx + double(mo->vely)*mo->vely));
|
||||
movelen = FixedMul(movelen, mo->wallbouncefactor);
|
||||
|
||||
FBoundingBox box(mo->x, mo->y, mo->radius);
|
||||
FBoundingBox box(mo->X(), mo->Y(), mo->radius);
|
||||
if (box.BoxOnLineSide(line) == -1)
|
||||
{
|
||||
mo->SetOrigin(mo->x + FixedMul(mo->radius,
|
||||
finecosine[deltaangle]), mo->y + FixedMul(mo->radius, finesine[deltaangle]), mo->z);
|
||||
fixedvec3 pos = mo->Vec3Offset(
|
||||
FixedMul(mo->radius, finecosine[deltaangle]),
|
||||
FixedMul(mo->radius, finesine[deltaangle]), 0);
|
||||
mo->SetOrigin(pos, true);
|
||||
|
||||
}
|
||||
if (movelen < FRACUNIT)
|
||||
{
|
||||
|
@ -3193,7 +3199,7 @@ bool aim_t::AimTraverse3DFloors(const divline_t &trace, intercept_t * in)
|
|||
fixed_t trY = trace.y + FixedMul(trace.dy, in->frac);
|
||||
fixed_t dist = FixedMul(attackrange, in->frac);
|
||||
|
||||
frontflag = P_PointOnLineSide(shootthing->x, shootthing->y, li);
|
||||
frontflag = P_PointOnLineSide(shootthing->X(), shootthing->Y(), li);
|
||||
|
||||
// 3D floor check. This is not 100% accurate but normally sufficient when
|
||||
// combined with a final sight check
|
||||
|
@ -3365,7 +3371,7 @@ void aim_t::AimTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_t en
|
|||
{
|
||||
if (lastceilingplane)
|
||||
{
|
||||
fixed_t ff_top = lastceilingplane->ZatPoint(th->x, th->y);
|
||||
fixed_t ff_top = lastceilingplane->ZatPoint(th);
|
||||
fixed_t pitch = -(int)R_PointToAngle2(0, shootz, dist, ff_top);
|
||||
// upper slope intersects with this 3d-floor
|
||||
if (pitch > toppitch)
|
||||
|
@ -3375,7 +3381,7 @@ void aim_t::AimTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_t en
|
|||
}
|
||||
if (lastfloorplane)
|
||||
{
|
||||
fixed_t ff_bottom = lastfloorplane->ZatPoint(th->x, th->y);
|
||||
fixed_t ff_bottom = lastfloorplane->ZatPoint(th);
|
||||
fixed_t pitch = -(int)R_PointToAngle2(0, shootz, dist, ff_bottom);
|
||||
// lower slope intersects with this 3d-floor
|
||||
if (pitch < bottompitch)
|
||||
|
@ -3387,12 +3393,12 @@ void aim_t::AimTraverse(fixed_t startx, fixed_t starty, fixed_t endx, fixed_t en
|
|||
|
||||
// check angles to see if the thing can be aimed at
|
||||
|
||||
thingtoppitch = -(int)R_PointToAngle2(0, shootz, dist, th->z + th->height);
|
||||
thingtoppitch = -(int)R_PointToAngle2(0, shootz, dist, th->Z() + th->height);
|
||||
|
||||
if (thingtoppitch > bottompitch)
|
||||
continue; // shot over the thing
|
||||
|
||||
thingbottompitch = -(int)R_PointToAngle2(0, shootz, dist, th->z);
|
||||
thingbottompitch = -(int)R_PointToAngle2(0, shootz, dist, th->Z());
|
||||
|
||||
if (thingbottompitch < toppitch)
|
||||
continue; // shot under the thing
|
||||
|
@ -3502,9 +3508,9 @@ fixed_t P_AimLineAttack(AActor *t1, angle_t angle, fixed_t distance, AActor **pL
|
|||
aim.shootthing = t1;
|
||||
aim.friender = (friender == NULL) ? t1 : friender;
|
||||
|
||||
x2 = t1->x + (distance >> FRACBITS)*finecosine[angle];
|
||||
y2 = t1->y + (distance >> FRACBITS)*finesine[angle];
|
||||
aim.shootz = t1->z + (t1->height >> 1) - t1->floorclip;
|
||||
x2 = t1->X() + (distance >> FRACBITS)*finecosine[angle];
|
||||
y2 = t1->Y() + (distance >> FRACBITS)*finesine[angle];
|
||||
aim.shootz = t1->Z() + (t1->height >> 1) - t1->floorclip;
|
||||
if (t1->player != NULL)
|
||||
{
|
||||
aim.shootz += FixedMul(t1->player->mo->AttackZOffset, t1->player->crouchfactor);
|
||||
|
@ -3559,15 +3565,15 @@ fixed_t P_AimLineAttack(AActor *t1, angle_t angle, fixed_t distance, AActor **pL
|
|||
for (unsigned i = 0; i<t1->Sector->e->XFloor.ffloors.Size(); i++)
|
||||
{
|
||||
F3DFloor * rover = t1->Sector->e->XFloor.ffloors[i];
|
||||
fixed_t bottomz = rover->bottom.plane->ZatPoint(t1->x, t1->y);
|
||||
fixed_t bottomz = rover->bottom.plane->ZatPoint(t1);
|
||||
|
||||
if (bottomz >= t1->z + t1->height) aim.lastceilingplane = rover->bottom.plane;
|
||||
if (bottomz >= t1->Top()) aim.lastceilingplane = rover->bottom.plane;
|
||||
|
||||
bottomz = rover->top.plane->ZatPoint(t1->x, t1->y);
|
||||
if (bottomz <= t1->z) aim.lastfloorplane = rover->top.plane;
|
||||
bottomz = rover->top.plane->ZatPoint(t1);
|
||||
if (bottomz <= t1->Z()) aim.lastfloorplane = rover->top.plane;
|
||||
}
|
||||
|
||||
aim.AimTraverse(t1->x, t1->y, x2, y2, target);
|
||||
aim.AimTraverse(t1->X(), t1->Y(), x2, y2, target);
|
||||
|
||||
if (!aim.linetarget)
|
||||
{
|
||||
|
@ -3670,7 +3676,7 @@ AActor *P_LineAttack(AActor *t1, angle_t angle, fixed_t distance,
|
|||
vy = FixedMul(finecosine[pitch], finesine[angle]);
|
||||
vz = -finesine[pitch];
|
||||
|
||||
shootz = t1->z - t1->floorclip + (t1->height >> 1);
|
||||
shootz = t1->Z() - t1->floorclip + (t1->height >> 1);
|
||||
if (t1->player != NULL)
|
||||
{
|
||||
shootz += FixedMul(t1->player->mo->AttackZOffset, t1->player->crouchfactor);
|
||||
|
@ -3708,7 +3714,7 @@ AActor *P_LineAttack(AActor *t1, angle_t angle, fixed_t distance,
|
|||
if (puffDefaults != NULL && puffDefaults->flags6 & MF6_NOTRIGGER) tflags = TRACE_NoSky;
|
||||
else tflags = TRACE_NoSky | TRACE_Impact;
|
||||
|
||||
if (!Trace(t1->x, t1->y, shootz, t1->Sector, vx, vy, vz, distance,
|
||||
if (!Trace(t1->X(), t1->Y(), shootz, t1->Sector, vx, vy, vz, distance,
|
||||
MF_SHOOTABLE, ML_BLOCKEVERYTHING | ML_BLOCKHITSCAN, t1, trace,
|
||||
tflags, CheckForActor, &TData))
|
||||
{ // hit nothing
|
||||
|
@ -3738,8 +3744,8 @@ AActor *P_LineAttack(AActor *t1, angle_t angle, fixed_t distance,
|
|||
if (trace.HitType != TRACE_HitWall || trace.Line->special != Line_Horizon)
|
||||
{
|
||||
fixed_t closer = trace.Distance - 4 * FRACUNIT;
|
||||
puff = P_SpawnPuff(t1, pufftype, t1->x + FixedMul(vx, closer),
|
||||
t1->y + FixedMul(vy, closer),
|
||||
fixedvec2 pos = t1->Vec2Offset(FixedMul(vx, closer), FixedMul(vy, closer));
|
||||
puff = P_SpawnPuff(t1, pufftype, pos.x, pos.y,
|
||||
shootz + FixedMul(vz, closer), angle - ANG90, 0, puffFlags);
|
||||
}
|
||||
|
||||
|
@ -3775,8 +3781,8 @@ AActor *P_LineAttack(AActor *t1, angle_t angle, fixed_t distance,
|
|||
{
|
||||
// Using the puff's position is not accurate enough.
|
||||
// Instead make it splash at the actual hit position
|
||||
hitx = t1->x + FixedMul(vx, trace.Distance);
|
||||
hity = t1->y + FixedMul(vy, trace.Distance);
|
||||
hitx = t1->X() + FixedMul(vx, trace.Distance);
|
||||
hity = t1->Y() + FixedMul(vy, trace.Distance);
|
||||
hitz = shootz + FixedMul(vz, trace.Distance);
|
||||
P_HitWater(puff, P_PointInSector(hitx, hity), hitx, hity, hitz);
|
||||
}
|
||||
|
|
343
src/p_mobj.cpp
343
src/p_mobj.cpp
File diff suppressed because it is too large
Load diff
|
@ -901,7 +901,8 @@ void FPolyObj::ThrustMobj (AActor *actor, side_t *side)
|
|||
actor->vely += thrustY;
|
||||
if (crush)
|
||||
{
|
||||
if (bHurtOnTouch || !P_CheckMove (actor, actor->x + thrustX, actor->y + thrustY))
|
||||
fixedvec2 pos = actor->Vec2Offset(thrustX, thrustY);
|
||||
if (bHurtOnTouch || !P_CheckMove (actor, pos.x, pos.y))
|
||||
{
|
||||
int newdam = P_DamageMobj (actor, NULL, NULL, crush, NAME_Crush);
|
||||
P_TraceBleed (newdam > 0 ? newdam : crush, actor);
|
||||
|
@ -1199,8 +1200,8 @@ bool FPolyObj::CheckMobjBlocking (side_t *sd)
|
|||
&& !((mobj->flags & MF_FLOAT) && (ld->flags & ML_BLOCK_FLOATERS))
|
||||
&& (!(ld->flags & ML_3DMIDTEX) ||
|
||||
(!P_LineOpening_3dMidtex(mobj, ld, open) &&
|
||||
(mobj->z + mobj->height < open.top)
|
||||
) || (open.abovemidtex && mobj->z > mobj->floorz))
|
||||
(mobj->Top() < open.top)
|
||||
) || (open.abovemidtex && mobj->Z() > mobj->floorz))
|
||||
)
|
||||
{
|
||||
// [BL] We can't just continue here since we must
|
||||
|
@ -1213,7 +1214,7 @@ bool FPolyObj::CheckMobjBlocking (side_t *sd)
|
|||
performBlockingThrust = true;
|
||||
}
|
||||
|
||||
FBoundingBox box(mobj->x, mobj->y, mobj->radius);
|
||||
FBoundingBox box(mobj->X(), mobj->Y(), mobj->radius);
|
||||
|
||||
if (box.Right() <= ld->bbox[BOXLEFT]
|
||||
|| box.Left() >= ld->bbox[BOXRIGHT]
|
||||
|
@ -1231,15 +1232,15 @@ bool FPolyObj::CheckMobjBlocking (side_t *sd)
|
|||
// Best use the one facing the player and ignore the back side.
|
||||
if (ld->sidedef[1] != NULL)
|
||||
{
|
||||
int side = P_PointOnLineSidePrecise(mobj->x, mobj->y, ld);
|
||||
int side = P_PointOnLineSidePrecise(mobj->X(), mobj->Y(), ld);
|
||||
if (ld->sidedef[side] != sd)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
// [BL] See if we hit below the floor/ceiling of the poly.
|
||||
else if(!performBlockingThrust && (
|
||||
mobj->z < ld->sidedef[!side]->sector->GetSecPlane(sector_t::floor).ZatPoint(mobj) ||
|
||||
mobj->z + mobj->height > ld->sidedef[!side]->sector->GetSecPlane(sector_t::ceiling).ZatPoint(mobj)
|
||||
mobj->Z() < ld->sidedef[!side]->sector->GetSecPlane(sector_t::floor).ZatPoint(mobj) ||
|
||||
mobj->Top() > ld->sidedef[!side]->sector->GetSecPlane(sector_t::ceiling).ZatPoint(mobj)
|
||||
))
|
||||
{
|
||||
performBlockingThrust = true;
|
||||
|
|
|
@ -175,9 +175,10 @@ void S_NoiseDebug (void)
|
|||
return;
|
||||
}
|
||||
|
||||
listener.X = FIXED2FLOAT(players[consoleplayer].camera->x);
|
||||
listener.Y = FIXED2FLOAT(players[consoleplayer].camera->z);
|
||||
listener.Z = FIXED2FLOAT(players[consoleplayer].camera->y);
|
||||
|
||||
listener.X = FIXED2FLOAT(players[consoleplayer].camera->SoundX());
|
||||
listener.Y = FIXED2FLOAT(players[consoleplayer].camera->SoundZ());
|
||||
listener.Z = FIXED2FLOAT(players[consoleplayer].camera->SoundY());
|
||||
|
||||
// Display the oldest channel first.
|
||||
for (chan = Channels; chan->NextChan != NULL; chan = chan->NextChan)
|
||||
|
@ -666,9 +667,9 @@ static void CalcPosVel(int type, const AActor *actor, const sector_t *sector,
|
|||
|
||||
if (players[consoleplayer].camera != NULL)
|
||||
{
|
||||
x = players[consoleplayer].camera->x;
|
||||
y = players[consoleplayer].camera->z;
|
||||
z = players[consoleplayer].camera->y;
|
||||
x = players[consoleplayer].camera->SoundX();
|
||||
y = players[consoleplayer].camera->SoundZ();
|
||||
z = players[consoleplayer].camera->SoundY();
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -685,9 +686,9 @@ static void CalcPosVel(int type, const AActor *actor, const sector_t *sector,
|
|||
// assert(actor != NULL);
|
||||
if (actor != NULL)
|
||||
{
|
||||
x = actor->x;
|
||||
y = actor->z;
|
||||
z = actor->y;
|
||||
x = actor->SoundX();
|
||||
y = actor->SoundZ();
|
||||
z = actor->SoundY();
|
||||
}
|
||||
break;
|
||||
|
||||
|
@ -723,7 +724,7 @@ static void CalcPosVel(int type, const AActor *actor, const sector_t *sector,
|
|||
{
|
||||
if ((chanflags & CHAN_LISTENERZ) && players[consoleplayer].camera != NULL)
|
||||
{
|
||||
y = players[consoleplayer].camera != NULL ? players[consoleplayer].camera->z : 0;
|
||||
y = players[consoleplayer].camera != NULL ? players[consoleplayer].camera->SoundZ() : 0;
|
||||
}
|
||||
pos->X = FIXED2FLOAT(x);
|
||||
pos->Y = FIXED2FLOAT(y);
|
||||
|
@ -763,8 +764,8 @@ static void CalcSectorSoundOrg(const sector_t *sec, int channum, fixed_t *x, fix
|
|||
// Are we inside the sector? If yes, the closest point is the one we're on.
|
||||
if (P_PointInSector(*x, *y) == sec)
|
||||
{
|
||||
*x = players[consoleplayer].camera->x;
|
||||
*y = players[consoleplayer].camera->y;
|
||||
*x = players[consoleplayer].camera->SoundX();
|
||||
*y = players[consoleplayer].camera->SoundY();
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1567,9 +1568,9 @@ void S_RelinkSound (AActor *from, AActor *to)
|
|||
{
|
||||
chan->Actor = NULL;
|
||||
chan->SourceType = SOURCE_Unattached;
|
||||
chan->Point[0] = FIXED2FLOAT(from->x);
|
||||
chan->Point[1] = FIXED2FLOAT(from->z);
|
||||
chan->Point[2] = FIXED2FLOAT(from->y);
|
||||
chan->Point[0] = FIXED2FLOAT(from->SoundX());
|
||||
chan->Point[1] = FIXED2FLOAT(from->SoundZ());
|
||||
chan->Point[2] = FIXED2FLOAT(from->SoundY());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -1959,9 +1960,9 @@ static void S_SetListener(SoundListener &listener, AActor *listenactor)
|
|||
listener.velocity.Z = listenactor->vely * (TICRATE/65536.f);
|
||||
*/
|
||||
listener.velocity.Zero();
|
||||
listener.position.X = FIXED2FLOAT(listenactor->x);
|
||||
listener.position.Y = FIXED2FLOAT(listenactor->z);
|
||||
listener.position.Z = FIXED2FLOAT(listenactor->y);
|
||||
listener.position.X = FIXED2FLOAT(listenactor->SoundX());
|
||||
listener.position.Y = FIXED2FLOAT(listenactor->SoundZ());
|
||||
listener.position.Z = FIXED2FLOAT(listenactor->SoundY());
|
||||
listener.underwater = listenactor->waterlevel == 3;
|
||||
assert(zones != NULL);
|
||||
listener.Environment = zones[listenactor->Sector->ZoneNumber].Environment;
|
||||
|
|
|
@ -4603,7 +4603,6 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_WolfAttack)
|
|||
fixedvec2 vec = self->Vec2To(self->target);
|
||||
fixed_t dx = abs (vec.x);
|
||||
fixed_t dy = abs (vec.y);
|
||||
fixed_t dz;
|
||||
fixed_t dist = dx > dy ? dx : dy;
|
||||
|
||||
// Some enemies are more precise
|
||||
|
|
Loading…
Reference in a new issue