zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2025-02-16 08:32:02 +00:00
Code Issues Projects Releases Packages Wiki Activity

- replaced ceilingz with a floating point variable, also in FCheckPosition.

Browse source
This commit is contained in:
Christoph Oelckers 2016-03-20 13:32:53 +01:00
parent 6e2421bd37
commit ec58e70078
25 changed files with 118 additions and 107 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/actor.h
View file

@ -1101,7 +1101,13 @@ public:
FBlockNode *BlockNode; // links in blocks (if needed)
struct sector_t *Sector;
subsector_t * subsector;
fixed_t floorz, ceilingz; // closest together of contacted secs
fixed_t floorz; double ceilingz; // closest together of contacted secs
inline fixed_t _f_ceilingz()
{
return FLOAT2FIXED(ceilingz);
}
fixed_t dropoffz; // killough 11/98: the lowest floor over all contacted Sectors.
struct sector_t *floorsector;

4
src/b_move.cpp
View file

@ -270,7 +270,7 @@ bool FCajunMaster::CleanAhead (AActor *thing, fixed_t x, fixed_t y, ticcmd_t *cm
if (!(thing->flags & MF_NOCLIP) )
{
fixed_t maxstep = thing->MaxStepHeight;
if (tm.ceilingz - tm.floorz < thing->height)
if (tm._f_ceilingz() - tm.floorz < thing->height)
return false; // doesn't fit
if (!(thing->flags&MF_MISSILE))
@ -284,7 +284,7 @@ bool FCajunMaster::CleanAhead (AActor *thing, fixed_t x, fixed_t y, ticcmd_t *cm
if ( !(thing->flags & MF_TELEPORT) &&
tm.ceilingz - thing->_f_Z() < thing->height)
tm.ceilingz < thing->Top())
return false; // mobj must lower itself to fit
// jump out of water

2
src/g_doom/a_painelemental.cpp
View file

@ -31,7 +31,7 @@ void A_PainShootSkull (AActor *self, DAngle Angle, PClassActor *spawntype, int f
if (self->DamageType == NAME_Massacre) return;
// [RH] check to make sure it's not too close to the ceiling
if (self->Top() + 8 > FIXED2FLOAT(self->ceilingz))
if (self->Top() + 8 > self->ceilingz)
{
if (self->flags & MF_FLOAT)
{

2
src/g_heretic/a_hereticweaps.cpp
View file

@ -1132,7 +1132,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_HideInCeiling)
}
}
self->bouncecount = -1;
self->_f_SetZ(self->ceilingz + 4*FRACUNIT, false);
self->SetZ(self->ceilingz + 4, false);
return 0;
}

7
src/g_hexen/a_korax.cpp
View file

@ -48,7 +48,7 @@ const int KORAX_ARM4_HEIGHT = 104*FRACUNIT;
const int KORAX_ARM5_HEIGHT = 86*FRACUNIT;
const int KORAX_ARM6_HEIGHT = 53*FRACUNIT;
const int KORAX_BOLT_HEIGHT = 48*FRACUNIT;
const double KORAX_BOLT_HEIGHT = 48.;
const int KORAX_BOLT_LIFETIME = 3;
@ -473,14 +473,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_KBoltRaise)
PARAM_ACTION_PROLOGUE;
AActor *mo;
fixed_t z;
// Spawn a child upward
z = self->_f_Z() + KORAX_BOLT_HEIGHT;
double z = self->Z() + KORAX_BOLT_HEIGHT;
if ((z + KORAX_BOLT_HEIGHT) < self->ceilingz)
{
mo = Spawn("KoraxBolt", self->_f_X(), self->_f_Y(), z, ALLOW_REPLACE);
mo = Spawn("KoraxBolt", self->PosAtZ(z), ALLOW_REPLACE);
if (mo)
{
mo->special1 = KORAX_BOLT_LIFETIME;

2
src/g_hexen/a_magelightning.cpp
View file

@ -161,7 +161,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_LightningClip)
}
else if (self->flags3 & MF3_CEILINGHUGGER)
{
self->_f_SetZ(self->ceilingz-self->height);
self->SetZ(self->ceilingz - self->_Height());
target = self->tracer;
}
if (self->flags3 & MF3_FLOORHUGGER)

6
src/g_hexen/a_wraith.cpp
View file

@ -31,12 +31,12 @@ DEFINE_ACTION_FUNCTION(AActor, A_WraithInit)
{
PARAM_ACTION_PROLOGUE;
self->_f_AddZ(48<<FRACBITS);
self->AddZ(48);
// [RH] Make sure the wraith didn't go into the ceiling
if (self->_f_Top() > self->ceilingz)
if (self->Top() > self->ceilingz)
{
self->_f_SetZ(self->ceilingz - self->height);
self->SetZ(self->ceilingz - self->_Height());
}
self->special1 = 0; // index into floatbob

4
src/g_shared/a_fastprojectile.cpp
View file

@ -117,7 +117,7 @@ void AFastProjectile::Tick ()
P_ExplodeMissile (this, NULL, NULL);
return;
}
if (_f_Top() > ceilingz)
if (Top() > ceilingz)
{ // Hit the ceiling
if (ceilingpic == skyflatnum && !(flags3 & MF3_SKYEXPLODE))
@ -126,7 +126,7 @@ void AFastProjectile::Tick ()
return;
}
_f_SetZ(ceilingz - height);
SetZ(ceilingz - _Height());
P_ExplodeMissile (this, NULL, NULL);
return;
}

8
src/g_shared/a_pickups.cpp
View file

@ -426,11 +426,11 @@ DEFINE_ACTION_FUNCTION(AActor, A_RestoreSpecialPosition)
if (self->flags & MF_SPAWNCEILING)
{
self->_f_SetZ(self->ceilingz - self->height - self->SpawnPoint[2]);
self->_f_SetZ(self->_f_ceilingz() - self->height - self->SpawnPoint[2]);
}
else if (self->flags2 & MF2_SPAWNFLOAT)
{
fixed_t space = self->ceilingz - self->height - self->floorz;
fixed_t space = self->_f_ceilingz() - self->height - self->floorz;
if (space > 48*FRACUNIT)
{
space -= 40*FRACUNIT;
@ -452,9 +452,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_RestoreSpecialPosition)
// initial spawn.
self->_f_SetZ(self->floorz);
}
if ((self->flags & MF_SOLID) && (self->_f_Top() > self->ceilingz))
if ((self->flags & MF_SOLID) && (self->Top() > self->ceilingz))
{ // Do the same for the ceiling.
self->_f_SetZ(self->ceilingz - self->height);
self->SetZ(self->ceilingz - self->_Height());
}
// Do not interpolate from the position the actor was at when it was
// picked up, in case that is different from where it is now.

4
src/g_shared/a_randomspawner.cpp
View file

@ -188,11 +188,11 @@ class ARandomSpawner : public AActor
// Handle special altitude flags
if (newmobj->flags & MF_SPAWNCEILING)
{
newmobj->_f_SetZ(newmobj->ceilingz - newmobj->height - SpawnPoint[2]);
newmobj->_f_SetZ(newmobj->_f_ceilingz() - newmobj->height - SpawnPoint[2]);
}
else if (newmobj->flags2 & MF2_SPAWNFLOAT)
{
fixed_t space = newmobj->ceilingz - newmobj->height - newmobj->floorz;
fixed_t space = newmobj->_f_ceilingz() - newmobj->height - newmobj->floorz;
if (space > 48*FRACUNIT)
{
space -= 40*FRACUNIT;

2
src/g_strife/a_inquisitor.cpp
View file

@ -42,7 +42,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_InquisitorDecide)
}
if (self->target->Z() != self->Z())
{
if (self->_f_Top() + 54*FRACUNIT < self->ceilingz)
if (self->Top() + 54 < self->ceilingz)
{
self->SetState (self->FindState("Jump"));
}

10
src/g_strife/a_sentinel.cpp
View file

@ -13,7 +13,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SentinelBob)
{
PARAM_ACTION_PROLOGUE;
fixed_t minz, maxz;
double minz, maxz;
if (self->flags & MF_INFLOAT)
{
@ -23,13 +23,13 @@ DEFINE_ACTION_FUNCTION(AActor, A_SentinelBob)
if (self->threshold != 0)
return 0;
maxz = self->ceilingz - self->height - 16*FRACUNIT;
minz = self->floorz + 96*FRACUNIT;
maxz = self->ceilingz - self->_Height() - 16;
minz = FIXED2FLOAT(self->floorz) + 96;
if (minz > maxz)
{
minz = maxz;
}
if (minz < self->_f_Z())
if (minz < self->Z())
{
self->Vel.Z -= 1;
}
@ -37,7 +37,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_SentinelBob)
{
self->Vel.Z += 1;
}
self->reactiontime = (minz >= self->_f_Z()) ? 4 : 0;
self->reactiontime = (minz >= self->Z()) ? 4 : 0;
return 0;
}

2
src/g_strife/a_stalker.cpp
View file

@ -19,7 +19,7 @@ DEFINE_ACTION_FUNCTION(AActor, A_StalkerChaseDecide)
{
self->SetState (self->FindState("SeeFloor"));
}
else if (self->ceilingz > self->_f_Top())
else if (self->ceilingz > self->Top())
{
self->SetState (self->FindState("Drop"));
}

4
src/g_strife/a_strifeweapons.cpp
View file

@ -552,9 +552,9 @@ DEFINE_ACTION_FUNCTION(AActor, A_MaulerTorpedoWave)
// If the torpedo hit the ceiling, it should still spawn the wave
savedz = self->_f_Z();
if (wavedef && self->ceilingz - self->_f_Z() < wavedef->height)
if (wavedef && self->ceilingz < wavedef->Top())
{
self->_f_SetZ(self->ceilingz - wavedef->height);
self->SetZ(self->ceilingz - wavedef->_Height());
}
for (int i = 0; i < 80; ++i)

2
src/p_3dfloors.cpp
View file

@ -408,7 +408,7 @@ bool P_CheckFor3DCeilingHit(AActor * mo)
if(rover->flags & FF_SOLID && rover->model->SecActTarget)
{
if(mo->ceilingz == rover->bottom.plane->ZatPoint(mo))
if(mo->_f_ceilingz() == rover->bottom.plane->ZatPoint(mo))
{
rover->model->SecActTarget->TriggerAction (mo, SECSPAC_HitCeiling);
return true;

4
src/p_acs.cpp
View file

@ -8715,7 +8715,7 @@ scriptwait:
case PCD_GETACTORCEILINGZ:
{
AActor *actor = SingleActorFromTID(STACK(1), activator);
STACK(1) = actor == NULL ? 0 : actor->ceilingz;
STACK(1) = actor == NULL ? 0 : DoubleToACS(actor->ceilingz);
}
break;
@ -9253,7 +9253,7 @@ scriptwait:
switch (STACK(1))
{
case PLAYERINFO_TEAM: STACK(2) = userinfo->GetTeam(); break;
case PLAYERINFO_AIMDIST: STACK(2) = userinfo->GetAimDist() * (0x40000000/90.); break; // Yes, this has been returning a BAM since its creation.
case PLAYERINFO_AIMDIST: STACK(2) = (SDWORD)(userinfo->GetAimDist() * (0x40000000/90.)); break; // Yes, this has been returning a BAM since its creation.
case PLAYERINFO_COLOR: STACK(2) = userinfo->GetColor(); break;
case PLAYERINFO_GENDER: STACK(2) = userinfo->GetGender(); break;
case PLAYERINFO_NEVERSWITCH: STACK(2) = userinfo->GetNeverSwitch(); break;

12
src/p_buildmap.cpp
View file

@ -45,7 +45,7 @@
struct sectortype
{
SWORD wallptr, wallnum;
SDWORD ceilingz, floorz;
SDWORD ceilingZ, floorZ;
SWORD ceilingstat, floorstat;
SWORD ceilingpicnum, ceilingheinum;
SBYTE ceilingshade;
@ -402,7 +402,7 @@ static void LoadSectors (sectortype *bsec)
bsec->floorstat = WORD(bsec->floorstat);
sec->e = &sectors[0].e[i];
sec->SetPlaneTexZ(sector_t::floor, -(LittleLong(bsec->floorz) << 8));
sec->SetPlaneTexZ(sector_t::floor, -(LittleLong(bsec->floorZ) << 8));
sec->floorplane.d = -sec->GetPlaneTexZ(sector_t::floor);
sec->floorplane.c = FRACUNIT;
sec->floorplane.ic = FRACUNIT;
@ -415,7 +415,7 @@ static void LoadSectors (sectortype *bsec)
sec->SetPlaneLight(sector_t::floor, SHADE2LIGHT (bsec->floorshade));
sec->ChangeFlags(sector_t::floor, 0, PLANEF_ABSLIGHTING);
sec->SetPlaneTexZ(sector_t::ceiling, -(LittleLong(bsec->ceilingz) << 8));
sec->SetPlaneTexZ(sector_t::ceiling, -(LittleLong(bsec->ceilingZ) << 8));
sec->ceilingplane.d = sec->GetPlaneTexZ(sector_t::ceiling);
sec->ceilingplane.c = -FRACUNIT;
sec->ceilingplane.ic = -FRACUNIT;
@ -647,13 +647,13 @@ static void LoadWalls (walltype *walls, int numwalls, sectortype *bsec)
if ((bsec->floorstat & 2) && (bsec->floorheinum != 0))
{ // floor is sloped
slope.heinum = -LittleShort(bsec->floorheinum);
slope.z[0] = slope.z[1] = slope.z[2] = -bsec->floorz;
slope.z[0] = slope.z[1] = slope.z[2] = -bsec->floorZ;
CalcPlane (slope, sectors[i].floorplane);
}
if ((bsec->ceilingstat & 2) && (bsec->ceilingheinum != 0))
{ // ceiling is sloped
slope.heinum = -LittleShort(bsec->ceilingheinum);
slope.z[0] = slope.z[1] = slope.z[2] = -bsec->ceilingz;
slope.z[0] = slope.z[1] = slope.z[2] = -bsec->ceilingZ;
CalcPlane (slope, sectors[i].ceilingplane);
}
int linenum = int(intptr_t(sides[bsec->wallptr].linedef));
@ -699,7 +699,7 @@ static int LoadSprites (spritetype *sprites, Xsprite *xsprites, int numsprites,
mapthings[count].thingid = 0;
mapthings[count].x = (sprites[i].x << 12);
mapthings[count].y = -(sprites[i].y << 12);
mapthings[count].z = (bsectors[sprites[i].sectnum].floorz - sprites[i].z) << 8;
mapthings[count].z = (bsectors[sprites[i].sectnum].floorZ - sprites[i].z) << 8;
mapthings[count].angle = (((2048-sprites[i].ang) & 2047) * 360) >> 11;
mapthings[count].ClassFilter = 0xffff;
mapthings[count].SkillFilter = 0xffff;

8
src/p_checkposition.h
View file

@ -20,7 +20,7 @@ struct FCheckPosition
// out
sector_t *sector;
fixed_t floorz;
fixed_t ceilingz;
double ceilingz;
fixed_t dropoffz;
FTextureID floorpic;
int floorterrain;
@ -46,6 +46,12 @@ struct FCheckPosition
PushTime = 0;
FromPMove = false;
}
inline fixed_t _f_ceilingz()
{
return FLOAT2FIXED(ceilingz);
}
};

2
src/p_local.h
View file

@ -236,7 +236,7 @@ AActor *P_RoughMonsterSearch (AActor *mo, int distance, bool onlyseekable=false)
// If "floatok" true, move would be ok
// if within "tmfloorz - tmceilingz".
// if within "tmfloorz - tm_f_ceilingz()".
extern msecnode_t *sector_list; // phares 3/16/98
struct spechit_t

72
src/p_map.cpp
View file

@ -242,7 +242,7 @@ static bool PIT_FindFloorCeiling(FMultiBlockLinesIterator &mit, FMultiBlockLines
// adjust floor / ceiling heights
if (!(flags & FFCF_NOCEILING))
{
if (open.top < tmf.ceilingz)
if (open.top < tmf._f_ceilingz())
{
tmf.ceilingz = open.top;
if (open.topsec != NULL) tmf.ceilingsector = open.topsec;
@ -291,7 +291,7 @@ void P_GetFloorCeilingZ(FCheckPosition &tmf, int flags)
sector_t *sec = (!(flags & FFCF_SAMESECTOR) || tmf.thing->Sector == NULL)? P_PointInSector(tmf.x, tmf.y) : tmf.sector;
F3DFloor *ffc, *fff;
tmf.ceilingz = sec->NextHighestCeilingAt(tmf.x, tmf.y, tmf.z, tmf.z + tmf.thing->height, flags, &tmf.ceilingsector, &ffc);
tmf.ceilingz = FIXED2DBL(sec->NextHighestCeilingAt(tmf.x, tmf.y, tmf.z, tmf.z + tmf.thing->height, flags, &tmf.ceilingsector, &ffc));
tmf.floorz = tmf.dropoffz = sec->NextLowestFloorAt(tmf.x, tmf.y, tmf.z, flags, tmf.thing->MaxStepHeight, &tmf.floorsector, &fff);
if (fff)
@ -343,7 +343,7 @@ void P_FindFloorCeiling(AActor *actor, int flags)
actor->floorsector = tmf.floorsector;
actor->ceilingpic = tmf.ceilingpic;
actor->ceilingsector = tmf.ceilingsector;
if (ffcf_verbose) Printf("Starting with ceilingz = %f, floorz = %f\n", FIXED2FLOAT(tmf.ceilingz), FIXED2FLOAT(tmf.floorz));
if (ffcf_verbose) Printf("Starting with ceilingz = %f, floorz = %f\n", tmf.ceilingz, FIXED2FLOAT(tmf.floorz));
tmf.touchmidtex = false;
tmf.abovemidtex = false;
@ -769,7 +769,7 @@ static int LineIsBelow(line_t *line, AActor *actor)
//
//
// PIT_CheckLine
// Adjusts tmfloorz and tmceilingz as lines are contacted
// Adjusts tmfloorz and tm_f_ceilingz() as lines are contacted
//
//
//==========================================================================
@ -857,7 +857,7 @@ bool PIT_CheckLine(FMultiBlockLinesIterator &mit, FMultiBlockLinesIterator::Chec
if (state == 1)
{
// the line should not block but we should set the ceilingz to the portal boundary so that we can't float up into that line.
fixed_t portalz = cres.line->frontsector->SkyBoxes[sector_t::floor]->threshold;
double portalz = FIXED2FLOAT(cres.line->frontsector->SkyBoxes[sector_t::floor]->threshold);
if (portalz < tm.ceilingz)
{
tm.ceilingz = portalz;
@ -936,9 +936,9 @@ bool PIT_CheckLine(FMultiBlockLinesIterator &mit, FMultiBlockLinesIterator::Chec
// adjust floor / ceiling heights
if (!(cres.portalflags & FFCF_NOCEILING))
{
if (open.top < tm.ceilingz)
if (open.top < tm._f_ceilingz())
{
tm.ceilingz = open.top;
tm.ceilingz = FIXED2DBL(open.top);
tm.ceilingsector = open.topsec;
tm.ceilingpic = open.ceilingpic;
tm.ceilingline = ld;
@ -1057,9 +1057,9 @@ static bool PIT_CheckPortal(FMultiBlockLinesIterator &mit, FMultiBlockLinesItera
P_LineOpening(open, tm.thing, ld, ref.x, ref.y, cres.position.x, cres.position.y, 0);
// adjust floor / ceiling heights
if (open.top - zofs < tm.ceilingz)
if (open.top - zofs < tm._f_ceilingz())
{
tm.ceilingz = open.top - zofs;
tm.ceilingz = FIXED2FLOAT(open.top - zofs);
tm.ceilingpic = open.ceilingpic;
/*
tm.ceilingsector = open.topsec;
@ -1625,7 +1625,7 @@ bool P_CheckPosition(AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm, bo
{
// With noclip2, we must ignore 3D floors and go right to the uppermost ceiling and lowermost floor.
tm.floorz = tm.dropoffz = newsec->_f_LowestFloorAt(x, y, &tm.floorsector);
tm.ceilingz = newsec->_f_HighestCeilingAt(x, y, &tm.ceilingsector);
tm.ceilingz = FIXED2DBL(newsec->_f_HighestCeilingAt(x, y, &tm.ceilingsector));
tm.floorpic = tm.floorsector->GetTexture(sector_t::floor);
tm.floorterrain = tm.floorsector->GetTerrain(sector_t::floor);
tm.ceilingpic = tm.ceilingsector->GetTexture(sector_t::ceiling);
@ -1752,7 +1752,7 @@ bool P_CheckPosition(AActor *thing, fixed_t x, fixed_t y, FCheckPosition &tm, bo
{
return false;
}
if (tm.ceilingz - tm.floorz < thing->height)
if (tm._f_ceilingz() - tm.floorz < thing->height)
{
return false;
}
@ -1792,7 +1792,7 @@ bool P_TestMobjLocation(AActor *mobj)
if (P_CheckPosition(mobj, mobj->_f_X(), mobj->_f_Y()))
{ // XY is ok, now check Z
mobj->flags = flags;
if ((mobj->_f_Z() < mobj->floorz) || (mobj->_f_Top() > mobj->ceilingz))
if ((mobj->_f_Z() < mobj->floorz) || (mobj->Top() > mobj->ceilingz))
{ // Bad Z
return false;
}
@ -1943,9 +1943,9 @@ void P_FakeZMovement(AActor *mo)
mo->_f_SetZ(mo->floorz);
}
if (mo->_f_Top() > mo->ceilingz)
if (mo->Top() > mo->ceilingz)
{ // hit the ceiling
mo->_f_SetZ(mo->ceilingz - mo->height);
mo->SetZ(mo->ceilingz - mo->_Height());
}
}
@ -2054,7 +2054,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
}
else if (BlockingMobj->_f_Top() - thing->_f_Z() > thing->MaxStepHeight
|| (BlockingMobj->Sector->ceilingplane.ZatPoint(x, y) - (BlockingMobj->_f_Top()) < thing->height)
|| (tm.ceilingz - (BlockingMobj->_f_Top()) < thing->height))
|| (tm.ceilingz - (BlockingMobj->Top()) < thing->_Height()))
{
goto pushline;
}
@ -2073,7 +2073,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
}
else if (thing->flags3 & MF3_CEILINGHUGGER)
{
thing->_f_SetZ(tm.ceilingz - thing->height);
thing->SetZ(tm.ceilingz - thing->_Height());
}
if (onfloor && tm.floorsector == thing->floorsector)
@ -2082,7 +2082,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
}
if (!(thing->flags & MF_NOCLIP))
{
if (tm.ceilingz - tm.floorz < thing->height)
if (tm._f_ceilingz() - tm.floorz < thing->height)
{
goto pushline; // doesn't fit
}
@ -2090,7 +2090,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
tm.floatok = true;
if (!(thing->flags & MF_TELEPORT)
&& tm.ceilingz - thing->_f_Z() < thing->height
&& tm.ceilingz < thing->Top()
&& !(thing->flags3 & MF3_CEILINGHUGGER)
&& (!(thing->flags2 & MF2_FLY) || !(thing->flags & MF_NOGRAVITY)))
{
@ -2099,12 +2099,12 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
if (thing->flags2 & MF2_FLY && thing->flags & MF_NOGRAVITY)
{
#if 1
if (thing->_f_Top() > 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->_f_Top() > tm.ceilingz)
if (thing->Top() > tm.ceilingz)
{
thing->_f_velz() = -8 * FRACUNIT;
goto pushline;
@ -2371,7 +2371,7 @@ bool P_TryMove(AActor *thing, fixed_t x, fixed_t y,
oldpos = thing->_f_Pos();
oldsector = thing->Sector;
thing->floorz = tm.floorz;
thing->ceilingz = tm.ceilingz;
thing->ceilingz= tm.ceilingz;
thing->dropoffz = tm.dropoffz; // killough 11/98: keep track of dropoffs
thing->floorpic = tm.floorpic;
thing->floorterrain = tm.floorterrain;
@ -2543,18 +2543,18 @@ bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y)
}
else if (thing->flags3 & MF3_CEILINGHUGGER)
{
newz = tm.ceilingz - thing->height;
newz = tm._f_ceilingz() - thing->height;
}
if (!(thing->flags & MF_NOCLIP))
{
if (tm.ceilingz - tm.floorz < thing->height)
if (tm._f_ceilingz() - tm.floorz < thing->height)
{
return false;
}
if (!(thing->flags & MF_TELEPORT)
&& tm.ceilingz - newz < thing->height
&& tm.ceilingz - newz < thing->_Height()
&& !(thing->flags3 & MF3_CEILINGHUGGER)
&& (!(thing->flags2 & MF2_FLY) || !(thing->flags & MF_NOGRAVITY)))
{
@ -2562,7 +2562,7 @@ bool P_CheckMove(AActor *thing, fixed_t x, fixed_t y)
}
if (thing->flags2 & MF2_FLY && thing->flags & MF_NOGRAVITY)
{
if (thing->_f_Top() > tm.ceilingz)
if (thing->Top() > tm.ceilingz)
return false;
}
if (!(thing->flags & MF_TELEPORT) && !(thing->flags3 & MF3_FLOORHUGGER))
@ -3254,7 +3254,7 @@ bool FSlide::BounceWall(AActor *mo)
if (BounceTraverse(leadx, leady, leadx + mo->_f_velx(), leady + mo->_f_vely()) && mo->BlockingLine == NULL)
{ // Could not find a wall, so bounce off the floor/ceiling instead.
fixed_t floordist = mo->_f_Z() - mo->floorz;
fixed_t ceildist = mo->ceilingz - mo->_f_Z();
fixed_t ceildist = mo->_f_ceilingz() - mo->_f_Z();
if (floordist <= ceildist)
{
mo->FloorBounceMissile(mo->Sector->floorplane);
@ -5679,7 +5679,7 @@ int P_PushUp(AActor *thing, FChangePosition *cpos)
unsigned int lastintersect;
int mymass = thing->Mass;
if (thing->_f_Top() > thing->ceilingz)
if (thing->Top() > thing->ceilingz)
{
return 1;
}
@ -5884,7 +5884,7 @@ void PIT_CeilingLower(AActor *thing, FChangePosition *cpos)
onfloor = thing->_f_Z() <= thing->floorz;
P_AdjustFloorCeil(thing, cpos);
if (thing->_f_Top() > thing->ceilingz)
if (thing->Top() > thing->ceilingz)
{
if (thing->flags4 & MF4_ACTLIKEBRIDGE)
{
@ -5893,9 +5893,9 @@ void PIT_CeilingLower(AActor *thing, FChangePosition *cpos)
}
intersectors.Clear();
fixed_t oldz = thing->_f_Z();
if (thing->ceilingz - thing->height >= thing->floorz)
if (thing->_f_ceilingz() - thing->height >= thing->floorz)
{
thing->_f_SetZ(thing->ceilingz - thing->height);
thing->SetZ(thing->ceilingz - thing->_Height());
}
else
{
@ -5939,23 +5939,23 @@ void PIT_CeilingRaise(AActor *thing, FChangePosition *cpos)
// (or something else?) Things marked as hanging from the ceiling will
// stay where they are.
if (thing->_f_Z() < thing->floorz &&
thing->_f_Top() >= thing->ceilingz - cpos->moveamt &&
thing->_f_Top() >= thing->_f_ceilingz() - cpos->moveamt &&
!(thing->flags & MF_NOLIFTDROP))
{
fixed_t oldz = thing->_f_Z();
thing->_f_SetZ(thing->floorz);
if (thing->_f_Top() > thing->ceilingz)
if (thing->Top() > thing->ceilingz)
{
thing->_f_SetZ(thing->ceilingz - thing->height);
thing->SetZ(thing->ceilingz - thing->_Height());
}
P_CheckFakeFloorTriggers(thing, oldz);
}
else if ((thing->flags2 & MF2_PASSMOBJ) && !isgood && thing->_f_Top() < thing->ceilingz)
else if ((thing->flags2 & MF2_PASSMOBJ) && !isgood && thing->Top() < thing->ceilingz)
{
AActor *onmobj;
if (!P_TestMobjZ(thing, true, &onmobj) && onmobj->_f_Z() <= thing->_f_Z())
if (!P_TestMobjZ(thing, true, &onmobj) && onmobj->Z() <= thing->Z())
{
thing->_f_SetZ( MIN(thing->ceilingz - thing->height, onmobj->_f_Top()));
thing->SetZ(MIN(thing->ceilingz - thing->_Height(), onmobj->Top()));
}
}
if (thing->player && thing->player->mo == thing)

32
src/p_mobj.cpp
View file

@ -2577,20 +2577,20 @@ void P_ZMovement (AActor *mo, fixed_t oldfloorz)
mo->AdjustFloorClip ();
}
if (mo->_f_Top() > mo->ceilingz)
if (mo->Top() > mo->ceilingz)
{ // hit the ceiling
if ((!mo->player || !(mo->player->cheats & CF_PREDICTING)) &&
mo->Sector->SecActTarget != NULL &&
mo->Sector->ceilingplane.ZatPoint(mo) == mo->ceilingz)
mo->Sector->ceilingplane.ZatPoint(mo) == mo->_f_ceilingz())
{ // [RH] Let the sector do something to the actor
mo->Sector->SecActTarget->TriggerAction (mo, SECSPAC_HitCeiling);
}
P_CheckFor3DCeilingHit(mo);
// [RH] Need to recheck this because the sector action might have
// teleported the actor so it is no longer above the ceiling.
if (mo->_f_Top() > mo->ceilingz)
if (mo->Top() > mo->ceilingz)
{
mo->_f_SetZ(mo->ceilingz - mo->height);
mo->SetZ(mo->ceilingz - mo->_Height());
if (mo->BounceFlags & BOUNCE_Ceilings)
{ // ceiling bounce
mo->FloorBounceMissile (mo->ceilingsector->ceilingplane);
@ -2764,9 +2764,9 @@ void P_NightmareRespawn (AActor *mobj)
// can use P_CheckPosition() properly.
mo->_f_SetZ(mo->floorz);
}
if (mo->_f_Top() > mo->ceilingz)
if (mo->Top() > mo->ceilingz)
{
mo->_f_SetZ(mo->ceilingz - mo->height);
mo->SetZ(mo->ceilingz- mo->_Height());
}
}
else if (z == ONCEILINGZ)
@ -2786,9 +2786,9 @@ void P_NightmareRespawn (AActor *mobj)
// can use P_CheckPosition() properly.
mo->_f_SetZ(mo->floorz);
}
if (mo->_f_Top() > mo->ceilingz)
if (mo->Top() > mo->ceilingz)
{ // Do the same for the ceiling.
mo->_f_SetZ(mo->ceilingz - mo->height);
mo->SetZ(mo->ceilingz - mo->_Height());
}
}
@ -4002,7 +4002,7 @@ void AActor::CheckSectorTransition(sector_t *oldsec)
{
P_CheckFor3DFloorHit(this);
}
if (_f_Top() == ceilingz)
if (Top() == ceilingz)
{
P_CheckFor3DCeilingHit(this);
}
@ -4193,7 +4193,7 @@ AActor *AActor::StaticSpawn (PClassActor *type, fixed_t ix, fixed_t iy, fixed_t
actor->dropoffz = // killough 11/98: for tracking dropoffs
actor->floorz = actor->Sector->floorplane.ZatPoint (ix, iy);
actor->ceilingz = actor->Sector->ceilingplane.ZatPoint (ix, iy);
actor->ceilingz = FIXED2DBL(actor->Sector->ceilingplane.ZatPoint (ix, iy));
// The z-coordinate needs to be set once before calling P_FindFloorCeiling
// For FLOATRANDZ just use the floor here.
@ -4203,7 +4203,7 @@ AActor *AActor::StaticSpawn (PClassActor *type, fixed_t ix, fixed_t iy, fixed_t
}
else if (iz == ONCEILINGZ)
{
actor->_f_SetZ(actor->ceilingz - actor->height);
actor->SetZ(actor->ceilingz - actor->_Height());
}
if (SpawningMapThing || !type->IsDescendantOf (RUNTIME_CLASS(APlayerPawn)))
@ -4246,11 +4246,11 @@ AActor *AActor::StaticSpawn (PClassActor *type, fixed_t ix, fixed_t iy, fixed_t
}
else if (iz == ONCEILINGZ)
{
actor->_f_SetZ(actor->ceilingz - actor->height);
actor->SetZ(actor->ceilingz - actor->_Height());
}
else if (iz == FLOATRANDZ)
{
fixed_t space = actor->ceilingz - actor->height - actor->floorz;
fixed_t space = actor->_f_ceilingz() - actor->height - actor->floorz;
if (space > 48*FRACUNIT)
{
space -= 40*FRACUNIT;
@ -4782,9 +4782,9 @@ APlayerPawn *P_SpawnPlayer (FPlayerStart *mthing, int playernum, int flags)
// "Fix" for one of the starts on exec.wad MAP01: If you start inside the ceiling,
// drop down below it, even if that means sinking into the floor.
if (mobj->_f_Top() > mobj->ceilingz)
if (mobj->Top() > mobj->ceilingz)
{
mobj->_f_SetZ(mobj->ceilingz - mobj->height, false);
mobj->SetZ(mobj->ceilingz - mobj->_Height(), false);
}
// [BC] Do script stuff
@ -6698,7 +6698,7 @@ void PrintMiscActorInfo(AActor *query)
Printf("\nTID: %d", query->tid);
Printf("\nCoord= x: %f, y: %f, z:%f, floor:%f, ceiling:%f.",
query->X(), query->Y(), query->Z(),
FIXED2DBL(query->floorz), FIXED2DBL(query->ceilingz));
FIXED2DBL(query->floorz), query->ceilingz);
Printf("\nSpeed= %f, velocity= x:%f, y:%f, z:%f, combined:%f.\n",
query->Speed, query->Vel.X, query->Vel.Y, query->Vel.Z, query->Vel.Length());
}

10
src/p_user.cpp
View file

@ -1852,8 +1852,8 @@ void P_CalcHeight (player_t *player)
{
player->viewz = player->mo->_f_Z() + defaultviewheight;
if (player->viewz > player->mo->ceilingz-4*FRACUNIT)
player->viewz = player->mo->ceilingz-4*FRACUNIT;
if (player->viewz > player->mo->_f_ceilingz()-4*FRACUNIT)
player->viewz = player->mo->_f_ceilingz()-4*FRACUNIT;
return;
}
@ -1911,9 +1911,9 @@ void P_CalcHeight (player_t *player)
{
player->viewz -= player->mo->floorclip;
}
if (player->viewz > player->mo->ceilingz - 4*FRACUNIT)
if (player->viewz > player->mo->_f_ceilingz() - 4*FRACUNIT)
{
player->viewz = player->mo->ceilingz - 4*FRACUNIT;
player->viewz = player->mo->_f_ceilingz() - 4*FRACUNIT;
}
if (player->viewz < player->mo->floorz + 4*FRACUNIT)
{
@ -2415,7 +2415,7 @@ void P_PlayerThink (player_t *player)
player->crouching = 0;
}
if (crouchdir == 1 && player->crouchfactor < 1 &&
player->mo->_f_Top() < player->mo->ceilingz)
player->mo->Top() < player->mo->ceilingz)
{
P_CrouchMove(player, 1);
}

4
src/r_things.cpp
View file

@ -2115,8 +2115,8 @@ void R_DrawSprite (vissprite_t *spr)
if (spr->fakeceiling != NULL)
{
fixed_t ceilingz = spr->fakeceiling->bottom.plane->Zat0();
if (viewz < ceilingz && ceilingz == sclipTop)
fixed_t ceilingZ = spr->fakeceiling->bottom.plane->Zat0();
if (viewz < ceilingZ && ceilingZ == sclipTop)
{
h = spr->fakeceiling->top.plane->Zat0();
}

12
src/thingdef/thingdef_codeptr.cpp
View file

@ -939,8 +939,8 @@ static int DoJumpIfCloser(AActor *target, VM_ARGS)
}
if (self->AproxDistance(target) < dist &&
(noz ||
((self->_f_Z() > target->_f_Z() && self->_f_Z() - target->_f_Top() < dist) ||
(self->_f_Z() <= target->_f_Z() && target->_f_Z() - self->_f_Top() < dist))))
((self->Z() > target->Z() && self->Z() - target->Top() < dist) ||
(self->Z() <= target->Z() && target->Z() - self->Top() < dist))))
{
ACTION_RETURN_STATE(jump);
}
@ -3383,7 +3383,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_CheckCeiling)
PARAM_ACTION_PROLOGUE;
PARAM_STATE(jump);
if (self->_f_Top() >= self->ceilingz) // Height needs to be counted
if (self->Top() >= self->ceilingz) // Height needs to be counted
{
ACTION_RETURN_STATE(jump);
}
@ -4784,7 +4784,7 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
if (flags & TF_SENSITIVEZ)
{
fixed_t posz = (flags & TF_USESPOTZ) ? spot->_f_Z() : spot->floorz;
if ((posz + ref->height > spot->ceilingz) || (posz < spot->floorz))
if ((posz + ref->height > spot->_f_ceilingz()) || (posz < spot->floorz))
{
return numret;
}
@ -4793,8 +4793,8 @@ DEFINE_ACTION_FUNCTION_PARAMS(AActor, A_Teleport)
fixed_t aboveFloor = spot->_f_Z() - spot->floorz;
fixed_t finalz = spot->floorz + aboveFloor;
if (spot->_f_Z() + ref->height > spot->ceilingz)
finalz = spot->ceilingz - ref->height;
if (spot->Z() + ref->_Height() > spot->ceilingz)
finalz = spot->_f_ceilingz() - ref->height;
else if (spot->_f_Z() < spot->floorz)
finalz = spot->floorz;

2
src/thingdef/thingdef_data.cpp
View file

@ -622,7 +622,7 @@ void InitThingdef()
symt.AddSymbol(new PField(NAME_Alpha, TypeFixed, VARF_Native, myoffsetof(AActor,alpha)));
symt.AddSymbol(new PField(NAME_Angle, TypeFloat64, VARF_Native, myoffsetof(AActor,Angles.Yaw)));
symt.AddSymbol(new PField(NAME_Args, array5, VARF_Native, myoffsetof(AActor,args)));
symt.AddSymbol(new PField(NAME_CeilingZ, TypeFixed, VARF_Native, myoffsetof(AActor,ceilingz)));
symt.AddSymbol(new PField(NAME_CeilingZ, TypeFloat64, VARF_Native, myoffsetof(AActor,ceilingz)));
symt.AddSymbol(new PField(NAME_FloorZ, TypeFixed, VARF_Native, myoffsetof(AActor,floorz)));
symt.AddSymbol(new PField(NAME_Health, TypeSInt32, VARF_Native, myoffsetof(AActor,health)));
symt.AddSymbol(new PField(NAME_Mass, TypeSInt32, VARF_Native, myoffsetof(AActor,Mass)));