diff --git a/source/games/duke/src/actors.cpp b/source/games/duke/src/actors.cpp
index f67447090..a8a5766f9 100644
--- a/source/games/duke/src/actors.cpp
+++ b/source/games/duke/src/actors.cpp
@@ -62,7 +62,7 @@ void RANDOMSCRAP(DDukeActor* origin)
 	int r1 = krand(), r2 = krand(), r3 = krand(), r4 = krand(), r5 = krand(), r6 = krand(), r7 = krand();
 	int v = isRR() ? 16 : 48;
 	EGS(origin->sector(),
-		origin->spr.pos.X + (r7 & 255) - 128, origin->spr.pos.Y + (r6 & 255) - 128, origin->spr.pos.Z - (8 << 8) - (r5 & 8191), 
+		origin->int_pos().X + (r7 & 255) - 128, origin->int_pos().Y + (r6 & 255) - 128, origin->int_pos().Z - (8 << 8) - (r5 & 8191), 
 		TILE_SCRAP6 + (r4 & 15), -8, v, v, r3 & 2047, (r2 & 63) + 64, -512 - (r1 & 2047), origin, 5); 
 }
 
@@ -265,7 +265,7 @@ void lotsofstuff(DDukeActor* actor, int n, int spawntype)
 	for (int i = n; i > 0; i--)
 	{
 		int r1 = krand(), r2 = krand();	// using the RANDCORRECT version from RR.
-		auto j = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
+		auto j = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
 		if (j) j->spr.cstat = randomFlip();
 	}
 }
@@ -290,7 +290,7 @@ void ms(DDukeActor* const actor)
 		vec2_t t;
 		rotatepoint({ 0, 0 }, { msx[j], msy[j] }, k & 2047, &t);
 
-		dragpoint(&wal, actor->spr.pos.X + t.X, actor->spr.pos.Y + t.Y);
+		dragpoint(&wal, actor->int_pos().X + t.X, actor->int_pos().Y + t.Y);
 		j++;
 	}
 }
@@ -375,7 +375,7 @@ void movedummyplayers(void)
 		}
 
 		act->add_int_pos({ (ps[p].pos.X - ps[p].opos.X), (ps[p].pos.Y - ps[p].opos.Y), 0 });
-		SetActor(act, act->spr.pos);
+		SetActor(act, act->int_pos());
 	}
 }
 
@@ -402,7 +402,7 @@ void moveplayers(void)
 				act->set_int_pos({ p->opos.X, p->opos.Y, p->opos.Z + gs.playerheight });
 				act->backupz();
 				act->spr.ang = p->angle.oang.asbuild();
-				SetActor(act, act->spr.pos);
+				SetActor(act, act->int_pos());
 			}
 			else
 			{
@@ -442,7 +442,7 @@ void moveplayers(void)
 
 				if (p->actorsqu != nullptr)
 				{
-					p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->actorsqu->spr.pos.X - p->pos.X, p->actorsqu->spr.pos.Y - p->pos.Y)) >> 2);
+					p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->actorsqu->int_pos().X - p->pos.X, p->actorsqu->int_pos().Y - p->pos.Y)) >> 2);
 				}
 
 				if (act->spr.extra > 0)
@@ -457,15 +457,15 @@ void moveplayers(void)
 				}
 				else
 				{
-					p->pos.X = act->spr.pos.X;
-					p->pos.Y = act->spr.pos.Y;
-					p->pos.Z = act->spr.pos.Z - (20 << 8);
+					p->pos.X = act->int_pos().X;
+					p->pos.Y = act->int_pos().Y;
+					p->pos.Z = act->int_pos().Z - (20 << 8);
 
 					p->newOwner = nullptr;
 
 					if (p->wackedbyactor != nullptr && p->wackedbyactor->spr.statnum < MAXSTATUS)
 					{
-						p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->wackedbyactor->spr.pos.X - p->pos.X, p->wackedbyactor->spr.pos.Y - p->pos.Y)) >> 1);
+						p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->wackedbyactor->int_pos().X - p->pos.X, p->wackedbyactor->int_pos().Y - p->pos.Y)) >> 1);
 					}
 				}
 				act->spr.ang = p->angle.ang.asbuild();
@@ -508,7 +508,7 @@ void moveplayers(void)
 			else
 			{
 				act->spr.ang = 2047 - (p->angle.ang.asbuild());
-				SetActor(act, act->spr.pos);
+				SetActor(act, act->int_pos());
 			}
 		}
 
@@ -644,8 +644,8 @@ void movecrane(DDukeActor *actor, int crane)
 			case STAT_ZOMBIEACTOR:
 			case STAT_STANDABLE:
 			case STAT_PLAYER:
-				actor->spr.ang = getangle(cpt.pole.X - actor->spr.pos.X, cpt.pole.Y - actor->spr.pos.Y);
-				SetActor(a2, { cpt.pole.X, cpt.pole.Y, a2->spr.pos.Z });
+				actor->spr.ang = getangle(cpt.pole.X - actor->int_pos().X, cpt.pole.Y - actor->int_pos().Y);
+				SetActor(a2, { cpt.pole.X, cpt.pole.Y, a2->int_pos().Z });
 				actor->temp_data[0]++;
 				return;
 			}
@@ -670,15 +670,15 @@ void movecrane(DDukeActor *actor, int crane)
 
 		if (actor->temp_data[0] == 2)
 		{
-			if ((sectp->floorz - actor->spr.pos.Z) < (64 << 8))
+			if ((sectp->floorz - actor->int_pos().Z) < (64 << 8))
 				if (actor->spr.picnum > crane) actor->spr.picnum--;
 
-			if ((sectp->floorz - actor->spr.pos.Z) < (4096 + 1024))
+			if ((sectp->floorz - actor->int_pos().Z) < (4096 + 1024))
 				actor->temp_data[0]++;
 		}
 		if (actor->temp_data[0] == 7)
 		{
-			if ((sectp->floorz - actor->spr.pos.Z) < (64 << 8))
+			if ((sectp->floorz - actor->int_pos().Z) < (64 << 8))
 			{
 				if (actor->spr.picnum > crane) actor->spr.picnum--;
 				else
@@ -738,10 +738,10 @@ void movecrane(DDukeActor *actor, int crane)
 	else if (actor->temp_data[0] == 5 || actor->temp_data[0] == 8)
 	{
 		if (actor->temp_data[0] == 8 && actor->spr.picnum < (crane + 2))
-			if ((sectp->floorz - actor->spr.pos.Z) > 8192)
+			if ((sectp->floorz - actor->int_pos().Z) > 8192)
 				actor->spr.picnum++;
 
-		if (actor->spr.pos.Z < cpt.pos.Z)
+		if (actor->int_pos().Z < cpt.pos.Z)
 		{
 			actor->temp_data[0]++;
 			actor->spr.xvel = 0;
@@ -753,9 +753,9 @@ void movecrane(DDukeActor *actor, int crane)
 	{
 		if (actor->spr.xvel < 192)
 			actor->spr.xvel += 8;
-		actor->spr.ang = getangle(cpt.pos.X - actor->spr.pos.X, cpt.pos.Y - actor->spr.pos.Y);
+		actor->spr.ang = getangle(cpt.pos.X - actor->int_pos().X, cpt.pos.Y - actor->int_pos().Y);
 		ssp(actor, CLIPMASK0);
-		if (((actor->spr.pos.X - cpt.pos.X) * (actor->spr.pos.X - cpt.pos.X) + (actor->spr.pos.Y - cpt.pos.Y) * (actor->spr.pos.Y - cpt.pos.Y)) < (128 * 128))
+		if (((actor->int_pos().X - cpt.pos.X) * (actor->int_pos().X - cpt.pos.X) + (actor->int_pos().Y - cpt.pos.Y) * (actor->int_pos().Y - cpt.pos.Y)) < (128 * 128))
 			actor->temp_data[0]++;
 	}
 
@@ -763,7 +763,7 @@ void movecrane(DDukeActor *actor, int crane)
 		actor->temp_data[0] = 0;
 
 	if (cpt.poleactor)
-		SetActor(cpt.poleactor, { actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (34 << 8) });
+		SetActor(cpt.poleactor, { actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (34 << 8) });
 
 	auto Owner = actor->GetOwner();
 	if (Owner != nullptr || actor->IsActiveCrane())
@@ -783,9 +783,9 @@ void movecrane(DDukeActor *actor, int crane)
 
 		if (Owner != nullptr)
 		{
-			SetActor(Owner, actor->spr.pos);
+			SetActor(Owner, actor->int_pos());
 
-			Owner->opos = actor->spr.pos;
+			Owner->opos = actor->int_pos();
 
 			actor->spr.zvel = 0;
 		}
@@ -795,9 +795,9 @@ void movecrane(DDukeActor *actor, int crane)
 			ps[p].opos.X = ps[p].pos.X;
 			ps[p].opos.Y = ps[p].pos.Y;
 			ps[p].opos.Z = ps[p].pos.Z;
-			ps[p].pos.X = actor->spr.pos.X - bcos(ang, -6);
-			ps[p].pos.Y = actor->spr.pos.Y - bsin(ang, -6);
-			ps[p].pos.Z = actor->spr.pos.Z + (2 << 8);
+			ps[p].pos.X = actor->int_pos().X - bcos(ang, -6);
+			ps[p].pos.Y = actor->int_pos().Y - bsin(ang, -6);
+			ps[p].pos.Z = actor->int_pos().Z + (2 << 8);
 			SetActor(ps[p].GetActor(), ps[p].pos);
 			ps[p].setCursector(ps[p].GetActor()->sector());
 		}
@@ -1106,9 +1106,9 @@ void movetouchplate(DDukeActor* actor, int plate)
 		}
 		else
 		{
-			if (x <= actor->spr.pos.Z)
+			if (x <= actor->int_pos().Z)
 			{
-				sectp->setfloorz(actor->spr.pos.Z);
+				sectp->setfloorz(actor->int_pos().Z);
 				actor->temp_data[1] = 0;
 			}
 			else
@@ -1272,7 +1272,7 @@ void bounce(DDukeActor* actor)
 	int daang = getangle(sectp->firstWall()->delta());
 
 	int k, l;
-	if (actor->spr.pos.Z < (actor->floorz + actor->ceilingz) >> 1)
+	if (actor->int_pos().Z < (actor->floorz + actor->ceilingz) >> 1)
 		k = sectp->ceilingheinum;
 	else
 		k = sectp->floorheinum;
@@ -1323,15 +1323,15 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
 		}
 
 	actor->spr.ang = Owner->spr.ang;
-	actor->set_int_xy(Owner->spr.pos.X, Owner->spr.pos.Y);
+	actor->set_int_xy(Owner->int_pos().X, Owner->int_pos().Y);
 	if (Owner->isPlayer())
-		actor->set_int_z(Owner->spr.pos.Z - (34 << 8));
+		actor->set_int_z(Owner->int_pos().Z - (34 << 8));
 	for (int k = 0; k < actor->temp_data[0]; k++)
 	{
 		auto q = EGS(actor->sector(),
-			actor->spr.pos.X + MulScale(k, bcos(actor->spr.ang), 9),
-			actor->spr.pos.Y + MulScale(k, bsin(actor->spr.ang), 9),
-			actor->spr.pos.Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), tongue, -40 + (k << 1),
+			actor->int_pos().X + MulScale(k, bcos(actor->spr.ang), 9),
+			actor->int_pos().Y + MulScale(k, bsin(actor->spr.ang), 9),
+			actor->int_pos().Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), tongue, -40 + (k << 1),
 			8, 8, 0, 0, 0, actor, 5);
 		if (q)
 		{
@@ -1341,9 +1341,9 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
 	}
 	int k = actor->temp_data[0];	// do not depend on the above loop counter.
 	auto spawned = EGS(actor->sector(),
-		actor->spr.pos.X + MulScale(k, bcos(actor->spr.ang), 9),
-		actor->spr.pos.Y + MulScale(k, bsin(actor->spr.ang), 9),
-		actor->spr.pos.Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), jaw, -40,
+		actor->int_pos().X + MulScale(k, bcos(actor->spr.ang), 9),
+		actor->int_pos().Y + MulScale(k, bsin(actor->spr.ang), 9),
+		actor->int_pos().Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), jaw, -40,
 		32, 32, 0, 0, 0, actor, 5);
 	if (spawned)
 	{
@@ -1469,7 +1469,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
 
 		Collision coll;
 		auto sect = actor->sector();
-		auto pos = actor->spr.pos;
+		auto pos = actor->int_pos();
 		int j = clipmove(pos, &sect,
 			(MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14) * TICSPERFRAME) << 11,
 			(MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14) * TICSPERFRAME) << 11,
@@ -1504,7 +1504,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
 		{
 			//						if(actor->spr.pal == 12)
 			{
-				int j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y));
+				int j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->int_pos().X - ps[p].pos.X, actor->int_pos().Y - ps[p].pos.Y));
 				if (j > -64 && j < 64 && PlayerInput(p, SB_OPEN))
 					if (ps[p].toggle_key_flag == 1)
 					{
@@ -1514,7 +1514,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
 						{
 							if (act2->spr.picnum == queball || act2->spr.picnum == stripeball)
 							{
-								j = getincangle(ps[p].angle.ang.asbuild(), getangle(act2->spr.pos.X - ps[p].pos.X, act2->spr.pos.Y - ps[p].pos.Y));
+								j = getincangle(ps[p].angle.ang.asbuild(), getangle(act2->int_pos().X - ps[p].pos.X, act2->int_pos().Y - ps[p].pos.Y));
 								if (j > -64 && j < 64)
 								{
 									int l;
@@ -1536,7 +1536,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
 		}
 		if (x < 512 && actor->sector() == ps[p].cursector)
 		{
-			actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
+			actor->spr.ang = getangle(actor->int_pos().X - ps[p].pos.X, actor->int_pos().Y - ps[p].pos.Y);
 			actor->spr.xvel = 48;
 		}
 	}
@@ -1577,7 +1577,7 @@ void forcesphere(DDukeActor* actor, int forcesphere)
 		if (actor->spr.zvel < 6144)
 			actor->spr.zvel += 192;
 		actor->add_int_z(actor->spr.zvel);
-		if (actor->spr.pos.Z > sectp->floorz)
+		if (actor->int_pos().Z > sectp->floorz)
 			actor->set_int_z(sectp->floorz);
 		actor->temp_data[3]--;
 		if (actor->temp_data[3] == 0)
@@ -1615,7 +1615,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 		actor->spr.shade += (sectp->ceilingshade - actor->spr.shade) >> 1;
 	else actor->spr.shade += (sectp->floorshade - actor->spr.shade) >> 1;
 
-	if (actor->spr.pos.Z < sectp->ceilingz + (32 << 8))
+	if (actor->int_pos().Z < sectp->ceilingz + (32 << 8))
 		actor->set_int_z(sectp->ceilingz + (32 << 8));
 
 	if (ud.multimode < 2)
@@ -1647,7 +1647,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 		actor->spr.ang += 96;
 		actor->spr.xvel = 128;
 		int j = ssp(actor, CLIPMASK0);
-		if (j != 1 || actor->spr.pos.Z > actor->floorz)
+		if (j != 1 || actor->int_pos().Z > actor->floorz)
 		{
 			for (int l = 0; l < 16; l++)
 				RANDOMSCRAP(actor);
@@ -1661,7 +1661,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 	}
 	else
 	{
-		if (actor->spr.pos.Z > actor->floorz - (48 << 8))
+		if (actor->int_pos().Z > actor->floorz - (48 << 8))
 			actor->set_int_z(actor->floorz - (48 << 8));
 	}
 
@@ -1682,13 +1682,13 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 			fi.shoot(actor, firelaser);
 			actor->spr.ang = a;
 		}
-		if (actor->temp_data[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
+		if (actor->temp_data[2] > (26 * 3) || !cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (16 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
 		{
 			actor->temp_data[0] = 0;
 			actor->temp_data[2] = 0;
 		}
 		else actor->tempang +=
-			getincangle(actor->tempang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) / 3;
+			getincangle(actor->tempang, getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y)) / 3;
 	}
 	else if (actor->temp_data[0] == 2 || actor->temp_data[0] == 3)
 	{
@@ -1698,14 +1698,14 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 
 		if (actor->temp_data[0] == 2)
 		{
-			int l = ps[p].pos.Z - actor->spr.pos.Z;
+			int l = ps[p].pos.Z - actor->int_pos().Z;
 			if (abs(l) < (48 << 8)) actor->temp_data[0] = 3;
-			else actor->add_int_z(Sgn(ps[p].pos.Z - actor->spr.pos.Z) << shift); // The shift here differs between Duke and RR.
+			else actor->add_int_z(Sgn(ps[p].pos.Z - actor->int_pos().Z) << shift); // The shift here differs between Duke and RR.
 		}
 		else
 		{
 			actor->temp_data[2]++;
-			if (actor->temp_data[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
+			if (actor->temp_data[2] > (26 * 3) || !cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (16 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
 			{
 				actor->temp_data[0] = 1;
 				actor->temp_data[2] = 0;
@@ -1716,7 +1716,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 				fi.shoot(actor, firelaser);
 			}
 		}
-		actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 2;
+		actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y)) >> 2;
 	}
 
 	if (actor->temp_data[0] != 2 && actor->temp_data[0] != 3 && Owner)
@@ -1727,7 +1727,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
 			a = actor->spr.ang;
 			actor->spr.xvel >>= 1;
 		}
-		else a = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
+		else a = getangle(Owner->int_pos().X - actor->int_pos().X, Owner->int_pos().Y - actor->int_pos().Y);
 
 		if (actor->temp_data[0] == 1 || actor->temp_data[0] == 4) // Found a locator and going with it
 		{
@@ -1886,7 +1886,7 @@ void reactor(DDukeActor* const actor, int REACTOR, int REACTOR2, int REACTORBURN
 	{
 		actor->temp_data[1]++;
 
-		actor->temp_data[4] = actor->spr.pos.Z;
+		actor->temp_data[4] = actor->int_pos().Z;
 		actor->set_int_z(sectp->floorz - (krand() % (sectp->floorz - sectp->ceilingz)));
 
 		switch (actor->temp_data[1])
@@ -2043,7 +2043,7 @@ void forcesphereexplode(DDukeActor *actor)
 			l -= 3;
 		}
 
-	actor->set_int_pos(Owner->spr.pos);
+	actor->set_int_pos(Owner->int_pos());
 	actor->spr.ang += Owner->temp_data[0];
 
 	if (l > 64) l = 64;
@@ -2138,16 +2138,16 @@ bool money(DDukeActor* actor, int BLOODPOOL)
 	ssp(actor, CLIPMASK0);
 
 	if ((krand() & 3) == 0)
-		SetActor(actor, actor->spr.pos);
+		SetActor(actor, actor->int_pos());
 
 	if (!actor->insector())
 	{
 		deletesprite(actor);
 		return false;
 	}
-	int l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
+	int l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
 
-	if (actor->spr.pos.Z > l)
+	if (actor->int_pos().Z > l)
 	{
 		actor->set_int_z(l);
 
@@ -2194,11 +2194,11 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
 
 	if (actor->spr.zvel > 1024 && actor->spr.zvel < 1280)
 	{
-		SetActor(actor, actor->spr.pos);
+		SetActor(actor, actor->int_pos());
 		sectp = actor->sector();
 	}
 
-	if (callsetsprite) SetActor(actor, actor->spr.pos);
+	if (callsetsprite) SetActor(actor, actor->int_pos());
 
 	// this was after the slope calls, but we should avoid calling that for invalid sectors.
 	if (!actor->insector())
@@ -2207,15 +2207,15 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
 		return false;
 	}
 
-	int l = getflorzofslopeptr(sectp, actor->spr.pos.X, actor->spr.pos.Y);
-	int x = getceilzofslopeptr(sectp, actor->spr.pos.X, actor->spr.pos.Y);
+	int l = getflorzofslopeptr(sectp, actor->int_pos().X, actor->int_pos().Y);
+	int x = getceilzofslopeptr(sectp, actor->int_pos().X, actor->int_pos().Y);
 	if (x == l)
 	{
 		deletesprite(actor);
 		return false;
 	}
 
-	if (actor->spr.pos.Z < l - (2 << 8))
+	if (actor->int_pos().Z < l - (2 << 8))
 	{
 		if (actor->temp_data[1] < 2) actor->temp_data[1]++;
 		else if (sectp->lotag != 2)
@@ -2248,7 +2248,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
 		actor->add_int_pos({ MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14), MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14), 0 });
 		actor->add_int_z(actor->spr.zvel);
 
-		if (floorcheck && actor->spr.pos.Z >= actor->sector()->floorz)
+		if (floorcheck && actor->int_pos().Z >= actor->sector()->floorz)
 		{
 			deletesprite(actor);
 			return false;
@@ -2275,7 +2275,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
 			}
 			actor->temp_data[2]++;
 		}
-		l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
+		l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
 
 		actor->set_int_z(l - (2 << 8));
 		actor->spr.xvel = 0;
@@ -2451,7 +2451,7 @@ void glasspieces(DDukeActor* actor)
 		return;
 	}
 
-	if (actor->spr.pos.Z == actor->floorz - (FOURSLEIGHT) && actor->temp_data[0] < 3)
+	if (actor->int_pos().Z == actor->floorz - (FOURSLEIGHT) && actor->temp_data[0] < 3)
 	{
 		actor->spr.zvel = -((3 - actor->temp_data[0]) << 8) - (krand() & 511);
 		if (sectp->lotag == 2)
@@ -2459,7 +2459,7 @@ void glasspieces(DDukeActor* actor)
 		actor->spr.xrepeat >>= 1;
 		actor->spr.yrepeat >>= 1;
 		if (rnd(96))
-			SetActor(actor, actor->spr.pos);
+			SetActor(actor, actor->int_pos());
 		actor->temp_data[0]++;//Number of bounces
 	}
 	else if (actor->temp_data[0] == 3)
@@ -2495,11 +2495,11 @@ void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
 
 	if (actor->spr.zvel > 1024 && actor->spr.zvel < 1280)
 	{
-		SetActor(actor, actor->spr.pos);
+		SetActor(actor, actor->int_pos());
 		sectp = actor->sector();
 	}
 
-	if (actor->spr.pos.Z < sectp->floorz - (2 << 8))
+	if (actor->int_pos().Z < sectp->floorz - (2 << 8))
 	{
 		if (actor->temp_data[1] < 1) actor->temp_data[1]++;
 		else
@@ -2529,7 +2529,7 @@ void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
 			auto spawned = spawn(actor, actor->spr.yvel);
 			if (spawned)
 			{
-				SetActor(spawned, actor->spr.pos);
+				SetActor(spawned, actor->int_pos());
 				getglobalz(spawned);
 				spawned->spr.hitag = spawned->spr.lotag = 0;
 			}
@@ -2552,8 +2552,8 @@ void gutsdir(DDukeActor* actor, int gtype, int n, int p)
 		sx = sy = 8;
 	else sx = sy = 32;
 
-	int gutz = actor->spr.pos.Z - (8 << 8);
-	int floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
+	int gutz = actor->int_pos().Z - (8 << 8);
+	int floorz = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
 
 	if (gutz > (floorz - (8 << 8)))
 		gutz = floorz - (8 << 8);
@@ -2566,7 +2566,7 @@ void gutsdir(DDukeActor* actor, int gtype, int n, int p)
 		int r1 = krand();
 		int r2 = krand();
 		// TRANSITIONAL: owned by a player???
-		EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
+		EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
 	}
 }
 
@@ -2609,20 +2609,20 @@ void handle_se00(DDukeActor* actor)
 			}
 			else actor->tempang = 256;
 
-			if (sect->floorz > actor->spr.pos.Z) //z's are touching
+			if (sect->floorz > actor->int_pos().Z) //z's are touching
 			{
 				sect->addfloorz(-512);
 				zchange = -512;
-				if (sect->floorz < actor->spr.pos.Z)
-					sect->setfloorz(actor->spr.pos.Z);
+				if (sect->floorz < actor->int_pos().Z)
+					sect->setfloorz(actor->int_pos().Z);
 			}
 
-			else if (sect->floorz < actor->spr.pos.Z) //z's are touching
+			else if (sect->floorz < actor->int_pos().Z) //z's are touching
 			{
 				sect->addfloorz(512);
 				zchange = 512;
-				if (sect->floorz > actor->spr.pos.Z)
-					sect->setfloorz(actor->spr.pos.Z);
+				if (sect->floorz > actor->int_pos().Z)
+					sect->setfloorz(actor->int_pos().Z);
 			}
 		}
 		else if (actor->spr.extra == 3)
@@ -2672,7 +2672,7 @@ void handle_se00(DDukeActor* actor)
 		if (actor->temp_data[3] == 0)
 			actor->temp_data[3] = ldist(actor, Owner);
 		actor->spr.xvel = actor->temp_data[3];
-		actor->set_int_xy(Owner->spr.pos.X, Owner->spr.pos.Y);
+		actor->set_int_xy(Owner->int_pos().X, Owner->int_pos().Y);
 		actor->spr.ang += (l * q);
 		actor->temp_data[2] += (l * q);
 	}
@@ -2689,7 +2689,7 @@ void handle_se00(DDukeActor* actor)
 				ps[p].pos.Z += zchange;
 
 				vec2_t res;
-				rotatepoint(Owner->spr.pos.vec2, ps[p].pos.vec2, (q * l), &res);
+				rotatepoint(Owner->int_pos().vec2, ps[p].pos.vec2, (q * l), &res);
 
 				ps[p].bobpos.X += res.X - ps[p].pos.X;
 				ps[p].bobpos.Y += res.Y - ps[p].pos.Y;
@@ -2717,8 +2717,8 @@ void handle_se00(DDukeActor* actor)
 				act2->spr.ang &= 2047;
 
 				act2->add_int_z(zchange);
-				auto pos = act2->spr.pos;
-				rotatepoint(Owner->spr.pos.vec2, act2->spr.pos.vec2, (q* l), &pos.vec2);
+				auto pos = act2->int_pos();
+				rotatepoint(Owner->int_pos().vec2, act2->int_pos().vec2, (q* l), &pos.vec2);
 				act2->set_int_pos(pos);
 			}
 		}
@@ -2795,7 +2795,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 	Owner = actor->GetOwner();
 	if (actor->spr.xvel)
 	{
-		int x = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
+		int x = getangle(Owner->int_pos().X - actor->int_pos().X, Owner->int_pos().Y - actor->int_pos().Y);
 		int q = getincangle(actor->spr.ang, x) >> 3;
 
 		actor->temp_data[2] += q;
@@ -2815,7 +2815,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 				if (x < 20480)
 				{
 					j = actor->spr.ang;
-					actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
+					actor->spr.ang = getangle(actor->int_pos().X - ps[p].pos.X, actor->int_pos().Y - ps[p].pos.Y);
 					fi.shoot(actor, RPG);
 					actor->spr.ang = j;
 				}
@@ -2837,11 +2837,11 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 						updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
 						if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
 						{
-							ps[p].pos.X = actor->spr.pos.X;
-							ps[p].pos.Y = actor->spr.pos.Y;
+							ps[p].pos.X = actor->int_pos().X;
+							ps[p].pos.Y = actor->int_pos().Y;
 							ps[p].setCursector(actor->sector());
 
-							SetActor(ps[p].GetActor(), actor->spr.pos);
+							SetActor(ps[p].GetActor(), actor->int_pos());
 							quickkill(&ps[p]);
 						}
 					}
@@ -2864,7 +2864,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 
 				if (actor->sector() == psp->sector())
 				{
-					rotatepoint(actor->spr.pos.vec2, ps[p].pos.vec2, q, &ps[p].pos.vec2);
+					rotatepoint(actor->int_pos().vec2, ps[p].pos.vec2, q, &ps[p].pos.vec2);
 
 					ps[p].pos.X += m;
 					ps[p].pos.Y += x;
@@ -2893,8 +2893,8 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 				(a2->spr.picnum != SECTOREFFECTOR || a2->spr.lotag == SE_49_POINT_LIGHT || a2->spr.lotag == SE_50_SPOT_LIGHT) &&
 					a2->spr.picnum != LOCATORS)
 			{
-				auto pos = a2->spr.pos;
-				rotatepoint(actor->spr.pos.vec2, a2->spr.pos.vec2, q, &pos.vec2);
+				auto pos = a2->int_pos();
+				rotatepoint(actor->int_pos().vec2, a2->int_pos().vec2, q, &pos.vec2);
 
 				pos.X += m;
 				pos.Y += x;
@@ -2911,7 +2911,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 
 		ms(actor);
 		// I have no idea why this is here, but the SE's sector must never, *EVER* change, or the map will corrupt.
-		//SetActor(actor, actor->spr.pos);
+		//SetActor(actor, actor->int_pos());
 
 		if ((sc->floorz - sc->ceilingz) < (108 << 8))
 		{
@@ -2924,11 +2924,11 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 						updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
 						if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
 						{
-							ps[p].opos.X = ps[p].pos.X = actor->spr.pos.X;
-							ps[p].opos.Y = ps[p].pos.Y = actor->spr.pos.Y;
+							ps[p].opos.X = ps[p].pos.X = actor->int_pos().X;
+							ps[p].opos.Y = ps[p].pos.Y = actor->int_pos().Y;
 							ps[p].setCursector(actor->sector());
 
-							SetActor(ps[p].GetActor(), actor->spr.pos);
+							SetActor(ps[p].GetActor(), actor->int_pos());
 							quickkill(&ps[p]);
 						}
 					}
@@ -2943,7 +2943,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
 					if (a2->spr.statnum == 1 && badguy(a2) && a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
 					{
 						auto k = a2->sector();
-						updatesector(a2->spr.pos.X, a2->spr.pos.Y, &k);
+						updatesector(a2->int_pos().X, a2->int_pos().Y, &k);
 						if (a2->spr.extra >= 0 && k == actor->sector())
 						{
 							gutsdir(a2, JIBS6, 72, myconnectindex);
@@ -2990,7 +2990,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
 		}
 		if (actor->temp_data[4] == 2)
 		{
-			int l = FindDistance2D(Owner->spr.pos.vec2 - actor->spr.pos.vec2);
+			int l = FindDistance2D(Owner->int_pos().vec2 - actor->int_pos().vec2);
 
 			if (l <= 128)
 				actor->spr.xvel = 0;
@@ -3025,11 +3025,11 @@ void handle_se30(DDukeActor *actor, int JIBS6)
 						updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
 						if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
 						{
-							ps[p].pos.X = actor->spr.pos.X;
-							ps[p].pos.Y = actor->spr.pos.Y;
+							ps[p].pos.X = actor->int_pos().X;
+							ps[p].pos.Y = actor->int_pos().Y;
 							ps[p].setCursector(actor->sector());
 
-							SetActor(ps[p].GetActor(), actor->spr.pos);
+							SetActor(ps[p].GetActor(), actor->int_pos());
 							quickkill(&ps[p]);
 						}
 					}
@@ -3074,7 +3074,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
 		}
 
 		ms(actor);
-		//SetActor(actor, actor->spr.pos);
+		//SetActor(actor, actor->int_pos());
 
 		if ((sc->floorz - sc->ceilingz) < (108 << 8))
 		{
@@ -3086,15 +3086,15 @@ void handle_se30(DDukeActor *actor, int JIBS6)
 						updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
 						if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
 						{
-							ps[p].pos.X = actor->spr.pos.X;
-							ps[p].pos.Y = actor->spr.pos.Y;
+							ps[p].pos.X = actor->int_pos().X;
+							ps[p].pos.Y = actor->int_pos().Y;
 
 							ps[p].opos.X = ps[p].pos.X;
 							ps[p].opos.Y = ps[p].pos.Y;
 
 							ps[p].setCursector(actor->sector());
 
-							SetActor(ps[p].GetActor(), actor->spr.pos);
+							SetActor(ps[p].GetActor(), actor->int_pos());
 							quickkill(&ps[p]);
 						}
 					}
@@ -3109,7 +3109,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
 						//					if(a2->spr.sector != actor->spr.sector)
 						{
 							auto k = a2->sector();
-							updatesector(a2->spr.pos.X, a2->spr.pos.Y, &k);
+							updatesector(a2->int_pos().X, a2->int_pos().Y, &k);
 							if (a2->spr.extra >= 0 && k == actor->sector())
 							{
 								gutsdir(a2, JIBS6, 24, myconnectindex);
@@ -3188,11 +3188,11 @@ void handle_se02(DDukeActor* actor)
 			if (a2->spr.picnum != SECTOREFFECTOR)
 			{
 				a2->add_int_pos({ m, x, 0 });
-				SetActor(a2, a2->spr.pos);
+				SetActor(a2, a2->int_pos());
 			}
 		}
 		ms(actor);
-		//SetActor(actor, actor->spr.pos);
+		//SetActor(actor, actor->int_pos());
 	}
 }
 
@@ -3327,7 +3327,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
 	if (x < 8192)
 	{
 		j = actor->spr.ang;
-		actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
+		actor->spr.ang = getangle(actor->int_pos().X - ps[p].pos.X, actor->int_pos().Y - ps[p].pos.Y);
 		fi.shoot(actor, FIRELASER);
 		actor->spr.ang = j;
 	}
@@ -3355,13 +3355,13 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
 
 		actor->SetOwner(Owner);
 		if (!Owner) return; // Undefined case - was not checked.
-		actor->spr.zvel = Sgn(Owner->spr.pos.Z - actor->spr.pos.Z) << 4;
+		actor->spr.zvel = Sgn(Owner->int_pos().Z - actor->int_pos().Z) << 4;
 	}
 
 	if (ldist(Owner, actor) < 1024)
 	{
 		auto ta = actor->spr.ang;
-		actor->spr.ang = getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y);
+		actor->spr.ang = getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y);
 		actor->spr.ang = ta;
 		actor->SetOwner(nullptr);
 		return;
@@ -3369,7 +3369,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
 	}
 	else actor->spr.xvel = 256;
 
-	x = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
+	x = getangle(Owner->int_pos().X - actor->int_pos().X, Owner->int_pos().Y - actor->int_pos().Y);
 	int q = getincangle(actor->spr.ang, x) >> 3;
 	actor->spr.ang += q;
 
@@ -3381,7 +3381,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
 	else
 	{
 		actor->temp_data[2] +=
-			getincangle(actor->temp_data[2] + 512, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 2;
+			getincangle(actor->temp_data[2] + 512, getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y)) >> 2;
 		sc->ceilingshade = 0;
 	}
 	j = fi.ifhitbyweapon(actor);
@@ -3399,7 +3399,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
 	sc->addceilingz(actor->spr.zvel);
 	sector[actor->temp_data[0]].addceilingz(actor->spr.zvel);
 	ms(actor);
-	//SetActor(actor, actor->spr.pos);
+	//SetActor(actor, actor->int_pos());
 }
 
 //---------------------------------------------------------------------------
@@ -3547,7 +3547,7 @@ void handle_se11(DDukeActor *actor)
 			DukeStatIterator it(STAT_ACTOR);
 			while (auto ac = it.Next())
 			{
-				if (ac->spr.extra > 0 && badguy(ac) && clipinsidebox(ac->spr.pos.X, ac->spr.pos.Y, wallnum(&wal), 256) == 1)
+				if (ac->spr.extra > 0 && badguy(ac) && clipinsidebox(ac->int_pos().X, ac->int_pos().Y, wallnum(&wal), 256) == 1)
 					return;
 			}
 		}
@@ -3556,20 +3556,20 @@ void handle_se11(DDukeActor *actor)
 		actor->temp_data[2] += k;
 		actor->temp_data[4] += k;
 		ms(actor);
-		//SetActor(actor, actor->spr.pos);
+		//SetActor(actor, actor->int_pos());
 
 		for(auto& wal : wallsofsector(sc))
 		{
 			DukeStatIterator it(STAT_PLAYER);
 			while (auto ac = it.Next())
 			{
-				if (ac->GetOwner() && clipinsidebox(ac->spr.pos.X, ac->spr.pos.Y, wallnum(&wal), 144) == 1)
+				if (ac->GetOwner() && clipinsidebox(ac->int_pos().X, ac->int_pos().Y, wallnum(&wal), 144) == 1)
 				{
 					actor->temp_data[5] = 8; // Delay
 					actor->temp_data[2] -= k;
 					actor->temp_data[4] -= k;
 					ms(actor);
-					//SetActor(actor, actor->spr.pos);
+					//SetActor(actor, actor->int_pos());
 					return;
 				}
 			}
@@ -3580,7 +3580,7 @@ void handle_se11(DDukeActor *actor)
 			actor->temp_data[4] = 0;
 			actor->temp_data[2] &= 0xffffff00;
 			ms(actor);
-			//SetActor(actor, actor->spr.pos);
+			//SetActor(actor, actor->int_pos());
 		}
 	}
 }
@@ -3770,7 +3770,7 @@ void handle_se15(DDukeActor* actor)
 		}
 
 		ms(actor);
-		//SetActor(actor, actor->spr.pos);
+		//SetActor(actor, actor->int_pos());
 	}
 }
 
@@ -3814,7 +3814,7 @@ void handle_se16(DDukeActor* actor, int REACTOR, int REACTOR2)
 	else sc->addceilingz(-512);
 
 	ms(actor);
-	//SetActor(actor, actor->spr.pos);
+	//SetActor(actor, actor->int_pos());
 }
 
 //---------------------------------------------------------------------------
@@ -3891,8 +3891,8 @@ void handle_se17(DDukeActor* actor)
 			{
 				int p = act3->spr.yvel;
 
-				ps[p].pos.X += act2->spr.pos.X - actor->spr.pos.X;
-				ps[p].pos.Y += act2->spr.pos.Y - actor->spr.pos.Y;
+				ps[p].pos.X += act2->int_pos().X - actor->int_pos().X;
+				ps[p].pos.Y += act2->int_pos().Y - actor->int_pos().Y;
 				ps[p].pos.Z = act2->sector()->floorz - (sc->floorz - ps[p].pos.Z);
 
 				act3->floorz = act2->sector()->floorz;
@@ -3911,13 +3911,13 @@ void handle_se17(DDukeActor* actor)
 			}
 			else if (act3->spr.statnum != STAT_EFFECTOR)
 			{
-				act3->add_int_pos({ act2->spr.pos.X - actor->spr.pos.X ,act2->spr.pos.Y - actor->spr.pos.Y, 0 });
-				act3->set_int_z(act2->sector()->floorz - (sc->floorz - act3->spr.pos.Z));
+				act3->add_int_pos({ act2->int_pos().X - actor->int_pos().X ,act2->int_pos().Y - actor->int_pos().Y, 0 });
+				act3->set_int_z(act2->sector()->floorz - (sc->floorz - act3->int_pos().Z));
 
 				act3->backupz();
 
 				ChangeActorSect(act3, act2->sector());
-				SetActor(act3, act3->spr.pos);
+				SetActor(act3, act3->int_pos());
 
 				act3->floorz = act2->sector()->floorz;
 				act3->ceilingz = act2->sector()->ceilingz;
@@ -3981,9 +3981,9 @@ void handle_se18(DDukeActor *actor, bool morecheck)
 			if (actor->spr.ang == 512)
 			{
 				sc->addceilingz(sc->extra);
-				if (sc->ceilingz >= actor->spr.pos.Z)
+				if (sc->ceilingz >= actor->int_pos().Z)
 				{
-					sc->setceilingz(actor->spr.pos.Z);
+					sc->setceilingz(actor->int_pos().Z);
 					deletesprite(actor);
 					return;
 				}
@@ -4005,9 +4005,9 @@ void handle_se18(DDukeActor *actor, bool morecheck)
 						}
 					}
 				}
-				if (sc->floorz <= actor->spr.pos.Z)
+				if (sc->floorz <= actor->int_pos().Z)
 				{
-					sc->setfloorz(actor->spr.pos.Z);
+					sc->setfloorz(actor->int_pos().Z);
 					deletesprite(actor);
 					return;
 				}
@@ -4222,7 +4222,7 @@ void handle_se21(DDukeActor* actor)
 
 	if (actor->temp_data[0] == 1) //Decide if the sector should go up or down
 	{
-		actor->spr.zvel = Sgn(actor->spr.pos.Z - *lp) * (actor->spr.yvel << 4);
+		actor->spr.zvel = Sgn(actor->int_pos().Z - *lp) * (actor->spr.yvel << 4);
 		actor->temp_data[0]++;
 	}
 
@@ -4230,9 +4230,9 @@ void handle_se21(DDukeActor* actor)
 	{
 		*lp += actor->spr.zvel;
 
-		if (abs(*lp - actor->spr.pos.Z) < 1024)
+		if (abs(*lp - actor->int_pos().Z) < 1024)
 		{
-			*lp = actor->spr.pos.Z;
+			*lp = actor->int_pos().Z;
 			deletesprite(actor);
 		}
 	}
@@ -4287,7 +4287,7 @@ void handle_se26(DDukeActor* actor)
 		if (a2->spr.statnum != 3 && a2->spr.statnum != 10)
 		{
 			a2->add_int_pos({ l, x, actor->spr.zvel });
-			SetActor(a2, a2->spr.pos);
+			SetActor(a2, a2->int_pos());
 		}
 	}
 
@@ -4300,7 +4300,7 @@ void handle_se26(DDukeActor* actor)
 		}
 
 	ms(actor);
-	//SetActor(actor, actor->spr.pos);
+	//SetActor(actor, actor->int_pos());
 }
 
 //---------------------------------------------------------------------------
@@ -4328,14 +4328,14 @@ void handle_se27(DDukeActor* actor)
 		}
 		else if (ud.recstat == 2 && ps[p].newOwner == nullptr)
 		{
-			if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
+			if (cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
 			{
 				if (x < sh)
 				{
 					ud.cameraactor = actor;
 					actor->temp_data[0] = 999;
-					actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 3;
-					actor->spr.yvel = 100 + ((actor->spr.pos.Z - ps[p].pos.Z) / 257);
+					actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y)) >> 3;
+					actor->spr.yvel = 100 + ((actor->int_pos().Z - ps[p].pos.Z) / 257);
 
 				}
 				else if (actor->temp_data[0] == 999)
@@ -4349,7 +4349,7 @@ void handle_se27(DDukeActor* actor)
 			}
 			else
 			{
-				actor->spr.ang = getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y);
+				actor->spr.ang = getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y);
 
 				if (actor->temp_data[0] == 999)
 				{
@@ -4397,11 +4397,11 @@ void handle_se24(DDukeActor *actor, bool scroll, int shift)
 					wallswitchcheck(a2))
 					continue;
 
-				if (a2->spr.pos.Z > (a2->floorz - (16 << 8)))
+				if (a2->int_pos().Z > (a2->floorz - (16 << 8)))
 				{
 					a2->add_int_pos({ x >> shift , y >> shift, 0 });
 
-					SetActor(a2, a2->spr.pos);
+					SetActor(a2, a2->int_pos());
 
 					if (a2->sector()->floorstat & CSTAT_SECTOR_SLOPE)
 						if (a2->spr.statnum == STAT_ZOMBIEACTOR)
@@ -4481,14 +4481,14 @@ void handle_se32(DDukeActor *actor)
 		{
 			if (actor->spr.ang != 1536)
 			{
-				if (abs(sc->ceilingz - actor->spr.pos.Z) < (actor->spr.yvel << 1))
+				if (abs(sc->ceilingz - actor->int_pos().Z) < (actor->spr.yvel << 1))
 				{
-					sc->setceilingz(actor->spr.pos.Z);
+					sc->setceilingz(actor->int_pos().Z);
 					callsound(actor->sector(), actor);
 					actor->temp_data[2] = 0;
 					actor->temp_data[0] = 0;
 				}
-				else sc->addceilingz(Sgn(actor->spr.pos.Z - sc->ceilingz) * actor->spr.yvel);
+				else sc->addceilingz(Sgn(actor->int_pos().Z - sc->ceilingz) * actor->spr.yvel);
 			}
 			else
 			{
@@ -4506,14 +4506,14 @@ void handle_se32(DDukeActor *actor)
 
 		if ((actor->spr.ang & 2047) == 1536)
 		{
-			if (abs(sc->ceilingz - actor->spr.pos.Z) < (actor->spr.yvel << 1))
+			if (abs(sc->ceilingz - actor->int_pos().Z) < (actor->spr.yvel << 1))
 			{
 				actor->temp_data[0] = 0;
 				actor->temp_data[2] = !actor->temp_data[2];
 				callsound(actor->sector(), actor);
-				sc->setceilingz(actor->spr.pos.Z);
+				sc->setceilingz(actor->int_pos().Z);
 			}
-			else sc->addceilingz(Sgn(actor->spr.pos.Z - sc->ceilingz) * actor->spr.yvel);
+			else sc->addceilingz(Sgn(actor->int_pos().Z - sc->ceilingz) * actor->spr.yvel);
 		}
 		else
 		{
@@ -4523,7 +4523,7 @@ void handle_se32(DDukeActor *actor)
 				actor->temp_data[2] = !actor->temp_data[2];
 				callsound(actor->sector(), actor);
 			}
-			else sc->addceilingz(-Sgn(actor->spr.pos.Z - actor->temp_data[1]) * actor->spr.yvel);
+			else sc->addceilingz(-Sgn(actor->int_pos().Z - actor->temp_data[1]) * actor->spr.yvel);
 		}
 	}
 
@@ -4539,7 +4539,7 @@ void handle_se35(DDukeActor *actor, int SMALLSMOKE, int EXPLOSION2)
 {
 	auto sc = actor->sector();
 
-	if (sc->ceilingz > actor->spr.pos.Z)
+	if (sc->ceilingz > actor->int_pos().Z)
 		for (int j = 0; j < 8; j++)
 		{
 			actor->spr.ang += krand() & 511;
@@ -4548,7 +4548,7 @@ void handle_se35(DDukeActor *actor, int SMALLSMOKE, int EXPLOSION2)
 			{
 				spawned->spr.xvel = 96 + (krand() & 127);
 				ssp(spawned, CLIPMASK0);
-				SetActor(spawned, spawned->spr.pos);
+				SetActor(spawned, spawned->int_pos());
 				if (rnd(16))
 					spawn(actor, EXPLOSION2);
 			}
@@ -4560,7 +4560,7 @@ void handle_se35(DDukeActor *actor, int SMALLSMOKE, int EXPLOSION2)
 		sc->addceilingz(actor->spr.yvel);
 		if (sc->ceilingz > sc->floorz)
 			sc->setfloorz(sc->ceilingz);
-		if (sc->ceilingz > actor->spr.pos.Z + (32 << 8))
+		if (sc->ceilingz > actor->int_pos().Z + (32 << 8))
 			actor->temp_data[0]++;
 		break;
 	case 1:
@@ -4669,9 +4669,9 @@ void handle_se31(DDukeActor* actor, bool choosedir)
 		{
 			if (actor->spr.ang != 1536)
 			{
-				if (abs(sec->floorz - actor->spr.pos.Z) < actor->spr.yvel)
+				if (abs(sec->floorz - actor->int_pos().Z) < actor->spr.yvel)
 				{
-					sec->setfloorz(actor->spr.pos.Z);
+					sec->setfloorz(actor->int_pos().Z);
 					actor->temp_data[2] = 0;
 					actor->temp_data[0] = 0;
 					if (choosedir) actor->temp_data[3] = actor->spr.hitag;
@@ -4679,7 +4679,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
 				}
 				else
 				{
-					int l = Sgn(actor->spr.pos.Z - sec->floorz) * actor->spr.yvel;
+					int l = Sgn(actor->int_pos().Z - sec->floorz) * actor->spr.yvel;
 					sec->addfloorz(l);
 
 					DukeSectIterator it(actor->sector());
@@ -4730,7 +4730,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
 
 		if ((actor->spr.ang & 2047) == 1536)
 		{
-			if (abs(actor->spr.pos.Z - sec->floorz) < actor->spr.yvel)
+			if (abs(actor->int_pos().Z - sec->floorz) < actor->spr.yvel)
 			{
 				callsound(actor->sector(), actor);
 				actor->temp_data[0] = 0;
@@ -4739,7 +4739,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
 			}
 			else
 			{
-				int l = Sgn(actor->spr.pos.Z - sec->floorz) * actor->spr.yvel;
+				int l = Sgn(actor->int_pos().Z - sec->floorz) * actor->spr.yvel;
 				sec->addfloorz(l);
 
 				DukeSectIterator it(actor->sector());
@@ -4767,7 +4767,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
 			}
 			else
 			{
-				int l = Sgn(actor->spr.pos.Z - actor->temp_data[1]) * actor->spr.yvel;
+				int l = Sgn(actor->int_pos().Z - actor->temp_data[1]) * actor->spr.yvel;
 				sec->addfloorz(-l);
 
 				DukeSectIterator it(actor->sector());
@@ -4806,7 +4806,7 @@ void getglobalz(DDukeActor* actor)
 
 		auto cc = actor->spr.cstat2;
 		actor->spr.cstat2 |= CSTAT2_SPRITE_NOFIND; // don't clip against self. getzrange cannot detect this because it only receives a coordinate.
-		getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->sector(), &actor->ceilingz, hz, &actor->floorz, lz, zr, CLIPMASK0);
+		getzrange({ actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (FOURSLEIGHT) }, actor->sector(), &actor->ceilingz, hz, &actor->floorz, lz, zr, CLIPMASK0);
 		actor->spr.cstat2 = cc;
 
 		actor->spr.cstat2 &= ~CSTAT2_SPRITE_NOSHADOW;
@@ -4868,7 +4868,7 @@ void makeitfall(DDukeActor* actor)
 	if ((actor->spr.statnum == STAT_ACTOR || actor->spr.statnum == STAT_PLAYER || actor->spr.statnum == STAT_ZOMBIEACTOR || actor->spr.statnum == STAT_STANDABLE))
 	{
 		Collision coll;
-		getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->sector(), &actor->ceilingz, coll, &actor->floorz, coll, 127, CLIPMASK0);
+		getzrange({ actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (FOURSLEIGHT) }, actor->sector(), &actor->ceilingz, coll, &actor->floorz, coll, 127, CLIPMASK0);
 	}
 	else
 	{
@@ -4876,7 +4876,7 @@ void makeitfall(DDukeActor* actor)
 		actor->floorz	= actor->sector()->floorz;
 	}
 
-	if( actor->spr.pos.Z < actor->floorz-(FOURSLEIGHT) )
+	if( actor->int_pos().Z < actor->floorz-(FOURSLEIGHT) )
 	{
 		if( actor->sector()->lotag == 2 && actor->spr.zvel > 3122 )
 			actor->spr.zvel = 3144;
@@ -4885,7 +4885,7 @@ void makeitfall(DDukeActor* actor)
 		else actor->spr.zvel = 6144;
 		actor->add_int_z(actor->spr.zvel);
 	}
-	if( actor->spr.pos.Z >= actor->floorz-(FOURSLEIGHT) )
+	if( actor->int_pos().Z >= actor->floorz-(FOURSLEIGHT) )
 	{
 		actor->set_int_z(actor->floorz - FOURSLEIGHT);
 		actor->spr.zvel = 0;
@@ -4902,8 +4902,8 @@ int dodge(DDukeActor* actor)
 {
 	int bx, by, mx, my, bxvect, byvect, d;
 
-	mx = actor->spr.pos.X;
-	my = actor->spr.pos.Y;
+	mx = actor->int_pos().X;
+	my = actor->int_pos().Y;
 
 	DukeStatIterator it(STAT_PROJECTILE);
 	while (auto ac = it.Next())
@@ -4911,8 +4911,8 @@ int dodge(DDukeActor* actor)
 		if (ac->GetOwner() == ac || ac->sector() != actor->sector())
 			continue;
 
-		bx = ac->spr.pos.X - mx;
-		by = ac->spr.pos.Y - my;
+		bx = ac->int_pos().X - mx;
+		by = ac->int_pos().Y - my;
 		bxvect = bcos(ac->spr.ang);
 		byvect = bsin(ac->spr.ang);
 
@@ -4950,9 +4950,9 @@ int furthestangle(DDukeActor *actor, int angs)
 
 	for (j = actor->spr.ang; j < (2048 + actor->spr.ang); j += angincs)
 	{
-		hitscan({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8) }, actor->sector(), { bcos(j), bsin(j), 0 }, hit, CLIPMASK1);
+		hitscan({ actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8) }, actor->sector(), { bcos(j), bsin(j), 0 }, hit, CLIPMASK1);
 
-		d = abs(hit.hitpos.X - actor->spr.pos.X) + abs(hit.hitpos.Y - actor->spr.pos.Y);
+		d = abs(hit.hitpos.X - actor->int_pos().X) + abs(hit.hitpos.Y - actor->int_pos().Y);
 
 		if (d > greatestd)
 		{
@@ -4983,13 +4983,13 @@ int furthestcanseepoint(DDukeActor *actor, DDukeActor* tosee, int* dax, int* day
 
 	for (j = tosee->spr.ang; j < (2048 + tosee->spr.ang); j += (angincs - (krand() & 511)))
 	{
-		hitscan({ tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - (16 << 8) }, tosee->sector(), { bcos(j), bsin(j), 16384 - (krand() & 32767) }, hit, CLIPMASK1);
+		hitscan({ tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().Z - (16 << 8) }, tosee->sector(), { bcos(j), bsin(j), 16384 - (krand() & 32767) }, hit, CLIPMASK1);
 
-		d = abs(hit.hitpos.X - tosee->spr.pos.X) + abs(hit.hitpos.Y - tosee->spr.pos.Y);
-		da = abs(hit.hitpos.X - actor->spr.pos.X) + abs(hit.hitpos.Y - actor->spr.pos.Y);
+		d = abs(hit.hitpos.X - tosee->int_pos().X) + abs(hit.hitpos.Y - tosee->int_pos().Y);
+		da = abs(hit.hitpos.X - actor->int_pos().X) + abs(hit.hitpos.Y - actor->int_pos().Y);
 
 		if (d < da && hit.hitSector)
-			if (cansee(hit.hitpos.X, hit.hitpos.Y, hit.hitpos.Z, hit.hitSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->sector()))
+			if (cansee(hit.hitpos.X, hit.hitpos.Y, hit.hitpos.Z, hit.hitSector, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (16 << 8), actor->sector()))
 			{
 				*dax = hit.hitpos.X;
 				*day = hit.hitpos.Y;
@@ -5027,15 +5027,15 @@ void alterang(int ang, DDukeActor* actor, int playernum)
 
 		// NOTE: looks like 'Owner' is set to target sprite ID...
 
-		if (holoduke && cansee(holoduke->spr.pos.X, holoduke->spr.pos.Y, holoduke->spr.pos.Z, holoduke->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
+		if (holoduke && cansee(holoduke->int_pos().X, holoduke->int_pos().Y, holoduke->int_pos().Z, holoduke->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector()))
 			actor->SetOwner(holoduke);
 		else actor->SetOwner(ps[playernum].GetActor());
 
 		auto Owner = actor->GetOwner();
 		if (Owner->isPlayer())
-			goalang = getangle(actor->ovel.X - actor->spr.pos.X, actor->ovel.Y - actor->spr.pos.Y);
+			goalang = getangle(actor->ovel.X - actor->int_pos().X, actor->ovel.Y - actor->int_pos().Y);
 		else
-			goalang = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
+			goalang = getangle(Owner->int_pos().X - actor->int_pos().X, Owner->int_pos().Y - actor->int_pos().Y);
 
 		if (actor->spr.xvel && actor->spr.picnum != TILE_DRONE)
 		{
@@ -5109,7 +5109,7 @@ void fall_common(DDukeActor *actor, int playernum, int JIBS6, int DRONE, int BLO
 		}
 		else actor->cgg--;
 
-		if (actor->spr.pos.Z < (actor->floorz - FOURSLEIGHT))
+		if (actor->int_pos().Z < (actor->floorz - FOURSLEIGHT))
 		{
 			actor->spr.zvel += c;
 			actor->add_int_z(actor->spr.zvel);
@@ -5244,8 +5244,8 @@ void movefta(void)
 						{
 							continue;
 						}
-						sx = act->spr.pos.X + 64 - (krand() & 127);
-						sy = act->spr.pos.Y + 64 - (krand() & 127);
+						sx = act->int_pos().X + 64 - (krand() & 127);
+						sy = act->int_pos().Y + 64 - (krand() & 127);
 						updatesector(px, py, &ssect);
 						if (ssect == nullptr)
 						{
@@ -5259,14 +5259,14 @@ void movefta(void)
 						{
 							int r1 = krand();
 							int r2 = krand();
-							canseeme = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->sector(), px, py, ps[p].opos.Z - (r1 % (32 << 8)), ps[p].cursector);
+							canseeme = cansee(sx, sy, act->int_pos().Z - (r2 % (52 << 8)), act->sector(), px, py, ps[p].opos.Z - (r1 % (32 << 8)), ps[p].cursector);
 						}
 					}
 					else
 					{
 						int r1 = krand();
 						int r2 = krand();
-						canseeme = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->sector(), ps[p].opos.X, ps[p].opos.Y, ps[p].opos.Z - ((r1 & 31) << 8), ps[p].cursector);
+						canseeme = cansee(act->int_pos().X, act->int_pos().Y, act->int_pos().Z - ((r2 & 31) << 8), act->sector(), ps[p].opos.X, ps[p].opos.Y, ps[p].opos.Z - ((r1 & 31) << 8), ps[p].cursector);
 					}
 
 
diff --git a/source/games/duke/src/actors_d.cpp b/source/games/duke/src/actors_d.cpp
index fe88b7778..97b605a11 100644
--- a/source/games/duke/src/actors_d.cpp
+++ b/source/games/duke/src/actors_d.cpp
@@ -267,16 +267,16 @@ void hitradius_d(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 
 		while (auto dasectp = search.GetNext())
 		{
-			if (((dasectp->ceilingz - actor->spr.pos.Z) >> 8) < r)
+			if (((dasectp->ceilingz - actor->int_pos().Z) >> 8) < r)
 			{
 				auto wal = dasectp->firstWall();
-				int d = abs(wal->wall_int_pos().X - actor->spr.pos.X) + abs(wal->wall_int_pos().Y - actor->spr.pos.Y);
+				int d = abs(wal->wall_int_pos().X - actor->int_pos().X) + abs(wal->wall_int_pos().Y - actor->int_pos().Y);
 				if (d < r)
 					fi.checkhitceiling(dasectp);
 				else
 				{
 					auto thirdpoint = wal->point2Wall()->point2Wall();
-					d = abs(thirdpoint->wall_int_pos().X - actor->spr.pos.X) + abs(thirdpoint->wall_int_pos().Y - actor->spr.pos.Y);
+					d = abs(thirdpoint->wall_int_pos().X - actor->int_pos().X) + abs(thirdpoint->wall_int_pos().Y - actor->int_pos().Y);
 					if (d < r)
 						fi.checkhitceiling(dasectp);
 				}
@@ -284,18 +284,18 @@ void hitradius_d(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 
 			for (auto& wal : wallsofsector(dasectp))
 			{
-				if ((abs(wal.wall_int_pos().X - actor->spr.pos.X) + abs(wal.wall_int_pos().Y - actor->spr.pos.Y)) < r)
+				if ((abs(wal.wall_int_pos().X - actor->int_pos().X) + abs(wal.wall_int_pos().Y - actor->int_pos().Y)) < r)
 				{
 					if (wal.twoSided())
 					{
 						search.Add(wal.nextSector());
 					}
-					int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->spr.pos.X) >> 1;
-					int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->spr.pos.Y) >> 1;
+					int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->int_pos().X) >> 1;
+					int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->int_pos().Y) >> 1;
 					sectortype* sect = wal.sectorp();
 					updatesector(x1, y1, &sect);
-					if (sect && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
-						fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->spr.pos.Z, actor->spr.picnum);
+					if (sect && cansee(x1, y1, actor->int_pos().Z, sect, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector()))
+						fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
 				}
 			}
 		}
@@ -327,7 +327,7 @@ void hitradius_d(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 				if (actor->spr.picnum != SHRINKSPARK || (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL))
 					if (dist(actor, act2) < r)
 					{
-						if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->sector()))
+						if (badguy(act2) && !cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z + q, act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z + q, actor->sector()))
 							continue;
 						fi.checkhitsprite(act2, actor);
 					}
@@ -347,9 +347,9 @@ void hitradius_d(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 				int d = dist(actor, act2);
 				if (act2->spr.picnum == APLAYER) act2->add_int_z(gs.playerheight);
 
-				if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->sector()))
+				if (d < r && cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z - (8 << 8), act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (12 << 8), actor->sector()))
 				{
-					act2->hitang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
+					act2->hitang = getangle(act2->int_pos().X - actor->int_pos().X, act2->int_pos().Y - actor->int_pos().Y);
 
 					if (actor->spr.picnum == RPG && act2->spr.extra > 0)
 						act2->attackertype = RPG;
@@ -443,13 +443,13 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
 	{
 		actor->add_int_pos({ (xchange * TICSPERFRAME) >> 2, (ychange * TICSPERFRAME) >> 2, (zchange * TICSPERFRAME) >> 2 });
 		if (bg)
-			SetActor(actor, actor->spr.pos);
+			SetActor(actor, actor->int_pos());
 		return result.setNone();
 	}
 
 	auto dasectp = actor->sector();
 
-	vec3_t pos = actor->spr.pos;
+	vec3_t pos = actor->int_pos();
 	pos.Z -= ((tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 1);
 
 	if (bg)
@@ -481,7 +481,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
 				actor->spr.ang = (krand()&2047);
 			else if ((actor->temp_data[0]&3) == 1 && actor->spr.picnum != COMMANDER)
 				actor->spr.ang = (krand()&2047);
-			SetActor(actor,actor->spr.pos);
+			SetActor(actor,actor->int_pos());
 			if (dasectp == nullptr) dasectp = &sector[0];
 			return result.setSector(dasectp);
 		}
@@ -499,7 +499,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
 	if (dasectp != nullptr)
 		if (dasectp != actor->sector())
 			ChangeActorSect(actor, dasectp);
-	int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
+	int daz = actor->int_pos().Z + ((zchange * TICSPERFRAME) >> 3);
 	if ((daz > actor->ceilingz) && (daz <= actor->floorz))
 		actor->set_int_z(daz);
 	else if (result.type == kHitNone)
@@ -545,8 +545,8 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
 		sx = sy = 8;
 	else sx = sy = 32;
 
-	gutz = actor->spr.pos.Z - (8 << 8);
-	floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
+	gutz = actor->int_pos().Z - (8 << 8);
+	floorz = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
 
 	if (gutz > (floorz - (8 << 8)))
 		gutz = floorz - (8 << 8);
@@ -570,7 +570,7 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
 		int r4 = krand();
 		int r5 = krand();
 		// TRANSITIONAL: owned by a player???
-		auto spawned = EGS(actor->sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
+		auto spawned = EGS(actor->sector(), actor->int_pos().X + (r5 & 255) - 128, actor->int_pos().Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
 		if (spawned)
 		{
 			if (spawned->spr.picnum == JIBS2)
@@ -770,14 +770,14 @@ void movefallers_d(void)
 						x = gs.gravity;
 				}
 
-				if (act->spr.pos.Z < (sectp->floorz - FOURSLEIGHT))
+				if (act->int_pos().Z < (sectp->floorz - FOURSLEIGHT))
 				{
 					act->spr.zvel += x;
 					if (act->spr.zvel > 6144)
 						act->spr.zvel = 6144;
 					act->add_int_z(act->spr.zvel);
 				}
-				if ((sectp->floorz - act->spr.pos.Z) < (16 << 8))
+				if ((sectp->floorz - act->int_pos().Z) < (16 << 8))
 				{
 					j = 1 + (krand() & 7);
 					for (x = 0; x < j; x++) RANDOMSCRAP(act);
@@ -871,14 +871,14 @@ static void movetripbomb(DDukeActor *actor)
 		int16_t l = actor->spr.ang;
 		actor->spr.ang = actor->temp_data[5];
 
-		actor->temp_data[3] = actor->spr.pos.X; actor->temp_data[4] = actor->spr.pos.Y;
+		actor->temp_data[3] = actor->int_pos().X; actor->temp_data[4] = actor->int_pos().Y;
 		actor->add_int_pos({ bcos(actor->temp_data[5], -9), bsin(actor->temp_data[5], -9), -(3 << 8) });
 
 		// Laser fix from EDuke32.
 		auto const oldSect = actor->sector();
 		auto       curSect = actor->sector();
 
-		updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
+		updatesectorneighbor(actor->int_pos().X, actor->int_pos().Y, &curSect, 2048);
 		ChangeActorSect(actor, curSect);
 
 		DDukeActor* hit;
@@ -896,9 +896,9 @@ static void movetripbomb(DDukeActor *actor)
 				auto spawned = spawn(actor, LASERLINE);
 				if (spawned)
 				{
-					SetActor(spawned, spawned->spr.pos);
+					SetActor(spawned, spawned->int_pos());
 					spawned->spr.hitag = actor->spr.hitag;
-					spawned->temp_data[1] = spawned->spr.pos.Z;
+					spawned->temp_data[1] = spawned->int_pos().Z;
 
 					if (x < 1024)
 					{
@@ -908,7 +908,7 @@ static void movetripbomb(DDukeActor *actor)
 					x -= 1024;
 
 					actor->add_int_pos({ bcos(actor->temp_data[5], -4), bsin(actor->temp_data[5], -4), 0 });
-					updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
+					updatesectorneighbor(actor->int_pos().X, actor->int_pos().Y, &curSect, 2048);
 
 					if (curSect == nullptr)
 						break;
@@ -938,16 +938,16 @@ static void movetripbomb(DDukeActor *actor)
 		actor->temp_data[1]++;
 
 
-		actor->temp_data[3] = actor->spr.pos.X; 
-		actor->temp_data[4] = actor->spr.pos.Y;
+		actor->temp_data[3] = actor->int_pos().X; 
+		actor->temp_data[4] = actor->int_pos().Y;
 		actor->add_int_pos({ bcos(actor->temp_data[5], -9), bsin(actor->temp_data[5], -9), -(3 << 8) });
-		SetActor(actor, actor->spr.pos);
+		SetActor(actor, actor->int_pos());
 
 		x = hitasprite(actor, nullptr);
 
 		actor->set_int_xy(actor->temp_data[3], actor->temp_data[4]);
 		actor->add_int_z(3 << 8);
-		SetActor(actor, actor->spr.pos);
+		SetActor(actor, actor->int_pos());
 
 		if (actor->ovel.X != x && lTripBombControl & TRIPBOMB_TRIPWIRE)
 		{
@@ -1003,7 +1003,7 @@ static void movefireext(DDukeActor* actor)
 
 	for (int k = 0; k < 16; k++)
 	{
-		auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
+		auto spawned = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
 		if(spawned) spawned->spr.pal = 2;
 	}
 
@@ -1330,7 +1330,7 @@ static bool movefireball(DDukeActor* actor)
 				ball->spr.cstat = actor->spr.cstat;
 				ball->spr.extra = 0;
 
-				ball->fproj = { ball->spr.pos, { ball->spr.xvel, ball->spr.yvel, ball->spr.zvel } };
+				ball->fproj = { ball->int_pos(), { ball->spr.xvel, ball->spr.yvel, ball->spr.zvel } };
 
 				ChangeActorStat(ball, STAT_PROJECTILE);
 			}
@@ -1425,7 +1425,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t &oldpos)
 	else
 	{
 		SetActor(proj, oldpos);
-		fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.pos.Z, proj->spr.picnum);
+		fi.checkhitwall(proj, wal, proj->int_pos().X, proj->int_pos().Y, proj->int_pos().Z, proj->spr.picnum);
 
 		if (proj->spr.picnum == FREEZEBLAST)
 		{
@@ -1505,7 +1505,7 @@ static void weaponcommon_d(DDukeActor* proj)
 			S_PlayActorSound(WIERDSHOT_FLY, proj);
 
 	int k, ll;
-	vec3_t oldpos = proj->spr.pos;
+	vec3_t oldpos = proj->int_pos();
 
 	if (proj->spr.picnum == RPG && proj->sector()->lotag == 2)
 	{
@@ -1541,7 +1541,7 @@ static void weaponcommon_d(DDukeActor* proj)
 		MulScale(k, bsin(proj->spr.ang), 14), ll, CLIPMASK1, coll);
 
 	if (proj->spr.picnum == RPG && proj->temp_actor != nullptr)
-		if (FindDistance2D(proj->spr.pos.vec2 - proj->temp_actor->spr.pos.vec2) < 256)
+		if (FindDistance2D(proj->int_pos().vec2 - proj->temp_actor->int_pos().vec2) < 256)
 			coll.setSprite(proj->temp_actor);
 
 	if (!proj->insector())
@@ -1552,14 +1552,14 @@ static void weaponcommon_d(DDukeActor* proj)
 
 	if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
 	{
-		if (proj->spr.pos.Z < proj->ceilingz)
+		if (proj->int_pos().Z < proj->ceilingz)
 		{
 			coll.setSector(proj->sector());
 			proj->spr.zvel = -1;
 		}
 		else
-			if ((proj->spr.pos.Z > proj->floorz && proj->sector()->lotag != 1) ||
-				(proj->spr.pos.Z > proj->floorz + (16 << 8) && proj->sector()->lotag == 1))
+			if ((proj->int_pos().Z > proj->floorz && proj->sector()->lotag != 1) ||
+				(proj->int_pos().Z > proj->floorz + (16 << 8) && proj->sector()->lotag == 1))
 			{
 				coll.setSector(proj->sector());
 				if (proj->sector()->lotag != 1)
@@ -1578,9 +1578,9 @@ static void weaponcommon_d(DDukeActor* proj)
 			};
 
 			auto spawned = EGS(proj->sector(),
-				proj->spr.pos.X + offset.X,
-				proj->spr.pos.Y + offset.Y,
-				proj->spr.pos.Z + offset.Z, FIRELASER, -40 + (k << 2),
+				proj->int_pos().X + offset.X,
+				proj->int_pos().Y + offset.Y,
+				proj->int_pos().Z + offset.Z, FIRELASER, -40 + (k << 2),
 				proj->spr.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
 
 			if (spawned)
@@ -1806,9 +1806,9 @@ void movetransports_d(void)
 								ps[p].transporter_hold = 13;
 							}
 
-							ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->spr.pos.X;
-							ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->spr.pos.Y;
-							ps[p].opos.Z = ps[p].pos.Z = Owner->spr.pos.Z - gs.playerheight;
+							ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->int_pos().X;
+							ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->int_pos().Y;
+							ps[p].opos.Z = ps[p].pos.Z = Owner->int_pos().Z - gs.playerheight;
 
 							ChangeActorSect(act2, Owner->sector());
 							ps[p].setCursector(act2->sector());
@@ -1824,16 +1824,16 @@ void movetransports_d(void)
 					}
 					else if (!(sectlotag == 1 && ps[p].on_ground == 1)) break;
 
-					if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 6144)
+					if (onfloorz == 0 && abs(act->int_pos().Z - ps[p].pos.Z) < 6144)
 						if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP))) ||
 							(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
 						{
-							ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
-							ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
+							ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
+							ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
 
 							if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
-								ps[p].pos.Z = Owner->spr.pos.Z - 6144;
-							else ps[p].pos.Z = Owner->spr.pos.Z + 6144;
+								ps[p].pos.Z = Owner->int_pos().Z - 6144;
+							else ps[p].pos.Z = Owner->int_pos().Z + 6144;
 							ps[p].opos.Z = ps[p].pos.Z;
 
 							auto pa = ps[p].GetActor();
@@ -1884,8 +1884,8 @@ void movetransports_d(void)
 
 					if (k == 1)
 					{
-						ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
-						ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
+						ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
+						ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
 
 						if (!Owner || Owner->GetOwner() != Owner)
 							ps[p].transporter_hold = -2;
@@ -1934,13 +1934,13 @@ void movetransports_d(void)
 
 				{
 					warpspriteto = 0;
-					if (ll && sectlotag == 2 && act2->spr.pos.Z < (sectp->ceilingz + ll))
+					if (ll && sectlotag == 2 && act2->int_pos().Z < (sectp->ceilingz + ll))
 						warpspriteto = 1;
 
-					if (ll && sectlotag == 1 && act2->spr.pos.Z > (sectp->floorz - ll))
+					if (ll && sectlotag == 1 && act2->int_pos().Z > (sectp->floorz - ll))
 						warpspriteto = 1;
 
-					if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 4096))
+					if (sectlotag == 0 && (onfloorz || abs(act2->int_pos().Z - act->int_pos().Z) < 4096))
 					{
 						if ((!Owner || Owner->GetOwner() != Owner) && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != STAT_MISC)
 						{
@@ -1989,7 +1989,7 @@ void movetransports_d(void)
 								{
 									if (act2->spr.statnum == STAT_PROJECTILE || (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1))
 									{
-										act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X),(Owner->spr.pos.Y - act->spr.pos.Y), -(act->spr.pos.Z - Owner->sector()->floorz) });
+										act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X),(Owner->int_pos().Y - act->int_pos().Y), -(act->int_pos().Z - Owner->sector()->floorz) });
 										act2->spr.ang = Owner->spr.ang;
 
 										act2->backupang();
@@ -2014,20 +2014,20 @@ void movetransports_d(void)
 								}
 								else
 								{
-									act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
-									act2->set_int_z(Owner->spr.pos.Z + 4096);
+									act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
+									act2->set_int_z(Owner->int_pos().Z + 4096);
 									act2->backupz();
 									ChangeActorSect(act2, Owner->sector());
 								}
 								break;
 							case ST_1_ABOVE_WATER:
-								act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
+								act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
 								act2->set_int_z(Owner->sector()->ceilingz + ll);
 								act2->backupz();
 								ChangeActorSect(act2, Owner->sector());
 								break;
 							case ST_2_UNDERWATER:
-								act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
+								act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
 								act2->set_int_z(Owner->sector()->floorz - ll);
 								act2->backupz();
 								ChangeActorSect(act2, Owner->sector());
@@ -2112,7 +2112,7 @@ static void greenslime(DDukeActor *actor)
 				return;
 			for (j = 16; j >= 0; j--)
 			{
-				auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
+				auto k = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
 				k->spr.pal = 1;
 			}
 			ps[p].actors_killed++;
@@ -2121,7 +2121,7 @@ static void greenslime(DDukeActor *actor)
 		}
 		else if (x < 1024 && ps[p].quick_kick == 0)
 		{
-			j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y));
+			j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->int_pos().X - ps[p].pos.X, actor->int_pos().Y - ps[p].pos.Y));
 			if (j > -128 && j < 128)
 				ps[p].quick_kick = 14;
 		}
@@ -2141,7 +2141,7 @@ static void greenslime(DDukeActor *actor)
 			return;
 		}
 
-		SetActor(actor, actor->spr.pos);
+		SetActor(actor, actor->int_pos());
 
 		actor->spr.ang = ps[p].angle.ang.asbuild();
 
@@ -2150,7 +2150,7 @@ static void greenslime(DDukeActor *actor)
 			{
 				for (x = 0; x < 8; x++)
 				{
-					auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
+					auto spawned = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
 					spawned->spr.pal = 6;
 				}
 
@@ -2260,7 +2260,7 @@ static void greenslime(DDukeActor *actor)
 
 		for (x = 0; x < 8; x++)
 		{
-			auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
+			auto spawned = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
 			if (spawned) spawned->spr.pal = 6;
 		}
 		actor->temp_data[0] = -3;
@@ -2299,7 +2299,7 @@ static void greenslime(DDukeActor *actor)
 
 			int l = s5->spr.ang;
 
-			actor->set_int_pos({ s5->spr.pos.X + bcos(l, -11), s5->spr.pos.Y + bsin(l, -11), s5->spr.pos.Z });
+			actor->set_int_pos({ s5->int_pos().X + bcos(l, -11), s5->int_pos().Y + bsin(l, -11), s5->int_pos().Z });
 
 			actor->spr.picnum = GREENSLIME + 2 + (global_random & 1);
 
@@ -2328,7 +2328,7 @@ static void greenslime(DDukeActor *actor)
 		{
 			if (actorflag(a2, SFLAG_GREENSLIMEFOOD))
 			{
-				if (ldist(actor, a2) < 768 && (abs(actor->spr.pos.Z - a2->spr.pos.Z) < 8192)) //Gulp them
+				if (ldist(actor, a2) < 768 && (abs(actor->int_pos().Z - a2->int_pos().Z) < 8192)) //Gulp them
 				{
 					actor->temp_actor = a2;
 					actor->temp_data[0] = -2;
@@ -2353,7 +2353,7 @@ static void greenslime(DDukeActor *actor)
 			actor->spr.zvel = 0;
 			actor->spr.cstat &= ~CSTAT_SPRITE_YFLIP;
 
-			if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 6144) < actor->spr.pos.Z)
+			if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 6144) < actor->int_pos().Z)
 			{
 				actor->add_int_z(2048);
 				actor->temp_data[0] = 3;
@@ -2379,7 +2379,7 @@ static void greenslime(DDukeActor *actor)
 			actor->spr.xvel = 64 - bcos(actor->temp_data[1], -9);
 
 			actor->spr.ang += getincangle(actor->spr.ang,
-				getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 3;
+				getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y)) >> 3;
 			// TJR
 		}
 
@@ -2404,7 +2404,7 @@ static void greenslime(DDukeActor *actor)
 		if (actor->spr.zvel > -(2048 + 1024))
 			actor->spr.zvel -= 348;
 		actor->add_int_z(actor->spr.zvel);
-		if (actor->spr.pos.Z < actor->ceilingz + 4096)
+		if (actor->int_pos().Z < actor->ceilingz + 4096)
 		{
 			actor->set_int_z(actor->ceilingz + 4096);
 			actor->spr.xvel = 0;
@@ -2418,7 +2418,7 @@ static void greenslime(DDukeActor *actor)
 
 		makeitfall(actor);
 
-		if (actor->spr.pos.Z > actor->floorz - (8 << 8))
+		if (actor->int_pos().Z > actor->floorz - (8 << 8))
 		{
 			actor->spr.yrepeat -= 4;
 			actor->spr.xrepeat += 2;
@@ -2429,7 +2429,7 @@ static void greenslime(DDukeActor *actor)
 			if (actor->spr.xrepeat > 8) actor->spr.xrepeat -= 4;
 		}
 
-		if (actor->spr.pos.Z > actor->floorz - 2048)
+		if (actor->int_pos().Z > actor->floorz - 2048)
 		{
 			actor->set_int_z(actor->floorz - 2048);
 			actor->temp_data[0] = 0;
@@ -2458,9 +2458,9 @@ static void flamethrowerflame(DDukeActor *actor)
 		return;
 	}
 
-	int dax = actor->spr.pos.X;
-	int day = actor->spr.pos.Y;
-	int daz = actor->spr.pos.Z;
+	int dax = actor->int_pos().X;
+	int day = actor->int_pos().Y;
+	int daz = actor->int_pos().Z;
 	int xvel = actor->spr.xvel;
 
 	getglobalz(actor);
@@ -2490,13 +2490,13 @@ static void flamethrowerflame(DDukeActor *actor)
 
 	if (coll.type != kHitSprite)
 	{
-		if (actor->spr.pos.Z < actor->ceilingz)
+		if (actor->int_pos().Z < actor->ceilingz)
 		{
 			coll.setSector(actor->sector());
 			actor->spr.zvel = -1;
 		}
-		else if ((actor->spr.pos.Z > actor->floorz && actor->sector()->lotag != 1)
-			|| (actor->spr.pos.Z > actor->floorz + (16 << 8) && actor->sector()->lotag == 1))
+		else if ((actor->int_pos().Z > actor->floorz && actor->sector()->lotag != 1)
+			|| (actor->int_pos().Z > actor->floorz + (16 << 8) && actor->sector()->lotag == 1))
 		{
 			coll.setSector(actor->sector());
 			if (actor->sector()->lotag != 1)
@@ -2515,7 +2515,7 @@ static void flamethrowerflame(DDukeActor *actor)
 		else if (coll.type == kHitWall)
 		{
 			SetActor(actor, { dax, day, daz });
-			fi.checkhitwall(actor, coll.hitWall, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
+			fi.checkhitwall(actor, coll.hitWall, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
 		}
 		else if (coll.type == kHitSector)
 		{
@@ -2583,7 +2583,7 @@ static void heavyhbomb(DDukeActor *actor)
 	{
 		makeitfall(actor);
 
-		if (sectp->lotag != 1 && actor->spr.pos.Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
+		if (sectp->lotag != 1 && actor->int_pos().Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
 		{
 			if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
 				S_PlayActorSound(PIPEBOMB_BOUNCE, actor);
@@ -2592,7 +2592,7 @@ static void heavyhbomb(DDukeActor *actor)
 				actor->spr.zvel >>= 2;
 			actor->spr.yvel++;
 		}
-		if (actor->spr.pos.Z < actor->ceilingz) // && sectp->lotag != 2 )
+		if (actor->int_pos().Z < actor->ceilingz) // && sectp->lotag != 2 )
 		{
 			actor->set_int_z(actor->ceilingz + (3 << 8));
 			actor->spr.zvel = 0;
@@ -2643,7 +2643,7 @@ static void heavyhbomb(DDukeActor *actor)
 	if (coll.type== kHitWall)
 	{
 		auto wal = coll.hitWall;
-		fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
+		fi.checkhitwall(actor, wal, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
 
 		int k = getangle(wal->delta());
 
@@ -2709,7 +2709,7 @@ DETONATEB:
 		}
 	}
 	else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && actor->temp_data[0] > 7 && actor->spr.xvel == 0)
-		if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
+		if (cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
 			if (ps[p].ammo_amount[HANDBOMB_WEAPON] < gs.max_ammo_amount[HANDBOMB_WEAPON])
 			{
 				if (ud.coop >= 1 && Owner == actor)
@@ -2954,8 +2954,8 @@ static void fireflyflyingeffect(DDukeActor *actor)
 	else
 		actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
 
-	double dx = Owner->spr.pos.X - ps[p].GetActor()->spr.pos.X;
-	double dy = Owner->spr.pos.Y - ps[p].GetActor()->spr.pos.Y;
+	double dx = Owner->int_pos().X - ps[p].GetActor()->int_pos().X;
+	double dy = Owner->int_pos().Y - ps[p].GetActor()->int_pos().Y;
 	double dist = sqrt(dx * dx + dy * dy);
 	if (dist != 0.0) 
 	{
@@ -2963,7 +2963,7 @@ static void fireflyflyingeffect(DDukeActor *actor)
 		dy /= dist;
 	}
 
-	actor->set_int_pos({ (int)(Owner->spr.pos.X - (dx * -10.0)), (int)(Owner->spr.pos.Y - (dy * -10.0)), Owner->spr.pos.Z + 2048 });
+	actor->set_int_pos({ (int)(Owner->int_pos().X - (dx * -10.0)), (int)(Owner->int_pos().Y - (dy * -10.0)), Owner->int_pos().Z + 2048 });
 
 	if (Owner->spr.extra <= 0) 
 	{
@@ -3077,7 +3077,7 @@ void moveexplosions_d(void)  // STATNUM 5
 		case MONEY + 1:
 		case MAIL + 1:
 		case PAPER + 1:
-			act->floorz = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
+			act->floorz = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
 			act->set_int_z(act->floorz);
 			break;
 		case MONEY:
@@ -3139,7 +3139,7 @@ void moveexplosions_d(void)  // STATNUM 5
 
 		case SHELL:
 		case SHOTGUNSHELL:
-			shell(act, (sectp->floorz + (24 << 8)) < act->spr.pos.Z);
+			shell(act, (sectp->floorz + (24 << 8)) < act->int_pos().Z);
 			continue;
 
 		case GLASSPIECES:
@@ -3256,7 +3256,7 @@ static void handle_se28(DDukeActor* actor)
 		}
 		else if (actor->temp_data[2] > (actor->temp_data[1] >> 3) && actor->temp_data[2] < (actor->temp_data[1] >> 2))
 		{
-			int j = !!cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
+			int j = !!cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
 
 			if (rnd(192) && (actor->temp_data[2] & 1))
 			{
@@ -3436,7 +3436,7 @@ void moveeffectors_d(void)   //STATNUM 3
 		case SE_29_WAVES:
 			act->spr.hitag += 64;
 			l = MulScale(act->spr.yvel, bsin(act->spr.hitag), 12);
-			sc->setfloorz(act->spr.pos.Z + l);
+			sc->setfloorz(act->int_pos().Z + l);
 			break;
 		case SE_31_FLOOR_RISE_FALL: // True Drop Floor
 			handle_se31(act, true);
@@ -3508,8 +3508,8 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 	if (a & face_player)
 	{
 		if (ps[playernum].newOwner != nullptr)
-			goalang = getangle(ps[playernum].opos.X - actor->spr.pos.X, ps[playernum].opos.Y - actor->spr.pos.Y);
-		else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
+			goalang = getangle(ps[playernum].opos.X - actor->int_pos().X, ps[playernum].opos.Y - actor->int_pos().Y);
+		else goalang = getangle(ps[playernum].pos.X - actor->int_pos().X, ps[playernum].pos.Y - actor->int_pos().Y);
 		angdif = getincangle(actor->spr.ang, goalang) >> 2;
 		if (angdif > -8 && angdif < 0) angdif = 0;
 		actor->spr.ang += angdif;
@@ -3521,8 +3521,8 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 	if (a & face_player_slow)
 	{
 		if (ps[playernum].newOwner != nullptr)
-			goalang = getangle(ps[playernum].opos.X - actor->spr.pos.X, ps[playernum].opos.Y - actor->spr.pos.Y);
-		else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
+			goalang = getangle(ps[playernum].opos.X - actor->int_pos().X, ps[playernum].opos.Y - actor->int_pos().Y);
+		else goalang = getangle(ps[playernum].pos.X - actor->int_pos().X, ps[playernum].pos.Y - actor->int_pos().Y);
 		angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
 		if (angdif > -32 && angdif < 0)
 		{
@@ -3545,7 +3545,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 
 		newx = ps[playernum].pos.X + (ps[playernum].vel.X / 768);
 		newy = ps[playernum].pos.Y + (ps[playernum].vel.Y / 768);
-		goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.pos.Y);
+		goalang = getangle(newx - actor->int_pos().X, newy - actor->int_pos().Y);
 		angdif = getincangle(actor->spr.ang, goalang) >> 2;
 		if (angdif > -8 && angdif < 0) angdif = 0;
 		actor->spr.ang += angdif;
@@ -3553,10 +3553,10 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 
 	if (actor->temp_data[1] == 0 || a == 0)
 	{
-		if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->spr.pos.X) || (actor->opos.Y != actor->spr.pos.Y))
+		if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->int_pos().X) || (actor->opos.Y != actor->int_pos().Y))
 		{
 			actor->backupvec2();
-			SetActor(actor, actor->spr.pos);
+			SetActor(actor, actor->int_pos());
 		}
 		return;
 	}
@@ -3584,15 +3584,15 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 			{
 				if (actor->spr.picnum == COMMANDER)
 				{
-					actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-					if (actor->spr.pos.Z > (l - (8 << 8)))
+					actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+					if (actor->int_pos().Z > (l - (8 << 8)))
 					{
-						if (actor->spr.pos.Z > (l - (8 << 8))) actor->set_int_z(l - (8 << 8));
+						if (actor->int_pos().Z > (l - (8 << 8))) actor->set_int_z(l - (8 << 8));
 						actor->spr.zvel = 0;
 					}
 
-					actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-					if ((actor->spr.pos.Z - l) < (80 << 8))
+					actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+					if ((actor->int_pos().Z - l) < (80 << 8))
 					{
 						actor->set_int_z(l + (80 << 8));
 						actor->spr.zvel = 0;
@@ -3602,14 +3602,14 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 				{
 					if (actor->spr.zvel > 0)
 					{
-						actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-						if (actor->spr.pos.Z > (l - (30 << 8)))
+						actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+						if (actor->int_pos().Z > (l - (30 << 8)))
 							actor->set_int_z(l - (30 << 8));
 					}
 					else
 					{
-						actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-						if ((actor->spr.pos.Z - l) < (50 << 8))
+						actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+						if ((actor->int_pos().Z - l) < (50 << 8))
 						{
 							actor->set_int_z(l + (50 << 8));
 							actor->spr.zvel = 0;
@@ -3619,12 +3619,12 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 			}
 			else if (actor->spr.picnum != ORGANTIC)
 			{
-				if (actor->spr.zvel > 0 && actor->floorz < actor->spr.pos.Z)
+				if (actor->spr.zvel > 0 && actor->floorz < actor->int_pos().Z)
 					actor->set_int_z(actor->floorz);
 				if (actor->spr.zvel < 0)
 				{
-					l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-					if ((actor->spr.pos.Z - l) < (66 << 8))
+					l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+					if ((actor->int_pos().Z - l) < (66 << 8))
 					{
 						actor->set_int_z(l + (66 << 8));
 						actor->spr.zvel >>= 1;
@@ -3633,7 +3633,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 			}
 		}
 		else if (actor->spr.picnum == APLAYER)
-			if ((actor->spr.pos.Z - actor->ceilingz) < (32 << 8))
+			if ((actor->int_pos().Z - actor->ceilingz) < (32 << 8))
 				actor->set_int_z(actor->ceilingz + (32 << 8));
 
 		daxvel = actor->spr.xvel;
@@ -3645,7 +3645,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 			{
 
 				daxvel = -(1024 - xvel);
-				angdif = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
+				angdif = getangle(ps[playernum].pos.X - actor->int_pos().X, ps[playernum].pos.Y - actor->int_pos().Y);
 
 				if (xvel < 512)
 				{
@@ -3662,7 +3662,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
 			{
 				if (!*(moveptr + 1))
 				{
-					if (actor->opos.Z != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
+					if (actor->opos.Z != actor->int_pos().Z || (ud.multimode < 2 && ud.player_skill < 2))
 					{
 						if ((actor->temp_data[0] & 1) || ps[playernum].actorsqu == actor) return;
 						else daxvel <<= 1;
diff --git a/source/games/duke/src/actors_lava.cpp b/source/games/duke/src/actors_lava.cpp
index e8c3f1666..87c5fc8d6 100644
--- a/source/games/duke/src/actors_lava.cpp
+++ b/source/games/duke/src/actors_lava.cpp
@@ -434,7 +434,7 @@ void moveminecart(void)
 		while (auto a2 = it.Next())
 		{
 			if (badguy(a2))
-				SetActor(a2, { int(cx * worldtoint), int(cy * worldtoint), a2->spr.pos.Z });
+				SetActor(a2, { int(cx * worldtoint), int(cy * worldtoint), a2->int_pos().Z });
 		}
 	}
 }
diff --git a/source/games/duke/src/actors_r.cpp b/source/games/duke/src/actors_r.cpp
index 2c3344d74..7272b073a 100644
--- a/source/games/duke/src/actors_r.cpp
+++ b/source/games/duke/src/actors_r.cpp
@@ -225,16 +225,16 @@ void hitradius_r(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 
 		while (auto dasectp = search.GetNext())
 		{
-			if (((dasectp->ceilingz - actor->spr.pos.Z) >> 8) < r)
+			if (((dasectp->ceilingz - actor->int_pos().Z) >> 8) < r)
 			{
 				auto wal = dasectp->firstWall();
-				int d = abs(wal->wall_int_pos().X - actor->spr.pos.X) + abs(wal->wall_int_pos().Y - actor->spr.pos.Y);
+				int d = abs(wal->wall_int_pos().X - actor->int_pos().X) + abs(wal->wall_int_pos().Y - actor->int_pos().Y);
 				if (d < r)
 					fi.checkhitceiling(dasectp);
 				else
 				{
 					auto thirdpoint = wal->point2Wall()->point2Wall();
-					d = abs(thirdpoint->wall_int_pos().X - actor->spr.pos.X) + abs(thirdpoint->wall_int_pos().Y - actor->spr.pos.Y);
+					d = abs(thirdpoint->wall_int_pos().X - actor->int_pos().X) + abs(thirdpoint->wall_int_pos().Y - actor->int_pos().Y);
 					if (d < r)
 						fi.checkhitceiling(dasectp);
 				}
@@ -242,18 +242,18 @@ void hitradius_r(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 
 			for (auto& wal : wallsofsector(dasectp))
 			{
-				if ((abs(wal.wall_int_pos().X - actor->spr.pos.X) + abs(wal.wall_int_pos().Y - actor->spr.pos.Y)) < r)
+				if ((abs(wal.wall_int_pos().X - actor->int_pos().X) + abs(wal.wall_int_pos().Y - actor->int_pos().Y)) < r)
 				{
 					if (wal.twoSided())
 					{
 						search.Add(wal.nextSector());
 					}
-					int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->spr.pos.X) >> 1;
-					int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->spr.pos.Y) >> 1;
+					int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->int_pos().X) >> 1;
+					int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->int_pos().Y) >> 1;
 					auto sect = wal.sectorp();
 					updatesector(x1, y1, &sect);
-					if (sect != nullptr && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
-						fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->spr.pos.Z, actor->spr.picnum);
+					if (sect != nullptr && cansee(x1, y1, actor->int_pos().Z, sect, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector()))
+						fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
 				}
 			}
 		}
@@ -272,7 +272,7 @@ void hitradius_r(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 				if (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL)
 					if (dist(actor, act2) < r)
 					{
-						if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->sector()))
+						if (badguy(act2) && !cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z + q, act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z + q, actor->sector()))
 						{
 							continue;
 						}
@@ -294,14 +294,14 @@ void hitradius_r(DDukeActor* actor, int  r, int  hp1, int  hp2, int  hp3, int  h
 				int d = dist(actor, act2);
 				if (act2->spr.picnum == APLAYER) act2->add_int_z(gs.playerheight);
 
-				if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->sector()))
+				if (d < r && cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z - (8 << 8), act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (12 << 8), actor->sector()))
 				{
 					if ((isRRRA()) && act2->spr.picnum == MINION && act2->spr.pal == 19)
 					{
 						continue;
 					}
 
-					act2->hitang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
+					act2->hitang = getangle(act2->int_pos().X - actor->int_pos().X, act2->int_pos().Y - actor->int_pos().Y);
 
 					if (actor->spr.picnum == RPG && act2->spr.extra > 0)
 						act2->attackertype = RPG;
@@ -372,13 +372,13 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
 	{
 		actor->add_int_pos({ (xchange * TICSPERFRAME) >> 2, (ychange * TICSPERFRAME) >> 2, (zchange * TICSPERFRAME) >> 2 });
 		if (bg)
-			SetActor(actor, actor->spr.pos);
+			SetActor(actor, actor->int_pos());
 		return result.setNone();
 	}
 
 	auto dasectp = actor->sector();
 
-	vec3_t pos = actor->spr.pos;
+	vec3_t pos = actor->int_pos();
 	pos.Z -= ((tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 1);
 
 	if (bg)
@@ -397,7 +397,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
 				actor->spr.ang = (krand() & 2047);
 			else if ((actor->temp_data[0] & 3) == 1)
 				actor->spr.ang = (krand() & 2047);
-			SetActor(actor, actor->spr.pos);
+			SetActor(actor, actor->int_pos());
 			if (dasectp == nullptr) dasectp = &sector[0];
 			return result.setSector(dasectp);
 		}
@@ -415,7 +415,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
 	if (dasectp)
 		if ((dasectp != actor->sector()))
 			ChangeActorSect(actor, dasectp);
-	int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
+	int daz = actor->int_pos().Z + ((zchange * TICSPERFRAME) >> 3);
 	if ((daz > actor->ceilingz) && (daz <= actor->floorz))
 		actor->set_int_z(daz);
 	else if (result.type == kHitNone)
@@ -453,8 +453,8 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
 		sx = sy = 8;
 	else sx = sy = 32;
 
-	gutz = actor->spr.pos.Z - (8 << 8);
-	floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
+	gutz = actor->int_pos().Z - (8 << 8);
+	floorz = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
 
 	if (gutz > (floorz - (8 << 8)))
 		gutz = floorz - (8 << 8);
@@ -482,7 +482,7 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
 		int r4 = krand();
 		int r5 = krand();
 		// TRANSITIONAL: owned by a player???
-		auto spawned = EGS(actor->sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
+		auto spawned = EGS(actor->sector(), actor->int_pos().X + (r5 & 255) - 128, actor->int_pos().Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
 		if (spawned && pal != 0)
 			spawned->spr.pal = pal;
 	}
@@ -689,14 +689,14 @@ void movefallers_r(void)
 						x = gs.gravity;
 				}
 
-				if (act->spr.pos.Z < (sectp->floorz - FOURSLEIGHT))
+				if (act->int_pos().Z < (sectp->floorz - FOURSLEIGHT))
 				{
 					act->spr.zvel += x;
 					if (act->spr.zvel > 6144)
 						act->spr.zvel = 6144;
 					act->add_int_z(act->spr.zvel);
 				}
-				if ((sectp->floorz - act->spr.pos.Z) < (16 << 8))
+				if ((sectp->floorz - act->int_pos().Z) < (16 << 8))
 				{
 					int j = 1 + (krand() & 7);
 					for (x = 0; x < j; x++) RANDOMSCRAP(act);
@@ -935,7 +935,7 @@ static void chickenarrow(DDukeActor* actor)
 	if (actor->seek_actor && actor->spr.hitag > 5)
 	{
 		int ang, ang2, ang3;
-		ang = getangle(ts->spr.pos.X - actor->spr.pos.X, ts->spr.pos.Y - actor->spr.pos.Y);
+		ang = getangle(ts->int_pos().X - actor->int_pos().X, ts->int_pos().Y - actor->int_pos().Y);
 		ang2 = ang - actor->spr.ang;
 		ang3 = abs(ang2);
 		if (ang2 < 100)
@@ -1061,7 +1061,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t& oldpos)
 	else
 	{
 		SetActor(proj, oldpos);
-		fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.pos.Z, proj->spr.picnum);
+		fi.checkhitwall(proj, wal, proj->int_pos().X, proj->int_pos().Y, proj->int_pos().Z, proj->spr.picnum);
 
 		if (!isRRRA() && proj->spr.picnum == FREEZEBLAST)
 		{
@@ -1192,7 +1192,7 @@ static void weaponcommon_r(DDukeActor *proj)
 		ll = proj->spr.zvel;
 	}
 
-	auto oldpos = proj->spr.pos;
+	auto oldpos = proj->int_pos();
 
 	getglobalz(proj);
 
@@ -1233,7 +1233,7 @@ static void weaponcommon_r(DDukeActor *proj)
 		MulScale(k, bsin(proj->spr.ang), 14), ll, CLIPMASK1, coll);
 
 	if ((proj->spr.picnum == RPG || (isRRRA() && isIn(proj->spr.picnum, RPG2, RRTILE1790))) && proj->temp_actor != nullptr)
-		if (FindDistance2D(proj->spr.pos.vec2 - proj->temp_actor->spr.pos.vec2) < 256)
+		if (FindDistance2D(proj->int_pos().vec2 - proj->temp_actor->int_pos().vec2) < 256)
 			coll.setSprite(proj->temp_actor);
 
 	if (!proj->insector()) // || (isRR() && proj->sector()->filler == 800))
@@ -1244,13 +1244,13 @@ static void weaponcommon_r(DDukeActor *proj)
 
 	if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
 	{
-		if (proj->spr.pos.Z < proj->ceilingz)
+		if (proj->int_pos().Z < proj->ceilingz)
 		{
 			coll.setSector(proj->sector());
 			proj->spr.zvel = -1;
 		}
 		else
-			if (proj->spr.pos.Z > proj->floorz)
+			if (proj->int_pos().Z > proj->floorz)
 			{
 				coll.setSector(proj->sector());
 				if (proj->sector()->lotag != 1)
@@ -1263,9 +1263,9 @@ static void weaponcommon_r(DDukeActor *proj)
 		for (k = -3; k < 2; k++)
 		{
 			auto x = EGS(proj->sector(),
-				proj->spr.pos.X + MulScale(k, bcos(proj->spr.ang), 9),
-				proj->spr.pos.Y + MulScale(k, bsin(proj->spr.ang), 9),
-				proj->spr.pos.Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
+				proj->int_pos().X + MulScale(k, bcos(proj->spr.ang), 9),
+				proj->int_pos().Y + MulScale(k, bsin(proj->spr.ang), 9),
+				proj->int_pos().Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
 				proj->spr.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
 
 			if (x)
@@ -1456,9 +1456,9 @@ void movetransports_r(void)
 								ps[p].transporter_hold = 13;
 							}
 
-							ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->spr.pos.X;
-							ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->spr.pos.Y;
-							ps[p].opos.Z = ps[p].pos.Z = Owner->spr.pos.Z - (gs.playerheight - (4 << 8));
+							ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->int_pos().X;
+							ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->int_pos().Y;
+							ps[p].opos.Z = ps[p].pos.Z = Owner->int_pos().Z - (gs.playerheight - (4 << 8));
 
 							ChangeActorSect(act2, Owner->sector());
 							ps[p].setCursector(act2->sector());
@@ -1471,16 +1471,16 @@ void movetransports_r(void)
 					}
 					else break;
 
-					if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 6144)
+					if (onfloorz == 0 && abs(act->int_pos().Z - ps[p].pos.Z) < 6144)
 						if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && PlayerInput(p, SB_JUMP)) ||
 							(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
 						{
-							ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
-							ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
+							ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
+							ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
 
 							if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
-								ps[p].pos.Z = Owner->spr.pos.Z - 6144;
-							else ps[p].pos.Z = Owner->spr.pos.Z + 6144;
+								ps[p].pos.Z = Owner->int_pos().Z - 6144;
+							else ps[p].pos.Z = Owner->int_pos().Z + 6144;
 							ps[p].opos.Z = ps[p].pos.Z;
 
 							ChangeActorSect(act2, Owner->sector());
@@ -1541,8 +1541,8 @@ void movetransports_r(void)
 
 					if (k == 1)
 					{
-						ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
-						ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
+						ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
+						ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
 
 						if (Owner->GetOwner() != Owner)
 							ps[p].transporter_hold = -2;
@@ -1555,8 +1555,8 @@ void movetransports_r(void)
 					}
 					else if (isRRRA() && k == 2)
 					{
-						ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
-						ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
+						ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
+						ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
 
 						if (Owner->GetOwner() != Owner)
 							ps[p].transporter_hold = -2;
@@ -1587,38 +1587,38 @@ void movetransports_r(void)
 
 				{
 					warpspriteto = 0;
-					if (ll && sectlotag == ST_2_UNDERWATER && act2->spr.pos.Z < (sectp->ceilingz + ll))
+					if (ll && sectlotag == ST_2_UNDERWATER && act2->int_pos().Z < (sectp->ceilingz + ll))
 						warpspriteto = 1;
 
-					if (ll && sectlotag == ST_1_ABOVE_WATER && act2->spr.pos.Z > (sectp->floorz - ll))
+					if (ll && sectlotag == ST_1_ABOVE_WATER && act2->int_pos().Z > (sectp->floorz - ll))
 						if (!isRRRA() || (act2->spr.picnum != CHEERBOAT && act2->spr.picnum != HULKBOAT && act2->spr.picnum != MINIONBOAT))
 							warpspriteto = 1;
 
 					if (isRRRA())
 					{
-						if (ll && sectlotag == 161 && act2->spr.pos.Z < (sectp->ceilingz + ll) && warpdir == 1)
+						if (ll && sectlotag == 161 && act2->int_pos().Z < (sectp->ceilingz + ll) && warpdir == 1)
 						{
 							warpspriteto = 1;
-							ll2 = ll - abs(act2->spr.pos.Z - sectp->ceilingz);
+							ll2 = ll - abs(act2->int_pos().Z - sectp->ceilingz);
 						}
-						else if (sectlotag == 161 && act2->spr.pos.Z < (sectp->ceilingz + 1000) && warpdir == 1)
+						else if (sectlotag == 161 && act2->int_pos().Z < (sectp->ceilingz + 1000) && warpdir == 1)
 						{
 							warpspriteto = 1;
 							ll2 = 1;
 						}
-						if (ll && sectlotag == 160 && act2->spr.pos.Z > (sectp->floorz - ll) && warpdir == 2)
+						if (ll && sectlotag == 160 && act2->int_pos().Z > (sectp->floorz - ll) && warpdir == 2)
 						{
 							warpspriteto = 1;
-							ll2 = ll - abs(sectp->floorz - act2->spr.pos.Z);
+							ll2 = ll - abs(sectp->floorz - act2->int_pos().Z);
 						}
-						else if (sectlotag == 160 && act2->spr.pos.Z > (sectp->floorz - 1000) && warpdir == 2)
+						else if (sectlotag == 160 && act2->int_pos().Z > (sectp->floorz - 1000) && warpdir == 2)
 						{
 							warpspriteto = 1;
 							ll2 = 1;
 						}
 					}
 
-					if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 4096))
+					if (sectlotag == 0 && (onfloorz || abs(act2->int_pos().Z - act->int_pos().Z) < 4096))
 					{
 						if (Owner->GetOwner() != Owner && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != 5)
 						{
@@ -1667,7 +1667,7 @@ void movetransports_r(void)
 								{
 									if (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1)
 									{
-										act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), -(act->spr.pos.Z - Owner->sector()->floorz) });
+										act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), -(act->int_pos().Z - Owner->sector()->floorz) });
 										act2->spr.ang = Owner->spr.ang;
 
 										act2->backupang();
@@ -1689,15 +1689,15 @@ void movetransports_r(void)
 								}
 								else
 								{
-									act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
-									act2->set_int_z(Owner->spr.pos.Z + 4096);
+									act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
+									act2->set_int_z(Owner->int_pos().Z + 4096);
 									act2->backupz();
 
 									ChangeActorSect(act2, Owner->sector());
 								}
 								break;
 							case ST_1_ABOVE_WATER:
-								act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
+								act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
 								act2->set_int_z(Owner->sector()->ceilingz + ll);
 								act2->backupz();
 
@@ -1705,7 +1705,7 @@ void movetransports_r(void)
 
 								break;
 							case ST_2_UNDERWATER:
-								act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
+								act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
 								act2->set_int_z(Owner->sector()->floorz - ll);
 								act2->backupz();
 
@@ -1715,7 +1715,7 @@ void movetransports_r(void)
 
 							case 160:
 								if (!isRRRA()) break;
-								act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
+								act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
 								act2->set_int_z(Owner->sector()->ceilingz + ll2);
 								act2->backupz();
 
@@ -1727,7 +1727,7 @@ void movetransports_r(void)
 								break;
 							case 161:
 								if (!isRRRA()) break;
-								act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
+								act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
 								act2->set_int_z(Owner->sector()->floorz - ll);
 								act2->backupz();
 
@@ -1900,7 +1900,7 @@ static void rrra_specialstats()
 				act->spr.extra = 1;
 			}
 			movesprite_ex(act, 0, 0, -300, CLIPMASK0, coll);
-			if (act->sector()->ceilingz + (4 << 8) > act->spr.pos.Z)
+			if (act->sector()->ceilingz + (4 << 8) > act->int_pos().Z)
 			{
 				act->spr.picnum = 0;
 				act->spr.extra = 100;
@@ -1908,7 +1908,7 @@ static void rrra_specialstats()
 		}
 		else if (act->spr.extra == 200)
 		{
-			SetActor(act, { act->spr.pos.X, act->spr.pos.Y, act->sector()->floorz - 10 });
+			SetActor(act, { act->int_pos().X, act->int_pos().Y, act->sector()->floorz - 10 });
 			act->spr.extra = 1;
 			act->spr.picnum = PIG + 11;
 			spawn(act, TRANSPORTERSTAR);
@@ -2132,7 +2132,7 @@ void rr_specialstats()
 		if (act->spr.hitag == 100)
 		{
 			act->add_int_z(4 << 8);
-			if (act->spr.pos.Z >= act->sector()->floorz + 15168)
+			if (act->int_pos().Z >= act->sector()->floorz + 15168)
 				act->set_int_z(act->sector()->floorz + 15168);
 		}
 
@@ -2285,9 +2285,9 @@ void rr_specialstats()
 					if (act2->spr.picnum == RRTILE297)
 					{
 						ps[p].angle.ang = buildang(act2->spr.ang);
-						ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = act2->spr.pos.X;
-						ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = act2->spr.pos.Y;
-						ps[p].opos.Z = ps[p].pos.Z = act2->spr.pos.Z - (36 << 8);
+						ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = act2->int_pos().X;
+						ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = act2->int_pos().Y;
+						ps[p].opos.Z = ps[p].pos.Z = act2->int_pos().Z - (36 << 8);
 						auto pact = ps[p].GetActor();
 						ChangeActorSect(pact, act2->sector());
 						ps[p].setCursector(pact->sector());
@@ -2344,7 +2344,7 @@ static void heavyhbomb(DDukeActor *actor)
 
 	makeitfall(actor);
 
-	if (sectp->lotag != 1 && (!isRRRA() || sectp->lotag != 160) && actor->spr.pos.Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
+	if (sectp->lotag != 1 && (!isRRRA() || sectp->lotag != 160) && actor->int_pos().Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
 	{
 		if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
 		{
@@ -2363,7 +2363,7 @@ static void heavyhbomb(DDukeActor *actor)
 			actor->spr.zvel >>= 2;
 		actor->spr.yvel++;
 	}
-	if (actor->spr.picnum != CHEERBOMB && actor->spr.pos.Z < actor->ceilingz + (16 << 8) && sectp->lotag != 2)
+	if (actor->spr.picnum != CHEERBOMB && actor->int_pos().Z < actor->ceilingz + (16 << 8) && sectp->lotag != 2)
 	{
 		actor->set_int_z(actor->ceilingz + (16 << 8));
 		actor->spr.zvel = 0;
@@ -2424,7 +2424,7 @@ static void heavyhbomb(DDukeActor *actor)
 	if (coll.type == kHitWall)
 	{
 		auto wal = coll.hitWall;
-		fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
+		fi.checkhitwall(actor, wal, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
 
 		int k = getangle(wal->delta());
 
@@ -2490,7 +2490,7 @@ DETONATEB:
 		}
 	}
 	else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && actor->temp_data[0] > 7 && actor->spr.xvel == 0)
-		if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
+		if (cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
 			if (ps[p].ammo_amount[DYNAMITE_WEAPON] < gs.max_ammo_amount[DYNAMITE_WEAPON])
 				if (actor->spr.pal == 0)
 				{
@@ -2687,7 +2687,7 @@ void moveactors_r(void)
 						act->spr.picnum = RRTILE3192;
 						break;
 					case 903:
-						if (act->spr.pos.Z >= sectp->floorz - (8<<8))
+						if (act->int_pos().Z >= sectp->floorz - (8<<8))
 						{
 							deletesprite(act);
 							continue;
@@ -2726,7 +2726,7 @@ void moveactors_r(void)
 				}
 				if (sectp->lotag == 903)
 				{
-					if (act->spr.pos.Z >= sectp->floorz - (4<<8))
+					if (act->int_pos().Z >= sectp->floorz - (4<<8))
 					{
 						deletesprite(act);
 						continue;
@@ -2750,7 +2750,7 @@ void moveactors_r(void)
 					MulScale(act->spr.xvel, bcos(act->spr.ang), 14),
 					MulScale(act->spr.xvel, bsin(act->spr.ang), 14),
 					act->spr.zvel,CLIPMASK0, coll);
-				if (act->spr.pos.Z >= sectp->floorz - (8<<8))
+				if (act->int_pos().Z >= sectp->floorz - (8<<8))
 				{
 					if (sectp->lotag == 1)
 					{
@@ -2831,7 +2831,7 @@ void moveactors_r(void)
 				getglobalz(act);
 				if (sectp->lotag == 1)
 				{
-					SetActor(act, { act->spr.pos.X,act->spr.pos.Y,act->floorz + (16 << 8) });
+					SetActor(act, { act->int_pos().X,act->int_pos().Y,act->floorz + (16 << 8) });
 				}
 				break;
 
@@ -2924,7 +2924,7 @@ void moveexplosions_r(void)  // STATNUM 5
 		{
 		case SHOTGUNSPRITE:
 			if (act->sector()->lotag == 800)
-				if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
+				if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
 				{
 					deletesprite(act);
 					continue;
@@ -3013,7 +3013,7 @@ void moveexplosions_r(void)  // STATNUM 5
 			deletesprite(act);
 			continue;
 		case FEATHER + 1: // feather
-			act->floorz = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
+			act->floorz = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
 			act->set_int_z(act->floorz);
 			if (act->sector()->lotag == 800)
 			{
@@ -3025,7 +3025,7 @@ void moveexplosions_r(void)  // STATNUM 5
 			if (!money(act, BLOODPOOL)) continue;
 
 			if (act->sector()->lotag == 800)
-				if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
+				if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
 				{
 					deletesprite(act);
 					continue;
@@ -3080,7 +3080,7 @@ void moveexplosions_r(void)  // STATNUM 5
 				isRRRA() && (act->spr.picnum == RRTILE2465 || act->spr.picnum == RRTILE2560))) continue;
 
 			if (act->sector()->lotag == 800)
-				if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
+				if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
 				{
 					deletesprite(act);
 					continue;
@@ -3092,7 +3092,7 @@ void moveexplosions_r(void)  // STATNUM 5
 			if (!bloodpool(act, false)) continue;
 
 			if (act->sector()->lotag == 800)
-				if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
+				if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
 				{
 					deletesprite(act);
 				}
@@ -3168,7 +3168,7 @@ void handle_se06_r(DDukeActor *actor)
 				}
 				if (!hulkspawn)
 				{
-					ns = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
+					ns = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
 					if (ns)
 					{
 						ns->spr.cstat = CSTAT_SPRITE_TRANS_FLIP | CSTAT_SPRITE_TRANSLUCENT;
@@ -3397,7 +3397,7 @@ void moveeffectors_r(void)   //STATNUM 3
 		case SE_29_WAVES:
 			act->spr.hitag += 64;
 			l = MulScale(act->spr.yvel, bsin(act->spr.hitag), 12);
-			sc->setfloorz(act->spr.pos.Z + l);
+			sc->setfloorz(act->int_pos().Z + l);
 			break;
 
 		case SE_31_FLOOR_RISE_FALL: // True Drop Floor
@@ -3486,8 +3486,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 	if (a & face_player)
 	{
 		if (ps[pnum].newOwner != nullptr)
-			goalang = getangle(ps[pnum].opos.X - actor->spr.pos.X, ps[pnum].opos.Y - actor->spr.pos.Y);
-		else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
+			goalang = getangle(ps[pnum].opos.X - actor->int_pos().X, ps[pnum].opos.Y - actor->int_pos().Y);
+		else goalang = getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y);
 		angdif = getincangle(actor->spr.ang, goalang) >> 2;
 		if (angdif > -8 && angdif < 0) angdif = 0;
 		actor->spr.ang += angdif;
@@ -3499,8 +3499,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 	if (a & face_player_slow)
 	{
 		if (ps[pnum].newOwner != nullptr)
-			goalang = getangle(ps[pnum].opos.X - actor->spr.pos.X, ps[pnum].opos.Y - actor->spr.pos.Y);
-		else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
+			goalang = getangle(ps[pnum].opos.X - actor->int_pos().X, ps[pnum].opos.Y - actor->int_pos().Y);
+		else goalang = getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y);
 		angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
 		if (angdif > -32 && angdif < 0)
 		{
@@ -3515,8 +3515,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 		if (a & antifaceplayerslow)
 		{
 			if (ps[pnum].newOwner != nullptr)
-				goalang = (getangle(ps[pnum].opos.X - actor->spr.pos.X, ps[pnum].opos.Y - actor->spr.pos.Y) + 1024) & 2047;
-			else goalang = (getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y) + 1024) & 2047;
+				goalang = (getangle(ps[pnum].opos.X - actor->int_pos().X, ps[pnum].opos.Y - actor->int_pos().Y) + 1024) & 2047;
+			else goalang = (getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y) + 1024) & 2047;
 			angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
 			if (angdif > -32 && angdif < 0)
 			{
@@ -3584,7 +3584,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 
 		newx = ps[pnum].pos.X + (ps[pnum].vel.X / 768);
 		newy = ps[pnum].pos.Y + (ps[pnum].vel.Y / 768);
-		goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.pos.Y);
+		goalang = getangle(newx - actor->int_pos().X, newy - actor->int_pos().Y);
 		angdif = getincangle(actor->spr.ang, goalang) >> 2;
 		if (angdif > -8 && angdif < 0) angdif = 0;
 		actor->spr.ang += angdif;
@@ -3592,10 +3592,10 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 
 	if (actor->temp_data[1] == 0 || a == 0)
 	{
-		if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->spr.pos.X) || (actor->opos.Y != actor->spr.pos.Y))
+		if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->int_pos().X) || (actor->opos.Y != actor->int_pos().Y))
 		{
 			actor->backupvec2();
-			SetActor(actor, actor->spr.pos);
+			SetActor(actor, actor->int_pos());
 		}
 		if (badguy(actor) && actor->spr.extra <= 0)
 		{
@@ -3641,34 +3641,34 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 			{
 				if (actor->spr.zvel > 0)
 				{
-					actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
+					actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
 					if (isRRRA())
 					{
-						if (actor->spr.pos.Z > (l - (28 << 8)))
+						if (actor->int_pos().Z > (l - (28 << 8)))
 							actor->set_int_z(l - (28 << 8));
 					}
 					else
 					{
-						if (actor->spr.pos.Z > (l - (30 << 8)))
+						if (actor->int_pos().Z > (l - (30 << 8)))
 							actor->set_int_z(l - (30 << 8));
 					}
 				}
 				else
 				{
-					actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-					if ((actor->spr.pos.Z - l) < (50 << 8))
+					actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+					if ((actor->int_pos().Z - l) < (50 << 8))
 					{
 						actor->set_int_z(l + (50 << 8));
 						actor->spr.zvel = 0;
 					}
 				}
 			}
-			if (actor->spr.zvel > 0 && actor->floorz < actor->spr.pos.Z)
+			if (actor->spr.zvel > 0 && actor->floorz < actor->int_pos().Z)
 				actor->set_int_z(actor->floorz);
 			if (actor->spr.zvel < 0)
 			{
-				l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
-				if ((actor->spr.pos.Z - l) < (66 << 8))
+				l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
+				if ((actor->int_pos().Z - l) < (66 << 8))
 				{
 					actor->set_int_z(l + (66 << 8));
 					actor->spr.zvel >>= 1;
@@ -3676,7 +3676,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 			}
 		}
 		else if (actor->spr.picnum == APLAYER)
-			if ((actor->spr.pos.Z - actor->ceilingz) < (32 << 8))
+			if ((actor->int_pos().Z - actor->ceilingz) < (32 << 8))
 				actor->set_int_z(actor->ceilingz + (32 << 8));
 
 		daxvel = actor->spr.xvel;
@@ -3688,7 +3688,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 			{
 
 				daxvel = -(1024 - xvel);
-				angdif = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
+				angdif = getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y);
 
 				if (xvel < 512)
 				{
@@ -3707,7 +3707,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
 			{
 				if (!*(moveptr + 1))
 				{
-					if (actor->opos.Z != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
+					if (actor->opos.Z != actor->int_pos().Z || (ud.multimode < 2 && ud.player_skill < 2))
 					{
 						if ((actor->temp_data[0] & 1) || ps[pnum].actorsqu == actor) return;
 						else daxvel <<= 1;
@@ -3818,7 +3818,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
 		}
 		else if (actor->sector()->lotag == 802)
 		{
-			if (actor->spr.picnum != APLAYER && badguy(actor) && actor->spr.pos.Z == actor->floorz - FOURSLEIGHT)
+			if (actor->spr.picnum != APLAYER && badguy(actor) && actor->int_pos().Z == actor->floorz - FOURSLEIGHT)
 			{
 				fi.guts(actor, JIBS6, 5, playernum);
 				S_PlayActorSound(SQUISHED, actor);
diff --git a/source/games/duke/src/animatesprites_d.cpp b/source/games/duke/src/animatesprites_d.cpp
index b65102dec..ace64c510 100644
--- a/source/games/duke/src/animatesprites_d.cpp
+++ b/source/games/duke/src/animatesprites_d.cpp
@@ -205,12 +205,12 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 			{
 				int sqa =
 					getangle(
-						OwnerAc->spr.pos.X - ps[screenpeek].pos.X,
-						OwnerAc->spr.pos.Y - ps[screenpeek].pos.Y);
+						OwnerAc->int_pos().X - ps[screenpeek].pos.X,
+						OwnerAc->int_pos().Y - ps[screenpeek].pos.Y);
 				int sqb =
 					getangle(
-						OwnerAc->spr.pos.X - t->pos.X,
-						OwnerAc->spr.pos.Y - t->pos.Y);
+						OwnerAc->int_pos().X - t->pos.X,
+						OwnerAc->int_pos().Y - t->pos.Y);
 
 				if (abs(getincangle(sqa, sqb)) > 512)
 					if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@@ -226,8 +226,8 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				else
 				{
 					t->ang = getangle(x - t->pos.X, y - t->pos.Y);
-					t->pos.X = OwnerAc->spr.pos.X;
-					t->pos.Y = OwnerAc->spr.pos.Y;
+					t->pos.X = OwnerAc->int_pos().X;
+					t->pos.Y = OwnerAc->int_pos().Y;
 					t->pos.X += bcos(t->ang, -10);
 					t->pos.Y += bsin(t->ang, -10);
 				}
@@ -268,7 +268,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				break;
 			}
 
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			if (k > 6)
 			{
@@ -286,7 +286,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				break;
 			}
 
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			if (h->temp_data[0] < 4)
 				k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			else k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
@@ -358,7 +358,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 
 				if (h->GetOwner())
 					newtspr->pos.Z = ps[p].pos.Z - (12 << 8);
-				else newtspr->pos.Z = h->spr.pos.Z - (51 << 8);
+				else newtspr->pos.Z = h->int_pos().Z - (51 << 8);
 				if (ps[p].curr_weapon == HANDBOMB_WEAPON)
 				{
 					newtspr->xrepeat = 10;
@@ -391,7 +391,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				}
 
 				if (t->sectp->lotag == 2) k += 1795 - 1405;
-				else if ((h->floorz - h->spr.pos.Z) > (64 << 8)) k += 60;
+				else if ((h->floorz - h->int_pos().Z) > (64 << 8)) k += 60;
 
 				t->picnum += k;
 				t->pal = ps[p].palookup;
@@ -401,7 +401,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 
 			if (ps[p].on_crane == nullptr && (h->sector()->lotag & 0x7ff) != 1)
 			{
-				l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
+				l = h->int_pos().Z - ps[p].GetActor()->floorz + (3 << 8);
 				if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
 					h->spr.yoffset = (int8_t)(l / (h->spr.yrepeat << 2));
 				else h->spr.yoffset = 0;
@@ -519,7 +519,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 					break;
 
 				case 5:
-					k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+					k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 					k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
 					if (k > 4)
 					{
@@ -529,7 +529,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 					else t->cstat &= ~CSTAT_SPRITE_XFLIP;
 					break;
 				case 7:
-					k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+					k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 					k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 					if (k > 6)
 					{
@@ -578,7 +578,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 							daz = h->floorz;
 
 
-						if ((h->spr.pos.Z - daz) < (8 << 8) && ps[screenpeek].pos.Z < daz)
+						if ((h->int_pos().Z - daz) < (8 << 8) && ps[screenpeek].pos.Z < daz)
 						{
 							auto shadowspr = tsprites.newTSprite();
 							*shadowspr = *t;
@@ -625,7 +625,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 		case LASERLINE:
 			if (!OwnerAc) break;
 			if (t->sectp->lotag == 2) t->pal = 8;
-			t->pos.Z = OwnerAc->spr.pos.Z - (3 << 8);
+			t->pos.Z = OwnerAc->int_pos().Z - (3 << 8);
 			if (gs.lasermode == 2 && ps[screenpeek].heat_on == 0)
 				t->yrepeat = 0;
 			t->shade = -127;
diff --git a/source/games/duke/src/animatesprites_r.cpp b/source/games/duke/src/animatesprites_r.cpp
index f746e6494..381951434 100644
--- a/source/games/duke/src/animatesprites_r.cpp
+++ b/source/games/duke/src/animatesprites_r.cpp
@@ -200,12 +200,12 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 			{
 				int sqa =
 					getangle(
-						OwnerAc->spr.pos.X - ps[screenpeek].pos.X,
-						OwnerAc->spr.pos.Y - ps[screenpeek].pos.Y);
+						OwnerAc->int_pos().X - ps[screenpeek].pos.X,
+						OwnerAc->int_pos().Y - ps[screenpeek].pos.Y);
 				int sqb =
 					getangle(
-						OwnerAc->spr.pos.X - t->pos.X,
-						OwnerAc->spr.pos.Y - t->pos.Y);
+						OwnerAc->int_pos().X - t->pos.X,
+						OwnerAc->int_pos().Y - t->pos.Y);
 
 				if (abs(getincangle(sqa, sqb)) > 512)
 					if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@@ -220,8 +220,8 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				else
 				{
 					t->ang = getangle(x - t->pos.X, y - t->pos.Y);
-					t->pos.X = OwnerAc->spr.pos.X;
-					t->pos.Y = OwnerAc->spr.pos.Y;
+					t->pos.X = OwnerAc->int_pos().X;
+					t->pos.Y = OwnerAc->int_pos().Y;
 					t->pos.X += bcos(t->ang, -10);
 					t->pos.Y += bsin(t->ang, -10);
 				}
@@ -262,7 +262,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				}
 				else if (OwnerAc->spr.picnum == MAMA)
 				{
-					k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+					k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 					k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
 					if (k > 4)
 					{
@@ -280,7 +280,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 			break;
 		case EMPTYBIKE:
 			if (!isRRRA()) goto default_case;
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			if (k > 6)
 			{
@@ -292,7 +292,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 			break;
 		case EMPTYBOAT:
 			if (!isRRRA()) goto default_case;
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			if (k > 6)
 			{
@@ -303,7 +303,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 			t->picnum = EMPTYBOAT + k;
 			break;
 		case RPG:
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			if (k > 6)
 			{
@@ -315,7 +315,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 			break;
 		case RPG2:
 			if (!isRRRA()) goto default_case;
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			if (k > 6)
 			{
@@ -328,7 +328,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 
 		case RECON:
 
-			k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+			k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 			if (h->temp_data[0] < 4)
 				k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 			else k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
@@ -398,7 +398,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 
 				if (h->GetOwner())
 					newtspr->pos.Z = ps[p].pos.Z - (12 << 8);
-				else newtspr->pos.Z = h->spr.pos.Z - (51 << 8);
+				else newtspr->pos.Z = h->int_pos().Z - (51 << 8);
 				if (ps[p].curr_weapon == HANDBOMB_WEAPON)
 				{
 					newtspr->xrepeat = 10;
@@ -435,7 +435,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 				}
 
 				if (t->sectp->lotag == 2) k += 1795 - 1405;
-				else if ((h->floorz - h->spr.pos.Z) > (64 << 8)) k += 60;
+				else if ((h->floorz - h->int_pos().Z) > (64 << 8)) k += 60;
 
 				t->picnum += k;
 				t->pal = ps[p].palookup;
@@ -445,7 +445,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 
 			if (ps[p].on_crane == nullptr && (h->sector()->lotag & 0x7ff) != 1)
 			{
-				l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
+				l = h->int_pos().Z - ps[p].GetActor()->floorz + (3 << 8);
 				if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
 					h->spr.yoffset = (int8_t)(l / (h->spr.yrepeat << 2));
 				else h->spr.yoffset = 0;
@@ -651,7 +651,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 					break;
 
 				case 5:
-					k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+					k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 					k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
 					if (k > 4)
 					{
@@ -661,7 +661,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 					else t->cstat &= ~CSTAT_SPRITE_XFLIP;
 					break;
 				case 7:
-					k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+					k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 					k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
 					if (k > 6)
 					{
@@ -678,7 +678,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 					bg = badguy(h);
 					if (bg && h->spr.statnum == 2 && h->spr.extra > 0)
 					{
-						k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
+						k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
 						k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
 						if (k > 4)
 						{
@@ -733,7 +733,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
 						else
 							daz = h->floorz;
 
-						if ((h->spr.pos.Z - daz) < (8 << 8))
+						if ((h->int_pos().Z - daz) < (8 << 8))
 							if (ps[screenpeek].pos.Z < daz)
 							{
 								auto shadowspr = tsprites.newTSprite();
diff --git a/source/games/duke/src/game_misc.cpp b/source/games/duke/src/game_misc.cpp
index e0257939e..a5f0e9fa9 100644
--- a/source/games/duke/src/game_misc.cpp
+++ b/source/games/duke/src/game_misc.cpp
@@ -420,8 +420,8 @@ bool GameInterface::DrawAutomapPlayer(int mx, int my, int cposx, int cposy, int
 			col = PalEntry(0, 170, 170);
 			if (act->spr.cstat & CSTAT_SPRITE_BLOCK) col = PalEntry(170, 0, 170);
 
-			sprx = act->spr.pos.X;
-			spry = act->spr.pos.Y;
+			sprx = act->int_pos().X;
+			spry = act->int_pos().Y;
 
 			if ((act->spr.cstat & CSTAT_SPRITE_BLOCK_ALL) != 0) switch (act->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK)
 			{
diff --git a/source/games/duke/src/gameexec.cpp b/source/games/duke/src/gameexec.cpp
index 6618f5357..fe0f32c0d 100644
--- a/source/games/duke/src/gameexec.cpp
+++ b/source/games/duke/src/gameexec.cpp
@@ -1172,16 +1172,16 @@ void DoActor(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor,
 	switch (lLabelID)
 	{
 	case ACTOR_X:
-		/*if (bSet) act->spr.pos.X = lValue;
-		else*/ SetGameVarID(lVar2, act->spr.pos.X, sActor, sPlayer);
+		/*if (bSet) act->int_pos().X = lValue;
+		else*/ SetGameVarID(lVar2, act->int_pos().X, sActor, sPlayer);
 		break;
 	case ACTOR_Y:
-		/*if (bSet) act->spr.pos.Y = lValue;
-		else*/ SetGameVarID(lVar2, act->spr.pos.Y, sActor, sPlayer);
+		/*if (bSet) act->int_pos().Y = lValue;
+		else*/ SetGameVarID(lVar2, act->int_pos().Y, sActor, sPlayer);
 		break;
 	case ACTOR_Z:
-		/*if (bSet) act->spr.pos.Z = lValue;
-		else*/ SetGameVarID(lVar2, act->spr.pos.Z, sActor, sPlayer);
+		/*if (bSet) act->int_pos().Z = lValue;
+		else*/ SetGameVarID(lVar2, act->int_pos().Z, sActor, sPlayer);
 		break;
 	case ACTOR_CSTAT:
 		if (bSet) act->spr.cstat = ESpriteFlags::FromInt(lValue);
@@ -1471,7 +1471,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
 	if (ps[pnum].holoduke_on != nullptr && !isRR())
 	{
 		tosee = ps[pnum].holoduke_on;
-		j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((32 << 8) - 1)), actor->sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z, tosee->sector());
+		j = cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & ((32 << 8) - 1)), actor->sector(), tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().Z, tosee->sector());
 
 		if (j == 0)
 		{
@@ -1483,7 +1483,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
 	else tosee = ps[pnum].GetActor();	// holoduke not on. look for player
 
 	// can they see player, (or player's holoduke)
-	j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((47 << 8))), actor->sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - ((isRR()? 28 : 24) << 8), tosee->sector());
+	j = cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & ((47 << 8))), actor->sector(), tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().Z - ((isRR()? 28 : 24) << 8), tosee->sector());
 
 	if (j == 0)
 	{
@@ -1495,8 +1495,8 @@ static bool ifcansee(DDukeActor* actor, int pnum)
 	{
 		// else, they did see it.
 		// save where we were looking..
-		actor->ovel.X = tosee->spr.pos.X;
-		actor->ovel.Y = tosee->spr.pos.Y;
+		actor->ovel.X = tosee->int_pos().X;
+		actor->ovel.Y = tosee->int_pos().Y;
 	}
 
 	if (j == 1 && (actor->spr.statnum == STAT_ACTOR || actor->spr.statnum == STAT_STANDABLE))
@@ -1534,12 +1534,12 @@ int ParseState::parse(void)
 		parseifelse(ifcanshoottarget(g_ac, g_p, g_x));
 		break;
 	case concmd_ifcanseetarget:
-		j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - ((krand() & 41) << 8), g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z/*-((krand()&41)<<8)*/, ps[g_p].GetActor()->sector());
+		j = cansee(g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z - ((krand() & 41) << 8), g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z/*-((krand()&41)<<8)*/, ps[g_p].GetActor()->sector());
 		parseifelse(j);
 		if (j) g_ac->timetosleep = SLEEPTIME;
 		break;
 	case concmd_ifnocover:
-		j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z, g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z, ps[g_p].GetActor()->sector());
+		j = cansee(g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z, g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z, ps[g_p].GetActor()->sector());
 		parseifelse(j);
 		if (j) g_ac->timetosleep = SLEEPTIME;
 		break;
@@ -2183,7 +2183,7 @@ int ParseState::parse(void)
 				else s = (krand()%3);
 
 				auto spawned = EGS(g_ac->sector(),
-					g_ac->spr.pos.X + (krand() & 255) - 128, g_ac->spr.pos.Y + (krand() & 255) - 128, g_ac->spr.pos.Z - (8 << 8) - (krand() & 8191),
+					g_ac->int_pos().X + (krand() & 255) - 128, g_ac->int_pos().Y + (krand() & 255) - 128, g_ac->int_pos().Z - (8 << 8) - (krand() & 8191),
 					dnum + s, g_ac->spr.shade, 32 + (krand() & 15), 32 + (krand() & 15),
 					krand() & 2047, (krand() & 127) + 32, -(krand() & 2047), g_ac, 5);
 				if (spawned)
@@ -2290,10 +2290,10 @@ int ParseState::parse(void)
 		parseifelse(ud.coop || numplayers > 2);
 		break;
 	case concmd_ifonmud:
-		parseifelse(abs(g_ac->spr.pos.Z - g_ac->sector()->floorz) < (32 << 8) && g_ac->sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
+		parseifelse(abs(g_ac->int_pos().Z - g_ac->sector()->floorz) < (32 << 8) && g_ac->sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
 		break;
 	case concmd_ifonwater:
-		parseifelse( abs(g_ac->spr.pos.Z-g_ac->sector()->floorz) < (32<<8) && g_ac->sector()->lotag == ST_1_ABOVE_WATER);
+		parseifelse( abs(g_ac->int_pos().Z-g_ac->sector()->floorz) < (32<<8) && g_ac->sector()->lotag == ST_1_ABOVE_WATER);
 		break;
 	case concmd_ifmotofast:
 		parseifelse(ps[g_p].MotoSpeed > 60);
@@ -2415,7 +2415,7 @@ int ParseState::parse(void)
 					j = 1;
 			else if( (l& prunning) && s >= 8 && PlayerInput(g_p, SB_RUN) )
 					j = 1;
-			else if( (l& phigher) && ps[g_p].pos.Z < (g_ac->spr.pos.Z-(48<<8)) )
+			else if( (l& phigher) && ps[g_p].pos.Z < (g_ac->int_pos().Z-(48<<8)) )
 					j = 1;
 			else if( (l& pwalkingback) && s <= -8 && !(PlayerInput(g_p, SB_RUN)) )
 					j = 1;
@@ -2440,7 +2440,7 @@ int ParseState::parse(void)
 				if (g_ac->isPlayer() && ud.multimode > 1)
 					j = getincangle(ps[otherp].angle.ang.asbuild(), getangle(ps[g_p].pos.X - ps[otherp].pos.X, ps[g_p].pos.Y - ps[otherp].pos.Y));
 				else
-					j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_ac->spr.pos.X - ps[g_p].pos.X, g_ac->spr.pos.Y - ps[g_p].pos.Y));
+					j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_ac->int_pos().X - ps[g_p].pos.X, g_ac->int_pos().Y - ps[g_p].pos.Y));
 
 				if( j > -128 && j < 128 )
 					j = 1;
@@ -2497,7 +2497,7 @@ int ParseState::parse(void)
 		if( g_ac->sector()->lotag == 0 )
 		{
 			HitInfo hit{};
-			neartag({ g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - (32 << 8) }, g_ac->sector(), g_ac->spr.ang, hit, 768, 1);
+			neartag({ g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z - (32 << 8) }, g_ac->sector(), g_ac->spr.ang, hit, 768, 1);
 			auto sectp = hit.hitSector;
 			if (sectp)
 			{
@@ -2549,11 +2549,11 @@ int ParseState::parse(void)
 		break;
 	case concmd_iffloordistl:
 		insptr++;
-		parseifelse( (g_ac->floorz - g_ac->spr.pos.Z) <= ((*insptr)<<8));
+		parseifelse( (g_ac->floorz - g_ac->int_pos().Z) <= ((*insptr)<<8));
 		break;
 	case concmd_ifceilingdistl:
 		insptr++;
-		parseifelse( ( g_ac->spr.pos.Z - g_ac->ceilingz ) <= ((*insptr)<<8));
+		parseifelse( ( g_ac->int_pos().Z - g_ac->ceilingz ) <= ((*insptr)<<8));
 		break;
 	case concmd_palfrom:
 		insptr++;
@@ -2804,7 +2804,7 @@ int ParseState::parse(void)
 	case concmd_pstomp:
 		insptr++;
 		if( ps[g_p].knee_incs == 0 && ps[g_p].GetActor()->spr.xrepeat >= (isRR()? 9: 40) )
-			if( cansee(g_ac->spr.pos.X,g_ac->spr.pos.Y,g_ac->spr.pos.Z-(4<<8),g_ac->sector(),ps[g_p].pos.X,ps[g_p].pos.Y,ps[g_p].pos.Z+(16<<8),ps[g_p].GetActor()->sector()) )
+			if( cansee(g_ac->int_pos().X,g_ac->int_pos().Y,g_ac->int_pos().Z-(4<<8),g_ac->sector(),ps[g_p].pos.X,ps[g_p].pos.Y,ps[g_p].pos.Z+(16<<8),ps[g_p].GetActor()->sector()) )
 		{
 			ps[g_p].knee_incs = 1;
 			if(ps[g_p].weapon_pos == 0)
@@ -2818,16 +2818,16 @@ int ParseState::parse(void)
 
 		j = 0;
 
-		updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y + 108, &s1);
+		updatesector(g_ac->int_pos().X + 108, g_ac->int_pos().Y + 108, &s1);
 		if (s1 == g_ac->sector())
 		{
-			updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y - 108, &s1);
+			updatesector(g_ac->int_pos().X - 108, g_ac->int_pos().Y - 108, &s1);
 			if (s1 == g_ac->sector())
 			{
-				updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y - 108, &s1);
+				updatesector(g_ac->int_pos().X + 108, g_ac->int_pos().Y - 108, &s1);
 				if (s1 == g_ac->sector())
 				{
-					updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y + 108, &s1);
+					updatesector(g_ac->int_pos().X - 108, g_ac->int_pos().Y + 108, &s1);
 					if (s1 == g_ac->sector())
 						j = 1;
 				}
@@ -3142,7 +3142,7 @@ int ParseState::parse(void)
 		i = *(insptr++);	// ID of def
 
 		// g_ac->lastvx and lastvy are last known location of target.
-		ang = getangle(g_ac->ovel.X - g_ac->spr.pos.X, g_ac->ovel.Y - g_ac->spr.pos.Y);
+		ang = getangle(g_ac->ovel.X - g_ac->int_pos().X, g_ac->ovel.Y - g_ac->int_pos().Y);
 		SetGameVarID(i, ang, g_ac, g_p);
 		break;
 	}
diff --git a/source/games/duke/src/inlines.h b/source/games/duke/src/inlines.h
index 8dc04d343..384535fcf 100644
--- a/source/games/duke/src/inlines.h
+++ b/source/games/duke/src/inlines.h
@@ -97,24 +97,24 @@ inline int checkcursectnums(sectortype* se)
 inline int ldist(DDukeActor* s1, DDukeActor* s2)
 {
 	int vx, vy;
-	vx = s1->spr.pos.X - s2->spr.pos.X;
-	vy = s1->spr.pos.Y - s2->spr.pos.Y;
+	vx = s1->int_pos().X - s2->int_pos().X;
+	vy = s1->int_pos().Y - s2->int_pos().Y;
 	return(FindDistance2D(vx, vy) + 1);
 }
 
 inline int ldist(const DDukeActor* s1, const tspritetype* s2)
 {
 	int vx, vy;
-	vx = s1->spr.pos.X - s2->pos.X;
-	vy = s1->spr.pos.Y - s2->pos.Y;
+	vx = s1->int_pos().X - s2->pos.X;
+	vy = s1->int_pos().Y - s2->pos.Y;
 	return(FindDistance2D(vx, vy) + 1);
 }
 inline int dist(DDukeActor* s1, DDukeActor* s2)
 {
 	int vx, vy, vz;
-	vx = s1->spr.pos.X - s2->spr.pos.X;
-	vy = s1->spr.pos.Y - s2->spr.pos.Y;
-	vz = s1->spr.pos.Z - s2->spr.pos.Z;
+	vx = s1->int_pos().X - s2->int_pos().X;
+	vy = s1->int_pos().Y - s2->int_pos().Y;
+	vz = s1->int_pos().Z - s2->int_pos().Z;
 	return(FindDistance3D(vx, vy, vz));
 }
 
diff --git a/source/games/duke/src/noise.cpp b/source/games/duke/src/noise.cpp
index 568db99c6..c9d04062e 100644
--- a/source/games/duke/src/noise.cpp
+++ b/source/games/duke/src/noise.cpp
@@ -52,8 +52,8 @@ int wakeup(DDukeActor* actor, int snum)
 
 	radius = p->noise_radius;
 
-	if (p->noise.X - radius < actor->spr.pos.X && p->noise.X + radius > actor->spr.pos.X
-		&& p->noise.Y - radius < actor->spr.pos.Y && p->noise.Y + radius > actor->spr.pos.Y)
+	if (p->noise.X - radius < actor->int_pos().X && p->noise.X + radius > actor->int_pos().X
+		&& p->noise.Y - radius < actor->int_pos().Y && p->noise.Y + radius > actor->int_pos().Y)
 		return 1;
 	return 0;
 }
diff --git a/source/games/duke/src/player.cpp b/source/games/duke/src/player.cpp
index bd000aaf6..8818b3b5c 100644
--- a/source/games/duke/src/player.cpp
+++ b/source/games/duke/src/player.cpp
@@ -174,9 +174,9 @@ int hits(DDukeActor* actor)
 	if (actor->isPlayer()) zoff = isRR() ? PHEIGHT_RR : PHEIGHT_DUKE;
 	else zoff = 0;
 
-	auto pos = actor->spr.pos;
+	auto pos = actor->int_pos();
 	hitscan(pos.withZOffset(-zoff), actor->sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
-	return (FindDistance2D(hit.hitpos.vec2 - actor->spr.pos.vec2));
+	return (FindDistance2D(hit.hitpos.vec2 - actor->int_pos().vec2));
 }
 
 //---------------------------------------------------------------------------
@@ -195,14 +195,14 @@ int hitasprite(DDukeActor* actor, DDukeActor** hitsp)
 	else if (actor->spr.picnum == TILE_APLAYER) zoff = isRR() ? PHEIGHT_RR : PHEIGHT_DUKE;
 	else zoff = 0;
 
-	auto pos = actor->spr.pos;
+	auto pos = actor->int_pos();
 	hitscan(pos.withZOffset(-zoff), actor->sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
 	if (hitsp) *hitsp = hit.actor();
 
 	if (hit.hitWall != nullptr && (hit.hitWall->cstat & CSTAT_WALL_MASKED) && badguy(actor))
 		return((1 << 30));
 
-	return (FindDistance2D(hit.hitpos.vec2 - actor->spr.pos.vec2));
+	return (FindDistance2D(hit.hitpos.vec2 - actor->int_pos().vec2));
 }
 
 //---------------------------------------------------------------------------
@@ -335,8 +335,8 @@ DDukeActor* aim(DDukeActor* actor, int aang)
 						if (gotfreezer && act->spr.pal == 1) continue;
 					}
 
-					xv = (act->spr.pos.X - actor->spr.pos.X);
-					yv = (act->spr.pos.Y - actor->spr.pos.Y);
+					xv = (act->int_pos().X - actor->int_pos().X);
+					yv = (act->int_pos().Y - actor->int_pos().Y);
 
 					if ((dy1 * xv) <= (dx1 * yv))
 						if ((dy2 * xv) >= (dx2 * yv))
@@ -345,10 +345,10 @@ DDukeActor* aim(DDukeActor* actor, int aang)
 							if (sdist > 512 && sdist < smax)
 							{
 								if (actor->isPlayer())
-									a = (abs(Scale(act->spr.pos.Z - actor->spr.pos.Z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
+									a = (abs(Scale(act->int_pos().Z - actor->int_pos().Z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
 								else a = 1;
 
-								cans = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (32 << 8), actor->sector());
+								cans = cansee(act->int_pos().X, act->int_pos().Y, act->int_pos().Z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (32 << 8), actor->sector());
 
 								if (a && cans)
 								{
@@ -507,8 +507,8 @@ void footprints(int snum)
 			while (auto act = it.Next())
 			{
 				if (act->spr.picnum == TILE_FOOTPRINTS || act->spr.picnum == TILE_FOOTPRINTS2 || act->spr.picnum == TILE_FOOTPRINTS3 || act->spr.picnum == TILE_FOOTPRINTS4)
-					if (abs(act->spr.pos.X - p->pos.X) < 384)
-						if (abs(act->spr.pos.Y - p->pos.Y) < 384)
+					if (abs(act->int_pos().X - p->pos.X) < 384)
+						if (abs(act->int_pos().Y - p->pos.Y) < 384)
 						{
 							j = 1;
 							break;
@@ -1059,7 +1059,7 @@ void shootbloodsplat(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
 					spawned->set_int_pos(hit.hitpos);
 					spawned->spr.cstat |= randomXFlip();
 					ssp(spawned, CLIPMASK0);
-					SetActor(spawned, spawned->spr.pos);
+					SetActor(spawned, spawned->int_pos());
 					if (actor->spr.picnum == OOZFILTER || actor->spr.picnum == NEWBEAST)
 						spawned->spr.pal = 6;
 				}
diff --git a/source/games/duke/src/player_d.cpp b/source/games/duke/src/player_d.cpp
index 187046ab7..34005ef63 100644
--- a/source/games/duke/src/player_d.cpp
+++ b/source/games/duke/src/player_d.cpp
@@ -241,8 +241,8 @@ static void shootknee(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
 	{
 		int x;
 		auto pactor = ps[findplayer(actor, &x)].GetActor();
-		zvel = ((pactor->spr.pos.Z - sz) << 8) / (x + 1);
-		sa = getangle(pactor->spr.pos.X - sx, pactor->spr.pos.Y - sy);
+		zvel = ((pactor->int_pos().Z - sz) << 8) / (x + 1);
+		sa = getangle(pactor->int_pos().X - sx, pactor->int_pos().Y - sy);
 	}
 
 	hitscan({ sx, sy, sz }, sectp, { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
@@ -346,8 +346,8 @@ static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa
 				dal -= (8 << 8);
 				break;
 			}
-			zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
-			sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+			zvel = ((aimed->int_pos().Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
+			sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 
 		if (isWW2GI())
@@ -592,8 +592,8 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
 		if (aimed)
 		{
 			int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
-			zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
-			sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+			zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
+			sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 		else
 			zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@@ -690,9 +690,9 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
 		if (aimed)
 		{
 			int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
-			zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
+			zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
 			if (aimed->spr.picnum != RECON)
-				sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+				sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 		else zvel = -MulScale(ps[p].horizon.sum().asq16(), 81, 16);
 		if (atwith == RPG)
@@ -930,8 +930,8 @@ static void shootgrowspark(DDukeActor* actor, int p, int sx, int sy, int sz, int
 				dal -= (8 << 8);
 				break;
 			}
-			zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
-			sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+			zvel = ((aimed->int_pos().Z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
+			sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 		else
 		{
@@ -1027,9 +1027,9 @@ void shoot_d(DDukeActor* actor, int atwith)
 	else
 	{
 		sa = actor->spr.ang;
-		sx = actor->spr.pos.X;
-		sy = actor->spr.pos.Y;
-		sz = actor->spr.pos.Z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
+		sx = actor->int_pos().X;
+		sy = actor->int_pos().Y;
+		sz = actor->int_pos().Z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
 		if (actor->spr.picnum != ROTATEGUN)
 		{
 			sz -= (7 << 8);
@@ -1139,8 +1139,8 @@ void shoot_d(DDukeActor* actor, int atwith)
 			if (aimed)
 			{
 				dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1);
-				zvel = ((aimed->spr.pos.Z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
-				sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+				zvel = ((aimed->int_pos().Z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
+				sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 			}
 			else zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
 		}
@@ -2026,7 +2026,7 @@ int operateTripbomb(int snum)
 	while ((act = it.Next()))
 	{
 		if (!actorflag(act, SFLAG_BLOCK_TRIPBOMB) &&
-			abs(act->spr.pos.Z - hit.hitpos.Z) < (12 << 8) && ((act->spr.pos.X - hit.hitpos.X) * (act->spr.pos.X - hit.hitpos.X) + (act->spr.pos.Y - hit.hitpos.Y) * (act->spr.pos.Y - hit.hitpos.Y)) < (290 * 290))
+			abs(act->int_pos().Z - hit.hitpos.Z) < (12 << 8) && ((act->int_pos().X - hit.hitpos.X) * (act->int_pos().X - hit.hitpos.X) + (act->int_pos().Y - hit.hitpos.Y) * (act->int_pos().Y - hit.hitpos.Y)) < (290 * 290))
 			return 0;
 	}
 
@@ -2773,9 +2773,9 @@ void processinput_d(int snum)
 			p->footprintcount = 0;
 			p->spritebridge = 1;
 		}
-		else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.pos.Z - clz.actor()->spr.pos.Z) < (84 << 8))
+		else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->int_pos().Z - clz.actor()->int_pos().Z) < (84 << 8))
 		{
-			j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
+			j = getangle(clz.actor()->int_pos().X - p->pos.X, clz.actor()->int_pos().Y - p->pos.Y);
 			p->vel.X -= bcos(j, 4);
 			p->vel.Y -= bsin(j, 4);
 		}
diff --git a/source/games/duke/src/player_r.cpp b/source/games/duke/src/player_r.cpp
index 1a24582af..518e81576 100644
--- a/source/games/duke/src/player_r.cpp
+++ b/source/games/duke/src/player_r.cpp
@@ -99,8 +99,8 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
 	{
 		int x;
 		auto pspr = ps[findplayer(actor, &x)].GetActor();
-		zvel = ((pspr->spr.pos.Z - sz) << 8) / (x + 1);
-		sa = getangle(pspr->spr.pos.X - sx, pspr->spr.pos.Y - sy);
+		zvel = ((pspr->int_pos().Z - sz) << 8) / (x + 1);
+		sa = getangle(pspr->int_pos().X - sx, pspr->int_pos().Y - sy);
 	}
 
 	hitscan({ sx, sy, sz }, sectp, { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
@@ -115,8 +115,8 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
 				&& effector->spr.lotag == SE_7_TELEPORT)
 			{
 				int nx, ny, nz;
-				nx = hit.hitpos.X + (effector->GetOwner()->spr.pos.X - effector->spr.pos.X);
-				ny = hit.hitpos.Y + (effector->GetOwner()->spr.pos.Y - effector->spr.pos.Y);
+				nx = hit.hitpos.X + (effector->GetOwner()->int_pos().X - effector->int_pos().X);
+				ny = hit.hitpos.Y + (effector->GetOwner()->int_pos().Y - effector->int_pos().Y);
 				if (hit.hitSector->lotag == 161)
 				{
 					nz = effector->GetOwner()->sector()->floorz;
@@ -215,8 +215,8 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
 		if (aimed)
 		{
 			int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (5 << 8);
-			zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
-			sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+			zvel = ((aimed->int_pos().Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
+			sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 
 		if (atwith == SHOTSPARK1)
@@ -270,8 +270,8 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
 				&& effector->spr.lotag == SE_7_TELEPORT)
 			{
 				int nx, ny, nz;
-				nx = hit.hitpos.X + (effector->GetOwner()->spr.pos.X - effector->spr.pos.X);
-				ny = hit.hitpos.Y + (effector->GetOwner()->spr.pos.Y - effector->spr.pos.Y);
+				nx = hit.hitpos.X + (effector->GetOwner()->int_pos().X - effector->int_pos().X);
+				ny = hit.hitpos.Y + (effector->GetOwner()->int_pos().Y - effector->int_pos().Y);
 				if (hit.hitSector->lotag == 161)
 				{
 					nz = effector->GetOwner()->sector()->floorz;
@@ -509,8 +509,8 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
 		if (aimed)
 		{
 			int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
-			zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
-			sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+			zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
+			sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 		else
 		{
@@ -624,9 +624,9 @@ static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
 					act90 = aimed;
 			}
 			int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
-			zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
+			zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
 			if (aimed->spr.picnum != RECON)
-				sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+				sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 		else zvel = -MulScale(ps[p].horizon.sum().asq16(), 81, 16);
 		if (atwith == RPG)
@@ -776,8 +776,8 @@ static void shootwhip(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
 		if (aimed)
 		{
 			int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
-			zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
-			sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
+			zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
+			sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
 		}
 		else
 			zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@@ -846,9 +846,9 @@ void shoot_r(DDukeActor* actor, int atwith)
 	{
 		p = -1;
 		sa = actor->spr.ang;
-		sx = actor->spr.pos.X;
-		sy = actor->spr.pos.Y;
-		sz = actor->spr.pos.Z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
+		sx = actor->int_pos().X;
+		sy = actor->int_pos().Y;
+		sz = actor->int_pos().Z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
 		sz -= (7 << 8);
 		if (badguy(actor))
 		{
@@ -3380,7 +3380,7 @@ void processinput_r(int snum)
 		while (auto act2 = it.Next())
 		{
 			if (act2->spr.picnum == RRTILE380)
-				if (act2->spr.pos.Z - (8 << 8) < p->pos.Z)
+				if (act2->int_pos().Z - (8 << 8) < p->pos.Z)
 					psectlotag = 2;
 		}
 	}
@@ -3473,9 +3473,9 @@ void processinput_r(int snum)
 		{
 			doVehicleHit();
 		}
-		else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.pos.Z - clz.actor()->spr.pos.Z) < (84 << 8))
+		else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->int_pos().Z - clz.actor()->int_pos().Z) < (84 << 8))
 		{
-			int j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
+			int j = getangle(clz.actor()->int_pos().X - p->pos.X, clz.actor()->int_pos().Y - p->pos.Y);
 			p->vel.X -= bcos(j, 4);
 			p->vel.Y -= bsin(j, 4);
 		}
@@ -3486,9 +3486,9 @@ void processinput_r(int snum)
 				p->stairs = 10;
 				if ((actions & SB_CROUCH) && !p->OnMotorcycle)
 				{
-					cz = clz.actor()->spr.pos.Z;
+					cz = clz.actor()->int_pos().Z;
 					chz.setNone();
-					fz = clz.actor()->spr.pos.Z + (4 << 8);
+					fz = clz.actor()->int_pos().Z + (4 << 8);
 				}
 			}
 			else
@@ -4047,8 +4047,8 @@ void OnMotorcycle(struct player_struct *p, DDukeActor* motosprite)
 	{
 		if (motosprite)
 		{
-			p->pos.X = motosprite->spr.pos.X;
-			p->pos.Y = motosprite->spr.pos.Y;
+			p->pos.X = motosprite->int_pos().X;
+			p->pos.Y = motosprite->int_pos().Y;
 			p->angle.ang = buildang(motosprite->spr.ang);
 			p->ammo_amount[MOTORCYCLE_WEAPON] = motosprite->saved_ammo;
 			deletesprite(motosprite);
@@ -4127,8 +4127,8 @@ void OnBoat(struct player_struct *p, DDukeActor* boat)
 	{
 		if (boat)
 		{
-			p->pos.X = boat->spr.pos.X;
-			p->pos.Y = boat->spr.pos.Y;
+			p->pos.X = boat->int_pos().X;
+			p->pos.Y = boat->int_pos().Y;
 			p->angle.ang = buildang(boat->spr.ang);
 			p->ammo_amount[BOAT_WEAPON] = boat->saved_ammo;
 			deletesprite(boat);
diff --git a/source/games/duke/src/premap.cpp b/source/games/duke/src/premap.cpp
index c1c48052c..edf494eb8 100644
--- a/source/games/duke/src/premap.cpp
+++ b/source/games/duke/src/premap.cpp
@@ -615,9 +615,9 @@ void resetpspritevars(int g)
 			firsty = ps[0].pos.Y;
 		}
 
-		po[numplayersprites].opos.X = act->spr.pos.X;
-		po[numplayersprites].opos.Y = act->spr.pos.Y;
-		po[numplayersprites].opos.Z = act->spr.pos.Z;
+		po[numplayersprites].opos.X = act->int_pos().X;
+		po[numplayersprites].opos.Y = act->int_pos().Y;
+		po[numplayersprites].opos.Z = act->int_pos().Z;
 		po[numplayersprites].oa = act->spr.ang;
 		po[numplayersprites].os = act->sector();
 
@@ -659,13 +659,13 @@ void resetpspritevars(int g)
 			ps[j].frag_ps = j;
 			act->SetOwner(act);
 
-			ps[j].bobpos.X = ps[j].opos.X = ps[j].pos.X = act->spr.pos.X;
-			ps[j].bobpos.Y = ps[j].opos.Y = ps[j].pos.Y = act->spr.pos.Y;
-			ps[j].opos.Z = ps[j].pos.Z = act->spr.pos.Z;
+			ps[j].bobpos.X = ps[j].opos.X = ps[j].pos.X = act->int_pos().X;
+			ps[j].bobpos.Y = ps[j].opos.Y = ps[j].pos.Y = act->int_pos().Y;
+			ps[j].opos.Z = ps[j].pos.Z = act->int_pos().Z;
 			act->backuppos();
 			ps[j].angle.oang = ps[j].angle.ang = buildang(act->spr.ang);
 
-			updatesector(act->spr.pos.X, act->spr.pos.Y, &ps[j].cursector);
+			updatesector(act->int_pos().X, act->int_pos().Y, &ps[j].cursector);
 
 			j = connectpoint2[j];
 
@@ -879,8 +879,8 @@ static void SpawnPortals()
 							sectortype* s1 = act->sector(), *s2 = act2->sector();
 							s1->portalflags = PORTAL_SECTOR_FLOOR;
 							s2->portalflags = PORTAL_SECTOR_CEILING;
-							s1->portalnum = portalAdd(PORTAL_SECTOR_FLOOR, sectnum(s2), act2->spr.pos.X - act->spr.pos.X, act2->spr.pos.Y - act->spr.pos.Y, act->spr.hitag);
-							s2->portalnum = portalAdd(PORTAL_SECTOR_CEILING, sectnum(s1), act->spr.pos.X - act2->spr.pos.X, act->spr.pos.Y - act2->spr.pos.Y, act->spr.hitag);
+							s1->portalnum = portalAdd(PORTAL_SECTOR_FLOOR, sectnum(s2), act2->int_pos().X - act->int_pos().X, act2->int_pos().Y - act->int_pos().Y, act->spr.hitag);
+							s2->portalnum = portalAdd(PORTAL_SECTOR_CEILING, sectnum(s1), act->int_pos().X - act2->int_pos().X, act->int_pos().Y - act2->int_pos().Y, act->spr.hitag);
 							processedTags.Push(act->spr.hitag);
 						}
 						else
diff --git a/source/games/duke/src/premap_d.cpp b/source/games/duke/src/premap_d.cpp
index f95a4db6b..c27a7e8f4 100644
--- a/source/games/duke/src/premap_d.cpp
+++ b/source/games/duke/src/premap_d.cpp
@@ -282,8 +282,8 @@ void prelevel_d(int g, TArray<DDukeActor*>& actors)
 
 		if (ac->spr.lotag == -1 && (ac->spr.cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
 		{
-			ps[0].exit.X = ac->spr.pos.X;
-			ps[0].exit.Y = ac->spr.pos.Y;
+			ps[0].exit.X = ac->int_pos().X;
+			ps[0].exit.Y = ac->int_pos().Y;
 		}
 		else
 			premapcontroller(ac);
diff --git a/source/games/duke/src/premap_r.cpp b/source/games/duke/src/premap_r.cpp
index 91034adb2..09370958f 100644
--- a/source/games/duke/src/premap_r.cpp
+++ b/source/games/duke/src/premap_r.cpp
@@ -535,8 +535,8 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
 
 		if (ac->spr.lotag == -1 && (ac->spr.cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
 		{
-			ps[0].exit.X = ac->spr.pos.X;
-			ps[0].exit.Y = ac->spr.pos.Y;
+			ps[0].exit.X = ac->int_pos().X;
+			ps[0].exit.Y = ac->int_pos().Y;
 		}
 		else switch (ac->spr.picnum)
 		{
diff --git a/source/games/duke/src/render.cpp b/source/games/duke/src/render.cpp
index 73903dbb9..fe4dbd96a 100644
--- a/source/games/duke/src/render.cpp
+++ b/source/games/duke/src/render.cpp
@@ -96,7 +96,7 @@ void GameInterface::UpdateCameras(double smoothratio)
 				display_mirror = 1; // should really be 'display external view'.
 				auto cstat = camera->spr.cstat;
 				camera->spr.cstat = CSTAT_SPRITE_INVISIBLE;
-				render_camtex(camera, camera->spr.pos, camera->sector(), ang, buildhoriz(camera->spr.shade), buildang(0), tex, rect, smoothratio);
+				render_camtex(camera, camera->int_pos(), camera->sector(), ang, buildhoriz(camera->spr.shade), buildang(0), tex, rect, smoothratio);
 				camera->spr.cstat = cstat;
 				display_mirror = 0;
 			});
@@ -264,7 +264,7 @@ void displayrooms(int snum, double smoothratio, bool sceneonly)
 		auto bh = buildhoriz(act->spr.yvel);
 		auto cstat = act->spr.cstat;
 		act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
-		renderView(act, act->sector(), act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (4 << 8), cang, bh, buildang(0), smoothratio, sceneonly, fov);
+		renderView(act, act->sector(), act->int_pos().X, act->int_pos().Y, act->int_pos().Z - (4 << 8), cang, bh, buildang(0), smoothratio, sceneonly, fov);
 		act->spr.cstat = cstat;
 
 	}
@@ -329,9 +329,9 @@ void displayrooms(int snum, double smoothratio, bool sceneonly)
 			auto act = p->newOwner;
 			cang = buildang(act->interpolatedang(smoothratio));
 			choriz = buildhoriz(act->spr.shade);
-			cposx = act->spr.pos.X;
-			cposy = act->spr.pos.Y;
-			cposz = act->spr.pos.Z;
+			cposx = act->int_pos().X;
+			cposy = act->int_pos().Y;
+			cposz = act->int_pos().Z;
 			sect = act->sector();
 			rotscrnang = buildang(0);
 			smoothratio = MaxSmoothRatio;
diff --git a/source/games/duke/src/sectors.cpp b/source/games/duke/src/sectors.cpp
index b77dc53c1..d2fcde8a6 100644
--- a/source/games/duke/src/sectors.cpp
+++ b/source/games/duke/src/sectors.cpp
@@ -216,7 +216,7 @@ int findplayer(const DDukeActor* actor, int* d)
 {
 	int j, closest_player;
 	int x, closest;
-	const auto s = actor->spr.pos;
+	const auto s = actor->int_pos();
 
 	if (ud.multimode < 2)
 	{
@@ -640,7 +640,7 @@ static void handle_st15(sectortype* sptr, DDukeActor* actor)
 	}
 	else
 	{
-		if (sptr->floorz > a2->spr.pos.Z)
+		if (sptr->floorz > a2->int_pos().Z)
 			activatewarpelevators(a2, -1);
 		else
 			activatewarpelevators(a2, 1);
@@ -753,7 +753,7 @@ REDODOOR:
 		{
 			if (a2->spr.statnum == 3 && a2->spr.lotag == 9)
 			{
-				j = a2->spr.pos.Z;
+				j = a2->int_pos().Z;
 				break;
 			}
 		}
diff --git a/source/games/duke/src/sectors_d.cpp b/source/games/duke/src/sectors_d.cpp
index 9d7584e0b..05b871872 100644
--- a/source/games/duke/src/sectors_d.cpp
+++ b/source/games/duke/src/sectors_d.cpp
@@ -240,8 +240,8 @@ bool checkhitswitch_d(int snum, walltype* wwal, DDukeActor *act)
 		lotag = act->spr.lotag;
 		if (lotag == 0) return 0;
 		hitag = act->spr.hitag;
-		sx = act->spr.pos.X;
-		sy = act->spr.pos.Y;
+		sx = act->int_pos().X;
+		sy = act->int_pos().Y;
 		picnum = act->spr.picnum;
 		switchpal = act->spr.pal;
 	}
@@ -1050,7 +1050,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
 		{
 			proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
 			proj->spr.ang -= (targ->spr.ang << 1) + 1024;
-			targ->spr.ang = getangle(targ->spr.pos.X - proj->spr.pos.X, targ->spr.pos.Y - proj->spr.pos.Y) - 512;
+			targ->spr.ang = getangle(targ->int_pos().X - proj->int_pos().X, targ->int_pos().Y - proj->int_pos().Y) - 512;
 			if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
 				S_PlayActorSound(POOLBALLHIT, targ);
 		}
@@ -1089,7 +1089,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
 		{
 			for (k = 0; k < 64; k++)
 			{
-				auto spawned = EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
+				auto spawned = EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
 				spawned->spr.pal = 8;
 			}
 
@@ -1102,7 +1102,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
 	case HANGLIGHT:
 	case GENERICPOLE2:
 		for (k = 0; k < 6; k++)
-			EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
+			EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
 		S_PlayActorSound(GLASS_HEAVYBREAK, targ);
 		deletesprite(targ);
 		break;
@@ -1132,7 +1132,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
 		if (gs.actorinfo[SHOTSPARK1].scriptaddress && proj->spr.extra != ScriptCode[gs.actorinfo[SHOTSPARK1].scriptaddress])
 		{
 			for (j = 0; j < 15; j++)
-				EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
+				EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
 					krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
 			spawn(targ, EXPLOSION2);
 			deletesprite(targ);
diff --git a/source/games/duke/src/sectors_r.cpp b/source/games/duke/src/sectors_r.cpp
index 3d460c468..7c03225d8 100644
--- a/source/games/duke/src/sectors_r.cpp
+++ b/source/games/duke/src/sectors_r.cpp
@@ -359,8 +359,8 @@ bool checkhitswitch_r(int snum, walltype* wwal, DDukeActor* act)
 		lotag = act->spr.lotag;
 		if (lotag == 0) return 0;
 		hitag = act->spr.hitag;
-		sx = act->spr.pos.X;
-		sy = act->spr.pos.Y;
+		sx = act->int_pos().X;
+		sy = act->int_pos().Y;
 		picnum = act->spr.picnum;
 		switchpal = act->spr.pal;
 	}
@@ -939,7 +939,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
 		for (j = n - 1; j >= 0; j--)
 		{
 			a = actor->spr.ang - 256 + (krand() & 511) + 1024;
-			EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
+			EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
 		}
 		return;
 	}
@@ -967,7 +967,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
 		{
 			z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
 			if (z < -(32 << 8) || z >(32 << 8))
-				z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
+				z = actor->int_pos().Z - (32 << 8) + (krand() & ((64 << 8) - 1));
 			a = actor->spr.ang - 1024;
 			EGS(actor->sector(), x1, y1, z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
 		}
@@ -2059,7 +2059,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
 		lotsofglass(targ, nullptr, 10);
 		targ->spr.picnum++;
 		for (k = 0; k < 6; k++)
-			EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
+			EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
 		break;
 	case BOWLINGBALL:
 		proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
@@ -2077,7 +2077,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
 		{
 			proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
 			proj->spr.ang -= (targ->spr.ang << 1) + 1024;
-			targ->spr.ang = getangle(targ->spr.pos.X - proj->spr.pos.X, targ->spr.pos.Y - proj->spr.pos.Y) - 512;
+			targ->spr.ang = getangle(targ->int_pos().X - proj->int_pos().X, targ->int_pos().Y - proj->int_pos().Y) - 512;
 			if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
 				S_PlayActorSound(POOLBALLHIT, targ);
 		}
@@ -2126,7 +2126,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
 		{
 			for (k = 0; k < 64; k++)
 			{
-				auto spawned = EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
+				auto spawned = EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
 				if (spawned) spawned->spr.pal = 8;
 			}
 
@@ -2158,7 +2158,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
 		if (gs.actorinfo[SHOTSPARK1].scriptaddress && proj->spr.extra != ScriptCode[gs.actorinfo[SHOTSPARK1].scriptaddress])
 		{
 			for (j = 0; j < 15; j++)
-				EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
+				EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
 					krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
 			spawn(targ, EXPLOSION2);
 			deletesprite(targ);
diff --git a/source/games/duke/src/sounds.cpp b/source/games/duke/src/sounds.cpp
index 5c25b077b..2b518cdf9 100644
--- a/source/games/duke/src/sounds.cpp
+++ b/source/games/duke/src/sounds.cpp
@@ -276,7 +276,7 @@ static int GetPositionInfo(DDukeActor* actor, int soundNum, sectortype* sect,
 	sndist += dist_adjust;
 	if (sndist < 0) sndist = 0;
 
-	if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (24 << 8), actor->sector()))
+	if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (24 << 8), actor->sector()))
 		sndist += sndist >> (isRR() ? 2 : 5);
 
 	// Here the sound distance was clamped to a minimum of 144*4. 
@@ -321,7 +321,7 @@ void S_GetCamera(vec3_t* c, int32_t* ca, sectortype** cs)
 	}
 	else
 	{
-		if (c) *c =  ud.cameraactor->spr.pos;
+		if (c) *c =  ud.cameraactor->int_pos();
 		if (cs) *cs = ud.cameraactor->sector();
 		if (ca) *ca = ud.cameraactor->spr.ang;
 	}
@@ -356,7 +356,7 @@ void DukeSoundEngine::CalcPosVel(int type, const void* source, const float pt[3]
 			auto aactor = (DDukeActor*)source;
 			if (aactor != nullptr)
 			{
-				GetPositionInfo(aactor, chanSound - 1, camsect, &campos, aactor->spr.pos, nullptr, pos);
+				GetPositionInfo(aactor, chanSound - 1, camsect, &campos, aactor->int_pos(), nullptr, pos);
 				/*
 				if (vel) // DN3D does not properly maintain this.
 				{
@@ -536,7 +536,7 @@ int S_PlaySound(int sndnum, int channel, EChanFlags flags, float vol)
 int S_PlayActorSound(int soundNum, DDukeActor* actor, int channel, EChanFlags flags)
 {
 	return (actor == nullptr ? S_PlaySound(soundNum, channel, flags) :
-		S_PlaySound3D(soundNum, actor, actor->spr.pos, channel, flags));
+		S_PlaySound3D(soundNum, actor, actor->int_pos(), channel, flags));
 }
 
 void S_StopSound(int sndNum, DDukeActor* actor, int channel)
diff --git a/source/games/duke/src/spawn.cpp b/source/games/duke/src/spawn.cpp
index 1559565b0..b338d92ac 100644
--- a/source/games/duke/src/spawn.cpp
+++ b/source/games/duke/src/spawn.cpp
@@ -216,7 +216,7 @@ DDukeActor* spawn(DDukeActor* actj, int pn)
 {
 	if (actj)
 	{
-		auto spawned = EGS(actj->sector(), actj->spr.pos.X, actj->spr.pos.Y, actj->spr.pos.Z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
+		auto spawned = EGS(actj->sector(), actj->int_pos().X, actj->int_pos().Y, actj->int_pos().Z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
 		if (spawned)
 		{
 			spawned->attackertype = actj->spr.picnum;
@@ -326,7 +326,7 @@ void spawntransporter(DDukeActor *actj, DDukeActor* act, bool beam)
 	act->spr.xvel = 128;
 	ChangeActorStat(act, STAT_MISC);
 	ssp(act, CLIPMASK0);
-	SetActor(act, act->spr.pos);
+	SetActor(act, act->int_pos());
 }
 
 //---------------------------------------------------------------------------
@@ -339,16 +339,16 @@ int spawnbloodpoolpart1(DDukeActor* act)
 {
 	auto s1 = act->sector();
 
-	updatesector(act->spr.pos.X + 108, act->spr.pos.Y + 108, &s1);
+	updatesector(act->int_pos().X + 108, act->int_pos().Y + 108, &s1);
 	if (s1 && s1->floorz == act->sector()->floorz)
 	{
-		updatesector(act->spr.pos.X - 108, act->spr.pos.Y - 108, &s1);
+		updatesector(act->int_pos().X - 108, act->int_pos().Y - 108, &s1);
 		if (s1 && s1->floorz == act->sector()->floorz)
 		{
-			updatesector(act->spr.pos.X + 108, act->spr.pos.Y - 108, &s1);
+			updatesector(act->int_pos().X + 108, act->int_pos().Y - 108, &s1);
 			if (s1 && s1->floorz == act->sector()->floorz)
 			{
-				updatesector(act->spr.pos.X - 108, act->spr.pos.Y + 108, &s1);
+				updatesector(act->int_pos().X - 108, act->int_pos().Y + 108, &s1);
 				if (s1 && s1->floorz != act->sector()->floorz)
 				{
 					act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return true;
@@ -381,16 +381,16 @@ void initfootprint(DDukeActor* actj, DDukeActor* act)
 	{
 		auto s1 = act->sector();
 
-		updatesector(act->spr.pos.X + 84, act->spr.pos.Y + 84, &s1);
+		updatesector(act->int_pos().X + 84, act->int_pos().Y + 84, &s1);
 		if (s1 && s1->floorz == act->sector()->floorz)
 		{
-			updatesector(act->spr.pos.X - 84, act->spr.pos.Y - 84, &s1);
+			updatesector(act->int_pos().X - 84, act->int_pos().Y - 84, &s1);
 			if (s1 && s1->floorz == act->sector()->floorz)
 			{
-				updatesector(act->spr.pos.X + 84, act->spr.pos.Y - 84, &s1);
+				updatesector(act->int_pos().X + 84, act->int_pos().Y - 84, &s1);
 				if (s1 && s1->floorz == act->sector()->floorz)
 				{
-					updatesector(act->spr.pos.X - 84, act->spr.pos.Y + 84, &s1);
+					updatesector(act->int_pos().X - 84, act->int_pos().Y + 84, &s1);
 					if (s1 && s1->floorz != act->sector()->floorz)
 					{
 						act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return;
@@ -439,10 +439,10 @@ void initshell(DDukeActor* actj, DDukeActor* act, bool isshell)
 		else
 		{
 			a = act->spr.ang;
-			act->set_int_z(actj->spr.pos.Z - gs.playerheight + (3 << 8));
+			act->set_int_z(actj->int_pos().Z - gs.playerheight + (3 << 8));
 		}
 
-		act->set_int_xy(actj->spr.pos.X + bcos(a, -7), actj->spr.pos.Y + bsin(a, -7));
+		act->set_int_xy(actj->int_pos().X + bcos(a, -7), actj->int_pos().Y + bsin(a, -7));
 
 		act->spr.shade = -8;
 
@@ -480,7 +480,7 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
 	act->temp_data[4] = cranes.Reserve(1);
 
 	auto& apt = cranes[act->temp_data[4]];
-	apt.pos = act->spr.pos;
+	apt.pos = act->int_pos();
 	apt.poleactor = nullptr;
 
 	DukeStatIterator it(STAT_DEFAULT);
@@ -495,13 +495,13 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
 			actk->spr.xrepeat = 48;
 			actk->spr.yrepeat = 128;
 
-			apt.pole.X = actk->spr.pos.X;
-			apt.pole.Y = actk->spr.pos.Y;
+			apt.pole.X = actk->int_pos().X;
+			apt.pole.Y = actk->int_pos().Y;
 
-			actk->set_int_pos(act->spr.pos);
+			actk->set_int_pos(act->int_pos());
 			actk->spr.shade = act->spr.shade;
 
-			SetActor(actk, actk->spr.pos);
+			SetActor(actk, actk->int_pos());
 			break;
 		}
 	}
@@ -528,14 +528,14 @@ void initwaterdrip(DDukeActor* actj, DDukeActor* actor)
 			actor->add_int_z(-(18 << 8));
 		}
 		else actor->add_int_z(-(13 << 8));
-		actor->spr.ang = getangle(ps[connecthead].pos.X - actor->spr.pos.X, ps[connecthead].pos.Y - actor->spr.pos.Y);
+		actor->spr.ang = getangle(ps[connecthead].pos.X - actor->int_pos().X, ps[connecthead].pos.Y - actor->int_pos().Y);
 		actor->spr.xvel = 48 - (krand() & 31);
 		ssp(actor, CLIPMASK0);
 	}
 	else if (!actj)
 	{
 		actor->add_int_z(4 << 8);
-		actor->temp_data[0] = actor->spr.pos.Z;
+		actor->temp_data[0] = actor->int_pos().Z;
 		if (!isRR()) actor->temp_data[1] = krand() & 127;
 	}
 	actor->spr.xrepeat = 24;
@@ -626,7 +626,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 			}
 			else actor->SetOwner(actor);
 
-			actor->temp_data[4] = sectp->floorz == actor->spr.pos.Z;
+			actor->temp_data[4] = sectp->floorz == actor->int_pos().Z;
 			actor->spr.cstat = 0;
 			ChangeActorStat(actor, STAT_TRANSPORT);
 			return;
@@ -640,13 +640,13 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 			{
 				actor->temp_data[1] = sectp->ceilingz;
 				if (actor->spr.pal)
-					sectp->setceilingz(actor->spr.pos.Z);
+					sectp->setceilingz(actor->int_pos().Z);
 			}
 			else
 			{
 				actor->temp_data[1] = sectp->floorz;
 				if (actor->spr.pal)
-					sectp->setfloorz(actor->spr.pos.Z);
+					sectp->setfloorz(actor->int_pos().Z);
 			}
 
 			actor->spr.hitag <<= 2;
@@ -664,11 +664,11 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 			else
 				actor->temp_data[4] = sectp->ceilingz;
 
-			sectp->setceilingz(actor->spr.pos.Z);
+			sectp->setceilingz(actor->int_pos().Z);
 			StartInterpolation(sectp, Interp_Sect_Ceilingz);
 			break;
 		case SE_35:
-			sectp->setceilingz(actor->spr.pos.Z);
+			sectp->setceilingz(actor->int_pos().Z);
 			break;
 		case SE_27_DEMO_CAM:
 			if (ud.recstat == 1)
@@ -692,20 +692,20 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 			actor->temp_data[0] = sectp->ceilingz;
 			actor->temp_data[1] = sectp->floorz;
 
-			bool ceiling = (abs(actor->temp_data[0] - actor->spr.pos.Z) < abs(actor->temp_data[1] - actor->spr.pos.Z));
+			bool ceiling = (abs(actor->temp_data[0] - actor->int_pos().Z) < abs(actor->temp_data[1] - actor->int_pos().Z));
 			actor->spriteextra = ceiling;
 
 			if (actor->spr.ang == 512)
 			{
 				if (ceiling)
-					sectp->setceilingz(actor->spr.pos.Z);
+					sectp->setceilingz(actor->int_pos().Z);
 				else
-					sectp->setfloorz(actor->spr.pos.Z);
+					sectp->setfloorz(actor->int_pos().Z);
 			}
 			else
 			{
-				sectp->setceilingz(actor->spr.pos.Z);
-				sectp->setfloorz(actor->spr.pos.Z);
+				sectp->setceilingz(actor->int_pos().Z);
+				sectp->setfloorz(actor->int_pos().Z);
 			}
 
 			if (sectp->ceilingstat & CSTAT_SECTOR_SKY)
@@ -779,7 +779,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 
 			for (auto& wal : wallsofsector(sectp))
 			{
-				d = FindDistance2D(actor->spr.pos.vec2 - wal.wall_int_pos());
+				d = FindDistance2D(actor->int_pos().vec2 - wal.wall_int_pos());
 				if (d < q)
 				{
 					q = d;
@@ -793,7 +793,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 
 			for (auto& wal : wallsofsector(sectp))
 			{
-				d = FindDistance2D(actor->spr.pos.vec2 - wal.wall_int_pos());
+				d = FindDistance2D(actor->int_pos().vec2 - wal.wall_int_pos());
 				if (d < q && &wal != actor->temp_walls[0])
 				{
 					q = d;
@@ -831,7 +831,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 		case SE_31_FLOOR_RISE_FALL:
 			actor->temp_data[1] = sectp->floorz;
 			//	actor->temp_data[2] = actor->spr.hitag;
-			if (actor->spr.ang != 1536) sectp->setfloorz(actor->spr.pos.Z);
+			if (actor->spr.ang != 1536) sectp->setfloorz(actor->int_pos().Z);
 
 			for (auto& wal : wallsofsector(sectp))
 				if (wal.hitag == 0) wal.hitag = 9999;
@@ -842,7 +842,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 		case SE_32_CEILING_RISE_FALL:
 			actor->temp_data[1] = sectp->ceilingz;
 			actor->temp_data[2] = actor->spr.hitag;
-			if (actor->spr.ang != 1536) sectp->setceilingz(actor->spr.pos.Z);
+			if (actor->spr.ang != 1536) sectp->setceilingz(actor->int_pos().Z);
 
 			for (auto& wal : wallsofsector(sectp))
 				if (wal.hitag == 0) wal.hitag = 9999;
@@ -865,7 +865,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 
 		case SE_9_DOWN_OPEN_DOOR_LIGHTS:
 			if (sectp->lotag &&
-				labs(sectp->ceilingz - actor->spr.pos.Z) > 1024)
+				labs(sectp->ceilingz - actor->int_pos().Z) > 1024)
 				sectp->lotag |= 32768; //If its open
 			[[fallthrough]];
 		case SE_8_UP_OPEN_DOOR_LIGHTS:
@@ -931,7 +931,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 						{
 							if (actor->spr.ang == 512)
 							{
-								actor->set_int_xy(act2->spr.pos.X, act2->spr.pos.Y);
+								actor->set_int_xy(act2->int_pos().X, act2->int_pos().Y);
 							}
 							found = true;
 							actor->SetOwner(act2);
@@ -944,7 +944,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 					actor->spr.cstat2 = CSTAT2_SPRITE_NOFIND;
 					actor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
 					ChangeActorStat(actor, STAT_REMOVED);
-					Printf("Found lonely Sector Effector (lotag 0) at (%d,%d)\n", actor->spr.pos.X, actor->spr.pos.Y);
+					Printf("Found lonely Sector Effector (lotag 0) at (%d,%d)\n", actor->int_pos().X, actor->int_pos().Y);
 					return;
 				}
 			}
@@ -952,8 +952,8 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 			actor->temp_data[1] = tempwallptr;
 			for (auto& wal : wallsofsector(sectp))
 			{
-				msx[tempwallptr] = wal.wall_int_pos().X - actor->spr.pos.X;
-				msy[tempwallptr] = wal.wall_int_pos().Y - actor->spr.pos.Y;
+				msx[tempwallptr] = wal.wall_int_pos().X - actor->int_pos().X;
+				msy[tempwallptr] = wal.wall_int_pos().Y - actor->int_pos().Y;
 				tempwallptr++;
 				if (tempwallptr > 2047)
 				{
@@ -983,7 +983,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 
 				if (s == nullptr)
 				{
-					I_Error("Subway found no zero'd sectors with locators\nat (%d,%d).\n", actor->spr.pos.X, actor->spr.pos.Y);
+					I_Error("Subway found no zero'd sectors with locators\nat (%d,%d).\n", actor->int_pos().X, actor->int_pos().Y);
 				}
 
 				actor->SetOwner(nullptr);
@@ -998,8 +998,8 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
 
 			else if (actor->spr.lotag == SE_26)
 			{
-				actor->temp_data[3] = actor->spr.pos.X;
-				actor->temp_data[4] = actor->spr.pos.Y;
+				actor->temp_data[3] = actor->int_pos().X;
+				actor->temp_data[4] = actor->int_pos().Y;
 				if (actor->spr.shade == sectp->floorshade) //UP
 					actor->spr.zvel = -256;
 				else
@@ -1087,7 +1087,7 @@ void lotsofglass(DDukeActor *actor, walltype* wal, int n)
 		for (j = n - 1; j >= 0; j--)
 		{
 			a = actor->spr.ang - 256 + (krand() & 511) + 1024;
-			EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
+			EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
 		}
 		return;
 	}
@@ -1110,7 +1110,7 @@ void lotsofglass(DDukeActor *actor, walltype* wal, int n)
 		{
 			z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
 			if (z < -(32 << 8) || z >(32 << 8))
-				z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
+				z = actor->int_pos().Z - (32 << 8) + (krand() & ((64 << 8) - 1));
 			a = actor->spr.ang - 1024;
 			EGS(actor->sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
 		}
@@ -1128,8 +1128,8 @@ void spriteglass(DDukeActor* actor, int n)
 	for (int j = n; j > 0; j--)
 	{
 		int a = krand() & 2047;
-		int z = actor->spr.pos.Z - ((krand() & 16) << 8);
-		auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, z, TILE_GLASSPIECES + (j % 3), krand() & 15, 36, 36, a, 32 + (krand() & 63), -512 - (krand() & 2047), actor, 5);
+		int z = actor->int_pos().Z - ((krand() & 16) << 8);
+		auto k = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, z, TILE_GLASSPIECES + (j % 3), krand() & 15, 36, 36, a, 32 + (krand() & 63), -512 - (krand() & 2047), actor, 5);
 		if (k) k->spr.pal = actor->spr.pal;
 	}
 }
@@ -1180,7 +1180,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
 		for (j = n - 1; j >= 0; j--)
 		{
 			a = krand() & 2047;
-			auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
+			auto k = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
 			if (k) k->spr.pal = krand() & 15;
 		}
 		return;
@@ -1199,7 +1199,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
 		updatesector(x1, y1, &sect);
 		z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
 		if (z < -(32 << 8) || z >(32 << 8))
-			z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
+			z = actor->int_pos().Z - (32 << 8) + (krand() & ((64 << 8) - 1));
 		a = actor->spr.ang - 1024;
 		auto k = EGS(actor->sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 2047), actor, 5);
 		if (k) k->spr.pal = krand() & 7;
diff --git a/source/games/duke/src/spawn_d.cpp b/source/games/duke/src/spawn_d.cpp
index 6dc0cd443..6ce422f47 100644
--- a/source/games/duke/src/spawn_d.cpp
+++ b/source/games/duke/src/spawn_d.cpp
@@ -146,7 +146,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 	case WATERSPLASH2:
 		if (actj)
 		{
-			SetActor(act, actj->spr.pos);
+			SetActor(act, actj->int_pos());
 			act->spr.xrepeat = act->spr.yrepeat = 8 + (krand() & 7);
 		}
 		else act->spr.xrepeat = act->spr.yrepeat = 16 + (krand() & 15);
@@ -157,11 +157,11 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 		{
 			if (actj->sector()->lotag == 2)
 			{
-				act->set_int_z(getceilzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8));
+				act->set_int_z(getceilzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y) + (16 << 8));
 				act->spr.cstat |= CSTAT_SPRITE_YFLIP;
 			}
 			else if (actj->sector()->lotag == 1)
-				act->set_int_z(getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y));
+				act->set_int_z(getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y));
 		}
 
 		if (sectp->floorpicnum == FLOORSLIME ||
@@ -294,8 +294,8 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 		act->spr.cstat |= CSTAT_SPRITE_ALIGNMENT_FLOOR;
 		if (act->spr.picnum == LAVAPOOL)  // Twentieth Anniversary World Tour
 		{
-			int fz = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
-			if (fz != act->spr.pos.Z)
+			int fz = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
+			if (fz != act->int_pos().Z)
 				act->set_int_z(fz);
 			act->add_int_z(-200);
 		}
@@ -544,8 +544,8 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 		break;
 
 	case SPOTLITE:
-		act->temp_data[0] = act->spr.pos.X;
-		act->temp_data[1] = act->spr.pos.Y;
+		act->temp_data[0] = act->int_pos().X;
+		act->temp_data[1] = act->int_pos().Y;
 		break;
 	case BULLETHOLE:
 		act->spr.xrepeat = act->spr.yrepeat = 3;
@@ -638,8 +638,8 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 
 		if (actj)
 		{
-			int x = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
-			if (act->spr.pos.Z > x - (12 << 8))
+			int x = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
+			if (act->int_pos().Z > x - (12 << 8))
 				act->set_int_z(x - (12 << 8));
 		}
 
@@ -720,7 +720,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 	case TOUCHPLATE:
 		act->temp_data[2] = sectp->floorz;
 		if (sectp->lotag != 1 && sectp->lotag != 2)
-			sectp->setfloorz(act->spr.pos.Z);
+			sectp->setfloorz(act->int_pos().Z);
 		if (!isWorldTour())
 		{
 			if (act->spr.pal && ud.multimode > 1)
@@ -744,7 +744,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 	case WATERBUBBLEMAKER:
 		if (act->spr.hitag && act->spr.picnum == WATERBUBBLEMAKER)
 		{	// JBF 20030913: Pisses off move(), eg. in bobsp2
-			Printf(TEXTCOLOR_YELLOW "WARNING: WATERBUBBLEMAKER %d @ %d,%d with hitag!=0. Applying fixup.\n", act->GetIndex(), act->spr.pos.X, act->spr.pos.Y);
+			Printf(TEXTCOLOR_YELLOW "WARNING: WATERBUBBLEMAKER %d @ %d,%d with hitag!=0. Applying fixup.\n", act->GetIndex(), act->int_pos().X, act->int_pos().Y);
 			act->spr.hitag = 0;
 		}
 		act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
diff --git a/source/games/duke/src/spawn_r.cpp b/source/games/duke/src/spawn_r.cpp
index 961516385..c9d4f6d52 100644
--- a/source/games/duke/src/spawn_r.cpp
+++ b/source/games/duke/src/spawn_r.cpp
@@ -201,7 +201,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 	case MUD:
 		if (actj)
 		{
-			SetActor(act, actj->spr.pos);
+			SetActor(act, actj->int_pos());
 			act->spr.xrepeat = act->spr.yrepeat = 8 + (krand() & 7);
 		}
 		else act->spr.xrepeat = act->spr.yrepeat = 16 + (krand() & 15);
@@ -212,11 +212,11 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 		{
 			if (actj->sector()->lotag == 2)
 			{
-				act->set_int_z(getceilzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8));
+				act->set_int_z(getceilzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y) + (16 << 8));
 				act->spr.cstat |= CSTAT_SPRITE_YFLIP;
 			}
 			else if (actj->sector()->lotag == 1)
-				act->set_int_z(getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y));
+				act->set_int_z(getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y));
 		}
 
 		if (sectp->floorpicnum == FLOORSLIME ||
@@ -569,8 +569,8 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 		break;
 
 	case SPOTLITE:
-		act->temp_data[0] = act->spr.pos.X;
-		act->temp_data[1] = act->spr.pos.Y;
+		act->temp_data[0] = act->int_pos().X;
+		act->temp_data[1] = act->int_pos().Y;
 		break;
 	case BULLETHOLE:
 		act->spr.xrepeat = act->spr.yrepeat = 3;
@@ -649,8 +649,8 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 
 		if (actj)
 		{
-			int x = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
-			if (act->spr.pos.Z > x - (12 << 8))
+			int x = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
+			if (act->int_pos().Z > x - (12 << 8))
 				act->set_int_z(x - (12 << 8));
 		}
 
@@ -717,7 +717,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
 	case TOUCHPLATE:
 		act->temp_data[2] = sectp->floorz;
 		if (sectp->lotag != 1 && sectp->lotag != 2)
-			sectp->setfloorz(act->spr.pos.Z);
+			sectp->setfloorz(act->int_pos().Z);
 		if (act->spr.pal && ud.multimode > 1)
 		{
 			act->spr.xrepeat = act->spr.yrepeat = 0;