zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-03-06 00:41:02 +00:00
Code Issues Projects Releases Packages Wiki Activity

- use DCoreActor::sector() wherever possible.

Browse source
This commit is contained in:
Christoph Oelckers 2021-12-30 16:51:56 +01:00
parent 88e4bb9f79
commit 5498699faf
124 changed files with 1567 additions and 1567 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
source/core/automap.cpp
View file

@ -627,8 +627,8 @@ void renderDrawMapView(int cposx, int cposy, int czoom, int cang)
vertices[j] = { x1 / 4096.f, y1 / 4096.f, j == 1 || j == 2 ? 1.f : 0.f, j == 2 || j == 3 ? 1.f : 0.f };
}
int shade;
if ((actor->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)) shade = actor->spr.sector()->ceilingshade;
else shade = actor->spr.sector()->floorshade;
if ((actor->sector()->ceilingstat & CSTAT_SECTOR_SKY)) shade = actor->sector()->ceilingshade;
else shade = actor->sector()->floorshade;
shade += actor->spr.shade;
PalEntry color = shadeToLight(shade);
FRenderStyle rs = LegacyRenderStyles[STYLE_Translucent];

2
source/core/coreactor.h
View file

@ -44,7 +44,7 @@ public:
sectortype* sector() const
{
return spr.sector();
return spr.sectp;
}
bool insector() const

2
source/core/maploader.cpp
View file

@ -364,7 +364,7 @@ static void ReadSpriteV5(FileReader& fr, spritetype& spr, int& secno)
spr.hitag = fr.ReadInt16();
spr.extra = fr.ReadInt16();
auto sec = spr.sector();
auto sec = spr.sectp;
if ((sec->ceilingstat & CSTAT_SECTOR_SKY) > 0)
spr.pal = sec->ceilingpal;
else

120
source/games/blood/src/actor.cpp
View file

@ -2713,7 +2713,7 @@ static void actNapalmMove(DBloodActor* actor)
if (Chance(0x8000)) actor->spr.cstat |= CSTAT_SPRITE_XFLIP;
sfxPlay3DSound(actor, 303, 24 + (actor->spr.flags & 3), 1);
actRadiusDamage(pOwner, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), 128, 0, 60, kDamageExplode, 15, 120);
actRadiusDamage(pOwner, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), 128, 0, 60, kDamageExplode, 15, 120);
if (actor->xspr.data4 > 1)
{
@ -2746,7 +2746,7 @@ static void actNapalmMove(DBloodActor* actor)
static DBloodActor* actSpawnFloor(DBloodActor* actor)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
updatesector(x, y, &pSector);
@ -2892,7 +2892,7 @@ bool actHealDude(DBloodActor* actor, int add, int threshold)
threshold <<= 4;
if (actor->xspr.health < (unsigned)threshold)
{
if (actor->IsPlayerActor()) sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 780, actor->spr.sector());
if (actor->IsPlayerActor()) sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 780, actor->sector());
actor->xspr.health = min<uint32_t>(actor->xspr.health + add, threshold);
return true;
}
@ -2965,7 +2965,7 @@ static bool actKillModernDude(DBloodActor* actor, DAMAGE_TYPE damageType)
else
{
seqKill(actor);
DBloodActor* pEffect = gFX.fxSpawnActor((FX_ID)52, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang);
DBloodActor* pEffect = gFX.fxSpawnActor((FX_ID)52, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang);
if (pEffect != nullptr)
{
pEffect->spr.cstat = CSTAT_SPRITE_ALIGNMENT_FACING;
@ -3725,7 +3725,7 @@ static int actDamageThing(DBloodActor* source, DBloodActor* actor, int damage, D
{
case -1:
GibSprite(actor, GIBTYPE_14, nullptr, nullptr);
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 312, actor->spr.sector());
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 312, actor->sector());
actPostSprite(actor, kStatFree);
break;
@ -3877,7 +3877,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case 4:
if (pWallHit)
{
auto pFX = gFX.fxSpawnActor(FX_52, missileActor->spr.sector(), missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_52, missileActor->sector(), missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 0);
if (pFX) pFX->spr.ang = (GetWallAngle(pWallHit) + 512) & 2047;
}
break;
@ -3898,7 +3898,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileArcGargoyle:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 306, missileActor->spr.sector());
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 306, missileActor->sector());
GibSprite(missileActor, GIBTYPE_6, NULL, NULL);
if (hitCode == 3 && actorHit && (pThingInfo || pDudeInfo))
@ -3912,7 +3912,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileLifeLeechAltNormal:
case kMissileLifeLeechAltSmall:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 306, missileActor->spr.sector());
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 306, missileActor->sector());
if (hitCode == 3 && actorHit && (pThingInfo || pDudeInfo))
{
@ -3951,7 +3951,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
evPostActor(actorHit, 0, kCallbackFXFlameLick);
actBurnSprite(missileOwner, actorHit, 480);
actRadiusDamage(missileOwner, missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, missileActor->spr.sector(), 16, 20, 10, kDamageBullet, 6, 480);
actRadiusDamage(missileOwner, missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, missileActor->sector(), 16, 20, 10, kDamageBullet, 6, 480);
// by NoOne: allow additional bullet damage for Flare Gun
if (gGameOptions.weaponsV10x && !VanillaMode())
@ -4026,7 +4026,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileEctoSkull:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 522, missileActor->spr.sector());
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 522, missileActor->sector());
actPostSprite(missileActor, kStatDebris);
seqSpawn(20, missileActor, -1);
if (hitCode == 3 && actorHit && actorHit->hasX())
@ -4059,7 +4059,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileTeslaRegular:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 518, missileActor->spr.sector());
sfxPlay3DSound(missileActor->spr.pos.X, missileActor->spr.pos.Y, missileActor->spr.pos.Z, 518, missileActor->sector());
GibSprite(missileActor, (hitCode == 2) ? GIBTYPE_23 : GIBTYPE_22, NULL, NULL);
evKillActor(missileActor);
seqKill(missileActor);
@ -4293,7 +4293,7 @@ static void checkHit(DBloodActor* actor)
break;
case kThingZombieHead:
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 357, actor->spr.sector());
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 357, actor->sector());
actKickObject(actor, actor2);
actDamageSprite(nullptr, actor2, kDamageFall, 80);
break;
@ -4371,7 +4371,7 @@ static void checkFloorHit(DBloodActor* actor)
pPlayer->kickPower = PlayClock + 60;
}
actKickObject(actor, actor2);
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 357, actor->spr.sector());
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 357, actor->sector());
sfxPlay3DSound(actor, 374, 0, 0);
break;
case kThingZombieHead:
@ -4381,7 +4381,7 @@ static void checkFloorHit(DBloodActor* actor)
pPlayer->kickPower = PlayClock + 60;
}
actKickObject(actor, actor2);
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 357, actor->spr.sector());
sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 357, actor->sector());
actDamageSprite(nullptr, actor2, kDamageFall, 80);
break;
case kTrapSawCircular:
@ -4501,8 +4501,8 @@ void actAirDrag(DBloodActor* actor, int a2)
{
int wind_x = 0;
int wind_y = 0;
assert(actor->spr.sector());
sectortype* pSector = actor->spr.sector();
assert(actor->sector());
sectortype* pSector = actor->sector();
if (pSector->hasX())
{
XSECTOR* pXSector = &pSector->xs();
@ -4530,7 +4530,7 @@ static Collision MoveThing(DBloodActor* actor)
assert(actor->hasX());
assert(actor->spr.type >= kThingBase && actor->spr.type < kThingMax);
const THINGINFO* pThingInfo = &thingInfo[actor->spr.type - kThingBase];
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
assert(pSector);
int top, bottom;
Collision lhit;
@ -4549,7 +4549,7 @@ static Collision MoveThing(DBloodActor* actor)
enginecompatibility_mode = bakCompat; // restore
actor->spr.cstat = bakCstat;
assert(pSector);
if (actor->spr.sector() != pSector)
if (actor->sector() != pSector)
{
assert(pSector);
ChangeActorSect(actor, pSector);
@ -4591,7 +4591,7 @@ static Collision MoveThing(DBloodActor* actor)
actor->vel.Z += 58254;
if (actor->spr.type == kThingZombieHead)
{
auto* fxActor = gFX.fxSpawnActor(FX_27, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto* fxActor = gFX.fxSpawnActor(FX_27, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (fxActor)
{
int v34 = (PlayClock * 3) & 2047;
@ -4614,21 +4614,21 @@ static Collision MoveThing(DBloodActor* actor)
GetActorExtents(actor, &top, &bottom);
if (bottom >= floorZ)
{
actTouchFloor(actor, actor->spr.sector());
actTouchFloor(actor, actor->sector());
actor->hit.florhit = floorColl;
actor->spr.pos.Z += floorZ - bottom;
int v20 = actor->vel.Z - actor->spr.sector()->velFloor;
int v20 = actor->vel.Z - actor->sector()->velFloor;
if (v20 > 0)
{
actor->spr.flags |= 4;
int vax = actFloorBounceVector(&actor->vel.X, &actor->vel.Y, (int*)&v20, actor->spr.sector(), pThingInfo->elastic);
int vax = actFloorBounceVector(&actor->vel.X, &actor->vel.Y, (int*)&v20, actor->sector(), pThingInfo->elastic);
int nDamage = MulScale(vax, vax, 30) - pThingInfo->dmgResist;
if (nDamage > 0) actDamageSprite(actor, actor, kDamageFall, nDamage);
actor->vel.Z = v20;
if (actor->spr.sector()->velFloor == 0 && abs(actor->vel.Z) < 0x10000)
if (actor->sector()->velFloor == 0 && abs(actor->vel.Z) < 0x10000)
{
actor->vel.Z = 0;
actor->spr.flags &= ~4;
@ -4747,7 +4747,7 @@ void MoveDude(DBloodActor* actor)
int bz = (bottom - actor->spr.pos.Z) / 4;
int tz = (actor->spr.pos.Z - top) / 4;
int wd = actor->spr.clipdist << 2;
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
int nAiStateType = (actor->xspr.aiState) ? actor->xspr.aiState->stateType : -1;
assert(pSector);
@ -4759,7 +4759,7 @@ void MoveDude(DBloodActor* actor)
actor->spr.pos.X += actor->vel.X >> 12;
actor->spr.pos.Y += actor->vel.Y >> 12;
if (!FindSector(actor->spr.pos.X, actor->spr.pos.Y, &pSector))
pSector = actor->spr.sector();
pSector = actor->sector();
}
else
{
@ -4768,7 +4768,7 @@ void MoveDude(DBloodActor* actor)
ClipMove(actor->spr.pos, &pSector, actor->vel.X >> 12, actor->vel.Y >> 12, wd, tz, bz, CLIPMASK0, actor->hit.hit);
if (pSector == nullptr)
{
pSector = actor->spr.sector();
pSector = actor->sector();
if (actor->spr.statnum == kStatDude || actor->spr.statnum == kStatThing)
actDamageSprite(actor, actor, kDamageFall, 1000 << 4);
}
@ -4847,10 +4847,10 @@ void MoveDude(DBloodActor* actor)
XSECTOR* pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (actor->spr.sector() != pSector)
if (actor->sector() != pSector)
{
assert(actor->spr.sector());
auto pOldSector = actor->spr.sector();
assert(actor->sector());
auto pOldSector = actor->sector();
XSECTOR* pXOldSector = pOldSector->hasX() ? &pOldSector->xs() : nullptr;
if (pXOldSector && pXOldSector->Exit && (pPlayer || !pXOldSector->dudeLockout))
@ -4864,7 +4864,7 @@ void MoveDude(DBloodActor* actor)
trTriggerSector(pSector, kCmdSectorEnter);
}
pSector = actor->spr.sector();
pSector = actor->sector();
}
int bUnderwater = 0;
int bDepth = 0;
@ -4938,11 +4938,11 @@ void MoveDude(DBloodActor* actor)
{
case kMarkerLowStack:
if (pPlayer == gView)
gotpic.Set(actor->spr.sector()->floorpicnum);
gotpic.Set(actor->sector()->floorpicnum);
break;
case kMarkerUpStack:
if (pPlayer == gView)
gotpic.Set(actor->spr.sector()->ceilingpicnum);
gotpic.Set(actor->sector()->ceilingpicnum);
break;
case kMarkerLowWater:
case kMarkerLowGoo:
@ -5106,10 +5106,10 @@ void MoveDude(DBloodActor* actor)
{
actor->hit.florhit = floorColl;
actor->spr.pos.Z += floorZ - bottom;
int v30 = actor->vel.Z - actor->spr.sector()->velFloor;
int v30 = actor->vel.Z - actor->sector()->velFloor;
if (v30 > 0)
{
int vax = actFloorBounceVector((int*)&actor->vel.X, (int*)&actor->vel.Y, (int*)&v30, actor->spr.sector(), 0);
int vax = actFloorBounceVector((int*)&actor->vel.X, (int*)&actor->vel.Y, (int*)&v30, actor->sector(), 0);
int nDamage = MulScale(vax, vax, 30);
if (pPlayer)
{
@ -5126,7 +5126,7 @@ void MoveDude(DBloodActor* actor)
actor->vel.Z = v30;
if (abs(actor->vel.Z) < 0x10000)
{
actor->vel.Z = actor->spr.sector()->velFloor;
actor->vel.Z = actor->sector()->velFloor;
actor->spr.flags &= ~4;
}
else
@ -5135,16 +5135,16 @@ void MoveDude(DBloodActor* actor)
switch (tileGetSurfType(floorColl))
{
case kSurfWater:
gFX.fxSpawnActor(FX_9, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
gFX.fxSpawnActor(FX_9, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
break;
case kSurfLava:
{
auto pFX = gFX.fxSpawnActor(FX_10, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
auto pFX = gFX.fxSpawnActor(FX_10, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
if (pFX)
{
for (int i = 0; i < 7; i++)
{
auto pFX2 = gFX.fxSpawnActor(FX_14, pFX->spr.sector(), pFX->spr.pos.X, pFX->spr.pos.Y, pFX->spr.pos.Z, 0);
auto pFX2 = gFX.fxSpawnActor(FX_14, pFX->sector(), pFX->spr.pos.X, pFX->spr.pos.Y, pFX->spr.pos.Z, 0);
if (pFX2)
{
pFX2->vel.X = Random2(0x6aaaa);
@ -5194,7 +5194,7 @@ void MoveDude(DBloodActor* actor)
return;
}
}
if (IsUnderwaterSector(actor->spr.sector()))
if (IsUnderwaterSector(actor->sector()))
return;
if (actor->xspr.height >= 0x100)
return;
@ -5258,7 +5258,7 @@ int MoveMissile(DBloodActor* actor)
while (1)
{
vec3_t pos = actor->spr.pos;
auto pSector2 = actor->spr.sector();
auto pSector2 = actor->sector();
const auto bakSpriteCstat = actor->spr.cstat;
if (Owner && !isFlameSprite && !cl_bloodvanillaexplosions && !VanillaMode())
{
@ -5343,13 +5343,13 @@ int MoveMissile(DBloodActor* actor)
actor->spr.pos = pos;
actor->spr.pos.Z += vz;
updatesector(pos.X, pos.Y, &pSector);
if (pSector != nullptr && pSector != actor->spr.sector())
if (pSector != nullptr && pSector != actor->sector())
{
assert(pSector);
ChangeActorSect(actor, pSector);
}
CheckLink(actor);
gHitInfo.hitSector = actor->spr.sector();
gHitInfo.hitSector = actor->sector();
gHitInfo.hitpos.X = actor->spr.pos.X;
gHitInfo.hitpos.Y = actor->spr.pos.Y;
gHitInfo.hitpos.Z = actor->spr.pos.Z;
@ -5433,7 +5433,7 @@ void actExplodeSprite(DBloodActor* actor)
case kThingTNTBarrel:
{
auto spawned = actSpawnSprite(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0, 1);
auto spawned = actSpawnSprite(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0, 1);
spawned->SetOwner(actor->GetOwner());
if (actCheckRespawn(actor))
{
@ -5530,7 +5530,7 @@ void actActivateGibObject(DBloodActor* actor)
if (gib1 > 0) GibSprite(actor, (GIBTYPE)(gib1 - 1), nullptr, nullptr);
if (gib2 > 0) GibSprite(actor, (GIBTYPE)(gib2 - 1), nullptr, nullptr);
if (gib3 > 0 && actor->xspr.burnTime > 0) GibSprite(actor, (GIBTYPE)(gib3 - 1), nullptr, nullptr);
if (sound > 0) sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, sound, actor->spr.sector());
if (sound > 0) sfxPlay3DSound(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, sound, actor->sector());
if (dropmsg > 0) actDropObject(actor, dropmsg);
if (!(actor->spr.cstat & CSTAT_SPRITE_INVISIBLE) && !(actor->spr.flags & kHitagRespawn))
@ -5607,7 +5607,7 @@ static void actCheckProximity()
proxyDist = 512;
}
if (CheckProximity(dudeactor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), proxyDist))
if (CheckProximity(dudeactor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), proxyDist))
{
switch (actor->spr.type)
{
@ -5655,7 +5655,7 @@ static void actCheckThings()
if (actor->spr.flags & 32) continue;
if (!actor->hasX()) continue;
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
XSECTOR* pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (pXSector && pXSector->panVel && (pXSector->panAlways || pXSector->state || pXSector->busy))
@ -5691,7 +5691,7 @@ static void actCheckThings()
actAirDrag(actor, 128);
if (((actor->GetIndex() >> 8) & 15) == (gFrameCount & 15) && (actor->spr.flags & 2)) actor->spr.flags |= 4;
if ((actor->spr.flags & 4) || actor->vel.X || actor->vel.Y || actor->vel.Z || actor->spr.sector()->velFloor || actor->spr.sector()->velCeil)
if ((actor->spr.flags & 4) || actor->vel.X || actor->vel.Y || actor->vel.Z || actor->sector()->velFloor || actor->sector()->velCeil)
{
Collision hit = MoveThing(actor);
if (hit.type)
@ -5726,7 +5726,7 @@ static void actCheckThings()
case kThingPodGreenBall:
if (hit.type == kHitSector)
{
actRadiusDamage(actor->GetOwner(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), 200, 1, 20, kDamageExplode, 6, 0);
actRadiusDamage(actor->GetOwner(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), 200, 1, 20, kDamageExplode, 6, 0);
evPostActor(actor, 0, kCallbackFXPodBloodSplat);
}
else if (hit.type == kHitSprite)
@ -5789,7 +5789,7 @@ static void actCheckExplosion()
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = actor->spr.pos.Z;
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
int radius = pExplodeInfo->radius;
#ifdef NOONE_EXTENSIONS
@ -5954,7 +5954,7 @@ static void actCheckTraps()
int dy = MulScale(t, Sin(actor->spr.ang), 30);
for (int i = 0; i < 2; i++)
{
auto pFX = gFX.fxSpawnActor(FX_32, actor->spr.sector(), x, y, z, 0);
auto pFX = gFX.fxSpawnActor(FX_32, actor->sector(), x, y, z, 0);
if (pFX)
{
pFX->vel.X = dx + Random2(0x8888);
@ -6036,7 +6036,7 @@ static void actCheckDudes()
if (actor2->IsPlayerActor() && (unsigned int)actor2->xspr.health > 0)
{
if (CheckProximity(actor2, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), 128))
if (CheckProximity(actor2, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), 128))
trTriggerSprite(actor, kCmdSpriteProximity);
}
}
@ -6089,7 +6089,7 @@ static void actCheckDudes()
{
if (actor->spr.flags & 32 || !actor->hasX()) continue;
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
viewBackupSpriteLoc(actor);
XSECTOR* pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
@ -6118,7 +6118,7 @@ static void actCheckDudes()
if (pXSector && pXSector->Underwater) actAirDrag(actor, 5376);
else actAirDrag(actor, 128);
if ((actor->spr.flags & 4) || actor->vel.X || actor->vel.Y || actor->vel.Z || actor->spr.sector()->velFloor || actor->spr.sector()->velCeil)
if ((actor->spr.flags & 4) || actor->vel.X || actor->vel.Y || actor->vel.Z || actor->sector()->velFloor || actor->sector()->velCeil)
MoveDude(actor);
}
}
@ -6218,7 +6218,7 @@ DBloodActor* actSpawnSprite(sectortype* pSector, int x, int y, int z, int nStat,
DBloodActor* actSpawnSprite(DBloodActor* source, int nStat)
{
DBloodActor* actor = InsertSprite(source->spr.sector(), nStat);
DBloodActor* actor = InsertSprite(source->sector(), nStat);
actor->spr.pos.X = source->spr.pos.X;
actor->spr.pos.Y = source->spr.pos.Y;
@ -6416,7 +6416,7 @@ DBloodActor* actFireThing(DBloodActor* actor, int a2, int a3, int a4, int thingT
x = gHitInfo.hitpos.X - MulScale(actor->spr.clipdist << 1, Cos(actor->spr.ang), 28);
y = gHitInfo.hitpos.Y - MulScale(actor->spr.clipdist << 1, Sin(actor->spr.ang), 28);
}
auto fired = actSpawnThing(actor->spr.sector(), x, y, z, thingType);
auto fired = actSpawnThing(actor->sector(), x, y, z, thingType);
fired->SetOwner(actor);
fired->spr.ang = actor->spr.ang;
fired->vel.X = MulScale(a6, Cos(fired->spr.ang), 30);
@ -6539,7 +6539,7 @@ DBloodActor* actFireMissile(DBloodActor* actor, int a2, int a3, int a4, int a5,
y = gHitInfo.hitpos.Y - MulScale(pMissileInfo->clipDist << 1, Sin(actor->spr.ang), 28);
}
}
auto spawned = actSpawnSprite(actor->spr.sector(), x, y, z, 5, 1);
auto spawned = actSpawnSprite(actor->sector(), x, y, z, 5, 1);
spawned->spr.cstat2 |= CSTAT2_SPRITE_MAPPED;
spawned->spr.type = nType;
@ -6941,7 +6941,7 @@ void actFireVector(DBloodActor* shooter, int a2, int a3, int a4, int a5, int a6,
void FireballSeqCallback(int, DBloodActor* actor)
{
auto pFX = gFX.fxSpawnActor(FX_11, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_11, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X;
@ -6952,7 +6952,7 @@ void FireballSeqCallback(int, DBloodActor* actor)
void NapalmSeqCallback(int, DBloodActor* actor)
{
auto pFX = gFX.fxSpawnActor(FX_12, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_12, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X;
@ -6963,7 +6963,7 @@ void NapalmSeqCallback(int, DBloodActor* actor)
void Fx32Callback(int, DBloodActor* actor)
{
auto pFX = gFX.fxSpawnActor(FX_32, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_32, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X;
@ -6974,7 +6974,7 @@ void Fx32Callback(int, DBloodActor* actor)
void Fx33Callback(int, DBloodActor* actor)
{
auto pFX = gFX.fxSpawnActor(FX_33, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_33, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X;

18
source/games/blood/src/ai.cpp
View file

@ -144,7 +144,7 @@ bool CanMove(DBloodActor* actor, DBloodActor* target, int nAngle, int nRange)
}
x += MulScale(nRange, Cos(nAngle), 30);
y += MulScale(nRange, Sin(nAngle), 30);
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
assert(pSector);
if (!FindSector(x, y, z, &pSector))
return false;
@ -570,7 +570,7 @@ void aiActivateDude(DBloodActor* actor)
case kDudeGillBeast:
{
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
XSECTOR* pXSector = actor->spr.sector()->hasX()? &actor->spr.sector()->xs() : nullptr;
XSECTOR* pXSector = actor->sector()->hasX()? &actor->sector()->xs() : nullptr;
pDudeExtraE->thinkTime = 0;
pDudeExtraE->active = 1;
@ -1405,7 +1405,7 @@ void RecoilDude(DBloodActor* actor)
aiNewState(actor, &eelRecoil);
break;
case kDudeGillBeast: {
XSECTOR* pXSector = actor->spr.sector()->hasX() ? &actor->spr.sector()->xs() : nullptr;
XSECTOR* pXSector = actor->sector()->hasX() ? &actor->sector()->xs() : nullptr;
aiPlay3DSound(actor, 1702, AI_SFX_PRIORITY_2, -1);
if (pXSector && pXSector->Underwater)
@ -1511,13 +1511,13 @@ void aiThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
@ -1557,13 +1557,13 @@ void aiLookForTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -1582,7 +1582,7 @@ void aiLookForTarget(DBloodActor* actor)
if (actor->xspr.state)
{
const bool newSectCheckMethod = !cl_bloodvanillaenemies && !VanillaMode(); // use new sector checking logic
GetClosestSpriteSectors(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, 400, nullptr, newSectCheckMethod);
GetClosestSpriteSectors(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, 400, nullptr, newSectCheckMethod);
BloodStatIterator it(kStatDude);
while (DBloodActor* actor2 = it.Next())
@ -1684,7 +1684,7 @@ void aiInit(void)
void aiInitSprite(DBloodActor* actor)
{
XSECTOR* pXSector = actor->spr.sector()->hasX() ? &actor->spr.sector()->xs() : nullptr;
XSECTOR* pXSector = actor->sector()->hasX() ? &actor->sector()->xs() : nullptr;
DUDEEXTRA* pDudeExtra = &actor->dudeExtra;
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;

12
source/games/blood/src/aibat.cpp
View file

@ -101,13 +101,13 @@ static void batThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -174,7 +174,7 @@ static void batThinkPonder(DBloodActor* actor)
int height2 = (getDudeInfo(pTarget->spr.type)->eyeHeight * pTarget->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z, pTarget->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z, pTarget->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < 0x3000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -281,12 +281,12 @@ static void batThinkChase(DBloodActor* actor)
int height2 = (pDudeInfo->eyeHeight * pTarget->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z, pTarget->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z, pTarget->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
int floorZ = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (height2 - height < 0x2000 && nDist < 0x200 && abs(nDeltaAngle) < 85)
aiNewState(actor, &batBite);
else if ((height2 - height > 0x5000 || floorZ - bottom > 0x5000) && nDist < 0x1400 && nDist > 0x800 && abs(nDeltaAngle) < 85)
@ -411,7 +411,7 @@ void batMoveToCeil(DBloodActor* actor)
aiNewState(actor, &batIdle);
}
else
aiSetTarget(actor, x, y, actor->spr.sector()->ceilingz);
aiSetTarget(actor, x, y, actor->sector()->ceilingz);
}
END_BLD_NS

12
source/games/blood/src/aibeast.cpp
View file

@ -86,7 +86,7 @@ void StompSeqCallback(int, DBloodActor* actor)
int y = actor->spr.pos.Y;
int z = actor->spr.pos.Z;
int vc = 400;
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
int v1c = 5 + 2 * gGameOptions.nDifficulty;
int v10 = 25 + 30 * gGameOptions.nDifficulty;
const bool newSectCheckMethod = !cl_bloodvanillaenemies && !VanillaMode(); // use new sector checking logic
@ -176,7 +176,7 @@ static void beastThinkGoto(DBloodActor* actor)
{
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
@ -198,7 +198,7 @@ static void beastThinkChase(DBloodActor* actor)
{
if (actor->GetTarget() == nullptr)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (pXSector && pXSector->Underwater)
@ -216,7 +216,7 @@ static void beastThinkChase(DBloodActor* actor)
int dy = target->spr.pos.Y - actor->spr.pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (target->xspr.health == 0)
@ -240,7 +240,7 @@ static void beastThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -372,7 +372,7 @@ static void beastThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + actor->spr.pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

10
source/games/blood/src/aiboneel.cpp
View file

@ -113,13 +113,13 @@ static void eelThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -188,7 +188,7 @@ static void eelThinkPonder(DBloodActor* actor)
int height2 = (getDudeInfo(target->spr.type)->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < -0x2000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -295,7 +295,7 @@ static void eelThinkChase(DBloodActor* actor)
GetActorExtents(actor, &top, &bottom);
int top2, bottom2;
GetActorExtents(target, &top2, &bottom2);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -415,7 +415,7 @@ void eelMoveToCeil(DBloodActor* actor)
aiNewState(actor, &eelIdle);
}
else
aiSetTarget(actor, x, y, actor->spr.sector()->ceilingz);
aiSetTarget(actor, x, y, actor->sector()->ceilingz);
}
END_BLD_NS

2
source/games/blood/src/aiburn.cpp
View file

@ -195,7 +195,7 @@ static void burnThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

8
source/games/blood/src/aicaleb.cpp
View file

@ -91,7 +91,7 @@ static void calebThinkGoto(DBloodActor* actor)
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
@ -111,7 +111,7 @@ static void calebThinkGoto(DBloodActor* actor)
static void calebThinkChase(DBloodActor* actor)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (actor->GetTarget() == nullptr)
@ -153,7 +153,7 @@ static void calebThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -253,7 +253,7 @@ static void calebThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + actor->spr.pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

10
source/games/blood/src/aicerber.cpp
View file

@ -123,7 +123,7 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
if (abs(nDeltaAngle) <= tt1.at8)
{
int tz1 = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->sector(), x2, y2, z2, actor2->sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -202,7 +202,7 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
DUDEINFO* pDudeInfo2 = getDudeInfo(actor2->spr.type);
int height1 = (pDudeInfo2->aimHeight * actor2->spr.yrepeat) << 2;
int tz1 = (z2 - height1) - z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->sector(), x2, y2, z2, actor2->sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -262,13 +262,13 @@ static void cerberusThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -374,7 +374,7 @@ static void cerberusThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

10
source/games/blood/src/aicult.cpp
View file

@ -274,7 +274,7 @@ static void cultThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -282,7 +282,7 @@ static void cultThinkChase(DBloodActor* actor)
actor->dudeSlope = nDist == 0 ? 0 : DivScale(target->spr.pos.Z - actor->spr.pos.Z, nDist, 10);
switch (actor->spr.type) {
case kDudeCultistTommy:
if (nDist < 0x1e00 && nDist > 0xe00 && abs(nDeltaAngle) < 85 && !TargetNearExplosion(target->spr.sector())
if (nDist < 0x1e00 && nDist > 0xe00 && abs(nDeltaAngle) < 85 && !TargetNearExplosion(target->sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty > 2 && target->IsPlayerActor() && gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
@ -350,7 +350,7 @@ static void cultThinkChase(DBloodActor* actor)
}
break;
case kDudeCultistShotgun:
if (nDist < 0x2c00 && nDist > 0x1400 && !TargetNearExplosion(target->spr.sector())
if (nDist < 0x2c00 && nDist > 0x1400 && !TargetNearExplosion(target->sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty >= 2 && target->IsPlayerActor() && !gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
@ -418,7 +418,7 @@ static void cultThinkChase(DBloodActor* actor)
}
break;
case kDudeCultistTesla:
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(target->spr.sector())
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(target->sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty > 2 && target->IsPlayerActor() && gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
@ -530,7 +530,7 @@ static void cultThinkChase(DBloodActor* actor)
}
break;
case kDudeCultistBeast:
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(target->spr.sector())
if (nDist < 0x1e00 && nDist > 0xe00 && !TargetNearExplosion(target->sector())
&& (target->spr.flags & 2) && gGameOptions.nDifficulty > 2 && target->IsPlayerActor() && gPlayer[target->spr.type - kDudePlayer1].isRunning
&& Chance(0x8000))
{

10
source/games/blood/src/aigarg.cpp
View file

@ -152,7 +152,7 @@ void BlastSSeqCallback(int, DBloodActor* actor)
if (abs(nDeltaAngle) <= tt.at8)
{
int tz1 = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->sector(), x2, y2, z2, actor2->sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -222,13 +222,13 @@ static void gargThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -364,12 +364,12 @@ static void gargThinkChase(DBloodActor* actor)
int height2 = (pDudeInfo->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
int floorZ = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
switch (actor->spr.type)
{
case kDudeGargoyleFlesh:

10
source/games/blood/src/aighost.cpp
View file

@ -138,7 +138,7 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
if (abs(nDeltaAngle) <= tt.at8)
{
int tz1 = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->sector(), x2, y2, z2, actor2->sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -202,13 +202,13 @@ static void ghostThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -343,12 +343,12 @@ static void ghostThinkChase(DBloodActor* actor)
int height2 = (pDudeInfo->eyeHeight * target->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
int floorZ = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
switch (actor->spr.type) {
case kDudePhantasm:
if (nDist < 0x2000 && nDist > 0x1000 && abs(nDeltaAngle) < 85) {

8
source/games/blood/src/aigilbst.cpp
View file

@ -82,7 +82,7 @@ static void gillThinkGoto(DBloodActor* actor)
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = actor->xspr.TargetPos.X - actor->spr.pos.X;
@ -102,7 +102,7 @@ static void gillThinkGoto(DBloodActor* actor)
static void gillThinkChase(DBloodActor* actor)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
if (actor->GetTarget() == nullptr)
@ -141,7 +141,7 @@ static void gillThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -240,7 +240,7 @@ static void gillThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + actor->spr.pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

2
source/games/blood/src/aihand.cpp
View file

@ -106,7 +106,7 @@ static void handThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

2
source/games/blood/src/aihound.cpp
View file

@ -123,7 +123,7 @@ static void houndThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

2
source/games/blood/src/aiinnoc.cpp
View file

@ -90,7 +90,7 @@ static void innocThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -122,7 +122,7 @@ void sub_70284(int, DBloodActor* actor)
nDist = 75;
break;
}
actRadiusDamage(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
actRadiusDamage(actor, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
}
static void aiPodSearch(DBloodActor* actor)
@ -203,7 +203,7 @@ static void aiPodChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

2
source/games/blood/src/airat.cpp
View file

@ -101,7 +101,7 @@ static void ratThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

2
source/games/blood/src/aispid.cpp
View file

@ -210,7 +210,7 @@ static void spidThinkChase(DBloodActor* actor)
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector())) {
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector())) {
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

10
source/games/blood/src/aitchern.cpp
View file

@ -107,7 +107,7 @@ void sub_71BD4(int, DBloodActor* actor)
if (abs(nDeltaAngle) <= tt.at8)
{
int tz1 = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->sector(), x2, y2, z2, actor2->sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -179,7 +179,7 @@ void sub_720AC(int, DBloodActor* actor)
if (abs(nDeltaAngle) <= tt.at8)
{
int tz1 = actor2->spr.pos.Z - actor->spr.pos.Z;
if (cansee(x, y, z, actor->spr.sector(), x2, y2, z2, actor2->spr.sector()))
if (cansee(x, y, z, actor->sector(), x2, y2, z2, actor2->sector()))
{
nClosest = nDist2;
aim.dx = bcos(nAngle);
@ -229,13 +229,13 @@ static void sub_725A4(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -307,7 +307,7 @@ static void sub_72934(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

26
source/games/blood/src/aiunicult.cpp
View file

@ -519,8 +519,8 @@ static void unicultThinkChase(DBloodActor* actor)
int losAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int eyeAboveZ = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (dist > pDudeInfo->seeDist || !cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(),
actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - eyeAboveZ, actor->spr.sector()))
if (dist > pDudeInfo->seeDist || !cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(),
actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - eyeAboveZ, actor->sector()))
{
if (spriteIsUnderwater(actor, false)) aiGenDudeNewState(actor, &genDudeSearchW);
else aiGenDudeNewState(actor, &genDudeSearchL);
@ -580,8 +580,8 @@ static void unicultThinkChase(DBloodActor* actor)
}
int ldist = aiFightGetTargetDist(target, pDudeInfo, actLeech);
if (ldist > 3 || !cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(),
actLeech->spr.pos.X, actLeech->spr.pos.Y, actLeech->spr.pos.Z, actLeech->spr.sector()) || actLeech->GetTarget() == nullptr)
if (ldist > 3 || !cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(),
actLeech->spr.pos.X, actLeech->spr.pos.Y, actLeech->spr.pos.Z, actLeech->sector()) || actLeech->GetTarget() == nullptr)
{
aiGenDudeNewState(actor, &genDudeThrow2);
genDudeThrow2.nextState = &genDudeDodgeShortL;
@ -726,7 +726,7 @@ static void unicultThinkChase(DBloodActor* actor)
{
int nType = curWeapon - kTrapExploder;
const EXPLOSION* pExpl = &explodeInfo[nType];
if (CheckProximity(actor, target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), pExpl->radius >> 1))
if (CheckProximity(actor, target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), pExpl->radius >> 1))
{
actor->vel.X = actor->vel.Y = actor->vel.Z = 0;
if (doExplosion(actor, nType) && actor->xspr.health > 0)
@ -1348,7 +1348,7 @@ bool playGenDudeSound(DBloodActor* actor, int mode)
bool spriteIsUnderwater(DBloodActor* actor, bool oldWay)
{
return (IsUnderwaterSector(actor->spr.sector())
return (IsUnderwaterSector(actor->sector())
|| (oldWay && (actor->xspr.medium == kMediumWater || actor->xspr.medium == kMediumGoo)));
}
@ -1400,7 +1400,7 @@ void removeLeech(DBloodActor* actLeech, bool delSprite)
{
if (actLeech != nullptr)
{
auto effectactor = gFX.fxSpawnActor((FX_ID)52, actLeech->spr.sector(), actLeech->spr.pos.X, actLeech->spr.pos.Y, actLeech->spr.pos.Z, actLeech->spr.ang);
auto effectactor = gFX.fxSpawnActor((FX_ID)52, actLeech->sector(), actLeech->spr.pos.X, actLeech->spr.pos.Y, actLeech->spr.pos.Z, actLeech->spr.ang);
if (effectactor != nullptr)
{
effectactor->spr.cstat = CSTAT_SPRITE_ALIGNMENT_FACING;
@ -1791,7 +1791,7 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
int x = actTarget->spr.pos.X; int y = actTarget->spr.pos.Y; int z = actTarget->spr.pos.Z;
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, actTarget->spr.sector()))
if (nDist != 0 && cansee(actor->spr.pos.X, actor->spr.pos.Y, top, actor->sector(), x, y, z, actTarget->sector()))
{
int t = DivScale(nDist, 0x1aaaaa, 12);
x += (actTarget->vel.X * t) >> 12;
@ -1831,7 +1831,7 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
bool doExplosion(DBloodActor* actor, int nType)
{
auto actExplosion = actSpawnSprite(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, kStatExplosion, true);
auto actExplosion = actSpawnSprite(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, kStatExplosion, true);
if (!actExplosion->hasX())
return false;
@ -2481,10 +2481,10 @@ bool genDudePrepare(DBloodActor* actor, int propId)
// make sure dudes aren't in the floor or ceiling
int zTop, zBot; GetActorExtents(actor, &zTop, &zBot);
if (!(actor->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY))
actor->spr.pos.Z += ClipLow(actor->spr.sector()->ceilingz - zTop, 0);
if (!(actor->spr.sector()->floorstat & CSTAT_SECTOR_SKY))
actor->spr.pos.Z += ClipHigh(actor->spr.sector()->floorz - zBot, 0);
if (!(actor->sector()->ceilingstat & CSTAT_SECTOR_SKY))
actor->spr.pos.Z += ClipLow(actor->sector()->ceilingz - zTop, 0);
if (!(actor->sector()->floorstat & CSTAT_SECTOR_SKY))
actor->spr.pos.Z += ClipHigh(actor->sector()->floorz - zBot, 0);
actor->spr.clipdist = ClipRange((actor->spr.xrepeat + actor->spr.yrepeat) >> 1, 4, 120);
if (propId) break;

8
source/games/blood/src/aizomba.cpp
View file

@ -135,7 +135,7 @@ static void zombaThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -181,7 +181,7 @@ static void zombaThinkPonder(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -215,13 +215,13 @@ static void myThinkTarget(DBloodActor* actor)
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.sector();
auto pSector = pPlayer->actor->sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->spr.sector()))
if (!cansee(x, y, z, pSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - ((pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2), actor->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)

2
source/games/blood/src/aizombf.cpp
View file

@ -130,7 +130,7 @@ static void zombfThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - actor->spr.ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * actor->spr.yrepeat) << 2;
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->spr.sector()))
if (cansee(target->spr.pos.X, target->spr.pos.Y, target->spr.pos.Z, target->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - height, actor->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{

44
source/games/blood/src/callback.cpp
View file

@ -50,7 +50,7 @@ void fxFlameLick(DBloodActor* actor, sectortype*) // 0
int x = actor->spr.pos.X + dx;
int y = actor->spr.pos.Y + dy;
int z = bottom - Random(bottom - top);
auto pFX = gFX.fxSpawnActor(FX_32, actor->spr.sector(), x, y, z, 0);
auto pFX = gFX.fxSpawnActor(FX_32, actor->sector(), x, y, z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(-dx);
@ -125,7 +125,7 @@ void FlareBurst(DBloodActor* actor, sectortype*) // 2
void fxFlareSpark(DBloodActor* actor, sectortype*) // 3
{
if (!actor) return;
auto pFX = gFX.fxSpawnActor(FX_28, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_28, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x1aaaa);
@ -144,7 +144,7 @@ void fxFlareSpark(DBloodActor* actor, sectortype*) // 3
void fxFlareSparkLite(DBloodActor* actor, sectortype*) // 4
{
if (!actor) return;
auto pFX = gFX.fxSpawnActor(FX_28, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_28, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x1aaaa);
@ -166,7 +166,7 @@ void fxZombieBloodSpurt(DBloodActor* actor, sectortype*) // 5
assert(actor->hasX());
int top, bottom;
GetActorExtents(actor, &top, &bottom);
auto pFX = gFX.fxSpawnActor(FX_27, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, top, 0);
auto pFX = gFX.fxSpawnActor(FX_27, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, top, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x11111);
@ -195,7 +195,7 @@ void fxZombieBloodSpurt(DBloodActor* actor, sectortype*) // 5
void fxBloodSpurt(DBloodActor* actor, sectortype*) // 6
{
if (!actor) return;
auto pFX = gFX.fxSpawnActor(FX_27, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_27, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->spr.ang = 0;
@ -215,7 +215,7 @@ void fxBloodSpurt(DBloodActor* actor, sectortype*) // 6
void fxArcSpark(DBloodActor* actor, sectortype*) // 7
{
if (!actor) return;
auto pFX = gFX.fxSpawnActor(FX_15, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_15, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x10000);
@ -240,7 +240,7 @@ void fxDynPuff(DBloodActor* actor, sectortype*) // 8
int x = actor->spr.pos.X + MulScale(nDist, Cos(actor->spr.ang - 512), 30);
int y = actor->spr.pos.Y + MulScale(nDist, Sin(actor->spr.ang - 512), 30);
int z = actor->spr.pos.Z;
auto pFX = gFX.fxSpawnActor(FX_7, actor->spr.sector(), x, y, z, 0);
auto pFX = gFX.fxSpawnActor(FX_7, actor->sector(), x, y, z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X;
@ -334,7 +334,7 @@ void Respawn(DBloodActor* actor, sectortype*) // 9
actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
}
gFX.fxSpawnActor(FX_29, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
gFX.fxSpawnActor(FX_29, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
sfxPlay3DSound(actor, 350, -1, 0);
break;
}
@ -364,7 +364,7 @@ void PlayerBubble(DBloodActor* actor, sectortype*) // 10
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)), actor->spr.sector(), x, y, z, 0);
auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23 + Random(3)), actor->sector(), x, y, z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x1aaaa);
@ -394,7 +394,7 @@ void EnemyBubble(DBloodActor* actor, sectortype*) // 11
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)), actor->spr.sector(), x, y, z, 0);
auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23 + Random(3)), actor->sector(), x, y, z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x1aaaa);
@ -466,7 +466,7 @@ void fxBloodBits(DBloodActor* actor, sectortype*) // 14
int nDist = Random(16) << 4;
int x = actor->spr.pos.X + MulScale(nDist, Cos(nAngle), 28);
int y = actor->spr.pos.Y + MulScale(nDist, Sin(nAngle), 28);
gFX.fxSpawnActor(FX_48, actor->spr.sector(), x, y, actor->spr.pos.Z, 0);
gFX.fxSpawnActor(FX_48, actor->sector(), x, y, actor->spr.pos.Z, 0);
if (actor->spr.ang == 1024)
{
int nChannel = 28 + (actor->GetIndex() & 2); // this is a little stupid...
@ -474,7 +474,7 @@ void fxBloodBits(DBloodActor* actor, sectortype*) // 14
}
if (Chance(0x5000))
{
auto pFX = gFX.fxSpawnActor(FX_36, actor->spr.sector(), x, y, floorZ - 64, 0);
auto pFX = gFX.fxSpawnActor(FX_36, actor->sector(), x, y, floorZ - 64, 0);
if (pFX)
pFX->spr.ang = nAngle;
}
@ -491,7 +491,7 @@ void fxBloodBits(DBloodActor* actor, sectortype*) // 14
void fxTeslaAlt(DBloodActor* actor, sectortype*) // 15
{
if (!actor) return;
auto pFX = gFX.fxSpawnActor(FX_49, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto pFX = gFX.fxSpawnActor(FX_49, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->vel.X = actor->vel.X + Random2(0x1aaaa);
@ -521,13 +521,13 @@ void fxBouncingSleeve(DBloodActor* actor, sectortype*) // 16
int top, bottom; GetActorExtents(actor, &top, &bottom);
actor->spr.pos.Z += floorZ - bottom;
int zv = actor->vel.Z - actor->spr.sector()->velFloor;
int zv = actor->vel.Z - actor->sector()->velFloor;
if (actor->vel.Z == 0) sleeveStopBouncing(actor);
else if (zv > 0) {
actFloorBounceVector((int*)&actor->vel.X, (int*)&actor->vel.Y, &zv, actor->spr.sector(), 0x9000);
actFloorBounceVector((int*)&actor->vel.X, (int*)&actor->vel.Y, &zv, actor->sector(), 0x9000);
actor->vel.Z = zv;
if (actor->spr.sector()->velFloor == 0 && abs(actor->vel.Z) < 0x20000) {
if (actor->sector()->velFloor == 0 && abs(actor->vel.Z) < 0x20000) {
sleeveStopBouncing(actor);
return;
}
@ -620,9 +620,9 @@ void fxPodBloodSpray(DBloodActor* actor, sectortype*) // 18
if (!actor) return;
DBloodActor* pFX;
if (actor->spr.type == 53)
pFX = gFX.fxSpawnActor(FX_53, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
pFX = gFX.fxSpawnActor(FX_53, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
else
pFX = gFX.fxSpawnActor(FX_54, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
pFX = gFX.fxSpawnActor(FX_54, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (pFX)
{
pFX->spr.ang = 0;
@ -663,13 +663,13 @@ void fxPodBloodSplat(DBloodActor* actor, sectortype*) // 19
if (actor->spr.type == 53 || actor->spr.type == kThingPodGreenBall)
{
if (Chance(0x500) || actor->spr.type == kThingPodGreenBall)
pFX = gFX.fxSpawnActor(FX_55, actor->spr.sector(), x, y, floorZ - 64, 0);
pFX = gFX.fxSpawnActor(FX_55, actor->sector(), x, y, floorZ - 64, 0);
if (pFX)
pFX->spr.ang = nAngle;
}
else
{
pFX = gFX.fxSpawnActor(FX_32, actor->spr.sector(), x, y, floorZ - 64, 0);
pFX = gFX.fxSpawnActor(FX_32, actor->sector(), x, y, floorZ - 64, 0);
if (pFX)
pFX->spr.ang = nAngle;
}
@ -710,9 +710,9 @@ void sub_76A08(DBloodActor* actor, DBloodActor* actor2, PLAYER* pPlayer) // ???
GetActorExtents(actor, &top, &bottom);
actor->spr.pos.X = actor2->spr.pos.X;
actor->spr.pos.Y = actor2->spr.pos.Y;
actor->spr.pos.Z = actor2->spr.sector()->floorz - (bottom - actor->spr.pos.Z);
actor->spr.pos.Z = actor2->sector()->floorz - (bottom - actor->spr.pos.Z);
actor->spr.ang = actor2->spr.ang;
ChangeActorSect(actor, actor2->spr.sector());
ChangeActorSect(actor, actor2->sector());
sfxPlay3DSound(actor2, 201, -1, 0);
actor->vel.X = actor->vel.Y = actor->vel.Z = 0;
viewBackupSpriteLoc(actor);

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

@ -203,7 +203,7 @@ void CFX::fxProcess(void)
while (auto actor = it.Next())
{
viewBackupSpriteLoc(actor);
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
assert(pSector);
assert(actor->spr.type < kFXMax);
FXDATA* pFXData = &gFXData[actor->spr.type];
@ -212,7 +212,7 @@ void CFX::fxProcess(void)
actor->spr.pos.Y += actor->vel.Y >> 12;
actor->spr.pos.Z += actor->vel.Z >> 8;
// Weird...
if (actor->vel.X || (actor->vel.Y && actor->spr.pos.Z >= actor->spr.sector()->floorz))
if (actor->vel.X || (actor->vel.Y && actor->spr.pos.Z >= actor->sector()->floorz))
{
updatesector(actor->spr.pos.X, actor->spr.pos.Y, &pSector);
if (pSector == nullptr)
@ -220,7 +220,7 @@ void CFX::fxProcess(void)
remove(actor);
continue;
}
if (getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) <= actor->spr.pos.Z)
if (getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y) <= actor->spr.pos.Z)
{
if (pFXData->funcID < 0 || pFXData->funcID >= kCallbackMax)
{
@ -230,7 +230,7 @@ void CFX::fxProcess(void)
gCallback[pFXData->funcID](actor, nullptr);
continue;
}
if (pSector != actor->spr.sector())
if (pSector != actor->sector())
{
assert(pSector);
ChangeActorSect(actor, pSector);
@ -270,12 +270,12 @@ void fxSpawnBlood(DBloodActor* actor, int)
{
if (!actor->insector())
return;
auto pSector = actor->spr.sector();
auto pSector = actor->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, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
auto bloodactor = gFX.fxSpawnActor(FX_27, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (bloodactor)
{
bloodactor->spr.ang = 1024;
@ -296,16 +296,16 @@ void fxSpawnPodStuff(DBloodActor* actor, int)
{
if (!actor->insector())
return;
auto pSector = actor->spr.sector();
auto pSector = actor->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 (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);
spawnactor = gFX.fxSpawnActor(FX_53, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
else
spawnactor = gFX.fxSpawnActor(FX_54, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
spawnactor = gFX.fxSpawnActor(FX_54, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
if (spawnactor)
{
spawnactor->spr.ang = 1024;
@ -328,7 +328,7 @@ void fxSpawnEjectingBrass(DBloodActor* actor, int z, int a3, int a4)
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);
auto pBrass = gFX.fxSpawnActor((FX_ID)(FX_37 + Random(3)), actor->sector(), x, y, z, 0);
if (pBrass)
{
if (!VanillaMode())
@ -353,7 +353,7 @@ void fxSpawnEjectingShell(DBloodActor* actor, int z, int a3, int a4)
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);
auto pShell = gFX.fxSpawnActor((FX_ID)(FX_40 + Random(3)), actor->sector(), x, y, z, 0);
if (pShell)
{
if (!VanillaMode())

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

@ -136,11 +136,11 @@ bool CheckProximity(DBloodActor* actor, int nX, int nY, int nZ, sectortype* pSec
int bottom, top;
GetActorExtents(actor, &top, &bottom);
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), nX, nY, nZ, pSector))
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), nX, nY, nZ, pSector))
return 1;
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, bottom, actor->spr.sector(), nX, nY, nZ, pSector))
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, bottom, actor->sector(), nX, nY, nZ, pSector))
return 1;
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, top, actor->spr.sector(), nX, nY, nZ, pSector))
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, top, actor->sector(), nX, nY, nZ, pSector))
return 1;
return 0;
}
@ -400,7 +400,7 @@ int HitScan(DBloodActor* actor, int z, int dx, int dy, int dz, unsigned int nMas
{
hitscangoal.X = hitscangoal.Y = 0x1ffffff;
}
hitscan({ x, y, z }, actor->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, nMask);
hitscan({ x, y, z }, actor->sector(), { dx, dy, dz << 4 }, gHitInfo, nMask);
hitscangoal.X = hitscangoal.Y = 0x1ffffff;
actor->spr.cstat = bakCstat;
@ -450,7 +450,7 @@ int VectorScan(DBloodActor* actor, int nOffset, int nZOffset, int dx, int dy, in
hitscangoal.X = hitscangoal.Y = 0x1fffffff;
}
vec3_t pos = { x1, y1, z1 };
hitscan(pos, actor->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
hitscan(pos, actor->sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
hitscangoal.X = hitscangoal.Y = 0x1ffffff;
actor->spr.cstat = bakCstat;
@ -499,7 +499,7 @@ int VectorScan(DBloodActor* actor, int nOffset, int nZOffset, int dx, int dy, in
other->spr.cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
gHitInfo.clearObj();
pos = gHitInfo.hitpos; // must make a copy!
hitscan(pos, other->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
hitscan(pos, other->sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
other->spr.cstat = bakCstat;
continue;
}
@ -581,7 +581,7 @@ int VectorScan(DBloodActor* actor, int nOffset, int nZOffset, int dx, int dy, in
y1 = gHitInfo.hitpos.Y + link->spr.pos.Y - upper->spr.pos.Y;
z1 = gHitInfo.hitpos.Z + link->spr.pos.Z - upper->spr.pos.Z;
pos = { x1, y1, z1 };
hitscan(pos, link->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
hitscan(pos, link->sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
continue;
}
@ -595,7 +595,7 @@ int VectorScan(DBloodActor* actor, int nOffset, int nZOffset, int dx, int dy, in
y1 = gHitInfo.hitpos.Y + link->spr.pos.Y - lower->spr.pos.Y;
z1 = gHitInfo.hitpos.Z + link->spr.pos.Z - lower->spr.pos.Z;
pos = { x1, y1, z1 };
hitscan(pos, link->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
hitscan(pos, link->sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
continue;
}
}
@ -618,7 +618,7 @@ void GetZRange(DBloodActor* actor, int* ceilZ, Collision* ceilColl, int* floorZ,
auto bakCstat = actor->spr.cstat;
int32_t nTemp1;
actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
getzrange(actor->spr.pos, actor->spr.sector(), (int32_t*)ceilZ, *ceilColl, (int32_t*)floorZ, *floorColl, nDist, nMask);
getzrange(actor->spr.pos, actor->sector(), (int32_t*)ceilZ, *ceilColl, (int32_t*)floorZ, *floorColl, nDist, nMask);
if (floorColl->type == kHitSector)
{
auto pSector = floorColl->hitSector;
@ -634,7 +634,7 @@ void GetZRange(DBloodActor* actor, int* ceilZ, Collision* ceilColl, int* floorZ,
{
auto linkOwner = linkActor->GetOwner();
vec3_t lpos = actor->spr.pos + linkOwner->spr.pos - linkActor->spr.pos;
getzrange(lpos, linkOwner->spr.sector(), &nTemp1, scratch, (int32_t*)floorZ, *floorColl, nDist, nMask);
getzrange(lpos, linkOwner->sector(), &nTemp1, scratch, (int32_t*)floorZ, *floorColl, nDist, nMask);
*floorZ -= linkOwner->spr.pos.Z - linkActor->spr.pos.Z;
}
}
@ -648,7 +648,7 @@ void GetZRange(DBloodActor* actor, int* ceilZ, Collision* ceilColl, int* floorZ,
{
auto linkOwner = linkActor->GetOwner();
vec3_t lpos = actor->spr.pos + linkOwner->spr.pos - linkActor->spr.pos;
getzrange(lpos, linkOwner->spr.sector(), (int32_t*)ceilZ, *ceilColl, &nTemp1, scratch, nDist, nMask);
getzrange(lpos, linkOwner->sector(), (int32_t*)ceilZ, *ceilColl, &nTemp1, scratch, nDist, nMask);
*ceilZ -= linkOwner->spr.pos.Z - linkActor->spr.pos.Z;
}
}
@ -682,7 +682,7 @@ void GetZRangeAtXYZ(int x, int y, int z, sectortype* pSector, int* ceilZ, Collis
{
auto link = actor->GetOwner();
vec3_t newpos = lpos + link->spr.pos - actor->spr.pos;
getzrange(newpos, link->spr.sector(), &nTemp1, scratch, (int32_t*)floorZ, *floorColl, nDist, nMask);
getzrange(newpos, link->sector(), &nTemp1, scratch, (int32_t*)floorZ, *floorColl, nDist, nMask);
*floorZ -= link->spr.pos.Z - actor->spr.pos.Z;
}
}
@ -696,7 +696,7 @@ void GetZRangeAtXYZ(int x, int y, int z, sectortype* pSector, int* ceilZ, Collis
{
auto link = actor->GetOwner();
vec3_t newpos = lpos + link->spr.pos - actor->spr.pos;
getzrange(newpos, link->spr.sector(), (int32_t*)ceilZ, *ceilColl, &nTemp1, scratch, nDist, nMask);
getzrange(newpos, link->sector(), (int32_t*)ceilZ, *ceilColl, &nTemp1, scratch, nDist, nMask);
*ceilZ -= link->spr.pos.Z - actor->spr.pos.Z;
}
}

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

@ -271,7 +271,7 @@ int ChanceToCount(int a1, int a2)
void GibFX(DBloodActor* actor, GIBFX* pGFX, CGibPosition* pPos, CGibVelocity* pVel)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
if (adult_lockout && gGameOptions.nGameType == 0 && pGFX->fxId == FX_13)
return;
CGibPosition gPos(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z);
@ -353,7 +353,7 @@ void GibThing(DBloodActor* actor, GIBTHING* pGThing, CGibPosition* pPos, CGibVel
if (pGThing->chance == 65536 || Chance(pGThing->chance))
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
int top, bottom;
GetActorExtents(actor, &top, &bottom);
int x, y, z;

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

@ -135,8 +135,8 @@ void hudDraw(PLAYER* gView, sectortype* pSector, double bobx, double boby, doubl
}
int nShade = pSector->floorshade;
int nPalette = 0;
if (gView->actor->spr.sector()->hasX()) {
sectortype* pViewSect = gView->actor->spr.sector();
if (gView->actor->sector()->hasX()) {
sectortype* pViewSect = gView->actor->sector();
XSECTOR* pXSector = &pViewSect->xs();
if (pXSector->color)
nPalette = pViewSect->floorpal;

2
source/games/blood/src/mirrors.cpp
View file

@ -126,7 +126,7 @@ void InitMirrors(void)
if (link2 == nullptr)
continue;
auto sectj = link2->spr.sector();
auto sectj = link2->sector();
int j = sectnum(sectj);
if (sectj->ceilingpicnum != 504)
I_Error("Lower link sector %d doesn't have mirror picnum\n", j);

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

@ -714,8 +714,8 @@ void nnExtInitModernStuff(TArray<DBloodActor*>& actors)
// very quick fix for floor sprites with Touch trigger flag if their Z is equals sector floorz / ceilgz
if (actor->insector() && actor->xspr.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++;
if (actor->spr.pos.Z == actor->sector()->floorz) actor->spr.pos.Z--;
else if (actor->spr.pos.Z == actor->sector()->ceilingz) actor->spr.pos.Z++;
}
// make Proximity flag work not just for dudes and things...
@ -1129,10 +1129,10 @@ void nnExtProcessSuperSprites()
}
else if (windactor->insector())
{
sectortype* pSect = windactor->spr.sector();
sectortype* pSect = windactor->sector();
XSECTOR* pXSector = (pSect->hasX()) ? &pSect->xs() : nullptr;
if ((fWindAlways) || (pXSector && !pXSector->locked && (pXSector->windAlways || pXSector->busy)))
windGenDoVerticalWind(windactor->xspr.sysData2, windactor->spr.sector());
windGenDoVerticalWind(windactor->xspr.sysData2, windactor->sector());
}
}
@ -1151,7 +1151,7 @@ void nnExtProcessSuperSprites()
int x = pProx->spr.pos.X;
int y = pProx->spr.pos.Y;
int z = pProx->spr.pos.Z;
auto pSect = pProx->spr.sector();
auto pSect = pProx->sector();
if (!pProx->xspr.DudeLockout)
{
@ -1206,7 +1206,7 @@ void nnExtProcessSuperSprites()
int x = pSight->spr.pos.X;
int y = pSight->spr.pos.Y;
int z = pSight->spr.pos.Z;
auto pSightSect = pSight->spr.sector();
auto pSightSect = pSight->sector();
int ztop2, zbot2;
for (int a = connecthead; a >= 0; a = connectpoint2[a])
@ -1217,7 +1217,7 @@ void nnExtProcessSuperSprites()
auto plActor = pPlayer->actor;
GetActorExtents(plActor, &ztop2, &zbot2);
if (cansee(x, y, z, pSightSect, plActor->spr.pos.X, plActor->spr.pos.Y, ztop2, plActor->spr.sector()))
if (cansee(x, y, z, pSightSect, plActor->spr.pos.X, plActor->spr.pos.Y, ztop2, plActor->sector()))
{
if (pSight->xspr.Sight)
{
@ -1267,7 +1267,7 @@ void nnExtProcessSuperSprites()
continue;
}
XSECTOR* pXSector = (debrisactor->spr.sector()->hasX()) ? &debrisactor->spr.sector()->xs() : nullptr;
XSECTOR* pXSector = (debrisactor->sector()->hasX()) ? &debrisactor->sector()->xs() : nullptr;
viewBackupSpriteLoc(debrisactor);
bool uwater = false;
@ -1280,7 +1280,7 @@ void nnExtProcessSuperSprites()
if (pXSector != nullptr)
{
if ((uwater = pXSector->Underwater) != 0) airVel <<= 6;
if (pXSector->panVel != 0 && getflorzofslopeptr(debrisactor->spr.sector(), debrisactor->spr.pos.X, debrisactor->spr.pos.Y) <= bottom)
if (pXSector->panVel != 0 && getflorzofslopeptr(debrisactor->sector(), debrisactor->spr.pos.X, debrisactor->spr.pos.Y) <= bottom)
{
int angle = pXSector->panAngle; int speed = 0;
if (pXSector->panAlways || pXSector->state || pXSector->busy)
@ -1289,8 +1289,8 @@ void nnExtProcessSuperSprites()
if (!pXSector->panAlways && pXSector->busy)
speed = MulScale(speed, pXSector->busy, 16);
}
if (debrisactor->spr.sector()->floorstat & CSTAT_SECTOR_ALIGN)
angle = (angle + GetWallAngle(debrisactor->spr.sector()->firstWall()) + 512) & 2047;
if (debrisactor->sector()->floorstat & CSTAT_SECTOR_ALIGN)
angle = (angle + GetWallAngle(debrisactor->sector()->firstWall()) + 512) & 2047;
int dx = MulScale(speed, Cos(angle), 30);
int dy = MulScale(speed, Sin(angle), 30);
debrisactor->vel.X += dx;
@ -1322,7 +1322,7 @@ void nnExtProcessSuperSprites()
}
if (debrisactor->xspr.physAttr & kPhysGravity) debrisactor->xspr.physAttr |= kPhysFalling;
if ((debrisactor->xspr.physAttr & kPhysFalling) || debrisactor->vel.X || debrisactor->vel.Y || debrisactor->vel.Z || debrisactor->spr.sector()->velFloor || debrisactor->spr.sector()->velCeil)
if ((debrisactor->xspr.physAttr & kPhysFalling) || debrisactor->vel.X || debrisactor->vel.Y || debrisactor->vel.Z || debrisactor->sector()->velFloor || debrisactor->sector()->velCeil)
debrisMove(i);
if (debrisactor->vel.X || debrisactor->vel.Y)
@ -1344,7 +1344,7 @@ void nnExtProcessSuperSprites()
if (ang < debrisactor->xspr.goalAng) debrisactor->spr.ang = ClipHigh(ang + angStep, debrisactor->xspr.goalAng);
else if (ang > debrisactor->xspr.goalAng) debrisactor->spr.ang = ClipLow(ang - angStep, debrisactor->xspr.goalAng);
auto pSector = debrisactor->spr.sector();
auto pSector = debrisactor->sector();
int cz = getceilzofslopeptr(pSector, debrisactor->spr.pos.X, debrisactor->spr.pos.Y);
int fz = getflorzofslopeptr(pSector, debrisactor->spr.pos.X, debrisactor->spr.pos.Y);
@ -1593,7 +1593,7 @@ void debrisBubble(DBloodActor* actor)
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)), actor->spr.sector(), x, y, z, 0);
auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23 + Random(3)), actor->sector(), x, y, z, 0);
if (pFX) {
pFX->vel.X = actor->vel.X + Random2(0x1aaaa);
pFX->vel.Y = actor->vel.Y + Random2(0x1aaaa);
@ -1615,7 +1615,7 @@ void debrisBubble(DBloodActor* actor)
void debrisMove(int listIndex)
{
DBloodActor* actor = gPhysSpritesList[listIndex];
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
if (!actor->hasX() || !pSector)
{
@ -1652,7 +1652,7 @@ void debrisMove(int listIndex)
actor->hit.hit = moveHit;
actor->spr.cstat = oldcstat;
if (actor->spr.sector() != pSector)
if (actor->sector() != pSector)
{
if (!pSector) return;
else ChangeActorSect(actor, pSector);
@ -1677,11 +1677,11 @@ void debrisMove(int listIndex)
return;
}
if (actor->spr.sector() != pSector)
if (actor->sector() != pSector)
{
assert(pSector);
ChangeActorSect(actor, pSector);
pSector = actor->spr.sector();
pSector = actor->sector();
}
if (pSector->hasX())
@ -1758,17 +1758,17 @@ void debrisMove(int listIndex)
if (floorZ <= bottom) {
actor->hit.florhit = floorColl;
int v30 = actor->vel.Z - actor->spr.sector()->velFloor;
int v30 = actor->vel.Z - actor->sector()->velFloor;
if (v30 > 0)
{
actor->xspr.physAttr |= kPhysFalling;
actFloorBounceVector(&actor->vel.X, &actor->vel.Y, &v30, actor->spr.sector(), tmpFraction);
actFloorBounceVector(&actor->vel.X, &actor->vel.Y, &v30, actor->sector(), tmpFraction);
actor->vel.Z = v30;
if (abs(actor->vel.Z) < 0x10000)
{
actor->vel.Z = actor->spr.sector()->velFloor;
actor->vel.Z = actor->sector()->velFloor;
actor->xspr.physAttr &= ~kPhysFalling;
}
@ -1777,17 +1777,17 @@ void debrisMove(int listIndex)
switch (tileGetSurfType(floorColl))
{
case kSurfLava:
if ((pFX = gFX.fxSpawnActor(FX_10, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0)) == NULL) break;
if ((pFX = gFX.fxSpawnActor(FX_10, actor->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;
if ((pFX2 = gFX.fxSpawnActor(FX_14, pFX->sector(), pFX->spr.pos.X, pFX->spr.pos.Y, pFX->spr.pos.Z, 0)) == NULL) continue;
pFX2->vel.X = Random2(0x6aaaa);
pFX2->vel.Y = Random2(0x6aaaa);
pFX2->vel.Z = -(int)Random(0xd5555);
}
break;
case kSurfWater:
gFX.fxSpawnActor(FX_9, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
gFX.fxSpawnActor(FX_9, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, floorZ, 0);
break;
}
@ -1861,7 +1861,7 @@ bool ceilIsTooLow(DBloodActor* actor)
{
if (actor != nullptr)
{
sectortype* pSector = actor->spr.sector();
sectortype* pSector = actor->sector();
int a = pSector->ceilingz - pSector->floorz;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
@ -1899,9 +1899,9 @@ void aiSetGenIdleState(DBloodActor* actor)
void windGenStopWindOnSectors(DBloodActor* sourceactor)
{
if (sourceactor->xspr.txID <= 0 && sourceactor->spr.sector()->hasX())
if (sourceactor->xspr.txID <= 0 && sourceactor->sector()->hasX())
{
sourceactor->spr.sector()->xs().windVel = 0;
sourceactor->sector()->xs().windVel = 0;
return;
}
@ -2933,11 +2933,11 @@ void usePropertiesChanger(DBloodActor* sourceactor, int objType, sectortype* pSe
void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
{
PLAYER* pPlayer = getPlayerById(actor->spr.type);
XSECTOR* pXSector = (sourceactor->spr.sector()->hasX()) ? &sourceactor->spr.sector()->xs() : nullptr;
XSECTOR* pXSector = (sourceactor->sector()->hasX()) ? &sourceactor->sector()->xs() : nullptr;
bool isDude = (!pPlayer && actor->IsDudeActor());
if (actor->spr.sector() != sourceactor->spr.sector())
ChangeActorSect(actor, sourceactor->spr.sector());
if (actor->sector() != sourceactor->sector())
ChangeActorSect(actor, sourceactor->sector());
actor->spr.pos.X = sourceactor->spr.pos.X; actor->spr.pos.Y = sourceactor->spr.pos.Y;
int zTop, zBot;
@ -2947,7 +2947,7 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
clampSprite(actor, 0x01);
if (sourceactor->spr.flags & kModernTypeFlag1) // force telefrag
TeleFrag(actor, sourceactor->spr.sector());
TeleFrag(actor, sourceactor->sector());
if (actor->spr.flags & kPhysGravity)
actor->spr.flags |= kPhysFalling;
@ -2956,12 +2956,12 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
{
if (pXSector->Enter && (pPlayer || (isDude && !pXSector->dudeLockout)))
trTriggerSector(sourceactor->spr.sector(), kCmdSectorEnter);
trTriggerSector(sourceactor->sector(), kCmdSectorEnter);
if (pXSector->Underwater)
{
DBloodActor* aUpper = nullptr;
auto aLink = barrier_cast<DBloodActor*>(sourceactor->spr.sector()->lowerLink);
auto aLink = barrier_cast<DBloodActor*>(sourceactor->sector()->lowerLink);
if (aLink)
{
// must be sure we found exact same upper link
@ -3095,14 +3095,14 @@ void useEffectGen(DBloodActor* sourceactor, DBloodActor* actor)
case 3:
case 4:
if (!actor->insector()) pos = top;
else pos = (sourceactor->xspr.data4 == 3) ? actor->spr.sector()->floorz : actor->spr.sector()->ceilingz;
else pos = (sourceactor->xspr.data4 == 3) ? actor->sector()->floorz : actor->sector()->ceilingz;
break;
default:
pos = top;
break;
}
if ((pEffect = gFX.fxSpawnActor((FX_ID)fxId, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, pos, 0)) != NULL)
if ((pEffect = gFX.fxSpawnActor((FX_ID)fxId, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, pos, 0)) != NULL)
{
pEffect->SetOwner(sourceactor);
@ -3143,14 +3143,14 @@ void useSectorWindGen(DBloodActor* sourceactor, sectortype* pSector)
{
pXSector = &pSector->xs();
}
else if (sourceactor->spr.sector()->hasX())
else if (sourceactor->sector()->hasX())
{
pSector = sourceactor->spr.sector();
pSector = sourceactor->sector();
pXSector = &pSector->xs();
}
else
{
pSector = sourceactor->spr.sector();
pSector = sourceactor->sector();
pSector->allocX();
pXSector = &pSector->xs();
pXSector->windAlways = 1;
@ -3244,7 +3244,7 @@ void useSectorWindGen(DBloodActor* sourceactor, sectortype* pSector)
void useSpriteDamager(DBloodActor* sourceactor, int objType, sectortype* targSect, DBloodActor* targetactor)
{
sectortype* pSector = sourceactor->spr.sector();
sectortype* pSector = sourceactor->sector();
int top, bottom;
bool floor, ceil, wall, enter;
@ -3502,7 +3502,7 @@ void useSeqSpawnerGen(DBloodActor* sourceactor, int objType, sectortype* pSector
{
if (sourceactor->xspr.data3 > 0)
{
auto spawned = InsertSprite(iactor->spr.sector(), kStatDecoration);
auto spawned = InsertSprite(iactor->sector(), kStatDecoration);
int top, bottom; GetActorExtents(spawned, &top, &bottom);
spawned->spr.pos.X = iactor->spr.pos.X;
spawned->spr.pos.Y = iactor->spr.pos.Y;
@ -4187,7 +4187,7 @@ bool condCheckDude(DBloodActor* aCond, int cmpOp, bool PUSH)
break;
case 3:
case 4:
var = cansee(objActor->spr.pos.X, objActor->spr.pos.Y, objActor->spr.pos.Z, objActor->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - eyeAboveZ, targ->spr.sector());
var = cansee(objActor->spr.pos.X, objActor->spr.pos.Y, objActor->spr.pos.Z, objActor->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - eyeAboveZ, targ->sector());
if (cond == 4 && var > 0)
{
var = ((1024 + getangle(dx, dy) - objActor->spr.ang) & 2047) - 1024;
@ -4324,7 +4324,7 @@ bool condCheckSprite(DBloodActor* aCond, int cmpOp, bool PUSH)
return true;
case 20: // stays in a sector?
if (!objActor->insector()) return false;
else if (PUSH) condPush(aCond, objActor->spr.sector());
else if (PUSH) condPush(aCond, objActor->sector());
return true;
case 25:
switch (arg1)
@ -4337,7 +4337,7 @@ bool condCheckSprite(DBloodActor* aCond, int cmpOp, bool PUSH)
break;
case 30:
if (!spriteIsUnderwater(objActor) && !spriteIsUnderwater(objActor, true)) return false;
else if (PUSH) condPush(aCond, objActor->spr.sector());
else if (PUSH) condPush(aCond, objActor->sector());
return true;
case 31:
if (arg1 == -1)
@ -4874,7 +4874,7 @@ bool aiFightDudeCanSeeTarget(DBloodActor* dudeactor, DUDEINFO* pDudeInfo, DBlood
int eyeAboveZ = pDudeInfo->eyeHeight * dudeactor->spr.yrepeat << 2;
// is there a line of sight to the target?
if (cansee(dudeactor->spr.pos.X, dudeactor->spr.pos.Y, dudeactor->spr.pos.Z, dudeactor->spr.sector(), targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.pos.Z - eyeAboveZ, targetactor->spr.sector()))
if (cansee(dudeactor->spr.pos.X, dudeactor->spr.pos.Y, dudeactor->spr.pos.Z, dudeactor->sector(), targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.pos.Z - eyeAboveZ, targetactor->sector()))
{
/*int nAngle = getangle(dx, dy);
int losAngle = ((1024 + nAngle - dudeactor->spr.ang) & 2047) - 1024;
@ -5454,7 +5454,7 @@ bool modernTypeOperateSprite(DBloodActor* actor, EVENT& event)
[[fallthrough]];
case kCmdRepeat:
if (actor->xspr.txID > 0) modernTypeSendCommand(actor, actor->xspr.txID, (COMMAND_ID)actor->xspr.command);
else if (actor->xspr.data1 == 0 && actor->insector()) useSpriteDamager(actor, OBJ_SECTOR, actor->spr.sector(), nullptr);
else if (actor->xspr.data1 == 0 && actor->insector()) useSpriteDamager(actor, OBJ_SECTOR, actor->sector(), nullptr);
else if (actor->xspr.data1 >= 666 && actor->xspr.data1 < 669) useSpriteDamager(actor, -1, nullptr, nullptr);
else
{
@ -6112,7 +6112,7 @@ void useRandomItemGen(DBloodActor* actor)
{
if ((unsigned int)iactor->spr.type == actor->xspr.dropMsg && iactor->spr.pos.X == actor->spr.pos.X && iactor->spr.pos.Y == actor->spr.pos.Y && iactor->spr.pos.Z == actor->spr.pos.Z)
{
gFX.fxSpawnActor((FX_ID)29, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
gFX.fxSpawnActor((FX_ID)29, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, 0);
iactor->spr.type = kSpriteDecoration;
actPostSprite(iactor, kStatFree);
break;
@ -6328,12 +6328,12 @@ void sprite2sectorSlope(DBloodActor* actor, sectortype* pSector, char rel, bool
int slope = 0, z = 0;
switch (rel) {
default:
z = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
z = getflorzofslopeptr(actor->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(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
z = getceilzofslopeptr(actor->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;
@ -6465,11 +6465,11 @@ void useSlopeChanger(DBloodActor* sourceactor, int objType, sectortype* pSect, D
if (!objActor->insector()) break;
switch (sourceactor->xspr.data4)
{
case 1: sprite2sectorSlope(objActor, objActor->spr.sector(), 0, flag2); break;
case 2: sprite2sectorSlope(objActor, objActor->spr.sector(), 1, flag2); break;
case 1: sprite2sectorSlope(objActor, objActor->sector(), 0, flag2); break;
case 2: sprite2sectorSlope(objActor, objActor->sector(), 1, flag2); break;
case 3:
if (getflorzofslopeptr(objActor->spr.sector(), objActor->spr.pos.X, objActor->spr.pos.Y) - kSlopeDist <= objActor->spr.pos.Z) sprite2sectorSlope(objActor, objActor->spr.sector(), 0, flag2);
if (getceilzofslopeptr(objActor->spr.sector(), objActor->spr.pos.X, objActor->spr.pos.Y) + kSlopeDist >= objActor->spr.pos.Z) sprite2sectorSlope(objActor, objActor->spr.sector(), 1, flag2);
if (getflorzofslopeptr(objActor->sector(), objActor->spr.pos.X, objActor->spr.pos.Y) - kSlopeDist <= objActor->spr.pos.Z) sprite2sectorSlope(objActor, objActor->sector(), 0, flag2);
if (getceilzofslopeptr(objActor->sector(), objActor->spr.pos.X, objActor->spr.pos.Y) + kSlopeDist >= objActor->spr.pos.Z) sprite2sectorSlope(objActor, objActor->sector(), 1, flag2);
break;
}
break;
@ -7311,7 +7311,7 @@ bool setDataValueOfObject(int objType, sectortype* sect, walltype* wal, DBloodAc
bool nnExtCanMove(DBloodActor* actor, DBloodActor* target, int nAngle, int nRange)
{
int x = actor->spr.pos.X, y = actor->spr.pos.Y, z = actor->spr.pos.Z;
auto pSector = actor->spr.sector();
auto pSector = actor->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 - (actor->spr.clipdist << 2) < nRange)
@ -7604,7 +7604,7 @@ void aiPatrolSetMarker(DBloodActor* actor)
continue;
GetActorExtents(nextactor, &zt1, &zb1);
if (cansee(nextactor->spr.pos.X, nextactor->spr.pos.Y, zt1, nextactor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, zt2, actor->spr.sector()))
if (cansee(nextactor->spr.pos.X, nextactor->spr.pos.Y, zt1, nextactor->sector(), actor->spr.pos.X, actor->spr.pos.Y, zt2, actor->sector()))
{
closest = dist;
selected = nextactor;
@ -7863,10 +7863,10 @@ void aiPatrolAlarmLite(DBloodActor* actor, DBloodActor* targetactor)
int eaz2 = (getDudeInfo(targetactor->spr.type)->eyeHeight * targetactor->spr.yrepeat) << 2;
int nDist = approxDist(dudeactor->spr.pos.X - actor->spr.pos.X, dudeactor->spr.pos.Y - actor->spr.pos.Y);
if (nDist >= kPatrolAlarmSeeDist || !cansee(actor->spr.pos.X, actor->spr.pos.Y, zt1, actor->spr.sector(), dudeactor->spr.pos.X, dudeactor->spr.pos.Y, dudeactor->spr.pos.Z - eaz2, dudeactor->spr.sector()))
if (nDist >= kPatrolAlarmSeeDist || !cansee(actor->spr.pos.X, actor->spr.pos.Y, zt1, actor->sector(), dudeactor->spr.pos.X, dudeactor->spr.pos.Y, dudeactor->spr.pos.Z - eaz2, dudeactor->sector()))
{
nDist = approxDist(dudeactor->spr.pos.X - targetactor->spr.pos.X, dudeactor->spr.pos.Y - targetactor->spr.pos.Y);
if (nDist >= kPatrolAlarmSeeDist || !cansee(targetactor->spr.pos.X, targetactor->spr.pos.Y, zt2, targetactor->spr.sector(), dudeactor->spr.pos.X, dudeactor->spr.pos.Y, dudeactor->spr.pos.Z - eaz2, dudeactor->spr.sector()))
if (nDist >= kPatrolAlarmSeeDist || !cansee(targetactor->spr.pos.X, targetactor->spr.pos.Y, zt2, targetactor->sector(), dudeactor->spr.pos.X, dudeactor->spr.pos.Y, dudeactor->spr.pos.Z - eaz2, dudeactor->sector()))
continue;
}
@ -7896,13 +7896,13 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
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 = actor->spr.sector();
auto pSect2 = actor->sector();
int tzt, tzb;
GetActorExtents(targetactor, &tzt, &tzb);
int x3 = targetactor->spr.pos.X, y3 = targetactor->spr.pos.Y, z3 = tzt;
auto pSect3 = targetactor->spr.sector();
auto pSect3 = targetactor->sector();
BloodStatIterator it(kStatDude);
while (auto dudeactor = it.Next())
@ -7916,7 +7916,7 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
int eaz1 = (getDudeInfo(dudeactor->spr.type)->eyeHeight * dudeactor->spr.yrepeat) << 2;
int x1 = dudeactor->spr.pos.X, y1 = dudeactor->spr.pos.Y, z1 = dudeactor->spr.pos.Z - eaz1;
auto pSect1 = dudeactor->spr.sector();
auto pSect1 = dudeactor->sector();
int nDist1 = approxDist(x1 - x2, y1 - y2);
int nDist2 = approxDist(x1 - x3, y1 - y3);
@ -8047,7 +8047,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
{
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, plActor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - eyeAboveZ, actor->spr.sector()))
if (!cansee(x, y, z, plActor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - eyeAboveZ, actor->sector()))
continue;
}
else
@ -8081,7 +8081,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
{
if (!emitterActor->insector()) return false;
searchsect = emitterActor->spr.sector();
searchsect = emitterActor->sector();
}
}
else if (chan->SourceType == SOURCE_Unattached)
@ -8230,7 +8230,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
continue;
}
else if (plActor->spr.sector() != steal->spr.sector())
else if (plActor->sector() != steal->sector())
continue;
if (crouch && pPlayer->posture == kPostureStand)
@ -8245,7 +8245,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
continue;
}
else if (plActor->spr.sector() != steal->spr.sector())
else if (plActor->sector() != steal->sector())
continue;
}
@ -8864,9 +8864,9 @@ void clampSprite(DBloodActor* actor, int which)
{
GetActorExtents(actor, &zTop, &zBot);
if (which & 0x01)
actor->spr.pos.Z += ClipHigh(getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) - zBot, 0);
actor->spr.pos.Z += ClipHigh(getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y) - zBot, 0);
if (which & 0x02)
actor->spr.pos.Z += ClipLow(getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) - zTop, 0);
actor->spr.pos.Z += ClipLow(getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y) - zTop, 0);
}

32
source/games/blood/src/player.cpp
View file

@ -894,7 +894,7 @@ void playerStart(int nPlayer, int bNewLevel)
{
viewInitializePrediction();
}
if (IsUnderwaterSector(actor->spr.sector()))
if (IsUnderwaterSector(actor->sector()))
{
pPlayer->posture = 1;
pPlayer->actor->xspr.medium = kMediumWater;
@ -1235,7 +1235,7 @@ bool PickupItem(PLAYER* pPlayer, DBloodActor* itemactor)
return 1;
}
sfxPlay3DSound(plActor->spr.pos.X, plActor->spr.pos.Y, plActor->spr.pos.Z, pickupSnd, plActor->spr.sector());
sfxPlay3DSound(plActor->spr.pos.X, plActor->spr.pos.Y, plActor->spr.pos.Z, pickupSnd, plActor->sector());
return 1;
}
@ -1371,7 +1371,7 @@ void CheckPickUp(PLAYER* pPlayer)
int x = plActor->spr.pos.X;
int y = plActor->spr.pos.Y;
int z = plActor->spr.pos.Z;
auto pSector = plActor->spr.sector();
auto pSector = plActor->sector();
BloodStatIterator it(kStatItem);
while (auto itemactor = it.Next())
{
@ -1395,9 +1395,9 @@ void CheckPickUp(PLAYER* pPlayer)
if (approxDist(dx, dy) > 48)
continue;
GetActorExtents(itemactor, &top, &bottom);
if (cansee(x, y, z, pSector, itemactor->spr.pos.X, itemactor->spr.pos.Y, itemactor->spr.pos.Z, itemactor->spr.sector())
|| cansee(x, y, z, pSector, itemactor->spr.pos.X, itemactor->spr.pos.Y, top, itemactor->spr.sector())
|| cansee(x, y, z, pSector, itemactor->spr.pos.X, itemactor->spr.pos.Y, bottom, itemactor->spr.sector()))
if (cansee(x, y, z, pSector, itemactor->spr.pos.X, itemactor->spr.pos.Y, itemactor->spr.pos.Z, itemactor->sector())
|| cansee(x, y, z, pSector, itemactor->spr.pos.X, itemactor->spr.pos.Y, top, itemactor->sector())
|| cansee(x, y, z, pSector, itemactor->spr.pos.X, itemactor->spr.pos.Y, bottom, itemactor->sector()))
PickUp(pPlayer, itemactor);
}
}
@ -1481,8 +1481,8 @@ int ActionScan(PLAYER* pPlayer, HitInfo* out)
}
}
}
out->hitSector = plActor->spr.sector();
if (plActor->spr.sector()->hasX() && plActor->spr.sector()->xs().Push)
out->hitSector = plActor->sector();
if (plActor->sector()->hasX() && plActor->sector()->xs().Push)
return 6;
return -1;
}
@ -1509,7 +1509,7 @@ void doslopetilting(PLAYER* pPlayer, double const scaleAdjust = 1)
auto plActor = pPlayer->actor;
int const florhit = pPlayer->actor->hit.florhit.type;
bool const va = plActor->xspr.height < 16 && (florhit == kHitSector || florhit == 0) ? 1 : 0;
pPlayer->horizon.calcviewpitch(plActor->spr.pos.vec2, buildang(plActor->spr.ang), va, plActor->spr.sector()->floorstat & CSTAT_SECTOR_SLOPE, plActor->spr.sector(), scaleAdjust);
pPlayer->horizon.calcviewpitch(plActor->spr.pos.vec2, buildang(plActor->spr.ang), va, plActor->sector()->floorstat & CSTAT_SECTOR_SLOPE, plActor->sector(), scaleAdjust);
}
//---------------------------------------------------------------------------
@ -1842,14 +1842,14 @@ void playerProcess(PLAYER* pPlayer)
int dw = actor->spr.clipdist << 2;
if (!gNoClip)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
if (pushmove(&actor->spr.pos, &pSector, dw, dzt, dzb, CLIPMASK0) == -1)
actDamageSprite(actor, actor, kDamageFall, 500 << 4);
if (actor->spr.sector() != pSector)
if (actor->sector() != pSector)
{
if (pSector == nullptr)
{
pSector = actor->spr.sector();
pSector = actor->sector();
actDamageSprite(actor, actor, kDamageFall, 500 << 4);
}
else
@ -1921,10 +1921,10 @@ void playerProcess(PLAYER* pPlayer)
if (pPlayer->posture == 1)
{
pPlayer->isUnderwater = 1;
auto link = actor->spr.sector()->lowerLink;
auto link = actor->sector()->lowerLink;
if (link && (link->spr.type == kMarkerLowGoo || link->spr.type == kMarkerLowWater))
{
if (getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y) > pPlayer->zView)
if (getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y) > pPlayer->zView)
pPlayer->isUnderwater = 0;
}
}
@ -2254,8 +2254,8 @@ int playerDamageSprite(DBloodActor* source, PLAYER* pPlayer, DAMAGE_TYPE nDamage
if (nDeathSeqID != 16)
{
powerupClear(pPlayer);
if (pActor->spr.sector()->hasX() && pActor->spr.sector()->xs().Exit)
trTriggerSector(pActor->spr.sector(), kCmdSectorExit);
if (pActor->sector()->hasX() && pActor->sector()->xs().Exit)
trTriggerSector(pActor->sector(), kCmdSectorExit);
pActor->spr.flags |= 7;
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{

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

@ -350,8 +350,8 @@ void SEQINST::Update()
// by NoOne: add surfaceSound trigger feature
if (!VanillaMode() && pSequence->frames[frameIndex].surfaceSound && actor->vel.Z == 0 && actor->vel.X != 0) {
if (actor->spr.sector()->upperLink) break; // don't play surface sound for stacked sectors
int surf = tileGetSurfType(actor->spr.sector()->floorpicnum);
if (actor->sector()->upperLink) break; // don't play surface sound for stacked sectors
int surf = tileGetSurfType(actor->sector()->floorpicnum);
if (!surf) break;
static int surfSfxMove[15][4] = {
/* {snd1, snd2, gameVolume, myVolume} */

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

@ -269,7 +269,7 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
int y = target->spr.pos.Y;
int z = target->spr.pos.Z;
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, target->spr.sector()))
if (nDist != 0 && cansee(actor->spr.pos.X, actor->spr.pos.Y, top, actor->sector(), x, y, z, target->sector()))
{
int t = DivScale(nDist, 0x1aaaaa, 12);
x += (target->vel.X * t) >> 12;
@ -1535,17 +1535,17 @@ void OperateTeleport(sectortype* pSector)
pPlayer = &gPlayer[actor->spr.type - kDudePlayer1];
else
pPlayer = NULL;
if (bPlayer || !SectorContainsDudes(destactor->spr.sector()))
if (bPlayer || !SectorContainsDudes(destactor->sector()))
{
if (!(gGameOptions.uNetGameFlags & 2))
{
TeleFrag(pXSector->actordata, destactor->spr.sector());
TeleFrag(pXSector->actordata, destactor->sector());
}
actor->spr.pos.X = destactor->spr.pos.X;
actor->spr.pos.Y = destactor->spr.pos.Y;
actor->spr.pos.Z += destactor->spr.sector()->floorz - pSector->floorz;
actor->spr.pos.Z += destactor->sector()->floorz - pSector->floorz;
actor->spr.ang = destactor->spr.ang;
ChangeActorSect(actor, destactor->spr.sector());
ChangeActorSect(actor, destactor->sector());
sfxPlay3DSound(destactor, 201, -1, 0);
actor->vel.X = actor->vel.Y = actor->vel.Z = 0;
actor->interpolated = false;
@ -2381,7 +2381,7 @@ void ActivateGenerator(DBloodActor* actor)
case kGenDripBlood: {
int top, bottom;
GetActorExtents(actor, &top, &bottom);
actSpawnThing(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, bottom, (actor->spr.type == kGenDripWater) ? kThingDripWater : kThingDripBlood);
actSpawnThing(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, bottom, (actor->spr.type == kGenDripWater) ? kThingDripWater : kThingDripBlood);
break;
}
case kGenSound:
@ -2406,7 +2406,7 @@ void ActivateGenerator(DBloodActor* actor)
case kGenBubbleMulti: {
int top, bottom;
GetActorExtents(actor, &top, &bottom);
gFX.fxSpawnActor((actor->spr.type == kGenBubble) ? FX_23 : FX_26, actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, top, 0);
gFX.fxSpawnActor((actor->spr.type == kGenBubble) ? FX_23 : FX_26, actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, top, 0);
break;
}
}

2
source/games/blood/src/view.cpp
View file

@ -491,7 +491,7 @@ void SetupView(int& cX, int& cY, int& cZ, binangle& cA, fixedhoriz& cH, sectorty
{
int bobWidth, bobHeight;
pSector = gView->actor->spr.sector();
pSector = gView->actor->sector();
#if 0
if (numplayers > 1 && gView == gMe && gPrediction && gMe->actor->xspr.health > 0)
{

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

@ -86,7 +86,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pZone->x = actor->spr.pos.X;
pZone->y = actor->spr.pos.Y;
pZone->z = actor->spr.pos.Z;
pZone->sector = actor->spr.sector();
pZone->sector = actor->sector();
pZone->ang = actor->spr.ang;
}
DeleteSprite(actor);
@ -99,7 +99,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pZone->x = actor->spr.pos.X;
pZone->y = actor->spr.pos.Y;
pZone->z = actor->spr.pos.Z;
pZone->sector = actor->spr.sector();
pZone->sector = actor->sector();
pZone->ang = actor->spr.ang;
#ifdef NOONE_EXTENSIONS
@ -110,7 +110,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pZone->x = actor->spr.pos.X;
pZone->y = actor->spr.pos.Y;
pZone->z = actor->spr.pos.Z;
pZone->sector = actor->spr.sector();
pZone->sector = actor->sector();
pZone->ang = actor->spr.ang;
team1++;
@ -120,7 +120,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pZone->x = actor->spr.pos.X;
pZone->y = actor->spr.pos.Y;
pZone->z = actor->spr.pos.Z;
pZone->sector = actor->spr.sector();
pZone->sector = actor->sector();
pZone->ang = actor->spr.ang;
team2++;
}
@ -132,30 +132,30 @@ void warpInit(TArray<DBloodActor*>& actors)
}
break;
case kMarkerUpLink:
actor->spr.sector()->upperLink = actor;
actor->sector()->upperLink = actor;
actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
break;
case kMarkerLowLink:
actor->spr.sector()->lowerLink = actor;
actor->sector()->lowerLink = actor;
actor->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
actor->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
break;
case kMarkerUpWater:
case kMarkerUpStack:
case kMarkerUpGoo:
actor->spr.sector()->upperLink = actor;
actor->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);
actor->spr.pos.Z = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
break;
case kMarkerLowWater:
case kMarkerLowStack:
case kMarkerLowGoo:
actor->spr.sector()->lowerLink = actor;
actor->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);
actor->spr.pos.Z = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
break;
}
}
@ -203,7 +203,7 @@ void warpInit(TArray<DBloodActor*>& actors)
int CheckLink(DBloodActor* actor)
{
auto pSector = actor->spr.sector();
auto pSector = actor->sector();
auto aUpper = barrier_cast<DBloodActor*>(pSector->upperLink);
auto aLower = barrier_cast<DBloodActor*>(pSector->lowerLink);
if (aUpper)
@ -212,20 +212,20 @@ int CheckLink(DBloodActor* actor)
if (aUpper->spr.type == kMarkerUpLink)
z = aUpper->spr.pos.Z;
else
z = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
z = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (z <= actor->spr.pos.Z)
{
aLower = aUpper->GetOwner();
assert(aLower);
assert(aLower->insector());
ChangeActorSect(actor, aLower->spr.sector());
ChangeActorSect(actor, aLower->sector());
actor->spr.pos.X += aLower->spr.pos.X - aUpper->spr.pos.X;
actor->spr.pos.Y += aLower->spr.pos.Y - aUpper->spr.pos.Y;
int z2;
if (aLower->spr.type == kMarkerLowLink)
z2 = aLower->spr.pos.Z;
else
z2 = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
z2 = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->spr.pos.Z += z2 - z;
actor->interpolated = false;
return aUpper->spr.type;
@ -237,20 +237,20 @@ int CheckLink(DBloodActor* actor)
if (aLower->spr.type == kMarkerLowLink)
z = aLower->spr.pos.Z;
else
z = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
z = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (z >= actor->spr.pos.Z)
{
aUpper = aLower->GetOwner();
assert(aUpper);
assert(aUpper->insector());
ChangeActorSect(actor, aUpper->spr.sector());
ChangeActorSect(actor, aUpper->sector());
actor->spr.pos.X += aUpper->spr.pos.X - aLower->spr.pos.X;
actor->spr.pos.Y += aUpper->spr.pos.Y - aLower->spr.pos.Y;
int z2;
if (aUpper->spr.type == kMarkerUpLink)
z2 = aUpper->spr.pos.Z;
else
z2 = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
z2 = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->spr.pos.Z += z2 - z;
actor->interpolated = false;
return aLower->spr.type;
@ -281,7 +281,7 @@ int CheckLink(int* x, int* y, int* z, sectortype** pSector)
aLower = aUpper->GetOwner();
assert(aLower);
assert(aLower->insector());
*pSector = aLower->spr.sector();
*pSector = aLower->sector();
*x += aLower->spr.pos.X - aUpper->spr.pos.X;
*y += aLower->spr.pos.Y - aUpper->spr.pos.Y;
int z2;
@ -304,7 +304,7 @@ int CheckLink(int* x, int* y, int* z, sectortype** pSector)
{
aUpper = aLower->GetOwner();
assert(aUpper);
*pSector = aUpper->spr.sector();
*pSector = aUpper->sector();
*x += aUpper->spr.pos.X - aLower->spr.pos.X;
*y += aUpper->spr.pos.Y - aLower->spr.pos.Y;
int z2;

10
source/games/blood/src/weapon.cpp
View file

@ -472,7 +472,7 @@ void UpdateAimVector(PLAYER* pPlayer)
int angle = getangle(x2 - x, y2 - y);
if (abs(((angle - plActor->spr.ang + 1024) & 2047) - 1024) > pWeaponTrack->angleRange)
continue;
if (pPlayer->aimTargetsCount < 16 && cansee(x, y, z, plActor->spr.sector(), x2, y2, z2, actor->spr.sector()))
if (pPlayer->aimTargetsCount < 16 && cansee(x, y, z, plActor->sector(), x2, y2, z2, actor->sector()))
pPlayer->aimTargets[pPlayer->aimTargetsCount++] = actor;
// Inlined?
int dz = (lz - z2) >> 8;
@ -484,7 +484,7 @@ void UpdateAimVector(PLAYER* pPlayer)
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int center = (actor->spr.yrepeat * pDudeInfo->aimHeight) << 2;
int dzCenter = (z2 - center) - z;
if (cansee(x, y, z, plActor->spr.sector(), x2, y2, z2, actor->spr.sector()))
if (cansee(x, y, z, plActor->sector(), x2, y2, z2, actor->sector()))
{
nClosest = nDist2;
aim.dx = bcos(angle);
@ -522,7 +522,7 @@ void UpdateAimVector(PLAYER* pPlayer)
int angle = getangle(dx, dy);
if (abs(((angle - plActor->spr.ang + 1024) & 2047) - 1024) > pWeaponTrack->thingAngle)
continue;
if (pPlayer->aimTargetsCount < 16 && cansee(x, y, z, plActor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector()))
if (pPlayer->aimTargetsCount < 16 && cansee(x, y, z, plActor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
pPlayer->aimTargets[pPlayer->aimTargetsCount++] = actor;
// Inlined?
int dz2 = (lz - z2) >> 8;
@ -531,7 +531,7 @@ void UpdateAimVector(PLAYER* pPlayer)
int nDist2 = ksqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2);
if (nDist2 >= nClosest)
continue;
if (cansee(x, y, z, plActor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector()))
if (cansee(x, y, z, plActor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
{
nClosest = nDist2;
aim.dx = bcos(angle);
@ -2996,7 +2996,7 @@ void teslaHit(DBloodActor* missileactor, int a2)
int y = missileactor->spr.pos.Y;
int z = missileactor->spr.pos.Z;
int nDist = 300;
auto pSector = missileactor->spr.sector();
auto pSector = missileactor->sector();
auto owneractor = missileactor->GetOwner();
const bool newSectCheckMethod = !cl_bloodvanillaexplosions && !VanillaMode(); // use new sector checking logic
auto sectorMap = GetClosestSpriteSectors(pSector, x, y, nDist, nullptr, newSectCheckMethod);

6
source/games/duke/src/_polymost.cpp
View file

@ -66,7 +66,7 @@ void SE40_Draw(int tag, spritetype *spr, int x, int y, int z, binangle a, fixedh
act->spr.hitag == floor1->hitag
)
{
auto sect = act->spr.sector();
auto sect = act->sector();
// repurpose otherwise unused fields in sectortype as temporary storage.
if (k == tag + 0)
{
@ -100,7 +100,7 @@ void SE40_Draw(int tag, spritetype *spr, int x, int y, int z, binangle a, fixedh
act->spr.hitag == floor1->hitag
)
{
auto sect = act->spr.sector();
auto sect = act->sector();
if (k == tag + 0)
{
sect->setfloorz(sect->Flag, true);
@ -143,7 +143,7 @@ void se40code(int x, int y, int z, binangle a, fixedhoriz h, int smoothratio)
case 43:
case 44:
case 45:
if (ps[screenpeek].cursector == act->spr.sector())
if (ps[screenpeek].cursector == act->sector())
SE40_Draw(tag, &act->spr, x, y, z, a, h, smoothratio);
break;
}

240
source/games/duke/src/actors.cpp
View file

@ -61,7 +61,7 @@ void RANDOMSCRAP(DDukeActor* origin)
{
int r1 = krand(), r2 = krand(), r3 = krand(), r4 = krand(), r5 = krand(), r6 = krand(), r7 = krand();
int v = isRR() ? 16 : 48;
EGS(origin->spr.sector(),
EGS(origin->sector(),
origin->spr.pos.X + (r7 & 255) - 128, origin->spr.pos.Y + (r6 & 255) - 128, origin->spr.pos.Z - (8 << 8) - (r5 & 8191),
TILE_SCRAP6 + (r4 & 15), -8, v, v, r3 & 2047, (r2 & 63) + 64, -512 - (r1 & 2047), origin, 5);
}
@ -265,7 +265,7 @@ void lotsofstuff(DDukeActor* actor, int n, int spawntype)
for (int i = n; i > 0; i--)
{
int r1 = krand(), r2 = krand(); // using the RANDCORRECT version from RR.
auto j = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
auto j = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
if (j) j->spr.cstat = randomFlip();
}
}
@ -362,7 +362,7 @@ void movedummyplayers(void)
if (ps[p].on_ground && ps[p].on_warping_sector == 1 && ps[p].cursector->lotag == 1)
{
act->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
act->spr.pos.Z = act->spr.sector()->ceilingz + (27 << 8);
act->spr.pos.Z = act->sector()->ceilingz + (27 << 8);
act->spr.ang = ps[p].angle.ang.asbuild();
if (act->temp_data[0] == 8)
act->temp_data[0] = 0;
@ -370,7 +370,7 @@ void movedummyplayers(void)
}
else
{
if (act->spr.sector()->lotag != 2) act->spr.pos.Z = act->spr.sector()->floorz;
if (act->sector()->lotag != 2) act->spr.pos.Z = act->sector()->floorz;
act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
}
}
@ -456,7 +456,7 @@ void moveplayers(void)
act->SetHitOwner(act);
if (ud.god == 0)
if (fi.ceilingspace(act->spr.sector()) || fi.floorspace(act->spr.sector()))
if (fi.ceilingspace(act->sector()) || fi.floorspace(act->sector()))
quickkill(p);
}
else
@ -496,9 +496,9 @@ void moveplayers(void)
else
{
act->spr.yrepeat = 36;
if (act->spr.sector()->lotag != ST_2_UNDERWATER)
if (act->sector()->lotag != ST_2_UNDERWATER)
makeitfall(act);
if (act->spr.zvel == 0 && act->spr.sector()->lotag == ST_1_ABOVE_WATER)
if (act->spr.zvel == 0 && act->sector()->lotag == ST_1_ABOVE_WATER)
act->spr.pos.Z += (32 << 8);
}
@ -518,10 +518,10 @@ void moveplayers(void)
if (act->insector())
{
if (act->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade += (act->spr.sector()->ceilingshade - act->spr.shade) >> 1;
if (act->sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade += (act->sector()->ceilingshade - act->spr.shade) >> 1;
else
act->spr.shade += (act->spr.sector()->floorshade - act->spr.shade) >> 1;
act->spr.shade += (act->sector()->floorshade - act->spr.shade) >> 1;
}
}
}
@ -584,7 +584,7 @@ void movefx(void)
act->temp_data[0] = 0;
}
}
else if (act->spr.lotag < 999 && (unsigned)act->spr.sector()->lotag < ST_9_SLIDING_ST_DOOR && snd_ambience && act->spr.sector()->floorz != act->spr.sector()->ceilingz)
else if (act->spr.lotag < 999 && (unsigned)act->sector()->lotag < ST_9_SLIDING_ST_DOOR && snd_ambience && act->sector()->floorz != act->sector()->ceilingz)
{
int flags = S_GetUserFlags(act->spr.lotag);
if (flags & SF_MSFX)
@ -608,7 +608,7 @@ void movefx(void)
{
if (act->temp_data[4] > 0) act->temp_data[4]--;
else for (p = connecthead; p >= 0; p = connectpoint2[p])
if (p == myconnectindex && ps[p].cursector == act->spr.sector())
if (p == myconnectindex && ps[p].cursector == act->sector())
{
S_PlaySound(act->spr.lotag + (unsigned)global_random % (act->spr.hitag + 1));
act->temp_data[4] = 26 * 40 + (global_random % (26 * 40));
@ -628,7 +628,7 @@ void movefx(void)
void movecrane(DDukeActor *actor, int crane)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int x;
auto& cpt = cranes[actor->temp_data[4]];
@ -665,7 +665,7 @@ void movecrane(DDukeActor *actor, int crane)
}
//IFMOVING; // JBF 20040825: see my rant above about this
ssp(actor, CLIPMASK0);
if (actor->spr.sector() == actor->temp_sect)
if (actor->sector() == actor->temp_sect)
actor->temp_data[0]++;
}
else if (actor->temp_data[0] == 2 || actor->temp_data[0] == 7)
@ -803,7 +803,7 @@ void movecrane(DDukeActor *actor, int crane)
ps[p].pos.Y = actor->spr.pos.Y - bsin(ang, -6);
ps[p].pos.Z = actor->spr.pos.Z + (2 << 8);
SetActor(ps[p].GetActor(), ps[p].pos);
ps[p].setCursector(ps[p].GetActor()->spr.sector());
ps[p].setCursector(ps[p].GetActor()->sector());
}
}
}
@ -891,7 +891,7 @@ void moveflammable(DDukeActor* actor, int tire, int box, int pool)
if (box >= 0 && actor->spr.picnum == box)
{
makeitfall(actor);
actor->ceilingz = actor->spr.sector()->ceilingz;
actor->ceilingz = actor->sector()->ceilingz;
}
}
@ -958,7 +958,7 @@ void movemasterswitch(DDukeActor *actor, int spectype1, int spectype2)
actor->spr.hitag--;
if (actor->spr.hitag <= 0)
{
operatesectors(actor->spr.sector(), actor);
operatesectors(actor->sector(), actor);
DukeSectIterator it(actor->sector());
while (auto effector = it.Next())
@ -1067,7 +1067,7 @@ void movewaterdrip(DDukeActor *actor, int drip)
void movedoorshock(DDukeActor* actor)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int j = abs(sectp->ceilingz - sectp->floorz) >> 9;
actor->spr.yrepeat = j + 4;
actor->spr.xrepeat = 16;
@ -1082,7 +1082,7 @@ void movedoorshock(DDukeActor* actor)
void movetouchplate(DDukeActor* actor, int plate)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int x;
int p;
@ -1100,7 +1100,7 @@ void movetouchplate(DDukeActor* actor, int plate)
else
{
sectp->addfloorz(sectp->extra);
p = checkcursectnums(actor->spr.sector());
p = checkcursectnums(actor->sector());
if (p >= 0) ps[p].pos.Z += sectp->extra;
}
}
@ -1114,7 +1114,7 @@ void movetouchplate(DDukeActor* actor, int plate)
else
{
sectp->addfloorz(-sectp->extra);
p = checkcursectnums(actor->spr.sector());
p = checkcursectnums(actor->sector());
if (p >= 0)
ps[p].pos.Z -= sectp->extra;
}
@ -1124,7 +1124,7 @@ void movetouchplate(DDukeActor* actor, int plate)
if (actor->temp_data[5] == 1) return;
p = checkcursectnums(actor->spr.sector());
p = checkcursectnums(actor->sector());
if (p >= 0 && (ps[p].on_ground || actor->spr.ang == 512))
{
if (actor->temp_data[0] == 0 && !check_activator_motion(actor->spr.lotag))
@ -1267,7 +1267,7 @@ void bounce(DDukeActor* actor)
int yvect = MulScale(actor->spr.xvel, bsin(actor->spr.ang), 10);
int zvect = actor->spr.zvel;
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int daang = getangle(sectp->firstWall()->delta());
@ -1329,7 +1329,7 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
actor->spr.pos.Z = Owner->spr.pos.Z - (34 << 8);
for (int k = 0; k < actor->temp_data[0]; k++)
{
auto q = EGS(actor->spr.sector(),
auto q = EGS(actor->sector(),
actor->spr.pos.X + MulScale(k, bcos(actor->spr.ang), 9),
actor->spr.pos.Y + MulScale(k, bsin(actor->spr.ang), 9),
actor->spr.pos.Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), tongue, -40 + (k << 1),
@ -1341,7 +1341,7 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
}
}
int k = actor->temp_data[0]; // do not depend on the above loop counter.
auto spawned = EGS(actor->spr.sector(),
auto spawned = EGS(actor->sector(),
actor->spr.pos.X + MulScale(k, bcos(actor->spr.ang), 9),
actor->spr.pos.Y + MulScale(k, bsin(actor->spr.ang), 9),
actor->spr.pos.Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), jaw, -40,
@ -1469,7 +1469,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
}
Collision coll;
auto sect = actor->spr.sector();
auto sect = actor->sector();
int j = clipmove(actor->spr.pos, &sect,
(MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14) * TICSPERFRAME) << 11,
(MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14) * TICSPERFRAME) << 11,
@ -1533,7 +1533,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
}
}
}
if (x < 512 && actor->spr.sector() == ps[p].cursector)
if (x < 512 && actor->sector() == ps[p].cursector)
{
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
actor->spr.xvel = 48;
@ -1550,7 +1550,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
void forcesphere(DDukeActor* actor, int forcesphere)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
if (actor->spr.yvel == 0)
{
actor->spr.yvel = 1;
@ -1605,7 +1605,7 @@ void forcesphere(DDukeActor* actor, int forcesphere)
void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int painsnd, int roamsnd, int shift, int (*getspawn)(DDukeActor* i))
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int a;
getglobalz(actor);
@ -1681,7 +1681,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
fi.shoot(actor, firelaser);
actor->spr.ang = a;
}
if (actor->temp_data[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (actor->temp_data[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
{
actor->temp_data[0] = 0;
actor->temp_data[2] = 0;
@ -1704,7 +1704,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
else
{
actor->temp_data[2]++;
if (actor->temp_data[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (actor->temp_data[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
{
actor->temp_data[0] = 1;
actor->temp_data[2] = 0;
@ -1818,7 +1818,7 @@ void ooz(DDukeActor *actor)
void reactor(DDukeActor* const actor, int REACTOR, int REACTOR2, int REACTORBURNT, int REACTOR2BURNT, int REACTORSPARK, int REACTOR2SPARK)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
if (actor->temp_data[4] == 1)
{
@ -2118,7 +2118,7 @@ void frameeffect1(DDukeActor *actor)
bool money(DDukeActor* actor, int BLOODPOOL)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
actor->spr.xvel = (krand() & 7) + bsin(actor->temp_data[0], -9);
actor->temp_data[0] += (krand() & 63);
@ -2144,7 +2144,7 @@ bool money(DDukeActor* actor, int BLOODPOOL)
deletesprite(actor);
return false;
}
int l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
int l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.pos.Z > l)
{
@ -2175,7 +2175,7 @@ bool money(DDukeActor* actor, int BLOODPOOL)
bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool floorcheck, bool zcheck1, bool zcheck2)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
if (actor->spr.xvel > 0) actor->spr.xvel--;
else actor->spr.xvel = 0;
@ -2194,7 +2194,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
if (actor->spr.zvel > 1024 && actor->spr.zvel < 1280)
{
SetActor(actor, actor->spr.pos);
sectp = actor->spr.sector();
sectp = actor->sector();
}
if (callsetsprite) SetActor(actor, actor->spr.pos);
@ -2248,7 +2248,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
actor->spr.pos.Y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.pos.Z += actor->spr.zvel;
if (floorcheck && actor->spr.pos.Z >= actor->spr.sector()->floorz)
if (floorcheck && actor->spr.pos.Z >= actor->sector()->floorz)
{
deletesprite(actor);
return false;
@ -2268,14 +2268,14 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
deletesprite(actor);
return false;
}
if ((actor->spr.sector()->floorstat & CSTAT_SECTOR_SLOPE))
if ((actor->sector()->floorstat & CSTAT_SECTOR_SLOPE))
{
deletesprite(actor);
return false;
}
actor->temp_data[2]++;
}
l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->spr.pos.Z = l - (2 << 8);
actor->spr.xvel = 0;
@ -2304,7 +2304,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
bool bloodpool(DDukeActor* actor, bool puke, int TIRE)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
if (actor->temp_data[0] == 0)
{
@ -2388,7 +2388,7 @@ bool bloodpool(DDukeActor* actor, bool puke, int TIRE)
void shell(DDukeActor* actor, bool morecheck)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
ssp(actor, CLIPMASK0);
@ -2440,7 +2440,7 @@ void shell(DDukeActor* actor, bool morecheck)
void glasspieces(DDukeActor* actor)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
makeitfall(actor);
@ -2487,7 +2487,7 @@ void glasspieces(DDukeActor* actor)
void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
if (actor->spr.xvel > 0)
actor->spr.xvel--;
@ -2496,7 +2496,7 @@ void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
if (actor->spr.zvel > 1024 && actor->spr.zvel < 1280)
{
SetActor(actor, actor->spr.pos);
sectp = actor->spr.sector();
sectp = actor->sector();
}
if (actor->spr.pos.Z < sectp->floorz - (2 << 8))
@ -2568,7 +2568,7 @@ void gutsdir(DDukeActor* actor, int gtype, int n, int p)
int r1 = krand();
int r2 = krand();
// TRANSITIONAL: owned by a player???
EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
}
}
@ -2605,7 +2605,7 @@ void handle_se00(DDukeActor* actor, int LASERLINE)
{
actor->tempang += 4;
if (actor->tempang >= 256)
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
if (actor->spr.clipdist) l = 1;
else l = -1;
}
@ -2633,7 +2633,7 @@ void handle_se00(DDukeActor* actor, int LASERLINE)
{
actor->tempang -= 4;
if (actor->tempang <= 0)
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
if (actor->spr.clipdist) l = -1;
else l = 1;
}
@ -2685,7 +2685,7 @@ void handle_se00(DDukeActor* actor, int LASERLINE)
int p;
for (p = connecthead; p >= 0; p = connectpoint2[p])
{
if (ps[p].cursector == actor->spr.sector() && ps[p].on_ground == 1)
if (ps[p].cursector == actor->sector() && ps[p].on_ground == 1)
{
ps[p].angle.addadjustment(l * q);
@ -2837,11 +2837,11 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
{
auto k = ps[p].cursector;
updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
{
ps[p].pos.X = actor->spr.pos.X;
ps[p].pos.Y = actor->spr.pos.Y;
ps[p].setCursector(actor->spr.sector());
ps[p].setCursector(actor->sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
quickkill(&ps[p]);
@ -2858,13 +2858,13 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
auto psp = ps[p].GetActor();
if (ps[p].insector() && ps[p].cursector->lotag != 2)
{
if (po[p].os == actor->spr.sector())
if (po[p].os == actor->sector())
{
po[p].opos.X += m;
po[p].opos.Y += x;
}
if (actor->spr.sector() == psp->spr.sector())
if (actor->sector() == psp->sector())
{
rotatepoint(actor->spr.pos.vec2, ps[p].pos.vec2, q, &ps[p].pos.vec2);
@ -2892,7 +2892,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
DukeSectIterator it(actor->sector());
while (auto a2 = it.Next())
{
if (a2->spr.statnum != 10 && a2->spr.sector()->lotag != 2 && a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
if (a2->spr.statnum != 10 && a2->sector()->lotag != 2 && a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
{
rotatepoint(actor->spr.pos.vec2, a2->spr.pos.vec2, q, &a2->spr.pos.vec2);
@ -2920,11 +2920,11 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
{
auto k = ps[p].cursector;
updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
{
ps[p].opos.X = ps[p].pos.X = actor->spr.pos.X;
ps[p].opos.Y = ps[p].pos.Y = actor->spr.pos.Y;
ps[p].setCursector(actor->spr.sector());
ps[p].setCursector(actor->sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
quickkill(&ps[p]);
@ -2940,9 +2940,9 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
{
if (a2->spr.statnum == 1 && badguy(a2) && a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
{
auto k = a2->spr.sector();
auto k = a2->sector();
updatesector(a2->spr.pos.X, a2->spr.pos.Y, &k);
if (a2->spr.extra >= 0 && k == actor->spr.sector())
if (a2->spr.extra >= 0 && k == actor->sector())
{
gutsdir(a2, JIBS6, 72, myconnectindex);
S_PlayActorSound(SQUISHED, actor);
@ -3021,11 +3021,11 @@ void handle_se30(DDukeActor *actor, int JIBS6)
{
auto k = ps[p].cursector;
updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
{
ps[p].pos.X = actor->spr.pos.X;
ps[p].pos.Y = actor->spr.pos.Y;
ps[p].setCursector(actor->spr.sector());
ps[p].setCursector(actor->sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
quickkill(&ps[p]);
@ -3035,7 +3035,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
{
auto psp = ps[p].GetActor();
if (psp->spr.sector() == actor->spr.sector())
if (psp->sector() == actor->sector())
{
ps[p].pos.X += l;
ps[p].pos.Y += x;
@ -3050,14 +3050,14 @@ void handle_se30(DDukeActor *actor, int JIBS6)
ps[p].bobpos.Y += x;
}
if (po[p].os == actor->spr.sector())
if (po[p].os == actor->sector())
{
po[p].opos.X += l;
po[p].opos.Y += x;
}
}
DukeSectIterator its(actor->spr.sector());
DukeSectIterator its(actor->sector());
while (auto a2 = its.Next())
{
if (a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
@ -3083,7 +3083,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
{
auto k = ps[p].cursector;
updatesector(ps[p].pos.X, ps[p].pos.Y, &k);
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
if ((k == nullptr && ud.clipping == 0) || (k == actor->sector() && ps[p].cursector != actor->sector()))
{
ps[p].pos.X = actor->spr.pos.X;
ps[p].pos.Y = actor->spr.pos.Y;
@ -3091,7 +3091,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
ps[p].opos.X = ps[p].pos.X;
ps[p].opos.Y = ps[p].pos.Y;
ps[p].setCursector(actor->spr.sector());
ps[p].setCursector(actor->sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
quickkill(&ps[p]);
@ -3107,9 +3107,9 @@ void handle_se30(DDukeActor *actor, int JIBS6)
{
// if(a2->spr.sector != actor->spr.sector)
{
auto k = a2->spr.sector();
auto k = a2->sector();
updatesector(a2->spr.pos.X, a2->spr.pos.Y, &k);
if (a2->spr.extra >= 0 && k == actor->spr.sector())
if (a2->spr.extra >= 0 && k == actor->sector())
{
gutsdir(a2, JIBS6, 24, myconnectindex);
S_PlayActorSound(SQUISHED, a2);
@ -3172,7 +3172,7 @@ void handle_se02(DDukeActor* actor)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
if (ps[p].cursector == actor->spr.sector() && ps[p].on_ground)
if (ps[p].cursector == actor->sector() && ps[p].on_ground)
{
ps[p].pos.X += m;
ps[p].pos.Y += x;
@ -3427,7 +3427,7 @@ void handle_se08(DDukeActor *actor, bool checkhitag1)
}
j = 1;
}
else j = getanimationgoal(anim_ceilingz, actor->spr.sector());
else j = getanimationgoal(anim_ceilingz, actor->sector());
if (j >= 0)
{
@ -3502,7 +3502,7 @@ void handle_se10(DDukeActor* actor, const int* specialtags)
if ((sc->lotag & 0xff) != 27)
for (int p = connecthead; p >= 0; p = connectpoint2[p])
if (sc->lotag != 30 && sc->lotag != 31 && sc->lotag != 0)
if (actor->spr.sector() == ps[p].GetActor()->spr.sector())
if (actor->sector() == ps[p].GetActor()->sector())
j = 0;
if (j == 1)
@ -3511,12 +3511,12 @@ void handle_se10(DDukeActor* actor, const int* specialtags)
{
if (specialtags) for (int i = 0; specialtags[i]; i++)
{
if (actor->spr.sector()->lotag == specialtags[i] && getanimationgoal(anim_ceilingz, actor->spr.sector()) >= 0)
if (actor->sector()->lotag == specialtags[i] && getanimationgoal(anim_ceilingz, actor->sector()) >= 0)
{
return;
}
}
fi.activatebysector(actor->spr.sector(), actor);
fi.activatebysector(actor->sector(), actor);
actor->temp_data[0] = 0;
}
else actor->temp_data[0]++;
@ -3753,7 +3753,7 @@ void handle_se15(DDukeActor* actor)
if (actor->temp_data[3] >= (actor->spr.yvel >> 3))
{
actor->temp_data[4] = 0; //Turn off the sliders
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
return;
}
actor->temp_data[3]++;
@ -3763,7 +3763,7 @@ void handle_se15(DDukeActor* actor)
if (actor->temp_data[3] < 1)
{
actor->temp_data[4] = 0;
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
return;
}
actor->temp_data[3]--;
@ -3893,10 +3893,10 @@ void handle_se17(DDukeActor* actor)
ps[p].pos.X += act2->spr.pos.X - actor->spr.pos.X;
ps[p].pos.Y += act2->spr.pos.Y - actor->spr.pos.Y;
ps[p].pos.Z = act2->spr.sector()->floorz - (sc->floorz - ps[p].pos.Z);
ps[p].pos.Z = act2->sector()->floorz - (sc->floorz - ps[p].pos.Z);
act3->floorz = act2->spr.sector()->floorz;
act3->ceilingz = act2->spr.sector()->ceilingz;
act3->floorz = act2->sector()->floorz;
act3->ceilingz = act2->sector()->ceilingz;
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y;
@ -3906,22 +3906,22 @@ void handle_se17(DDukeActor* actor)
ps[p].truecz = act3->ceilingz;
ps[p].bobcounter = 0;
ChangeActorSect(act3, act2->spr.sector());
ps[p].setCursector(act2->spr.sector());
ChangeActorSect(act3, act2->sector());
ps[p].setCursector(act2->sector());
}
else if (act3->spr.statnum != STAT_EFFECTOR)
{
act3->spr.pos.X += act2->spr.pos.X - actor->spr.pos.X;
act3->spr.pos.Y += act2->spr.pos.Y - actor->spr.pos.Y;
act3->spr.pos.Z = act2->spr.sector()->floorz - (sc->floorz - act3->spr.pos.Z);
act3->spr.pos.Z = act2->sector()->floorz - (sc->floorz - act3->spr.pos.Z);
act3->spr.backupz();
ChangeActorSect(act3, act2->spr.sector());
ChangeActorSect(act3, act2->sector());
SetActor(act3, act3->spr.pos);
act3->floorz = act2->spr.sector()->floorz;
act3->ceilingz = act2->spr.sector()->ceilingz;
act3->floorz = act2->sector()->floorz;
act3->ceilingz = act2->sector()->ceilingz;
}
}
@ -4148,7 +4148,7 @@ void handle_se20(DDukeActor* actor)
actor->spr.pos.X -= x;
actor->spr.pos.Y -= l;
actor->temp_data[0] = 0;
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
return;
}
@ -4171,7 +4171,7 @@ void handle_se20(DDukeActor* actor)
dragpoint(wal[1], wal[1]->pos.X + x, wal[1]->pos.Y + l);
for (int p = connecthead; p >= 0; p = connectpoint2[p])
if (ps[p].cursector == actor->spr.sector() && ps[p].on_ground)
if (ps[p].cursector == actor->sector() && ps[p].on_ground)
{
ps[p].pos.X += x;
ps[p].pos.Y += l;
@ -4283,7 +4283,7 @@ void handle_se26(DDukeActor* actor)
}
for (int p = connecthead; p >= 0; p = connectpoint2[p])
if (ps[p].GetActor()->sector() == actor->spr.sector() && ps[p].on_ground)
if (ps[p].GetActor()->sector() == actor->sector() && ps[p].on_ground)
{
ps[p].fric.X += l << 5;
ps[p].fric.Y += x << 5;
@ -4319,7 +4319,7 @@ void handle_se27(DDukeActor* actor)
}
else if (ud.recstat == 2 && ps[p].newOwner == nullptr)
{
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
{
if (x < sh)
{
@ -4406,7 +4406,7 @@ void handle_se24(DDukeActor *actor, const int16_t *list1, const int16_t *list2,
SetActor(a2, a2->spr.pos);
if (a2->spr.sector()->floorstat & CSTAT_SECTOR_SLOPE)
if (a2->sector()->floorstat & CSTAT_SECTOR_SLOPE)
if (a2->spr.statnum == 2)
makeitfall(a2);
}
@ -4418,7 +4418,7 @@ void handle_se24(DDukeActor *actor, const int16_t *list1, const int16_t *list2,
for (auto p = connecthead; p >= 0; p = connectpoint2[p])
{
if (ps[p].cursector == actor->spr.sector() && ps[p].on_ground)
if (ps[p].cursector == actor->sector() && ps[p].on_ground)
{
if (abs(ps[p].pos.Z - ps[p].truefz) < gs.playerheight + (9 << 8))
{
@ -4488,7 +4488,7 @@ void handle_se32(DDukeActor *actor)
if (abs(sc->ceilingz - actor->spr.pos.Z) < (actor->spr.yvel << 1))
{
sc->setceilingz(actor->spr.pos.Z);
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
actor->temp_data[2] = 0;
actor->temp_data[0] = 0;
}
@ -4499,7 +4499,7 @@ void handle_se32(DDukeActor *actor)
if (abs(sc->ceilingz - actor->temp_data[1]) < (actor->spr.yvel << 1))
{
sc->setceilingz(actor->temp_data[1]);
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
actor->temp_data[2] = 0;
actor->temp_data[0] = 0;
}
@ -4514,7 +4514,7 @@ void handle_se32(DDukeActor *actor)
{
actor->temp_data[0] = 0;
actor->temp_data[2] = !actor->temp_data[2];
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
sc->setceilingz(actor->spr.pos.Z);
}
else sc->addceilingz(Sgn(actor->spr.pos.Z - sc->ceilingz) * actor->spr.yvel);
@ -4525,7 +4525,7 @@ void handle_se32(DDukeActor *actor)
{
actor->temp_data[0] = 0;
actor->temp_data[2] = !actor->temp_data[2];
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
}
else sc->addceilingz(-Sgn(actor->spr.pos.Z - actor->temp_data[1]) * actor->spr.yvel);
}
@ -4679,7 +4679,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
actor->temp_data[2] = 0;
actor->temp_data[0] = 0;
if (choosedir) actor->temp_data[3] = actor->spr.hitag;
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
}
else
{
@ -4705,7 +4705,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
if (abs(sec->floorz - actor->temp_data[1]) < actor->spr.yvel)
{
sec->setfloorz(actor->temp_data[1]);
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
actor->temp_data[2] = 0;
actor->temp_data[0] = 0;
if (choosedir) actor->temp_data[3] = actor->spr.hitag;
@ -4736,7 +4736,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
{
if (abs(actor->spr.pos.Z - sec->floorz) < actor->spr.yvel)
{
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
actor->temp_data[0] = 0;
actor->temp_data[2] = 1;
if (choosedir) actor->temp_data[3] = actor->spr.hitag;
@ -4765,7 +4765,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
if (abs(sec->floorz - actor->temp_data[1]) < actor->spr.yvel)
{
actor->temp_data[0] = 0;
callsound(actor->spr.sector(), actor);
callsound(actor->sector(), actor);
actor->temp_data[2] = 1;
actor->temp_data[3] = actor->spr.hitag;
}
@ -4810,7 +4810,7 @@ void getglobalz(DDukeActor* actor)
auto cc = actor->spr.cstat2;
actor->spr.cstat2 |= CSTAT2_SPRITE_NOFIND; // don't clip against self. getzrange cannot detect this because it only receives a coordinate.
getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->spr.sector(), &actor->ceilingz, hz, &actor->floorz, lz, zr, CLIPMASK0);
getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->sector(), &actor->ceilingz, hz, &actor->floorz, lz, zr, CLIPMASK0);
actor->spr.cstat2 = cc;
if( lz.type == kHitSprite && (lz.actor()->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0 )
@ -4834,15 +4834,15 @@ void getglobalz(DDukeActor* actor)
}
else if(actor->spr.statnum == STAT_PROJECTILE && lz.actor()->spr.picnum == TILE_APLAYER && actor->GetOwner() == actor)
{
actor->ceilingz = actor->spr.sector()->ceilingz;
actor->floorz = actor->spr.sector()->floorz;
actor->ceilingz = actor->sector()->ceilingz;
actor->floorz = actor->sector()->floorz;
}
}
}
else
{
actor->ceilingz = actor->spr.sector()->ceilingz;
actor->floorz = actor->spr.sector()->floorz;
actor->ceilingz = actor->sector()->ceilingz;
actor->floorz = actor->sector()->floorz;
}
}
@ -4856,11 +4856,11 @@ void makeitfall(DDukeActor* actor)
{
int c;
if( fi.floorspace(actor->spr.sector()) )
if( fi.floorspace(actor->sector()) )
c = 0;
else
{
if( fi.ceilingspace(actor->spr.sector()) || actor->spr.sector()->lotag == ST_2_UNDERWATER)
if( fi.ceilingspace(actor->sector()) || actor->sector()->lotag == ST_2_UNDERWATER)
c = gs.gravity/6;
else c = gs.gravity;
}
@ -4873,17 +4873,17 @@ void makeitfall(DDukeActor* actor)
if ((actor->spr.statnum == STAT_ACTOR || actor->spr.statnum == STAT_PLAYER || actor->spr.statnum == STAT_ZOMBIEACTOR || actor->spr.statnum == STAT_STANDABLE))
{
Collision coll;
getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->spr.sector(), &actor->ceilingz, coll, &actor->floorz, coll, 127, CLIPMASK0);
getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->sector(), &actor->ceilingz, coll, &actor->floorz, coll, 127, CLIPMASK0);
}
else
{
actor->ceilingz = actor->spr.sector()->ceilingz;
actor->floorz = actor->spr.sector()->floorz;
actor->ceilingz = actor->sector()->ceilingz;
actor->floorz = actor->sector()->floorz;
}
if( actor->spr.pos.Z < actor->floorz-(FOURSLEIGHT) )
{
if( actor->spr.sector()->lotag == 2 && actor->spr.zvel > 3122 )
if( actor->sector()->lotag == 2 && actor->spr.zvel > 3122 )
actor->spr.zvel = 3144;
if(actor->spr.zvel < 6144)
actor->spr.zvel += c;
@ -4913,7 +4913,7 @@ int dodge(DDukeActor* actor)
DukeStatIterator it(STAT_PROJECTILE);
while (auto ac = it.Next())
{
if (ac->GetOwner() == ac || ac->spr.sector() != actor->spr.sector())
if (ac->GetOwner() == ac || ac->sector() != actor->sector())
continue;
bx = ac->spr.pos.X - mx;
@ -4955,7 +4955,7 @@ int furthestangle(DDukeActor *actor, int angs)
for (j = actor->spr.ang; j < (2048 + actor->spr.ang); j += angincs)
{
hitscan({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8) }, actor->spr.sector(), { bcos(j), bsin(j), 0 }, hit, CLIPMASK1);
hitscan({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8) }, actor->sector(), { bcos(j), bsin(j), 0 }, hit, CLIPMASK1);
d = abs(hit.hitpos.X - actor->spr.pos.X) + abs(hit.hitpos.Y - actor->spr.pos.Y);
@ -4988,13 +4988,13 @@ int furthestcanseepoint(DDukeActor *actor, DDukeActor* tosee, int* dax, int* day
for (j = tosee->spr.ang; j < (2048 + tosee->spr.ang); j += (angincs - (krand() & 511)))
{
hitscan({ tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - (16 << 8) }, tosee->spr.sector(), { bcos(j), bsin(j), 16384 - (krand() & 32767) }, hit, CLIPMASK1);
hitscan({ tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - (16 << 8) }, tosee->sector(), { bcos(j), bsin(j), 16384 - (krand() & 32767) }, hit, CLIPMASK1);
d = abs(hit.hitpos.X - tosee->spr.pos.X) + abs(hit.hitpos.Y - tosee->spr.pos.Y);
da = abs(hit.hitpos.X - actor->spr.pos.X) + abs(hit.hitpos.Y - actor->spr.pos.Y);
if (d < da && hit.hitSector)
if (cansee(hit.hitpos.X, hit.hitpos.Y, hit.hitpos.Z, hit.hitSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->spr.sector()))
if (cansee(hit.hitpos.X, hit.hitpos.Y, hit.hitpos.Z, hit.hitSector, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (16 << 8), actor->sector()))
{
*dax = hit.hitpos.X;
*day = hit.hitpos.Y;
@ -5032,7 +5032,7 @@ void alterang(int ang, DDukeActor* actor, int playernum)
// NOTE: looks like 'Owner' is set to target sprite ID...
if (holoduke && cansee(holoduke->spr.pos.X, holoduke->spr.pos.Y, holoduke->spr.pos.Z, holoduke->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector()))
if (holoduke && cansee(holoduke->spr.pos.X, holoduke->spr.pos.Y, holoduke->spr.pos.Z, holoduke->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
actor->SetOwner(holoduke);
else actor->SetOwner(ps[playernum].GetActor());
@ -5098,16 +5098,16 @@ void fall_common(DDukeActor *actor, int playernum, int JIBS6, int DRONE, int BLO
int c;
int sphit = fallspecial? fallspecial(actor, playernum) : 0;
if (fi.floorspace(actor->spr.sector()))
if (fi.floorspace(actor->sector()))
c = 0;
else
{
if (fi.ceilingspace(actor->spr.sector()) || actor->spr.sector()->lotag == 2)
if (fi.ceilingspace(actor->sector()) || actor->sector()->lotag == 2)
c = gs.gravity / 6;
else c = gs.gravity;
}
if (actor->cgg <= 0 || (actor->spr.sector()->floorstat & CSTAT_SECTOR_SLOPE))
if (actor->cgg <= 0 || (actor->sector()->floorstat & CSTAT_SECTOR_SLOPE))
{
getglobalz(actor);
actor->cgg = 6;
@ -5153,18 +5153,18 @@ void fall_common(DDukeActor *actor, int playernum, int JIBS6, int DRONE, int BLO
actor->extra = 1;
actor->spr.zvel = 0;
}
else if (actor->spr.zvel > 2048 && actor->spr.sector()->lotag != 1)
else if (actor->spr.zvel > 2048 && actor->sector()->lotag != 1)
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
pushmove(&actor->spr.pos, &sect, 128, (4 << 8), (4 << 8), CLIPMASK0);
if (sect != actor->spr.sector() && sect != nullptr)
if (sect != actor->sector() && sect != nullptr)
ChangeActorSect(actor, sect);
S_PlayActorSound(thud, actor);
}
}
if (actor->spr.sector()->lotag == 1)
if (actor->sector()->lotag == 1)
actor->spr.pos.Z += gs.actorinfo[actor->spr.picnum].falladjustz;
else actor->spr.zvel = 0;
}
@ -5182,7 +5182,7 @@ DDukeActor *LocateTheLocator(int n, sectortype* sect)
DukeStatIterator it(STAT_LOCATOR);
while (auto ac = it.Next())
{
if ((sect == nullptr || sect == ac->spr.sector()) && n == ac->spr.lotag)
if ((sect == nullptr || sect == ac->sector()) && n == ac->spr.lotag)
return ac;
}
return nullptr;

144
source/games/duke/src/actors_d.cpp
View file

@ -221,7 +221,7 @@ bool ifsquished(DDukeActor* actor, int p)
if (actor->spr.picnum == APLAYER && ud.clipping)
return false;
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int floorceildist = sectp->floorz - sectp->ceilingz;
if (sectp->lotag != ST_23_SWINGING_DOOR)
@ -263,7 +263,7 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if(actor->spr.picnum != SHRINKSPARK && !(actor->spr.picnum == RPG && actor->spr.xrepeat < 11))
{
BFSSectorSearch search(actor->spr.sector());
BFSSectorSearch search(actor->sector());
while (auto dasectp = search.GetNext())
{
@ -294,7 +294,7 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
int y1 = (((wal.pos.Y + wal.point2Wall()->pos.Y) >> 1) + actor->spr.pos.Y) >> 1;
sectortype* sect = wal.sectorp();
updatesector(x1, y1, &sect);
if (sect && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector()))
if (sect && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
fi.checkhitwall(actor, &wal, wal.pos.X, wal.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
}
}
@ -327,7 +327,7 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (actor->spr.picnum != SHRINKSPARK || (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL))
if (dist(actor, act2) < r)
{
if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->spr.sector()))
if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->sector()))
continue;
fi.checkhitsprite(act2, actor);
}
@ -347,7 +347,7 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
int d = dist(actor, act2);
if (act2->spr.picnum == APLAYER) act2->spr.pos.Z += gs.playerheight;
if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->spr.sector()))
if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->sector()))
{
act2->ang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
@ -449,7 +449,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
return result.setNone();
}
auto dasectp = actor->spr.sector();
auto dasectp = actor->sector();
vec3_t pos = actor->spr.pos;
pos.Z -= ((tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 1);
@ -500,7 +500,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
actor->spr.pos.Y = pos.Y;
if (dasectp != nullptr)
if (dasectp != actor->spr.sector())
if (dasectp != actor->sector())
ChangeActorSect(actor, dasectp);
int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
@ -549,7 +549,7 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
else sx = sy = 32;
gutz = actor->spr.pos.Z - (8 << 8);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -573,7 +573,7 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
int r4 = krand();
int r5 = krand();
// TRANSITIONAL: owned by a player???
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
auto spawned = EGS(actor->sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
if (spawned)
{
if (spawned->spr.picnum == JIBS2)
@ -606,7 +606,7 @@ void movefta_d(void)
{
p = findplayer(act, &x);
ssect = psect = act->spr.sector();
ssect = psect = act->sector();
auto pa = ps[p].GetActor();
if (pa->spr.extra > 0)
@ -635,13 +635,13 @@ void movefta_d(void)
int r1 = krand();
int r2 = krand();
j = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->spr.sector(), px, py, ps[p].opos.Z - (r1 % (32 << 8)), ps[p].cursector);
j = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->sector(), px, py, ps[p].opos.Z - (r1 % (32 << 8)), ps[p].cursector);
}
else
{
int r1 = krand();
int r2 = krand();
j = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->spr.sector(), ps[p].opos.X, ps[p].opos.Y, ps[p].opos.Z - ((r1 & 31) << 8), ps[p].cursector);
j = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->sector(), ps[p].opos.X, ps[p].opos.Y, ps[p].opos.Z - ((r1 & 31) << 8), ps[p].cursector);
}
@ -661,9 +661,9 @@ void movefta_d(void)
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
case TRIPBOMB:
if (act->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->spr.sector()->ceilingshade;
else act->spr.shade = act->spr.sector()->floorshade;
if (act->sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->sector()->ceilingshade;
else act->spr.shade = act->sector()->floorshade;
act->timetosleep = 0;
ChangeActorStat(act, STAT_STANDABLE);
@ -680,9 +680,9 @@ void movefta_d(void)
}
if (badguy(act))
{
if (act->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->spr.sector()->ceilingshade;
else act->spr.shade = act->spr.sector()->floorshade;
if (act->sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->sector()->ceilingshade;
else act->spr.shade = act->sector()->floorshade;
}
}
}
@ -699,7 +699,7 @@ DDukeActor* ifhitsectors_d(sectortype* sect)
DukeStatIterator it(STAT_MISC);
while (auto a1 = it.Next())
{
if (a1->spr.picnum == EXPLOSION2 && sect == a1->spr.sector())
if (a1->spr.picnum == EXPLOSION2 && sect == a1->sector())
return a1;
}
return nullptr;
@ -833,7 +833,7 @@ void movefallers_d(void)
DukeStatIterator iti(STAT_FALLER);
while (auto act = iti.Next())
{
auto sectp = act->spr.sector();
auto sectp = act->sector();
if (act->temp_data[0] == 0)
{
@ -889,10 +889,10 @@ void movefallers_d(void)
ssp(act, CLIPMASK0);
}
if (fi.floorspace(act->spr.sector())) x = 0;
if (fi.floorspace(act->sector())) x = 0;
else
{
if (fi.ceilingspace(act->spr.sector()))
if (fi.ceilingspace(act->sector()))
x = gs.gravity / 6;
else
x = gs.gravity;
@ -1005,8 +1005,8 @@ static void movetripbomb(DDukeActor *actor)
actor->spr.pos.Z -= (3 << 8);
// Laser fix from EDuke32.
auto const oldSect = actor->spr.sector();
auto curSect = actor->spr.sector();
auto const oldSect = actor->sector();
auto curSect = actor->sector();
updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
ChangeActorSect(actor, curSect);
@ -1135,7 +1135,7 @@ static void movefireext(DDukeActor* actor)
for (int k = 0; k < 16; k++)
{
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
if(spawned) spawned->spr.pal = 2;
}
@ -1200,7 +1200,7 @@ static void moveviewscreen(DDukeActor* actor)
static void movesidebolt(DDukeActor* actor)
{
int x;
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
findplayer(actor, &x);
if (x > 20480) return;
@ -1241,7 +1241,7 @@ CLEAR_THE_BOLT2:
static void movebolt(DDukeActor *actor)
{
int x;
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
findplayer(actor, &x);
if (x > 20480) return;
@ -1427,7 +1427,7 @@ static bool movefireball(DDukeActor* actor)
{
auto Owner = actor->GetOwner();
if (actor->spr.sector()->lotag == 2)
if (actor->sector()->lotag == 2)
{
deletesprite(actor);
return true;
@ -1587,14 +1587,14 @@ static bool weaponhitsector(DDukeActor* proj, const vec3_t& oldpos, bool firebal
if (proj->spr.zvel < 0)
{
if (proj->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (proj->spr.sector()->ceilingpal == 0)
if (proj->sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (proj->sector()->ceilingpal == 0)
{
deletesprite(proj);
return true;
}
fi.checkhitceiling(proj->spr.sector());
fi.checkhitceiling(proj->sector());
}
else if (fireball)
{
@ -1639,7 +1639,7 @@ static void weaponcommon_d(DDukeActor* proj)
int k, ll;
vec3_t oldpos = proj->spr.pos;
if (proj->spr.picnum == RPG && proj->spr.sector()->lotag == 2)
if (proj->spr.picnum == RPG && proj->sector()->lotag == 2)
{
k = proj->spr.xvel >> 1;
ll = proj->spr.zvel >> 1;
@ -1655,7 +1655,7 @@ static void weaponcommon_d(DDukeActor* proj)
switch (proj->spr.picnum)
{
case RPG:
if (proj->attackertype != BOSS2 && proj->spr.xrepeat >= 10 && proj->spr.sector()->lotag != 2)
if (proj->attackertype != BOSS2 && proj->spr.xrepeat >= 10 && proj->sector()->lotag != 2)
{
auto spawned = spawn(proj, SMALLSMOKE);
if (spawned) spawned->spr.pos.Z += (1 << 8);
@ -1686,15 +1686,15 @@ static void weaponcommon_d(DDukeActor* proj)
{
if (proj->spr.pos.Z < proj->ceilingz)
{
coll.setSector(proj->spr.sector());
coll.setSector(proj->sector());
proj->spr.zvel = -1;
}
else
if ((proj->spr.pos.Z > proj->floorz && proj->spr.sector()->lotag != 1) ||
(proj->spr.pos.Z > proj->floorz + (16 << 8) && proj->spr.sector()->lotag == 1))
if ((proj->spr.pos.Z > proj->floorz && proj->sector()->lotag != 1) ||
(proj->spr.pos.Z > proj->floorz + (16 << 8) && proj->sector()->lotag == 1))
{
coll.setSector(proj->spr.sector());
if (proj->spr.sector()->lotag != 1)
coll.setSector(proj->sector());
if (proj->sector()->lotag != 1)
proj->spr.zvel = 1;
}
}
@ -1703,7 +1703,7 @@ static void weaponcommon_d(DDukeActor* proj)
{
for (k = -3; k < 2; k++)
{
auto spawned = EGS(proj->spr.sector(),
auto spawned = EGS(proj->sector(),
proj->spr.pos.X + MulScale(k, bcos(proj->spr.ang), 9),
proj->spr.pos.Y + MulScale(k, bsin(proj->spr.ang), 9),
proj->spr.pos.Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
@ -1794,7 +1794,7 @@ static void weaponcommon_d(DDukeActor* proj)
return;
}
}
else if (proj->spr.picnum == RPG && proj->spr.sector()->lotag == 2 && proj->spr.xrepeat >= 10 && rnd(140))
else if (proj->spr.picnum == RPG && proj->sector()->lotag == 2 && proj->spr.xrepeat >= 10 && rnd(140))
spawn(proj, WATERBUBBLE);
}
@ -1884,7 +1884,7 @@ void movetransports_d(void)
continue;
}
auto sectp = act->spr.sector();
auto sectp = act->sector();
int sectlotag = sectp->lotag;
int onfloorz = act->temp_data[4];
@ -1934,7 +1934,7 @@ void movetransports_d(void)
ps[p].opos.Z = ps[p].pos.Z = Owner->spr.pos.Z - gs.playerheight;
ChangeActorSect(act2, Owner->sector());
ps[p].setCursector(act2->spr.sector());
ps[p].setCursector(act2->sector());
if (act->spr.pal == 0)
{
@ -2119,7 +2119,7 @@ void movetransports_d(void)
case 0:
if (onfloorz)
{
if (act2->spr.statnum == STAT_PROJECTILE || (checkcursectnums(act->spr.sector()) == -1 && checkcursectnums(Owner->spr.sector()) == -1))
if (act2->spr.statnum == STAT_PROJECTILE || (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1))
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
@ -2198,7 +2198,7 @@ void movetransports_d(void)
static void greenslime(DDukeActor *actor)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int j;
// #ifndef isShareware()
@ -2256,7 +2256,7 @@ static void greenslime(DDukeActor *actor)
return;
for (j = 16; j >= 0; j--)
{
auto k = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
k->spr.pal = 1;
}
ps[p].actors_killed++;
@ -2294,7 +2294,7 @@ static void greenslime(DDukeActor *actor)
{
for (x = 0; x < 8; x++)
{
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
spawned->spr.pal = 6;
}
@ -2409,7 +2409,7 @@ static void greenslime(DDukeActor *actor)
for (x = 0; x < 8; x++)
{
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
if (spawned) spawned->spr.pal = 6;
}
actor->temp_data[0] = -3;
@ -2597,7 +2597,7 @@ static void greenslime(DDukeActor *actor)
static void flamethrowerflame(DDukeActor *actor)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int x;
int p = findplayer(actor, &x);
execute(actor, p, x);
@ -2643,14 +2643,14 @@ static void flamethrowerflame(DDukeActor *actor)
{
if (actor->spr.pos.Z < actor->ceilingz)
{
coll.setSector(actor->spr.sector());
coll.setSector(actor->sector());
actor->spr.zvel = -1;
}
else if ((actor->spr.pos.Z > actor->floorz && actor->spr.sector()->lotag != 1)
|| (actor->spr.pos.Z > actor->floorz + (16 << 8) && actor->spr.sector()->lotag == 1))
else if ((actor->spr.pos.Z > actor->floorz && actor->sector()->lotag != 1)
|| (actor->spr.pos.Z > actor->floorz + (16 << 8) && actor->sector()->lotag == 1))
{
coll.setSector(actor->spr.sector());
if (actor->spr.sector()->lotag != 1)
coll.setSector(actor->sector());
if (actor->sector()->lotag != 1)
actor->spr.zvel = 1;
}
}
@ -2672,7 +2672,7 @@ static void flamethrowerflame(DDukeActor *actor)
{
SetActor(actor, { dax, day, daz });
if (actor->spr.zvel < 0)
fi.checkhitceiling(actor->spr.sector());
fi.checkhitceiling(actor->sector());
}
if (actor->spr.xrepeat >= 10)
@ -2697,7 +2697,7 @@ static void flamethrowerflame(DDukeActor *actor)
static void heavyhbomb(DDukeActor *actor)
{
auto Owner = actor->GetOwner();
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int x, l;
if ((actor->spr.cstat & CSTAT_SPRITE_INVISIBLE))
@ -2739,7 +2739,7 @@ static void heavyhbomb(DDukeActor *actor)
if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
S_PlayActorSound(PIPEBOMB_BOUNCE, actor);
actor->spr.zvel = -((4 - actor->spr.yvel) << 8);
if (actor->spr.sector()->lotag == 2)
if (actor->sector()->lotag == 2)
actor->spr.zvel >>= 2;
actor->spr.yvel++;
}
@ -2756,7 +2756,7 @@ static void heavyhbomb(DDukeActor *actor)
MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14),
actor->spr.zvel, CLIPMASK0, coll);
if (actor->spr.sector()->lotag == 1 && actor->spr.zvel == 0)
if (actor->sector()->lotag == 1 && actor->spr.zvel == 0)
{
actor->spr.pos.Z += (32 << 8);
if (actor->temp_data[5] == 0)
@ -2860,7 +2860,7 @@ DETONATEB:
}
}
else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && actor->temp_data[0] > 7 && actor->spr.xvel == 0)
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (ps[p].ammo_amount[HANDBOMB_WEAPON] < gs.max_ammo_amount[HANDBOMB_WEAPON])
{
if (ud.coop >= 1 && Owner == actor)
@ -2918,7 +2918,7 @@ void moveactors_d(void)
DukeStatIterator it(STAT_ACTOR);
while (auto act = it.Next())
{
auto sectp = act->spr.sector();
auto sectp = act->sector();
if (act->spr.xrepeat == 0 || sectp == nullptr)
{
@ -3144,7 +3144,7 @@ void moveexplosions_d(void) // STATNUM 5
continue;
}
auto sectp = act->spr.sector();
auto sectp = act->sector();
switch (act->spr.picnum)
{
@ -3230,7 +3230,7 @@ void moveexplosions_d(void) // STATNUM 5
case MONEY + 1:
case MAIL + 1:
case PAPER + 1:
act->floorz = act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
act->floorz = act->spr.pos.Z = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
break;
case MONEY:
case MAIL:
@ -3408,7 +3408,7 @@ static void handle_se28(DDukeActor* actor)
}
else if (actor->temp_data[2] > (actor->temp_data[1] >> 3) && actor->temp_data[2] < (actor->temp_data[1] >> 2))
{
int j = !!cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
int j = !!cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
if (rnd(192) && (actor->temp_data[2] & 1))
{
@ -3637,7 +3637,7 @@ void moveeffectors_d(void) //STATNUM 3
auto sc = act->sector();
if (sc->wallnum != 4) continue;
auto wal = sc->firstWall() + 2;
alignflorslope(act->spr.sector(), wal->pos.X, wal->pos.Y, wal->nextSector()->floorz);
alignflorslope(act->sector(), wal->pos.X, wal->pos.Y, wal->nextSector()->floorz);
}
}
@ -3738,14 +3738,14 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (actor->spr.picnum == COMMANDER)
{
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.pos.Z > (l - (8 << 8)))
{
if (actor->spr.pos.Z > (l - (8 << 8))) actor->spr.pos.Z = l - (8 << 8);
actor->spr.zvel = 0;
}
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (80 << 8))
{
actor->spr.pos.Z = l + (80 << 8);
@ -3756,13 +3756,13 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (actor->spr.zvel > 0)
{
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.pos.Z > (l - (30 << 8)))
actor->spr.pos.Z = l - (30 << 8);
}
else
{
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (50 << 8))
{
actor->spr.pos.Z = l + (50 << 8);
@ -3777,7 +3777,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
actor->spr.pos.Z = actor->floorz;
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (66 << 8))
{
actor->spr.pos.Z = l + (66 << 8);
@ -3835,11 +3835,11 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (a)
{
if (actor->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
actor->spr.shade += (actor->spr.sector()->ceilingshade - actor->spr.shade) >> 1;
else actor->spr.shade += (actor->spr.sector()->floorshade - actor->spr.shade) >> 1;
if (actor->sector()->ceilingstat & CSTAT_SECTOR_SKY)
actor->spr.shade += (actor->sector()->ceilingshade - actor->spr.shade) >> 1;
else actor->spr.shade += (actor->sector()->floorshade - actor->spr.shade) >> 1;
if (actor->spr.sector()->floorpicnum == MIRROR)
if (actor->sector()->floorpicnum == MIRROR)
deletesprite(actor);
}
}

8
source/games/duke/src/actors_lava.cpp
View file

@ -128,8 +128,8 @@ void addtorch(DDukeActor* actor)
if (torchcnt >= 64)
I_Error("Too many torch effects");
torchsector[torchcnt] = actor->spr.sector();
torchsectorshade[torchcnt] = actor->spr.sector()->floorshade;
torchsector[torchcnt] = actor->sector();
torchsectorshade[torchcnt] = actor->sector()->floorshade;
torchtype[torchcnt] = actor->spr.lotag;
torchcnt++;
}
@ -139,8 +139,8 @@ void addlightning(DDukeActor* actor)
if (lightnincnt >= 64)
I_Error("Too many lightnin effects");
lightninsector[lightnincnt] = actor->spr.sector();
lightninsectorshade[lightnincnt] = actor->spr.sector()->floorshade;
lightninsector[lightnincnt] = actor->sector();
lightninsectorshade[lightnincnt] = actor->sector()->floorshade;
lightnincnt++;
}

184
source/games/duke/src/actors_r.cpp
View file

@ -221,7 +221,7 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (actor->spr.xrepeat >= 11 || !(actor->spr.picnum == RPG || ((isRRRA()) && actor->spr.picnum == RPG2)))
{
BFSSectorSearch search(actor->spr.sector());
BFSSectorSearch search(actor->sector());
while (auto dasectp = search.GetNext())
{
@ -252,7 +252,7 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
int y1 = (((wal.pos.Y + wal.point2Wall()->pos.Y) >> 1) + actor->spr.pos.Y) >> 1;
auto sect = wal.sectorp();
updatesector(x1, y1, &sect);
if (sect != nullptr && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector()))
if (sect != nullptr && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
fi.checkhitwall(actor, &wal, wal.pos.X, wal.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
}
}
@ -272,7 +272,7 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL)
if (dist(actor, act2) < r)
{
if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->spr.sector()))
if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->sector()))
{
continue;
}
@ -294,7 +294,7 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
int d = dist(actor, act2);
if (act2->spr.picnum == APLAYER) act2->spr.pos.Z += gs.playerheight;
if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->spr.sector()))
if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->sector()))
{
if ((isRRRA()) && act2->spr.picnum == MINION && act2->spr.pal == 19)
{
@ -378,7 +378,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
return result.setNone();
}
auto dasectp = actor->spr.sector();
auto dasectp = actor->sector();
vec3_t pos = actor->spr.pos;
pos.Z -= ((tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 1);
@ -416,7 +416,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
actor->spr.pos.Y = pos.Y;
if (dasectp)
if ((dasectp != actor->spr.sector()))
if ((dasectp != actor->sector()))
ChangeActorSect(actor, dasectp);
int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
@ -457,7 +457,7 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
else sx = sy = 32;
gutz = actor->spr.pos.Z - (8 << 8);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -485,7 +485,7 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
int r4 = krand();
int r5 = krand();
// TRANSITIONAL: owned by a player???
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
auto spawned = EGS(actor->sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
if (spawned && pal != 0)
spawned->spr.pal = pal;
}
@ -510,7 +510,7 @@ void movefta_r(void)
p = findplayer(act, &x);
j = 0;
ssect = psect = act->spr.sector();
ssect = psect = act->sector();
if (ps[p].GetActor()->spr.extra > 0)
{
@ -544,14 +544,14 @@ void movefta_r(void)
{
int r1 = krand();
int r2 = krand();
j = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->spr.sector(), px, py, ps[p].opos.Z - (r1 % (32 << 8)), ps[p].cursector);
j = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->sector(), px, py, ps[p].opos.Z - (r1 % (32 << 8)), ps[p].cursector);
}
}
else
{
int r1 = krand();
int r2 = krand();
j = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->spr.sector(), ps[p].opos.X, ps[p].opos.Y, ps[p].opos.Z - ((r1 & 31) << 8), ps[p].cursector);
j = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->sector(), ps[p].opos.X, ps[p].opos.Y, ps[p].opos.Z - ((r1 & 31) << 8), ps[p].cursector);
}
@ -567,9 +567,9 @@ void movefta_r(void)
case NUKEBARREL:
case NUKEBARRELDENTED:
case NUKEBARRELLEAKED:
if (act->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->spr.sector()->ceilingshade;
else act->spr.shade = act->spr.sector()->floorshade;
if (act->sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->sector()->ceilingshade;
else act->spr.shade = act->sector()->floorshade;
act->timetosleep = 0;
ChangeActorStat(act, STAT_STANDABLE);
@ -589,9 +589,9 @@ void movefta_r(void)
}
if (/*!j &&*/ badguy(act)) // this is like RedneckGDX. j is uninitialized here, i.e. most likely not 0.
{
if (act->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->spr.sector()->ceilingshade;
else act->spr.shade = act->spr.sector()->floorshade;
if (act->sector()->ceilingstat & CSTAT_SECTOR_SKY)
act->spr.shade = act->sector()->ceilingshade;
else act->spr.shade = act->sector()->floorshade;
if (act->spr.picnum == HEN || act->spr.picnum == COW || act->spr.picnum == PIG || act->spr.picnum == DOGRUN || ((isRRRA()) && act->spr.picnum == RABBIT))
{
@ -619,7 +619,7 @@ DDukeActor* ifhitsectors_r(sectortype* sect)
DukeStatIterator it(STAT_MISC);
while (auto a1 = it.Next())
{
if (a1->spr.picnum == EXPLOSION2 || (a1->spr.picnum == EXPLOSION3 && sect == a1->spr.sector()))
if (a1->spr.picnum == EXPLOSION2 || (a1->spr.picnum == EXPLOSION3 && sect == a1->sector()))
return a1;
}
return nullptr;
@ -774,7 +774,7 @@ void movefallers_r(void)
DukeStatIterator it(STAT_FALLER);
while (auto act = it.Next())
{
auto sectp = act->spr.sector();
auto sectp = act->sector();
if (act->temp_data[0] == 0)
{
@ -828,10 +828,10 @@ void movefallers_r(void)
}
int x;
if (fi.floorspace(act->spr.sector())) x = 0;
if (fi.floorspace(act->sector())) x = 0;
else
{
if (fi.ceilingspace(act->spr.sector()))
if (fi.ceilingspace(act->sector()))
x = gs.gravity / 6;
else
x = gs.gravity;
@ -903,7 +903,7 @@ static void movecrack(DDukeActor* actor)
static void movebolt(DDukeActor* actor)
{
int x;
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
findplayer(actor, &x);
if (x > 20480) return;
@ -1066,7 +1066,7 @@ void movestandables_r(void)
static void chickenarrow(DDukeActor* actor)
{
actor->spr.hitag++;
if (actor->attackertype != BOSS2 && actor->spr.xrepeat >= 10 && actor->spr.sector()->lotag != 2)
if (actor->attackertype != BOSS2 && actor->spr.xrepeat >= 10 && actor->sector()->lotag != 2)
{
auto spawned = spawn(actor, SMALLSMOKE);
if (spawned) spawned->spr.pos.Z += (1 << 8);
@ -1285,14 +1285,14 @@ bool weaponhitsector(DDukeActor *proj, const vec3_t& oldpos)
if (proj->spr.zvel < 0)
{
if (proj->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (proj->spr.sector()->ceilingpal == 0)
if (proj->sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (proj->sector()->ceilingpal == 0)
{
deletesprite(proj);
return true;
}
fi.checkhitceiling(proj->spr.sector());
fi.checkhitceiling(proj->sector());
}
if (!isRRRA() && proj->spr.picnum == FREEZEBLAST)
@ -1323,12 +1323,12 @@ static void weaponcommon_r(DDukeActor *proj)
p = -1;
if (proj->spr.picnum == RPG && proj->spr.sector()->lotag == 2)
if (proj->spr.picnum == RPG && proj->sector()->lotag == 2)
{
k = proj->spr.xvel >> 1;
ll = proj->spr.zvel >> 1;
}
else if (isRRRA() && proj->spr.picnum == RPG2 && proj->spr.sector()->lotag == 2)
else if (isRRRA() && proj->spr.picnum == RPG2 && proj->sector()->lotag == 2)
{
k = proj->spr.xvel >> 1;
ll = proj->spr.zvel >> 1;
@ -1346,7 +1346,7 @@ static void weaponcommon_r(DDukeActor *proj)
switch (proj->spr.picnum)
{
case RPG:
if (proj->attackertype != BOSS2 && proj->spr.xrepeat >= 10 && proj->spr.sector()->lotag != 2)
if (proj->attackertype != BOSS2 && proj->spr.xrepeat >= 10 && proj->sector()->lotag != 2)
{
spawn(proj, SMALLSMOKE)->spr.pos.Z += (1 << 8);
}
@ -1365,7 +1365,7 @@ static void weaponcommon_r(DDukeActor *proj)
}
else
makeitfall(proj);
if (proj->spr.xrepeat >= 10 && proj->spr.sector()->lotag != 2)
if (proj->spr.xrepeat >= 10 && proj->sector()->lotag != 2)
{
spawn(proj, SMALLSMOKE)->spr.pos.Z += (1 << 8);
}
@ -1381,7 +1381,7 @@ static void weaponcommon_r(DDukeActor *proj)
if (FindDistance2D(proj->spr.pos.vec2 - proj->temp_actor->spr.pos.vec2) < 256)
coll.setSprite(proj->temp_actor);
if (!proj->insector()) // || (isRR() && proj->spr.sector()->filler == 800))
if (!proj->insector()) // || (isRR() && proj->sector()->filler == 800))
{
deletesprite(proj);
return;
@ -1391,14 +1391,14 @@ static void weaponcommon_r(DDukeActor *proj)
{
if (proj->spr.pos.Z < proj->ceilingz)
{
coll.setSector(proj->spr.sector());
coll.setSector(proj->sector());
proj->spr.zvel = -1;
}
else
if (proj->spr.pos.Z > proj->floorz)
{
coll.setSector(proj->spr.sector());
if (proj->spr.sector()->lotag != 1)
coll.setSector(proj->sector());
if (proj->sector()->lotag != 1)
proj->spr.zvel = 1;
}
}
@ -1407,7 +1407,7 @@ static void weaponcommon_r(DDukeActor *proj)
{
for (k = -3; k < 2; k++)
{
auto x = EGS(proj->spr.sector(),
auto x = EGS(proj->sector(),
proj->spr.pos.X + MulScale(k, bcos(proj->spr.ang), 9),
proj->spr.pos.Y + MulScale(k, bsin(proj->spr.ang), 9),
proj->spr.pos.Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
@ -1463,7 +1463,7 @@ static void weaponcommon_r(DDukeActor *proj)
deletesprite(proj);
return;
}
if ((proj->spr.picnum == RPG || (isRRRA() && proj->spr.picnum == RPG2)) && proj->spr.sector()->lotag == 2 && proj->spr.xrepeat >= 10 && rnd(184))
if ((proj->spr.picnum == RPG || (isRRRA() && proj->spr.picnum == RPG2)) && proj->sector()->lotag == 2 && proj->spr.xrepeat >= 10 && rnd(184))
spawn(proj, WATERBUBBLE);
}
@ -1552,7 +1552,7 @@ void movetransports_r(void)
DukeStatIterator iti(STAT_TRANSPORT);
while (auto act = iti.Next())
{
auto sectp = act->spr.sector();
auto sectp = act->sector();
sectlotag = sectp->lotag;
auto Owner = act->GetOwner();
@ -1606,7 +1606,7 @@ void movetransports_r(void)
ps[p].opos.Z = ps[p].pos.Z = Owner->spr.pos.Z - (gs.playerheight - (4 << 8));
ChangeActorSect(act2, Owner->sector());
ps[p].setCursector(act2->spr.sector());
ps[p].setCursector(act2->sector());
auto beam = spawn(Owner, TRANSPORTERBEAM);
if (beam) S_PlayActorSound(TELEPORTER, beam);
@ -1815,7 +1815,7 @@ void movetransports_r(void)
case ST_0_NO_EFFECT:
if (onfloorz)
{
if (checkcursectnums(act->spr.sector()) == -1 && checkcursectnums(Owner->spr.sector()) == -1)
if (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1)
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
@ -2061,7 +2061,7 @@ static void rrra_specialstats()
act->spr.extra = 1;
}
movesprite_ex(act, 0, 0, -300, CLIPMASK0, coll);
if (act->spr.sector()->ceilingz + (4 << 8) > act->spr.pos.Z)
if (act->sector()->ceilingz + (4 << 8) > act->spr.pos.Z)
{
act->spr.picnum = 0;
act->spr.extra = 100;
@ -2069,7 +2069,7 @@ static void rrra_specialstats()
}
else if (act->spr.extra == 200)
{
SetActor(act, { act->spr.pos.X, act->spr.pos.Y, act->spr.sector()->floorz - 10 });
SetActor(act, { act->spr.pos.X, act->spr.pos.Y, act->sector()->floorz - 10 });
act->spr.extra = 1;
act->spr.picnum = PIG + 11;
spawn(act, TRANSPORTERSTAR);
@ -2293,8 +2293,8 @@ void rr_specialstats()
if (act->spr.hitag == 100)
{
act->spr.pos.Z += (4 << 8);
if (act->spr.pos.Z >= act->spr.sector()->floorz + 15168)
act->spr.pos.Z = act->spr.sector()->floorz + 15168;
if (act->spr.pos.Z >= act->sector()->floorz + 15168)
act->spr.pos.Z = act->sector()->floorz + 15168;
}
if (act->spr.picnum == LUMBERBLADE)
@ -2303,7 +2303,7 @@ void rr_specialstats()
if (act->spr.extra == 192)
{
act->spr.hitag = 0;
act->spr.pos.Z = act->spr.sector()->floorz - 15168;
act->spr.pos.Z = act->sector()->floorz - 15168;
act->spr.extra = 0;
act->spr.picnum = RRTILE3410;
DukeStatIterator it2(STAT_DEFAULT);
@ -2410,13 +2410,13 @@ void rr_specialstats()
if (act->spr.picnum == BOWLINGPINSPOT)
if (act->spr.lotag == 100)
{
auto pst = pinsectorresetup(act->spr.sector());
auto pst = pinsectorresetup(act->sector());
if (pst)
{
act->spr.lotag = 0;
if (act->spr.extra == 1)
{
pst = checkpins(act->spr.sector());
pst = checkpins(act->sector());
if (!pst)
{
act->spr.extra = 2;
@ -2425,7 +2425,7 @@ void rr_specialstats()
if (act->spr.extra == 2)
{
act->spr.extra = 0;
resetpins(act->spr.sector());
resetpins(act->sector());
}
}
}
@ -2469,7 +2469,7 @@ void rr_specialstats()
static void heavyhbomb(DDukeActor *actor)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int x, l;
auto Owner = actor->GetOwner();
@ -2520,7 +2520,7 @@ static void heavyhbomb(DDukeActor *actor)
}
}
actor->spr.zvel = -((4 - actor->spr.yvel) << 8);
if (actor->spr.sector()->lotag == 2)
if (actor->sector()->lotag == 2)
actor->spr.zvel >>= 2;
actor->spr.yvel++;
}
@ -2536,7 +2536,7 @@ static void heavyhbomb(DDukeActor *actor)
MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14),
actor->spr.zvel, CLIPMASK0, coll);
if (actor->spr.sector()->lotag == 1 && actor->spr.zvel == 0)
if (actor->sector()->lotag == 1 && actor->spr.zvel == 0)
{
actor->spr.pos.Z += (32 << 8);
if (actor->temp_data[5] == 0)
@ -2620,7 +2620,7 @@ DETONATEB:
case CHEERBOMB: m = gs.morterblastradius; break;
}
if (actor->spr.sector()->lotag != 800)
if (actor->sector()->lotag != 800)
{
fi.hitradius(actor, m, x >> 2, x >> 1, x - (x >> 2), x);
spawn(actor, EXPLOSION2);
@ -2651,7 +2651,7 @@ DETONATEB:
}
}
else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && actor->temp_data[0] > 7 && actor->spr.xvel == 0)
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (ps[p].ammo_amount[DYNAMITE_WEAPON] < gs.max_ammo_amount[DYNAMITE_WEAPON])
if (actor->spr.pal == 0)
{
@ -2713,7 +2713,7 @@ static int henstand(DDukeActor *actor)
return 1;
}
}
if (actor->spr.sector()->lotag == 900)
if (actor->sector()->lotag == 900)
actor->spr.xvel = 0;
if (actor->spr.xvel)
{
@ -2771,7 +2771,7 @@ static int henstand(DDukeActor *actor)
return 2;//deletesprite(actor); still needs to run a script but should not do on a deleted object
}
}
else if (actor->spr.sector()->lotag == 900)
else if (actor->sector()->lotag == 900)
{
if (actor->spr.picnum == BOWLINGBALL)
ballreturn(actor);
@ -2813,7 +2813,7 @@ void moveactors_r(void)
continue;
}
auto sectp = act->spr.sector();
auto sectp = act->sector();
switch(act->spr.picnum)
{
@ -2934,7 +2934,7 @@ void moveactors_r(void)
deletesprite(act);
continue;
}
if (act->spr.sector()->lotag == 900)
if (act->sector()->lotag == 900)
{
S_StopSound(356, nullptr);
}
@ -3073,7 +3073,7 @@ void moveexplosions_r(void) // STATNUM 5
while (auto act = it.Next())
{
t = &act->temp_data[0];
auto sectp = act->spr.sector();
auto sectp = act->sector();
if (!act->insector() || act->spr.xrepeat == 0)
{
@ -3084,8 +3084,8 @@ void moveexplosions_r(void) // STATNUM 5
switch (act->spr.picnum)
{
case SHOTGUNSPRITE:
if (act->spr.sector()->lotag == 800)
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3174,8 +3174,8 @@ void moveexplosions_r(void) // STATNUM 5
deletesprite(act);
continue;
case FEATHER + 1: // feather
act->floorz = act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.sector()->lotag == 800)
act->floorz = act->spr.pos.Z = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->sector()->lotag == 800)
{
deletesprite(act);
continue;
@ -3184,8 +3184,8 @@ void moveexplosions_r(void) // STATNUM 5
case FEATHER:
if (!money(act, BLOODPOOL)) continue;
if (act->spr.sector()->lotag == 800)
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3239,8 +3239,8 @@ void moveexplosions_r(void) // STATNUM 5
if (!jibs(act, JIBS6, false, true, true, act->spr.picnum == DUKELEG || act->spr.picnum == DUKETORSO || act->spr.picnum == DUKEGUN,
isRRRA() && (act->spr.picnum == RRTILE2465 || act->spr.picnum == RRTILE2560))) continue;
if (act->spr.sector()->lotag == 800)
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3251,8 +3251,8 @@ void moveexplosions_r(void) // STATNUM 5
case BLOODPOOL:
if (!bloodpool(act, false, TIRE)) continue;
if (act->spr.sector()->lotag == 800)
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
}
@ -3328,7 +3328,7 @@ void handle_se06_r(DDukeActor *actor)
}
if (!hulkspawn)
{
ns = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
ns = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
if (ns)
{
ns->spr.cstat = CSTAT_SPRITE_TRANS_FLIP | CSTAT_SPRITE_TRANSLUCENT;
@ -3341,7 +3341,7 @@ void handle_se06_r(DDukeActor *actor)
{
ns->spr.cstat = 0;
ns->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
ns->spr.pos.Z = actor->spr.sector()->floorz - 6144;
ns->spr.pos.Z = actor->sector()->floorz - 6144;
}
deletesprite(actor);
return;
@ -3761,20 +3761,20 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
}
if (badguy(actor) && actor->spr.extra <= 0)
{
if (actor->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (actor->sector()->ceilingstat & CSTAT_SECTOR_SKY)
{
if (actor->spr.sector()->shadedsector == 1)
if (actor->sector()->shadedsector == 1)
{
actor->spr.shade += (16 - actor->spr.shade) >> 1;
}
else
{
actor->spr.shade += (actor->spr.sector()->ceilingshade - actor->spr.shade) >> 1;
actor->spr.shade += (actor->sector()->ceilingshade - actor->spr.shade) >> 1;
}
}
else
{
actor->spr.shade += (actor->spr.sector()->floorshade - actor->spr.shade) >> 1;
actor->spr.shade += (actor->sector()->floorshade - actor->spr.shade) >> 1;
}
}
return;
@ -3803,7 +3803,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
{
if (actor->spr.zvel > 0)
{
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (isRRRA())
{
if (actor->spr.pos.Z > (l - (28 << 8)))
@ -3817,7 +3817,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
}
else
{
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (50 << 8))
{
actor->spr.pos.Z = l + (50 << 8);
@ -3829,7 +3829,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
actor->spr.pos.Z = actor->floorz;
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (66 << 8))
{
actor->spr.pos.Z = l + (66 << 8);
@ -3881,7 +3881,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
}
if (isRRRA())
{
if (actor->spr.sector()->lotag != 1)
if (actor->sector()->lotag != 1)
{
switch (actor->spr.picnum)
{
@ -3892,7 +3892,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
break;
}
}
else if (actor->spr.sector()->lotag == 1)
else if (actor->sector()->lotag == 1)
{
switch (actor->spr.picnum)
{
@ -3913,20 +3913,20 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a)
{
if (actor->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY)
if (actor->sector()->ceilingstat & CSTAT_SECTOR_SKY)
{
if (actor->spr.sector()->shadedsector == 1)
if (actor->sector()->shadedsector == 1)
{
actor->spr.shade += (16 - actor->spr.shade) >> 1;
}
else
{
actor->spr.shade += (actor->spr.sector()->ceilingshade - actor->spr.shade) >> 1;
actor->spr.shade += (actor->sector()->ceilingshade - actor->spr.shade) >> 1;
}
}
else actor->spr.shade += (actor->spr.sector()->floorshade - actor->spr.shade) >> 1;
else actor->spr.shade += (actor->sector()->floorshade - actor->spr.shade) >> 1;
if (actor->spr.sector()->floorpicnum == MIRROR)
if (actor->sector()->floorpicnum == MIRROR)
deletesprite(actor);
}
}
@ -3965,7 +3965,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
int sphit = 0;
if (isRRRA())
{
if (actor->spr.sector()->lotag == 801)
if (actor->sector()->lotag == 801)
{
if (actor->spr.picnum == ROCK)
{
@ -3975,7 +3975,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
}
return 0;
}
else if (actor->spr.sector()->lotag == 802)
else if (actor->sector()->lotag == 802)
{
if (actor->spr.picnum != APLAYER && badguy(actor) && actor->spr.pos.Z == actor->floorz - FOURSLEIGHT)
{
@ -3985,14 +3985,14 @@ static int fallspecial(DDukeActor *actor, int playernum)
}
return 0;
}
else if (actor->spr.sector()->lotag == 803)
else if (actor->sector()->lotag == 803)
{
if (actor->spr.picnum == ROCK2)
addspritetodelete();
return 0;
}
}
if (actor->spr.sector()->lotag == 800)
if (actor->sector()->lotag == 800)
{
if (actor->spr.picnum == 40)
{
@ -4016,7 +4016,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
actor->attackertype = SHOTSPARK1;
actor->extra = 1;
}
else if (isRRRA() && (actor->spr.sector()->floorpicnum == RRTILE7820 || actor->spr.sector()->floorpicnum == RRTILE7768))
else if (isRRRA() && (actor->sector()->floorpicnum == RRTILE7820 || actor->sector()->floorpicnum == RRTILE7768))
{
if (actor->spr.picnum != MINION && actor->spr.pal != 19)
{
@ -4066,7 +4066,7 @@ void destroyit(DDukeActor *actor)
DukeStatIterator it(STAT_DESTRUCT);
while (auto a2 = it.Next())
{
auto it_sect = a2->spr.sector();
auto it_sect = a2->sector();
if (hitag && hitag == a2->spr.hitag)
{
DukeSectIterator its(it_sect);
@ -4079,10 +4079,10 @@ void destroyit(DDukeActor *actor)
}
}
}
if (spr && spr->spr.sector() != it_sect)
if (spr && spr->sector() != it_sect)
if (lotag == a2->spr.lotag)
{
auto sect = spr->spr.sector();
auto sect = spr->sector();
auto destsect = spr->sector();
auto srcsect = it_sect;
@ -4127,7 +4127,7 @@ void destroyit(DDukeActor *actor)
destsect->extra = srcsect->extra;
}
}
it1.Reset(actor->spr.sector());
it1.Reset(actor->sector());
while (auto a2 = it1.Next())
{
switch (a2->spr.picnum)

4
source/games/duke/src/animatesprites_d.cpp
View file

@ -175,7 +175,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
t->pos = h->spr.interpolatedvec3(smoothratio);
}
auto sectp = h->spr.sector();
auto sectp = h->sector();
t1 = h->temp_data[1];
t3 = h->temp_data[3];
t4 = h->temp_data[4];
@ -401,7 +401,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
goto PALONLY;
}
if (ps[p].on_crane == nullptr && (h->spr.sector()->lotag & 0x7ff) != 1)
if (ps[p].on_crane == nullptr && (h->sector()->lotag & 0x7ff) != 1)
{
l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)

8
source/games/duke/src/animatesprites_r.cpp
View file

@ -107,7 +107,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
default:
if (((t->cstat & CSTAT_SPRITE_ALIGNMENT_WALL)) || (badguypic(t->picnum) && t->extra > 0) || t->statnum == STAT_PLAYER)
{
if (h->spr.sector()->shadedsector == 1 && h->spr.statnum != 1)
if (h->sector()->shadedsector == 1 && h->spr.statnum != 1)
{
h->spr.shade = 16;
t->shade = 16;
@ -158,7 +158,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
t->pos = h->spr.interpolatedvec3(smoothratio);
}
auto sectp = h->spr.sector();
auto sectp = h->sector();
t1 = h->temp_data[1];
t3 = h->temp_data[3];
t4 = h->temp_data[4];
@ -444,7 +444,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
goto PALONLY;
}
if (ps[p].on_crane == nullptr && (h->spr.sector()->lotag & 0x7ff) != 1)
if (ps[p].on_crane == nullptr && (h->sector()->lotag & 0x7ff) != 1)
{
l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
@ -582,7 +582,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
stuff:
if (t->pal == 6) t->shade = -120;
if (h->spr.sector()->shadedsector == 1)
if (h->sector()->shadedsector == 1)
t->shade = 16;
[[fallthrough]];

2
source/games/duke/src/bowling.cpp
View file

@ -39,7 +39,7 @@ void ballreturn(DDukeActor *ball)
DukeStatIterator it(STAT_BOWLING);
while (auto act = it.Next())
{
if (act->spr.picnum == RRTILE281 && ball->spr.sector() == act->spr.sector())
if (act->spr.picnum == RRTILE281 && ball->sector() == act->sector())
{
DukeStatIterator it2(STAT_BOWLING);
while (auto act2 = it2.Next())

48
source/games/duke/src/gameexec.cpp
View file

@ -1478,7 +1478,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
if (ps[pnum].holoduke_on != nullptr && !isRR())
{
tosee = ps[pnum].holoduke_on;
j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((32 << 8) - 1)), actor->spr.sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z, tosee->sector());
j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((32 << 8) - 1)), actor->sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z, tosee->sector());
if (j == 0)
{
@ -1490,7 +1490,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
else tosee = ps[pnum].GetActor(); // holoduke not on. look for player
// can they see player, (or player's holoduke)
j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((47 << 8))), actor->spr.sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - ((isRR()? 28 : 24) << 8), tosee->sector());
j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((47 << 8))), actor->sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - ((isRR()? 28 : 24) << 8), tosee->sector());
if (j == 0)
{
@ -1541,12 +1541,12 @@ int ParseState::parse(void)
parseifelse(ifcanshoottarget(g_ac, g_p, g_x));
break;
case concmd_ifcanseetarget:
j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - ((krand() & 41) << 8), g_ac->spr.sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z/*-((krand()&41)<<8)*/, ps[g_p].GetActor()->sector());
j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - ((krand() & 41) << 8), g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z/*-((krand()&41)<<8)*/, ps[g_p].GetActor()->sector());
parseifelse(j);
if (j) g_ac->timetosleep = SLEEPTIME;
break;
case concmd_ifnocover:
j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z, g_ac->spr.sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z, ps[g_p].GetActor()->sector());
j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z, g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z, ps[g_p].GetActor()->sector());
parseifelse(j);
if (j) g_ac->timetosleep = SLEEPTIME;
break;
@ -1857,7 +1857,7 @@ int ParseState::parse(void)
break;
case concmd_tearitup:
insptr++;
tearitup(g_ac->spr.sector());
tearitup(g_ac->sector());
break;
case concmd_fall:
insptr++;
@ -2189,7 +2189,7 @@ int ParseState::parse(void)
s = 0;
else s = (krand()%3);
auto spawned = EGS(g_ac->spr.sector(),
auto spawned = EGS(g_ac->sector(),
g_ac->spr.pos.X + (krand() & 255) - 128, g_ac->spr.pos.Y + (krand() & 255) - 128, g_ac->spr.pos.Z - (8 << 8) - (krand() & 8191),
dnum + s, g_ac->spr.shade, 32 + (krand() & 15), 32 + (krand() & 15),
krand() & 2047, (krand() & 127) + 32, -(krand() & 2047), g_ac, 5);
@ -2299,10 +2299,10 @@ int ParseState::parse(void)
parseifelse(ud.coop || numplayers > 2);
break;
case concmd_ifonmud:
parseifelse(abs(g_ac->spr.pos.Z - g_ac->spr.sector()->floorz) < (32 << 8) && g_ac->spr.sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
parseifelse(abs(g_ac->spr.pos.Z - g_ac->sector()->floorz) < (32 << 8) && g_ac->sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
break;
case concmd_ifonwater:
parseifelse( abs(g_ac->spr.pos.Z-g_ac->spr.sector()->floorz) < (32<<8) && g_ac->spr.sector()->lotag == ST_1_ABOVE_WATER);
parseifelse( abs(g_ac->spr.pos.Z-g_ac->sector()->floorz) < (32<<8) && g_ac->sector()->lotag == ST_1_ABOVE_WATER);
break;
case concmd_ifmotofast:
parseifelse(ps[g_p].MotoSpeed > 60);
@ -2323,7 +2323,7 @@ int ParseState::parse(void)
break;
case concmd_ifinwater:
parseifelse( g_ac->spr.sector()->lotag == 2);
parseifelse( g_ac->sector()->lotag == 2);
break;
case concmd_ifcount:
insptr++;
@ -2496,17 +2496,17 @@ int ParseState::parse(void)
parseifelse(PlayerInput(g_p, SB_OPEN));
break;
case concmd_ifoutside:
parseifelse(g_ac->spr.sector()->ceilingstat & CSTAT_SECTOR_SKY);
parseifelse(g_ac->sector()->ceilingstat & CSTAT_SECTOR_SKY);
break;
case concmd_ifmultiplayer:
parseifelse(ud.multimode > 1);
break;
case concmd_operate:
insptr++;
if( g_ac->spr.sector()->lotag == 0 )
if( g_ac->sector()->lotag == 0 )
{
HitInfo hit{};
neartag({ g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - (32 << 8) }, g_ac->spr.sector(), g_ac->spr.ang, hit, 768, 1);
neartag({ g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - (32 << 8) }, g_ac->sector(), g_ac->spr.ang, hit, 768, 1);
auto sectp = hit.hitSector;
if (sectp)
{
@ -2528,7 +2528,7 @@ int ParseState::parse(void)
}
break;
case concmd_ifinspace:
parseifelse(fi.ceilingspace(g_ac->spr.sector()));
parseifelse(fi.ceilingspace(g_ac->sector()));
break;
case concmd_spritepal:
@ -2813,7 +2813,7 @@ int ParseState::parse(void)
case concmd_pstomp:
insptr++;
if( ps[g_p].knee_incs == 0 && ps[g_p].GetActor()->spr.xrepeat >= (isRR()? 9: 40) )
if( cansee(g_ac->spr.pos.X,g_ac->spr.pos.Y,g_ac->spr.pos.Z-(4<<8),g_ac->spr.sector(),ps[g_p].pos.X,ps[g_p].pos.Y,ps[g_p].pos.Z+(16<<8),ps[g_p].GetActor()->spr.sector()) )
if( cansee(g_ac->spr.pos.X,g_ac->spr.pos.Y,g_ac->spr.pos.Z-(4<<8),g_ac->sector(),ps[g_p].pos.X,ps[g_p].pos.Y,ps[g_p].pos.Z+(16<<8),ps[g_p].GetActor()->sector()) )
{
ps[g_p].knee_incs = 1;
if(ps[g_p].weapon_pos == 0)
@ -2823,21 +2823,21 @@ int ParseState::parse(void)
break;
case concmd_ifawayfromwall:
{
auto s1 = g_ac->spr.sector();
auto s1 = g_ac->sector();
j = 0;
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y + 108, &s1);
if (s1 == g_ac->spr.sector())
if (s1 == g_ac->sector())
{
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y - 108, &s1);
if (s1 == g_ac->spr.sector())
if (s1 == g_ac->sector())
{
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y - 108, &s1);
if (s1 == g_ac->spr.sector())
if (s1 == g_ac->sector())
{
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y + 108, &s1);
if (s1 == g_ac->spr.sector())
if (s1 == g_ac->sector())
j = 1;
}
}
@ -2852,7 +2852,7 @@ int ParseState::parse(void)
insptr++;
break;
case concmd_ifinouterspace:
parseifelse( fi.floorspace(g_ac->spr.sector()));
parseifelse( fi.floorspace(g_ac->sector()));
break;
case concmd_ifnotmoving:
parseifelse( (g_ac->movflag&kHitTypeMask) > kHitSector );
@ -3461,19 +3461,19 @@ int ParseState::parse(void)
case concmd_sectgetlotag:
{
insptr++;
SetGameVarID(g_iLoTagID, g_ac->spr.sector()->lotag, g_ac, g_p);
SetGameVarID(g_iLoTagID, g_ac->sector()->lotag, g_ac, g_p);
break;
}
case concmd_sectgethitag:
{
insptr++;
SetGameVarID(g_iHiTagID, g_ac->spr.sector()->hitag, g_ac, g_p);
SetGameVarID(g_iHiTagID, g_ac->sector()->hitag, g_ac, g_p);
break;
}
case concmd_gettexturefloor:
{
insptr++;
SetGameVarID(g_iTextureID, g_ac->spr.sector()->floorpicnum, g_ac, g_p);
SetGameVarID(g_iTextureID, g_ac->sector()->floorpicnum, g_ac, g_p);
break;
}
@ -3610,7 +3610,7 @@ int ParseState::parse(void)
case concmd_gettextureceiling:
{
insptr++;
SetGameVarID(g_iTextureID, g_ac->spr.sector()->ceilingpicnum, g_ac, g_p);
SetGameVarID(g_iTextureID, g_ac->sector()->ceilingpicnum, g_ac, g_p);
break;
}
case concmd_ifvarvarand:

2
source/games/duke/src/inlines.h
View file

@ -67,7 +67,7 @@ inline int checkcursectnums(sectortype* se)
{
int i;
for(i=connecthead;i>=0;i=connectpoint2[i])
if(ps[i].GetActor() && ps[i].GetActor()->spr.sector() == se ) return i;
if(ps[i].GetActor() && ps[i].GetActor()->sector() == se ) return i;
return -1;
}

10
source/games/duke/src/player.cpp
View file

@ -174,7 +174,7 @@ int hits(DDukeActor* actor)
if (actor->spr.picnum == TILE_APLAYER) zoff = isRR() ? PHEIGHT_RR : PHEIGHT_DUKE;
else zoff = 0;
hitscan(actor->spr.pos, actor->spr.sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
hitscan(actor->spr.pos, actor->sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
return (FindDistance2D(hit.hitpos.vec2 - actor->spr.pos.vec2));
}
@ -194,7 +194,7 @@ int hitasprite(DDukeActor* actor, DDukeActor** hitsp)
else if (actor->spr.picnum == TILE_APLAYER) zoff = (39 << 8);
else zoff = 0;
hitscan({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - zoff }, actor->spr.sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
hitscan({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - zoff }, actor->sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
if (hitsp) *hitsp = hit.actor();
if (hit.hitWall != nullptr && (hit.hitWall->cstat & CSTAT_WALL_MASKED) && badguy(actor))
@ -346,7 +346,7 @@ DDukeActor* aim(DDukeActor* actor, int aang)
a = (abs(Scale(act->spr.pos.Z - actor->spr.pos.Z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
else a = 1;
cans = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (32 << 8), actor->spr.sector());
cans = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (32 << 8), actor->sector());
if (a && cans)
{
@ -500,7 +500,7 @@ void footprints(int snum)
if ((p->cursector->floorstat & CSTAT_SECTOR_SLOPE) != 2)
{
int j = -1;
DukeSectIterator it(actor->spr.sector());
DukeSectIterator it(actor->sector());
while (auto act = it.Next())
{
if (act->spr.picnum == TILE_FOOTPRINTS || act->spr.picnum == TILE_FOOTPRINTS2 || act->spr.picnum == TILE_FOOTPRINTS3 || act->spr.picnum == TILE_FOOTPRINTS4)
@ -999,7 +999,7 @@ int haskey(sectortype* sectp, int snum)
void shootbloodsplat(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, int atwith, int BIGFORCE, int OOZFILTER, int NEWBEAST)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int zvel;
HitInfo hit{};

36
source/games/duke/src/player_d.cpp
View file

@ -125,7 +125,7 @@ static void shootfireball(DDukeActor *actor, int p, int sx, int sy, int sz, int
sizy = 7;
}
auto spawned = EGS(actor->spr.sector(), sx, sy, sz, FIREBALL, -127, sizx, sizy, sa, vel, zvel, actor, (short)4);
auto spawned = EGS(actor->sector(), sx, sy, sz, FIREBALL, -127, sizx, sizy, sa, vel, zvel, actor, (short)4);
if (spawned)
{
spawned->spr.extra += (krand() & 7);
@ -176,7 +176,7 @@ static void shootflamethrowerflame(DDukeActor* actor, int p, int sx, int sy, int
if (badguy(actor) && (actor->spr.hitag & face_player_smart) != 0)
sa = (short)(actor->spr.ang + (krand() & 31) - 16);
if (actor->spr.sector()->lotag == 2 && (krand() % 5) == 0)
if (actor->sector()->lotag == 2 && (krand() % 5) == 0)
spawned = spawn(actor, WATERBUBBLE);
}
else
@ -186,7 +186,7 @@ static void shootflamethrowerflame(DDukeActor* actor, int p, int sx, int sy, int
vel = (int)((((512 - (1024
- abs(abs(getangle(sx - ps[p].opos.X, sy - ps[p].opos.Y) - sa) - 1024)))
* 0.001953125f) * ps[p].GetActor()->spr.xvel) + 400);
if (actor->spr.sector()->lotag == 2 && (krand() % 5) == 0)
if (actor->sector()->lotag == 2 && (krand() % 5) == 0)
spawned = spawn(actor, WATERBUBBLE);
}
@ -201,7 +201,7 @@ static void shootflamethrowerflame(DDukeActor* actor, int p, int sx, int sy, int
spawned->spr.pos.X = sx + bsin(sa + 630) / 448;
spawned->spr.pos.Y = sy + bsin(sa + 112) / 448;
spawned->spr.pos.Z = sz - 256;
spawned->setsector(actor->spr.sector());
spawned->setsector(actor->sector());
spawned->spr.cstat = CSTAT_SPRITE_YCENTER;
spawned->spr.ang = sa;
spawned->spr.xrepeat = 2;
@ -230,7 +230,7 @@ static void shootflamethrowerflame(DDukeActor* actor, int p, int sx, int sy, int
static void shootknee(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int zvel;
HitInfo hit{};
@ -316,7 +316,7 @@ static void shootknee(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int zvel = 0;
HitInfo hit{};
@ -565,7 +565,7 @@ static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa
static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
sectortype* sect = actor->spr.sector();
sectortype* sect = actor->sector();
int vel, zvel;
int l, scount;
@ -676,7 +676,7 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
int vel, zvel;
int l, scount;
@ -842,7 +842,7 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
static void shootlaser(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int zvel;
int j;
HitInfo hit{};
@ -912,7 +912,7 @@ static void shootlaser(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
static void shootgrowspark(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
int zvel;
int k;
HitInfo hit{};
@ -1018,7 +1018,7 @@ void shoot_d(DDukeActor* actor, int atwith)
}
auto sect = actor->spr.sector();
auto sect = actor->sector();
zvel = 0;
if (actor->spr.picnum == TILE_APLAYER)
@ -2891,9 +2891,9 @@ void processinput_d(int snum)
if (p->spritebridge == 0 && pact->insector())
{
j = pact->spr.sector()->floorpicnum;
j = pact->sector()->floorpicnum;
if (j == PURPLELAVA || pact->spr.sector()->ceilingpicnum == PURPLELAVA)
if (j == PURPLELAVA || pact->sector()->ceilingpicnum == PURPLELAVA)
{
if (p->boot_amount > 0)
{
@ -3053,7 +3053,7 @@ HORIZONLY:
if (psectlotag < 3)
{
psectp = pact->spr.sector();
psectp = pact->sector();
if (ud.clipping == 0 && psectp->lotag == 31)
{
auto secact = barrier_cast<DDukeActor*>(psectp->hitagactor);
@ -3069,7 +3069,7 @@ HORIZONLY:
if (!S_CheckActorSoundPlaying(pact, DUKE_ONWATER))
S_PlayActorSound(DUKE_ONWATER, pact);
if (p->cursector != pact->spr.sector())
if (p->cursector != pact->sector())
ChangeActorSect(pact, p->cursector);
if (ud.clipping == 0)
@ -3080,9 +3080,9 @@ HORIZONLY:
{
if (abs(pact->floorz - pact->ceilingz) < (48 << 8) || j)
{
if (!(pact->spr.sector()->lotag & 0x8000) && (isanunderoperator(pact->spr.sector()->lotag) ||
isanearoperator(pact->spr.sector()->lotag)))
fi.activatebysector(pact->spr.sector(), pact);
if (!(pact->sector()->lotag & 0x8000) && (isanunderoperator(pact->sector()->lotag) ||
isanearoperator(pact->sector()->lotag)))
fi.activatebysector(pact->sector(), pact);
if (j)
{
quickkill(p);

32
source/games/duke/src/player_r.cpp
View file

@ -85,7 +85,7 @@ void incur_damage_r(struct player_struct* p)
static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int zvel;
HitInfo hit{};
@ -111,7 +111,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
DukeStatIterator its(STAT_EFFECTOR);
while (auto effector = its.Next())
{
if (effector->spr.sector() == hit.hitSector && effector->spr.picnum == SECTOREFFECTOR && effector->GetOwner()
if (effector->sector() == hit.hitSector && effector->spr.picnum == SECTOREFFECTOR && effector->GetOwner()
&& effector->spr.lotag == SE_7_TELEPORT)
{
int nx, ny, nz;
@ -125,7 +125,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
{
nz = effector->GetOwner()->sector()->ceilingz;
}
hitscan({ nx, ny, nz }, effector->GetOwner()->spr.sector(), { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
hitscan({ nx, ny, nz }, effector->GetOwner()->sector(), { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
break;
}
}
@ -204,7 +204,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int zvel = 0;
HitInfo hit{};
@ -267,7 +267,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
DukeStatIterator its(STAT_EFFECTOR);
while (auto effector = its.Next())
{
if (effector->spr.sector() == hit.hitSector && effector->spr.picnum == SECTOREFFECTOR && effector->GetOwner()
if (effector->sector() == hit.hitSector && effector->spr.picnum == SECTOREFFECTOR && effector->GetOwner()
&& effector->spr.lotag == SE_7_TELEPORT)
{
int nx, ny, nz;
@ -281,7 +281,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
{
nz = effector->GetOwner()->sector()->ceilingz;
}
hitscan({ nx, ny, nz }, effector->GetOwner()->spr.sector(), { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
hitscan({ nx, ny, nz }, effector->GetOwner()->sector(), { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
break;
}
}
@ -459,7 +459,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
int vel = 0, zvel;
int scount;
@ -599,7 +599,7 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
int vel, zvel;
int l, scount;
@ -751,7 +751,7 @@ static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
static void shootwhip(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, int atwith)
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
int vel = 0, zvel;
int scount;
@ -830,7 +830,7 @@ void shoot_r(DDukeActor* actor, int atwith)
int sx, sy, sz, vel, zvel, x;
auto const sect = actor->spr.sector();
auto const sect = actor->sector();
zvel = 0;
if (actor->spr.picnum == TILE_APLAYER)
@ -3622,7 +3622,7 @@ void processinput_r(int snum)
if (p->spritebridge == 0 && pact->insector())
{
int j = pact->spr.sector()->floorpicnum;
int j = pact->sector()->floorpicnum;
k = 0;
if (p->on_ground && truefdist <= gs.playerheight + (16 << 8))
@ -3892,7 +3892,7 @@ HORIZONLY:
if (psectlotag < 3)
{
psectp = pact->spr.sector();
psectp = pact->sector();
if (ud.clipping == 0 && psectp->lotag == ST_31_TWO_WAY_TRAIN)
{
auto act = barrier_cast<DDukeActor*>(psectp->hitagactor);
@ -3909,7 +3909,7 @@ HORIZONLY:
if (!isRRRA() || (!p->OnBoat && !p->OnMotorcycle && p->cursector->hitag != 321))
S_PlayActorSound(DUKE_ONWATER, pact);
if (p->cursector != pact->spr.sector())
if (p->cursector != pact->sector())
ChangeActorSect(pact, p->cursector);
int j;
@ -3926,9 +3926,9 @@ HORIZONLY:
{
if (abs(pact->floorz - pact->ceilingz) < (48 << 8) || j)
{
if (!(pact->spr.sector()->lotag & 0x8000) && (isanunderoperator(pact->spr.sector()->lotag) ||
isanearoperator(pact->spr.sector()->lotag)))
fi.activatebysector(pact->spr.sector(), pact);
if (!(pact->sector()->lotag & 0x8000) && (isanunderoperator(pact->sector()->lotag) ||
isanearoperator(pact->sector()->lotag)))
fi.activatebysector(pact->sector(), pact);
if (j)
{
quickkill(p);

4
source/games/duke/src/premap.cpp
View file

@ -585,7 +585,7 @@ void resetpspritevars(int g)
po[numplayersprites].opos.Y = act->spr.pos.Y;
po[numplayersprites].opos.Z = act->spr.pos.Z;
po[numplayersprites].oa = act->spr.ang;
po[numplayersprites].os = act->spr.sector();
po[numplayersprites].os = act->sector();
numplayersprites++;
if (j >= 0)
@ -842,7 +842,7 @@ static void SpawnPortals()
{
if (processedTags.Find(act->spr.hitag) == processedTags.Size())
{
sectortype* s1 = act->spr.sector(), *s2 = act2->spr.sector();
sectortype* s1 = act->sector(), *s2 = act2->sector();
s1->portalflags = PORTAL_SECTOR_FLOOR;
s1->portalflags = PORTAL_SECTOR_CEILING;
s2->portalnum = portalAdd(PORTAL_SECTOR_FLOOR, sectnum(s2), act2->spr.pos.X - act->spr.pos.X, act2->spr.pos.Y - act->spr.pos.Y, act->spr.hitag);

6
source/games/duke/src/premap_d.cpp
View file

@ -295,17 +295,17 @@ void prelevel_d(int g, TArray<DDukeActor*>& actors)
else switch (ac->spr.picnum)
{
case GPSPEED:
ac->spr.sector()->extra = ac->spr.lotag;
ac->sector()->extra = ac->spr.lotag;
deletesprite(ac);
break;
case CYCLER:
if (numcyclers >= MAXCYCLERS)
I_Error("Too many cycling sectors.");
cyclers[numcyclers].sector = ac->spr.sector();
cyclers[numcyclers].sector = ac->sector();
cyclers[numcyclers].lotag = ac->spr.lotag;
cyclers[numcyclers].shade1 = ac->spr.shade;
cyclers[numcyclers].shade2 = ac->spr.sector()->floorshade;
cyclers[numcyclers].shade2 = ac->sector()->floorshade;
cyclers[numcyclers].hitag = ac->spr.hitag;
cyclers[numcyclers].state = (ac->spr.ang == 1536);
numcyclers++;

18
source/games/duke/src/premap_r.cpp
View file

@ -508,7 +508,7 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
if (act1->spr.picnum == RRTILE66)
if (act1->spr.lotag == act->sectno()) // bad map format design... Should have used a tag instead...
{
childsectnum = act1->spr.sector();
childsectnum = act1->sector();
deletesprite(act1);
}
}
@ -543,17 +543,17 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
break;
case GPSPEED:
ac->spr.sector()->extra = ac->spr.lotag;
ac->sector()->extra = ac->spr.lotag;
deletesprite(ac);
break;
case CYCLER:
if (numcyclers >= MAXCYCLERS)
I_Error("Too many cycling sectors.");
cyclers[numcyclers].sector = ac->spr.sector();
cyclers[numcyclers].sector = ac->sector();
cyclers[numcyclers].lotag = ac->spr.lotag;
cyclers[numcyclers].shade1 = ac->spr.shade;
cyclers[numcyclers].shade2 = ac->spr.sector()->floorshade;
cyclers[numcyclers].shade2 = ac->sector()->floorshade;
cyclers[numcyclers].hitag = ac->spr.hitag;
cyclers[numcyclers].state = (ac->spr.ang == 1536);
numcyclers++;
@ -571,7 +571,7 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
break;
case RRTILE68:
ac->spr.sector()->shadedsector = 1;
ac->sector()->shadedsector = 1;
deletesprite(ac);
break;
@ -604,21 +604,21 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
I_Error("Too many geometry effects");
if (actor->spr.hitag == 0)
{
geosector[geocnt] = actor->spr.sector();
geosector[geocnt] = actor->sector();
for (auto actor2 : actors)
{
if (actor->spr.lotag == actor2->spr.lotag && actor2 != actor && actor2->spr.picnum == RRTILE19)
{
if (actor2->spr.hitag == 1)
{
geosectorwarp[geocnt] = actor2->spr.sector();
geosectorwarp[geocnt] = actor2->sector();
geox[geocnt] = actor->spr.pos.X - actor2->spr.pos.X;
geoy[geocnt] = actor->spr.pos.Y - actor2->spr.pos.Y;
//geoz[geocnt] = actor->spr.z - actor2->spr.z;
}
if (actor2->spr.hitag == 2)
{
geosectorwarp2[geocnt] = actor2->spr.sector();
geosectorwarp2[geocnt] = actor2->sector();
geox2[geocnt] = actor->spr.pos.X - actor2->spr.pos.X;
geoy2[geocnt] = actor->spr.pos.Y - actor2->spr.pos.Y;
//geoz2[geocnt] = actor->spr.z - actor2->spr.z;
@ -650,7 +650,7 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
deletesprite(actor);
if (actor->spr.picnum == RRTILE34)
{
actor->spr.sector()->keyinfo = uint8_t(actor->spr.lotag);
actor->sector()->keyinfo = uint8_t(actor->spr.lotag);
deletesprite(actor);
}
}

8
source/games/duke/src/render.cpp
View file

@ -115,7 +115,7 @@ void GameInterface::UpdateCameras(double smoothratio)
if (!testnewrenderer)
{
// Note: no ROR or camera here - Polymost has no means to detect these things before rendering the scene itself.
renderDrawRoomsQ16(camera->spr.pos.X, camera->spr.pos.Y, camera->spr.pos.Z, ang.asq16(), IntToFixed(camera->spr.shade), camera->spr.sector(), false); // why 'shade'...?
renderDrawRoomsQ16(camera->spr.pos.X, camera->spr.pos.Y, camera->spr.pos.Z, ang.asq16(), IntToFixed(camera->spr.shade), camera->sector(), false); // why 'shade'...?
fi.animatesprites(pm_tsprite, pm_spritesortcnt, camera->spr.pos.X, camera->spr.pos.Y, ang.asbuild(), (int)smoothratio);
renderDrawMasks();
}
@ -123,7 +123,7 @@ void GameInterface::UpdateCameras(double smoothratio)
{
auto cstat = camera->spr.cstat;
camera->spr.cstat = CSTAT_SPRITE_INVISIBLE;
render_camtex(camera, camera->spr.pos, camera->spr.sector(), ang, buildhoriz(camera->spr.shade), buildang(0), tex, rect, smoothratio);
render_camtex(camera, camera->spr.pos, camera->sector(), ang, buildhoriz(camera->spr.shade), buildang(0), tex, rect, smoothratio);
camera->spr.cstat = cstat;
}
display_mirror = 0;
@ -295,7 +295,7 @@ void displayrooms(int snum, double smoothratio)
auto bh = buildhoriz(act->spr.yvel);
auto cstat = act->spr.cstat;
act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
renderView(act, act->spr.sector(), act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (4 << 8), cang, bh, buildang(0), (int)smoothratio);
renderView(act, act->sector(), act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (4 << 8), cang, bh, buildang(0), (int)smoothratio);
act->spr.cstat = cstat;
}
@ -361,7 +361,7 @@ void displayrooms(int snum, double smoothratio)
cposx = act->spr.pos.X;
cposy = act->spr.pos.Y;
cposz = act->spr.pos.Z;
sect = act->spr.sector();
sect = act->sector();
rotscrnang = buildang(0);
smoothratio = MaxSmoothRatio;
viewer = act;

16
source/games/duke/src/sectors.cpp
View file

@ -89,7 +89,7 @@ int callsound(sectortype* sn, DDukeActor* whatsprite)
act->temp_actor = whatsprite;
}
if ((act->spr.sector()->lotag & 0xff) != ST_22_SPLITTING_DOOR)
if ((act->sector()->lotag & 0xff) != ST_22_SPLITTING_DOOR)
act->temp_data[0] = 1;
}
}
@ -122,13 +122,13 @@ int check_activator_motion(int lotag)
if (act->spr.lotag == lotag)
{
for (int j = animatecnt - 1; j >= 0; j--)
if (act->spr.sector() == animatesect[j])
if (act->sector() == animatesect[j])
return(1);
DukeStatIterator it1(STAT_EFFECTOR);
while (auto act2 = it1.Next())
{
if (act->spr.sector() == act2->spr.sector())
if (act->sector() == act2->sector())
switch (act2->spr.lotag)
{
case SE_11_SWINGING_DOOR:
@ -448,7 +448,7 @@ int setanimation(sectortype* animsect, int animtype, sectortype* animtarget, int
bool activatewarpelevators(DDukeActor* actor, int d) //Parm = sectoreffectornum
{
auto sect = actor->spr.sector();
auto sect = actor->sector();
// See if the sector exists
@ -597,7 +597,7 @@ static void handle_st15(sectortype* sptr, DDukeActor* actor)
}
if (!a2) return;
if (actor->spr.sector() == sptr)
if (actor->sector() == sptr)
{
if (activatewarpelevators(a2, -1))
activatewarpelevators(a2, 1);
@ -818,7 +818,7 @@ static void handle_st23(sectortype* sptr, DDukeActor* actor)
DDukeActor* act2;
while ((act2 = it.Next()))
{
if (act2->spr.lotag == SE_11_SWINGING_DOOR && act2->spr.sector() == sptr && !act2->temp_data[4])
if (act2->spr.lotag == SE_11_SWINGING_DOOR && act2->sector() == sptr && !act2->temp_data[4])
{
break;
}
@ -870,7 +870,7 @@ static void handle_st25(sectortype* sptr, DDukeActor* actor)
DDukeActor* act2;
while ((act2 = it.Next()))
{
if (act2->spr.lotag == 15 && act2->spr.sector() == sptr)
if (act2->spr.lotag == 15 && act2->sector() == sptr)
{
break;
}
@ -908,7 +908,7 @@ static void handle_st27(sectortype* sptr, DDukeActor* actor)
DukeStatIterator it(STAT_EFFECTOR);
while (auto act2 = it.Next())
{
if ((act2->spr.lotag & 0xff) == 20 && act2->spr.sector() == sptr) //Bridge
if ((act2->spr.lotag & 0xff) == 20 && act2->sector() == sptr) //Bridge
{
sptr->lotag ^= 0x8000;

18
source/games/duke/src/sectors_d.cpp
View file

@ -1110,7 +1110,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
case HEAVYHBOMB:
for (k = 0; k < 64; k++)
{
auto spawned = EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
auto spawned = EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
spawned->spr.pal = 8;
}
@ -1125,7 +1125,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
case HANGLIGHT:
case GENERICPOLE2:
for (k = 0; k < 6; k++)
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
S_PlayActorSound(GLASS_HEAVYBREAK, targ);
deletesprite(targ);
break;
@ -1134,8 +1134,8 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
case FANSPRITE:
targ->spr.picnum = FANSPRITEBROKE;
targ->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
if (targ->spr.sector()->floorpicnum == FANSHADOW)
targ->spr.sector()->floorpicnum = FANSHADOWBROKE;
if (targ->sector()->floorpicnum == FANSHADOW)
targ->sector()->floorpicnum = FANSHADOWBROKE;
S_PlayActorSound(GLASS_HEAVYBREAK, targ);
for (j = 0; j < 16; j++) RANDOMSCRAP(targ);
@ -1155,7 +1155,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
if (gs.actorinfo[SHOTSPARK1].scriptaddress && proj->spr.extra != ScriptCode[gs.actorinfo[SHOTSPARK1].scriptaddress])
{
for (j = 0; j < 15; j++)
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
spawn(targ, EXPLOSION2);
deletesprite(targ);
@ -1311,7 +1311,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
}
{
auto spawned = spawn(targ, STEAM);
if (spawned) spawned->spr.pos.Z = targ->spr.sector()->floorz - (32 << 8);
if (spawned) spawned->spr.pos.Z = targ->sector()->floorz - (32 << 8);
}
break;
@ -1420,9 +1420,9 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
if ((targ->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
targ->spr.ang = (proj->spr.ang + 1024) & 2047;
targ->spr.xvel = -(proj->spr.extra << 2);
auto sp = targ->spr.sector();
auto sp = targ->sector();
pushmove(&targ->spr.pos, &sp, 128L, (4 << 8), (4 << 8), CLIPMASK0);
if (sp != targ->spr.sector() && sp != nullptr)
if (sp != targ->sector() && sp != nullptr)
ChangeActorSect(targ, sp);
}
@ -1655,7 +1655,7 @@ void checksectors_d(int snum)
if (p->newOwner == nullptr && near.actor() == nullptr && near.hitWall == nullptr && near.hitSector == nullptr)
if (isanunderoperator(p->GetActor()->sector()->lotag))
near.hitSector = p->GetActor()->spr.sector();
near.hitSector = p->GetActor()->sector();
if (near.hitSector && (near.hitSector->lotag & 16384))
return;

18
source/games/duke/src/sectors_r.cpp
View file

@ -939,7 +939,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
for (j = n - 1; j >= 0; j--)
{
a = actor->spr.ang - 256 + (krand() & 511) + 1024;
EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
}
return;
}
@ -969,7 +969,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
a = actor->spr.ang - 1024;
EGS(actor->spr.sector(), x1, y1, z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
EGS(actor->sector(), x1, y1, z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
}
}
}
@ -1102,7 +1102,7 @@ void checkhitwall_r(DDukeActor* spr, walltype* wal, int x, int y, int z, int atw
{
if (wl.twoSided()) wl.nextSector()->lotag = 0;
}
act->spr.sector()->lotag = 0;
act->sector()->lotag = 0;
S_StopSound(act->spr.lotag);
S_PlayActorSound(400, act);
deletesprite(act);
@ -2072,7 +2072,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
lotsofglass(targ, nullptr, 10);
targ->spr.picnum++;
for (k = 0; k < 6; k++)
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
break;
case BOWLINGBALL:
proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
@ -2164,7 +2164,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
case UWHIP:
for (k = 0; k < 64; k++)
{
auto spawned = EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
auto spawned = EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
if (spawned) spawned->spr.pal = 8;
}
@ -2197,7 +2197,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
if (gs.actorinfo[SHOTSPARK1].scriptaddress && proj->spr.extra != ScriptCode[gs.actorinfo[SHOTSPARK1].scriptaddress])
{
for (j = 0; j < 15; j++)
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
spawn(targ, EXPLOSION2);
deletesprite(targ);
@ -2323,7 +2323,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
}
{
auto spawned = spawn(targ, STEAM);
if (spawned) spawned->spr.pos.Z = targ->spr.sector()->floorz - (32 << 8);
if (spawned) spawned->spr.pos.Z = targ->sector()->floorz - (32 << 8);
}
break;
@ -2601,7 +2601,7 @@ void checksectors_r(int snum)
if (p->newOwner == nullptr && near.actor() == nullptr && near.hitWall == nullptr && near.hitSector == nullptr)
if (isanunderoperator(p->GetActor()->sector()->lotag))
near.hitSector = p->GetActor()->spr.sector();
near.hitSector = p->GetActor()->sector();
if (near.hitSector && (near.hitSector->lotag & 16384))
return;
@ -2772,7 +2772,7 @@ void checksectors_r(int snum)
return;
}
if (haskey(near.hitSector, snum))
operatesectors(p->GetActor()->spr.sector(), p->GetActor());
operatesectors(p->GetActor()->sector(), p->GetActor());
else
{
if (neartagsprite && neartagsprite->spriteextra > 3)

8
source/games/duke/src/sounds.cpp
View file

@ -269,14 +269,14 @@ static int GetPositionInfo(DDukeActor* actor, int soundNum, sectortype* sect,
{
orgsndist = sndist = int(16 * (sndorg - campos).Length());
if ((userflags & (SF_GLOBAL | SF_DTAG)) != SF_GLOBAL && actor->spr.picnum == MUSICANDSFX && actor->spr.lotag < 999 && (actor->spr.sector()->lotag & 0xff) < ST_9_SLIDING_ST_DOOR)
if ((userflags & (SF_GLOBAL | SF_DTAG)) != SF_GLOBAL && actor->spr.picnum == MUSICANDSFX && actor->spr.lotag < 999 && (actor->sector()->lotag & 0xff) < ST_9_SLIDING_ST_DOOR)
sndist = DivScale(sndist, actor->spr.hitag + 1, 14);
}
sndist += dist_adjust;
if (sndist < 0) sndist = 0;
if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (24 << 8), actor->spr.sector()))
if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (24 << 8), actor->sector()))
sndist += sndist >> (isRR() ? 2 : 5);
// Here the sound distance was clamped to a minimum of 144*4.
@ -322,7 +322,7 @@ void S_GetCamera(vec3_t** c, int32_t* ca, sectortype** cs)
else
{
if (c) *c = &ud.cameraactor->spr.pos;
if (cs) *cs = ud.cameraactor->spr.sector();
if (cs) *cs = ud.cameraactor->sector();
if (ca) *ca = ud.cameraactor->spr.ang;
}
}
@ -561,7 +561,7 @@ void S_StopSound(int sndNum, DDukeActor* actor, int channel)
else soundEngine->StopSound(SOURCE_Actor, actor, channel, -1);
// StopSound kills the actor reference so this cannot be delayed until ChannelEnded gets called. At that point the actor may also not be valid anymore.
if (S_IsAmbientSFX(actor) && actor->spr.sector()->lotag < 3) // ST_2_UNDERWATER
if (S_IsAmbientSFX(actor) && actor->sector()->lotag < 3) // ST_2_UNDERWATER
actor->temp_data[0] = 0;
}
}

62
source/games/duke/src/spawn.cpp
View file

@ -149,8 +149,8 @@ bool initspriteforspawn(DDukeActor* act, const std::initializer_list<int> &exclu
act->movflag = 0;
act->tempang = 0;
act->dispicnum = 0;
act->floorz = act->spr.sector()->floorz;
act->ceilingz = act->spr.sector()->ceilingz;
act->floorz = act->sector()->floorz;
act->ceilingz = act->sector()->ceilingz;
act->ovel.X = 0;
act->ovel.Y = 0;
@ -217,7 +217,7 @@ DDukeActor* spawn(DDukeActor* actj, int pn)
{
if (actj)
{
auto spawned = EGS(actj->spr.sector(), actj->spr.pos.X, actj->spr.pos.Y, actj->spr.pos.Z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
auto spawned = EGS(actj->sector(), actj->spr.pos.X, actj->spr.pos.Y, actj->spr.pos.Z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
if (spawned)
{
spawned->attackertype = actj->spr.picnum;
@ -261,7 +261,7 @@ void spawninitdefault(DDukeActor* actj, DDukeActor *act)
makeitfall(act);
if (actorflag(act, SFLAG_BADGUYSTAYPUT))
act->actorstayput = act->spr.sector();
act->actorstayput = act->sector();
if (!isRR() || actorflag(act, SFLAG_KILLCOUNT)) // Duke is just like Doom - Bad guys always count as kill.
ps[myconnectindex].max_actors_killed++;
@ -302,7 +302,7 @@ void spawntransporter(DDukeActor *actj, DDukeActor* act, bool beam)
{
act->spr.xrepeat = 31;
act->spr.yrepeat = 1;
act->spr.pos.Z = actj->spr.sector()->floorz - (isRR() ? PHEIGHT_RR : PHEIGHT_DUKE);
act->spr.pos.Z = actj->sector()->floorz - (isRR() ? PHEIGHT_RR : PHEIGHT_DUKE);
}
else
{
@ -338,19 +338,19 @@ void spawntransporter(DDukeActor *actj, DDukeActor* act, bool beam)
int spawnbloodpoolpart1(DDukeActor* act)
{
auto s1 = act->spr.sector();
auto s1 = act->sector();
updatesector(act->spr.pos.X + 108, act->spr.pos.Y + 108, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 108, act->spr.pos.Y - 108, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X + 108, act->spr.pos.Y - 108, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 108, act->spr.pos.Y + 108, &s1);
if (s1 && s1->floorz != act->spr.sector()->floorz)
if (s1 && s1->floorz != act->sector()->floorz)
{
act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return true;
}
@ -361,7 +361,7 @@ int spawnbloodpoolpart1(DDukeActor* act)
}
else { act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return true; }
if (act->spr.sector()->lotag == 1)
if (act->sector()->lotag == 1)
{
ChangeActorStat(act, STAT_MISC);
return true;
@ -377,22 +377,22 @@ int spawnbloodpoolpart1(DDukeActor* act)
void initfootprint(DDukeActor* actj, DDukeActor* act)
{
auto sect = act->spr.sector();
auto sect = act->sector();
if (actj)
{
auto s1 = act->spr.sector();
auto s1 = act->sector();
updatesector(act->spr.pos.X + 84, act->spr.pos.Y + 84, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 84, act->spr.pos.Y - 84, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X + 84, act->spr.pos.Y - 84, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 84, act->spr.pos.Y + 84, &s1);
if (s1 && s1->floorz != act->spr.sector()->floorz)
if (s1 && s1->floorz != act->sector()->floorz)
{
act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return;
}
@ -474,7 +474,7 @@ void initshell(DDukeActor* actj, DDukeActor* act, bool isshell)
void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
{
auto sect = act->spr.sector();
auto sect = act->sector();
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL | CSTAT_SPRITE_ONE_SIDE;
act->spr.picnum += 2;
@ -494,7 +494,7 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
{
apt.poleactor = actk;
act->temp_sect = actk->spr.sector();
act->temp_sect = actk->sector();
actk->spr.xrepeat = 48;
actk->spr.yrepeat = 128;
@ -601,7 +601,7 @@ int initreactor(DDukeActor* actj, DDukeActor* actor, bool isrecon)
void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
{
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
int d, clostest = 0;
actor->spr.yvel = sectp->extra;
@ -1014,8 +1014,8 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
}
else if (actor->spr.lotag == SE_2_EARTHQUAKE)
{
actor->temp_data[5] = actor->spr.sector()->floorheinum;
actor->spr.sector()->setfloorslope(0);
actor->temp_data[5] = actor->sector()->floorheinum;
actor->sector()->setfloorslope(0);
}
}
@ -1028,7 +1028,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
if (j == -1)
{
if (!isRR()) j = SUBWAY; // Duke
else if (actor->spr.sector()->floorpal == 7) j = 456;
else if (actor->sector()->floorpal == 7) j = 456;
else j = 75;
}
actor->ovel.X = j;
@ -1044,12 +1044,12 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_15_SLIDING_DOOR:
case SE_16_REACTOR:
case SE_26:
setsectinterpolate(actor->spr.sector());
setsectinterpolate(actor->sector());
break;
case SE_29_WAVES:
StartInterpolation(actor->spr.sector(), Interp_Sect_Floorheinum);
StartInterpolation(actor->spr.sector(), Interp_Sect_Floorz);
StartInterpolation(actor->sector(), Interp_Sect_Floorheinum);
StartInterpolation(actor->sector(), Interp_Sect_Floorz);
break;
}
@ -1077,7 +1077,7 @@ void lotsofglass(DDukeActor *actor, walltype* wal, int n)
for (j = n - 1; j >= 0; j--)
{
a = actor->spr.ang - 256 + (krand() & 511) + 1024;
EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
}
return;
}
@ -1102,7 +1102,7 @@ void lotsofglass(DDukeActor *actor, walltype* wal, int n)
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
a = actor->spr.ang - 1024;
EGS(actor->spr.sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
EGS(actor->sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
}
}
}
@ -1119,7 +1119,7 @@ void spriteglass(DDukeActor* actor, int n)
{
int a = krand() & 2047;
int z = actor->spr.pos.Z - ((krand() & 16) << 8);
auto k = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, z, TILE_GLASSPIECES + (j % 3), krand() & 15, 36, 36, a, 32 + (krand() & 63), -512 - (krand() & 2047), actor, 5);
auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, z, TILE_GLASSPIECES + (j % 3), krand() & 15, 36, 36, a, 32 + (krand() & 63), -512 - (krand() & 2047), actor, 5);
if (k) k->spr.pal = actor->spr.pal;
}
}
@ -1170,7 +1170,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
for (j = n - 1; j >= 0; j--)
{
a = krand() & 2047;
auto k = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
if (k) k->spr.pal = krand() & 15;
}
return;
@ -1191,7 +1191,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
a = actor->spr.ang - 1024;
auto k = EGS(actor->spr.sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 2047), actor, 5);
auto k = EGS(actor->sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 2047), actor, 5);
if (k) k->spr.pal = krand() & 7;
}
}

22
source/games/duke/src/spawn_d.cpp
View file

@ -43,7 +43,7 @@ BEGIN_DUKE_NS
DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors)
{
auto sectp = act->spr.sector();
auto sectp = act->sector();
if (isWorldTour())
{
@ -52,7 +52,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case BOSS2STAYPUT:
case BOSS3STAYPUT:
case BOSS5STAYPUT:
act->actorstayput = act->spr.sector();
act->actorstayput = act->sector();
[[fallthrough]];
case FIREFLY:
case BOSS5:
@ -157,13 +157,13 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
if (actj)
{
if (actj->spr.sector()->lotag == 2)
if (actj->sector()->lotag == 2)
{
act->spr.pos.Z = getceilzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8);
act->spr.pos.Z = getceilzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8);
act->spr.cstat |= CSTAT_SPRITE_YFLIP;
}
else if (actj->spr.sector()->lotag == 1)
act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
else if (actj->sector()->lotag == 1)
act->spr.pos.Z = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -296,7 +296,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_ALIGNMENT_FLOOR;
if (act->spr.picnum == LAVAPOOL) // Twentieth Anniversary World Tour
{
int fz = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
int fz = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
if (fz != act->spr.pos.Z)
act->spr.pos.Z = fz;
act->spr.pos.Z -= 200;
@ -640,7 +640,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
int x = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
int x = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.pos.Z > x - (12 << 8))
act->spr.pos.Z = x - (12 << 8);
}
@ -663,7 +663,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.xrepeat = actj->spr.xrepeat;
act->spr.yrepeat = actj->spr.yrepeat;
act->spr.zvel = 128;
if (act->spr.sector()->lotag != 2)
if (act->sector()->lotag != 2)
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
}
ChangeActorStat(act, STAT_DUMMYPLAYER);
@ -786,7 +786,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case PIGCOPDIVE:
case COMMANDERSTAYPUT:
case BOSS4STAYPUT:
act->actorstayput = act->spr.sector();
act->actorstayput = act->sector();
[[fallthrough]];
case BOSS1:
case BOSS2:
@ -917,7 +917,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case ACTIVATOR:
act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
if (act->spr.picnum == ACTIVATORLOCKED)
act->spr.sector()->lotag |= 16384;
act->sector()->lotag |= 16384;
ChangeActorStat(act, 8);
break;

18
source/games/duke/src/spawn_r.cpp
View file

@ -37,7 +37,7 @@ BEGIN_DUKE_NS
DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>* actors)
{
auto sectp = act->spr.sector();
auto sectp = act->sector();
switch (act->spr.picnum)
{
@ -210,13 +210,13 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
if (actj)
{
if (actj->spr.sector()->lotag == 2)
if (actj->sector()->lotag == 2)
{
act->spr.pos.Z = getceilzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8);
act->spr.pos.Z = getceilzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8);
act->spr.cstat |= CSTAT_SPRITE_YFLIP;
}
else if (actj->spr.sector()->lotag == 1)
act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
else if (actj->sector()->lotag == 1)
act->spr.pos.Z = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -649,7 +649,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
int x = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
int x = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.pos.Z > x - (12 << 8))
act->spr.pos.Z = x - (12 << 8);
}
@ -664,7 +664,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.xrepeat = actj->spr.xrepeat;
act->spr.yrepeat = actj->spr.yrepeat;
act->spr.zvel = 128;
if (act->spr.sector()->lotag != 2)
if (act->sector()->lotag != 2)
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
}
ChangeActorStat(act, 13);
@ -785,7 +785,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case MINIONSTAYPUT:
case COOTSTAYPUT:
rrra_stayput:
act->actorstayput = act->spr.sector();
act->actorstayput = act->sector();
[[fallthrough]];
case BOULDER:
case BOULDER1:
@ -1319,7 +1319,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.yrepeat = 16;
break;
}
act->spr.shade = act->spr.sector()->floorshade;
act->spr.shade = act->sector()->floorshade;
break;
case WATERFOUNTAIN:
act->spr.lotag = 1;

12
source/games/exhumed/src/anims.cpp
View file

@ -140,16 +140,16 @@ void AIAnim::Tick(RunListEvent* ev)
pActor->spr.pos.Y = pIgniter->spr.pos.Y;
pActor->spr.pos.Z = pIgniter->spr.pos.Z;
if (pIgniter->spr.sector() != pActor->spr.sector())
if (pIgniter->sector() != pActor->sector())
{
if (!pIgniter->spr.sector())
if (!pIgniter->sector())
{
DestroyAnim(pActor);
return;
}
else
{
ChangeActorSect(pActor, pIgniter->spr.sector());
ChangeActorSect(pActor, pIgniter->sector());
}
}
@ -230,7 +230,7 @@ void AIAnim::Draw(RunListEvent* ev)
void BuildExplosion(DExhumedActor* pActor)
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
int edx = 36;
@ -238,12 +238,12 @@ void BuildExplosion(DExhumedActor* pActor)
{
edx = 75;
}
else if (pActor->spr.pos.Z == pActor->spr.sector()->floorz)
else if (pActor->spr.pos.Z == pActor->sector()->floorz)
{
edx = 34;
}
BuildAnim(nullptr, edx, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), pActor->spr.xrepeat, 4);
BuildAnim(nullptr, edx, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), pActor->spr.xrepeat, 4);
}
void BuildSplash(DExhumedActor* pActor, sectortype* pSector)

14
source/games/exhumed/src/anubis.cpp
View file

@ -55,7 +55,7 @@ void BuildAnubis(DExhumedActor* ap, int x, int y, int z, sectortype* pSector, in
x = ap->spr.pos.X;
y = ap->spr.pos.Y;
z = ap->spr.sector()->floorz;
z = ap->sector()->floorz;
nAngle = ap->spr.ang;
}
@ -67,7 +67,7 @@ void BuildAnubis(DExhumedActor* ap, int x, int y, int z, sectortype* pSector, in
ap->spr.shade = -12;
ap->spr.yoffset = 0;
ap->spr.picnum = 1;
ap->spr.pal = ap->spr.sector()->ceilingpal;
ap->spr.pal = ap->sector()->ceilingpal;
ap->spr.clipdist = 60;
ap->spr.ang = nAngle;
ap->spr.xrepeat = 40;
@ -217,8 +217,8 @@ void AIAnubis::Tick(RunListEvent* ev)
if (pTarget != nullptr) // NOTE: nTarget can be -1. this check wasn't in original code. TODO: demo compatiblity?
{
if (cansee(ap->spr.pos.X, ap->spr.pos.Y, ap->spr.pos.Z - GetActorHeight(ap), ap->spr.sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->spr.sector()))
if (cansee(ap->spr.pos.X, ap->spr.pos.Y, ap->spr.pos.Z - GetActorHeight(ap), ap->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->sector()))
{
ap->spr.xvel = 0;
ap->spr.yvel = 0;
@ -397,11 +397,11 @@ void AIAnubis::Damage(RunListEvent* ev)
{
if (nAction >= 6 && nAction <= 10)
{
auto pDrumActor = insertActor(ap->spr.sector(), kStatAnubisDrum);
auto pDrumActor = insertActor(ap->sector(), kStatAnubisDrum);
pDrumActor->spr.pos.X = ap->spr.pos.X;
pDrumActor->spr.pos.Y = ap->spr.pos.Y;
pDrumActor->spr.pos.Z = pDrumActor->spr.sector()->floorz;
pDrumActor->spr.pos.Z = pDrumActor->sector()->floorz;
pDrumActor->spr.xrepeat = 40;
pDrumActor->spr.yrepeat = 40;
pDrumActor->spr.shade = -64;
@ -425,7 +425,7 @@ void AIAnubis::Damage(RunListEvent* ev)
ap->spr.xvel = 0;
ap->spr.yvel = 0;
ap->spr.zvel = 0;
ap->spr.pos.Z = ap->spr.sector()->floorz;
ap->spr.pos.Z = ap->sector()->floorz;
ap->spr.cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
ap->nHealth = 0;

4
source/games/exhumed/src/bubbles.cpp
View file

@ -89,7 +89,7 @@ void AIBubble::Tick(RunListEvent* ev)
pActor->spr.pos.Z += pActor->spr.zvel;
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
if (pActor->spr.pos.Z <= pSector->ceilingz)
{
@ -124,7 +124,7 @@ void DoBubbleMachines()
{
pActor->nCount = (RandomWord() % pActor->nFrame) + 30;
BuildBubble(pActor->spr.pos, pActor->spr.sector());
BuildBubble(pActor->spr.pos, pActor->sector());
}
}
}

28
source/games/exhumed/src/bullet.cpp
View file

@ -165,7 +165,7 @@ void IgniteSprite(DExhumedActor* pActor)
{
pActor->spr.hitag += 2;
auto pAnimActor = BuildAnim(nullptr, 38, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), 40, 20);
auto pAnimActor = BuildAnim(nullptr, 38, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), 40, 20);
if (pAnimActor)
{
@ -318,7 +318,7 @@ int MoveBullet(int nBullet)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int z = pActor->spr.pos.Z; // ebx
int nSectFlag = pActor->spr.sector()->Flag;
int nSectFlag = pActor->sector()->Flag;
int x2, y2, z2;
@ -377,7 +377,7 @@ MOVEEND:
x2 = pActor->spr.pos.X;
y2 = pActor->spr.pos.Y;
z2 = pActor->spr.pos.Z;
pHitSect = pActor->spr.sector();
pHitSect = pActor->sector();
#if 0
// Original code. This was producing some beautiful undefined behavior in the first case because the index can be anything, not just a wall.
@ -417,7 +417,7 @@ MOVEEND:
nVal = coll.type || coll.exbits? 1:0;
// pSprite's sector may have changed since we set nSectFlag ?
int nFlagVal = nSectFlag ^ pActor->spr.sector()->Flag;
int nFlagVal = nSectFlag ^ pActor->sector()->Flag;
if (nFlagVal & kSectUnderwater)
{
DestroyBullet(nBullet);
@ -426,7 +426,7 @@ MOVEEND:
if (nVal == 0 && nType != 15 && nType != 3)
{
AddFlash(pActor->spr.sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 0);
AddFlash(pActor->sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 0);
if (pActor->spr.pal != 5) {
pActor->spr.pal = 1;
@ -443,7 +443,7 @@ MOVEEND:
x2 = hitactor->spr.pos.X;
y2 = hitactor->spr.pos.Y;
z2 = hitactor->spr.pos.Z - (GetActorHeight(hitactor) >> 1);
pHitSect = hitactor->spr.sector();
pHitSect = hitactor->sector();
}
else
{
@ -454,7 +454,7 @@ MOVEEND:
dz = -bsin(pBullet->nPitch, 3);
else
dz = -pBullet->nPitch * 512;
hitscan(startPos, pActor->spr.sector(), { bcos(pActor->spr.ang), bsin(pActor->spr.ang), dz }, hit, CLIPMASK1);
hitscan(startPos, pActor->sector(), { bcos(pActor->spr.ang), bsin(pActor->spr.ang), dz }, hit, CLIPMASK1);
x2 = hit.hitpos.X;
y2 = hit.hitpos.Y;
z2 = hit.hitpos.Z;
@ -554,7 +554,7 @@ HITSPRITE:
nRadialBullet = -1;
AddFlash(pActor->spr.sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
AddFlash(pActor->sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
}
}
}
@ -587,14 +587,14 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
sBullet.nType = nType;
sBullet.nDoubleDamage = nDoubleDamage;
sBullet.pActor = insertActor(pActor->spr.sector(), 200);
sBullet.pActor = insertActor(pActor->sector(), 200);
sBullet.pActor->spr.ang = nAngle;
int nHeight = GetActorHeight(pTarget);
assert(pTarget->spr.sector());
assert(pTarget->sector());
BulletHitsSprite(&sBullet, pActor, pTarget, pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - (nHeight >> 1), pTarget->spr.sector());
BulletHitsSprite(&sBullet, pActor, pTarget, pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - (nHeight >> 1), pTarget->sector());
DeleteActor(sBullet.pActor);
return nullptr;
}
@ -618,7 +618,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
}
else
{
pSector = pActor->spr.sector();
pSector = pActor->sector();
}
auto pBulletActor = insertActor(pSector, 200);
@ -706,7 +706,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
int var_18 = 0;
pSector = pBulletActor->spr.sector();
pSector = pBulletActor->sector();
while (pBulletActor->spr.pos.Z < pSector->ceilingz)
{
@ -827,7 +827,7 @@ void AIBullet::Tick(RunListEvent* ev)
if (nFlag & 0x80)
{
BuildAnim(nullptr, 45, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), pActor->spr.xrepeat, 0);
BuildAnim(nullptr, 45, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), pActor->spr.xrepeat, 0);
}
BulletList[nBullet].nFrame++;

2
source/games/exhumed/src/exhumed.cpp
View file

@ -208,7 +208,7 @@ void DoRedAlert(int nVal)
if (nVal)
{
PlayFXAtXYZ(StaticSound[kSoundAlarm], ac->spr.pos.X, ac->spr.pos.Y, ac->spr.pos.Z);
AddFlash(ac->spr.sector(), ac->spr.pos.X, ac->spr.pos.Y, ac->spr.pos.Z, 192);
AddFlash(ac->sector(), ac->spr.pos.X, ac->spr.pos.Y, ac->spr.pos.Z, 192);
}
}
}

14
source/games/exhumed/src/fish.cpp
View file

@ -42,7 +42,7 @@ static actionSeq FishSeq[] = {
void BuildFishLimb(DExhumedActor* pActor, int anim)
{
auto pChunkActor = insertActor(pActor->spr.sector(), 99);
auto pChunkActor = insertActor(pActor->sector(), 99);
pChunkActor->nCount = anim + 40;
pChunkActor->nFrame = RandomSize(3) % SeqSize[SeqOffsets[kSeqFish] + anim + 40];
@ -96,11 +96,11 @@ void AIFishLimb::Tick(RunListEvent* ev)
{
pActor->nFrame = 0;
if (RandomBit()) {
BuildBlood(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector());
BuildBlood(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector());
}
}
int FloorZ = pActor->spr.sector()->floorz;
int FloorZ = pActor->sector()->floorz;
if (FloorZ <= pActor->spr.pos.Z)
{
@ -163,7 +163,7 @@ void BuildFish(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pActor->spr.clipdist = 80;
pActor->spr.xrepeat = 40;
pActor->spr.yrepeat = 40;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.picnum = seq_GetSeqPicnum(kSeqFish, FishSeq[0].a, 0);
@ -311,7 +311,7 @@ void AIFish::Tick(RunListEvent* ev)
int nAction = pActor->nAction;
if (!(pActor->spr.sector()->Flag & kSectUnderwater))
if (!(pActor->sector()->Flag & kSectUnderwater))
{
Gravity(pActor);
}
@ -422,12 +422,12 @@ void AIFish::Tick(RunListEvent* ev)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int z = pActor->spr.pos.Z;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
// loc_2EF54
Collision coll = movesprite(pActor, pActor->spr.xvel << 13, pActor->spr.yvel << 13, pActor->spr.zvel << 2, 0, 0, CLIPMASK0);
if (!(pActor->spr.sector()->Flag & kSectUnderwater))
if (!(pActor->sector()->Flag & kSectUnderwater))
{
ChangeActorSect(pActor, pSector);
pActor->spr.pos.X = x;

10
source/games/exhumed/src/grenade.cpp
View file

@ -145,7 +145,7 @@ void ExplodeGrenade(DExhumedActor* pActor)
int var_28, var_20;
int nPlayer = pActor->spr.owner;
auto pGrenadeSect = pActor->spr.sector();
auto pGrenadeSect = pActor->sector();
pActor->nFrame = 1;
@ -181,7 +181,7 @@ void ExplodeGrenade(DExhumedActor* pActor)
pActor->spr.pos.X = bcos(nAngle, -5) + pPlayerActor->spr.pos.X;
pActor->spr.pos.Y = bsin(nAngle, -5) + pPlayerActor->spr.pos.Y;
ChangeActorSect(pActor, pPlayerActor->spr.sector());
ChangeActorSect(pActor, pPlayerActor->sector());
if (!PlayerList[nPlayer].invincibility) {
PlayerList[nPlayer].nHealth = 1;
@ -196,8 +196,8 @@ void ExplodeGrenade(DExhumedActor* pActor)
runlist_RadialDamageEnemy(pActor, nDamage, BulletInfo[kWeaponGrenade].nRadius);
BuildAnim(nullptr, var_28, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), var_20, 4);
AddFlash(pActor->spr.sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
BuildAnim(nullptr, var_28, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), var_20, 4);
AddFlash(pActor->sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
DestroyGrenade(pActor);
}
@ -294,7 +294,7 @@ void AIGrenade::Tick(RunListEvent* ev)
{
if (zVel)
{
if (pActor->spr.sector()->Damage > 0)
if (pActor->sector()->Damage > 0)
{
ExplodeGrenade(pActor);
return;

6
source/games/exhumed/src/gun.cpp
View file

@ -613,7 +613,7 @@ loc_flag:
{
BuildFlash(nPlayer, 512);
AddFlash(
pPlayerActor->spr.sector(),
pPlayerActor->sector(),
pPlayerActor->spr.pos.X,
pPlayerActor->spr.pos.Y,
pPlayerActor->spr.pos.Z,
@ -687,7 +687,7 @@ loc_flag:
}
}
auto pSectorB = pPlayerActor->spr.sector();
auto pSectorB = pPlayerActor->sector();
switch (nWeapon)
{
@ -807,7 +807,7 @@ loc_flag:
{
DExhumedActor* t = sPlayerInput[nPlayer].pTarget;
// only autoaim if target is in front of the player.
assert(t->spr.sector());
assert(t->sector());
int angletotarget = bvectangbam(t->spr.pos.X - pPlayerActor->spr.pos.X, t->spr.pos.Y - pPlayerActor->spr.pos.Y).asbuild();
int anglediff = (pPlayerActor->spr.ang - angletotarget) & 2047;
if (anglediff < 512 || anglediff > 1536)

26
source/games/exhumed/src/init.cpp
View file

@ -420,12 +420,12 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
{
case 999:
{
AddFlicker(pActor->spr.sector(), nSpeed);
AddFlicker(pActor->sector(), nSpeed);
break;
}
case 998:
{
AddGlow(pActor->spr.sector(), nSpeed);
AddGlow(pActor->sector(), nSpeed);
break;
}
case 118: // Anubis with drum
@ -570,7 +570,7 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
}
case 99: // underwater type 2
{
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
pSector->pAbove = &sector[nHitag];
pSector->Flag |= kSectUnderwater;
@ -579,7 +579,7 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
}
case 98:
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
pSector->pBelow = &sector[nHitag];
SnapSectors(pSector, pSector->pBelow, 1);
@ -588,7 +588,7 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
}
case 97:
{
AddSectorBob(pActor->spr.sector(), nHitag, 1);
AddSectorBob(pActor->sector(), nHitag, 1);
DeleteActor(pActor);
return;
@ -600,7 +600,7 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
nDamage = 1;
}
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
pSector->Damage = nDamage;
pSector->Flag |= kSectLava;
@ -610,14 +610,14 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
}
case 95:
{
AddSectorBob(pActor->spr.sector(), nHitag, 0);
AddSectorBob(pActor->sector(), nHitag, 0);
DeleteActor(pActor);
return;
}
case 94: // water
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
pSector->Depth = nHitag << 8;
DeleteActor(pActor);
@ -636,7 +636,7 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
case 79:
case 89:
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
pSector->Speed = nSpeed;
pSector->Flag |= pActor->spr.ang;
@ -645,14 +645,14 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
}
case 88:
{
AddFlow(pActor->spr.sector(), nSpeed, 0, pActor->spr.ang);
AddFlow(pActor->sector(), nSpeed, 0, pActor->spr.ang);
DeleteActor(pActor);
return;
}
case 80: // underwater
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
pSector->Flag |= kSectUnderwater;
DeleteActor(pActor);
@ -660,9 +660,9 @@ void ProcessSpriteTag(DExhumedActor* pActor, int nLotag, int nHitag)
}
case 78:
{
AddFlow(pActor->spr.sector(), nSpeed, 1, pActor->spr.ang);
AddFlow(pActor->sector(), nSpeed, 1, pActor->spr.ang);
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
pSector->Flag |= 0x8000;
DeleteActor(pActor);

8
source/games/exhumed/src/items.cpp
View file

@ -123,7 +123,7 @@ void BuildItemAnim(DExhumedActor* pActor)
if (nItemAnimInfo[nItem].a >= 0)
{
auto pAnimActor = BuildAnim(pActor, 41, nItemAnimInfo[nItem].a, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), nItemAnimInfo[nItem].repeat, 20);
auto pAnimActor = BuildAnim(pActor, 41, nItemAnimInfo[nItem].a, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), nItemAnimInfo[nItem].repeat, 20);
if (nItem == 44) {
pAnimActor->spr.cstat |= CSTAT_SPRITE_TRANSLUCENT;
@ -341,13 +341,13 @@ void DropMagic(DExhumedActor* pActor)
pActor->spr.pos.X,
pActor->spr.pos.Y,
pActor->spr.pos.Z,
pActor->spr.sector(),
pActor->sector(),
48,
4);
if (pAnimActor)
{
AddFlash(pAnimActor->spr.sector(), pAnimActor->spr.pos.X, pAnimActor->spr.pos.Y, pAnimActor->spr.pos.Z, 128);
AddFlash(pAnimActor->sector(), pAnimActor->spr.pos.X, pAnimActor->spr.pos.Y, pAnimActor->spr.pos.Z, 128);
ChangeActorStat(pAnimActor, 950);
}
nMagicCount = RandomSize(2);
@ -401,7 +401,7 @@ void DoRegenerates()
if (pActor->spr.extra <= 0)
{
BuildAnim(nullptr, 38, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), 64, 4);
BuildAnim(nullptr, 38, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), 64, 4);
D3PlayFX(StaticSound[kSoundTorchOn], pActor);
}
else {

8
source/games/exhumed/src/lavadude.cpp
View file

@ -39,7 +39,7 @@ static actionSeq LavadudeSeq[] = {
DExhumedActor* BuildLavaLimb(DExhumedActor* pActor, int move, int ebx)
{
auto pLimbActor = insertActor(pActor->spr.sector(), 118);
auto pLimbActor = insertActor(pActor->sector(), 118);
pLimbActor->spr.pos.X = pActor->spr.pos.X;
pLimbActor->spr.pos.Y = pActor->spr.pos.Y;
@ -107,7 +107,7 @@ void BuildLava(DExhumedActor* pActor, int x, int y, int, sectortype* pSector, in
}
else
{
pSector = pActor->spr.sector();
pSector = pActor->sector();
nAngle = pActor->spr.ang;
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
@ -285,11 +285,11 @@ void AILavaDude::Tick(RunListEvent* ev)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int z = pActor->spr.pos.Z;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
auto coll = movesprite(pActor, pActor->spr.xvel << 8, pActor->spr.yvel << 8, 0, 0, 0, CLIPMASK0);
if (pSector != pActor->spr.sector())
if (pSector != pActor->sector())
{
ChangeActorSect(pActor, pSector);
pActor->spr.pos.X = x;

6
source/games/exhumed/src/lion.cpp
View file

@ -52,7 +52,7 @@ void BuildLion(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
ChangeActorStat(pActor, 104);
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
z = pActor->spr.sector()->floorz;
z = pActor->sector()->floorz;
nAngle = pActor->spr.ang;
}
@ -65,7 +65,7 @@ void BuildLion(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pActor->spr.xrepeat = 40;
pActor->spr.yrepeat = 40;
pActor->spr.picnum = 1;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.ang = nAngle;
@ -397,7 +397,7 @@ void AILion::Tick(RunListEvent* ev)
{
HitInfo hit{};
hitscan({ x, y, z }, pActor->spr.sector(), { bcos(nScanAngle), bsin(nScanAngle), 0 }, hit, CLIPMASK1);
hitscan({ x, y, z }, pActor->sector(), { bcos(nScanAngle), bsin(nScanAngle), 0 }, hit, CLIPMASK1);
if (hit.hitWall)
{

2
source/games/exhumed/src/map.cpp
View file

@ -89,7 +89,7 @@ bool GameInterface::DrawAutomapPlayer(int mx, int my, int x, int y, int z, int a
int nTile = pPlayerActor->spr.picnum;
int ceilZ, floorZ;
Collision ceilHit, floorHit;
getzrange(pPlayerActor->spr.pos, pPlayerActor->spr.sector(), &ceilZ, ceilHit, &floorZ, floorHit, (pPlayerActor->spr.clipdist << 2) + 16, CLIPMASK0);
getzrange(pPlayerActor->spr.pos, pPlayerActor->sector(), &ceilZ, ceilHit, &floorZ, floorHit, (pPlayerActor->spr.clipdist << 2) + 16, CLIPMASK0);
int nTop, nBottom;
GetActorExtents(pPlayerActor, &nTop, &nBottom);
int nScale = (pPlayerActor->spr.yrepeat + ((floorZ - nBottom) >> 8)) * z;

50
source/games/exhumed/src/move.cpp
View file

@ -239,7 +239,7 @@ void clipwall()
int BelowNear(DExhumedActor* pActor, int x, int y, int walldist)
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
int z = pActor->spr.pos.Z;
int z2;
@ -310,7 +310,7 @@ int BelowNear(DExhumedActor* pActor, int x, int y, int walldist)
Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdist)
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
assert(pSector);
overridesect = pSector;
@ -341,9 +341,9 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
}
// loc_151E7:
while (ebp > pActor->spr.sector()->floorz && pActor->spr.sector()->pBelow != nullptr)
while (ebp > pActor->sector()->floorz && pActor->sector()->pBelow != nullptr)
{
ChangeActorSect(pActor, pActor->spr.sector()->pBelow);
ChangeActorSect(pActor, pActor->sector()->pBelow);
}
if (pSect2 != pSector)
@ -363,9 +363,9 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
}
else
{
while ((ebp < pActor->spr.sector()->ceilingz) && (pActor->spr.sector()->pAbove != nullptr))
while ((ebp < pActor->sector()->ceilingz) && (pActor->sector()->pAbove != nullptr))
{
ChangeActorSect(pActor, pActor->spr.sector()->pAbove);
ChangeActorSect(pActor, pActor->sector()->pAbove);
}
}
@ -373,12 +373,12 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
// This function finds the highest and lowest z coordinates that your clipping BOX can get to.
vec3_t pos = pActor->spr.pos;
pos.Z -= 256;
getzrange(pos, pActor->spr.sector(), &sprceiling, hiHit, &sprfloor, loHit, 128, CLIPMASK0);
getzrange(pos, pActor->sector(), &sprceiling, hiHit, &sprfloor, loHit, 128, CLIPMASK0);
int mySprfloor = sprfloor;
if (loHit.type != kHitSprite) {
mySprfloor += pActor->spr.sector()->Depth;
mySprfloor += pActor->sector()->Depth;
}
if (ebp > mySprfloor)
@ -419,11 +419,11 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
else
{
// Path B
if (pActor->spr.sector()->pBelow == nullptr)
if (pActor->sector()->pBelow == nullptr)
{
nRet.exbits |= kHitAux2;
int nSectDamage = pActor->spr.sector()->Damage;
int nSectDamage = pActor->sector()->Damage;
if (nSectDamage != 0)
{
@ -450,7 +450,7 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
}
else
{
if ((ebp - height) < sprceiling && (hiHit.type == kHitSprite || pActor->spr.sector()->pAbove == nullptr))
if ((ebp - height) < sprceiling && (hiHit.type == kHitSprite || pActor->sector()->pAbove == nullptr))
{
ebp = sprceiling + height;
nRet.exbits |= kHitAux1;
@ -499,7 +499,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
int nClipDist = (int8_t)pActor->spr.clipdist << 2;
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
assert(pSector);
int floorZ = pSector->floorz;
@ -512,7 +512,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
Collision nRet = movespritez(pActor, dz, nSpriteHeight, flordist, nClipDist);
pSector = pActor->spr.sector(); // modified in movespritez so re-grab this variable
pSector = pActor->sector(); // modified in movespritez so re-grab this variable
if (pActor->spr.statnum == 100)
{
@ -545,7 +545,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
nRet = coll;
}
if ((pSector != pActor->spr.sector()) && pSector != nullptr)
if ((pSector != pActor->sector()) && pSector != nullptr)
{
if (nRet.exbits & kHitAux2) {
dz = 0;
@ -562,7 +562,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
if (pActor->spr.pal < 5 && !pActor->spr.hitag)
{
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
}
}
}
@ -572,7 +572,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
void Gravity(DExhumedActor* pActor)
{
if (pActor->spr.sector()->Flag & kSectUnderwater)
if (pActor->sector()->Flag & kSectUnderwater)
{
if (pActor->spr.statnum != 100)
{
@ -624,11 +624,11 @@ Collision MoveCreatureWithCaution(DExhumedActor* pActor)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int z = pActor->spr.pos.Z;
auto pSectorPre = pActor->spr.sector();
auto pSectorPre = pActor->sector();
auto ecx = MoveCreature(pActor);
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
if (pSector != pSectorPre)
{
@ -698,7 +698,7 @@ DExhumedActor* FindPlayer(DExhumedActor* pActor, int nDistance, bool dontengage)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
int z = pActor->spr.pos.Z - GetActorHeight(pActor);
@ -722,7 +722,7 @@ DExhumedActor* FindPlayer(DExhumedActor* pActor, int nDistance, bool dontengage)
{
int v10 = abs(pPlayerActor->spr.pos.Y - y);
if (v10 < nDistance && cansee(pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z - 7680, pPlayerActor->spr.sector(), x, y, z, pSector))
if (v10 < nDistance && cansee(pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z - 7680, pPlayerActor->sector(), x, y, z, pSector))
{
break;
}
@ -1081,7 +1081,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
inity = pActor->spr.pos.Y;
initz = pActor->spr.pos.Z;
inita = pActor->spr.ang;
initsectp = pActor->spr.sector();
initsectp = pActor->sector();
}
void SetQuake(DExhumedActor* pActor, int nVal)
@ -1239,7 +1239,7 @@ void WheresMyMouth(int nPlayer, vec3_t* pos, sectortype **sectnum)
auto pActor = PlayerList[nPlayer].pActor;
int height = GetActorHeight(pActor) >> 1;
*sectnum = pActor->spr.sector();
*sectnum = pActor->sector();
*pos = pActor->spr.pos;
pos->Z -= height;
@ -1358,7 +1358,7 @@ DExhumedActor* BuildCreatureChunk(DExhumedActor* pSrc, int nPic, bool bSpecial)
}
pActor->spr.pos = pSrc->spr.pos;
ChangeActorSect(pActor, pSrc->spr.sector());
ChangeActorSect(pActor, pSrc->sector());
pActor->spr.cstat = CSTAT_SPRITE_YCENTER;
pActor->spr.shade = -12;
@ -1399,7 +1399,7 @@ void AICreatureChunk::Tick(RunListEvent* ev)
Gravity(pActor);
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
pActor->spr.pal = pSector->ceilingpal;
auto nVal = movesprite(pActor, pActor->spr.xvel << 10, pActor->spr.yvel << 10, pActor->spr.zvel, 2560, -2560, CLIPMASK1);
@ -1407,7 +1407,7 @@ void AICreatureChunk::Tick(RunListEvent* ev)
if (pActor->spr.pos.Z >= pSector->floorz)
{
// re-grab this variable as it may have changed in movesprite(). Note the check above is against the value *before* movesprite so don't change it.
pSector = pActor->spr.sector();
pSector = pActor->sector();
pActor->spr.xvel = 0;
pActor->spr.yvel = 0;

12
source/games/exhumed/src/mummy.cpp
View file

@ -64,7 +64,7 @@ void BuildMummy(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pActor->spr.zvel = 0;
pActor->spr.xrepeat = 42;
pActor->spr.yrepeat = 42;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.ang = nAngle;
@ -104,8 +104,8 @@ void CheckMummyRevive(DExhumedActor* pActor)
if (x <= 20 && y <= 20)
{
if (cansee(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - 8192, pActor->spr.sector(),
pOther->spr.pos.X, pOther->spr.pos.Y, pOther->spr.pos.Z - 8192, pOther->spr.sector()))
if (cansee(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - 8192, pActor->sector(),
pOther->spr.pos.X, pOther->spr.pos.Y, pOther->spr.pos.Z - 8192, pOther->sector()))
{
pOther->spr.cstat = 0;
pOther->nAction = 6;
@ -208,8 +208,8 @@ void AIMummy::Tick(RunListEvent* ev)
{
if (RandomBit() && pTarget)
{
if (cansee(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - GetActorHeight(pActor), pActor->spr.sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->spr.sector()))
if (cansee(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - GetActorHeight(pActor), pActor->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->sector()))
{
pActor->nAction = 3;
pActor->nFrame = 0;
@ -450,7 +450,7 @@ void AIMummy::Damage(RunListEvent* ev)
pActor->spr.xvel = 0;
pActor->spr.yvel = 0;
pActor->spr.zvel = 0;
pActor->spr.pos.Z = pActor->spr.sector()->floorz;
pActor->spr.pos.Z = pActor->sector()->floorz;
}
else
{

20
source/games/exhumed/src/object.cpp
View file

@ -1234,7 +1234,7 @@ int BuildTrap(DExhumedActor* pActor, int edx, int ebx, int ecx)
return nTrap;
}
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
for(auto& wal : wallsofsector(pSector))
{
@ -1356,7 +1356,7 @@ int BuildFireBall(DExhumedActor* nSprite, int a, int b)
DExhumedActor* BuildSpark(DExhumedActor* pActor, int nVal)
{
auto pSpark = insertActor(pActor->spr.sector(), 0);
auto pSpark = insertActor(pActor->sector(), 0);
pSpark->spr.pos.X = pActor->spr.pos.X;
pSpark->spr.pos.Y = pActor->spr.pos.Y;
@ -1637,7 +1637,7 @@ void KillCreatures()
void ExplodeEnergyBlock(DExhumedActor* pActor)
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
for(auto& wal : wallsofsector(pSector))
{
@ -1764,7 +1764,7 @@ void AIEnergyBlock::RadialDamage(RunListEvent* ev)
auto pActor = ev->pObjActor;
if (!pActor) return;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
if (pSector->extra == -1) {
return;
@ -1826,7 +1826,7 @@ DExhumedActor* BuildObject(DExhumedActor* pActor, int nOjectType, int nHitag)
pActor->nFrame = RandomSize(4) % (SeqSize[pActor->nIndex] - 1);
}
auto pActor2 = insertActor(pActor->spr.sector(), 0);
auto pActor2 = insertActor(pActor->sector(), 0);
pActor->pTarget = pActor2;
pActor->nIndex2 = -1;
@ -1928,7 +1928,7 @@ void AIObject::Tick(RunListEvent* ev)
int var_18;
// red branch
if ((nStat == kStatExplodeTarget) || (pActor->spr.pos.Z < pActor->spr.sector()->floorz))
if ((nStat == kStatExplodeTarget) || (pActor->spr.pos.Z < pActor->sector()->floorz))
{
var_18 = 36;
}
@ -1937,8 +1937,8 @@ void AIObject::Tick(RunListEvent* ev)
var_18 = 34;
}
AddFlash(pActor->spr.sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
BuildAnim(nullptr, var_18, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.sector()->floorz, pActor->spr.sector(), 240, 4);
AddFlash(pActor->sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
BuildAnim(nullptr, var_18, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->sector()->floorz, pActor->sector(), 240, 4);
// int edi = nSprite | 0x4000;
@ -1971,7 +1971,7 @@ void AIObject::Tick(RunListEvent* ev)
pActor->nHealth = 120;
pActor->spr.pos = pActor->pTarget->spr.pos;
ChangeActorSect(pActor, pActor->pTarget->spr.sector());
ChangeActorSect(pActor, pActor->pTarget->sector());
return;
}
}
@ -2103,7 +2103,7 @@ void DoDrips()
if (!pActor) continue;
int nSeqOffset = SeqOffsets[kSeqDrips];
if (!(pActor->spr.sector()->Flag & kSectLava)) {
if (!(pActor->sector()->Flag & kSectLava)) {
nSeqOffset++;
}

78
source/games/exhumed/src/player.cpp
View file

@ -249,7 +249,7 @@ void RestartPlayer(int nPlayer)
ChangeActorSect(pActor, plr->sPlayerSave.pSector);
ChangeActorStat(pActor, 100);
auto pDActor = insertActor(pActor->spr.sector(), 100);
auto pDActor = insertActor(pActor->sector(), 100);
plr->pDoppleSprite = pDActor;
if (nTotalPlayers > 1)
@ -264,11 +264,11 @@ void RestartPlayer(int nPlayer)
pActor->spr.pos.X = nNStartSprite->spr.pos.X;
pActor->spr.pos.Y = nNStartSprite->spr.pos.Y;
pActor->spr.pos.Z = nNStartSprite->spr.pos.Z;
ChangeActorSect(pActor, nNStartSprite->spr.sector());
ChangeActorSect(pActor, nNStartSprite->sector());
plr->angle.ang = buildang(nNStartSprite->spr.ang&kAngleMask);
pActor->spr.ang = plr->angle.ang.asbuild();
floorsprt = insertActor(pActor->spr.sector(), 0);
floorsprt = insertActor(pActor->sector(), 0);
floorsprt->spr.pos.X = pActor->spr.pos.X;
floorsprt->spr.pos.Y = pActor->spr.pos.Y;
@ -434,7 +434,7 @@ void StartDeathSeq(int nPlayer, int nVal)
auto pActor = PlayerList[nPlayer].pActor;
PlayerList[nPlayer].nHealth = 0;
int nLotag = pActor->spr.sector()->lotag;
int nLotag = pActor->sector()->lotag;
if (nLotag > 0) {
runlist_SignalRun(nLotag - 1, nPlayer, &ExhumedAI::EnterSector);
@ -452,7 +452,7 @@ void StartDeathSeq(int nPlayer, int nVal)
if (nWeapon > kWeaponSword && nWeapon <= kWeaponRing)
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
if (pSector->pBelow != nullptr) {
pSector = pSector->pBelow;
}
@ -484,7 +484,7 @@ void StartDeathSeq(int nPlayer, int nVal)
SetNewWeaponImmediate(nPlayer, -2);
if (pActor->spr.sector()->Damage <= 0)
if (pActor->sector()->Damage <= 0)
{
PlayerList[nPlayer].nDeathType = nVal;
}
@ -495,7 +495,7 @@ void StartDeathSeq(int nPlayer, int nVal)
nVal *= 2;
if (nVal || !(pActor->spr.sector()->Flag & kSectUnderwater))
if (nVal || !(pActor->sector()->Flag & kSectUnderwater))
{
PlayerList[nPlayer].nAction = nVal + 17;
}
@ -665,7 +665,7 @@ void AIPlayer::Damage(RunListEvent* ev)
return;
}
if (pPlayerActor->spr.sector()->Flag & kSectUnderwater)
if (pPlayerActor->sector()->Flag & kSectUnderwater)
{
if (nAction != 12)
{
@ -780,7 +780,7 @@ void AIPlayer::Tick(RunListEvent* ev)
if (nPlayer != nLocalPlayer)
{
nFlashDepth = 5;
AddFlash(pPlayerActor->spr.sector(),
AddFlash(pPlayerActor->sector(),
pPlayerActor->spr.pos.X,
pPlayerActor->spr.pos.Y,
pPlayerActor->spr.pos.Z, 0);
@ -852,7 +852,7 @@ void AIPlayer::Tick(RunListEvent* ev)
}
// loc_1A4E6
auto pSector = pPlayerActor->spr.sector();
auto pSector = pPlayerActor->sector();
int nSectFlag = PlayerList[nPlayer].pPlayerViewSect->Flag;
int playerX = pPlayerActor->spr.pos.X;
@ -874,7 +874,7 @@ void AIPlayer::Tick(RunListEvent* ev)
int spr_x = pPlayerActor->spr.pos.X;
int spr_y = pPlayerActor->spr.pos.Y;
int spr_z = pPlayerActor->spr.pos.Z;
auto spr_sect = pPlayerActor->spr.sector();
auto spr_sect = pPlayerActor->sector();
// TODO
// nSectFlag & kSectUnderwater;
@ -891,22 +891,22 @@ void AIPlayer::Tick(RunListEvent* ev)
vec3_t pos = { pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z };
SetActor(pPlayerActor, &pos);
pPlayerActor->spr.pos.Z = pPlayerActor->spr.sector()->floorz;
pPlayerActor->spr.pos.Z = pPlayerActor->sector()->floorz;
}
else
{
nMove = movesprite(pPlayerActor, x, y, z, 5120, -5120, CLIPMASK0);
auto pPlayerSect = pPlayerActor->spr.sector();
auto pPlayerSect = pPlayerActor->sector();
pushmove(&pPlayerActor->spr.pos, &pPlayerSect, pPlayerActor->spr.clipdist << 2, 5120, -5120, CLIPMASK0);
if (pPlayerSect != pPlayerActor->spr.sector()) {
if (pPlayerSect != pPlayerActor->sector()) {
ChangeActorSect(pPlayerActor, pPlayerSect);
}
}
// loc_1A6E4
if (inside(pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.sector()) != 1)
if (inside(pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->sector()) != 1)
{
ChangeActorSect(pPlayerActor, spr_sect);
@ -919,7 +919,7 @@ void AIPlayer::Tick(RunListEvent* ev)
}
// int _bTouchFloor = bTouchFloor;
int bUnderwater = pPlayerActor->spr.sector()->Flag & kSectUnderwater;
int bUnderwater = pPlayerActor->sector()->Flag & kSectUnderwater;
if (bUnderwater)
{
@ -928,7 +928,7 @@ void AIPlayer::Tick(RunListEvent* ev)
}
// Trigger Ramses?
if ((pPlayerActor->spr.sector()->Flag & 0x8000) && bTouchFloor)
if ((pPlayerActor->sector()->Flag & 0x8000) && bTouchFloor)
{
if (nTotalPlayers <= 1)
{
@ -1100,7 +1100,7 @@ sectdone:
PlayerList[nPlayer].ototalvel = PlayerList[nPlayer].totalvel;
PlayerList[nPlayer].totalvel = ksqrt(sqrtNum);
auto pViewSect = pPlayerActor->spr.sector();
auto pViewSect = pPlayerActor->sector();
int EyeZ = PlayerList[nPlayer].eyelevel + pPlayerActor->spr.pos.Z + nQuake[nPlayer];
@ -1120,7 +1120,7 @@ sectdone:
// Do underwater sector check
if (bUnderwater)
{
if (pViewSect != pPlayerActor->spr.sector())
if (pViewSect != pPlayerActor->sector())
{
if (nMove.type == kHitWall)
{
@ -1140,7 +1140,7 @@ sectdone:
auto coll = movesprite(pPlayerActor, x, y, 0, 5120, 0, CLIPMASK0);
if (coll.type == kHitWall)
{
ChangeActorSect(pPlayerActor, pPlayerActor->spr.sector());
ChangeActorSect(pPlayerActor, pPlayerActor->sector());
pPlayerActor->spr.pos.X = var_C4;
pPlayerActor->spr.pos.Y = var_D4;
@ -1239,7 +1239,7 @@ sectdone:
}
else
{
auto pTmpSect = pPlayerActor->spr.sector();
auto pTmpSect = pPlayerActor->sector();
if (PlayerList[nPlayer].totalvel > 25 && pPlayerActor->spr.pos.Z > pTmpSect->floorz)
{
@ -1279,12 +1279,12 @@ sectdone:
pFloorActor->spr.pos.X = pPlayerActor->spr.pos.X;
pFloorActor->spr.pos.Y = pPlayerActor->spr.pos.Y;
if (pFloorActor->spr.sector() != pPlayerActor->spr.sector())
if (pFloorActor->sector() != pPlayerActor->sector())
{
ChangeActorSect(pFloorActor, pPlayerActor->spr.sector());
ChangeActorSect(pFloorActor, pPlayerActor->sector());
}
pFloorActor->spr.pos.Z = pPlayerActor->spr.sector()->floorz;
pFloorActor->spr.pos.Z = pPlayerActor->sector()->floorz;
}
int var_30 = 0;
@ -1303,10 +1303,10 @@ sectdone:
HitInfo near;
// neartag finds the nearest sector, wall, and sprite which has its hitag and/or lotag set to a value.
neartag(pPlayerActor->spr.pos, pPlayerActor->spr.sector(), pPlayerActor->spr.ang, near, 1024, 2);
neartag(pPlayerActor->spr.pos, pPlayerActor->sector(), pPlayerActor->spr.ang, near, 1024, 2);
DExhumedActor* pActorB;
feebtag(pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z, pPlayerActor->spr.sector(), &pActorB, var_30, 768);
feebtag(pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z, pPlayerActor->sector(), &pActorB, var_30, 768);
// Item pickup code
if (pActorB != nullptr && pActorB->spr.statnum >= 900)
@ -2201,7 +2201,7 @@ sectdone:
ChangeActorStat(pActorB, 899);
}
SetSavePoint(nPlayer, pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z, pPlayerActor->spr.sector(), pPlayerActor->spr.ang);
SetSavePoint(nPlayer, pPlayerActor->spr.pos.X, pPlayerActor->spr.pos.Y, pPlayerActor->spr.pos.Z, pPlayerActor->sector(), pPlayerActor->spr.ang);
break;
}
@ -2223,22 +2223,22 @@ sectdone:
// CORRECT ? // loc_1BAF9:
if (bTouchFloor)
{
if (pPlayerActor->spr.sector()->lotag > 0)
if (pPlayerActor->sector()->lotag > 0)
{
runlist_SignalRun(pPlayerActor->spr.sector()->lotag - 1, nPlayer, &ExhumedAI::TouchFloor);
runlist_SignalRun(pPlayerActor->sector()->lotag - 1, nPlayer, &ExhumedAI::TouchFloor);
}
}
if (pSector != pPlayerActor->spr.sector())
if (pSector != pPlayerActor->sector())
{
if (pSector->lotag > 0)
{
runlist_SignalRun(pSector->lotag - 1, nPlayer, &ExhumedAI::EnterSector);
}
if (pPlayerActor->spr.sector()->lotag > 0)
if (pPlayerActor->sector()->lotag > 0)
{
runlist_SignalRun(pPlayerActor->spr.sector()->lotag - 1, nPlayer, &ExhumedAI::LeaveSector);
runlist_SignalRun(pPlayerActor->sector()->lotag - 1, nPlayer, &ExhumedAI::LeaveSector);
}
}
@ -2273,7 +2273,7 @@ sectdone:
// loc_1BC57:
// CHECKME - are we finished with 'nSector' variable at this point? if so, maybe set it to pPlayerActor->spr.sector so we can make this code a bit neater. Don't assume pPlayerActor->spr.sector == nSector here!!
if (nStandHeight > (pPlayerActor->spr.sector()->floorz - pPlayerActor->spr.sector()->ceilingz)) {
if (nStandHeight > (pPlayerActor->sector()->floorz - pPlayerActor->sector()->ceilingz)) {
var_48 = 1;
}
@ -2471,7 +2471,7 @@ sectdone:
{
pPlayerActor->spr.picnum = seq_GetSeqPicnum(kSeqJoe, 120, 0);
pPlayerActor->spr.cstat = 0;
pPlayerActor->spr.pos.Z = pPlayerActor->spr.sector()->floorz;
pPlayerActor->spr.pos.Z = pPlayerActor->sector()->floorz;
}
// will invalidate nPlayerSprite
@ -2519,7 +2519,7 @@ sectdone:
case 16:
PlayerList[nPlayer].nSeqSize = SeqSize[var_AC] - 1;
if (pPlayerActor->spr.pos.Z < pPlayerActor->spr.sector()->floorz) {
if (pPlayerActor->spr.pos.Z < pPlayerActor->sector()->floorz) {
pPlayerActor->spr.pos.Z += 256;
}
@ -2548,7 +2548,7 @@ sectdone:
initx = pPlayerActor->spr.pos.X;
inity = pPlayerActor->spr.pos.Y;
initz = pPlayerActor->spr.pos.Z;
initsectp = pPlayerActor->spr.sector();
initsectp = pPlayerActor->sector();
inita = pPlayerActor->spr.ang;
}
@ -2579,7 +2579,7 @@ sectdone:
}
else if (PlayerList[nPlayer].horizon.horiz.asq16() <= 0)
{
if (!(pPlayerActor->spr.sector()->Flag & kSectUnderwater))
if (!(pPlayerActor->sector()->Flag & kSectUnderwater))
{
SetNewWeapon(nPlayer, PlayerList[nPlayer].nDeathType + 8);
}
@ -2593,10 +2593,10 @@ sectdone:
// loc_1C4E1
pDopple->spr.pos = pPlayerActor->spr.pos;
if (pPlayerActor->spr.sector()->pAbove != nullptr)
if (pPlayerActor->sector()->pAbove != nullptr)
{
pDopple->spr.ang = pPlayerActor->spr.ang;
ChangeActorSect(pDopple, pPlayerActor->spr.sector()->pAbove);
ChangeActorSect(pDopple, pPlayerActor->sector()->pAbove);
pDopple->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
}
else

24
source/games/exhumed/src/queen.cpp
View file

@ -249,7 +249,7 @@ void DestroyEgg(int nEgg)
if (QueenEgg[nEgg].nAction != 4)
{
BuildAnim(nullptr, 34, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), pActor->spr.xrepeat, 4);
BuildAnim(nullptr, 34, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), pActor->spr.xrepeat, 4);
}
else
{
@ -395,7 +395,7 @@ void BuildTail()
int x = head->spr.pos.X;
int y = head->spr.pos.X;
int z = head->spr.pos.X;
auto pSector =head->spr.sector();
auto pSector =head->sector();
int i;
@ -415,7 +415,7 @@ void BuildTail()
pTailActor->spr.xrepeat = 80;
pTailActor->spr.yrepeat = 80;
pTailActor->spr.picnum = 1;
pTailActor->spr.pal = pTailActor->spr.sector()->ceilingpal;
pTailActor->spr.pal = pTailActor->sector()->ceilingpal;
pTailActor->spr.xoffset = 0;
pTailActor->spr.yoffset = 0;
pTailActor->spr.pos.Z = z;
@ -447,7 +447,7 @@ void BuildQueenEgg(int nQueen, int nVal)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
int nFloorZ = pSector->floorz;
int nAngle = pActor->spr.ang;
@ -654,7 +654,7 @@ void AIQueenEgg::Tick(RunListEvent* ev)
pEgg->nCounter--;
if (pEgg->nCounter <= 0)
{
auto pWaspSprite = BuildWasp(nullptr, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), pActor->spr.ang, true);
auto pWaspSprite = BuildWasp(nullptr, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), pActor->spr.ang, true);
pActor->spr.pos.Z = pWaspSprite->spr.pos.Z;
DestroyEgg(nEgg);
@ -708,7 +708,7 @@ void BuildQueenHead(int nQueen)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int nAngle = pActor->spr.ang;
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
int z = pSector->floorz;
auto pActor2 = insertActor(pSector, 121);
@ -926,8 +926,8 @@ void AIQueenHead::Tick(RunListEvent* ev)
MoveQX[nQHead] = pActor->spr.pos.X;
MoveQY[nQHead] = pActor->spr.pos.Y;
MoveQZ[nQHead] = pActor->spr.pos.Z;
assert(pActor->spr.sector());
MoveQS[nQHead] = pActor->spr.sector();
assert(pActor->sector());
MoveQS[nQHead] = pActor->sector();
MoveQA[nQHead] = pActor->spr.ang;
nHd = nQHead;
@ -944,7 +944,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
DExhumedActor* pTActor = tailspr[i];
if (pTActor)
{
if (headSect != pTActor->spr.sector())
if (headSect != pTActor->sector())
{
assert(headSect);
ChangeActorSect(pTActor, headSect);
@ -978,7 +978,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int z = pActor->spr.pos.Z;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
int nAngle = RandomSize(11) & kAngleMask;
pActor->spr.xrepeat = 127 - QueenHead.nIndex2;
@ -1122,7 +1122,7 @@ void BuildQueen(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
ChangeActorStat(pActor, 121);
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
z = pActor->spr.sector()->floorz;
z = pActor->sector()->floorz;
nAngle = pActor->spr.ang;
}
@ -1474,7 +1474,7 @@ void AIQueen::Damage(RunListEvent* ev)
QueenList[nQueen].nHealth = 4000;
QueenList[nQueen].nAction = 7;
BuildAnim(nullptr, 36, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - 7680, pActor->spr.sector(), pActor->spr.xrepeat, 4);
BuildAnim(nullptr, 36, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - 7680, pActor->sector(), pActor->spr.xrepeat, 4);
break;
case 2:
QueenList[nQueen].nHealth = 4000;

10
source/games/exhumed/src/ra.cpp
View file

@ -87,7 +87,7 @@ void BuildRa(int nPlayer)
{
auto pPlayerActor = PlayerList[nPlayer].pActor;
auto pActor = insertActor(pPlayerActor->spr.sector(), 203);
auto pActor = insertActor(pPlayerActor->sector(), 203);
pActor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
pActor->spr.xvel = 0;
@ -141,8 +141,8 @@ void MoveRaToEnemy(int nPlayer)
}
else
{
if (pActor->spr.sector() != pTarget->spr.sector()) {
ChangeActorSect(pActor, pTarget->spr.sector());
if (pActor->sector() != pTarget->sector()) {
ChangeActorSect(pActor, pTarget->sector());
}
}
}
@ -167,8 +167,8 @@ void MoveRaToEnemy(int nPlayer)
pActor->spr.pos.Y = pTarget->spr.pos.Y;
pActor->spr.pos.Z = pTarget->spr.pos.Z - GetActorHeight(pTarget);
if (pActor->spr.sector() != pTarget->spr.sector()) {
ChangeActorSect(pActor, pTarget->spr.sector());
if (pActor->sector() != pTarget->sector()) {
ChangeActorSect(pActor, pTarget->sector());
}
}

6
source/games/exhumed/src/ramses.cpp
View file

@ -299,7 +299,7 @@ void DoSpiritHead()
pSpiritSpr->spr.shade--;
if (--dimSectCount < 0)
{
DimSector(pSpiritSpr->spr.sector());
DimSector(pSpiritSpr->sector());
dimSectCount = 5;
}
@ -425,8 +425,8 @@ void DoSpiritHead()
if (nCount < (15 * nPixels) / 16) {
SoundBigEntrance();
AddGlow(pSpiritSpr->spr.sector(), 20);
AddFlash(pSpiritSpr->spr.sector(), pSpiritSpr->spr.pos.X, pSpiritSpr->spr.pos.Y, pSpiritSpr->spr.pos.Z, 128);
AddGlow(pSpiritSpr->sector(), 20);
AddFlash(pSpiritSpr->sector(), pSpiritSpr->spr.pos.X, pSpiritSpr->spr.pos.Y, pSpiritSpr->spr.pos.Z, 128);
nHeadStage = 3;
TintPalette(255, 255, 255);
CopyHeadToWorkTile(kTileRamsesNormal);

8
source/games/exhumed/src/rat.cpp
View file

@ -94,7 +94,7 @@ void BuildRat(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.picnum = 1;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.clipdist = 30;
pActor->spr.ang = nAngle;
pActor->spr.xrepeat = 50;
@ -125,7 +125,7 @@ void BuildRat(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
DExhumedActor* FindFood(DExhumedActor* pActor)
{
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;
int z = pActor->spr.pos.Z;
@ -137,7 +137,7 @@ DExhumedActor* FindFood(DExhumedActor* pActor)
DExhumedActor* pActor2 = nChunkSprite[RandomSize(7) % nChunkTotal];
if (pActor2 != nullptr)
{
if (cansee(x, y, z2, pSector, pActor2->spr.pos.X, pActor2->spr.pos.Y, pActor2->spr.pos.Z, pActor2->spr.sector())) {
if (cansee(x, y, z2, pSector, pActor2->spr.pos.X, pActor2->spr.pos.Y, pActor2->spr.pos.Z, pActor2->sector())) {
return pActor2;
}
}
@ -152,7 +152,7 @@ DExhumedActor* FindFood(DExhumedActor* pActor)
{
if (nPlayerPic == pActor2->spr.picnum)
{
if (cansee(x, y, z, pSector, pActor2->spr.pos.X, pActor2->spr.pos.Y, pActor2->spr.pos.Z, pActor2->spr.sector())) {
if (cansee(x, y, z, pSector, pActor2->spr.pos.X, pActor2->spr.pos.Y, pActor2->spr.pos.Z, pActor2->sector())) {
return pActor2;
}
}

4
source/games/exhumed/src/rex.cpp
View file

@ -47,7 +47,7 @@ void BuildRex(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
{
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
z = pActor->spr.sector()->floorz;
z = pActor->sector()->floorz;
nAngle = pActor->spr.ang;
ChangeActorStat(pActor, 119);
@ -62,7 +62,7 @@ void BuildRex(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
pActor->spr.xrepeat = 64;
pActor->spr.yrepeat = 64;
pActor->spr.picnum = 1;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.ang = nAngle;

4
source/games/exhumed/src/roach.cpp
View file

@ -46,7 +46,7 @@ void BuildRoach(int nType, DExhumedActor* pActor, int x, int y, int z, sectortyp
ChangeActorStat(pActor, 105);
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
z = pActor->spr.sector()->floorz;
z = pActor->sector()->floorz;
angle = pActor->spr.ang;
}
@ -58,7 +58,7 @@ void BuildRoach(int nType, DExhumedActor* pActor, int x, int y, int z, sectortyp
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.picnum = 1;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.clipdist = 60;
pActor->spr.ang = angle;
pActor->spr.xrepeat = 40;

6
source/games/exhumed/src/runlist.cpp
View file

@ -1644,11 +1644,11 @@ int runlist_CheckRadialDamage(DExhumedActor* pActor)
cansee(pRadialActor->spr.pos.X,
pRadialActor->spr.pos.Y,
pRadialActor->spr.pos.Z - 512,
pRadialActor->spr.sector(),
pRadialActor->sector(),
pActor->spr.pos.X,
pActor->spr.pos.Y,
pActor->spr.pos.Z - 8192,
pActor->spr.sector()))
pActor->sector()))
{
edi = (nRadialDamage * (nDamageRadius - nDist)) / nDamageRadius;
@ -1729,7 +1729,7 @@ void runlist_DamageEnemy(DExhumedActor* pActor, DExhumedActor* pActor2, int nDam
{
// Do a taunt
auto pPlayerActor = PlayerList[nPlayer].pActor;
auto pSector = pPlayerActor->spr.sector();
auto pSector = pPlayerActor->sector();
if (!(pSector->Flag & kSectUnderwater))
{

10
source/games/exhumed/src/scorp.cpp
View file

@ -50,7 +50,7 @@ void BuildScorp(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
z = pActor->spr.sector()->floorz;
z = pActor->sector()->floorz;
nAngle = pActor->spr.ang;
}
@ -63,7 +63,7 @@ void BuildScorp(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pActor->spr.xrepeat = 80;
pActor->spr.yrepeat = 80;
pActor->spr.picnum = 1;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.ang = nAngle;
@ -369,7 +369,7 @@ void AIScorp::Tick(RunListEvent* ev)
return;
}
auto pSpiderActor = BuildSpider(nullptr, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), pActor->spr.ang);
auto pSpiderActor = BuildSpider(nullptr, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), pActor->spr.ang);
if (pSpiderActor)
{
pSpiderActor->spr.ang = RandomSize(11);
@ -428,8 +428,8 @@ void AIScorp::Effect(RunListEvent* ev, DExhumedActor* pTarget, int mode)
{
pActor->nCount = 45;
if (cansee(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - GetActorHeight(pActor), pActor->spr.sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->spr.sector()))
if (cansee(pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z - GetActorHeight(pActor), pActor->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->sector()))
{
pActor->spr.xvel = 0;
pActor->spr.yvel = 0;

12
source/games/exhumed/src/set.cpp
View file

@ -50,7 +50,7 @@ void BuildSet(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
ChangeActorStat(pActor, 120);
x = pActor->spr.pos.X;
y = pActor->spr.pos.Y;
z = pActor->spr.sector()->floorz;
z = pActor->sector()->floorz;
nAngle = pActor->spr.ang;
}
@ -65,7 +65,7 @@ void BuildSet(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
pActor->spr.zvel = 0;
pActor->spr.xrepeat = 87;
pActor->spr.yrepeat = 96;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.xoffset = 0;
pActor->spr.yoffset = 0;
pActor->spr.ang = nAngle;
@ -97,7 +97,7 @@ void BuildSet(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
void BuildSoul(DExhumedActor* pSet)
{
auto pActor = insertActor(pSet->spr.sector(), 0);
auto pActor = insertActor(pSet->sector(), 0);
pActor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
pActor->spr.shade = -127;
@ -115,7 +115,7 @@ void BuildSoul(DExhumedActor* pSet)
pActor->spr.pos.X = pSet->spr.pos.X;
pActor->spr.pos.Y = pSet->spr.pos.Y;
pActor->spr.pos.Z = (RandomSize(8) << 8) + 8192 + pActor->spr.sector()->ceilingz - GetActorHeight(pActor);
pActor->spr.pos.Z = (RandomSize(8) << 8) + 8192 + pActor->sector()->ceilingz - GetActorHeight(pActor);
//pActor->spr.hitag = nSet;
pActor->pTarget = pSet;
@ -158,7 +158,7 @@ void AISoul::Tick(RunListEvent* ev)
pActor->spr.pos.X = pSet->spr.pos.X;
pActor->spr.pos.Y = pSet->spr.pos.Y;
pActor->spr.pos.Z = pSet->spr.pos.Z - (GetActorHeight(pSet) >> 1);
ChangeActorSect(pActor, pSet->spr.sector());
ChangeActorSect(pActor, pSet->sector());
return;
}
}
@ -272,7 +272,7 @@ void AISet::Tick(RunListEvent* ev)
auto nMov = MoveCreature(pActor);
auto sect = pActor->spr.sector();
auto sect = pActor->sector();
pushmove(&pActor->spr.pos, &sect, pActor->spr.clipdist << 2, 5120, -5120, CLIPMASK0);
pActor->setsector(sect);

12
source/games/exhumed/src/snake.cpp
View file

@ -117,9 +117,9 @@ void ExplodeSnakeSprite(DExhumedActor* pActor, int nPlayer)
pActor->pTarget = nOwner;
BuildAnim(nullptr, 23, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->spr.sector(), 40, 4);
BuildAnim(nullptr, 23, 0, pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, pActor->sector(), 40, 4);
AddFlash(pActor->spr.sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
AddFlash(pActor->sector(), pActor->spr.pos.X, pActor->spr.pos.Y, pActor->spr.pos.Z, 128);
StopActorSound(pActor);
}
@ -139,7 +139,7 @@ void BuildSnake(int nPlayer, int zVal)
int nAngle = pPlayerActor->spr.ang;
HitInfo hit{};
hitscan({ x, y, z }, pPlayerActor->spr.sector(), { bcos(nAngle), bsin(nAngle), 0 }, hit, CLIPMASK1);
hitscan({ x, y, z }, pPlayerActor->sector(), { bcos(nAngle), bsin(nAngle), 0 }, hit, CLIPMASK1);
uint32_t yDiff = abs(hit.hitpos.Y - y);
uint32_t xDiff = abs(hit.hitpos.X - x);
@ -198,7 +198,7 @@ void BuildSnake(int nPlayer, int zVal)
pActor->spr.pos.Z = pPlayerActor->spr.pos.Z + zVal;
pActor->spr.xrepeat = 32;
pActor->spr.yrepeat = 32;
pViewSect = pActor->spr.sector();
pViewSect = pActor->sector();
sprt = pActor;
}
else
@ -264,7 +264,7 @@ DExhumedActor* FindSnakeEnemy(int nSnake)
if (!pActor) return nullptr;
int nAngle = pActor->spr.ang;
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
int esi = 2048;
@ -369,7 +369,7 @@ void AISnake::Tick(RunListEvent* ev)
SnakeList[nSnake].nAngle = (SnakeList[nSnake].nAngle + 64) & 0x7FF;
int var_28 = (nAngle + 512) & kAngleMask;
auto pSector = pActor->spr.sector();
auto pSector = pActor->sector();
int x = pActor->spr.pos.X;
int y = pActor->spr.pos.Y;

12
source/games/exhumed/src/spider.cpp
View file

@ -48,7 +48,7 @@ DExhumedActor* BuildSpider(DExhumedActor* spp, int x, int y, int z, sectortype*
x = spp->spr.pos.X;
y = spp->spr.pos.Y;
z = spp->spr.sector()->floorz;
z = spp->sector()->floorz;
nAngle = spp->spr.ang;
}
@ -63,7 +63,7 @@ DExhumedActor* BuildSpider(DExhumedActor* spp, int x, int y, int z, sectortype*
spp->spr.zvel = 0;
spp->spr.xrepeat = 40;
spp->spr.yrepeat = 40;
spp->spr.pal = spp->spr.sector()->ceilingpal;
spp->spr.pal = spp->sector()->ceilingpal;
spp->spr.xoffset = 0;
spp->spr.yoffset = 0;
spp->spr.ang = nAngle;
@ -102,7 +102,7 @@ void AISpider::Tick(RunListEvent* ev)
{
if (spp->spr.cstat & CSTAT_SPRITE_YFLIP)
{
spp->spr.pos.Z = spp->spr.sector()->ceilingz + GetActorHeight(spp);
spp->spr.pos.Z = spp->sector()->ceilingz + GetActorHeight(spp);
}
else
{
@ -174,7 +174,7 @@ void AISpider::Tick(RunListEvent* ev)
case 3:
{
case_3:
auto pSector =spp->spr.sector();
auto pSector =spp->sector();
if (spp->spr.cstat & CSTAT_SPRITE_YFLIP)
{
@ -287,10 +287,10 @@ void AISpider::Tick(RunListEvent* ev)
if (nMov.exbits & kHitAux1
&& spp->spr.zvel < 0
&& hiHit.type != kHitSprite
&& !((spp->spr.sector()->ceilingstat) & CSTAT_SECTOR_SKY))
&& !((spp->sector()->ceilingstat) & CSTAT_SECTOR_SKY))
{
spp->spr.cstat |= CSTAT_SPRITE_YFLIP;
spp->spr.pos.Z = GetActorHeight(spp) + spp->spr.sector()->ceilingz;
spp->spr.pos.Z = GetActorHeight(spp) + spp->sector()->ceilingz;
spp->spr.zvel = 0;
spp->nAction = 1;

8
source/games/exhumed/src/view.cpp
View file

@ -91,7 +91,7 @@ static void analyzesprites(tspritetype* tsprite, int& spritesortcnt, int x, int
bestTarget = nullptr;
auto pSector =pPlayerActor->spr.sector();
auto pSector =pPlayerActor->sector();
int nAngle = (2048 - pPlayerActor->spr.ang) & kAngleMask;
@ -171,7 +171,7 @@ static void analyzesprites(tspritetype* tsprite, int& spritesortcnt, int x, int
{
nCreepyTimer = kCreepyCount;
if (!cansee(x, y, z, pSector, targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - GetActorHeight(targ), targ->spr.sector()))
if (!cansee(x, y, z, pSector, targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - GetActorHeight(targ), targ->sector()))
{
bestTarget = nullptr;
}
@ -220,7 +220,7 @@ void DrawView(double smoothRatio, bool sceneonly)
playerX = pActor->spr.pos.X;
playerY = pActor->spr.pos.Y;
playerZ = pActor->spr.pos.Z;
pSector = pActor->spr.sector();
pSector = pActor->sector();
nAngle = buildang(pActor->spr.ang);
rotscrnang = buildang(0);
@ -284,7 +284,7 @@ void DrawView(double smoothRatio, bool sceneonly)
else
{
viewz = playerZ + nQuake[nLocalPlayer];
int floorZ = pPlayerActor->spr.sector()->floorz;
int floorZ = pPlayerActor->sector()->floorz;
if (viewz > floorZ)
viewz = floorZ;

6
source/games/exhumed/src/wasp.cpp
View file

@ -58,7 +58,7 @@ DExhumedActor* BuildWasp(DExhumedActor* pActor, int x, int y, int z, sectortype*
pActor->spr.shade = -12;
pActor->spr.cstat = CSTAT_SPRITE_BLOCK_ALL;
pActor->spr.pal = pActor->spr.sector()->ceilingpal;
pActor->spr.pal = pActor->sector()->ceilingpal;
pActor->spr.clipdist = 70;
if (bEggWasp)
@ -211,7 +211,7 @@ void AIWasp::Tick(RunListEvent* ev)
{
pTarget = pActor->pTarget;
if (pTarget && (!(pTarget->spr.cstat & CSTAT_SPRITE_BLOCK_ALL) || (pTarget->spr.sector()->Flag & kSectUnderwater)))
if (pTarget && (!(pTarget->spr.cstat & CSTAT_SPRITE_BLOCK_ALL) || (pTarget->sector()->Flag & kSectUnderwater)))
{
// goto pink
pActor->pTarget = nullptr;
@ -332,7 +332,7 @@ void AIWasp::Tick(RunListEvent* ev)
}
case 5:
{
auto pSector =pActor->spr.sector();
auto pSector =pActor->sector();
pActor->spr.pos.Z += pActor->spr.zvel;

76
source/games/sw/src/_polymost.cpp
View file

@ -11,7 +11,7 @@ int ViewSectorInScene(sectortype* cursect, int level)
{
if (actor->spr.hitag == level)
{
if (cursect == actor->spr.sector())
if (cursect == actor->sector())
{
// ignore case if sprite is pointing up
if (actor->spr.ang == 1536)
@ -97,19 +97,19 @@ void FAF_DrawRooms(int x, int y, int z, fixed_t q16ang, fixed_t q16horiz, int se
if (SP_TAG3(actor) == 0)
{
// back up ceilingpicnum and ceilingstat
SP_TAG5(actor) = actor->spr.sector()->ceilingpicnum;
actor->spr.sector()->ceilingpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->spr.sector()->ceilingstat;
actor->spr.sector()->ceilingstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->spr.sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
SP_TAG5(actor) = actor->sector()->ceilingpicnum;
actor->sector()->ceilingpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->sector()->ceilingstat;
actor->sector()->ceilingstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
}
else if (SP_TAG3(actor) == 1)
{
SP_TAG5(actor) = actor->spr.sector()->floorpicnum;
actor->spr.sector()->floorpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->spr.sector()->floorstat;
actor->spr.sector()->floorstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->spr.sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
SP_TAG5(actor) = actor->sector()->floorpicnum;
actor->sector()->floorpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->sector()->floorstat;
actor->sector()->floorstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
}
}
@ -127,15 +127,15 @@ void FAF_DrawRooms(int x, int y, int z, fixed_t q16ang, fixed_t q16horiz, int se
if (SP_TAG3(actor) == 0)
{
// restore ceilingpicnum and ceilingstat
actor->spr.sector()->ceilingpicnum = SP_TAG5(actor);
actor->spr.sector()->ceilingstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->spr.sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
actor->sector()->ceilingpicnum = SP_TAG5(actor);
actor->sector()->ceilingstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
}
else if (SP_TAG3(actor) == 1)
{
actor->spr.sector()->floorpicnum = SP_TAG5(actor);
actor->spr.sector()->floorstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->spr.sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
actor->sector()->floorpicnum = SP_TAG5(actor);
actor->sector()->floorstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
}
}
}
@ -274,7 +274,7 @@ void JS_DrawMirrors(PLAYERp pp, int tx, int ty, int tz, fixed_t tpq16ang, fixed
if (mirror[cnt].campic != -1)
tileDelete(mirror[cnt].campic);
renderDrawRoomsQ16(dx, dy, dz, tpq16ang, tpq16horiz, actor->spr.sector(), true);
renderDrawRoomsQ16(dx, dy, dz, tpq16ang, tpq16horiz, actor->sector(), true);
analyzesprites(pm_tsprite, pm_spritesortcnt, dx, dy, dz, false);
renderDrawMasks();
}
@ -313,8 +313,8 @@ void JS_DrawMirrors(PLAYERp pp, int tx, int ty, int tz, fixed_t tpq16ang, fixed
void SW_FloorPortalHack(DSWActor* actor, int z, int match)
{
// move ceiling multiple of 128 so that the wall tile will line up
int pix_diff = labs(z - actor->spr.sector()->ceilingz) >> 8;
int newz = actor->spr.sector()->ceilingz - ((pix_diff / 128) + 1) * Z(128);
int pix_diff = labs(z - actor->sector()->ceilingz) >> 8;
int newz = actor->sector()->ceilingz - ((pix_diff / 128) + 1) * Z(128);
SWStatIterator it(STAT_FAF);
while (actor = it.Next())
@ -325,17 +325,17 @@ void SW_FloorPortalHack(DSWActor* actor, int z, int match)
if (actor->spr.hitag == VIEW_LEVEL1)
{
// save it off
save.sect[save.zcount] = actor->spr.sector();
save.zval[save.zcount] = actor->spr.sector()->ceilingz;
save.pic[save.zcount] = actor->spr.sector()->ceilingpicnum;
save.slope[save.zcount] = actor->spr.sector()->ceilingheinum;
save.sect[save.zcount] = actor->sector();
save.zval[save.zcount] = actor->sector()->ceilingz;
save.pic[save.zcount] = actor->sector()->ceilingpicnum;
save.slope[save.zcount] = actor->sector()->ceilingheinum;
actor->spr.sector()->setceilingz(newz, true);
actor->sector()->setceilingz(newz, true);
// don't change FAF_MIRROR_PIC - ConnectArea
if (actor->spr.sector()->ceilingpicnum != FAF_MIRROR_PIC)
actor->spr.sector()->ceilingpicnum = FAF_MIRROR_PIC + 1;
actor->spr.sector()->setceilingslope(0);
if (actor->sector()->ceilingpicnum != FAF_MIRROR_PIC)
actor->sector()->ceilingpicnum = FAF_MIRROR_PIC + 1;
actor->sector()->setceilingslope(0);
save.zcount++;
PRODUCTION_ASSERT(save.zcount < ZMAX);
@ -346,8 +346,8 @@ void SW_FloorPortalHack(DSWActor* actor, int z, int match)
void SW_CeilingPortalHack(DSWActor* actor, int z, int match)
{
int pix_diff = labs(z - actor->spr.sector()->floorz) >> 8;
int newz = actor->spr.sector()->floorz + ((pix_diff / 128) + 1) * Z(128);
int pix_diff = labs(z - actor->sector()->floorz) >> 8;
int newz = actor->sector()->floorz + ((pix_diff / 128) + 1) * Z(128);
SWStatIterator it(STAT_FAF);
while (actor = it.Next())
@ -358,16 +358,16 @@ void SW_CeilingPortalHack(DSWActor* actor, int z, int match)
if (actor->spr.hitag == VIEW_LEVEL2)
{
// save it off
save.sect[save.zcount] = actor->spr.sector();
save.zval[save.zcount] = actor->spr.sector()->floorz;
save.pic[save.zcount] = actor->spr.sector()->floorpicnum;
save.slope[save.zcount] = actor->spr.sector()->floorheinum;
save.sect[save.zcount] = actor->sector();
save.zval[save.zcount] = actor->sector()->floorz;
save.pic[save.zcount] = actor->sector()->floorpicnum;
save.slope[save.zcount] = actor->sector()->floorheinum;
actor->spr.sector()->setfloorz(newz, true);
actor->sector()->setfloorz(newz, true);
// don't change FAF_MIRROR_PIC - ConnectArea
if (actor->spr.sector()->floorpicnum != FAF_MIRROR_PIC)
actor->spr.sector()->floorpicnum = FAF_MIRROR_PIC + 1;
actor->spr.sector()->setfloorslope(0);
if (actor->sector()->floorpicnum != FAF_MIRROR_PIC)
actor->sector()->floorpicnum = FAF_MIRROR_PIC + 1;
actor->sector()->setfloorslope(0);
save.zcount++;
PRODUCTION_ASSERT(save.zcount < ZMAX);

20
source/games/sw/src/actor.cpp
View file

@ -284,7 +284,7 @@ int DoActorDie(DSWActor* actor, DSWActor* weapActor, int meansofdeath)
void DoDebrisCurrent(DSWActor* actor)
{
int nx, ny;
auto sectp = actor->spr.sector();
auto sectp = actor->sector();
//actor->spr.clipdist = (256+128)>>2;
@ -309,7 +309,7 @@ void DoDebrisCurrent(DSWActor* actor)
int DoActorSectorDamage(DSWActor* actor)
{
SECTORp sectp = actor->spr.sector();
SECTORp sectp = actor->sector();
if (actor->user.Health <= 0)
return false;
@ -383,7 +383,7 @@ bool move_debris(DSWActor* actor, int xchange, int ychange, int zchange)
int DoActorDebris(DSWActor* actor)
{
SECTORp sectp = actor->spr.sector();
SECTORp sectp = actor->sector();
int nx, ny;
// This was move from DoActorDie so actor's can't be walked through until they are on the floor
@ -397,9 +397,9 @@ int DoActorDebris(DSWActor* actor)
KillActor(actor);
return 0;
case ZILLA_RUN_R0:
getzsofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, &actor->user.hiz, &actor->user.loz);
actor->user.lo_sectp = actor->spr.sector();
actor->user.hi_sectp = actor->spr.sector();
getzsofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, &actor->user.hiz, &actor->user.loz);
actor->user.lo_sectp = actor->sector();
actor->user.hi_sectp = actor->sector();
actor->user.lowActor = nullptr;
actor->user.highActor = nullptr;
break;
@ -426,7 +426,7 @@ int DoActorDebris(DSWActor* actor)
}
}
if (actor->spr.sector()->hasU() && FixedToInt(actor->spr.sector()->depth_fixed) > 10) // JBF: added null check
if (actor->sector()->hasU() && FixedToInt(actor->sector()->depth_fixed) > 10) // JBF: added null check
{
actor->user.WaitTics = (actor->user.WaitTics + (ACTORMOVETICS << 3)) & 1023;
actor->spr.pos.Z = actor->user.loz - MulScale(Z(2), bsin(actor->user.WaitTics), 14);
@ -476,7 +476,7 @@ int DoGenerateSewerDebris(DSWActor* actor)
{
actor->user.Tics = actor->user.WaitTics;
auto spawned = SpawnActor(STAT_DEAD_ACTOR, 0, Debris[RANDOM_P2(4<<8)>>8], actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang, 200);
auto spawned = SpawnActor(STAT_DEAD_ACTOR, 0, Debris[RANDOM_P2(4<<8)>>8], actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang, 200);
SetOwner(actor, spawned);
}
@ -491,7 +491,7 @@ void KeepActorOnFloor(DSWActor* actor)
SECTORp sectp;
int depth;
sectp = actor->spr.sector();
sectp = actor->sector();
actor->spr.cstat &= ~(CSTAT_SPRITE_YFLIP); // If upside down, reset it
@ -565,7 +565,7 @@ void KeepActorOnFloor(DSWActor* actor)
{
int ceilz, florz;
Collision ctrash, ftrash;
FAFgetzrangepoint(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(),
FAFgetzrangepoint(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(),
&ceilz, &ctrash, &florz, &ftrash);
actor->user.oz = actor->spr.pos.Z = florz;

6
source/games/sw/src/ai.cpp
View file

@ -254,7 +254,7 @@ int CanHitPlayer(DSWActor* actor)
else
return false;
FAFhitscan(actor->spr.pos.X, actor->spr.pos.Y, zhs, actor->spr.sector(),
FAFhitscan(actor->spr.pos.X, actor->spr.pos.Y, zhs, actor->sector(),
xvect,
yvect,
zvect,
@ -438,7 +438,7 @@ int DoActorOperate(DSWActor* actor)
for (i = 0; i < SIZ(z); i++)
{
neartag({ actor->spr.pos.X, actor->spr.pos.Y, z[i] }, actor->spr.sector(), actor->spr.ang, near, 1024, NTAG_SEARCH_LO_HI);
neartag({ actor->spr.pos.X, actor->spr.pos.Y, z[i] }, actor->sector(), actor->spr.ang, near, 1024, NTAG_SEARCH_LO_HI);
}
if (near.hitSector != nullptr && near.hitpos.X < 1024)
@ -1348,7 +1348,7 @@ Collision move_scan(DSWActor* actor, int ang, int dist, int *stopx, int *stopy,
highActor = actor->user.highActor;
lo_sectp = actor->user.lo_sectp;
hi_sectp = actor->user.hi_sectp;
ssp = actor->spr.sector();
ssp = actor->sector();
// do the move
actor->spr.ang = ang;

12
source/games/sw/src/bunny.cpp
View file

@ -1003,7 +1003,7 @@ int DoBunnyQuickJump(DSWActor* actor)
if (pp == Player+myconnectindex)
{
choose_snd = StdRandomRange(2<<8)>>8;
if (FAFcansee(actor->spr.pos.X,actor->spr.pos.Y,ActorZOfTop(actor),actor->spr.sector(),pp->pos.X, pp->pos.Y, pp->pos.Z, pp->cursector) && Facing(actor, actor->user.targetActor))
if (FAFcansee(actor->spr.pos.X,actor->spr.pos.Y,ActorZOfTop(actor),actor->sector(),pp->pos.X, pp->pos.Y, pp->pos.Z, pp->cursector) && Facing(actor, actor->user.targetActor))
PlayerSound(fagsnds[choose_snd], v3df_doppler|v3df_follow|v3df_dontpan,pp);
}
}
@ -1018,7 +1018,7 @@ int DoBunnyQuickJump(DSWActor* actor)
if (pp == Player+myconnectindex)
{
choose_snd = StdRandomRange(3<<8)>>8;
if (FAFcansee(actor->spr.pos.X,actor->spr.pos.Y,ActorZOfTop(actor),actor->spr.sector(),pp->pos.X, pp->pos.Y, pp->pos.Z, pp->cursector) && Facing(actor, actor->user.targetActor))
if (FAFcansee(actor->spr.pos.X,actor->spr.pos.Y,ActorZOfTop(actor),actor->sector(),pp->pos.X, pp->pos.Y, pp->pos.Z, pp->cursector) && Facing(actor, actor->user.targetActor))
PlayerSound(straightsnds[choose_snd], v3df_doppler|v3df_follow|v3df_dontpan,pp);
}
}
@ -1112,7 +1112,7 @@ void BunnyHatch(DSWActor* actor)
for (int i = 0; i < MAX_BUNNYS; i++)
{
auto actorNew = insertActor(actor->spr.sector(), STAT_DEFAULT);
auto actorNew = insertActor(actor->sector(), STAT_DEFAULT);
actorNew->spr.clear();
actorNew->spr.pos = actor->spr.pos;
actorNew->spr.xrepeat = 30; // Baby size
@ -1169,7 +1169,7 @@ void BunnyHatch(DSWActor* actor)
DSWActor* BunnyHatch2(DSWActor* actor)
{
auto actorNew = insertActor(actor->spr.sector(), STAT_DEFAULT);
auto actorNew = insertActor(actor->sector(), STAT_DEFAULT);
actorNew->spr.clear();
actorNew->spr.pos.X = actor->spr.pos.X;
actorNew->spr.pos.Y = actor->spr.pos.Y;
@ -1272,7 +1272,7 @@ int DoBunnyMove(DSWActor* actor)
if (RandomRange(1000) > 985 && actor->spr.pal != PALETTE_PLAYER1 && actor->user.track < 0)
{
switch (actor->spr.sector()->floorpicnum)
switch (actor->sector()->floorpicnum)
{
case 153:
case 154:
@ -1329,7 +1329,7 @@ int DoBunnyEat(DSWActor* actor)
DoActorSectorDamage(actor);
switch (actor->spr.sector()->floorpicnum)
switch (actor->sector()->floorpicnum)
{
case 153:
case 154:

2
source/games/sw/src/coolg.cpp
View file

@ -541,7 +541,7 @@ int NewCoolg(DSWActor* actor)
{
ANIMATOR DoActorDecide;
auto actorNew = SpawnActor(STAT_ENEMY, COOLG_RUN_R0, &s_CoolgBirth[0], actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang, 50);
auto actorNew = SpawnActor(STAT_ENEMY, COOLG_RUN_R0, &s_CoolgBirth[0], actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.ang, 50);
ChangeState(actorNew, &s_CoolgBirth[0]);
actorNew->user.StateEnd = s_CoolgDie;

10
source/games/sw/src/copysect.cpp
View file

@ -112,7 +112,7 @@ void CopySectorMatch(int match)
SWStatIterator it(STAT_COPY_DEST);
while (auto dActor = it.Next())
{
dsectp = dActor->spr.sector();
dsectp = dActor->sector();
if (match != dActor->spr.lotag)
continue;
@ -123,7 +123,7 @@ void CopySectorMatch(int match)
if (SP_TAG2(sActor) == SP_TAG2(dActor) &&
SP_TAG3(sActor) == SP_TAG3(dActor))
{
ssectp = sActor->spr.sector();
ssectp = sActor->sector();
// !!!!!AAAAAAAAAAAAAAAAAAAAAAHHHHHHHHHHHHHHHHHHHHHH
// Don't kill anything you don't have to
@ -165,8 +165,8 @@ void CopySectorMatch(int match)
// move sprites from source to dest - use center offset
// get center of src and dest sect
SectorMidPoint(sActor->spr.sector(), &sx, &sy, &trash);
SectorMidPoint(dActor->spr.sector(), &dx, &dy, &trash);
SectorMidPoint(sActor->sector(), &sx, &sy, &trash);
SectorMidPoint(dActor->sector(), &dx, &dy, &trash);
// get offset
src_xoff = sx - itActor->spr.pos.X;
@ -185,7 +185,7 @@ void CopySectorMatch(int match)
SECTOR_OBJECTp sop;
// find and add sprite to SO
sop = DetectSectorObject(itActor->spr.sector());
sop = DetectSectorObject(itActor->sector());
AddSpriteToSectorObject(itActor, sop);
// update sprites postions so they aren't in the

54
source/games/sw/src/draw.cpp
View file

@ -456,8 +456,8 @@ void WarpCopySprite(tspritetype* tsprite, int& spritesortcnt)
{
if (itActor1->spr.lotag == match)
{
auto sect1 = itActor->spr.sector();
auto sect2 = itActor1->spr.sector();
auto sect1 = itActor->sector();
auto sect2 = itActor1->sector();
SWSectIterator it2(sect1);
while (auto itActor2 = it.Next())
@ -478,7 +478,7 @@ void WarpCopySprite(tspritetype* tsprite, int& spritesortcnt)
newTSpr->pos.X = itActor1->spr.pos.X - xoff;
newTSpr->pos.Y = itActor1->spr.pos.Y - yoff;
newTSpr->pos.Z = itActor1->spr.pos.Z - zoff;
newTSpr->sectp = itActor1->spr.sector();
newTSpr->sectp = itActor1->sector();
}
it2.Reset(sect2);
@ -495,7 +495,7 @@ void WarpCopySprite(tspritetype* tsprite, int& spritesortcnt)
auto off = itActor1->spr.pos - newTSpr->pos;
newTSpr->pos = itActor->spr.pos - off;
newTSpr->sectp = itActor->spr.sector();
newTSpr->sectp = itActor->sector();
}
}
}
@ -654,7 +654,7 @@ void analyzesprites(tspritetype* tsprite, int& spritesortcnt, int viewx, int vie
// workaround for mines and floor decals beneath the floor
if (tsp->picnum == BETTY_R0 || tsp->picnum == FLOORBLOOD1)
{
int32_t const floorz = getflorzofslopeptr(tActor->spr.sector(), tActor->spr.pos.X, tActor->spr.pos.Y);
int32_t const floorz = getflorzofslopeptr(tActor->sector(), tActor->spr.pos.X, tActor->spr.pos.Y);
if (tActor->spr.pos.Z > floorz)
tsp->pos.Z = floorz;
}
@ -1115,8 +1115,8 @@ void CameraView(PLAYERp pp, int *tx, int *ty, int *tz, sectortype** tsect, binan
ang_test = getincangle(ang.asbuild(), actor->spr.ang) < actor->spr.lotag;
FAFcansee_test =
(FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), *tx, *ty, *tz, pp->cursector) ||
FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.sector(), *tx, *ty, *tz + ActorSizeZ(pp->actor), pp->cursector));
(FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), *tx, *ty, *tz, pp->cursector) ||
FAFcansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), *tx, *ty, *tz + ActorSizeZ(pp->actor), pp->cursector));
player_in_camera = ang_test && FAFcansee_test;
@ -1168,7 +1168,7 @@ void CameraView(PLAYERp pp, int *tx, int *ty, int *tz, sectortype** tsect, binan
*tx = actor->spr.pos.X;
*ty = actor->spr.pos.Y;
*tz = actor->spr.pos.Z;
*tsect = actor->spr.sector();
*tsect = actor->sector();
found_camera = true;
break;
@ -1214,7 +1214,7 @@ void PreDraw(void)
SWStatIterator it(STAT_FLOOR_SLOPE_DONT_DRAW);
while (auto actor = it.Next())
{
actor->spr.sector()->floorstat &= ~(CSTAT_SECTOR_SLOPE);
actor->sector()->floorstat &= ~(CSTAT_SECTOR_SLOPE);
}
}
@ -1224,7 +1224,7 @@ void PostDraw(void)
SWStatIterator it(STAT_FLOOR_SLOPE_DONT_DRAW);
while (auto actor = it.Next())
{
actor->spr.sector()->floorstat |= (CSTAT_SECTOR_SLOPE);
actor->sector()->floorstat |= (CSTAT_SECTOR_SLOPE);
}
it.Reset(STAT_FAF_COPY);
@ -1240,7 +1240,7 @@ void PreDrawStackedWater(void)
SWStatIterator it(STAT_CEILING_FLOOR_PIC_OVERRIDE);
while (auto itActor = it.Next())
{
SWSectIterator it2(itActor->spr.sector());
SWSectIterator it2(itActor->sector());
while (auto itActor2 = it2.Next())
{
if (itActor2->hasU())
@ -1333,19 +1333,19 @@ void UpdateWallPortalState()
if (SP_TAG3(actor) == 0)
{
// back up ceilingpicnum and ceilingstat
SP_TAG5(actor) = actor->spr.sector()->ceilingpicnum;
actor->spr.sector()->ceilingpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->spr.sector()->ceilingstat;
actor->spr.sector()->ceilingstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->spr.sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
SP_TAG5(actor) = actor->sector()->ceilingpicnum;
actor->sector()->ceilingpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->sector()->ceilingstat;
actor->sector()->ceilingstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
}
else if (SP_TAG3(actor) == 1)
{
SP_TAG5(actor) = actor->spr.sector()->floorpicnum;
actor->spr.sector()->floorpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->spr.sector()->floorstat;
actor->spr.sector()->floorstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->spr.sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
SP_TAG5(actor) = actor->sector()->floorpicnum;
actor->sector()->floorpicnum = SP_TAG2(actor);
SP_TAG4(actor) = actor->sector()->floorstat;
actor->sector()->floorstat |= (ESectorFlags::FromInt(SP_TAG6(actor)));
actor->sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
}
}
@ -1359,15 +1359,15 @@ void RestorePortalState()
if (SP_TAG3(actor) == 0)
{
// restore ceilingpicnum and ceilingstat
actor->spr.sector()->ceilingpicnum = SP_TAG5(actor);
actor->spr.sector()->ceilingstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->spr.sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
actor->sector()->ceilingpicnum = SP_TAG5(actor);
actor->sector()->ceilingstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->sector()->ceilingstat &= ~(CSTAT_SECTOR_SKY);
}
else if (SP_TAG3(actor) == 1)
{
actor->spr.sector()->floorpicnum = SP_TAG5(actor);
actor->spr.sector()->floorstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->spr.sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
actor->sector()->floorpicnum = SP_TAG5(actor);
actor->sector()->floorstat = ESectorFlags::FromInt(SP_TAG4(actor));
actor->sector()->floorstat &= ~(CSTAT_SECTOR_SKY);
}
}
}

10
source/games/sw/src/eel.cpp
View file

@ -420,17 +420,17 @@ int DoEelMatchPlayerZ(DSWActor* actor)
int bound;
if (FAF_ConnectArea(actor->spr.sector()))
if (FAF_ConnectArea(actor->sector()))
{
if (actor->user.hi_sectp)
{
actor->user.hiz = actor->spr.sector()->ceilingz + Z(16);
actor->user.hi_sectp = actor->spr.sector();
actor->user.hiz = actor->sector()->ceilingz + Z(16);
actor->user.hi_sectp = actor->sector();
}
else
{
if (actor->user.hiz < actor->spr.sector()->ceilingz + Z(16))
actor->user.hiz = actor->spr.sector()->ceilingz + Z(16);
if (actor->user.hiz < actor->sector()->ceilingz + Z(16))
actor->user.hiz = actor->sector()->ceilingz + Z(16);
}
}

Some files were not shown because too many files have changed in this diff Show more