zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2024-11-11 15:21:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch 'master' of c:\programming\doom-dev\zdoom

Browse source
This commit is contained in:
Christoph Oelckers 2016-04-08 14:19:02 +02:00
commit 3f28478eb2
10 changed files with 283 additions and 322 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

204
src/dsectoreffect.cpp
View file

@ -133,17 +133,17 @@ DMovingCeiling::DMovingCeiling (sector_t *sector)
interpolation = sector->SetInterpolation(sector_t::CeilingMove, true);
}
bool DMover::MoveAttached(int crush, double move, int floorOrCeiling, bool resetfailed)
bool sector_t::MoveAttached(int crush, double move, int floorOrCeiling, bool resetfailed)
{
if (!P_Scroll3dMidtex(m_Sector, crush, move, !!floorOrCeiling) && resetfailed)
if (!P_Scroll3dMidtex(this, crush, move, !!floorOrCeiling) && resetfailed)
{
P_Scroll3dMidtex(m_Sector, crush, -move, !!floorOrCeiling);
P_Scroll3dMidtex(this, crush, -move, !!floorOrCeiling);
return false;
}
if (!P_MoveLinkedSectors(m_Sector, crush, move, !!floorOrCeiling) && resetfailed)
if (!P_MoveLinkedSectors(this, crush, move, !!floorOrCeiling) && resetfailed)
{
P_MoveLinkedSectors(m_Sector, crush, -move, !!floorOrCeiling);
P_Scroll3dMidtex(m_Sector, crush, -move, !!floorOrCeiling);
P_MoveLinkedSectors(this, crush, -move, !!floorOrCeiling);
P_Scroll3dMidtex(this, crush, -move, !!floorOrCeiling);
return false;
}
return true;
@ -155,8 +155,7 @@ bool DMover::MoveAttached(int crush, double move, int floorOrCeiling, bool reset
// (Use -1 to prevent it from trying to crush)
// dest is the desired d value for the plane
//
DMover::EResult DMover::MovePlane (double speed, double dest, int crush,
int floorOrCeiling, int direction, bool hexencrush)
EMoveResult sector_t::MoveFloor(double speed, double dest, int crush, int direction, bool hexencrush)
{
bool flag;
double lastpos;
@ -164,55 +163,51 @@ DMover::EResult DMover::MovePlane (double speed, double dest, int crush,
double move;
//double destheight; //jff 02/04/98 used to keep floors/ceilings
// from moving thru each other
switch (floorOrCeiling)
{
case 0:
// FLOOR
lastpos = m_Sector->floorplane.fD();
lastpos = floorplane.fD();
switch (direction)
{
case -1:
// DOWN
movedest = m_Sector->floorplane.GetChangedHeight (-speed);
movedest = floorplane.GetChangedHeight(-speed);
if (movedest >= dest)
{
move = m_Sector->floorplane.HeightDiff (lastpos, dest);
move = floorplane.HeightDiff(lastpos, dest);
if (!MoveAttached(crush, move, 0, true)) return crushed;
if (!MoveAttached(crush, move, 0, true)) return EMoveResult::crushed;
m_Sector->floorplane.setD(dest);
flag = P_ChangeSector (m_Sector, crush, move, 0, false);
floorplane.setD(dest);
flag = P_ChangeSector(this, crush, move, 0, false);
if (flag)
{
m_Sector->floorplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, -move, 0, true);
floorplane.setD(lastpos);
P_ChangeSector(this, crush, -move, 0, true);
MoveAttached(crush, -move, 0, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::floor, move);
m_Sector->AdjustFloorClip ();
ChangePlaneTexZ(sector_t::floor, move);
AdjustFloorClip();
}
return pastdest;
return EMoveResult::pastdest;
}
else
{
if (!MoveAttached(crush, -speed, 0, true)) return crushed;
if (!MoveAttached(crush, -speed, 0, true)) return EMoveResult::crushed;
m_Sector->floorplane.setD(movedest);
floorplane.setD(movedest);
flag = P_ChangeSector (m_Sector, crush, -speed, 0, false);
flag = P_ChangeSector(this, crush, -speed, 0, false);
if (flag)
{
m_Sector->floorplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, speed, 0, true);
floorplane.setD(lastpos);
P_ChangeSector(this, crush, speed, 0, true);
MoveAttached(crush, speed, 0, false);
return crushed;
return EMoveResult::crushed;
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
ChangePlaneTexZ(sector_t::floor, floorplane.HeightDiff(lastpos));
AdjustFloorClip();
}
}
break;
@ -221,170 +216,175 @@ DMover::EResult DMover::MovePlane (double speed, double dest, int crush,
// UP
// jff 02/04/98 keep floor from moving thru ceilings
// [RH] not so easy with arbitrary planes
//destheight = (dest < m_Sector->ceilingheight) ? dest : m_Sector->ceilingheight;
if (!m_Sector->ceilingplane.isSlope() && !m_Sector->floorplane.isSlope() &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && -dest > m_Sector->ceilingplane.fD()))
//destheight = (dest < ceilingheight) ? dest : ceilingheight;
if (!ceilingplane.isSlope() && !floorplane.isSlope() &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && -dest > ceilingplane.fD()))
{
dest = -m_Sector->ceilingplane.fD();
dest = -ceilingplane.fD();
}
movedest = m_Sector->floorplane.GetChangedHeight (speed);
movedest = floorplane.GetChangedHeight(speed);
if (movedest <= dest)
{
move = m_Sector->floorplane.HeightDiff (lastpos, dest);
move = floorplane.HeightDiff(lastpos, dest);
if (!MoveAttached(crush, move, 0, true)) return crushed;
if (!MoveAttached(crush, move, 0, true)) return EMoveResult::crushed;
m_Sector->floorplane.setD(dest);
floorplane.setD(dest);
flag = P_ChangeSector (m_Sector, crush, move, 0, false);
flag = P_ChangeSector(this, crush, move, 0, false);
if (flag)
{
m_Sector->floorplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, -move, 0, true);
floorplane.setD(lastpos);
P_ChangeSector(this, crush, -move, 0, true);
MoveAttached(crush, -move, 0, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::floor, move);
m_Sector->AdjustFloorClip ();
ChangePlaneTexZ(sector_t::floor, move);
AdjustFloorClip();
}
return pastdest;
return EMoveResult::pastdest;
}
else
{
if (!MoveAttached(crush, speed, 0, true)) return crushed;
if (!MoveAttached(crush, speed, 0, true)) return EMoveResult::crushed;
m_Sector->floorplane.setD(movedest);
floorplane.setD(movedest);
// COULD GET CRUSHED
flag = P_ChangeSector (m_Sector, crush, speed, 0, false);
flag = P_ChangeSector(this, crush, speed, 0, false);
if (flag)
{
if (crush >= 0 && !hexencrush)
{
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
return crushed;
ChangePlaneTexZ(sector_t::floor, floorplane.HeightDiff(lastpos));
AdjustFloorClip();
return EMoveResult::crushed;
}
m_Sector->floorplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, -speed, 0, true);
floorplane.setD(lastpos);
P_ChangeSector(this, crush, -speed, 0, true);
MoveAttached(crush, -speed, 0, false);
return crushed;
return EMoveResult::crushed;
}
m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
m_Sector->AdjustFloorClip ();
ChangePlaneTexZ(sector_t::floor, floorplane.HeightDiff(lastpos));
AdjustFloorClip();
}
break;
}
break;
return EMoveResult::ok;
}
case 1:
// CEILING
lastpos = m_Sector->ceilingplane.fD();
EMoveResult sector_t::MoveCeiling(double speed, double dest, int crush, int direction, bool hexencrush)
{
bool flag;
double lastpos;
double movedest;
double move;
//double destheight; //jff 02/04/98 used to keep floors/ceilings
// from moving thru each other
lastpos = ceilingplane.fD();
switch (direction)
{
case -1:
// DOWN
// jff 02/04/98 keep ceiling from moving thru floors
// [RH] not so easy with arbitrary planes
//destheight = (dest > m_Sector->floorheight) ? dest : m_Sector->floorheight;
if (!m_Sector->ceilingplane.isSlope() && !m_Sector->floorplane.isSlope() &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -m_Sector->floorplane.fD()))
//destheight = (dest > floorheight) ? dest : floorheight;
if (!ceilingplane.isSlope() && !floorplane.isSlope() &&
(!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -floorplane.fD()))
{
dest = -m_Sector->floorplane.fD();
dest = -floorplane.fD();
}
movedest = m_Sector->ceilingplane.GetChangedHeight (-speed);
movedest = ceilingplane.GetChangedHeight (-speed);
if (movedest <= dest)
{
move = m_Sector->ceilingplane.HeightDiff (lastpos, dest);
move = ceilingplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 1, true)) return crushed;
if (!MoveAttached(crush, move, 1, true)) return EMoveResult::crushed;
m_Sector->ceilingplane.setD(dest);
flag = P_ChangeSector (m_Sector, crush, move, 1, false);
ceilingplane.setD(dest);
flag = P_ChangeSector (this, crush, move, 1, false);
if (flag)
{
m_Sector->ceilingplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, -move, 1, true);
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, -move, 1, true);
MoveAttached(crush, -move, 1, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
ChangePlaneTexZ(sector_t::ceiling, move);
}
return pastdest;
return EMoveResult::pastdest;
}
else
{
if (!MoveAttached(crush, -speed, 1, true)) return crushed;
if (!MoveAttached(crush, -speed, 1, true)) return EMoveResult::crushed;
m_Sector->ceilingplane.setD(movedest);
ceilingplane.setD(movedest);
// COULD GET CRUSHED
flag = P_ChangeSector (m_Sector, crush, -speed, 1, false);
flag = P_ChangeSector (this, crush, -speed, 1, false);
if (flag)
{
if (crush >= 0 && !hexencrush)
{
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
return crushed;
ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
return EMoveResult::crushed;
}
m_Sector->ceilingplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, speed, 1, true);
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, speed, 1, true);
MoveAttached(crush, speed, 1, false);
return crushed;
return EMoveResult::crushed;
}
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
}
break;
case 1:
// UP
movedest = m_Sector->ceilingplane.GetChangedHeight (speed);
movedest = ceilingplane.GetChangedHeight (speed);
if (movedest >= dest)
{
move = m_Sector->ceilingplane.HeightDiff (lastpos, dest);
move = ceilingplane.HeightDiff (lastpos, dest);
if (!MoveAttached(crush, move, 1, true)) return crushed;
if (!MoveAttached(crush, move, 1, true)) return EMoveResult::crushed;
m_Sector->ceilingplane.setD(dest);
ceilingplane.setD(dest);
flag = P_ChangeSector (m_Sector, crush, move, 1, false);
flag = P_ChangeSector (this, crush, move, 1, false);
if (flag)
{
m_Sector->ceilingplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, move, 1, true);
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, move, 1, true);
MoveAttached(crush, move, 1, false);
}
else
{
m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
ChangePlaneTexZ(sector_t::ceiling, move);
}
return pastdest;
return EMoveResult::pastdest;
}
else
{
if (!MoveAttached(crush, speed, 1, true)) return crushed;
if (!MoveAttached(crush, speed, 1, true)) return EMoveResult::crushed;
m_Sector->ceilingplane.setD(movedest);
ceilingplane.setD(movedest);
flag = P_ChangeSector (m_Sector, crush, speed, 1, false);
flag = P_ChangeSector (this, crush, speed, 1, false);
if (flag)
{
m_Sector->ceilingplane.setD(lastpos);
P_ChangeSector (m_Sector, crush, -speed, 1, true);
ceilingplane.setD(lastpos);
P_ChangeSector (this, crush, -speed, 1, true);
MoveAttached(crush, -speed, 1, false);
return crushed;
return EMoveResult::crushed;
}
m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
}
break;
}
break;
}
return ok;
return EMoveResult::ok;
}

19
src/dsectoreffect.h
View file

@ -27,32 +27,13 @@ class DMover : public DSectorEffect
public:
DMover (sector_t *sector);
protected:
enum EResult { ok, crushed, pastdest };
TObjPtr<DInterpolation> interpolation;
private:
bool MoveAttached(int crush, double move, int floorOrCeiling, bool resetfailed);
EResult MovePlane (double speed, double dest, int crush, int floorOrCeiling, int direction, bool hexencrush);
protected:
DMover ();
void Serialize (FArchive &arc);
void Destroy();
void StopInterpolation(bool force = false);
inline EResult MoveFloor (double speed, double dest, int crush, int direction, bool hexencrush)
{
return MovePlane (speed, dest, crush, 0, direction, hexencrush);
}
inline EResult MoveFloor (double speed, double dest, int direction)
{
return MovePlane (speed, dest, -1, 0, direction, false);
}
inline EResult MoveCeiling (double speed, double dest, int crush, int direction, bool hexencrush)
{
return MovePlane (speed, dest, crush, 1, direction, hexencrush);
}
inline EResult MoveCeiling (double speed, double dest, int direction)
{
return MovePlane (speed, dest, -1, 1, direction, false);
}
};
class DMovingFloor : public DMover

55
src/fragglescript/t_func.cpp
View file

@ -1535,26 +1535,6 @@ void FParser::SF_StartSectorSound(void)
}
}
/************* Sector functions ***************/
class DFloorChanger : public DFloor
{
public:
DFloorChanger(sector_t * sec)
: DFloor(sec) {}
bool Move(double speed, double dest, int crush, int direction)
{
bool res = DMover::crushed != MoveFloor(speed, dest, crush, direction, false);
Destroy();
m_Sector->floordata=NULL;
StopInterpolation(true);
m_Sector=NULL;
return res;
}
};
//==========================================================================
//
//
@ -1588,12 +1568,12 @@ void FParser::SF_FloorHeight(void)
{
if (sectors[i].floordata) continue; // don't move floors that are active!
DFloorChanger * f = new DFloorChanger(&sectors[i]);
if (!f->Move(
if (sectors[i].MoveFloor(
fabs(dest - sectors[i].CenterFloor()),
sectors[i].floorplane.PointToDist (sectors[i].centerspot, dest),
crush? 10:-1,
(dest > sectors[i].CenterFloor()) ? 1 : -1))
(dest > sectors[i].CenterFloor()) ? 1 : -1,
false) != EMoveResult::crushed)
{
returnval = 0;
}
@ -1686,29 +1666,6 @@ void FParser::SF_MoveFloor(void)
//
//==========================================================================
class DCeilingChanger : public DCeiling
{
public:
DCeilingChanger(sector_t * sec)
: DCeiling(sec) {}
bool Move(double speed, double dest, int crush, int direction)
{
bool res = DMover::crushed != MoveCeiling(speed, dest, crush, direction, false);
Destroy();
m_Sector->ceilingdata=NULL;
StopInterpolation (true);
m_Sector=NULL;
return res;
}
};
//==========================================================================
//
//
//
//==========================================================================
// ceiling height of sector
void FParser::SF_CeilingHeight(void)
{
@ -1735,12 +1692,12 @@ void FParser::SF_CeilingHeight(void)
{
if (sectors[i].ceilingdata) continue; // don't move ceilings that are active!
DCeilingChanger * c = new DCeilingChanger(&sectors[i]);
if (!c->Move(
if (sectors[i].MoveCeiling(
fabs(dest - sectors[i].CenterCeiling()),
sectors[i].ceilingplane.PointToDist (sectors[i].centerspot, dest),
crush? 10:-1,
(dest > sectors[i].CenterCeiling()) ? 1 : -1))
(dest > sectors[i].CenterCeiling()) ? 1 : -1,
false) != EMoveResult::crushed)
{
returnval = 0;
}

6
src/g_hexen/a_fighterplayer.cpp
View file

@ -27,7 +27,11 @@ static FRandom pr_fpatk ("FPunchAttack");
void AdjustPlayerAngle (AActor *pmo, FTranslatedLineTarget *t)
{
DAngle difference = deltaangle(pmo->Angles.Yaw, pmo->AngleTo(t->linetarget));
// normally this will adjust relative to the actual direction to the target,
// but with arbitrary portals that cannot be calculated so using the actual
// attack angle is the only option.
DAngle atkangle = t->unlinked ? t->angleFromSource : pmo->AngleTo(t->linetarget);
DAngle difference = deltaangle(pmo->Angles.Yaw, atkangle);
if (fabs(difference) > MAX_ANGLE_ADJUST)
{
if (difference > 0)

12
src/p_ceiling.cpp
View file

@ -127,7 +127,7 @@ void DCeiling::PlayCeilingSound ()
void DCeiling::Tick ()
{
EResult res;
EMoveResult res;
switch (m_Direction)
{
@ -136,9 +136,9 @@ void DCeiling::Tick ()
break;
case 1:
// UP
res = MoveCeiling (m_Speed, m_TopHeight, m_Direction);
res = m_Sector->MoveCeiling (m_Speed, m_TopHeight, m_Direction);
if (res == pastdest)
if (res == EMoveResult::pastdest)
{
switch (m_Type)
{
@ -167,9 +167,9 @@ void DCeiling::Tick ()
case -1:
// DOWN
res = MoveCeiling (m_Speed, m_BottomHeight, m_Crush, m_Direction, m_CrushMode == ECrushMode::crushHexen);
res = m_Sector->MoveCeiling (m_Speed, m_BottomHeight, m_Crush, m_Direction, m_CrushMode == ECrushMode::crushHexen);
if (res == pastdest)
if (res == EMoveResult::pastdest)
{
switch (m_Type)
{
@ -198,7 +198,7 @@ void DCeiling::Tick ()
}
else // ( res != pastdest )
{
if (res == crushed)
if (res == EMoveResult::crushed)
{
switch (m_Type)
{

22
src/p_doors.cpp
View file

@ -80,7 +80,7 @@ void DDoor::Serialize (FArchive &arc)
void DDoor::Tick ()
{
EResult res;
EMoveResult res;
// Adjust bottom height - but only if there isn't an active lift attached to the floor.
if (m_Sector->floorplane.fD() != m_OldFloorDist)
@ -137,7 +137,7 @@ void DDoor::Tick ()
case -1:
// DOWN
res = MoveCeiling (m_Speed, m_BotDist, -1, m_Direction, false);
res = m_Sector->MoveCeiling (m_Speed, m_BotDist, -1, m_Direction, false);
// killough 10/98: implement gradual lighting effects
if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fD())
@ -146,7 +146,7 @@ void DDoor::Tick ()
(m_Sector->ceilingplane.fD() + m_Sector->floorplane.fD()) / (m_TopDist + m_Sector->floorplane.fD()));
}
if (res == pastdest)
if (res == EMoveResult::pastdest)
{
SN_StopSequence (m_Sector, CHAN_CEILING);
switch (m_Type)
@ -166,7 +166,7 @@ void DDoor::Tick ()
break;
}
}
else if (res == crushed)
else if (res == EMoveResult::crushed)
{
switch (m_Type)
{
@ -183,7 +183,7 @@ void DDoor::Tick ()
case 1:
// UP
res = MoveCeiling (m_Speed, m_TopDist, -1, m_Direction, false);
res = m_Sector->MoveCeiling (m_Speed, m_TopDist, -1, m_Direction, false);
// killough 10/98: implement gradual lighting effects
if (m_LightTag != 0 && m_TopDist != -m_Sector->floorplane.fD())
@ -192,7 +192,7 @@ void DDoor::Tick ()
(m_Sector->ceilingplane.fD() + m_Sector->floorplane.fD()) / (m_TopDist + m_Sector->floorplane.fD()));
}
if (res == pastdest)
if (res == EMoveResult::pastdest)
{
SN_StopSequence (m_Sector, CHAN_CEILING);
switch (m_Type)
@ -212,7 +212,7 @@ void DDoor::Tick ()
break;
}
}
else if (res == crushed)
else if (res == EMoveResult::crushed)
{
switch (m_Type)
{
@ -560,12 +560,12 @@ bool DAnimatedDoor::StartClosing ()
}
double topdist = m_Sector->ceilingplane.fD();
if (MoveCeiling (2048., m_BotDist, 0, -1, false) == crushed)
if (m_Sector->MoveCeiling (2048., m_BotDist, 0, -1, false) == EMoveResult::crushed)
{
return false;
}
MoveCeiling (2048., topdist, 1);
m_Sector->MoveCeiling (2048., topdist, 1);
m_Line1->flags |= ML_BLOCKING;
m_Line2->flags |= ML_BLOCKING;
@ -650,7 +650,7 @@ void DAnimatedDoor::Tick ()
if (--m_Frame < 0)
{
// IF DOOR IS DONE CLOSING...
MoveCeiling (2048., m_BotDist, -1);
m_Sector->MoveCeiling (2048., m_BotDist, -1);
m_Sector->ceilingdata = NULL;
Destroy ();
// Unset blocking flags on lines that didn't start with them. Since the
@ -734,7 +734,7 @@ DAnimatedDoor::DAnimatedDoor (sector_t *sec, line_t *line, int speed, int delay,
m_Line1->flags |= ML_BLOCKING;
m_Line2->flags |= ML_BLOCKING;
m_BotDist = m_Sector->ceilingplane.fD();
MoveCeiling (2048., topdist, 1);
m_Sector->MoveCeiling (2048., topdist, 1);
if (m_DoorAnim->OpenSound != NAME_None)
{
SN_StartSequence (m_Sector, CHAN_INTERIOR, m_DoorAnim->OpenSound, 1);

30
src/p_floor.cpp
View file

@ -112,7 +112,7 @@ void DFloor::Serialize (FArchive &arc)
void DFloor::Tick ()
{
EResult res;
EMoveResult res;
// [RH] Handle resetting stairs
if (m_Type == buildStair || m_Type == waitStair)
@ -144,9 +144,9 @@ void DFloor::Tick ()
if (m_Type == waitStair)
return;
res = MoveFloor (m_Speed, m_FloorDestDist, m_Crush, m_Direction, m_Hexencrush);
res = m_Sector->MoveFloor (m_Speed, m_FloorDestDist, m_Crush, m_Direction, m_Hexencrush);
if (res == pastdest)
if (res == EMoveResult::pastdest)
{
SN_StopSequence (m_Sector, CHAN_FLOOR);
@ -898,7 +898,7 @@ void DElevator::Destroy()
void DElevator::Tick ()
{
EResult res;
EMoveResult res;
double oldfloor, oldceiling;
@ -907,30 +907,30 @@ void DElevator::Tick ()
if (m_Direction < 0) // moving down
{
res = MoveFloor (m_Speed, m_FloorDestDist, m_Direction);
if (res == ok || res == pastdest)
res = m_Sector->MoveFloor (m_Speed, m_FloorDestDist, m_Direction);
if (res == EMoveResult::ok || res == EMoveResult::pastdest)
{
res = MoveCeiling (m_Speed, m_CeilingDestDist, m_Direction);
if (res == crushed)
res = m_Sector->MoveCeiling (m_Speed, m_CeilingDestDist, m_Direction);
if (res == EMoveResult::crushed)
{
MoveFloor (m_Speed, oldfloor, -m_Direction);
m_Sector->MoveFloor (m_Speed, oldfloor, -m_Direction);
}
}
}
else // up
{
res = MoveCeiling (m_Speed, m_CeilingDestDist, m_Direction);
if (res == ok || res == pastdest)
res = m_Sector->MoveCeiling (m_Speed, m_CeilingDestDist, m_Direction);
if (res == EMoveResult::ok || res == EMoveResult::pastdest)
{
res = MoveFloor (m_Speed, m_FloorDestDist, m_Direction);
if (res == crushed)
res = m_Sector->MoveFloor (m_Speed, m_FloorDestDist, m_Direction);
if (res == EMoveResult::crushed)
{
MoveCeiling (m_Speed, oldceiling, -m_Direction);
m_Sector->MoveCeiling (m_Speed, oldceiling, -m_Direction);
}
}
}
if (res == pastdest) // if destination height acheived
if (res == EMoveResult::pastdest) // if destination height acheived
{
// make floor stop sound
SN_StopSequence (m_Sector, CHAN_FLOOR);

20
src/p_pillar.cpp
View file

@ -88,7 +88,7 @@ void DPillar::Serialize (FArchive &arc)
void DPillar::Tick ()
{
int r, s;
EMoveResult r, s;
double oldfloor, oldceiling;
oldfloor = m_Sector->floorplane.fD();
@ -96,29 +96,29 @@ void DPillar::Tick ()
if (m_Type == pillarBuild)
{
r = MoveFloor (m_FloorSpeed, m_FloorTarget, m_Crush, 1, m_Hexencrush);
s = MoveCeiling (m_CeilingSpeed, m_CeilingTarget, m_Crush, -1, m_Hexencrush);
r = m_Sector->MoveFloor (m_FloorSpeed, m_FloorTarget, m_Crush, 1, m_Hexencrush);
s = m_Sector->MoveCeiling (m_CeilingSpeed, m_CeilingTarget, m_Crush, -1, m_Hexencrush);
}
else
{
r = MoveFloor (m_FloorSpeed, m_FloorTarget, m_Crush, -1, m_Hexencrush);
s = MoveCeiling (m_CeilingSpeed, m_CeilingTarget, m_Crush, 1, m_Hexencrush);
r = m_Sector->MoveFloor (m_FloorSpeed, m_FloorTarget, m_Crush, -1, m_Hexencrush);
s = m_Sector->MoveCeiling (m_CeilingSpeed, m_CeilingTarget, m_Crush, 1, m_Hexencrush);
}
if (r == pastdest && s == pastdest)
if (r == EMoveResult::pastdest && s == EMoveResult::pastdest)
{
SN_StopSequence (m_Sector, CHAN_FLOOR);
Destroy ();
}
else
{
if (r == crushed)
if (r == EMoveResult::crushed)
{
MoveFloor (m_FloorSpeed, oldfloor, -1, -1, m_Hexencrush);
m_Sector->MoveFloor (m_FloorSpeed, oldfloor, -1, -1, m_Hexencrush);
}
if (s == crushed)
if (s == EMoveResult::crushed)
{
MoveCeiling (m_CeilingSpeed, oldceiling, -1, 1, m_Hexencrush);
m_Sector->MoveCeiling (m_CeilingSpeed, oldceiling, -1, 1, m_Hexencrush);
}
}
}

14
src/p_plats.cpp
View file

@ -94,20 +94,20 @@ void DPlat::PlayPlatSound (const char *sound)
//
void DPlat::Tick ()
{
EResult res;
EMoveResult res;
switch (m_Status)
{
case up:
res = MoveFloor (m_Speed, m_High, m_Crush, 1, false);
res = m_Sector->MoveFloor (m_Speed, m_High, m_Crush, 1, false);
if (res == crushed && (m_Crush == -1))
if (res == EMoveResult::crushed && (m_Crush == -1))
{
m_Count = m_Wait;
m_Status = down;
PlayPlatSound ("Platform");
}
else if (res == pastdest)
else if (res == EMoveResult::pastdest)
{
SN_StopSequence (m_Sector, CHAN_FLOOR);
if (m_Type != platToggle)
@ -144,9 +144,9 @@ void DPlat::Tick ()
break;
case down:
res = MoveFloor (m_Speed, m_Low, -1, -1, false);
res = m_Sector->MoveFloor (m_Speed, m_Low, -1, -1, false);
if (res == pastdest)
if (res == EMoveResult::pastdest)
{
SN_StopSequence (m_Sector, CHAN_FLOOR);
// if not an instant toggle, start waiting
@ -172,7 +172,7 @@ void DPlat::Tick ()
m_Status = in_stasis; //for reactivation of toggle
}
}
else if (res == crushed && m_Crush < 0 && m_Type != platToggle)
else if (res == EMoveResult::crushed && m_Crush < 0 && m_Type != platToggle)
{
m_Status = up;
m_Count = m_Wait;

19
src/r_defs.h
View file

@ -648,9 +648,28 @@ struct secspecial_t
FArchive &operator<< (FArchive &arc, secspecial_t &p);
enum class EMoveResult { ok, crushed, pastdest };
struct sector_t
{
// Member functions
private:
bool MoveAttached(int crush, double move, int floorOrCeiling, bool resetfailed);
public:
EMoveResult MoveFloor(double speed, double dest, int crush, int direction, bool hexencrush);
EMoveResult MoveCeiling(double speed, double dest, int crush, int direction, bool hexencrush);
inline EMoveResult MoveFloor(double speed, double dest, int direction)
{
return MoveFloor(speed, dest, -1, direction, false);
}
inline EMoveResult MoveCeiling(double speed, double dest, int direction)
{
return MoveCeiling(speed, dest, -1, direction, false);
}
bool IsLinked(sector_t *other, bool ceiling) const;
double FindLowestFloorSurrounding(vertex_t **v) const;
double FindHighestFloorSurrounding(vertex_t **v) const;