diff --git a/src/dsectoreffect.cpp b/src/dsectoreffect.cpp
index 50909764f4..499eb96c8d 100644
--- a/src/dsectoreffect.cpp
+++ b/src/dsectoreffect.cpp
@@ -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,227 +163,228 @@ 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)
+	lastpos = floorplane.fD();
+	switch (direction)
 	{
-	case 0:
-		// FLOOR
-		lastpos = m_Sector->floorplane.fD();
-		switch (direction)
+	case -1:
+		// DOWN
+		movedest = floorplane.GetChangedHeight(-speed);
+		if (movedest >= dest)
 		{
-		case -1:
-			// DOWN
-			movedest = m_Sector->floorplane.GetChangedHeight (-speed);
-			if (movedest >= dest)
+			move = floorplane.HeightDiff(lastpos, dest);
+
+			if (!MoveAttached(crush, move, 0, true)) return EMoveResult::crushed;
+
+			floorplane.setD(dest);
+			flag = P_ChangeSector(this, crush, move, 0, false);
+			if (flag)
 			{
-				move = m_Sector->floorplane.HeightDiff (lastpos, dest);
-
-				if (!MoveAttached(crush, move, 0, true)) return crushed;
-
-				m_Sector->floorplane.setD(dest);
-				flag = P_ChangeSector (m_Sector, crush, move, 0, false);
-				if (flag)
-				{
-					m_Sector->floorplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, -move, 0, true);
-					MoveAttached(crush, -move, 0, false);
-				}
-				else
-				{
-					m_Sector->ChangePlaneTexZ(sector_t::floor, move);
-					m_Sector->AdjustFloorClip ();
-				}
-				return pastdest;
+				floorplane.setD(lastpos);
+				P_ChangeSector(this, crush, -move, 0, true);
+				MoveAttached(crush, -move, 0, false);
 			}
 			else
 			{
-				if (!MoveAttached(crush, -speed, 0, true)) return crushed;
-
-				m_Sector->floorplane.setD(movedest);
-
-				flag = P_ChangeSector (m_Sector, crush, -speed, 0, false);
-				if (flag)
-				{
-					m_Sector->floorplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, speed, 0, true);
-					MoveAttached(crush, speed, 0, false);
-					return crushed;
-				}
-				else
-				{
-					m_Sector->ChangePlaneTexZ(sector_t::floor, m_Sector->floorplane.HeightDiff (lastpos));
-					m_Sector->AdjustFloorClip ();
-				}
+				ChangePlaneTexZ(sector_t::floor, move);
+				AdjustFloorClip();
 			}
-			break;
-												
-		case 1:
-			// 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()))
+			return EMoveResult::pastdest;
+		}
+		else
+		{
+			if (!MoveAttached(crush, -speed, 0, true)) return EMoveResult::crushed;
+
+			floorplane.setD(movedest);
+
+			flag = P_ChangeSector(this, crush, -speed, 0, false);
+			if (flag)
 			{
-				dest = -m_Sector->ceilingplane.fD();
-			}
-
-			movedest = m_Sector->floorplane.GetChangedHeight (speed);
-
-			if (movedest <= dest)
-			{
-				move = m_Sector->floorplane.HeightDiff (lastpos, dest);
-
-				if (!MoveAttached(crush, move, 0, true)) return crushed;
-
-				m_Sector->floorplane.setD(dest);
-
-				flag = P_ChangeSector (m_Sector, crush, move, 0, false);
-				if (flag)
-				{
-					m_Sector->floorplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, -move, 0, true);
-					MoveAttached(crush, -move, 0, false);
-				}
-				else
-				{
-					m_Sector->ChangePlaneTexZ(sector_t::floor, move);
-					m_Sector->AdjustFloorClip ();
-				}
-				return pastdest;
+				floorplane.setD(lastpos);
+				P_ChangeSector(this, crush, speed, 0, true);
+				MoveAttached(crush, speed, 0, false);
+				return EMoveResult::crushed;
 			}
 			else
 			{
-				if (!MoveAttached(crush, speed, 0, true)) return crushed;
-
-				m_Sector->floorplane.setD(movedest);
-
-				// COULD GET CRUSHED
-				flag = P_ChangeSector (m_Sector, 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;
-					}
-					m_Sector->floorplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, -speed, 0, true);
-					MoveAttached(crush, -speed, 0, false);
-					return 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;
-																		
-	  case 1:
-		// CEILING
-		lastpos = m_Sector->ceilingplane.fD();
-		switch (direction)
+
+	case 1:
+		// UP
+		// jff 02/04/98 keep floor from moving thru ceilings
+		// [RH] not so easy with arbitrary planes
+		//destheight = (dest < ceilingheight) ? dest : ceilingheight;
+		if (!ceilingplane.isSlope() && !floorplane.isSlope() &&
+			(!(i_compatflags2 & COMPATF2_FLOORMOVE) && -dest > ceilingplane.fD()))
 		{
-		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()))
+			dest = -ceilingplane.fD();
+		}
+
+		movedest = floorplane.GetChangedHeight(speed);
+
+		if (movedest <= dest)
+		{
+			move = floorplane.HeightDiff(lastpos, dest);
+
+			if (!MoveAttached(crush, move, 0, true)) return EMoveResult::crushed;
+
+			floorplane.setD(dest);
+
+			flag = P_ChangeSector(this, crush, move, 0, false);
+			if (flag)
 			{
-				dest = -m_Sector->floorplane.fD();
-			}
-			movedest = m_Sector->ceilingplane.GetChangedHeight (-speed);
-			if (movedest <= dest)
-			{
-				move = m_Sector->ceilingplane.HeightDiff (lastpos, dest);
-
-				if (!MoveAttached(crush, move, 1, true)) return crushed;
-
-				m_Sector->ceilingplane.setD(dest);
-				flag = P_ChangeSector (m_Sector, crush, move, 1, false);
-
-				if (flag)
-				{
-					m_Sector->ceilingplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, -move, 1, true);
-					MoveAttached(crush, -move, 1, false);
-				}
-				else
-				{
-					m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
-				}
-				return pastdest;
+				floorplane.setD(lastpos);
+				P_ChangeSector(this, crush, -move, 0, true);
+				MoveAttached(crush, -move, 0, false);
 			}
 			else
 			{
-				if (!MoveAttached(crush, -speed, 1, true)) return crushed;
-
-				m_Sector->ceilingplane.setD(movedest);
-
-				// COULD GET CRUSHED
-				flag = P_ChangeSector (m_Sector, crush, -speed, 1, false);
-				if (flag)
-				{
-					if (crush >= 0 && !hexencrush)
-					{
-						m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
-						return crushed;
-					}
-					m_Sector->ceilingplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, speed, 1, true);
-					MoveAttached(crush, speed, 1, false);
-					return crushed;
-				}
-				m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
+				ChangePlaneTexZ(sector_t::floor, move);
+				AdjustFloorClip();
 			}
-			break;
-												
-		case 1:
-			// UP
-			movedest = m_Sector->ceilingplane.GetChangedHeight (speed);
-			if (movedest >= dest)
+			return EMoveResult::pastdest;
+		}
+		else
+		{
+			if (!MoveAttached(crush, speed, 0, true)) return EMoveResult::crushed;
+
+			floorplane.setD(movedest);
+
+			// COULD GET CRUSHED
+			flag = P_ChangeSector(this, crush, speed, 0, false);
+			if (flag)
 			{
-				move = m_Sector->ceilingplane.HeightDiff (lastpos, dest);
-
-				if (!MoveAttached(crush, move, 1, true)) return crushed;
-
-				m_Sector->ceilingplane.setD(dest);
-
-				flag = P_ChangeSector (m_Sector, crush, move, 1, false);
-				if (flag)
+				if (crush >= 0 && !hexencrush)
 				{
-					m_Sector->ceilingplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, move, 1, true);
-					MoveAttached(crush, move, 1, false);
+					ChangePlaneTexZ(sector_t::floor, floorplane.HeightDiff(lastpos));
+					AdjustFloorClip();
+					return EMoveResult::crushed;
 				}
-				else
-				{
-					m_Sector->ChangePlaneTexZ(sector_t::ceiling, move);
-				}
-				return pastdest;
+				floorplane.setD(lastpos);
+				P_ChangeSector(this, crush, -speed, 0, true);
+				MoveAttached(crush, -speed, 0, false);
+				return EMoveResult::crushed;
 			}
-			else
-			{
-				if (!MoveAttached(crush, speed, 1, true)) return crushed;
-
-				m_Sector->ceilingplane.setD(movedest);
-
-				flag = P_ChangeSector (m_Sector, crush, speed, 1, false);
-				if (flag)
-				{
-					m_Sector->ceilingplane.setD(lastpos);
-					P_ChangeSector (m_Sector, crush, -speed, 1, true);
-					MoveAttached(crush, -speed, 1, false);
-					return crushed;
-				}
-				m_Sector->ChangePlaneTexZ(sector_t::ceiling, m_Sector->ceilingplane.HeightDiff (lastpos));
-			}
-			break;
+			ChangePlaneTexZ(sector_t::floor, floorplane.HeightDiff(lastpos));
+			AdjustFloorClip();
 		}
 		break;
-				
 	}
-	return ok;
+	return EMoveResult::ok;
+}
+
+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 > floorheight) ? dest : floorheight;
+		if (!ceilingplane.isSlope() && !floorplane.isSlope() &&
+			(!(i_compatflags2 & COMPATF2_FLOORMOVE) && dest < -floorplane.fD()))
+		{
+			dest = -floorplane.fD();
+		}
+		movedest = ceilingplane.GetChangedHeight (-speed);
+		if (movedest <= dest)
+		{
+			move = ceilingplane.HeightDiff (lastpos, dest);
+
+			if (!MoveAttached(crush, move, 1, true)) return EMoveResult::crushed;
+
+			ceilingplane.setD(dest);
+			flag = P_ChangeSector (this, crush, move, 1, false);
+
+			if (flag)
+			{
+				ceilingplane.setD(lastpos);
+				P_ChangeSector (this, crush, -move, 1, true);
+				MoveAttached(crush, -move, 1, false);
+			}
+			else
+			{
+				ChangePlaneTexZ(sector_t::ceiling, move);
+			}
+			return EMoveResult::pastdest;
+		}
+		else
+		{
+			if (!MoveAttached(crush, -speed, 1, true)) return EMoveResult::crushed;
+
+			ceilingplane.setD(movedest);
+
+			// COULD GET CRUSHED
+			flag = P_ChangeSector (this, crush, -speed, 1, false);
+			if (flag)
+			{
+				if (crush >= 0 && !hexencrush)
+				{
+					ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
+					return EMoveResult::crushed;
+				}
+				ceilingplane.setD(lastpos);
+				P_ChangeSector (this, crush, speed, 1, true);
+				MoveAttached(crush, speed, 1, false);
+				return EMoveResult::crushed;
+			}
+			ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
+		}
+		break;
+												
+	case 1:
+		// UP
+		movedest = ceilingplane.GetChangedHeight (speed);
+		if (movedest >= dest)
+		{
+			move = ceilingplane.HeightDiff (lastpos, dest);
+
+			if (!MoveAttached(crush, move, 1, true)) return EMoveResult::crushed;
+
+			ceilingplane.setD(dest);
+
+			flag = P_ChangeSector (this, crush, move, 1, false);
+			if (flag)
+			{
+				ceilingplane.setD(lastpos);
+				P_ChangeSector (this, crush, move, 1, true);
+				MoveAttached(crush, move, 1, false);
+			}
+			else
+			{
+				ChangePlaneTexZ(sector_t::ceiling, move);
+			}
+			return EMoveResult::pastdest;
+		}
+		else
+		{
+			if (!MoveAttached(crush, speed, 1, true)) return EMoveResult::crushed;
+
+			ceilingplane.setD(movedest);
+
+			flag = P_ChangeSector (this, crush, speed, 1, false);
+			if (flag)
+			{
+				ceilingplane.setD(lastpos);
+				P_ChangeSector (this, crush, -speed, 1, true);
+				MoveAttached(crush, -speed, 1, false);
+				return EMoveResult::crushed;
+			}
+			ChangePlaneTexZ(sector_t::ceiling, ceilingplane.HeightDiff (lastpos));
+		}
+		break;
+	}
+	return EMoveResult::ok;
 }
diff --git a/src/dsectoreffect.h b/src/dsectoreffect.h
index bbafd898d5..0423244161 100644
--- a/src/dsectoreffect.h
+++ b/src/dsectoreffect.h
@@ -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
diff --git a/src/fragglescript/t_func.cpp b/src/fragglescript/t_func.cpp
index 41f740dda6..9bf043af73 100644
--- a/src/fragglescript/t_func.cpp
+++ b/src/fragglescript/t_func.cpp
@@ -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;
 				}
diff --git a/src/g_hexen/a_fighterplayer.cpp b/src/g_hexen/a_fighterplayer.cpp
index 607a9a88a6..c8f3aa19f7 100644
--- a/src/g_hexen/a_fighterplayer.cpp
+++ b/src/g_hexen/a_fighterplayer.cpp
@@ -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)
diff --git a/src/p_ceiling.cpp b/src/p_ceiling.cpp
index 00af933ef3..9a506be29b 100644
--- a/src/p_ceiling.cpp
+++ b/src/p_ceiling.cpp
@@ -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)
 				{
diff --git a/src/p_doors.cpp b/src/p_doors.cpp
index ba2fba399e..b122768bbc 100644
--- a/src/p_doors.cpp
+++ b/src/p_doors.cpp
@@ -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);
diff --git a/src/p_floor.cpp b/src/p_floor.cpp
index 9ad68c3b1f..7dc0f6e6e1 100644
--- a/src/p_floor.cpp
+++ b/src/p_floor.cpp
@@ -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);
diff --git a/src/p_pillar.cpp b/src/p_pillar.cpp
index da939abb0b..2a134cc50e 100644
--- a/src/p_pillar.cpp
+++ b/src/p_pillar.cpp
@@ -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);
 		}
 	}
 }
diff --git a/src/p_plats.cpp b/src/p_plats.cpp
index 7d2754d2c7..55ba39fe54 100644
--- a/src/p_plats.cpp
+++ b/src/p_plats.cpp
@@ -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;
diff --git a/src/r_defs.h b/src/r_defs.h
index 8eb982384f..eb604ff6f4 100644
--- a/src/r_defs.h
+++ b/src/r_defs.h
@@ -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;