teambeef/raze
0
0
Fork 0
mirror of https://github.com/DrBeef/Raze.git synced 2025-04-08 00:31:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

- the ultimate 'replace pSprite-> with actor->spr. commit.

Browse source 
This takes care of the majority of s() uses in Blood with a single search&replace action after ensuring that pSprite never gets used for other things.
(There were two small functions in nnexts.cpp left that still did.)
This commit is contained in:
Christoph Oelckers 2021-12-23 00:41:35 +01:00
parent 1f11eb24dd
commit 6b8ec17017
9 changed files with 552 additions and 556 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
source/games/blood/src/_polymost.cpp
View file

@ -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;

4
source/games/blood/src/eventq.cpp
View file

@ -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())
{

92
source/games/blood/src/fx.cpp
View file

@ -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);

60
source/games/blood/src/gameutil.cpp
View file

@ -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)

22
source/games/blood/src/gib.cpp
View file

@ -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);

494
source/games/blood/src/nnexts.cpp
View file

File diff suppressed because it is too large Load diff

66
source/games/blood/src/seq.cpp
View file

@ -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} */

208
source/games/blood/src/triggers.cpp
View file

@ -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);

96
source/games/blood/src/warp.cpp
View file

@ -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;
}