diff --git a/source/games/blood/src/_polymost.cpp b/source/games/blood/src/_polymost.cpp
index 7b5c51a67..76f60695a 100644
--- a/source/games/blood/src/_polymost.cpp
+++ b/source/games/blood/src/_polymost.cpp
@@ -19,8 +19,8 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
         int top, bottom;
         GetSpriteExtents(pSprite, &top, &bottom);
         int zCeil, zFloor;
-        getzsofslopeptr(&sector[nSector], pSprite->pos.X, pSprite->pos.Y, &zCeil, &zFloor);
-        if (pSprite->statnum == kStatDude && (top < zCeil || bottom > zFloor))
+        getzsofslopeptr(&sector[nSector], actor->spr.pos.X, actor->spr.pos.Y, &zCeil, &zFloor);
+        if (actor->spr.statnum == kStatDude && (top < zCeil || bottom > zFloor))
         {
             int j = i;
             if (mirror[i].type == 2)
@@ -34,27 +34,27 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
             {
                 tspritetype* pTSprite = &pm_tsprite[pm_spritesortcnt++];
                 *pTSprite = {};
-                pTSprite->type = pSprite->type;
+                pTSprite->type = actor->spr.type;
                 pTSprite->setsector(nSector2);
-                pTSprite->pos.X = pSprite->pos.X + dx;
-                pTSprite->pos.Y = pSprite->pos.Y + dy;
-                pTSprite->pos.Z = pSprite->pos.Z + dz;
-                pTSprite->ang = pSprite->ang;
-                pTSprite->picnum = pSprite->picnum;
-                pTSprite->shade = pSprite->shade;
-                pTSprite->pal = pSprite->pal;
-                pTSprite->xrepeat = pSprite->xrepeat;
-                pTSprite->yrepeat = pSprite->yrepeat;
-                pTSprite->xoffset = pSprite->xoffset;
-                pTSprite->yoffset = pSprite->yoffset;
-                pTSprite->cstat = pSprite->cstat;
+                pTSprite->pos.X = actor->spr.pos.X + dx;
+                pTSprite->pos.Y = actor->spr.pos.Y + dy;
+                pTSprite->pos.Z = actor->spr.pos.Z + dz;
+                pTSprite->ang = actor->spr.ang;
+                pTSprite->picnum = actor->spr.picnum;
+                pTSprite->shade = actor->spr.shade;
+                pTSprite->pal = actor->spr.pal;
+                pTSprite->xrepeat = actor->spr.xrepeat;
+                pTSprite->yrepeat = actor->spr.yrepeat;
+                pTSprite->xoffset = actor->spr.xoffset;
+                pTSprite->yoffset = actor->spr.yoffset;
+                pTSprite->cstat = actor->spr.cstat;
                 pTSprite->statnum = kStatDecoration;
                 pTSprite->ownerActor = actor;
-                pTSprite->flags = pSprite->hitag | 0x200;
-                pTSprite->pos.X = dx + interpolatedvalue(pSprite->opos.X, pSprite->pos.X, interpolation);
-                pTSprite->pos.Y = dy + interpolatedvalue(pSprite->opos.Y, pSprite->pos.Y, interpolation);
-                pTSprite->pos.Z = dz + interpolatedvalue(pSprite->opos.Z, pSprite->pos.Z, interpolation);
-                pTSprite->ang = pSprite->interpolatedang(interpolation);
+                pTSprite->flags = actor->spr.hitag | 0x200;
+                pTSprite->pos.X = dx + interpolatedvalue(actor->spr.opos.X, actor->spr.pos.X, interpolation);
+                pTSprite->pos.Y = dy + interpolatedvalue(actor->spr.opos.Y, actor->spr.pos.Y, interpolation);
+                pTSprite->pos.Z = dz + interpolatedvalue(actor->spr.opos.Z, actor->spr.pos.Z, interpolation);
+                pTSprite->ang = actor->spr.interpolatedang(interpolation);
 
                 int nAnim = 0;
                 switch (picanm[pTSprite->picnum].extra & 7)
@@ -135,14 +135,14 @@ RORHACK:
         ror_status[i] = testgotpic(4080 + i);
     fixed_t deliriumPitchI = interpolatedvalue(IntToFixed(deliriumPitchO), IntToFixed(deliriumPitch), gInterpolate);
     DrawMirrors(cX, cY, cZ, cA.asq16(), cH.asq16() + deliriumPitchI, int(gInterpolate), gViewIndex);
-    auto bakCstat = gView->pSprite->cstat;
+    auto bakCstat = gView->actor->spr.cstat;
     if (gViewPos == 0)
     {
-        gView->pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
+        gView->actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
     }
     else
     {
-        gView->pSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT |  CSTAT_SPRITE_TRANS_FLIP;
+        gView->actor->spr.cstat |= CSTAT_SPRITE_TRANSLUCENT |  CSTAT_SPRITE_TRANS_FLIP;
     }
 
     renderDrawRoomsQ16(cX, cY, cZ, cA.asq16(), cH.asq16() + deliriumPitchI, nSectnum, false);
@@ -153,7 +153,7 @@ RORHACK:
             do_ror_hack = true;
     if (do_ror_hack)
     {
-        gView->pSprite->cstat = bakCstat;
+        gView->actor->spr.cstat = bakCstat;
         pm_spritesortcnt = 0;
         goto RORHACK;
     }
@@ -164,7 +164,7 @@ RORHACK:
     setPortalFlags(0);
     processSpritesOnOtherSideOfPortal(cX, cY, int(gInterpolate));
     renderDrawMasks();
-    gView->pSprite->cstat = bakCstat;
+    gView->actor->spr.cstat = bakCstat;
 
 }
 
@@ -261,14 +261,14 @@ void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int
                 ESpriteFlags bakCstat = 0;
                 if (viewPlayer >= 0)
                 {
-                    bakCstat = gPlayer[viewPlayer].pSprite->cstat;
+                    bakCstat = gPlayer[viewPlayer].actor->spr.cstat;
                     if (gViewPos == 0)
                     {
-                        gPlayer[viewPlayer].pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
+                        gPlayer[viewPlayer].actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
                     }
                     else
                     {
-                        gPlayer[viewPlayer].pSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT |  CSTAT_SPRITE_TRANS_FLIP;
+                        gPlayer[viewPlayer].actor->spr.cstat |= CSTAT_SPRITE_TRANSLUCENT |  CSTAT_SPRITE_TRANS_FLIP;
                     }
                 }
                 renderDrawRoomsQ16(x + mirror[i].dx, y + mirror[i].dy, z + mirror[i].dz, a, horiz, nSector, true);
@@ -281,7 +281,7 @@ void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int
                     gotpic.Clear(4080 + i);
                 if (viewPlayer >= 0)
                 {
-                    gPlayer[viewPlayer].pSprite->cstat = bakCstat;
+                    gPlayer[viewPlayer].actor->spr.cstat = bakCstat;
                 }
                 r_rorphase = 0;
                 return;
@@ -293,14 +293,14 @@ void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int
                 ESpriteFlags bakCstat = 0;
                 if (viewPlayer >= 0)
                 {
-                    bakCstat = gPlayer[viewPlayer].pSprite->cstat;
+                    bakCstat = gPlayer[viewPlayer].actor->spr.cstat;
                     if (gViewPos == 0)
                     {
-                        gPlayer[viewPlayer].pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
+                        gPlayer[viewPlayer].actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
                     }
                     else
                     {
-                        gPlayer[viewPlayer].pSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT |  CSTAT_SPRITE_TRANS_FLIP;
+                        gPlayer[viewPlayer].actor->spr.cstat |= CSTAT_SPRITE_TRANSLUCENT |  CSTAT_SPRITE_TRANS_FLIP;
                     }
                 }
                 renderDrawRoomsQ16(x + mirror[i].dx, y + mirror[i].dy, z + mirror[i].dz, a, horiz, nSector, true);
@@ -313,7 +313,7 @@ void DrawMirrors(int x, int y, int z, fixed_t a, fixed_t horiz, int smooth, int
                     gotpic.Clear(4080 + i);
                 if (viewPlayer >= 0)
                 {
-                    gPlayer[viewPlayer].pSprite->cstat = bakCstat;
+                    gPlayer[viewPlayer].actor->spr.cstat = bakCstat;
                 }
                 r_rorphase = 0;
                 return;
diff --git a/source/games/blood/src/eventq.cpp b/source/games/blood/src/eventq.cpp
index c879ef89b..b1f4d0942 100644
--- a/source/games/blood/src/eventq.cpp
+++ b/source/games/blood/src/eventq.cpp
@@ -421,7 +421,7 @@ void evSend(EventObject& eob, int rxId, COMMAND_ID command)
 		while (auto actor = it.Next())
 		{
 			spritetype* pSprite = &actor->s();
-			if (pSprite->flags & 32)
+			if (actor->spr.flags & 32)
 				continue;
 			if (actor->hasX())
 			{
@@ -439,7 +439,7 @@ void evSend(EventObject& eob, int rxId, COMMAND_ID command)
 		while (auto actor = it.Next())
 		{
 			spritetype* pSprite = &actor->s();
-			if (pSprite->flags & 32)
+			if (actor->spr.flags & 32)
 				continue;
 			if (actor->hasX())
 			{
diff --git a/source/games/blood/src/fx.cpp b/source/games/blood/src/fx.cpp
index 1910451bf..90437a554 100644
--- a/source/games/blood/src/fx.cpp
+++ b/source/games/blood/src/fx.cpp
@@ -120,7 +120,7 @@ void CFX::remove(DBloodActor* actor)
     if (!actor) return;
     spritetype *pSprite = &actor->s();
     if (actor->hasX()) seqKill(actor);
-    if (pSprite->statnum != kStatFree)
+    if (actor->spr.statnum != kStatFree)
         actPostSprite(actor, kStatFree);
 }
 
@@ -163,20 +163,20 @@ DBloodActor* CFX::fxSpawnActor(FX_ID nFx, sectortype* pSector, int x, int y, int
     }
     auto actor = actSpawnSprite(pSector, x, y, z, 1, 0);
     spritetype* pSprite = &actor->s();
-    pSprite->type = nFx;
-    pSprite->picnum = pFX->picnum;
-    pSprite->cstat |= pFX->cstat;
-    pSprite->shade = pFX->shade;
-    pSprite->pal = pFX->pal;
-    pSprite->detail = pFX->detail;
+    actor->spr.type = nFx;
+    actor->spr.picnum = pFX->picnum;
+    actor->spr.cstat |= pFX->cstat;
+    actor->spr.shade = pFX->shade;
+    actor->spr.pal = pFX->pal;
+    actor->spr.detail = pFX->detail;
     if (pFX->xrepeat > 0)
-        pSprite->xrepeat = pFX->xrepeat;
+        actor->spr.xrepeat = pFX->xrepeat;
     if (pFX->yrepeat > 0)
-        pSprite->yrepeat = pFX->yrepeat;
+        actor->spr.yrepeat = pFX->yrepeat;
     if ((pFX->flags & 1) && Chance(0x8000))
-        pSprite->cstat |= CSTAT_SPRITE_XFLIP;
+        actor->spr.cstat |= CSTAT_SPRITE_XFLIP;
     if ((pFX->flags & 2) && Chance(0x8000))
-        pSprite->cstat |= CSTAT_SPRITE_YFLIP;
+        actor->spr.cstat |= CSTAT_SPRITE_YFLIP;
     if (pFX->seq)
     {
         actor->addX();
@@ -196,24 +196,24 @@ void CFX::fxProcess(void)
     {
         spritetype *pSprite = &actor->s();
         viewBackupSpriteLoc(actor);
-        auto pSector = pSprite->sector();
+        auto pSector = actor->spr.sector();
         assert(pSector);
-        assert(pSprite->type < kFXMax);
-        FXDATA *pFXData = &gFXData[pSprite->type];
+        assert(actor->spr.type < kFXMax);
+        FXDATA *pFXData = &gFXData[actor->spr.type];
         actAirDrag(actor, pFXData->drag);
-        pSprite->pos.X += actor->xvel>>12;
-        pSprite->pos.Y += actor->yvel>>12;
-        pSprite->pos.Z += actor->zvel>>8;
+        actor->spr.pos.X += actor->xvel>>12;
+        actor->spr.pos.Y += actor->yvel>>12;
+        actor->spr.pos.Z += actor->zvel>>8;
         // Weird...
-        if (actor->xvel || (actor->yvel && pSprite->pos.Z >= pSprite->sector()->floorz))
+        if (actor->xvel || (actor->yvel && actor->spr.pos.Z >= actor->spr.sector()->floorz))
         {
-            updatesector(pSprite->pos.X, pSprite->pos.Y, &pSector);
+            updatesector(actor->spr.pos.X, actor->spr.pos.Y, &pSector);
             if (pSector == nullptr)
             {
                 remove(actor);
                 continue;
             }
-            if (getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) <= pSprite->pos.Z)
+            if (getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) <= actor->spr.pos.Z)
             {
                 if (pFXData->funcID < 0 || pFXData->funcID >= kCallbackMax)
                 {
@@ -223,7 +223,7 @@ void CFX::fxProcess(void)
                 gCallback[pFXData->funcID](actor, nullptr);
                 continue;
             }
-            if (pSector != pSprite->sector())
+            if (pSector != actor->spr.sector())
             {
                 assert(pSector);
                 ChangeActorSect(actor, pSector);
@@ -232,13 +232,13 @@ void CFX::fxProcess(void)
         if (actor->xvel || actor->yvel || actor->zvel)
         {
             int32_t floorZ, ceilZ;
-            getzsofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y, &ceilZ, &floorZ);
-            if (ceilZ > pSprite->pos.Z && !(pSector->ceilingstat & CSTAT_SECTOR_SKY))
+            getzsofslopeptr(pSector, actor->spr.pos.X, actor->spr.pos.Y, &ceilZ, &floorZ);
+            if (ceilZ > actor->spr.pos.Z && !(pSector->ceilingstat & CSTAT_SECTOR_SKY))
             {
                 remove(actor);
                 continue;
             }
-            if (floorZ < pSprite->pos.Z)
+            if (floorZ < actor->spr.pos.Z)
             {
                 if (pFXData->funcID < 0 || pFXData->funcID >= kCallbackMax)
                 {
@@ -256,14 +256,14 @@ void CFX::fxProcess(void)
 void fxSpawnBlood(DBloodActor *actor, int )
 {
     spritetype* pSprite = &actor->s();
-    if (!pSprite->insector())
+    if (!actor->spr.insector())
         return;
-    auto pSector = pSprite->sector();
-    if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector))
+    auto pSector = actor->spr.sector();
+    if (!FindSector(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, &pSector))
         return;
     if (adult_lockout && gGameOptions.nGameType <= 0)
         return;
-    auto bloodactor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
+    auto bloodactor = gFX.fxSpawnActor(FX_27, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
     if (bloodactor)
     {
         bloodactor->spr.ang = 1024;
@@ -277,18 +277,18 @@ void fxSpawnBlood(DBloodActor *actor, int )
 void fxSpawnPodStuff(DBloodActor* actor, int )
 {
     auto pSprite = &actor->s();
-    if (!pSprite->insector())
+    if (!actor->spr.insector())
         return;
-    auto pSector = pSprite->sector();
-    if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector))
+    auto pSector = actor->spr.sector();
+    if (!FindSector(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, &pSector))
         return;
     if (adult_lockout && gGameOptions.nGameType <= 0)
         return;
     DBloodActor *spawnactor;
-    if (pSprite->type == kDudePodGreen)
-        spawnactor = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
+    if (actor->spr.type == kDudePodGreen)
+        spawnactor = gFX.fxSpawnActor(FX_53, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
     else
-        spawnactor = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
+        spawnactor = gFX.fxSpawnActor(FX_54, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
     if (spawnactor)
     {
         spawnactor->spr.ang = 1024;
@@ -302,17 +302,17 @@ void fxSpawnPodStuff(DBloodActor* actor, int )
 void fxSpawnEjectingBrass(DBloodActor* actor, int z, int a3, int a4)
 {
     auto pSprite = &actor->s();
-    int x = pSprite->pos.X + MulScale(pSprite->clipdist - 4, Cos(pSprite->ang), 28);
-    int y = pSprite->pos.Y + MulScale(pSprite->clipdist - 4, Sin(pSprite->ang), 28);
-    x += MulScale(a3, Cos(pSprite->ang + 512), 30);
-    y += MulScale(a3, Sin(pSprite->ang + 512), 30);
-    auto pBrass = gFX.fxSpawnActor((FX_ID)(FX_37 + Random(3)), pSprite->sector(), x, y, z, 0);
+    int x = actor->spr.pos.X + MulScale(actor->spr.clipdist - 4, Cos(actor->spr.ang), 28);
+    int y = actor->spr.pos.Y + MulScale(actor->spr.clipdist - 4, Sin(actor->spr.ang), 28);
+    x += MulScale(a3, Cos(actor->spr.ang + 512), 30);
+    y += MulScale(a3, Sin(actor->spr.ang + 512), 30);
+    auto pBrass = gFX.fxSpawnActor((FX_ID)(FX_37 + Random(3)), actor->spr.sector(), x, y, z, 0);
     if (pBrass)
     {
         if (!VanillaMode())
             pBrass->spr.ang = Random(2047);
         int nDist = (a4 << 18) / 120 + Random2(((a4 / 4) << 18) / 120);
-        int nAngle = pSprite->ang + Random2(56) + 512;
+        int nAngle = actor->spr.ang + Random2(56) + 512;
         pBrass->xvel = MulScale(nDist, Cos(nAngle), 30);
         pBrass->yvel = MulScale(nDist, Sin(nAngle), 30);
         pBrass->zvel = actor->zvel - (0x20000 + (Random2(40) << 18) / 120);
@@ -322,17 +322,17 @@ void fxSpawnEjectingBrass(DBloodActor* actor, int z, int a3, int a4)
 void fxSpawnEjectingShell(DBloodActor* actor, int z, int a3, int a4)
 {
     auto pSprite = &actor->s();
-    int x = pSprite->pos.X + MulScale(pSprite->clipdist - 4, Cos(pSprite->ang), 28);
-    int y = pSprite->pos.Y + MulScale(pSprite->clipdist - 4, Sin(pSprite->ang), 28);
-    x += MulScale(a3, Cos(pSprite->ang + 512), 30);
-    y += MulScale(a3, Sin(pSprite->ang + 512), 30);
-    auto pShell = gFX.fxSpawnActor((FX_ID)(FX_40 + Random(3)), pSprite->sector(), x, y, z, 0);
+    int x = actor->spr.pos.X + MulScale(actor->spr.clipdist - 4, Cos(actor->spr.ang), 28);
+    int y = actor->spr.pos.Y + MulScale(actor->spr.clipdist - 4, Sin(actor->spr.ang), 28);
+    x += MulScale(a3, Cos(actor->spr.ang + 512), 30);
+    y += MulScale(a3, Sin(actor->spr.ang + 512), 30);
+    auto pShell = gFX.fxSpawnActor((FX_ID)(FX_40 + Random(3)), actor->spr.sector(), x, y, z, 0);
     if (pShell)
     {
         if (!VanillaMode())
             pShell->spr.ang = Random(2047);
         int nDist = (a4 << 18) / 120 + Random2(((a4 / 4) << 18) / 120);
-        int nAngle = pSprite->ang + Random2(56) + 512;
+        int nAngle = actor->spr.ang + Random2(56) + 512;
         pShell->xvel = MulScale(nDist, Cos(nAngle), 30);
         pShell->yvel = MulScale(nDist, Sin(nAngle), 30);
         pShell->zvel = actor->zvel - (0x20000 + (Random2(20) << 18) / 120);
diff --git a/source/games/blood/src/gameutil.cpp b/source/games/blood/src/gameutil.cpp
index 7c6eed1ef..71958dab0 100644
--- a/source/games/blood/src/gameutil.cpp
+++ b/source/games/blood/src/gameutil.cpp
@@ -106,24 +106,24 @@ bool CheckProximity(DBloodActor *actor, int nX, int nY, int nZ, sectortype* pSec
 {
     assert(actor != NULL);
     auto pSprite = &actor->s();
-    int oX = abs(nX-pSprite->pos.X)>>4;
+    int oX = abs(nX-actor->spr.pos.X)>>4;
     if (oX >= nDist) return 0;
 
-    int oY = abs(nY-pSprite->pos.Y)>>4;
+    int oY = abs(nY-actor->spr.pos.Y)>>4;
     if (oY >= nDist) return 0;
 
-    int oZ = abs(nZ-pSprite->pos.Z)>>8;
+    int oZ = abs(nZ-actor->spr.pos.Z)>>8;
     if (oZ >= nDist) return 0;
 
     if (approxDist(oX, oY) >= nDist) return 0;
 
     int bottom, top;
     GetActorExtents(actor, &top, &bottom);
-    if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), nX, nY, nZ, pSector))
+    if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), nX, nY, nZ, pSector))
         return 1;
-    if (cansee(pSprite->pos.X, pSprite->pos.Y, bottom, pSprite->sector(), nX, nY, nZ, pSector))
+    if (cansee(actor->spr.pos.X, actor->spr.pos.Y, bottom, actor->spr.sector(), nX, nY, nZ, pSector))
         return 1;
-    if (cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), nX, nY, nZ, pSector))
+    if (cansee(actor->spr.pos.X, actor->spr.pos.Y, top, actor->spr.sector(), nX, nY, nZ, pSector))
         return 1;
     return 0;
 }
@@ -341,23 +341,23 @@ int HitScan(DBloodActor *actor, int z, int dx, int dy, int dz, unsigned int nMas
     auto pSprite = &actor->s();
     assert(dx != 0 || dy != 0);
     gHitInfo.clearObj();
-    int x = pSprite->pos.X;
-    int y = pSprite->pos.Y;
-    auto bakCstat = pSprite->cstat;
-    pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
+    int x = actor->spr.pos.X;
+    int y = actor->spr.pos.Y;
+    auto bakCstat = actor->spr.cstat;
+    actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
     if (nRange)
     {
-        hitscangoal.X = x + MulScale(nRange << 4, Cos(pSprite->ang), 30);
-        hitscangoal.Y = y + MulScale(nRange << 4, Sin(pSprite->ang), 30);
+        hitscangoal.X = x + MulScale(nRange << 4, Cos(actor->spr.ang), 30);
+        hitscangoal.Y = y + MulScale(nRange << 4, Sin(actor->spr.ang), 30);
     }
     else
     {
         hitscangoal.X = hitscangoal.Y = 0x1ffffff;
     }
-    hitscan({ x, y, z }, pSprite->sector(), { dx, dy, dz << 4 }, gHitInfo, nMask);
+    hitscan({ x, y, z }, actor->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, nMask);
 
     hitscangoal.X = hitscangoal.Y = 0x1ffffff;
-    pSprite->cstat = bakCstat;
+    actor->spr.cstat = bakCstat;
     if (gHitInfo.actor() != nullptr)
         return 3;
     if (gHitInfo.hitWall != nullptr)
@@ -385,28 +385,28 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
     int nNum = 256;
     assert(pSprite != NULL);
     gHitInfo.clearObj();
-    int x1 = pSprite->pos.X+MulScale(nOffset, Cos(pSprite->ang+512), 30);
-    int y1 = pSprite->pos.Y+MulScale(nOffset, Sin(pSprite->ang+512), 30);
-    int z1 = pSprite->pos.Z+nZOffset;
-    auto bakCstat = pSprite->cstat;
-    pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
+    int x1 = actor->spr.pos.X+MulScale(nOffset, Cos(actor->spr.ang+512), 30);
+    int y1 = actor->spr.pos.Y+MulScale(nOffset, Sin(actor->spr.ang+512), 30);
+    int z1 = actor->spr.pos.Z+nZOffset;
+    auto bakCstat = actor->spr.cstat;
+    actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
     if (nRange)
     {
-        hitscangoal.X = x1+MulScale(nRange<<4, Cos(pSprite->ang), 30);
-        hitscangoal.Y = y1+MulScale(nRange<<4, Sin(pSprite->ang), 30);
+        hitscangoal.X = x1+MulScale(nRange<<4, Cos(actor->spr.ang), 30);
+        hitscangoal.Y = y1+MulScale(nRange<<4, Sin(actor->spr.ang), 30);
     }
     else
     {
         hitscangoal.X = hitscangoal.Y = 0x1fffffff;
     }
     vec3_t pos = { x1, y1, z1 };
-    hitscan(pos, pSprite->sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
+    hitscan(pos, actor->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
 
     hitscangoal.X = hitscangoal.Y = 0x1ffffff;
-    pSprite->cstat = bakCstat;
+    actor->spr.cstat = bakCstat;
     while (nNum--)
     {
-        if (nRange && approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->pos.Y) > nRange)
+        if (nRange && approxDist(gHitInfo.hitpos.X - actor->spr.pos.X, gHitInfo.hitpos.Y - actor->spr.pos.Y) > nRange)
             return -1;
         if (gHitInfo.actor() != nullptr)
         {
@@ -560,10 +560,10 @@ void GetZRange(DBloodActor *actor, int *ceilZ, Collision *ceilColl, int *floorZ,
     auto pSprite = &actor->s();
     Collision scratch;
 
-    auto bakCstat = pSprite->cstat;
+    auto bakCstat = actor->spr.cstat;
     int32_t nTemp1;
-    pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
-    getzrange(pSprite->pos, pSprite->sector(), (int32_t*)ceilZ, *ceilColl, (int32_t*)floorZ, *floorColl, nDist, nMask);
+    actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
+    getzrange(actor->spr.pos, actor->spr.sector(), (int32_t*)ceilZ, *ceilColl, (int32_t*)floorZ, *floorColl, nDist, nMask);
     if (floorColl->type == kHitSector)
     {
         auto pSector = floorColl->hitSector;
@@ -578,7 +578,7 @@ void GetZRange(DBloodActor *actor, int *ceilZ, Collision *ceilColl, int *floorZ,
         if (actor)
         {
             auto link = actor->GetOwner();
-            vec3_t lpos = pSprite->pos + link->spr.pos - actor->spr.pos;
+            vec3_t lpos = actor->spr.pos + link->spr.pos - actor->spr.pos;
             getzrange(lpos, link->spr.sector(), &nTemp1, scratch, (int32_t*)floorZ, *floorColl, nDist, nMask);
             *floorZ -= link->spr.pos.Z - actor->spr.pos.Z;
         }
@@ -592,12 +592,12 @@ void GetZRange(DBloodActor *actor, int *ceilZ, Collision *ceilColl, int *floorZ,
         if (actor)
         {
             auto link = actor->GetOwner();
-            vec3_t lpos = pSprite->pos + link->spr.pos - actor->spr.pos;
+            vec3_t lpos = actor->spr.pos + link->spr.pos - actor->spr.pos;
             getzrange(lpos, link->spr.sector(), (int32_t*)ceilZ, *ceilColl, &nTemp1, scratch, nDist, nMask);
             *ceilZ -= link->spr.pos.Z - actor->spr.pos.Z;
         }
     }
-    pSprite->cstat = bakCstat;
+    actor->spr.cstat = bakCstat;
 }
 
 void GetZRangeAtXYZ(int x, int y, int z, sectortype* pSector, int *ceilZ, Collision* ceilColl, int* floorZ, Collision* floorColl, int nDist, unsigned int nMask, unsigned int nClipParallax)
diff --git a/source/games/blood/src/gib.cpp b/source/games/blood/src/gib.cpp
index 8c8896bd4..f9b285359 100644
--- a/source/games/blood/src/gib.cpp
+++ b/source/games/blood/src/gib.cpp
@@ -266,10 +266,10 @@ int ChanceToCount(int a1, int a2)
 void GibFX(DBloodActor* actor, GIBFX *pGFX, CGibPosition *pPos, CGibVelocity *pVel)
 {
     spritetype* pSprite = &actor->s();
-    auto pSector = pSprite->sector();
+    auto pSector = actor->spr.sector();
     if (adult_lockout && gGameOptions.nGameType == 0 && pGFX->fxId == FX_13)
         return;
-    CGibPosition gPos(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
+    CGibPosition gPos(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
     if (pPos)
         gPos = *pPos;
     int32_t ceilZ, floorZ;
@@ -281,18 +281,18 @@ void GibFX(DBloodActor* actor, GIBFX *pGFX, CGibPosition *pPos, CGibVelocity *pV
     GetActorExtents(actor, &top, &bottom);
     for (int i = 0; i < nCount; i++)
     {
-        if (!pPos && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
+        if (!pPos && (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
         {
             int nAngle = Random(2048);
-            gPos.x = pSprite->pos.X+MulScale(pSprite->clipdist<<2, Cos(nAngle), 30);
-            gPos.y = pSprite->pos.Y+MulScale(pSprite->clipdist<<2, Sin(nAngle), 30);
+            gPos.x = actor->spr.pos.X+MulScale(actor->spr.clipdist<<2, Cos(nAngle), 30);
+            gPos.y = actor->spr.pos.Y+MulScale(actor->spr.clipdist<<2, Sin(nAngle), 30);
             gPos.z = bottom-Random(bottom-top);
         }
         auto pFX = gFX.fxSpawnActor(pGFX->fxId, pSector, gPos.x, gPos.y, gPos.z, 0);
         if (pFX)
         {
             if (pGFX->at1 < 0)
-                pFX->spr.pal = pSprite->pal;
+                pFX->spr.pal = actor->spr.pal;
             if (pVel)
             {
                 pFX->xvel = pVel->vx+Random2(pGFX->atd);
@@ -303,7 +303,7 @@ void GibFX(DBloodActor* actor, GIBFX *pGFX, CGibPosition *pPos, CGibVelocity *pV
             {
                 pFX->xvel = Random2((pGFX->atd<<18)/120);
                 pFX->yvel = Random2((pGFX->atd<<18)/120);
-                switch(pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK)
+                switch(actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK)
                 {
                 case 16:
                     pFX->zvel = Random2((pGFX->at11<<18)/120);
@@ -343,15 +343,15 @@ void GibThing(DBloodActor* actor, GIBTHING *pGThing, CGibPosition *pPos, CGibVel
 
     if (pGThing->chance == 65536 || Chance(pGThing->chance))
     {
-        auto pSector = pSprite->sector();
+        auto pSector = actor->spr.sector();
         int top, bottom;
         GetActorExtents(actor, &top, &bottom);
         int x, y, z;
         if (!pPos)
         {
             int nAngle = Random(2048);
-            x = pSprite->pos.X+MulScale(pSprite->clipdist<<2, Cos(nAngle), 30);
-            y = pSprite->pos.Y+MulScale(pSprite->clipdist<<2, Sin(nAngle), 30);
+            x = actor->spr.pos.X+MulScale(actor->spr.clipdist<<2, Cos(nAngle), 30);
+            y = actor->spr.pos.Y+MulScale(actor->spr.clipdist<<2, Sin(nAngle), 30);
             z = bottom-Random(bottom-top);
         }
         else
@@ -380,7 +380,7 @@ void GibThing(DBloodActor* actor, GIBTHING *pGThing, CGibPosition *pPos, CGibVel
         {
             gibactor->xvel = Random2((pGThing->atc<<18)/120);
             gibactor->yvel = Random2((pGThing->atc<<18)/120);
-            switch (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK)
+            switch (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK)
             {
             case 16:
                 gibactor->zvel = Random2((pGThing->at10<<18)/120);
diff --git a/source/games/blood/src/nnexts.cpp b/source/games/blood/src/nnexts.cpp
index 0a460a8df..3172a7f5f 100644
--- a/source/games/blood/src/nnexts.cpp
+++ b/source/games/blood/src/nnexts.cpp
@@ -346,15 +346,15 @@ bool nnExtIsImmune(DBloodActor* actor, int dmgType, int minScale)
     auto pSprite = &actor->s();
     if (dmgType >= kDmgFall && dmgType < kDmgMax && actor->hasX() && actor->xspr.locked != 1) 
     {
-        if (pSprite->type >= kThingBase && pSprite->type < kThingMax)
+        if (actor->spr.type >= kThingBase && actor->spr.type < kThingMax)
         {
-            return (thingInfo[pSprite->type - kThingBase].dmgControl[dmgType] <= minScale);
+            return (thingInfo[actor->spr.type - kThingBase].dmgControl[dmgType] <= minScale);
         }
         else if (actor->IsDudeActor()) 
         {
-            if (actor->IsPlayerActor()) return (gPlayer[pSprite->type - kDudePlayer1].damageControl[dmgType]);
-            else if (pSprite->type == kDudeModernCustom) return (actor->genDudeExtra.dmgControl[dmgType] <= minScale);
-            else return (getDudeInfo(pSprite->type)->damageVal[dmgType] <= minScale);
+            if (actor->IsPlayerActor()) return (gPlayer[actor->spr.type - kDudePlayer1].damageControl[dmgType]);
+            else if (actor->spr.type == kDudeModernCustom) return (actor->genDudeExtra.dmgControl[dmgType] <= minScale);
+            else return (getDudeInfo(actor->spr.type)->damageVal[dmgType] <= minScale);
         }
     }
 
@@ -373,7 +373,7 @@ bool nnExtEraseModernStuff(DBloodActor* actor)
     auto pXSprite = &actor->x();
 
     bool erased = false;
-    switch (pSprite->type) {
+    switch (actor->spr.type) {
         // erase all modern types if the map is not extended
         case kModernSpriteDamager:
         case kModernCustomDudeSpawn:
@@ -394,7 +394,7 @@ bool nnExtEraseModernStuff(DBloodActor* actor)
         case kModernConditionFalse:
         case kModernSlopeChanger:
         case kModernStealthRegion:
-            pSprite->type = kSpriteDecoration;
+            actor->spr.type = kSpriteDecoration;
             erased = true;
             break;
         case kItemModernMapLevel:
@@ -402,14 +402,14 @@ bool nnExtEraseModernStuff(DBloodActor* actor)
         case kDudeModernCustomBurning:
         case kModernThingTNTProx:
         case kModernThingEnemyLifeLeech:
-            pSprite->type = kSpriteDecoration;
+            actor->spr.type = kSpriteDecoration;
             ChangeActorStat(actor, kStatDecoration);
             erased = true;
             break;
         // also erase some modernized vanilla types which was not active
         case kMarkerWarpDest:
-            if (pSprite->statnum == kStatMarker) break;
-            pSprite->type = kSpriteDecoration;
+            if (actor->spr.statnum == kStatMarker) break;
+            actor->spr.type = kSpriteDecoration;
             erased = true;
             break;
     }
@@ -423,7 +423,7 @@ bool nnExtEraseModernStuff(DBloodActor* actor)
     if (pXSprite->Proximity) 
     {
         // proximity works only for things and dudes in vanilla
-        switch (pSprite->statnum) 
+        switch (actor->spr.statnum) 
         {
             case kStatThing:
             case kStatDude:
@@ -527,7 +527,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
         XSPRITE* pXSprite = &actor->x();
         spritetype* pSprite = &actor->s();
         
-        switch (pSprite->type) {
+        switch (actor->spr.type) {
             case kModernRandomTX:
             case kModernSequentialTX:
                 if (pXSprite->command == kCmdLink) gEventRedirectsUsed = true;
@@ -539,7 +539,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
             case kModernCondition:
             case kModernConditionFalse:
                 if (!pXSprite->rxID && pXSprite->data1 > kCondGameMax) condError(actor,"\nThe condition must have RX ID!\nSPRITE #%d", actor->GetIndex());
-                else if (!pXSprite->txID && !pSprite->flags) 
+                else if (!pXSprite->txID && !actor->spr.flags) 
                 {
                     Printf(PRINT_HIGH, "The condition must have TX ID or hitag to be set: RX ID %d, SPRITE #%d", pXSprite->rxID, actor->GetIndex());
                 }
@@ -555,37 +555,37 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
                 pXSprite->sysData2 = pXSprite->data4;
             
             // check reserved statnums
-            if (pSprite->statnum >= kStatModernBase && pSprite->statnum < kStatModernMax) 
+            if (actor->spr.statnum >= kStatModernBase && actor->spr.statnum < kStatModernMax) 
             {
                 bool sysStat = true;
-                switch (pSprite->statnum) 
+                switch (actor->spr.statnum) 
                 {
                     case kStatModernStealthRegion:
-                        sysStat = (pSprite->type != kModernStealthRegion);
+                        sysStat = (actor->spr.type != kModernStealthRegion);
                         break;
                     case kStatModernDudeTargetChanger:
-                        sysStat = (pSprite->type != kModernDudeTargetChanger);
+                        sysStat = (actor->spr.type != kModernDudeTargetChanger);
                         break;
                     case kStatModernCondition:
-                        sysStat = (pSprite->type != kModernCondition && pSprite->type != kModernConditionFalse);
+                        sysStat = (actor->spr.type != kModernCondition && actor->spr.type != kModernConditionFalse);
                         break;
                     case kStatModernEventRedirector:
-                        sysStat = (pSprite->type != kModernRandomTX && pSprite->type != kModernSequentialTX);
+                        sysStat = (actor->spr.type != kModernRandomTX && actor->spr.type != kModernSequentialTX);
                         break;
                     case kStatModernWindGen:
-                        sysStat = (pSprite->type != kModernWindGenerator);
+                        sysStat = (actor->spr.type != kModernWindGenerator);
                         break;
                     case kStatModernPlayerLinker:
                     case kStatModernQavScene:
-                        sysStat = (pSprite->type != kModernPlayerControl);
+                        sysStat = (actor->spr.type != kModernPlayerControl);
                         break;
                 }
 
                 if (sysStat)
-                    I_Error("Sprite statnum %d on sprite #%d is in a range of reserved (%d - %d)!", pSprite->statnum, actor->GetIndex(), kStatModernBase, kStatModernMax);
+                    I_Error("Sprite statnum %d on sprite #%d is in a range of reserved (%d - %d)!", actor->spr.statnum, actor->GetIndex(), kStatModernBase, kStatModernMax);
             }
 
-            switch (pSprite->type) 
+            switch (actor->spr.type) 
             {
                 case kModernRandomTX:
                 case kModernSequentialTX:
@@ -594,7 +594,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
                     ChangeActorStat(actor, kStatModernEventRedirector);
                     break;
                 case kModernWindGenerator:
-                    pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
+                    actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK;
                     ChangeActorStat(actor, kStatModernWindGen);
                     break;
                 case kModernDudeTargetChanger:
@@ -602,9 +602,9 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
                 case kModernRandom:
                 case kModernRandom2:
                 case kModernStealthRegion:
-                    pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
-                    pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
-                    switch (pSprite->type) 
+                    actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK;
+                    actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
+                    switch (actor->spr.type) 
                     {
                         // stealth regions for patrolling enemies
                         case kModernStealthRegion:
@@ -673,7 +673,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
                                 I_Error("\nPlayer Control (SPRITE #%d):\nPlayer %d already linked with different player control sprite #%d!", actor->GetIndex(), pXSprite->data1, iactor->GetIndex());
                             }
                             pXSprite->sysData1 = -1;
-                            pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
+                            actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK;
                             ChangeActorStat(actor, kStatModernPlayerLinker);
                             break;
                         }
@@ -706,16 +706,16 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
                     pXSprite->targetX = pXSprite->targetY = pXSprite->targetZ = pXSprite->sysData2 = -1;
                     actor->SetTarget(nullptr);
                     ChangeActorStat(actor, kStatModernCondition);
-                    auto oldStat = pSprite->cstat; 
-                    pSprite->cstat = CSTAT_SPRITE_ALIGNMENT_SLOPE;
+                    auto oldStat = actor->spr.cstat; 
+                    actor->spr.cstat = CSTAT_SPRITE_ALIGNMENT_SLOPE;
                     
                     if (oldStat & CSTAT_SPRITE_BLOCK) 
-                        pSprite->cstat |= CSTAT_SPRITE_BLOCK;
+                        actor->spr.cstat |= CSTAT_SPRITE_BLOCK;
                     
-                    if (oldStat & CSTAT_SPRITE_MOVE_FORWARD) pSprite->cstat |= CSTAT_SPRITE_MOVE_FORWARD;
-                    else if (oldStat & CSTAT_SPRITE_MOVE_REVERSE) pSprite->cstat |= CSTAT_SPRITE_MOVE_REVERSE;
+                    if (oldStat & CSTAT_SPRITE_MOVE_FORWARD) actor->spr.cstat |= CSTAT_SPRITE_MOVE_FORWARD;
+                    else if (oldStat & CSTAT_SPRITE_MOVE_REVERSE) actor->spr.cstat |= CSTAT_SPRITE_MOVE_REVERSE;
 
-                    pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
+                    actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
                     break;
             }
 
@@ -727,15 +727,15 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
                 pXSprite->Proximity = false;
             
             // very quick fix for floor sprites with Touch trigger flag if their Z is equals sector floorz / ceilgz
-            if (pSprite->insector() && pXSprite->Touch && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)) {
-                if (pSprite->pos.Z == pSprite->sector()->floorz) pSprite->pos.Z--;
-                else if (pSprite->pos.Z == pSprite->sector()->ceilingz) pSprite->pos.Z++;
+            if (actor->spr.insector() && pXSprite->Touch && (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)) {
+                if (actor->spr.pos.Z == actor->spr.sector()->floorz) actor->spr.pos.Z--;
+                else if (actor->spr.pos.Z == actor->spr.sector()->ceilingz) actor->spr.pos.Z++;
             }
 
         // make Proximity flag work not just for dudes and things...
         if (pXSprite->Proximity && gProxySpritesCount < kMaxSuperXSprites) 
         {
-            switch (pSprite->statnum) 
+            switch (actor->spr.statnum) 
             {
                 case kStatFX:           case kStatExplosion:            case kStatItem:
                 case kStatPurge:        case kStatSpares:               case kStatFlare:
@@ -754,7 +754,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
         // make Sight, Screen, Aim flags work not just for dudes and things...
         if ((pXSprite->Sight || pXSprite->unused3) && gSightSpritesCount < kMaxSuperXSprites) 
         {
-            switch (pSprite->statnum) 
+            switch (actor->spr.statnum) 
             {
                 case kStatFX:           case kStatExplosion:            case kStatItem:
                 case kStatPurge:        case kStatSpares:               case kStatFlare:
@@ -772,7 +772,7 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
         // make Impact flag work for sprites that affected by explosions...
         if (pXSprite->Impact && gImpactSpritesCount < kMaxSuperXSprites) 
         {
-            switch (pSprite->statnum) 
+            switch (actor->spr.statnum) 
             {
                 case kStatFX:           case kStatExplosion:            case kStatItem:
                 case kStatPurge:        case kStatSpares:               case kStatFlare:
@@ -1348,8 +1348,8 @@ void nnExtProcessSuperSprites()
                         int nSpeed = approxDist(pact->xvel, pact->yvel);
                             nSpeed = ClipLow(nSpeed - MulScale(nSpeed, mass, 6), 0x9000 - (mass << 3));
 
-                            debrisactor->xvel += MulScale(nSpeed, Cos(pPlayer->pSprite->ang), 30);
-                            debrisactor->yvel += MulScale(nSpeed, Sin(pPlayer->pSprite->ang), 30);
+                            debrisactor->xvel += MulScale(nSpeed, Cos(pPlayer->actor->spr.ang), 30);
+                            debrisactor->yvel += MulScale(nSpeed, Sin(pPlayer->actor->spr.ang), 30);
 
                         debrisactor->hit.hit.setSprite(pPlayer->actor);
                     }
@@ -1423,14 +1423,14 @@ void sfxPlayVectorSound(DBloodActor* actor, int vectorId)
 int getSpriteMassBySize(DBloodActor* actor)
 {
     auto pSprite = &actor->s();
-    int mass = 0; int seqId = -1; int clipDist = pSprite->clipdist;
+    int mass = 0; int seqId = -1; int clipDist = actor->spr.clipdist;
     if (!actor->hasX())
     {
-        I_Error("getSpriteMassBySize: pSprite->hasX == false");
+        I_Error("getSpriteMassBySize: actor->spr.hasX == false");
     }
     else if (actor->IsDudeActor()) 
     {
-        switch (pSprite->type) 
+        switch (actor->spr.type) 
         {
         case kDudePodMother: // fake dude, no seq
             break;
@@ -1440,7 +1440,7 @@ int getSpriteMassBySize(DBloodActor* actor)
             clipDist = actor->genDudeExtra.initVals[2];
             break;
         default:
-            seqId = getDudeInfo(pSprite->type)->seqStartID;
+            seqId = getDudeInfo(actor->spr.type)->seqStartID;
             break;
         }
     } 
@@ -1450,13 +1450,13 @@ int getSpriteMassBySize(DBloodActor* actor)
     }
 
     SPRITEMASS* cached = &actor->spriteMass;
-    if (((seqId >= 0 && seqId == cached->seqId) || pSprite->picnum == cached->picnum) && pSprite->xrepeat == cached->xrepeat &&
-        pSprite->yrepeat == cached->yrepeat && clipDist == cached->clipdist) 
+    if (((seqId >= 0 && seqId == cached->seqId) || actor->spr.picnum == cached->picnum) && actor->spr.xrepeat == cached->xrepeat &&
+        actor->spr.yrepeat == cached->yrepeat && clipDist == cached->clipdist) 
     {
         return cached->mass;
     }
 
-    int picnum = pSprite->picnum;
+    int picnum = actor->spr.picnum;
     int massDiv = 30; 
     int addMul = 2; 
     int subMul = 2;
@@ -1469,17 +1469,17 @@ int getSpriteMassBySize(DBloodActor* actor)
             picnum = seqGetTile(&pSeq->frames[0]);
         } 
         else
-            picnum = pSprite->picnum;
+            picnum = actor->spr.picnum;
     }
 
-    clipDist = ClipLow(pSprite->clipdist, 1);
+    clipDist = ClipLow(actor->spr.clipdist, 1);
     int x = tileWidth(picnum);        
     int y = tileHeight(picnum);
-    int xrepeat = pSprite->xrepeat; 	
-    int yrepeat = pSprite->yrepeat;
+    int xrepeat = actor->spr.xrepeat; 	
+    int yrepeat = actor->spr.yrepeat;
 
     // take surface type into account
-    switch (tileGetSurfType(pSprite->picnum)) 
+    switch (tileGetSurfType(actor->spr.picnum)) 
     {
         case 1:  massDiv = 16; break; // stone
         case 2:  massDiv = 18; break; // metal
@@ -1531,11 +1531,11 @@ int getSpriteMassBySize(DBloodActor* actor)
     cached->airVel = ClipRange(400 - cached->mass, 32, 400);
     cached->fraction = ClipRange(60000 - (cached->mass << 7), 8192, 60000);
 
-    cached->xrepeat = pSprite->xrepeat;             
-    cached->yrepeat = pSprite->yrepeat;
-    cached->picnum = pSprite->picnum;              
+    cached->xrepeat = actor->spr.xrepeat;             
+    cached->yrepeat = actor->spr.yrepeat;
+    cached->picnum = actor->spr.picnum;              
     cached->seqId = seqId;
-    cached->clipdist = pSprite->clipdist;
+    cached->clipdist = actor->spr.clipdist;
 
     return cached->mass;
 }
@@ -1587,10 +1587,10 @@ void debrisConcuss(DBloodActor* owneractor, int listIndex, int x, int y, int z,
     if (actor != nullptr && actor->hasX())
     {
         spritetype* pSprite = &actor->s();
-        int dx = pSprite->pos.X - x; int dy = pSprite->pos.Y - y; int dz = (pSprite->pos.Z - z) >> 4;
+        int dx = actor->spr.pos.X - x; int dy = actor->spr.pos.Y - y; int dz = (actor->spr.pos.Z - z) >> 4;
         dmg = scale(0x40000, dmg, 0x40000 + dx * dx + dy * dy + dz * dz);
-        bool thing = (pSprite->type >= kThingBase && pSprite->type < kThingMax);
-        int size = (tileWidth(pSprite->picnum) * pSprite->xrepeat * tileHeight(pSprite->picnum) * pSprite->yrepeat) >> 1;
+        bool thing = (actor->spr.type >= kThingBase && actor->spr.type < kThingMax);
+        int size = (tileWidth(actor->spr.picnum) * actor->spr.xrepeat * tileHeight(actor->spr.picnum) * actor->spr.yrepeat) >> 1;
         if (actor->xspr.physAttr & kPhysDebrisExplode) 
         {
             if (actor->spriteMass.mass > 0) 
@@ -1603,13 +1603,13 @@ void debrisConcuss(DBloodActor* owneractor, int listIndex, int x, int y, int z,
             }
 
             if (thing)
-                pSprite->statnum = kStatThing; // temporary change statnum property
+                actor->spr.statnum = kStatThing; // temporary change statnum property
         }
 
         actDamageSprite(owneractor, actor, kDamageExplode, dmg);
         
         if (thing)
-            pSprite->statnum = kStatDecoration; // return statnum property back
+            actor->spr.statnum = kStatDecoration; // return statnum property back
     }
 }
 
@@ -1627,12 +1627,12 @@ void debrisBubble(DBloodActor* actor)
     GetSpriteExtents(pSprite, &top, &bottom);
     for (unsigned int i = 0; i < 1 + Random(5); i++) {
         
-        int nDist = (pSprite->xrepeat * (tileWidth(pSprite->picnum) >> 1)) >> 2;
+        int nDist = (actor->spr.xrepeat * (tileWidth(actor->spr.picnum) >> 1)) >> 2;
         int nAngle = Random(2048);
-        int x = pSprite->pos.X + MulScale(nDist, Cos(nAngle), 30);
-        int y = pSprite->pos.Y + MulScale(nDist, Sin(nAngle), 30);
+        int x = actor->spr.pos.X + MulScale(nDist, Cos(nAngle), 30);
+        int y = actor->spr.pos.Y + MulScale(nDist, Sin(nAngle), 30);
         int z = bottom - Random(bottom - top);
-        auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23 + Random(3)), pSprite->sector(), x, y, z, 0);
+        auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23 + Random(3)), actor->spr.sector(), x, y, z, 0);
         if (pFX) {
             pFX->xvel = actor->xvel + Random2(0x1aaaa);
             pFX->yvel = actor->yvel + Random2(0x1aaaa);
@@ -1656,7 +1656,7 @@ void debrisMove(int listIndex)
     DBloodActor* actor = gPhysSpritesList[listIndex];
     XSPRITE* pXSprite = &actor->x();
     spritetype* pSprite = &actor->s();   
-    auto pSector = pSprite->sector();
+    auto pSector = actor->spr.sector();
 
     if (!actor->hasX() || !pSector)
     {
@@ -1669,9 +1669,9 @@ void debrisMove(int listIndex)
 
     Collision moveHit;
     moveHit.setNone();
-    int floorDist = (bottom - pSprite->pos.Z) >> 2;
-    int ceilDist = (pSprite->pos.Z - top) >> 2;
-    int clipDist = pSprite->clipdist << 2;
+    int floorDist = (bottom - actor->spr.pos.Z) >> 2;
+    int ceilDist = (actor->spr.pos.Z - top) >> 2;
+    int clipDist = actor->spr.clipdist << 2;
     int mass = actor->spriteMass.mass;
 
     bool uwater = false;
@@ -1685,15 +1685,15 @@ void debrisMove(int listIndex)
     if (actor->xvel || actor->yvel) 
     {
 
-        auto oldcstat = pSprite->cstat;
-        pSprite->cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
+        auto oldcstat = actor->spr.cstat;
+        actor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK | CSTAT_SPRITE_BLOCK_HITSCAN);
 
-        ClipMove(pSprite->pos, &pSector, actor->xvel >> 12,
+        ClipMove(actor->spr.pos, &pSector, actor->xvel >> 12,
             actor->yvel >> 12, clipDist, ceilDist, floorDist, CLIPMASK0, moveHit);
         actor->hit.hit = moveHit;
 
-        pSprite->cstat = oldcstat;
-        if (pSprite->sector() != pSector) 
+        actor->spr.cstat = oldcstat;
+        if (actor->spr.sector() != pSector) 
         {
             if (!pSector) return;
             else ChangeActorSect(actor, pSector);
@@ -1702,7 +1702,7 @@ void debrisMove(int listIndex)
         if (pSector->type >= kSectorPath && pSector->type <= kSectorRotate) 
         {
             auto pSector2 = pSector;
-            if (pushmove(&pSprite->pos, &pSector2, clipDist, ceilDist, floorDist, CLIPMASK0) != -1)
+            if (pushmove(&actor->spr.pos, &pSector2, clipDist, ceilDist, floorDist, CLIPMASK0) != -1)
                 pSector = pSector2;
         }
 
@@ -1713,23 +1713,23 @@ void debrisMove(int listIndex)
         }
 
     } 
-    else if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector)) 
+    else if (!FindSector(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, &pSector)) 
     {
         return;
     }
 
-    if (pSprite->sector() != pSector)
+    if (actor->spr.sector() != pSector)
     {
         assert(pSector);
         ChangeActorSect(actor, pSector);
-        pSector = pSprite->sector();
+        pSector = actor->spr.sector();
     }
 
     if (pSector->hasX())
         uwater = pSector->xs().Underwater;
 
     if (actor->zvel)
-        pSprite->pos.Z += actor->zvel >> 8;
+        actor->spr.pos.Z += actor->zvel >> 8;
 
     int ceilZ, floorZ;
     Collision ceilColl, floorColl;
@@ -1739,8 +1739,8 @@ void debrisMove(int listIndex)
     if ((pXSprite->physAttr & kPhysDebrisSwim) && uwater) 
     {
         int vc = 0;
-        int cz = getceilzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
-        int fz = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
+        int cz = getceilzofslopeptr(pSector, actor->spr.pos.X, actor->spr.pos.Y);
+        int fz = getflorzofslopeptr(pSector, actor->spr.pos.X, actor->spr.pos.Y);
         int div = ClipLow(bottom - top, 1);
 
         if (pSector->lowerLink) cz += (cz < 0) ? 0x500 : -0x500;
@@ -1752,14 +1752,14 @@ void debrisMove(int listIndex)
 
         if (vc) 
         {
-            pSprite->pos.Z += ((vc << 2) >> 1) >> 8;
+            actor->spr.pos.Z += ((vc << 2) >> 1) >> 8;
             actor->zvel += vc;
         }
 
     }
     else if ((pXSprite->physAttr & kPhysGravity) && bottom < floorZ) 
     {
-        pSprite->pos.Z += 455;
+        actor->spr.pos.Z += 455;
         actor->zvel += 58254;
 
     }
@@ -1768,7 +1768,7 @@ void debrisMove(int listIndex)
     if ((i = CheckLink(actor)) != 0)
     {
         GetZRange(actor, &ceilZ, &ceilColl, &floorZ, &floorColl, clipDist, CLIPMASK0, PARALLAXCLIP_CEILING | PARALLAXCLIP_FLOOR);
-        if (!(pSprite->cstat & CSTAT_SPRITE_INVISIBLE))
+        if (!(actor->spr.cstat & CSTAT_SPRITE_INVISIBLE))
         {
             switch (i)
             {
@@ -1799,17 +1799,17 @@ void debrisMove(int listIndex)
     if (floorZ <= bottom) {
 
         actor->hit.florhit = floorColl;
-        int v30 = actor->zvel - pSprite->sector()->velFloor;
+        int v30 = actor->zvel - actor->spr.sector()->velFloor;
 
         if (v30 > 0) 
         {
             pXSprite->physAttr |= kPhysFalling;
-            actFloorBounceVector(&actor->xvel, &actor->yvel, &v30, pSprite->sector(), tmpFraction);
+            actFloorBounceVector(&actor->xvel, &actor->yvel, &v30, actor->spr.sector(), tmpFraction);
             actor->zvel = v30;
 
             if (abs(actor->zvel) < 0x10000)
             {
-                actor->zvel = pSprite->sector()->velFloor;
+                actor->zvel = actor->spr.sector()->velFloor;
                 pXSprite->physAttr &= ~kPhysFalling;
             }
 
@@ -1818,7 +1818,7 @@ void debrisMove(int listIndex)
             switch (tileGetSurfType(floorColl)) 
             {
             case kSurfLava:
-                if ((pFX = gFX.fxSpawnActor(FX_10, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, floorZ, 0)) == NULL) break;
+                if ((pFX = gFX.fxSpawnActor(FX_10, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0)) == NULL) break;
                 for (i = 0; i < 7; i++) 
                 {
                     if ((pFX2 = gFX.fxSpawnActor(FX_14, pFX->spr.sector(), pFX->spr.pos.X, pFX->spr.pos.Y, pFX->spr.pos.Z, 0)) == NULL) continue;
@@ -1828,7 +1828,7 @@ void debrisMove(int listIndex)
                 }
                 break;
             case kSurfWater:
-                gFX.fxSpawnActor(FX_9, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, floorZ, 0);
+                gFX.fxSpawnActor(FX_9, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
                 break;
             }
 
@@ -1848,7 +1848,7 @@ void debrisMove(int listIndex)
     if (top <= ceilZ) 
     {
         actor->hit.ceilhit = moveHit = ceilColl;
-        pSprite->pos.Z += ClipLow(ceilZ - top, 0);
+        actor->spr.pos.Z += ClipLow(ceilZ - top, 0);
         if (actor->zvel <= 0 && (pXSprite->physAttr & kPhysFalling))
             actor->zvel = MulScale(-actor->zvel, 0x2000, 16);
 
@@ -1860,7 +1860,7 @@ void debrisMove(int listIndex)
     }
 
     if (moveHit.type != kHitNone && pXSprite->Impact && !pXSprite->locked && !pXSprite->isTriggered && (pXSprite->state == pXSprite->restState || pXSprite->Interrutable)) {
-        if (pSprite->type >= kThingBase && pSprite->type < kThingMax)
+        if (actor->spr.type >= kThingBase && actor->spr.type < kThingMax)
             ChangeActorStat(actor, kStatThing);
 
         trTriggerSprite(actor, kCmdToggle);
@@ -1872,8 +1872,8 @@ void debrisMove(int listIndex)
 
         if ((floorColl.actor()->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
         {
-            actor->xvel += MulScale(4, pSprite->pos.X - floorColl.actor()->spr.pos.X, 2);
-            actor->yvel += MulScale(4, pSprite->pos.Y - floorColl.actor()->spr.pos.Y, 2);
+            actor->xvel += MulScale(4, actor->spr.pos.X - floorColl.actor()->spr.pos.X, 2);
+            actor->yvel += MulScale(4, actor->spr.pos.Y - floorColl.actor()->spr.pos.Y, 2);
             return;
         }
     }
@@ -2992,25 +2992,25 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
     auto pSource = &sourceactor->s();
     auto pXSource = &sourceactor->x();
 
-    PLAYER* pPlayer = getPlayerById(pSprite->type);
+    PLAYER* pPlayer = getPlayerById(actor->spr.type);
     XSECTOR* pXSector = (pSource->sector()->hasX()) ? &pSource->sector()->xs() : nullptr;
     bool isDude = (!pPlayer && actor->IsDudeActor());
 
-    if (pSprite->sector() != pSource->sector())
+    if (actor->spr.sector() != pSource->sector())
         ChangeActorSect(actor, pSource->sector());
 
-    pSprite->pos.X = pSource->pos.X; pSprite->pos.Y = pSource->pos.Y;
+    actor->spr.pos.X = pSource->pos.X; actor->spr.pos.Y = pSource->pos.Y;
     int zTop, zBot; 
     GetActorExtents(sourceactor, &zTop, &zBot);
-    pSprite->pos.Z = zBot;
+    actor->spr.pos.Z = zBot;
 
     clampSprite(actor, 0x01);
 
     if (pSource->flags & kModernTypeFlag1) // force telefrag
         TeleFrag(actor, pSource->sector());
 
-    if (pSprite->flags & kPhysGravity)
-        pSprite->flags |= kPhysFalling;
+    if (actor->spr.flags & kPhysGravity)
+        actor->spr.flags |= kPhysFalling;
 
     if (pXSector) 
     {
@@ -3063,7 +3063,7 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
         }
     }
 
-    if (pSprite->statnum == kStatDude && actor->IsDudeActor() && !actor->IsPlayerActor()) 
+    if (actor->spr.statnum == kStatDude && actor->IsDudeActor() && !actor->IsPlayerActor()) 
     {
         XSPRITE* pXDude = &actor->x();
         int x = pXDude->targetX;
@@ -3090,8 +3090,8 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
             pPlayer->angle.settarget(pSource->ang);
             pPlayer->angle.lockinput();
         }
-        else if (isDude) pXSource->goalAng = pSprite->ang = pSource->ang;
-        else pSprite->ang = pSource->ang;
+        else if (isDude) pXSource->goalAng = actor->spr.ang = pSource->ang;
+        else actor->spr.ang = pSource->ang;
     }
 
     if (pXSource->data3 == 1)
@@ -3151,19 +3151,19 @@ void useEffectGen(DBloodActor* sourceactor, DBloodActor* actor)
                 pos = bottom;
                 break;
             case 2: // middle
-                pos = pSprite->pos.Z + (tileHeight(pSprite->picnum) / 2 + tileTopOffset(pSprite->picnum));
+                pos = actor->spr.pos.Z + (tileHeight(actor->spr.picnum) / 2 + tileTopOffset(actor->spr.picnum));
                 break;
             case 3:
             case 4:
-                if (!pSprite->insector()) pos = top;
-                else pos = (pXSource->data4 == 3) ? pSprite->sector()->floorz : pSprite->sector()->ceilingz;
+                if (!actor->spr.insector()) pos = top;
+                else pos = (pXSource->data4 == 3) ? actor->spr.sector()->floorz : actor->spr.sector()->ceilingz;
                 break;
             default:
                 pos = top;
                 break;
         }
 
-        if ((pEffect = gFX.fxSpawnActor((FX_ID)fxId, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pos, 0)) != NULL)
+        if ((pEffect = gFX.fxSpawnActor((FX_ID)fxId, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, pos, 0)) != NULL)
         {
             auto pEffectSpr = &pEffect->s();
             pEffect->SetOwner(sourceactor);
@@ -3392,7 +3392,7 @@ void damageSprites(DBloodActor* sourceactor, DBloodActor* actor)
     auto pXSprite = &actor->x();
     auto pXSource = &sourceactor->x();
 
-    PLAYER* pPlayer = getPlayerById(pSprite->type);
+    PLAYER* pPlayer = getPlayerById(actor->spr.type);
     int dmgType = (pXSource->data2 >= kDmgFall) ? ClipHigh(pXSource->data2, kDmgElectric) : -1;
     int dmg = pXSprite->health << 4; 
     int armor[3];
@@ -3404,7 +3404,7 @@ void damageSprites(DBloodActor* sourceactor, DBloodActor* actor)
     {
         if (pSource->flags & kModernTypeFlag1) dmg = ClipHigh(pXSource->data3 << 1, 65535);
         else if (pXSprite->sysData2 > 0) dmg = (ClipHigh(pXSprite->sysData2 << 4, 65535) * pXSource->data3) / kPercFull;
-        else dmg = ((getDudeInfo(pSprite->type)->startHealth << 4) * pXSource->data3) / kPercFull;
+        else dmg = ((getDudeInfo(actor->spr.type)->startHealth << 4) * pXSource->data3) / kPercFull;
 
         health = pXSprite->health - dmg;
     }
@@ -3430,7 +3430,7 @@ void damageSprites(DBloodActor* sourceactor, DBloodActor* actor)
             }
             else
             {
-                //Printf(PRINT_HIGH, "Dude type %d is immune to damage type %d!", pSprite->type, dmgType);
+                //Printf(PRINT_HIGH, "Dude type %d is immune to damage type %d!", actor->spr.type, dmgType);
         }
         }
         else if (!pPlayer) actKillDude(sourceactor, actor, (DAMAGE_TYPE)dmgType, dmg);
@@ -4868,7 +4868,7 @@ DBloodActor* aiFightGetTargetInRange(DBloodActor* actor, int minDist, int maxDis
     auto pSprite = &actor->s();
     XSPRITE* pXSprite = &actor->x();
 
-    DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
+    DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
     
     BloodStatIterator it(kStatDude);
     while (auto targactor = it.Next())
@@ -5127,7 +5127,7 @@ void aiFightAlarmDudesInSight(DBloodActor* actor, int max)
 {
     auto pSprite = &actor->s();
 
-    DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
+    DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
 
     BloodStatIterator it(kStatDude);
     while (auto dudeactor = it.Next())
@@ -5405,15 +5405,15 @@ bool modernTypeOperateSector(sectortype* pSector, const EVENT& event)
 //
 //---------------------------------------------------------------------------
 
-void useCustomDudeSpawn(DBloodActor* pSource, DBloodActor* pSprite)
+void useCustomDudeSpawn(DBloodActor* pSource, DBloodActor* pActor)
 {
-    genDudeSpawn(pSource, pSprite, pSprite->spr.clipdist << 1);
+    genDudeSpawn(pSource, pActor, pActor->spr.clipdist << 1);
 }
 
-void useDudeSpawn(DBloodActor* pSource, DBloodActor* pSprite)
+void useDudeSpawn(DBloodActor* pSource, DBloodActor* pActor)
 {
-    if (randomSpawnDude(pSource, pSprite, pSprite->spr.clipdist << 1, 0) == nullptr)
-        nnExtSpawnDude(pSource, pSprite, pSource->xspr.data1, pSprite->spr.clipdist << 1, 0);
+    if (randomSpawnDude(pSource, pActor, pActor->spr.clipdist << 1, 0) == nullptr)
+        nnExtSpawnDude(pSource, pActor, pSource->xspr.data1, pActor->spr.clipdist << 1, 0);
 }
 
 //---------------------------------------------------------------------------
@@ -5442,7 +5442,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
                 break;
         }
 
-        switch (pSprite->type) 
+        switch (actor->spr.type) 
         {
             case kModernCondition:
             case kModernConditionFalse:
@@ -5473,7 +5473,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
 
         }
     }
-    if (pSprite->statnum == kStatDude && actor->IsDudeActor()) 
+    if (actor->spr.statnum == kStatDude && actor->IsDudeActor()) 
     {
         switch (event.cmd) 
         {
@@ -5512,7 +5512,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
         return true;
     }
 
-    switch (pSprite->type) 
+    switch (actor->spr.type) 
     {
         default:
             return false; // no modern type found to work with, go normal OperateSprite();
@@ -5521,7 +5521,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
             // dude to thing morphing causing a lot of problems since it continues receiving commands after dude is dead.
             // this leads to weird stuff like exploding with gargoyle gib or corpse disappearing immediately.
             // let's allow only specific commands here to avoid this.
-            if (pSprite->inittype < kDudeBase || pSprite->inittype >= kDudeMax) return false;
+            if (actor->spr.inittype < kDudeBase || actor->spr.inittype >= kDudeMax) return false;
             else if (event.cmd != kCmdToggle && event.cmd != kCmdOff && event.cmd != kCmdSpriteImpact) return true;
             DudeToGibCallback1(0, actor); // set proper gib type just in case DATAs was changed from the outside.
             return false;
@@ -5534,27 +5534,27 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
         // add spawn random dude feature - works only if at least 2 data fields are not empty.
         case kMarkerDudeSpawn:
             if (!gGameOptions.nMonsterSettings) return true;
-            else if (!(pSprite->flags & kModernTypeFlag4)) useDudeSpawn(actor, actor);
+            else if (!(actor->spr.flags & kModernTypeFlag4)) useDudeSpawn(actor, actor);
             else if (pXSprite->txID) evSendActor(actor, pXSprite->txID, kCmdModernUse);
             return true;
 
         case kModernCustomDudeSpawn:
             if (!gGameOptions.nMonsterSettings) return true;
-            else if (!(pSprite->flags & kModernTypeFlag4)) useCustomDudeSpawn(actor, actor);
+            else if (!(actor->spr.flags & kModernTypeFlag4)) useCustomDudeSpawn(actor, actor);
             else if (pXSprite->txID) evSendActor(actor, pXSprite->txID, kCmdModernUse);
             return true;
 
         case kModernRandomTX: // random Event Switch takes random data field and uses it as TX ID
         case kModernSequentialTX: // sequential Switch takes values from data fields starting from data1 and uses it as TX ID
             if (pXSprite->command == kCmdLink) return true; // work as event redirector
-            switch (pSprite->type) 
+            switch (actor->spr.type) 
             {
                 case kModernRandomTX:
                     useRandomTx(actor, (COMMAND_ID)pXSprite->command, true);
                     break;
 
                 case kModernSequentialTX:
-                    if (!(pSprite->flags & kModernTypeFlag1)) useSequentialTx(actor, (COMMAND_ID)pXSprite->command, true);
+                    if (!(actor->spr.flags & kModernTypeFlag1)) useSequentialTx(actor, (COMMAND_ID)pXSprite->command, true);
                     else seqTxSendCmdAll(actor, actor, (COMMAND_ID)pXSprite->command, false);
                     break;
             }
@@ -5572,7 +5572,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
                     [[fallthrough]];
                 case kCmdRepeat:
                     if (pXSprite->txID > 0) modernTypeSendCommand(actor, pXSprite->txID, (COMMAND_ID)pXSprite->command);
-                    else if (pXSprite->data1 == 0 && pSprite->insector()) useSpriteDamager(actor, OBJ_SECTOR, pSprite->sector(), nullptr);
+                    else if (pXSprite->data1 == 0 && actor->spr.insector()) useSpriteDamager(actor, OBJ_SECTOR, actor->spr.sector(), nullptr);
                     else if (pXSprite->data1 >= 666 && pXSprite->data1 < 669) useSpriteDamager(actor, -1, nullptr, nullptr);
                     else
                     {
@@ -5627,11 +5627,11 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
                 case kCmdOn:
                     evKillActor(actor); // queue overflow protect
                     if (pXSprite->state == 0) SetSpriteState(actor, 1);
-                    if (pSprite->type == kModernSeqSpawner) seqSpawnerOffSameTx(actor);
+                    if (actor->spr.type == kModernSeqSpawner) seqSpawnerOffSameTx(actor);
                     [[fallthrough]];
                 case kCmdRepeat:
                     if (pXSprite->txID > 0) modernTypeSendCommand(actor, pXSprite->txID, (COMMAND_ID)pXSprite->command);
-                    else if (pSprite->type == kModernSeqSpawner) useSeqSpawnerGen(actor, OBJ_SPRITE, nullptr, nullptr, actor);
+                    else if (actor->spr.type == kModernSeqSpawner) useSeqSpawnerGen(actor, OBJ_SPRITE, nullptr, nullptr, actor);
                     else useEffectGen(actor, nullptr);
             
                     if (pXSprite->busyTime > 0)
@@ -5717,7 +5717,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
                     [[fallthrough]];
                 case kCmdRepeat:
                     // force OFF after *all* TX objects reach the goal value
-                    if (pSprite->flags == kModernTypeFlag0 && incDecGoalValueIsReached(actor)) 
+                    if (actor->spr.flags == kModernTypeFlag0 && incDecGoalValueIsReached(actor)) 
                     {
                         evPostActor(actor, 0, kCmdOff);
                         break;
@@ -5756,7 +5756,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
             return true;
 
         case kModernThingTNTProx:
-            if (pSprite->statnum != kStatRespawn) 
+            if (actor->spr.statnum != kStatRespawn) 
             {
                 switch (event.cmd) 
                 {
@@ -5794,7 +5794,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
                         
                 switch (cmd) {
                     case 36:
-                        actHealDude(pPlayer->actor, ((pXSprite->data2 > 0) ? ClipHigh(pXSprite->data2, 200) : getDudeInfo(pPlayer->pSprite->type)->startHealth), 200);
+                        actHealDude(pPlayer->actor, ((pXSprite->data2 > 0) ? ClipHigh(pXSprite->data2, 200) : getDudeInfo(pPlayer->actor->spr.type)->startHealth), 200);
                         pPlayer->curWeapon = kWeapPitchFork;
                         break;
                 }
@@ -5848,9 +5848,9 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
                 case 9: // 73 (set player's sprite angle, TO-DO: if tx > 0, take a look on TX ID sprite)
                     //data4 is reserved
                     if (pXSprite->data4 != 0) break;
-                    else if (pSprite->flags & kModernTypeFlag1) 
+                    else if (actor->spr.flags & kModernTypeFlag1) 
                     {
-                        pPlayer->angle.settarget(pSprite->ang);
+                        pPlayer->angle.settarget(actor->spr.ang);
                         pPlayer->angle.lockinput();
                     }
                     else if (valueIsBetween(pXSprite->data2, -kAng360, kAng360)) 
@@ -6293,15 +6293,15 @@ void useUniMissileGen(DBloodActor* sourceactor, DBloodActor* actor)
     if (pXSource->data1 < kMissileBase || pXSource->data1 >= kMissileMax)
         return;
 
-    if (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) 
+    if (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) 
     {
-        if (pSprite->cstat & CSTAT_SPRITE_YFLIP) dz = 0x4000;
+        if (actor->spr.cstat & CSTAT_SPRITE_YFLIP) dz = 0x4000;
         else dz = -0x4000;
     }
     else 
     {
-        dx = bcos(pSprite->ang);
-        dy = bsin(pSprite->ang);
+        dx = bcos(actor->spr.ang);
+        dy = bsin(actor->spr.ang);
         dz = pXSource->data3 << 6; // add slope controlling
         if (dz > 0x10000) dz = 0x10000;
         else if (dz < -0x10000) dz = -0x10000;
@@ -6332,16 +6332,16 @@ void useUniMissileGen(DBloodActor* sourceactor, DBloodActor* actor)
             if (canInherit != 0) 
             {
                 if (canInherit & 0x2)
-                    pMissile->xrepeat = (from == kModernTypeFlag1) ? pSource->xrepeat : pSprite->xrepeat;
+                    pMissile->xrepeat = (from == kModernTypeFlag1) ? pSource->xrepeat : actor->spr.xrepeat;
                 
                 if (canInherit & 0x1)
-                    pMissile->yrepeat = (from == kModernTypeFlag1) ? pSource->yrepeat : pSprite->yrepeat;
+                    pMissile->yrepeat = (from == kModernTypeFlag1) ? pSource->yrepeat : actor->spr.yrepeat;
 
                 if (canInherit & 0x4)
-                    pMissile->pal = (from == kModernTypeFlag1) ? pSource->pal : pSprite->pal;
+                    pMissile->pal = (from == kModernTypeFlag1) ? pSource->pal : actor->spr.pal;
                 
                 if (canInherit & 0x8)
-                    pMissile->shade = (from == kModernTypeFlag1) ? pSource->shade : pSprite->shade;
+                    pMissile->shade = (from == kModernTypeFlag1) ? pSource->shade : actor->spr.shade;
             }
         }
 
@@ -6467,19 +6467,19 @@ void sprite2sectorSlope(DBloodActor* actor, sectortype* pSector, char rel, bool
     int slope = 0, z = 0;
     switch (rel) {
         default:
-            z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
-            if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) && actor->hasX() && actor->xspr.Touch) z--;
+            z = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
+            if ((actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) && actor->hasX() && actor->xspr.Touch) z--;
             slope = pSector->floorheinum;
             break;
         case 1:
-            z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
-            if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) && actor->hasX() && actor->xspr.Touch) z++;
+            z = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
+            if ((actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) && actor->hasX() && actor->xspr.Touch) z++;
             slope = pSector->ceilingheinum;
             break;
     }
 
     spriteSetSlope(pSprite, slope);
-    if (forcez) pSprite->pos.Z = z;
+    if (forcez) actor->spr.pos.Z = z;
 }
 
 //---------------------------------------------------------------------------
@@ -6722,9 +6722,9 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
 {
     spritetype* pSprite = &actor->s();
     
-    if (!actor->IsDudeActor() || pSprite->statnum != kStatDude) 
+    if (!actor->IsDudeActor() || actor->spr.statnum != kStatDude) 
     {
-        switch (pSprite->type) // can be dead dude turned in gib
+        switch (actor->spr.type) // can be dead dude turned in gib
         {
             // make current target and all other dudes not attack this dude anymore
         case kThingBloodBits:
@@ -6741,7 +6741,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
     XSPRITE* pXSprite = &actor->x();
 
     int receiveHp = 33 + Random(33);
-    DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type); 
+    DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type); 
     int matesPerEnemy = 1;
 
     // dude is burning?
@@ -6777,15 +6777,15 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
         auto actLeech = leechIsDropped(actor);
         if (pXSource->data4 == 3) 
         {
-            aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
+            aiSetTarget(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
             aiSetGenIdleState(actor);
-            if (pSprite->type == kDudeModernCustom && actLeech)
+            if (actor->spr.type == kDudeModernCustom && actLeech)
                 removeLeech(actLeech);
         }
         else if (pXSource->data4 == 4) 
         {
             aiSetTarget(actor, pPlayer->pos.X, pPlayer->pos.Y, pPlayer->pos.Z);
-            if (pSprite->type == kDudeModernCustom && actLeech)
+            if (actor->spr.type == kDudeModernCustom && actLeech)
                 removeLeech(actLeech);
         }
     }
@@ -6798,13 +6798,13 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
         auto pXTarget = &targetactor->x();
 
         if (aiFightUnitCanFly(actor) && aiFightIsMeleeUnit(targetactor) && !aiFightUnitCanFly(targetactor))
-            pSprite->flags |= 0x0002;
+            actor->spr.flags |= 0x0002;
         else if (aiFightUnitCanFly(actor))
-            pSprite->flags &= ~0x0002;
+            actor->spr.flags &= ~0x0002;
 
         if (!targetactor->IsDudeActor() || pXTarget->health < 1 || !aiFightDudeCanSeeTarget(actor, pDudeInfo, targetactor))
         {
-            aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
+            aiSetTarget(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
         }
         // dude attack or attacked by target that does not fit by data id?
         else if (pXSource->data1 != 666 && pXTarget->data1 != pXSource->data1) 
@@ -6812,7 +6812,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
             if (aiFightDudeIsAffected(targetactor)) 
             {
                 // force stop attack target
-                aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
+                aiSetTarget(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
                 if (actor->GetBurnSource() == targetactor) 
                 {
                     pXSprite->burnTime = 0;
@@ -6865,7 +6865,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
 
             // force dude stop attack mate, if target was not changed previously
             if (actor == mateactor)
-                aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
+                aiSetTarget(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
 
 
         }
@@ -7143,7 +7143,7 @@ void playerQavSceneDraw(PLAYER* pPlayer, int a2, double a3, double a4, int a5)
         }
 
         // draw as weapon
-        if (!(pSprite->flags & kModernTypeFlag1)) 
+        if (!(actor->spr.flags & kModernTypeFlag1)) 
         {
             pQAV->x = int(a3); pQAV->y = int(a4);
             pQAV->Draw(a3, a4, v4, flags, a2, a5, true, smoothratio);
@@ -7243,7 +7243,7 @@ PLAYER* getPlayerById(int id)
     {
         for (int i = connecthead; i >= 0; i = connectpoint2[i]) 
         {
-            if (id == gPlayer[i].pSprite->type)
+            if (id == gPlayer[i].actor->spr.type)
                 return &gPlayer[i];
         }
     }
@@ -7483,11 +7483,11 @@ bool setDataValueOfObject(int objType, sectortype* sect, walltype* wal, DBloodAc
 bool nnExtCanMove(DBloodActor* actor, DBloodActor* target, int nAngle, int nRange) 
 {
     auto pSprite = &actor->s();
-    int x = pSprite->pos.X, y = pSprite->pos.Y, z = pSprite->pos.Z;
-    auto pSector = pSprite->sector();
+    int x = actor->spr.pos.X, y = actor->spr.pos.Y, z = actor->spr.pos.Z;
+    auto pSector = actor->spr.sector();
     HitScan(actor, z, Cos(nAngle) >> 16, Sin(nAngle) >> 16, 0, CLIPMASK0, nRange);
     int nDist = approxDist(x - gHitInfo.hitpos.X, y - gHitInfo.hitpos.Y);
-    if (target != nullptr && nDist - (pSprite->clipdist << 2) < nRange)
+    if (target != nullptr && nDist - (actor->spr.clipdist << 2) < nRange)
         return (target == gHitInfo.actor());
 
     x += MulScale(nRange, Cos(nAngle), 30);
@@ -7516,37 +7516,37 @@ void nnExtAiSetDirection(DBloodActor* actor, int a3)
 {
     spritetype* pSprite = &actor->s();
     XSPRITE* pXSprite = &actor->x();
-    assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
+    assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
     
-    int vc = ((a3 + 1024 - pSprite->ang) & 2047) - 1024;
-    int t1 = DMulScale(actor->xvel, Cos(pSprite->ang), actor->yvel, Sin(pSprite->ang), 30);
+    int vc = ((a3 + 1024 - actor->spr.ang) & 2047) - 1024;
+    int t1 = DMulScale(actor->xvel, Cos(actor->spr.ang), actor->yvel, Sin(actor->spr.ang), 30);
     int vsi = ((t1 * 15) >> 12) / 2;
     int v8 = 341;
     
     if (vc < 0)
         v8 = -341;
 
-    if (nnExtCanMove(actor, actor->GetTarget(), pSprite->ang + vc, vsi))
-        pXSprite->goalAng = pSprite->ang + vc;
-    else if (nnExtCanMove(actor, actor->GetTarget(), pSprite->ang + vc / 2, vsi))
-        pXSprite->goalAng = pSprite->ang + vc / 2;
-    else if (nnExtCanMove(actor, actor->GetTarget(), pSprite->ang - vc / 2, vsi))
-        pXSprite->goalAng = pSprite->ang - vc / 2;
-    else if (nnExtCanMove(actor, actor->GetTarget(), pSprite->ang + v8, vsi))
-        pXSprite->goalAng = pSprite->ang + v8;
-    else if (nnExtCanMove(actor, actor->GetTarget(), pSprite->ang, vsi))
-        pXSprite->goalAng = pSprite->ang;
-    else if (nnExtCanMove(actor, actor->GetTarget(), pSprite->ang - v8, vsi))
-        pXSprite->goalAng = pSprite->ang - v8;
+    if (nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang + vc, vsi))
+        pXSprite->goalAng = actor->spr.ang + vc;
+    else if (nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang + vc / 2, vsi))
+        pXSprite->goalAng = actor->spr.ang + vc / 2;
+    else if (nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang - vc / 2, vsi))
+        pXSprite->goalAng = actor->spr.ang - vc / 2;
+    else if (nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang + v8, vsi))
+        pXSprite->goalAng = actor->spr.ang + v8;
+    else if (nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang, vsi))
+        pXSprite->goalAng = actor->spr.ang;
+    else if (nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang - v8, vsi))
+        pXSprite->goalAng = actor->spr.ang - v8;
     else
-        pXSprite->goalAng = pSprite->ang + 341;
+        pXSprite->goalAng = actor->spr.ang + 341;
 
     if (pXSprite->dodgeDir) 
         {
-        if (!nnExtCanMove(actor, actor->GetTarget(), pSprite->ang + pXSprite->dodgeDir * 512, 512))
+        if (!nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang + pXSprite->dodgeDir * 512, 512))
         {
             pXSprite->dodgeDir = -pXSprite->dodgeDir;
-            if (!nnExtCanMove(actor, actor->GetTarget(), pSprite->ang + pXSprite->dodgeDir * 512, 512))
+            if (!nnExtCanMove(actor, actor->GetTarget(), actor->spr.ang + pXSprite->dodgeDir * 512, 512))
                 pXSprite->dodgeDir = 0;
         }
     }
@@ -7562,7 +7562,7 @@ void nnExtAiSetDirection(DBloodActor* actor, int a3)
 void aiPatrolState(DBloodActor* actor, int state) 
 {
     spritetype* pSprite = &actor->s();
-    assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax && actor->hasX());
+    assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax && actor->hasX());
     assert(actor->GetTarget());
     
     XSPRITE* pXSprite = &actor->x();
@@ -7575,7 +7575,7 @@ void aiPatrolState(DBloodActor* actor, int state)
     bool nSeqOverride = false, crouch = false;
     int i, seq = -1, start = 0, end = kPatrolStateSize;
     
-    const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[pSprite->type - kDudeBase];
+    const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[actor->spr.type - kDudeBase];
     
     switch (state) {
         case kAiStatePatrolWaitL:
@@ -7621,7 +7621,7 @@ void aiPatrolState(DBloodActor* actor, int state)
 
     
     if (pXMarker->data4 > 0) seq = pXMarker->data4, nSeqOverride = true;
-    else if (!nSeqOverride && state == kAiStatePatrolWaitC && (pSprite->type == kDudeCultistTesla || pSprite->type == kDudeCultistTNT))
+    else if (!nSeqOverride && state == kAiStatePatrolWaitC && (actor->spr.type == kDudeCultistTesla || actor->spr.type == kDudeCultistTNT))
         seq = 11537, nSeqOverride = true;  // these don't have idle crouch seq for some reason...
 
     if (seq < 0)
@@ -7633,7 +7633,7 @@ void aiPatrolState(DBloodActor* actor, int state)
         if (newState->stateType != state || (!nSeqOverride && seq != newState->seqId))
             continue;
 
-        if (pSprite->type == kDudeModernCustom) aiGenDudeNewState(actor, newState);
+        if (actor->spr.type == kDudeModernCustom) aiGenDudeNewState(actor, newState);
         else aiNewState(actor, newState);
 
         if (crouch) pXSprite->unused1 |= kDudeFlagCrouch;
@@ -7647,7 +7647,7 @@ void aiPatrolState(DBloodActor* actor, int state)
 
     if (i == end) 
     {
-        viewSetSystemMessage("No patrol state #%d found for dude #%d (type = %d)", state, actor->GetIndex(), pSprite->type);
+        viewSetSystemMessage("No patrol state #%d found for dude #%d (type = %d)", state, actor->GetIndex(), actor->spr.type);
         aiPatrolStop(actor, nullptr);
     }
 }
@@ -7682,16 +7682,16 @@ DBloodActor* aiPatrolMarkerBusy(DBloodActor* except, DBloodActor* marker)
 bool aiPatrolMarkerReached(DBloodActor* actor) 
 {
     spritetype* pSprite = &actor->s();
-    assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
+    assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
 
-    const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[pSprite->type - kDudeBase];
+    const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[actor->spr.type - kDudeBase];
     auto markeractor = actor->GetTarget();
     if (markeractor && markeractor->spr.type == kMarkerPath) 
     {
         spritetype* pMarker = &markeractor->s();
         int okDist = ClipLow(pMarker->clipdist << 1, 4);
-        int oX = abs(pMarker->pos.X - pSprite->pos.X) >> 4;
-        int oY = abs(pMarker->pos.Y - pSprite->pos.Y) >> 4;
+        int oX = abs(pMarker->pos.X - actor->spr.pos.X) >> 4;
+        int oY = abs(pMarker->pos.Y - actor->spr.pos.Y) >> 4;
 
         if (approxDist(oX, oY) <= okDist) 
         {
@@ -7793,11 +7793,11 @@ void aiPatrolSetMarker(DBloodActor* actor)
             auto pNext = &nextactor->s();
             auto pXNext = &nextactor->x();
 
-            if (pXNext->locked || pXNext->isTriggered || pXNext->DudeLockout || (dist = approxDist(pNext->pos.X - pSprite->pos.X, pNext->pos.Y - pSprite->pos.Y)) > closest)
+            if (pXNext->locked || pXNext->isTriggered || pXNext->DudeLockout || (dist = approxDist(pNext->pos.X - actor->spr.pos.X, pNext->pos.Y - actor->spr.pos.Y)) > closest)
                 continue;
 
             GetActorExtents(nextactor, &zt1, &zb1); 
-            if (cansee(pNext->pos.X, pNext->pos.Y, zt1, pNext->sector(), pSprite->pos.X, pSprite->pos.Y, zt2, pSprite->sector()))
+            if (cansee(pNext->pos.X, pNext->pos.Y, zt1, pNext->sector(), actor->spr.pos.X, actor->spr.pos.Y, zt2, actor->spr.sector()))
             {
                 closest = dist;
                 selected = nextactor;
@@ -7899,7 +7899,7 @@ void aiPatrolStop(DBloodActor* actor, DBloodActor* targetactor, bool alarm)
 
         if (mytarget && mytarget->spr.type == kMarkerPath) 
         {
-            if (targetactor == nullptr) pSprite->ang = mytarget->spr.ang & 2047;
+            if (targetactor == nullptr) actor->spr.ang = mytarget->spr.ang & 2047;
             actor->SetTarget(nullptr);
         }
 
@@ -7959,9 +7959,9 @@ void aiPatrolTurn(DBloodActor* actor)
     auto pXSprite = &actor->x();
     auto pSprite = &actor->s();
 
-    int nTurnRange = (getDudeInfo(pSprite->type)->angSpeed << 1) >> 4;
-    int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
-    pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
+    int nTurnRange = (getDudeInfo(actor->spr.type)->angSpeed << 1) >> 4;
+    int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
+    actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
 
 }
 
@@ -7977,12 +7977,12 @@ void aiPatrolMove(DBloodActor* actor)
     auto pSprite = &actor->s();
     auto targetactor = actor->GetTarget();
 
-    if (!(pSprite->type >= kDudeBase && pSprite->type < kDudeMax) || !targetactor)
+    if (!(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax) || !targetactor)
         return;
 
 
-    int dudeIdx = pSprite->type - kDudeBase;
-    switch (pSprite->type) 
+    int dudeIdx = actor->spr.type - kDudeBase;
+    switch (actor->spr.type) 
     {
         case kDudeCultistShotgunProne:  dudeIdx = kDudeCultistShotgun - kDudeBase;  break;
         case kDudeCultistTommyProne:    dudeIdx = kDudeCultistTommy - kDudeBase;    break;
@@ -7993,9 +7993,9 @@ void aiPatrolMove(DBloodActor* actor)
     DUDEINFO* pDudeInfo = &dudeInfo[dudeIdx];
     const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[dudeIdx];
     
-    int dx = (pTarget->pos.X - pSprite->pos.X);
-    int dy = (pTarget->pos.Y - pSprite->pos.Y);
-    int dz = (pTarget->pos.Z - (pSprite->pos.Z - pDudeInfo->eyeHeight)) * 6;
+    int dx = (pTarget->pos.X - actor->spr.pos.X);
+    int dy = (pTarget->pos.Y - actor->spr.pos.Y);
+    int dz = (pTarget->pos.Z - (actor->spr.pos.Z - pDudeInfo->eyeHeight)) * 6;
     int vel = (pXSprite->unused1 & kDudeFlagCrouch) ? kMaxPatrolCrouchVelocity : kMaxPatrolVelocity;
     int goalAng = 341;
 
@@ -8003,17 +8003,17 @@ void aiPatrolMove(DBloodActor* actor)
     {
         goalAng >>= 1;
         actor->zvel = dz;
-        if (pSprite->flags & kPhysGravity)
-            pSprite->flags &= ~kPhysGravity;
+        if (actor->spr.flags & kPhysGravity)
+            actor->spr.flags &= ~kPhysGravity;
     } 
     else if (!pExtra->flying) 
     {
-        pSprite->flags |= kPhysGravity | kPhysFalling;
+        actor->spr.flags |= kPhysGravity | kPhysFalling;
     }
 
     int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
-    int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
-    pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
+    int nAng = ((pXSprite->goalAng + 1024 - actor->spr.ang) & 2047) - 1024;
+    actor->spr.ang = (actor->spr.ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
     
     if (abs(nAng) > goalAng || ((pXTarget->waitTime > 0 || pXTarget->data1 == pXTarget->data2) && aiPatrolMarkerReached(actor))) 
     {
@@ -8032,8 +8032,8 @@ void aiPatrolMove(DBloodActor* actor)
     else 
     {
         int frontSpeed = aiPatrolGetVelocity(pDudeInfo->frontSpeed, pXTarget->busyTime);
-        actor->xvel += MulScale(frontSpeed, Cos(pSprite->ang), 30);
-        actor->yvel += MulScale(frontSpeed, Sin(pSprite->ang), 30);
+        actor->xvel += MulScale(frontSpeed, Cos(actor->spr.ang), 30);
+        actor->yvel += MulScale(frontSpeed, Sin(actor->spr.ang), 30);
     }
 
     vel = MulScale(vel, approxDist(dx, dy) << 6, 16);
@@ -8060,7 +8060,7 @@ void aiPatrolAlarmLite(DBloodActor* actor, DBloodActor* targetactor)
     if (pXSprite->health <= 0)
         return;
 
-    int zt1, zb1, zt2, zb2; //int eaz1 = (getDudeInfo(pSprite->type)->eyeHeight * pSprite->yrepeat) << 2;
+    int zt1, zb1, zt2, zb2; //int eaz1 = (getDudeInfo(actor->spr.type)->eyeHeight * actor->spr.yrepeat) << 2;
     GetActorExtents(actor, &zt1, &zb1); 
     GetActorExtents(targetactor, &zt2, &zb2);
     
@@ -8076,8 +8076,8 @@ void aiPatrolAlarmLite(DBloodActor* actor, DBloodActor* targetactor)
             continue;
 
         int eaz2 = (getDudeInfo(pTarget->type)->eyeHeight * pTarget->yrepeat) << 2;
-        int nDist = approxDist(pDude->pos.X - pSprite->pos.X, pDude->pos.Y - pSprite->pos.Y);
-        if (nDist >= kPatrolAlarmSeeDist || !cansee(pSprite->pos.X, pSprite->pos.Y, zt1, pSprite->sector(), pDude->pos.X, pDude->pos.Y, pDude->pos.Z - eaz2, pDude->sector()))
+        int nDist = approxDist(pDude->pos.X - actor->spr.pos.X, pDude->pos.Y - actor->spr.pos.Y);
+        if (nDist >= kPatrolAlarmSeeDist || !cansee(actor->spr.pos.X, actor->spr.pos.Y, zt1, actor->spr.sector(), pDude->pos.X, pDude->pos.Y, pDude->pos.Z - eaz2, pDude->sector()))
         {
             nDist = approxDist(pDude->pos.X - pTarget->pos.X, pDude->pos.Y - pTarget->pos.Y);
             if (nDist >= kPatrolAlarmSeeDist || !cansee(pTarget->pos.X, pTarget->pos.Y, zt2, pTarget->sector(), pDude->pos.X, pDude->pos.Y, pDude->pos.Z - eaz2, pDude->sector()))
@@ -8111,10 +8111,10 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
     if (pXSprite->health <= 0)
         return;
 
-    int eaz2 = (getDudeInfo(pSprite->type)->eyeHeight * pSprite->yrepeat) << 2;
-    int x2 = pSprite->pos.X, y2 = pSprite->pos.Y, z2 = pSprite->pos.Z - eaz2;
+    int eaz2 = (getDudeInfo(actor->spr.type)->eyeHeight * actor->spr.yrepeat) << 2;
+    int x2 = actor->spr.pos.X, y2 = actor->spr.pos.Y, z2 = actor->spr.pos.Z - eaz2;
     
-    auto pSect2 = pSprite->sector();
+    auto pSect2 = actor->spr.sector();
     
     int tzt, tzb; 
     GetActorExtents(targetactor, &tzt, &tzb);
@@ -8151,7 +8151,7 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
                 continue;
 
             if (actor->GetTarget() ) aiSetTarget(dudeactor, actor->GetTarget());
-            else aiSetTarget(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
+            else aiSetTarget(dudeactor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
             aiActivateDude(dudeactor);
 
             if (chain)
@@ -8190,9 +8190,9 @@ bool spritesTouching(DBloodActor *actor1, DBloodActor* actor2)
 bool aiCanCrouch(DBloodActor* actor)
 {
     auto pSprite = &actor->s();
-    if (pSprite->type >= kDudeBase && pSprite->type < kDudeVanillaMax)
-        return (gDudeInfoExtra[pSprite->type - kDudeBase].idlcseqofs >= 0 && gDudeInfoExtra[pSprite->type - kDudeBase].mvecseqofs >= 0);
-    else if (pSprite->type == kDudeModernCustom || pSprite->type == kDudeModernCustomBurning)
+    if (actor->spr.type >= kDudeBase && actor->spr.type < kDudeVanillaMax)
+        return (gDudeInfoExtra[actor->spr.type - kDudeBase].idlcseqofs >= 0 && gDudeInfoExtra[actor->spr.type - kDudeBase].mvecseqofs >= 0);
+    else if (actor->spr.type == kDudeModernCustom || actor->spr.type == kDudeModernCustomBurning)
         return actor->genDudeExtra.canDuck;
 
     return false;
@@ -8235,8 +8235,8 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
     enum { kMaxPatrolFoundSounds = 256 }; // should be the maximum amount of sound channels the engine can play at the same time.
     PATROL_FOUND_SOUNDS patrolBonkles[kMaxPatrolFoundSounds];
 
-    assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
-    DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type); PLAYER* pPlayer = NULL;
+    assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
+    DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type); PLAYER* pPlayer = NULL;
     
     for (int i = 0; i < kMaxPatrolFoundSounds; i++) 
     {
@@ -8263,7 +8263,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
 
         newtarget = nullptr;
         seeChance = hearChance = 0x0000;
-        x = pSpr->pos.X, y = pSpr->pos.Y, z = pSpr->pos.Z, dx = x - pSprite->pos.X, dy = y - pSprite->pos.Y; nDist = approxDist(dx, dy);
+        x = pSpr->pos.X, y = pSpr->pos.Y, z = pSpr->pos.Z, dx = x - actor->spr.pos.X, dy = y - actor->spr.pos.Y; nDist = approxDist(dx, dy);
         seeDist = (stealth) ? pDudeInfo->seeDist / 3 : pDudeInfo->seeDist >> 1;
         hearDist = pDudeInfo->hearDist; feelDist = hearDist >> 1;
 
@@ -8272,9 +8272,9 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
 
         if (nDist <= seeDist) 
         {
-            eyeAboveZ = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
+            eyeAboveZ = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
             if (nDist < seeDist >> 3) GetActorExtents(pPlayer->actor, &z, &j); //use ztop of the target sprite
-            if (!cansee(x, y, z, pSpr->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - eyeAboveZ, pSprite->sector()))
+            if (!cansee(x, y, z, pSpr->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - eyeAboveZ, actor->spr.sector()))
                 continue;
         }
         else 
@@ -8319,7 +8319,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
                         searchsect = &sector[chan->UserData];
                     }
                     if (searchsect == nullptr) return false;
-                    int nDist = approxDist(sndx - pSprite->pos.X, sndy - pSprite->pos.Y);
+                    int nDist = approxDist(sndx - actor->spr.pos.X, sndy - actor->spr.pos.Y);
                     if (nDist > hearDist) return false;
 
 
@@ -8410,7 +8410,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
             if (seeDist) 
             {
                 int periphery = ClipLow(pDudeInfo->periphery, kAng60);
-                int nDeltaAngle = abs(((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024);
+                int nDeltaAngle = abs(((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024);
                 if ((itCanSee = (!blind && nDist < seeDist && nDeltaAngle < periphery)) == true) 
                 {
                     int base = 100 + ((20 * gGameOptions.nDifficulty) - (nDeltaAngle / 5));
@@ -8471,7 +8471,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
                     {
                         if (pXSteal->data1 > 0)
                         {
-                            if (approxDist(abs(pSteal->pos.X - pSprite->pos.X) >> 4, abs(pSteal->pos.Y - pSprite->pos.Y) >> 4) >= pXSteal->data1)
+                            if (approxDist(abs(pSteal->pos.X - actor->spr.pos.X) >> 4, abs(pSteal->pos.Y - actor->spr.pos.Y) >> 4) >= pXSteal->data1)
                                 continue;
 
                         } 
@@ -8622,7 +8622,7 @@ void aiPatrolThink(DBloodActor* actor)
     auto pXSprite = &actor->x();
     auto pSprite = &actor->s();
 
-    assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
+    assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
 
     DBloodActor* targetactor;
     int stateTimer;
@@ -8635,7 +8635,7 @@ void aiPatrolThink(DBloodActor* actor)
 
     
     bool crouch = (pXSprite->unused1 & kDudeFlagCrouch), uwater = spriteIsUnderwater(actor);
-    if (markeractor == nullptr || (pSprite->type == kDudeModernCustom && ((uwater && !canSwim(actor)) || !canWalk(actor)))) 
+    if (markeractor == nullptr || (actor->spr.type == kDudeModernCustom && ((uwater && !canSwim(actor)) || !canWalk(actor)))) 
     {
         aiPatrolStop(actor, nullptr);
         return;
@@ -8643,7 +8643,7 @@ void aiPatrolThink(DBloodActor* actor)
     
     spritetype* pMarker = &markeractor->s();
     XSPRITE* pXMarker = &markeractor->x();
-    const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[pSprite->type - kDudeBase];
+    const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[actor->spr.type - kDudeBase];
     bool isFinal = ((!pXSprite->unused2 && pXMarker->data2 == -1) || (pXSprite->unused2 && pXMarker->data1 == -1));
     bool reached = false;
     
@@ -8706,7 +8706,7 @@ void aiPatrolThink(DBloodActor* actor)
     } else if (aiPatrolTurning(pXSprite->aiState)) 
     {
         //viewSetSystemMessage("TURN");
-        if ((int)pSprite->ang == (int)pXSprite->goalAng) 
+        if ((int)actor->spr.ang == (int)pXSprite->goalAng) 
         {
             // save imer for waiting
             stateTimer = pXSprite->stateTimer;
@@ -8738,7 +8738,7 @@ void aiPatrolThink(DBloodActor* actor)
             if (!(pMarker->flags & kModernTypeFlag4)) 
             {
                 pXSprite->goalAng = ((!(pMarker->flags & kModernTypeFlag8) && pXSprite->unused2) ? pMarker->ang + kAng180 : pMarker->ang) & 2047;
-                if ((int)pSprite->ang != (int)pXSprite->goalAng) // let the enemy play move animation while turning
+                if ((int)actor->spr.ang != (int)pXSprite->goalAng) // let the enemy play move animation while turning
                     return;
             }
 
@@ -8813,7 +8813,7 @@ void aiPatrolThink(DBloodActor* actor)
         }
     }
     
-    nnExtAiSetDirection(actor, getangle(pMarker->pos.X - pSprite->pos.X, pMarker->pos.Y - pSprite->pos.Y));
+    nnExtAiSetDirection(actor, getangle(pMarker->pos.X - actor->spr.pos.X, pMarker->pos.Y - actor->spr.pos.Y));
 
     if (aiPatrolMoving(pXSprite->aiState) && !reached) return;
     else if (uwater) aiPatrolState(actor, kAiStatePatrolMoveW);
@@ -9031,7 +9031,7 @@ void callbackUniMissileBurst(DBloodActor* actor, sectortype*) // 22
 {
     if (!actor) return;
     spritetype* pSprite = &actor->s();
-    if (pSprite->statnum != kStatProjectile) return;
+    if (actor->spr.statnum != kStatProjectile) return;
     int nAngle = getangle(actor->xvel, actor->yvel);
     int nRadius = 0x55555;
 
@@ -9041,24 +9041,24 @@ void callbackUniMissileBurst(DBloodActor* actor, sectortype*) // 22
         if (!burstactor) break;
         spritetype* pBurst = &burstactor->s();
 
-        pBurst->type = pSprite->type;
-        pBurst->shade = pSprite->shade;
-        pBurst->picnum = pSprite->picnum;
+        pBurst->type = actor->spr.type;
+        pBurst->shade = actor->spr.shade;
+        pBurst->picnum = actor->spr.picnum;
 
         
-        pBurst->cstat = pSprite->cstat;
+        pBurst->cstat = actor->spr.cstat;
         if ((pBurst->cstat & CSTAT_SPRITE_BLOCK)) 
         {
             pBurst->cstat &= ~CSTAT_SPRITE_BLOCK; // we don't want missiles impact each other
             evPostActor(burstactor, 100, kCallbackMissileSpriteBlock); // so set blocking flag a bit later
         }
 
-        pBurst->pal = pSprite->pal;
-        pBurst->clipdist = pSprite->clipdist / 4;
-        pBurst->flags = pSprite->flags;
-        pBurst->xrepeat = pSprite->xrepeat / 2;
-        pBurst->yrepeat = pSprite->yrepeat / 2;
-        pBurst->ang = ((pSprite->ang + missileInfo[pSprite->type - kMissileBase].angleOfs) & 2047);
+        pBurst->pal = actor->spr.pal;
+        pBurst->clipdist = actor->spr.clipdist / 4;
+        pBurst->flags = actor->spr.flags;
+        pBurst->xrepeat = actor->spr.xrepeat / 2;
+        pBurst->yrepeat = actor->spr.yrepeat / 2;
+        pBurst->ang = ((actor->spr.ang + missileInfo[actor->spr.type - kMissileBase].angleOfs) & 2047);
         burstactor->SetOwner(actor);
 
         actBuildMissile(burstactor, actor);
@@ -9104,13 +9104,13 @@ void clampSprite(DBloodActor* actor, int which)
 {
     auto pSprite = &actor->s();
     int zTop, zBot;
-    if (pSprite->insector())
+    if (actor->spr.insector())
     {
         GetSpriteExtents(pSprite, &zTop, &zBot);
         if (which & 0x01)
-            pSprite->pos.Z += ClipHigh(getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zBot, 0);
+            actor->spr.pos.Z += ClipHigh(getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) - zBot, 0);
         if (which & 0x02)
-            pSprite->pos.Z += ClipLow(getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zTop, 0);
+            actor->spr.pos.Z += ClipLow(getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) - zTop, 0);
 
     }
 
diff --git a/source/games/blood/src/seq.cpp b/source/games/blood/src/seq.cpp
index af3a0d8a4..b1b652660 100644
--- a/source/games/blood/src/seq.cpp
+++ b/source/games/blood/src/seq.cpp
@@ -243,68 +243,68 @@ void UpdateSprite(DBloodActor* actor, SEQFRAME* pFrame)
 {
 	spritetype* pSprite = &actor->s();
 	assert(actor->hasX());
-	if (pSprite->flags & 2)
+	if (actor->spr.flags & 2)
 	{
-		if (tileHeight(pSprite->picnum) != tileHeight(seqGetTile(pFrame)) || tileTopOffset(pSprite->picnum) != tileTopOffset(seqGetTile(pFrame))
-			|| (pFrame->yrepeat && pFrame->yrepeat != pSprite->yrepeat))
-			pSprite->flags |= 4;
+		if (tileHeight(actor->spr.picnum) != tileHeight(seqGetTile(pFrame)) || tileTopOffset(actor->spr.picnum) != tileTopOffset(seqGetTile(pFrame))
+			|| (pFrame->yrepeat && pFrame->yrepeat != actor->spr.yrepeat))
+			actor->spr.flags |= 4;
 	}
-	pSprite->picnum = seqGetTile(pFrame);
+	actor->spr.picnum = seqGetTile(pFrame);
 	if (pFrame->palette)
-		pSprite->pal = pFrame->palette;
-	pSprite->shade = pFrame->shade;
+		actor->spr.pal = pFrame->palette;
+	actor->spr.shade = pFrame->shade;
 
 	int scale = actor->xspr.scale; // SEQ size scaling
 	if (pFrame->xrepeat) {
-		if (scale) pSprite->xrepeat = ClipRange(MulScale(pFrame->xrepeat, scale, 8), 0, 255);
-		else pSprite->xrepeat = pFrame->xrepeat;
+		if (scale) actor->spr.xrepeat = ClipRange(MulScale(pFrame->xrepeat, scale, 8), 0, 255);
+		else actor->spr.xrepeat = pFrame->xrepeat;
 	}
 
 	if (pFrame->yrepeat) {
-		if (scale) pSprite->yrepeat = ClipRange(MulScale(pFrame->yrepeat, scale, 8), 0, 255);
-		else pSprite->yrepeat = pFrame->yrepeat;
+		if (scale) actor->spr.yrepeat = ClipRange(MulScale(pFrame->yrepeat, scale, 8), 0, 255);
+		else actor->spr.yrepeat = pFrame->yrepeat;
 	}
 
 	if (pFrame->transparent)
-		pSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
+		actor->spr.cstat |= CSTAT_SPRITE_TRANSLUCENT;
 	else
-		pSprite->cstat &= ~CSTAT_SPRITE_TRANSLUCENT;
+		actor->spr.cstat &= ~CSTAT_SPRITE_TRANSLUCENT;
 	if (pFrame->transparent2)
-		pSprite->cstat |= CSTAT_SPRITE_TRANS_FLIP;
+		actor->spr.cstat |= CSTAT_SPRITE_TRANS_FLIP;
 	else
-		pSprite->cstat &= ~CSTAT_SPRITE_TRANS_FLIP;
+		actor->spr.cstat &= ~CSTAT_SPRITE_TRANS_FLIP;
 	if (pFrame->blockable)
-		pSprite->cstat |= CSTAT_SPRITE_BLOCK;
+		actor->spr.cstat |= CSTAT_SPRITE_BLOCK;
 	else
-		pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
+		actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK;
 	if (pFrame->hittable)
-		pSprite->cstat |= CSTAT_SPRITE_BLOCK_HITSCAN;
+		actor->spr.cstat |= CSTAT_SPRITE_BLOCK_HITSCAN;
 	else
-		pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
+		actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
 	if (pFrame->invisible)
-		pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
+		actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
 	else
-		pSprite->cstat &= ~CSTAT_SPRITE_INVISIBLE;
+		actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
 	if (pFrame->pushable)
-		pSprite->cstat |= CSTAT_SPRITE_BLOOD_BIT1;
+		actor->spr.cstat |= CSTAT_SPRITE_BLOOD_BIT1;
 	else
-		pSprite->cstat &= ~CSTAT_SPRITE_BLOOD_BIT1;
+		actor->spr.cstat &= ~CSTAT_SPRITE_BLOOD_BIT1;
 	if (pFrame->smoke)
-		pSprite->flags |= 256;
+		actor->spr.flags |= 256;
 	else
-		pSprite->flags &= ~256;
+		actor->spr.flags &= ~256;
 	if (pFrame->aiming)
-		pSprite->flags |= 8;
+		actor->spr.flags |= 8;
 	else
-		pSprite->flags &= ~8;
+		actor->spr.flags &= ~8;
 	if (pFrame->flipx)
-		pSprite->flags |= 1024;
+		actor->spr.flags |= 1024;
 	else
-		pSprite->flags &= ~1024;
+		actor->spr.flags &= ~1024;
 	if (pFrame->flipy)
-		pSprite->flags |= 2048;
+		actor->spr.flags |= 2048;
 	else
-		pSprite->flags &= ~2048;
+		actor->spr.flags &= ~2048;
 }
 
 //---------------------------------------------------------------------------
@@ -352,8 +352,8 @@ void SEQINST::Update()
 		spritetype* pSprite = &actor->s();
 		if (!VanillaMode() && pSequence->frames[frameIndex].surfaceSound && actor->zvel == 0 && actor->xvel != 0) {
 
-			if (pSprite->sector()->upperLink) break; // don't play surface sound for stacked sectors
-			int surf = tileGetSurfType(pSprite->sector()->floorpicnum); 
+			if (actor->spr.sector()->upperLink) break; // don't play surface sound for stacked sectors
+			int surf = tileGetSurfType(actor->spr.sector()->floorpicnum); 
 			if (!surf) break;
 			static int surfSfxMove[15][4] = {
 				/* {snd1, snd2, gameVolume, myVolume} */
diff --git a/source/games/blood/src/triggers.cpp b/source/games/blood/src/triggers.cpp
index 6f7c1bbf5..c7e2c12ff 100644
--- a/source/games/blood/src/triggers.cpp
+++ b/source/games/blood/src/triggers.cpp
@@ -57,7 +57,7 @@ bool SetSpriteState(DBloodActor* actor, int nState)
     pXSprite->busy  = IntToFixed(nState);
     pXSprite->state = nState;
     evKillActor(actor);
-    if ((pSprite->flags & kHitagRespawn) != 0 && pSprite->inittype >= kDudeBase && pSprite->inittype < kDudeMax)
+    if ((actor->spr.flags & kHitagRespawn) != 0 && actor->spr.inittype >= kDudeBase && actor->spr.inittype < kDudeMax)
     {
         pXSprite->respawnPending = 3;
         evPostActor(actor, gGameOptions.nMonsterRespawnTime, kCallbackRespawn);
@@ -221,20 +221,20 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
                     GetSpriteExtents(pSprite, &top, &bottom);
                     int nType = pTarget->type-kDudeBase;
                     DUDEINFO *pDudeInfo = getDudeInfo(nType+kDudeBase);
-                    int z1 = (top-pSprite->pos.Z)-256;
+                    int z1 = (top-actor->spr.pos.Z)-256;
                     int x = pTarget->pos.X;
                     int y = pTarget->pos.Y;
                     int z = pTarget->pos.Z;
-                    int nDist = approxDist(x - pSprite->pos.X, y - pSprite->pos.Y);
-                    if (nDist != 0 && cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), x, y, z, pTarget->sector()))
+                    int nDist = approxDist(x - actor->spr.pos.X, y - actor->spr.pos.Y);
+                    if (nDist != 0 && cansee(actor->spr.pos.X, actor->spr.pos.Y, top, actor->spr.sector(), x, y, z, pTarget->sector()))
                     {
                         int t = DivScale(nDist, 0x1aaaaa, 12);
                         x += (target->xvel*t)>>12;
                         y += (target->yvel*t)>>12;
-                        int angBak = pSprite->ang;
-                        pSprite->ang = getangle(x-pSprite->pos.X, y-pSprite->pos.Y);
-                        int dx = bcos(pSprite->ang);
-                        int dy = bsin(pSprite->ang);
+                        int angBak = actor->spr.ang;
+                        actor->spr.ang = getangle(x-actor->spr.pos.X, y-actor->spr.pos.Y);
+                        int dx = bcos(actor->spr.ang);
+                        int dy = bsin(actor->spr.ang);
                         int tz = pTarget->pos.Z - (pTarget->yrepeat * pDudeInfo->aimHeight) * 4;
                         int dz = DivScale(tz - top - 256, nDist, 10);
                         int nMissileType = kMissileLifeLeechAltNormal + (pXSprite->data3 ? 1 : 0);
@@ -253,7 +253,7 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
                             if (!VanillaMode()) // disable collisions so lifeleech doesn't do that weird bobbing
                                 missile->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
                         }
-                        pSprite->ang = angBak;
+                        actor->spr.ang = angBak;
                     }
                 }
             }
@@ -288,7 +288,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
             return;
     }
 
-    if (pSprite->statnum == kStatDude && pSprite->type >= kDudeBase && pSprite->type < kDudeMax) {
+    if (actor->spr.statnum == kStatDude && actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax) {
         
         switch (event.cmd) {
             case kCmdOff:
@@ -309,7 +309,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
     }
 
 
-    switch (pSprite->type) {
+    switch (actor->spr.type) {
     case kTrapMachinegun:
         if (pXSprite->health <= 0) break; 
         switch (event.cmd) {
@@ -327,7 +327,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
         break;
     case kThingFallingRock:
         if (SetSpriteState(actor, 1))
-            pSprite->flags |= 7;
+            actor->spr.flags |= 7;
         break;
     case kThingWallCrack:
         if (SetSpriteState(actor, 0))
@@ -341,18 +341,18 @@ void OperateSprite(DBloodActor* actor, EVENT event)
         switch (event.cmd) {
             case kCmdOff:
                 pXSprite->state = 0;
-                pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
-                pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
+                actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
+                actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK;
                 break;
             case kCmdOn:
                 pXSprite->state = 1;
-                pSprite->cstat &= ~CSTAT_SPRITE_INVISIBLE;
-                pSprite->cstat |= CSTAT_SPRITE_BLOCK;
+                actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
+                actor->spr.cstat |= CSTAT_SPRITE_BLOCK;
                 break;
             case kCmdToggle:
                 pXSprite->state ^= 1;
-                pSprite->cstat ^= CSTAT_SPRITE_INVISIBLE;
-                pSprite->cstat ^= CSTAT_SPRITE_BLOCK;
+                actor->spr.cstat ^= CSTAT_SPRITE_INVISIBLE;
+                actor->spr.cstat ^= CSTAT_SPRITE_BLOCK;
                 break;
         }
         break;
@@ -475,15 +475,15 @@ void OperateSprite(DBloodActor* actor, EVENT event)
         SetSpriteState(actor, 1);
         for (int p = connecthead; p >= 0; p = connectpoint2[p]) {
             spritetype *pPlayerSprite = gPlayer[p].pSprite;
-            int dx = (pSprite->pos.X - pPlayerSprite->pos.X)>>4;
-            int dy = (pSprite->pos.Y - pPlayerSprite->pos.Y)>>4;
-            int dz = (pSprite->pos.Z - pPlayerSprite->pos.Z)>>8;
+            int dx = (actor->spr.pos.X - pPlayerSprite->pos.X)>>4;
+            int dy = (actor->spr.pos.Y - pPlayerSprite->pos.Y)>>4;
+            int dz = (actor->spr.pos.Z - pPlayerSprite->pos.Z)>>8;
             int nDist = dx*dx+dy*dy+dz*dz+0x40000;
             gPlayer[p].quakeEffect = DivScale(pXSprite->data1, nDist, 16);
         }
         break;
     case kThingTNTBarrel:
-        if (pSprite->flags & kHitagRespawn) return;
+        if (actor->spr.flags & kHitagRespawn) return;
         [[fallthrough]];
     case kThingArmedTNTStick:
     case kThingArmedTNTBundle:
@@ -496,13 +496,13 @@ void OperateSprite(DBloodActor* actor, EVENT event)
                 SetSpriteState(actor, 1);
                 break;
             default:
-                pSprite->cstat &= ~CSTAT_SPRITE_INVISIBLE;
+                actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
                 actExplodeSprite(actor);
                 break;
         }
         break;
     case kThingArmedRemoteBomb:
-        if (pSprite->statnum != kStatRespawn) {
+        if (actor->spr.statnum != kStatRespawn) {
             if (event.cmd != kCmdOn) actExplodeSprite(actor);
             else {
                 sfxPlay3DSound(actor, 454, 0, 0);
@@ -511,7 +511,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
         }
         break;    
     case kThingArmedProxBomb:
-        if (pSprite->statnum != kStatRespawn) {
+        if (actor->spr.statnum != kStatRespawn) {
             switch (event.cmd) {
                 case kCmdSpriteProximity:
                     if (pXSprite->state) break;
@@ -546,7 +546,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
                 SetSpriteState(actor, 0);
                 break;
             case kCmdRepeat:
-                if (pSprite->type != kGenTrigger) ActivateGenerator(actor);
+                if (actor->spr.type != kGenTrigger) ActivateGenerator(actor);
                 if (pXSprite->txID) evSendActor(actor, pXSprite->txID, (COMMAND_ID)pXSprite->command);
                 if (pXSprite->busyTime > 0) {
                     int nRand = Random2(pXSprite->data1);
@@ -706,7 +706,7 @@ void SectorStartSound(sectortype* pSector, int nState)
     while (auto actor = it.Next())
     {
         spritetype *pSprite = &actor->s();
-        if (pSprite->statnum == kStatDecoration && pSprite->type == kSoundSector && actor->hasX())
+        if (actor->spr.statnum == kStatDecoration && actor->spr.type == kSoundSector && actor->hasX())
         {
             XSPRITE *pXSprite = &actor->x();
             if (nState)
@@ -729,7 +729,7 @@ void SectorEndSound(sectortype* pSector, int nState)
     while (auto actor = it.Next())
     {
         spritetype* pSprite = &actor->s();
-        if (pSprite->statnum == kStatDecoration && pSprite->type == kSoundSector && actor->hasX())
+        if (actor->spr.statnum == kStatDecoration && actor->spr.type == kSoundSector && actor->hasX())
         {
             XSPRITE *pXSprite = &actor->x();
             if (nState)
@@ -752,7 +752,7 @@ void PathSound(sectortype* pSector, int nSound)
     while (auto actor = it.Next())
     {
         spritetype* pSprite = &actor->s();
-        if (pSprite->statnum == kStatDecoration && pSprite->type == kSoundSector)
+        if (actor->spr.statnum == kStatDecoration && actor->spr.type == kSoundSector)
             sfxPlay3DSound(actor, nSound, 0, 0);
     }
 }
@@ -862,11 +862,11 @@ void TranslateSector(sectortype* pSector, int a2, int a3, int a4, int a5, int a6
     {
         spritetype *pSprite = &actor->s();
         // allow to move markers by sector movements in game if flags 1 is added in editor.
-        switch (pSprite->statnum) {
+        switch (actor->spr.statnum) {
             case kStatMarker:
             case kStatPathMarker:
                 #ifdef NOONE_EXTENSIONS
-                    if (!gModernMap || !(pSprite->flags & 0x1)) continue;
+                    if (!gModernMap || !(actor->spr.flags & 0x1)) continue;
                 #else
                     continue;
                 #endif
@@ -875,37 +875,37 @@ void TranslateSector(sectortype* pSector, int a2, int a3, int a4, int a5, int a6
 
         x = actor->basePoint.X;
         y = actor->basePoint.Y;
-        if (pSprite->cstat & CSTAT_SPRITE_MOVE_FORWARD)
+        if (actor->spr.cstat & CSTAT_SPRITE_MOVE_FORWARD)
         {
             if (vbp)
                 RotatePoint((int*)&x, (int*)&y, vbp, a4, a5);
             viewBackupSpriteLoc(actor);
-            pSprite->ang = (pSprite->ang+v14)&2047;
-            pSprite->pos.X = x+vc-a4;
-            pSprite->pos.Y = y+v8-a5;
+            actor->spr.ang = (actor->spr.ang+v14)&2047;
+            actor->spr.pos.X = x+vc-a4;
+            actor->spr.pos.Y = y+v8-a5;
         }
-        else if (pSprite->cstat & CSTAT_SPRITE_MOVE_REVERSE)
+        else if (actor->spr.cstat & CSTAT_SPRITE_MOVE_REVERSE)
         {
             if (vbp)
                 RotatePoint((int*)& x, (int*)& y, -vbp, a4, a4);
             viewBackupSpriteLoc(actor);
-            pSprite->ang = (pSprite->ang-v14)&2047;
-            pSprite->pos.X = x-(vc-a4);
-            pSprite->pos.Y = y-(v8-a5);
+            actor->spr.ang = (actor->spr.ang-v14)&2047;
+            actor->spr.pos.X = x-(vc-a4);
+            actor->spr.pos.Y = y-(v8-a5);
         }
         else if (pXSector->Drag)
         {
             int top, bottom;
             GetSpriteExtents(pSprite, &top, &bottom);
-            int floorZ = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
-            if (!(pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) && floorZ <= bottom)
+            int floorZ = getflorzofslopeptr(pSector, actor->spr.pos.X, actor->spr.pos.Y);
+            if (!(actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) && floorZ <= bottom)
             {
                 if (v14)
-                    RotatePoint((int*)&pSprite->pos.X, (int*)&pSprite->pos.Y, v14, v20, v24);
+                    RotatePoint((int*)&actor->spr.pos.X, (int*)&actor->spr.pos.Y, v14, v20, v24);
                 viewBackupSpriteLoc(actor);
-                pSprite->ang = (pSprite->ang+v14)&2047;
-                pSprite->pos.X += v28;
-                pSprite->pos.Y += v2c;
+                actor->spr.ang = (actor->spr.ang+v14)&2047;
+                actor->spr.pos.X += v28;
+                actor->spr.pos.Y += v2c;
             }
         }
     }
@@ -925,21 +925,21 @@ void ZTranslateSector(sectortype* pSector, XSECTOR *pXSector, int a3, int a4)
         while (auto actor = it.Next())
         {
             spritetype* pSprite = &actor->s();
-            if (pSprite->statnum == kStatMarker || pSprite->statnum == kStatPathMarker)
+            if (actor->spr.statnum == kStatMarker || actor->spr.statnum == kStatPathMarker)
                 continue;
             int top, bottom;
             GetSpriteExtents(pSprite, &top, &bottom);
-            if (pSprite->cstat & CSTAT_SPRITE_MOVE_FORWARD)
+            if (actor->spr.cstat & CSTAT_SPRITE_MOVE_FORWARD)
             {
                 viewBackupSpriteLoc(actor);
-                pSprite->pos.Z += pSector->floorz-oldZ;
+                actor->spr.pos.Z += pSector->floorz-oldZ;
             }
-            else if (pSprite->flags&2)
-                pSprite->flags |= 4;
-            else if (oldZ <= bottom && !(pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK))
+            else if (actor->spr.flags&2)
+                actor->spr.flags |= 4;
+            else if (oldZ <= bottom && !(actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK))
             {
                 viewBackupSpriteLoc(actor);
-                pSprite->pos.Z += pSector->floorz-oldZ;
+                actor->spr.pos.Z += pSector->floorz-oldZ;
             }
         }
     }
@@ -954,12 +954,12 @@ void ZTranslateSector(sectortype* pSector, XSECTOR *pXSector, int a3, int a4)
         while (auto actor = it.Next())
         {
             spritetype* pSprite = &actor->s();
-            if (pSprite->statnum == kStatMarker || pSprite->statnum == kStatPathMarker)
+            if (actor->spr.statnum == kStatMarker || actor->spr.statnum == kStatPathMarker)
                 continue;
-            if (pSprite->cstat & CSTAT_SPRITE_MOVE_REVERSE)
+            if (actor->spr.cstat & CSTAT_SPRITE_MOVE_REVERSE)
             {
                 viewBackupSpriteLoc(actor);
-                pSprite->pos.Z += pSector->ceilingz-oldZ;
+                actor->spr.pos.Z += pSector->ceilingz-oldZ;
             }
         }
     }
@@ -974,13 +974,13 @@ DBloodActor* GetHighestSprite(sectortype* pSector, int nStatus, int *z)
     while (auto actor = it.Next())
     {
         spritetype* pSprite = &actor->s();
-        if (pSprite->statnum == nStatus || nStatus == kStatFree)
+        if (actor->spr.statnum == nStatus || nStatus == kStatFree)
         {
             int top, bottom;
             GetSpriteExtents(pSprite, &top, &bottom);
-            if (top-pSprite->pos.Z > *z)
+            if (top-actor->spr.pos.Z > *z)
             {
-                *z = top-pSprite->pos.Z;
+                *z = top-actor->spr.pos.Z;
                 found = actor;
             }
         }
@@ -999,7 +999,7 @@ DBloodActor* GetCrushedSpriteExtents(sectortype* pSector, int *pzTop, int *pzBot
     while (auto actor = it.Next())
     {
         spritetype* pSprite = &actor->s();
-        if (pSprite->statnum == kStatDude || pSprite->statnum == kStatThing)
+        if (actor->spr.statnum == kStatDude || actor->spr.statnum == kStatThing)
         {
             int top, bottom;
             GetActorExtents(actor, &top, &bottom);
@@ -1068,10 +1068,10 @@ int VSpriteBusy(sectortype* pSector, unsigned int a2)
         while (auto actor = it.Next())
         {
             spritetype *pSprite = &actor->s();
-            if (pSprite->cstat & CSTAT_SPRITE_MOVE_FORWARD)
+            if (actor->spr.cstat & CSTAT_SPRITE_MOVE_FORWARD)
             {
                 viewBackupSpriteLoc(actor);
-                pSprite->pos.Z = actor->basePoint.Z+MulScale(dz1, GetWaveValue(a2, nWave), 16);
+                actor->spr.pos.Z = actor->basePoint.Z+MulScale(dz1, GetWaveValue(a2, nWave), 16);
             }
         }
     }
@@ -1082,10 +1082,10 @@ int VSpriteBusy(sectortype* pSector, unsigned int a2)
         while (auto actor = it.Next())
         {
             spritetype* pSprite = &actor->s();
-            if (pSprite->cstat & CSTAT_SPRITE_MOVE_REVERSE)
+            if (actor->spr.cstat & CSTAT_SPRITE_MOVE_REVERSE)
             {
                 viewBackupSpriteLoc(actor);
-                pSprite->pos.Z = actor->basePoint.Z + MulScale(dz2, GetWaveValue(a2, nWave), 16);
+                actor->spr.pos.Z = actor->basePoint.Z + MulScale(dz2, GetWaveValue(a2, nWave), 16);
             }
         }
     }
@@ -1365,7 +1365,7 @@ bool SectorContainsDudes(sectortype * pSector)
     while (auto actor = it.Next())
     {
         spritetype* pSprite = &actor->s();
-        if (pSprite->statnum == kStatDude)
+        if (actor->spr.statnum == kStatDude)
             return 1;
     }
     return 0;
@@ -1397,12 +1397,12 @@ void OperateTeleport(sectortype* pSector)
     while (auto actor = it.Next())
     {
         spritetype *pSprite = &actor->s();
-        if (pSprite->statnum == kStatDude)
+        if (actor->spr.statnum == kStatDude)
         {
             PLAYER *pPlayer;
             char bPlayer = IsPlayerSprite(pSprite);
             if (bPlayer)
-                pPlayer = &gPlayer[pSprite->type-kDudePlayer1];
+                pPlayer = &gPlayer[actor->spr.type-kDudePlayer1];
             else
                 pPlayer = NULL;
             if (bPlayer || !SectorContainsDudes(pDest->sector()))
@@ -1411,10 +1411,10 @@ void OperateTeleport(sectortype* pSector)
                 {
                     TeleFrag(pXSector->actordata, pDest->sector());
                 }
-                pSprite->pos.X = pDest->pos.X;
-                pSprite->pos.Y = pDest->pos.Y;
-                pSprite->pos.Z += pDest->sector()->floorz - pSector->floorz;
-                pSprite->ang = pDest->ang;
+                actor->spr.pos.X = pDest->pos.X;
+                actor->spr.pos.Y = pDest->pos.Y;
+                actor->spr.pos.Z += pDest->sector()->floorz - pSector->floorz;
+                actor->spr.ang = pDest->ang;
                 ChangeActorSect(actor, pDest->sector());
                 sfxPlay3DSound(destactor, 201, -1, 0);
                 actor->xvel = actor->yvel = actor->zvel = 0;
@@ -1424,7 +1424,7 @@ void OperateTeleport(sectortype* pSector)
                 {
                     playerResetInertia(pPlayer);
                     pPlayer->zViewVel = pPlayer->zWeaponVel = 0;
-                    pPlayer->angle.settarget(pSprite->ang, true);
+                    pPlayer->angle.settarget(actor->spr.ang, true);
                 }
             }
         }
@@ -1434,7 +1434,6 @@ void OperateTeleport(sectortype* pSector)
 void OperatePath(sectortype* pSector, EVENT event)
 {
     DBloodActor* actor;
-    spritetype *pSprite = NULL;
     XSPRITE *pXSprite;
     assert(pSector);
     auto pXSector = &pSector->xs();
@@ -1446,8 +1445,7 @@ void OperatePath(sectortype* pSector, EVENT event)
     BloodStatIterator it(kStatPathMarker);
     while ((actor = it.Next()))
     {
-        pSprite = &actor->s();
-        if (pSprite->type == kMarkerPath)
+        if (actor->spr.type == kMarkerPath)
         {
             pXSprite = &actor->x();
             if (pXSprite->data1 == nId)
@@ -1470,7 +1468,7 @@ void OperatePath(sectortype* pSector, EVENT event)
         
     pXSector->marker1 = actor;
     pXSector->offFloorZ = pSprite1->pos.Z;
-    pXSector->onFloorZ = pSprite->pos.Z;
+    pXSector->onFloorZ = actor->spr.pos.Z;
     switch (event.cmd) {
         case kCmdOn:
             pXSector->state = 0;
@@ -1583,7 +1581,6 @@ void OperateSector(sectortype* pSector, EVENT event)
 void InitPath(sectortype* pSector, XSECTOR *pXSector)
 {
     DBloodActor* actor = nullptr;
-    spritetype *pSprite = nullptr;
     XSPRITE *pXSprite;
     assert(pSector);
     int nId = pXSector->data;
@@ -1591,8 +1588,7 @@ void InitPath(sectortype* pSector, XSECTOR *pXSector)
     BloodStatIterator it(kStatPathMarker);
     while ((actor = it.Next()))
     {
-        pSprite = &actor->s();
-        if (pSprite->type == kMarkerPath && actor->hasX())
+        if (actor->spr.type == kMarkerPath && actor->hasX())
         {
             pXSprite = &actor->x();
             if (pXSprite->data1 == nId)
@@ -1600,7 +1596,7 @@ void InitPath(sectortype* pSector, XSECTOR *pXSector)
         }
     }
     
-    if (pSprite == nullptr) {
+    if (actor == nullptr) {
         viewSetSystemMessage("Unable to find path marker with id #%d for path sector", nId);
         return;
         
@@ -1646,7 +1642,7 @@ void LinkSprite(DBloodActor* actor, EVENT event)
     auto pXSprite = &actor->x();
     int nBusy = GetSourceBusy(event);
 
-    switch (pSprite->type)  {
+    switch (actor->spr.type)  {
         case kSwitchCombo:
         {
             if (event.isActor())
@@ -1791,7 +1787,7 @@ void trMessageSprite(DBloodActor* actor, EVENT event)
 {
     auto pSprite = &actor->s();
     auto pXSprite = &actor->x();
-    if (pSprite->statnum != kStatFree) {
+    if (actor->spr.statnum != kStatFree) {
 
         if (!pXSprite->locked || event.cmd == kCmdUnlock || event.cmd == kCmdToggleLock) 
         {
@@ -1837,10 +1833,10 @@ void ProcessMotion(void)
             while (auto actor = it.Next())
             {
                 auto pSprite = &actor->s();
-                if (pSprite->cstat & CSTAT_SPRITE_MOVE_MASK)
+                if (actor->spr.cstat & CSTAT_SPRITE_MOVE_MASK)
                 {
                     viewBackupSpriteLoc(actor);
-                    pSprite->pos.Z += vdi;
+                    actor->spr.pos.Z += vdi;
                 }
             }
             if (pXSector->bobFloor)
@@ -1853,16 +1849,16 @@ void ProcessMotion(void)
                 while (auto actor = it.Next())
                 {
                     auto pSprite = &actor->s();
-                    if (pSprite->flags&2)
-                        pSprite->flags |= 4;
+                    if (actor->spr.flags&2)
+                        actor->spr.flags |= 4;
                     else
                     {
                         int top, bottom;
                         GetSpriteExtents(pSprite, &top, &bottom);
-                        if (bottom >= floorZ && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
+                        if (bottom >= floorZ && (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
                         {
                             viewBackupSpriteLoc(actor);
-                            pSprite->pos.Z += vdi;
+                            actor->spr.pos.Z += vdi;
                         }
                     }
                 }
@@ -1879,10 +1875,10 @@ void ProcessMotion(void)
                     auto pSprite = &actor->s();
                     int top, bottom;
                     GetSpriteExtents(pSprite, &top, &bottom);
-                    if (top <= ceilZ && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
+                    if (top <= ceilZ && (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
                     {
                         viewBackupSpriteLoc(actor);
-                        pSprite->pos.Z += vdi;
+                        actor->spr.pos.Z += vdi;
                     }
                 }
             }
@@ -2062,12 +2058,12 @@ void trInit(TArray<DBloodActor*>& actors)
     for (auto actor : actors)
     {
         auto pSprite = &actor->s();
-        if (pSprite->statnum < kStatFree && actor->hasX())
+        if (actor->spr.statnum < kStatFree && actor->hasX())
         {
             auto pXSprite = &actor->x();
             if (pXSprite->state)
                 pXSprite->busy = 65536;
-            switch (pSprite->type) {
+            switch (actor->spr.type) {
             case kSwitchPadlock:
                 pXSprite->triggerOnce = 1;
                 break;
@@ -2106,12 +2102,12 @@ void trInit(TArray<DBloodActor*>& actors)
                 pXSprite->Proximity = 1;
                 break;
             case kThingFallingRock:
-                if (pXSprite->state) pSprite->flags |= 7;
-                else pSprite->flags &= ~7;
+                if (pXSprite->state) actor->spr.flags |= 7;
+                else actor->spr.flags &= ~7;
                 break;
             }
-            if (pXSprite->Vector) pSprite->cstat |= CSTAT_SPRITE_BLOCK_HITSCAN;
-            if (pXSprite->Push) pSprite->cstat |= CSTAT_SPRITE_BLOOD_BIT1;
+            if (pXSprite->Vector) actor->spr.cstat |= CSTAT_SPRITE_BLOCK_HITSCAN;
+            if (pXSprite->Push) actor->spr.cstat |= CSTAT_SPRITE_BLOOD_BIT1;
         }
     }
     
@@ -2142,10 +2138,10 @@ void InitGenerator(DBloodActor* actor)
     spritetype *pSprite = &actor->s();
     assert(actor->hasX());
     XSPRITE *pXSprite = &actor->x();
-    switch (pSprite->type) {
+    switch (actor->spr.type) {
         case kGenTrigger:
-            pSprite->cstat &= ~CSTAT_SPRITE_BLOCK;
-            pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
+            actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK;
+            actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
             break;
     }
     if (pXSprite->state != pXSprite->restState && pXSprite->busyTime > 0)
@@ -2157,12 +2153,12 @@ void ActivateGenerator(DBloodActor* actor)
     spritetype *pSprite = &actor->s();
     assert(actor->hasX());
     XSPRITE *pXSprite = &actor->x();
-    switch (pSprite->type) {
+    switch (actor->spr.type) {
         case kGenDripWater:
         case kGenDripBlood: {
             int top, bottom;
             GetActorExtents(actor, &top, &bottom);
-            actSpawnThing(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, bottom, (pSprite->type == kGenDripWater) ? kThingDripWater : kThingDripBlood);
+            actSpawnThing(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, bottom, (actor->spr.type == kGenDripWater) ? kThingDripWater : kThingDripBlood);
             break;
         }
         case kGenSound:
@@ -2187,7 +2183,7 @@ void ActivateGenerator(DBloodActor* actor)
         case kGenBubbleMulti: {
             int top, bottom;
             GetActorExtents(actor, &top, &bottom);
-            gFX.fxSpawnActor((pSprite->type == kGenBubble) ? FX_23 : FX_26, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, top, 0);
+            gFX.fxSpawnActor((actor->spr.type == kGenBubble) ? FX_23 : FX_26, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, top, 0);
             break;
         }
     }
@@ -2196,10 +2192,10 @@ void ActivateGenerator(DBloodActor* actor)
 void FireballTrapSeqCallback(int, DBloodActor* actor)
 {
     spritetype* pSprite = &actor->s();
-    if (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)
-        actFireMissile(actor, 0, 0, 0, 0, (pSprite->cstat & CSTAT_SPRITE_YFLIP) ? 0x4000 : -0x4000, kMissileFireball);
+    if (actor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)
+        actFireMissile(actor, 0, 0, 0, 0, (actor->spr.cstat & CSTAT_SPRITE_YFLIP) ? 0x4000 : -0x4000, kMissileFireball);
     else
-        actFireMissile(actor, 0, 0, bcos(pSprite->ang), bsin(pSprite->ang), 0, kMissileFireball);
+        actFireMissile(actor, 0, 0, bcos(actor->spr.ang), bsin(actor->spr.ang), 0, kMissileFireball);
 }
 
 
@@ -2215,8 +2211,8 @@ void MGunFireSeqCallback(int, DBloodActor* actor)
             if (pXSprite->data2 == 0)
                 evPostActor(actor, 1, kCmdOff);
         }
-        int dx = bcos(pSprite->ang)+Random2(1000);
-        int dy = bsin(pSprite->ang)+Random2(1000);
+        int dx = bcos(actor->spr.ang)+Random2(1000);
+        int dy = bsin(actor->spr.ang)+Random2(1000);
         int dz = Random2(1000);
         actFireVector(actor, 0, 0, dx, dy, dz, kVectorBullet);
         sfxPlay3DSound(actor, 359, -1, 0);
diff --git a/source/games/blood/src/warp.cpp b/source/games/blood/src/warp.cpp
index ef14daed5..7e11ecbfd 100644
--- a/source/games/blood/src/warp.cpp
+++ b/source/games/blood/src/warp.cpp
@@ -69,15 +69,15 @@ void warpInit(TArray<DBloodActor*>& actors)
         spritetype* pSprite = &actor->s();
             if (actor->hasX()) {
                 XSPRITE *pXSprite = &actor->x();
-                switch (pSprite->type) {
+                switch (actor->spr.type) {
                     case kMarkerSPStart:
                         if (gGameOptions.nGameType < 2 && pXSprite->data1 >= 0 && pXSprite->data1 < kMaxPlayers) {
                             ZONE *pZone = &gStartZone[pXSprite->data1];
-                            pZone->x = pSprite->pos.X;
-                            pZone->y = pSprite->pos.Y;
-                            pZone->z = pSprite->pos.Z;
-                            pZone->sector = pSprite->sector();
-                            pZone->ang = pSprite->ang;
+                            pZone->x = actor->spr.pos.X;
+                            pZone->y = actor->spr.pos.Y;
+                            pZone->z = actor->spr.pos.Z;
+                            pZone->sector = actor->spr.sector();
+                            pZone->ang = actor->spr.ang;
                         }
                         DeleteSprite(actor);
                         break;
@@ -86,31 +86,31 @@ void warpInit(TArray<DBloodActor*>& actors)
                             if (gGameOptions.nGameType >= 2) {
                                 // default if BB or teams without data2 specified
                                 ZONE* pZone = &gStartZone[pXSprite->data1];
-                                pZone->x = pSprite->pos.X;
-                                pZone->y = pSprite->pos.Y;
-                                pZone->z = pSprite->pos.Z;
-                                pZone->sector = pSprite->sector();
-                                pZone->ang = pSprite->ang;
+                                pZone->x = actor->spr.pos.X;
+                                pZone->y = actor->spr.pos.Y;
+                                pZone->z = actor->spr.pos.Z;
+                                pZone->sector = actor->spr.sector();
+                                pZone->ang = actor->spr.ang;
                             
                                 #ifdef NOONE_EXTENSIONS
                                     // fill player spawn position according team of player in TEAMS mode.
                                     if (gModernMap && gGameOptions.nGameType == 3) {
                                         if (pXSprite->data2 == 1) {
                                             pZone = &gStartZoneTeam1[team1];
-                                            pZone->x = pSprite->pos.X;
-                                            pZone->y = pSprite->pos.Y;
-                                            pZone->z = pSprite->pos.Z;
-                                            pZone->sector = pSprite->sector();
-                                            pZone->ang = pSprite->ang;
+                                            pZone->x = actor->spr.pos.X;
+                                            pZone->y = actor->spr.pos.Y;
+                                            pZone->z = actor->spr.pos.Z;
+                                            pZone->sector = actor->spr.sector();
+                                            pZone->ang = actor->spr.ang;
                                             team1++;
 
                                         } else if (pXSprite->data2 == 2) {
                                             pZone = &gStartZoneTeam2[team2];
-                                            pZone->x = pSprite->pos.X;
-                                            pZone->y = pSprite->pos.Y;
-                                            pZone->z = pSprite->pos.Z;
-                                            pZone->sector = pSprite->sector();
-                                            pZone->ang = pSprite->ang;
+                                            pZone->x = actor->spr.pos.X;
+                                            pZone->y = actor->spr.pos.Y;
+                                            pZone->z = actor->spr.pos.Z;
+                                            pZone->sector = actor->spr.sector();
+                                            pZone->ang = actor->spr.ang;
                                             team2++;
                                         }
                                     }
@@ -121,30 +121,30 @@ void warpInit(TArray<DBloodActor*>& actors)
                         }
                         break;
                     case kMarkerUpLink:
-                        pSprite->sector()->upperLink = actor;
-                        pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
-                        pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
+                        actor->spr.sector()->upperLink = actor;
+                        actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
+                        actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
                         break;
                     case kMarkerLowLink:
-                        pSprite->sector()->lowerLink = actor;
-                        pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
-                        pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
+                        actor->spr.sector()->lowerLink = actor;
+                        actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
+                        actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
                         break;
                     case kMarkerUpWater:
                     case kMarkerUpStack:
                     case kMarkerUpGoo:
-                        pSprite->sector()->upperLink = actor;
-                        pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
-                        pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
-                        pSprite->pos.Z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
+                        actor->spr.sector()->upperLink = actor;
+                        actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
+                        actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
+                        actor->spr.pos.Z = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
                         break;
                     case kMarkerLowWater:
                     case kMarkerLowStack:
                     case kMarkerLowGoo:
-                        pSprite->sector()->lowerLink = actor;
-                        pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
-                        pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
-                        pSprite->pos.Z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
+                        actor->spr.sector()->lowerLink = actor;
+                        actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
+                        actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
+                        actor->spr.pos.Z = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
                         break;
                 }
             }
@@ -191,7 +191,7 @@ void warpInit(TArray<DBloodActor*>& actors)
 int CheckLink(DBloodActor *actor)
 {
     auto pSprite = &actor->s();
-    auto pSector = pSprite->sector();
+    auto pSector = actor->spr.sector();
     auto aUpper = barrier_cast<DBloodActor*>(pSector->upperLink);
     auto aLower = barrier_cast<DBloodActor*>(pSector->lowerLink);
     if (aUpper)
@@ -201,22 +201,22 @@ int CheckLink(DBloodActor *actor)
         if (pUpper->type == kMarkerUpLink)
             z = pUpper->pos.Z;
         else
-            z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
-        if (z <= pSprite->pos.Z)
+            z = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
+        if (z <= actor->spr.pos.Z)
         {
             aLower = aUpper->GetOwner();
             assert(aLower);
             spritetype *pLower = &aLower->s();
             assert(pLower->insector());
             ChangeActorSect(actor, pLower->sector());
-            pSprite->pos.X += pLower->pos.X - pUpper->pos.X;
-            pSprite->pos.Y += pLower->pos.Y - pUpper->pos.Y;
+            actor->spr.pos.X += pLower->pos.X - pUpper->pos.X;
+            actor->spr.pos.Y += pLower->pos.Y - pUpper->pos.Y;
             int z2;
             if (pLower->type == kMarkerLowLink)
                 z2 = pLower->pos.Z;
             else
-                z2 = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
-            pSprite->pos.Z += z2-z;
+                z2 = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
+            actor->spr.pos.Z += z2-z;
             actor->interpolated = false;
             return pUpper->type;
         }
@@ -228,22 +228,22 @@ int CheckLink(DBloodActor *actor)
         if (pLower->type == kMarkerLowLink)
             z = pLower->pos.Z;
         else
-            z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
-        if (z >= pSprite->pos.Z)
+            z = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
+        if (z >= actor->spr.pos.Z)
         {
             aUpper = aLower->GetOwner();
             assert(aUpper);
             spritetype *pUpper = &aUpper->s();
             assert(pUpper->insector());
             ChangeActorSect(actor, pUpper->sector());
-            pSprite->pos.X += pUpper->pos.X - pLower->pos.X;
-            pSprite->pos.Y += pUpper->pos.Y - pLower->pos.Y;
+            actor->spr.pos.X += pUpper->pos.X - pLower->pos.X;
+            actor->spr.pos.Y += pUpper->pos.Y - pLower->pos.Y;
             int z2;
             if (pUpper->type == kMarkerUpLink)
                 z2 = pUpper->pos.Z;
             else
-                z2 = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
-            pSprite->pos.Z += z2-z;
+                z2 = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
+            actor->spr.pos.Z += z2-z;
             actor->interpolated = false;
             return pLower->type;
         }