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

- Replace spritetypebase z with pos.Z calls and eliminate spritetypebase pos union.

Browse source
This commit is contained in:
Mitchell Richters 2021-12-22 22:29:00 +11:00 committed by Christoph Oelckers
parent cecb8dc48e
commit baf78848eb
138 changed files with 1690 additions and 1693 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
source/build/src/clip.cpp
View file

@ -137,10 +137,10 @@ static int32_t spriteGetZOfSlope(const spritetype* spr, int32_t dax, int32_t day
{
int16_t const heinum = spriteGetSlope(spr);
if (heinum == 0)
return spr->z;
return spr->pos.Z;
int const j = DMulScale(bsin(spr->ang + 1024), day - spr->pos.Y, -bsin(spr->ang + 512), dax - spr->pos.X, 4);
return spr->z + MulScale(heinum, j, 18);
return spr->pos.Z + MulScale(heinum, j, 18);
}
@ -607,7 +607,7 @@ CollisionBase clipmove_(vec3_t * const pos, int * const sectnum, int32_t xvect,
case CSTAT_SPRITE_ALIGNMENT_FACING:
if (p1.X >= clipMin.X && p1.X <= clipMax.X && p1.Y >= clipMin.Y && p1.Y <= clipMax.Y)
{
int32_t height, daz = spr->z+spriteheightofsptr(spr, &height, 1);
int32_t height, daz = spr->pos.Z+spriteheightofsptr(spr, &height, 1);
if (pos->Z > daz-height-flordist && pos->Z < daz+ceildist)
{
@ -623,7 +623,7 @@ CollisionBase clipmove_(vec3_t * const pos, int * const sectnum, int32_t xvect,
case CSTAT_SPRITE_ALIGNMENT_WALL:
{
int32_t height, daz = spr->z+spriteheightofsptr(spr, &height, 1);
int32_t height, daz = spr->pos.Z+spriteheightofsptr(spr, &height, 1);
if (pos->Z > daz-height-flordist && pos->Z < daz+ceildist)
{
@ -668,7 +668,7 @@ CollisionBase clipmove_(vec3_t * const pos, int * const sectnum, int32_t xvect,
else
{
heinum = 0;
sz = spr->z;
sz = spr->pos.Z;
}
if (pos->Z > sz - flordist && pos->Z < sz + ceildist)
@ -734,7 +734,7 @@ CollisionBase clipmove_(vec3_t * const pos, int * const sectnum, int32_t xvect,
int32_t zz[3] = { pos->Z, pos->Z + flordist, pos->Z - ceildist };
for (int k = 0; k < 3; k++)
{
int32_t jj = DivScale(spr->z - zz[k], heinum, 18);
int32_t jj = DivScale(spr->pos.Z - zz[k], heinum, 18);
int32_t jj2 = MulScale(jj, ratio, 12);
if (jj2 > (centery << 8) || jj2 < ((centery - rspany) << 8))
continue;
@ -1150,7 +1150,7 @@ void getzrange(const vec3_t& pos, sectortype* sect, int32_t* ceilz, CollisionBas
int32_t k = walldist+(spr->clipdist<<2)+1;
if ((abs(v1.X-pos.X) <= k) && (abs(v1.Y-pos.Y) <= k))
{
daz = spr->z + spriteheightofsptr(spr, &k, 1);
daz = spr->pos.Z + spriteheightofsptr(spr, &k, 1);
daz2 = daz - k;
clipyou = 1;
}
@ -1165,7 +1165,7 @@ void getzrange(const vec3_t& pos, sectortype* sect, int32_t* ceilz, CollisionBas
if (clipinsideboxline(pos.X,pos.Y,v1.X,v1.Y,v2.X,v2.Y,walldist+1) != 0)
{
int32_t k;
daz = spr->z + spriteheightofsptr(spr, &k, 1);
daz = spr->pos.Z + spriteheightofsptr(spr, &k, 1);
daz2 = daz-k;
clipyou = 1;
}
@ -1175,7 +1175,7 @@ void getzrange(const vec3_t& pos, sectortype* sect, int32_t* ceilz, CollisionBas
case CSTAT_SPRITE_ALIGNMENT_FLOOR:
case CSTAT_SPRITE_ALIGNMENT_SLOPE:
{
if ((cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FLOOR) daz = spr->z;
if ((cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FLOOR) daz = spr->pos.Z;
else daz = spriteGetZOfSlope(spr, pos.X, pos.Y);
if ((cstat & CSTAT_SPRITE_ONE_SIDE) != 0 && (pos.Z > daz) == ((cstat & CSTAT_SPRITE_YFLIP)==0))
@ -1414,7 +1414,7 @@ int hitscan(const vec3_t& start, const sectortype* startsect, const vec3_t& dire
if ((cstat&dasprclipmask) == 0)
continue;
x1 = spr->pos.X; y1 = spr->pos.Y; z1 = spr->z;
x1 = spr->pos.X; y1 = spr->pos.Y; z1 = spr->pos.Z;
switch (cstat&CSTAT_SPRITE_ALIGNMENT_MASK)
{
case 0:
@ -1446,7 +1446,7 @@ int hitscan(const vec3_t& start, const sectortype* startsect, const vec3_t& dire
if (abs(intx-sv->X)+abs(inty-sv->Y) > abs((hitinfo.hitpos.X)-sv->X)+abs((hitinfo.hitpos.Y)-sv->Y))
continue;
daz = spr->z + spriteheightofsptr(&actor->s(), &k, 1);
daz = spr->pos.Z + spriteheightofsptr(&actor->s(), &k, 1);
if (intz > daz-k && intz < daz)
{
if (picanm[tilenum].sf&PICANM_TEXHITSCAN_BIT)
@ -1507,7 +1507,7 @@ int hitscan(const vec3_t& start, const sectortype* startsect, const vec3_t& dire
if (j == 0) continue;
if ((cstat & 64) != 0)
if ((j < 0) == ((cstat & 8) == 0)) continue;
int32_t i = ((spr->z - sv->Z) << 8) + DMulScale(dax, sv->Y - spr->pos.Y, -day, sv->X - spr->pos.X, 15);
int32_t i = ((spr->pos.Z - sv->Z) << 8) + DMulScale(dax, sv->Y - spr->pos.Y, -day, sv->X - spr->pos.X, 15);
if ((i ^ j) < 0 || (abs(i) >> 1) >= abs(j)) continue;
i = DivScale(i, j, 30);

2
source/build/src/mdsprite.cpp
View file

@ -1180,7 +1180,7 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
a0.Z = m->zadd * m->scale;
// Parkar: Moved up to be able to use k0 for the y-flipping code
k0 = (float)tspr->z+sext->position_offset.Z;
k0 = (float)tspr->pos.Z+sext->position_offset.Z;
f = ((globalorientation & 8) && (spr->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != CSTAT_SPRITE_ALIGNMENT_FACING) ? -4.f : 4.f;
k0 -= (tspr->yoffset*tspr->yrepeat)*f;
if ((globalorientation&128) && !((globalorientation & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FLOOR))

14
source/build/src/polymost.cpp
View file

@ -2577,8 +2577,8 @@ static inline int32_t polymost_findwall(tspritetype const * const tspr, vec2_t c
for(auto& wal : wallsofsector(sect))
{
if ((!wal.twoSided() || ((wal.nextSector()->ceilingz > (tspr->z - ((tsiz->Y * tspr->yrepeat) << 2))) ||
wal.nextSector()->floorz < tspr->z)) && !polymost_getclosestpointonwall((const vec2_t *) tspr, wallnum(&wal), &n))
if ((!wal.twoSided() || ((wal.nextSector()->ceilingz > (tspr->pos.Z - ((tsiz->Y * tspr->yrepeat) << 2))) ||
wal.nextSector()->floorz < tspr->pos.Z)) && !polymost_getclosestpointonwall((const vec2_t *) tspr, wallnum(&wal), &n))
{
int const dst = abs(tspr->pos.X - n.X) + abs(tspr->pos.Y - n.Y);
@ -2639,10 +2639,10 @@ static inline float tspriteGetZOfSlopeFloat(tspriteptr_t const tspr, float dax,
{
int16_t const heinum = tspriteGetSlope(tspr);
if (heinum == 0)
return float(tspr->z);
return float(tspr->pos.Z);
float const f = bsin(tspr->ang + 1024) * (day - tspr->pos.Y) - bsin(tspr->ang + 512) * (dax - tspr->pos.X);
return float(tspr->z) + heinum * f * (1.f / 4194304.f);
return float(tspr->pos.Z) + heinum * f * (1.f / 4194304.f);
}
@ -3381,7 +3381,7 @@ static inline int comparetsprites(int const k, int const l)
if (tspriteptr[k]->pos.X == tspriteptr[l]->pos.X &&
tspriteptr[k]->pos.Y == tspriteptr[l]->pos.Y &&
tspriteptr[k]->z == tspriteptr[l]->z &&
tspriteptr[k]->pos.Z == tspriteptr[l]->pos.Z &&
(tspriteptr[k]->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == (tspriteptr[l]->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) &&
tspriteptr[k]->ownerActor != tspriteptr[l]->ownerActor)
return tspriteptr[k]->ownerActor->GetIndex() - tspriteptr[l]->ownerActor->GetIndex();
@ -3428,7 +3428,7 @@ static void sortsprites(int const start, int const end)
{
auto const s = tspriteptr[k];
spritesxyz[k].Z = s->z;
spritesxyz[k].Z = s->pos.Z;
if ((s->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != CSTAT_SPRITE_ALIGNMENT_FLOOR)
{
int32_t yoff = tileTopOffset(s->picnum) + s->yoffset;
@ -3826,7 +3826,7 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
f = (float)tspr->yrepeat * k0;
m0.Z *= f; a0.Z *= f;
k0 = (float)(tspr->z + tspr->ownerActor->sx().position_offset.Z);
k0 = (float)(tspr->pos.Z + tspr->ownerActor->sx().position_offset.Z);
f = ((globalorientation & 8) && (tspr->ownerActor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != 0) ? -4.f : 4.f;
k0 -= (tspr->yoffset * tspr->yrepeat) * f * m->bscale;
zoff = m->siz.Z * .5f;

2
source/core/automap.cpp
View file

@ -608,7 +608,7 @@ void renderDrawMapView(int cposx, int cposy, int czoom, int cang)
{
auto A = *(spritetype**)a;
auto B = *(spritetype**)b;
if (A->z != B->z) return B->z - A->z;
if (A->pos.Z != B->pos.Z) return B->pos.Z - A->pos.Z;
return A->time - B->time; // ensures stable sort.
});

4
source/core/gamefuncs.h
View file

@ -274,10 +274,10 @@ inline int tspriteGetSlope(const tspritetype* spr)
inline int32_t tspriteGetZOfSlope(const tspritetype* tspr, int dax, int day)
{
int heinum = tspriteGetSlope(tspr);
if (heinum == 0) return tspr->z;
if (heinum == 0) return tspr->pos.Z;
int const j = DMulScale(bsin(tspr->ang + 1024), day - tspr->pos.Y, -bsin(tspr->ang + 512), dax - tspr->pos.X, 4);
return tspr->z + MulScale(heinum, j, 18);
return tspr->pos.Z + MulScale(heinum, j, 18);
}

5
source/core/maptypes.h
View file

@ -381,10 +381,7 @@ struct walltype
struct spritetypebase
{
// todo: get rid of the single variables!
union {
struct { int32_t BLAHBLAHX, BLAHBLAHY, z; };
vec3_t pos;
};
union {
struct { int32_t ox, oy, oz; };
vec3_t opos;
@ -436,7 +433,7 @@ struct spritetypebase
int32_t interpolatedz(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(oz, z, smoothratio, scale);
return interpolatedvalue(oz, pos.Z, smoothratio, scale);
}
vec2_t interpolatedvec2(double const smoothratio, int const scale = 16)

2
source/core/rendering/scene/hw_flats.cpp
View file

@ -397,7 +397,7 @@ void HWFlat::ProcessFlatSprite(HWDrawInfo* di, tspritetype* sprite, sectortype*
{
int tilenum = sprite->picnum;
texture = tileGetTexture(tilenum);
z = sprite->z * (1 / -256.f);
z = sprite->pos.Z * (1 / -256.f);
if (z == di->Viewpoint.Pos.Z) return; // looking right at the edge.
dynlightindex = -1;

6
source/core/rendering/scene/hw_sprites.cpp
View file

@ -332,7 +332,7 @@ void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int
SetSpriteTranslucency(spr, alpha, RenderStyle);
x = spr->pos.X * (1 / 16.f);
z = spr->z * (1 / -256.f);
z = spr->pos.Z * (1 / -256.f);
y = spr->pos.Y * (1 / -16.f);
auto vp = di->Viewpoint;
@ -396,7 +396,7 @@ void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int
x = spr->pos.X * (1 / 16.f);
y = spr->pos.Y * (1 / -16.f);
z = spr->z * (1 / -256.f);
z = spr->pos.Z * (1 / -256.f);
x1 = x - viewvecY * (xoff - (width * 0.5f));
x2 = x - viewvecY * (xoff + (width * 0.5f));
@ -504,7 +504,7 @@ bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, tspritetype* spr, s
scalevec.Z *= sprzscale;
translatevec.Z *= sprzscale;
float zpos = (float)(spr->z + sprext->position_offset.Z);
float zpos = (float)(spr->pos.Z + sprext->position_offset.Z);
float zscale = ((spr->cstat & CSTAT_SPRITE_YFLIP) && (spr->ownerActor->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != 0) ? -4.f : 4.f;
zpos -= (spr->yoffset * spr->yrepeat) * zscale * voxel->bscale;

4
source/core/rendering/scene/hw_walls.cpp
View file

@ -114,11 +114,11 @@ static int IsOnWall(tspritetype* tspr, int height)
vec2_t n;
walltype* closest = nullptr;
int topz = (tspr->z - ((height * tspr->yrepeat) << 2));
int topz = (tspr->pos.Z - ((height * tspr->yrepeat) << 2));
for(auto& wal : wallsofsector(sect))
{
if ((wal.nextsector == -1 || ((wal.nextSector()->ceilingz > topz) ||
wal.nextSector()->floorz < tspr->z)) && !GetClosestPointOnWall(tspr, &wal, &n))
wal.nextSector()->floorz < tspr->pos.Z)) && !GetClosestPointOnWall(tspr, &wal, &n))
{
int const dst = abs(tspr->pos.X - n.X) + abs(tspr->pos.Y - n.Y);

2
source/core/savegamehelp.cpp
View file

@ -448,7 +448,7 @@ FSerializer &Serialize(FSerializer &arc, const char *key, spritetype &c, spritet
{
arc("x", c.pos.X, def->pos.X)
("y", c.pos.Y, def->pos.Y)
("z", c.z, def->z)
("z", c.pos.Z, def->pos.Z)
("cstat", c.cstat, def->cstat)
("picnum", c.picnum, def->picnum)
("shade", c.shade, def->shade)

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

@ -38,7 +38,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
pTSprite->setsector(nSector2);
pTSprite->pos.X = pSprite->pos.X + dx;
pTSprite->pos.Y = pSprite->pos.Y + dy;
pTSprite->z = pSprite->z + dz;
pTSprite->pos.Z = pSprite->pos.Z + dz;
pTSprite->ang = pSprite->ang;
pTSprite->picnum = pSprite->picnum;
pTSprite->shade = pSprite->shade;
@ -53,7 +53,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
pTSprite->flags = pSprite->hitag | 0x200;
pTSprite->pos.X = dx + interpolatedvalue(pSprite->ox, pSprite->pos.X, interpolation);
pTSprite->pos.Y = dy + interpolatedvalue(pSprite->oy, pSprite->pos.Y, interpolation);
pTSprite->z = dz + interpolatedvalue(pSprite->oz, pSprite->z, interpolation);
pTSprite->pos.Z = dz + interpolatedvalue(pSprite->oz, pSprite->pos.Z, interpolation);
pTSprite->ang = pSprite->interpolatedang(interpolation);
int nAnim = 0;

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

@ -2550,7 +2550,7 @@ static void ConcussSprite(DBloodActor* source, DBloodActor* actor, int x, int y,
auto pSprite = &actor->s();
int dx = pSprite->pos.X - x;
int dy = pSprite->pos.Y - y;
int dz = (pSprite->z - z) >> 4;
int dz = (pSprite->pos.Z - z) >> 4;
int dist2 = 0x40000 + dx * dx + dy * dy + dz * dz;
assert(dist2 > 0);
damage = scale(0x40000, damage, dist2);
@ -2667,7 +2667,7 @@ void actRadiusDamage(DBloodActor* source, int x, int y, int z, sectortype* pSect
int dx = abs(x - pSprite2->pos.X);
int dy = abs(y - pSprite2->pos.Y);
int dz = abs(z - pSprite2->z) >> 4;
int dz = abs(z - pSprite2->pos.Z) >> 4;
int dist = ksqrt(dx * dx + dy * dy + dz * dz);
if (dist > nDist) continue;
@ -2727,7 +2727,7 @@ static void actNapalmMove(DBloodActor* actor)
if (Chance(0x8000)) pSprite->cstat |= CSTAT_SPRITE_XFLIP;
sfxPlay3DSound(actor, 303, 24 + (pSprite->flags & 3), 1);
actRadiusDamage(pOwner, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 128, 0, 60, kDamageExplode, 15, 120);
actRadiusDamage(pOwner, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), 128, 0, 60, kDamageExplode, 15, 120);
if (pXSprite->data4 > 1)
{
@ -2895,8 +2895,8 @@ DBloodActor* actDropObject(DBloodActor* actor, int nType)
{
int top, bottom;
GetActorExtents(act2, &top, &bottom);
if (bottom >= act2->spr.z)
act2->spr.z -= bottom - act2->spr.z;
if (bottom >= act2->spr.pos.Z)
act2->spr.pos.Z -= bottom - act2->spr.pos.Z;
}
return act2;
@ -2917,7 +2917,7 @@ bool actHealDude(DBloodActor* actor, int add, int threshold)
if (pXDude->health < (unsigned)threshold)
{
spritetype* pSprite = &actor->s();
if (actor->IsPlayerActor()) sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, 780, pSprite->sector());
if (actor->IsPlayerActor()) sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 780, pSprite->sector());
pXDude->health = min<uint32_t>(pXDude->health + add, threshold);
return true;
}
@ -2992,7 +2992,7 @@ static bool actKillModernDude(DBloodActor* actor, DAMAGE_TYPE damageType)
else
{
seqKill(actor);
DBloodActor* pEffectA = gFX.fxSpawnActor((FX_ID)52, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->ang);
DBloodActor* pEffectA = gFX.fxSpawnActor((FX_ID)52, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->ang);
if (pEffectA != nullptr)
{
auto pEffect = &pEffectA->s();
@ -3773,7 +3773,7 @@ static int actDamageThing(DBloodActor* source, DBloodActor* actor, int damage, D
{
case -1:
GibSprite(actor, GIBTYPE_14, nullptr, nullptr);
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, 312, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 312, pSprite->sector());
actPostSprite(actor, kStatFree);
break;
@ -3932,7 +3932,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case 4:
if (pWallHit)
{
auto pFX = gFX.fxSpawnActor(FX_52, pMissile->sector(), pMissile->pos.X, pMissile->pos.Y, pMissile->z, 0);
auto pFX = gFX.fxSpawnActor(FX_52, pMissile->sector(), pMissile->pos.X, pMissile->pos.Y, pMissile->pos.Z, 0);
if (pFX) pFX->spr.ang = (GetWallAngle(pWallHit) + 512) & 2047;
}
break;
@ -3953,7 +3953,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileArcGargoyle:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->z, 306, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->pos.Z, 306, pMissile->sector());
GibSprite(missileActor, GIBTYPE_6, NULL, NULL);
if (hitCode == 3 && pSpriteHit && (pThingInfo || pDudeInfo))
@ -3967,7 +3967,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileLifeLeechAltNormal:
case kMissileLifeLeechAltSmall:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->z, 306, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->pos.Z, 306, pMissile->sector());
if (hitCode == 3 && pSpriteHit && (pThingInfo || pDudeInfo))
{
@ -4006,7 +4006,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
evPostActor(actorHit, 0, kCallbackFXFlameLick);
actBurnSprite(missileOwner, actorHit, 480);
actRadiusDamage(missileOwner, pMissile->pos.X, pMissile->pos.Y, pMissile->z, pMissile->sector(), 16, 20, 10, kDamageBullet, 6, 480);
actRadiusDamage(missileOwner, pMissile->pos.X, pMissile->pos.Y, pMissile->pos.Z, pMissile->sector(), 16, 20, 10, kDamageBullet, 6, 480);
// by NoOne: allow additional bullet damage for Flare Gun
if (gGameOptions.weaponsV10x && !VanillaMode())
@ -4025,7 +4025,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
{
pMissile->picnum = 2123;
missileActor->SetTarget(actorHit);
pXMissile->targetZ = pMissile->z - pSpriteHit->z;
pXMissile->targetZ = pMissile->pos.Z - pSpriteHit->pos.Z;
pXMissile->goalAng = getangle(pMissile->pos.X - pSpriteHit->pos.X, pMissile->pos.Y - pSpriteHit->pos.Y) - pSpriteHit->ang;
pXMissile->state = 1;
actPostSprite(missileActor, kStatFlare);
@ -4081,7 +4081,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileEctoSkull:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->z, 522, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->pos.Z, 522, pMissile->sector());
actPostSprite(missileActor, kStatDebris);
seqSpawn(20, missileActor, -1);
if (hitCode == 3 && actorHit && actorHit->hasX())
@ -4114,7 +4114,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileTeslaRegular:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->z, 518, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->pos.Z, 518, pMissile->sector());
GibSprite(missileActor, (hitCode == 2) ? GIBTYPE_23 : GIBTYPE_22, NULL, NULL);
evKillActor(missileActor);
seqKill(missileActor);
@ -4357,7 +4357,7 @@ static void checkHit(DBloodActor* actor)
break;
case kThingZombieHead:
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, 357, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 357, pSprite->sector());
actKickObject(actor, actor2);
actDamageSprite(nullptr, actor2, kDamageFall, 80);
break;
@ -4439,7 +4439,7 @@ static void checkFloorHit(DBloodActor* actor)
pPlayer->kickPower = PlayClock + 60;
}
actKickObject(actor, actor2);
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, 357, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 357, pSprite->sector());
sfxPlay3DSound(actor, 374, 0, 0);
break;
case kThingZombieHead:
@ -4449,7 +4449,7 @@ static void checkFloorHit(DBloodActor* actor)
pPlayer->kickPower = PlayClock + 60;
}
actKickObject(actor, actor2);
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, 357, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 357, pSprite->sector());
actDamageSprite(nullptr, actor2, kDamageFall, 80);
break;
case kTrapSawCircular:
@ -4616,7 +4616,7 @@ static Collision MoveThing(DBloodActor* actor)
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
if ((actor->GetOwner()) && !cl_bloodvanillaexplosions && !VanillaMode())
enginecompatibility_mode = ENGINECOMPATIBILITY_NONE; // improved clipmove accuracy
ClipMove(pSprite->pos, &pSector, actor->xvel >> 12, actor->yvel >> 12, pSprite->clipdist << 2, (pSprite->z - top) / 4, (bottom - pSprite->z) / 4, CLIPMASK0, lhit);
ClipMove(pSprite->pos, &pSector, actor->xvel >> 12, actor->yvel >> 12, pSprite->clipdist << 2, (pSprite->pos.Z - top) / 4, (bottom - pSprite->pos.Z) / 4, CLIPMASK0, lhit);
actor->hit.hit = lhit;
enginecompatibility_mode = bakCompat; // restore
pSprite->cstat = bakCstat;
@ -4647,10 +4647,10 @@ static Collision MoveThing(DBloodActor* actor)
else
{
assert(pSector);
FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector);
FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector);
}
pSprite->z += actor->zvel >> 8;
pSprite->pos.Z += actor->zvel >> 8;
int ceilZ, floorZ;
Collision ceilColl, floorColl;
@ -4659,11 +4659,11 @@ static Collision MoveThing(DBloodActor* actor)
if ((pSprite->flags & 2) && bottom < floorZ)
{
pSprite->z += 455;
pSprite->pos.Z += 455;
actor->zvel += 58254;
if (pSprite->type == kThingZombieHead)
{
auto* fxActor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto* fxActor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (fxActor)
{
int v34 = (PlayClock * 3) & 2047;
@ -4688,7 +4688,7 @@ static Collision MoveThing(DBloodActor* actor)
{
actTouchFloor(actor, pSprite->sector());
actor->hit.florhit = floorColl;
pSprite->z += floorZ - bottom;
pSprite->pos.Z += floorZ - bottom;
int v20 = actor->zvel - pSprite->sector()->velFloor;
if (v20 > 0)
@ -4743,7 +4743,7 @@ static Collision MoveThing(DBloodActor* actor)
if (top <= ceilZ)
{
actor->hit.ceilhit = ceilColl;
pSprite->z += ClipLow(ceilZ - top, 0);
pSprite->pos.Z += ClipLow(ceilZ - top, 0);
if (actor->zvel < 0)
{
actor->xvel = MulScale(actor->xvel, 0xc000, 16);
@ -4819,8 +4819,8 @@ void MoveDude(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int top, bottom;
GetActorExtents(actor, &top, &bottom);
int bz = (bottom - pSprite->z) / 4;
int tz = (pSprite->z - top) / 4;
int bz = (bottom - pSprite->pos.Z) / 4;
int tz = (pSprite->pos.Z - top) / 4;
int wd = pSprite->clipdist << 2;
auto pSector = pSprite->sector();
int nAiStateType = (pXSprite->aiState) ? pXSprite->aiState->stateType : -1;
@ -4919,7 +4919,7 @@ void MoveDude(DBloodActor* actor)
else
{
assert(pSector);
FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector);
FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector);
}
XSECTOR* pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
@ -4955,7 +4955,7 @@ void MoveDude(DBloodActor* actor)
if (pUpperLink && (pUpperLink->spr.type == kMarkerUpWater || pUpperLink->spr.type == kMarkerUpGoo)) bDepth = 1;
if (pLowerLink && (pLowerLink->spr.type == kMarkerLowWater || pLowerLink->spr.type == kMarkerLowGoo)) bDepth = 1;
if (pPlayer) wd += 16;
if (actor->zvel) pSprite->z += actor->zvel >> 8;
if (actor->zvel) pSprite->pos.Z += actor->zvel >> 8;
int ceilZ, floorZ;
Collision ceilColl, floorColl;
@ -4991,7 +4991,7 @@ void MoveDude(DBloodActor* actor)
}
if (vc)
{
pSprite->z += ((vc * 4) / 2) >> 8;
pSprite->pos.Z += ((vc * 4) / 2) >> 8;
actor->zvel += vc;
}
}
@ -5173,7 +5173,7 @@ void MoveDude(DBloodActor* actor)
int floorZ2 = floorZ;
auto floorColl2 = floorColl;
GetZRange(actor, &ceilZ, &ceilColl, &floorZ, &floorColl, pSprite->clipdist << 2, CLIPMASK0, PARALLAXCLIP_CEILING | PARALLAXCLIP_FLOOR);
if (bottom <= floorZ && pSprite->z - floorZ2 < bz)
if (bottom <= floorZ && pSprite->pos.Z - floorZ2 < bz)
{
floorZ = floorZ2;
floorColl = floorColl2;
@ -5182,7 +5182,7 @@ void MoveDude(DBloodActor* actor)
if (floorZ <= bottom)
{
actor->hit.florhit = floorColl;
pSprite->z += floorZ - bottom;
pSprite->pos.Z += floorZ - bottom;
int v30 = actor->zvel - pSprite->sector()->velFloor;
if (v30 > 0)
{
@ -5222,7 +5222,7 @@ void MoveDude(DBloodActor* actor)
auto pFXs = &pFX->s();
for (int i = 0; i < 7; i++)
{
auto pFX2 = gFX.fxSpawnActor(FX_14, pFXs->sector(), pFXs->pos.X, pFXs->pos.Y, pFXs->z, 0);
auto pFX2 = gFX.fxSpawnActor(FX_14, pFXs->sector(), pFXs->pos.X, pFXs->pos.Y, pFXs->pos.Z, 0);
if (pFX2)
{
pFX2->xvel = Random2(0x6aaaa);
@ -5249,7 +5249,7 @@ void MoveDude(DBloodActor* actor)
if (top <= ceilZ)
{
actor->hit.ceilhit = ceilColl;
pSprite->z += ClipLow(ceilZ - top, 0);
pSprite->pos.Z += ClipLow(ceilZ - top, 0);
if (actor->zvel <= 0 && (pSprite->flags & 4))
actor->zvel = MulScale(-actor->zvel, 0x2000, 16);
@ -5323,10 +5323,10 @@ int MoveMissile(DBloodActor* actor)
RotatePoint(&vx, &vy, (nTargetAngle + 1536) & 2047, 0, 0);
actor->xvel = vx;
actor->yvel = vy;
int dz = pTarget->z - pSprite->z;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int deltaz = dz / 10;
if (pTarget->z < pSprite->z) deltaz = -deltaz;
if (pTarget->pos.Z < pSprite->pos.Z) deltaz = -deltaz;
actor->zvel += deltaz;
}
}
@ -5424,7 +5424,7 @@ int MoveMissile(DBloodActor* actor)
cliptype = 1;
}
pSprite->pos = pos;
pSprite->z += vz;
pSprite->pos.Z += vz;
updatesector(pos.X, pos.Y, &pSector);
if (pSector != nullptr && pSector != pSprite->sector())
{
@ -5435,7 +5435,7 @@ int MoveMissile(DBloodActor* actor)
gHitInfo.hitSector = pSprite->sector();
gHitInfo.hitpos.X = pSprite->pos.X;
gHitInfo.hitpos.Y = pSprite->pos.Y;
gHitInfo.hitpos.Z = pSprite->z;
gHitInfo.hitpos.Z = pSprite->pos.Z;
break;
}
if (pOwner) pOwner->cstat = bakCstat;
@ -5519,7 +5519,7 @@ void actExplodeSprite(DBloodActor* actor)
case kThingTNTBarrel:
{
auto spawned = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0, 1);
auto spawned = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0, 1);
spawned->SetOwner(actor->GetOwner());
if (actCheckRespawn(actor))
{
@ -5621,7 +5621,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 && pXSprite->burnTime > 0) GibSprite(actor, (GIBTYPE)(gib3 - 1), nullptr, nullptr);
if (sound > 0) sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, sound, pSprite->sector());
if (sound > 0) sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, sound, pSprite->sector());
if (dropmsg > 0) actDropObject(actor, dropmsg);
if (!(pSprite->cstat & CSTAT_SPRITE_INVISIBLE) && !(pSprite->flags & kHitagRespawn))
@ -5703,7 +5703,7 @@ static void actCheckProximity()
proxyDist = 512;
}
if (CheckProximity(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), proxyDist))
if (CheckProximity(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), proxyDist))
{
switch (pSprite->type)
{
@ -5825,7 +5825,7 @@ static void actCheckThings()
case kThingPodGreenBall:
if (hit.type == kHitSector)
{
actRadiusDamage(actor->GetOwner(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 200, 1, 20, kDamageExplode, 6, 0);
actRadiusDamage(actor->GetOwner(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), 200, 1, 20, kDamageExplode, 6, 0);
evPostActor(actor, 0, kCallbackFXPodBloodSplat);
}
else if (hit.type == kHitSprite)
@ -5893,7 +5893,7 @@ static void actCheckExplosion()
const EXPLOSION* pExplodeInfo = &explodeInfo[nType];
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pSector = pSprite->sector();
int radius = pExplodeInfo->radius;
@ -5977,7 +5977,7 @@ static void actCheckExplosion()
spritetype* pSprite2 = gPlayer[p].pSprite;
int dx = (x - pSprite2->pos.X) >> 4;
int dy = (y - pSprite2->pos.Y) >> 4;
int dz = (z - pSprite2->z) >> 8;
int dz = (z - pSprite2->pos.Z) >> 8;
int nDist = dx * dx + dy * dy + dz * dz + 0x40000;
int t = DivScale(pXSprite->data2, nDist, 16);
gPlayer[p].flickerEffect += t;
@ -6064,7 +6064,7 @@ static void actCheckTraps()
{
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
int t = (pXSprite->data1 << 23) / 120;
int dx = MulScale(t, Cos(pSprite->ang), 30);
int dy = MulScale(t, Sin(pSprite->ang), 30);
@ -6158,7 +6158,7 @@ static void actCheckDudes()
if ((unsigned int)pXSprite2->health > 0 && actor2->IsPlayerActor())
{
if (CheckProximity(actor2, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 128))
if (CheckProximity(actor2, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), 128))
trTriggerSprite(actor, kCmdSpriteProximity);
}
}
@ -6276,7 +6276,7 @@ void actCheckFlares()
{
int x = pTarget->pos.X + mulscale30r(Cos(pXSprite->goalAng + pTarget->ang), pTarget->clipdist * 2);
int y = pTarget->pos.Y + mulscale30r(Sin(pXSprite->goalAng + pTarget->ang), pTarget->clipdist * 2);
int z = pTarget->z + pXSprite->targetZ;
int z = pTarget->pos.Z + pXSprite->targetZ;
vec3_t pos = { x, y, z };
SetActor(actor, &pos);
actor->xvel = target->xvel;
@ -6352,7 +6352,7 @@ DBloodActor* actSpawnSprite(DBloodActor* source, int nStat)
spritetype* pSprite = &actor->s();
pSprite->pos.X = pSource->pos.X;
pSprite->pos.Y = pSource->pos.Y;
pSprite->z = pSource->z;
pSprite->pos.Z = pSource->pos.Z;
actor->xvel = source->xvel;
actor->yvel = source->yvel;
actor->zvel = source->zvel;
@ -6381,7 +6381,7 @@ DBloodActor* actSpawnDude(DBloodActor* source, int nType, int a3, int a4)
int angle = pSource->ang;
int nDude = nType - kDudeBase;
int x, y, z;
z = a4 + pSource->z;
z = a4 + pSource->pos.Z;
if (a3 < 0)
{
x = pSource->pos.X;
@ -6545,7 +6545,7 @@ DBloodActor* actFireThing(DBloodActor* actor, int a2, int a3, int a4, int thingT
assert(thingType >= kThingBase && thingType < kThingMax);
int x = pSprite->pos.X + MulScale(a2, Cos(pSprite->ang + 512), 30);
int y = pSprite->pos.Y + MulScale(a2, Sin(pSprite->ang + 512), 30);
int z = pSprite->z + a3;
int z = pSprite->pos.Z + a3;
x += MulScale(pSprite->clipdist, Cos(pSprite->ang), 28);
y += MulScale(pSprite->clipdist, Sin(pSprite->ang), 28);
if (HitScan(actor, z, x - pSprite->pos.X, y - pSprite->pos.Y, 0, CLIPMASK0, pSprite->clipdist) != -1)
@ -6660,7 +6660,7 @@ DBloodActor* actFireMissile(DBloodActor* actor, int a2, int a3, int a4, int a5,
const MissileType* pMissileInfo = &missileInfo[nType - kMissileBase];
int x = pSprite->pos.X + MulScale(a2, Cos(pSprite->ang + 512), 30);
int y = pSprite->pos.Y + MulScale(a2, Sin(pSprite->ang + 512), 30);
int z = pSprite->z + a3;
int z = pSprite->pos.Z + a3;
int clipdist = pMissileInfo->clipDist + pSprite->clipdist;
x += MulScale(clipdist, Cos(pSprite->ang), 28);
y += MulScale(clipdist, Sin(pSprite->ang), 28);
@ -6854,7 +6854,7 @@ void actFireVector(DBloodActor* shooter, int a2, int a3, int a4, int a5, int a6,
gHitInfo.hitActor = shooter;
gHitInfo.hitpos.X = pShooter->pos.X;
gHitInfo.hitpos.Y = pShooter->pos.Y;
gHitInfo.hitpos.Z = pShooter->z;
gHitInfo.hitpos.Z = pShooter->pos.Z;
}
}
}
@ -7093,7 +7093,7 @@ void actFireVector(DBloodActor* shooter, int a2, int a3, int a4, int a5, int a6,
void FireballSeqCallback(int, DBloodActor* actor)
{
auto pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_11, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_11, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel;
@ -7105,7 +7105,7 @@ void FireballSeqCallback(int, DBloodActor* actor)
void NapalmSeqCallback(int, DBloodActor* actor)
{
auto pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_12, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_12, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel;
@ -7117,7 +7117,7 @@ void NapalmSeqCallback(int, DBloodActor* actor)
void Fx32Callback(int, DBloodActor* actor)
{
auto pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_32, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_32, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel;
@ -7129,7 +7129,7 @@ void Fx32Callback(int, DBloodActor* actor)
void Fx33Callback(int, DBloodActor* actor)
{
auto pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_33, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_33, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel;
@ -7249,7 +7249,7 @@ void MakeSplash(DBloodActor* actor)
{
auto pSprite = &actor->s();
pSprite->flags &= ~2;
pSprite->z -= 4 << 8;
pSprite->pos.Z -= 4 << 8;
int nSurface = tileGetSurfType(actor->hit.florhit);
switch (pSprite->type)
{

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

@ -137,7 +137,7 @@ bool CanMove(DBloodActor* actor, DBloodActor* target, int nAngle, int nRange)
GetActorExtents(actor, &top, &bottom);
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
HitScan(actor, z, bcos(nAngle), bsin(nAngle), 0, CLIPMASK0, nRange);
int nDist = approxDist(x - gHitInfo.hitpos.X, y - gHitInfo.hitpos.Y);
if (nDist - (pSprite->clipdist << 2) < nRange)
@ -954,7 +954,7 @@ void aiSetTarget(DBloodActor* actor, DBloodActor* target)
DUDEINFO* pDudeInfo = getDudeInfo(pTarget->type);
pXSprite->targetX = pTarget->pos.X;
pXSprite->targetY = pTarget->pos.Y;
pXSprite->targetZ = pTarget->z - ((pDudeInfo->eyeHeight * pTarget->yrepeat) << 2);
pXSprite->targetZ = pTarget->pos.Z - ((pDudeInfo->eyeHeight * pTarget->yrepeat) << 2);
}
}
}
@ -1535,14 +1535,14 @@ void aiThinkTarget(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
@ -1583,14 +1583,14 @@ void aiLookForTarget(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)

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

@ -100,14 +100,14 @@ static void batThinkTarget(DBloodActor* actor)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.z;
int z = pPlayer->actor->spr.pos.Z;
auto pSector = pPlayer->actor->spr.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.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->spr.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.z, pTarget->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - height, actor->spr.sector()))
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()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < 0x3000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -281,7 +281,7 @@ 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.z, pTarget->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - height, actor->spr.sector()))
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 (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -402,7 +402,7 @@ void batMoveToCeil(DBloodActor* actor)
{
int x = actor->spr.pos.X;
int y = actor->spr.pos.Y;
int z = actor->spr.z;
int z = actor->spr.pos.Z;
if (z - actor->xspr.targetZ < 0x1000)
{
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;

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

@ -70,7 +70,7 @@ void SlashSeqCallback(int, DBloodActor* actor)
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
// Correct ?
int dz = pSprite->z - pTarget->z;
int dz = pSprite->pos.Z - pTarget->pos.Z;
dx += Random3(4000 - 700 * gGameOptions.nDifficulty);
dy += Random3(4000 - 700 * gGameOptions.nDifficulty);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGargSlash);
@ -86,14 +86,14 @@ void StompSeqCallback(int, DBloodActor* actor1)
int dy = bsin(pSprite->ang);
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
int vc = 400;
auto pSector = pSprite->sector();
int v1c = 5 + 2 * gGameOptions.nDifficulty;
int v10 = 25 + 30 * gGameOptions.nDifficulty;
const bool newSectCheckMethod = !cl_bloodvanillaenemies && !VanillaMode(); // use new sector checking logic
auto sectorMap = GetClosestSpriteSectors(pSector, x, y, vc, nullptr, newSectCheckMethod);
int hit = HitScan(actor1, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor1, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
DBloodActor* actor2 = nullptr;
actHitcodeToData(hit, &gHitInfo, &actor2);
@ -250,16 +250,16 @@ static void beastThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0? 0 : DivScale(pTarget->z - pSprite->z, nDist, 10);
actor->dudeSlope = nDist == 0? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, nDist, 10);
if (nDist < 0x1400 && nDist > 0xa00 && abs(nDeltaAngle) < 85 && (pTarget->flags & 2)
&& IsPlayerSprite(pTarget) && Chance(0x8000))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
if (pXTarget->health > (unsigned)gPlayerTemplate[0].startHealth / 2)
{
switch (hit)
@ -291,7 +291,7 @@ static void beastThinkChase(DBloodActor* actor)
}
if (nDist < 921 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -382,10 +382,10 @@ static void beastThinkSwimChase(DBloodActor* actor)
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + pSprite->z;
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -468,8 +468,8 @@ static void sub_62AE0(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int z = pSprite->z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->z + getDudeInfo(pTarget->type)->eyeHeight;
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
@ -505,8 +505,8 @@ static void sub_62D7C(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int z = pSprite->z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->z + getDudeInfo(pTarget->type)->eyeHeight;
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;

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

@ -116,14 +116,14 @@ static void eelThinkTarget(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -196,7 +196,7 @@ static void eelThinkPonder(DBloodActor* actor)
int height2 = (getDudeInfo(pTarget->type)->eyeHeight * pTarget->yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < -0x2000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -308,7 +308,7 @@ static void eelThinkChase(DBloodActor* actor)
GetActorExtents(actor, &top, &bottom);
int top2, bottom2;
GetSpriteExtents(pTarget, &top2, &bottom2);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -427,7 +427,7 @@ void eelMoveToCeil(DBloodActor* actor)
auto pSprite = &actor->s();
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
if (z - pXSprite->targetZ < 0x1000)
{
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;

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

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

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

@ -158,15 +158,15 @@ static void calebThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->z-pSprite->z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->pos.Z-pSprite->pos.Z, nDist, 10);
if (nDist < 0x599 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -258,10 +258,10 @@ static void calebThinkSwimChase(DBloodActor* actor)
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + pSprite->z;
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -320,8 +320,8 @@ static void sub_65F44(DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int z = pSprite->z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->z + getDudeInfo(pTarget->type)->eyeHeight;
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
@ -358,8 +358,8 @@ static void sub_661E0(DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int z = pSprite->z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->z + getDudeInfo(pTarget->type)->eyeHeight;
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;

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

@ -67,7 +67,7 @@ void cerberusBiteSeqCallback(int, DBloodActor* actor)
}
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int dz = pTarget->z - pSprite->z;
int dz = pTarget->pos.Z - pSprite->pos.Z;
actFireVector(actor, 350, -100, dx, dy, dz, kVectorCerberusHack);
actFireVector(actor, -350, 0, dx, dy, dz, kVectorCerberusHack);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorCerberusHack);
@ -97,7 +97,7 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int z2 = pSprite2->pos.Z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
continue;
@ -126,7 +126,7 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt1.at8)
{
int tz = pSprite2->z - pSprite->z;
int tz = pSprite2->pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, pSprite2->sector()))
{
nClosest = nDist2;
@ -176,7 +176,7 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int z2 = pSprite2->pos.Z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
continue;
@ -271,14 +271,14 @@ static void cerberusThinkTarget(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -388,7 +388,7 @@ static void cerberusThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());
@ -416,7 +416,7 @@ static void cerberusThinkChase(DBloodActor* actor)
}
else if (nDist < 0x200 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (pSprite->type) {
case kDudeCerberusTwoHead:
switch (hit) {

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

@ -136,7 +136,7 @@ void cultThrowSeqCallback(int, DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
if (nDist > 0x1e00)
@ -170,7 +170,7 @@ void sub_68230(int, DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
auto pMissile = actFireThing(actor, 0, 0, dz / 128 - 14500, nMissile, (nDist2 << 17) / 120);
@ -284,19 +284,19 @@ static void cultThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->z - pSprite->z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, nDist, 10);
switch (pSprite->type) {
case kDudeCultistTommy:
if (nDist < 0x1e00 && nDist > 0xe00 && abs(nDeltaAngle) < 85 && !TargetNearExplosion(pTarget)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty > 2 && IsPlayerSprite(pTarget) && gPlayer[pTarget->type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -317,7 +317,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x4600 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -364,7 +364,7 @@ static void cultThinkChase(DBloodActor* actor)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty >= 2 && IsPlayerSprite(pTarget) && !gPlayer[pTarget->type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -385,7 +385,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x3200 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -432,7 +432,7 @@ static void cultThinkChase(DBloodActor* actor)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty > 2 && IsPlayerSprite(pTarget) && gPlayer[pTarget->type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -453,7 +453,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x3200 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -499,7 +499,7 @@ static void cultThinkChase(DBloodActor* actor)
if (nDist < 0x2c00 && nDist > 0x1400 && abs(nDeltaAngle) < 85
&& (pTarget->flags & 2) && IsPlayerSprite(pTarget))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -520,7 +520,7 @@ static void cultThinkChase(DBloodActor* actor)
else if (nDist < 0x1400 && abs(nDeltaAngle) < 85
&& (pTarget->flags & 2) && IsPlayerSprite(pTarget))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -544,7 +544,7 @@ static void cultThinkChase(DBloodActor* actor)
&& (pTarget->flags & 2) && gGameOptions.nDifficulty > 2 && IsPlayerSprite(pTarget) && gPlayer[pTarget->type - kDudePlayer1].isRunning
&& Chance(0x8000))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -565,7 +565,7 @@ static void cultThinkChase(DBloodActor* actor)
}
else if (nDist < 0x3200 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:

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

@ -126,7 +126,7 @@ void BlastSSeqCallback(int, DBloodActor* actor)
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int z2 = pSprite2->pos.Z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
continue;
@ -155,7 +155,7 @@ void BlastSSeqCallback(int, DBloodActor* actor)
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = pSprite2->z - pSprite->z;
int tz = pSprite2->pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, pSprite2->sector()))
{
nClosest = nDist2;
@ -228,14 +228,14 @@ static void gargThinkTarget(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -382,7 +382,7 @@ static void gargThinkChase(DBloodActor* actor)
int height2 = (pDudeInfo->eyeHeight * pTarget->yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -393,7 +393,7 @@ static void gargThinkChase(DBloodActor* actor)
case kDudeGargoyleFlesh:
if (nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -418,7 +418,7 @@ static void gargThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -452,7 +452,7 @@ static void gargThinkChase(DBloodActor* actor)
case kDudeGargoyleStone:
if (nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -477,7 +477,7 @@ static void gargThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:

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

@ -112,7 +112,7 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int z2 = pSprite2->pos.Z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
continue;
@ -141,7 +141,7 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = pSprite2->z - pSprite->z;
int tz = pSprite2->pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, pSprite2->sector()))
{
nClosest = nDist2;
@ -208,14 +208,14 @@ static void ghostThinkTarget(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -362,7 +362,7 @@ static void ghostThinkChase(DBloodActor* actor)
int height2 = (pDudeInfo->eyeHeight * pTarget->yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -371,7 +371,7 @@ static void ghostThinkChase(DBloodActor* actor)
switch (pSprite->type) {
case kDudePhantasm:
if (nDist < 0x2000 && nDist > 0x1000 && abs(nDeltaAngle) < 85) {
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -391,7 +391,7 @@ static void ghostThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:

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

@ -64,7 +64,7 @@ void GillBiteSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int dz = pSprite->z - pTarget->z;
int dz = pSprite->pos.Z - pTarget->pos.Z;
dx += Random3(2000);
dy += Random3(2000);
actFireVector(actor, 0, 0, dx, dy, dz, kVectorGillBite);
@ -147,15 +147,15 @@ static void gillThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->z - pSprite->z, nDist, 10);
actor->dudeSlope = nDist == 0 ? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, nDist, 10);
if (nDist < 921 && abs(nDeltaAngle) < 28)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -247,10 +247,10 @@ static void gillThinkSwimChase(DBloodActor* actor)
if (nDist <= pDudeInfo->seeDist)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = pDudeInfo->eyeHeight + pSprite->z;
int height = pDudeInfo->eyeHeight + pSprite->pos.Z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -314,8 +314,8 @@ static void sub_6CD74(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int z = pSprite->z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->z + getDudeInfo(pTarget->type)->eyeHeight;
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;
@ -351,8 +351,8 @@ static void sub_6D03C(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
int z = pSprite->z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->z + getDudeInfo(pTarget->type)->eyeHeight;
int z = pSprite->pos.Z + getDudeInfo(pSprite->type)->eyeHeight;
int z2 = pTarget->pos.Z + getDudeInfo(pTarget->type)->eyeHeight;
int nAng = ((pXSprite->goalAng + 1024 - pSprite->ang) & 2047) - 1024;
int nTurnRange = (pDudeInfo->angSpeed << 2) >> 4;
pSprite->ang = (pSprite->ang + ClipRange(nAng, -nTurnRange, nTurnRange)) & 2047;

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

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

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

@ -57,7 +57,7 @@ void houndBiteSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
#ifdef NOONE_EXTENSIONS
if (IsPlayerSprite(pTarget) || gModernMap) // allow to hit non-player targets
actFireVector(actor, 0, 0, dx, dy, pTarget->z - pSprite->z, kVectorHoundBite);
actFireVector(actor, 0, 0, dx, dy, pTarget->pos.Z - pSprite->pos.Z, kVectorHoundBite);
#else
if (IsPlayerSprite(pTarget))
actFireVector(actor, 0, 0, dx, dy, pTarget->z - pSprite->z, kVectorHoundBite);
@ -132,7 +132,7 @@ static void houndThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

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

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

@ -70,7 +70,7 @@ void podAttack(int, DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int x = pTarget->pos.X - pSprite->pos.X;
int y = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int dz = pTarget->pos.Z - pSprite->pos.Z;
x += Random2(1000);
y += Random2(1000);
int nDist = approxDist(x, y);
@ -125,7 +125,7 @@ void sub_70284(int, DBloodActor* actor)
nDist = 75;
break;
}
actRadiusDamage(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
actRadiusDamage(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
}
static void aiPodSearch(DBloodActor* actor)
@ -212,7 +212,7 @@ static void aiPodChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -50,7 +50,7 @@ void ratBiteSeqCallback(int, DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
if (IsPlayerSprite(pTarget))
actFireVector(actor, 0, 0, dx, dy, pTarget->z - pSprite->z, kVectorRatBite);
actFireVector(actor, 0, 0, dx, dy, pTarget->pos.Z - pSprite->pos.Z, kVectorRatBite);
}
static void ratThinkSearch(DBloodActor* actor)
@ -106,7 +106,7 @@ static void ratThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -73,10 +73,10 @@ void SpidBiteSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &target->s();
if (IsPlayerSprite(pTarget))
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
if (hit == 3 && gHitInfo.actor()->IsPlayerActor())
{
dz += pTarget->z - pSprite->z;
dz += pTarget->pos.Z - pSprite->pos.Z;
PLAYER* pPlayer = &gPlayer[pTarget->type - kDudePlayer1];
switch (pSprite->type)
{
@ -120,7 +120,7 @@ void SpidJumpSeqCallback(int, DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
spritetype* pTarget = &actor->GetTarget()->s();
if (IsPlayerSprite(pTarget)) {
dz += pTarget->z - pSprite->z;
dz += pTarget->pos.Z - pSprite->pos.Z;
switch (pSprite->type) {
case kDudeSpiderBrown:
case kDudeSpiderRed:
@ -220,7 +220,7 @@ static void spidThinkChase(DBloodActor* actor)
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector())) {
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector())) {
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

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

@ -79,7 +79,7 @@ void sub_71BD4(int, DBloodActor* actor)
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int z2 = pSprite2->pos.Z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
continue;
@ -108,7 +108,7 @@ void sub_71BD4(int, DBloodActor* actor)
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = pSprite2->z - pSprite->z;
int tz = pSprite2->pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, pSprite2->sector()))
{
nClosest = nDist2;
@ -153,7 +153,7 @@ void sub_720AC(int, DBloodActor* actor)
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int z2 = pSprite2->pos.Z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
continue;
@ -182,7 +182,7 @@ void sub_720AC(int, DBloodActor* actor)
int nDeltaAngle = ((nAngle - pSprite->ang + 1024) & 2047) - 1024;
if (abs(nDeltaAngle) <= tt.at8)
{
int tz = pSprite2->z - pSprite->z;
int tz = pSprite2->pos.Z - pSprite->pos.Z;
if (cansee(x, y, z, pSprite->sector(), x2, y2, z2, pSprite2->sector()))
{
nClosest = nDist2;
@ -236,14 +236,14 @@ static void sub_725A4(DBloodActor* actor)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
int z = pPlayer->pSprite->pos.Z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist > pDudeInfo->seeDist && nDist > pDudeInfo->hearDist)
continue;
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
@ -320,7 +320,7 @@ static void sub_72934(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -145,7 +145,7 @@ static bool genDudeAdjustSlope(DBloodActor* actor, int dist, int weaponType, int
for (int i = -8191; i < 8192; i += by)
{
HitScan(actor, pSprite->z, bcos(pSprite->ang), bsin(pSprite->ang), i, clipMask, dist);
HitScan(actor, pSprite->pos.Z, bcos(pSprite->ang), bsin(pSprite->ang), i, clipMask, dist);
if (!fStart && actor->GetTarget() == gHitInfo.actor()) fStart = i;
else if (fStart && actor->GetTarget() != gHitInfo.actor())
{
@ -327,7 +327,7 @@ static void ThrowThing(DBloodActor* actor, bool impact)
int zThrow = 14500;
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int dz = pTarget->pos.Z - pSprite->pos.Z;
int dist = approxDist(dx, dy);
auto actLeech = leechIsDropped(actor);
@ -544,8 +544,8 @@ static void unicultThinkChase(DBloodActor* actor)
int losAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int eyeAboveZ = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (dist > pDudeInfo->seeDist || !cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(),
pSprite->pos.X, pSprite->pos.Y, pSprite->z - eyeAboveZ, pSprite->sector()))
if (dist > pDudeInfo->seeDist || !cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(),
pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - eyeAboveZ, pSprite->sector()))
{
if (spriteIsUnderwater(actor, false)) aiGenDudeNewState(actor, &genDudeSearchW);
else aiGenDudeNewState(actor, &genDudeSearchL);
@ -559,7 +559,7 @@ static void unicultThinkChase(DBloodActor* actor)
if ((PlayClock & 64) == 0 && Chance(0x3000) && !spriteIsUnderwater(actor, false))
playGenDudeSound(actor, kGenDudeSndChasing);
actor->dudeSlope = dist == 0 ? 0 : DivScale(pTarget->z - pSprite->z, dist, 10);
actor->dudeSlope = dist == 0 ? 0 : DivScale(pTarget->pos.Z - pSprite->pos.Z, dist, 10);
int curWeapon = actor->genDudeExtra.curWeapon;
int weaponType = actor->genDudeExtra.weaponType;
@ -581,7 +581,7 @@ static void unicultThinkChase(DBloodActor* actor)
}
else if (dist < 12264 && dist > 7680 && !spriteIsUnderwater(actor, false) && curWeapon != kModernThingEnemyLifeLeech)
{
int pHit = HitScan(actor, pSprite->z, dx, dy, 0, 16777280, 0);
int pHit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, 16777280, 0);
switch (pHit) {
case 0:
case 4:
@ -606,8 +606,8 @@ static void unicultThinkChase(DBloodActor* actor)
}
int ldist = aiFightGetTargetDist(targetactor, pDudeInfo, actLeech);
if (ldist > 3 || !cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(),
pLeech->pos.X, pLeech->pos.Y, pLeech->z, pLeech->sector()) || actLeech->GetTarget() == nullptr)
if (ldist > 3 || !cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(),
pLeech->pos.X, pLeech->pos.Y, pLeech->pos.Z, pLeech->sector()) || actLeech->GetTarget() == nullptr)
{
aiGenDudeNewState(actor, &genDudeThrow2);
genDudeThrow2.nextState = &genDudeDodgeShortL;
@ -680,7 +680,7 @@ static void unicultThinkChase(DBloodActor* actor)
// don't attack slaves
if (actor->GetTarget() != nullptr && actor->GetTarget()->GetOwner() == actor)
{
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
return;
}
else if (actor->genDudeExtra.slaveCount > gGameOptions.nDifficulty || dist < meleeVector->maxDist)
@ -751,7 +751,7 @@ static void unicultThinkChase(DBloodActor* actor)
{
int nType = curWeapon - kTrapExploder;
const EXPLOSION* pExpl = &explodeInfo[nType];
if (CheckProximity(actor, pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pExpl->radius >> 1))
if (CheckProximity(actor, pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pExpl->radius >> 1))
{
actor->xvel = actor->yvel = actor->zvel = 0;
if (doExplosion(actor, nType) && pXSprite->health > 0)
@ -769,9 +769,9 @@ static void unicultThinkChase(DBloodActor* actor)
{
int objDist = -1; int targetDist = -1; int hit = -1;
if (weaponType == kGenDudeWeaponHitscan)
hit = HitScan(actor, pSprite->z, bcos(pSprite->ang), bsin(pSprite->ang), actor->dudeSlope, CLIPMASK1, dist);
hit = HitScan(actor, pSprite->pos.Z, bcos(pSprite->ang), bsin(pSprite->ang), actor->dudeSlope, CLIPMASK1, dist);
else if (weaponType == kGenDudeWeaponMissile)
hit = HitScan(actor, pSprite->z, bcos(pSprite->ang), bsin(pSprite->ang), actor->dudeSlope, CLIPMASK0, dist);
hit = HitScan(actor, pSprite->pos.Z, bcos(pSprite->ang), bsin(pSprite->ang), actor->dudeSlope, CLIPMASK0, dist);
if (hit >= 0)
{
@ -1442,7 +1442,7 @@ void removeLeech(DBloodActor* actLeech, bool delSprite)
if (actLeech != NULL)
{
auto const pLeech = &actLeech->s();
auto effectactor = gFX.fxSpawnActor((FX_ID)52, pLeech->sector(), pLeech->pos.X, pLeech->pos.Y, pLeech->z, pLeech->ang);
auto effectactor = gFX.fxSpawnActor((FX_ID)52, pLeech->sector(), pLeech->pos.X, pLeech->pos.Y, pLeech->pos.Z, pLeech->ang);
if (effectactor != NULL)
{
spritetype* pEffect = &effectactor->s();
@ -1841,8 +1841,8 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
GetActorExtents(actor, &top, &bottom);
int nType = pTarget->type - kDudeBase;
DUDEINFO* pDudeInfo = &dudeInfo[nType];
int z1 = (top - pSprite->z) - 256;
int x = pTarget->pos.X; int y = pTarget->pos.Y; int z = pTarget->z;
int z1 = (top - pSprite->pos.Z) - 256;
int x = pTarget->pos.X; int y = pTarget->pos.Y; int z = pTarget->pos.Z;
int nDist = approxDist(x - pSprite->pos.X, y - pSprite->pos.Y);
if (nDist != 0 && cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), x, y, z, pTarget->sector()))
@ -1854,7 +1854,7 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
pSprite->ang = getangle(x - pSprite->pos.X, y - pSprite->pos.Y);
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int tz = pTarget->z - (pTarget->yrepeat * pDudeInfo->aimHeight) * 4;
int tz = pTarget->pos.Z - (pTarget->yrepeat * pDudeInfo->aimHeight) * 4;
int dz = DivScale(tz - top - 256, nDist, 10);
int nMissileType = kMissileLifeLeechAltNormal + (pXSprite->data3 ? 1 : 0);
int t2;
@ -1887,7 +1887,7 @@ bool doExplosion(DBloodActor* actor, int nType)
{
auto const pSprite = &actor->s();
auto actExplosion = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, kStatExplosion, true);
auto actExplosion = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, kStatExplosion, true);
auto const pExplosion = &actExplosion->s();
auto const pXExplosion = &actExplosion->x();
if (!actExplosion->hasX())
@ -1937,7 +1937,7 @@ DBloodActor* genDudeSpawn(DBloodActor* source, DBloodActor* actor, int nDist)
spritetype* pDude = &spawned->s();
XSPRITE* pXDude = &spawned->x();
int x, y, z = pSprite->z, nAngle = pSprite->ang, nType = kDudeModernCustom;
int x, y, z = pSprite->pos.Z, nAngle = pSprite->ang, nType = kDudeModernCustom;
if (nDist > 0)
{
@ -2124,7 +2124,7 @@ void genDudeTransform(DBloodActor* actor)
aiInitSprite(actor);
// try to restore target
if (target == nullptr) aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
if (target == nullptr) aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
else aiSetTarget(actor, target);
// finally activate it
@ -2210,11 +2210,11 @@ void updateTargetOfSlaves(DBloodActor* actor)
if (actTarget != slave[i]->GetTarget()) aiSetTarget(slave[i], actTarget);
// check if slave have proper target
if (slave[i]->GetTarget() == nullptr || slave[i]->GetTarget()->GetOwner() == actor)
aiSetTarget(slave[i], pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetTarget(slave[i], pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
}
else
{
aiSetTarget(slave[i], pSprite->pos.X, pSprite->pos.Y, pSprite->z); // try return to master
aiSetTarget(slave[i], pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z); // try return to master
}
}
}
@ -2558,9 +2558,9 @@ bool genDudePrepare(DBloodActor* actor, int propId)
// make sure dudes aren't in the floor or ceiling
int zTop, zBot; GetSpriteExtents(pSprite, &zTop, &zBot);
if (!(pSprite->sector()->ceilingstat & CSTAT_SECTOR_SKY))
pSprite->z += ClipLow(pSprite->sector()->ceilingz - zTop, 0);
pSprite->pos.Z += ClipLow(pSprite->sector()->ceilingz - zTop, 0);
if (!(pSprite->sector()->floorstat & CSTAT_SECTOR_SKY))
pSprite->z += ClipHigh(pSprite->sector()->floorz - zBot, 0);
pSprite->pos.Z += ClipHigh(pSprite->sector()->floorz - zBot, 0);
pSprite->clipdist = ClipRange((pSprite->xrepeat + pSprite->yrepeat) >> 1, 4, 120);
if (propId) break;

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

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

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

@ -138,14 +138,14 @@ static void zombfThinkChase(DBloodActor* actor)
{
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
if (nDist < 0x1400 && nDist > 0xe00 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -164,7 +164,7 @@ static void zombfThinkChase(DBloodActor* actor)
}
else if (nDist < 0x1400 && nDist > 0x600 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:
@ -183,7 +183,7 @@ static void zombfThinkChase(DBloodActor* actor)
}
else if (nDist < 0x400 && abs(nDeltaAngle) < 85)
{
int hit = HitScan(actor, pSprite->z, dx, dy, 0, CLIPMASK1, 0);
int hit = HitScan(actor, pSprite->pos.Z, dx, dy, 0, CLIPMASK1, 0);
switch (hit)
{
case -1:

50
source/games/blood/src/animatesprite.cpp
View file

@ -150,7 +150,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
if (perc >= 75) pNSprite2->pal = 0;
else if (perc >= 50) pNSprite2->pal = 6;
pNSprite2->z = top - 2048;
pNSprite2->pos.Z = top - 2048;
pNSprite2->shade = -128;
break;
}
@ -173,7 +173,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
RotateXZ(&x, &y, &z, nRand2);
pNSprite->pos.X = pTSprite->pos.X + x;
pNSprite->pos.Y = pTSprite->pos.Y + y;
pNSprite->z = pTSprite->z + (z<<4);
pNSprite->pos.Z = pTSprite->pos.Z + (z<<4);
pNSprite->picnum = 1720;
pNSprite->shade = -128;
}
@ -189,7 +189,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
pNSprite->shade = -128;
pNSprite->pal = 0;
pNSprite->z = top;
pNSprite->pos.Z = top;
if (nViewEffect == kViewEffectFlag)
pNSprite->xrepeat = pNSprite->yrepeat = 24;
else
@ -203,7 +203,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
if (!pNSprite)
break;
pNSprite->z = pTSprite->z;
pNSprite->pos.Z = pTSprite->pos.Z;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->shade = -128;
pNSprite->xrepeat = pTSprite->xrepeat;
@ -249,7 +249,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->xrepeat = pNSprite->yrepeat = 24;
pNSprite->picnum = 626;
pNSprite->z = top;
pNSprite->pos.Z = top;
break;
}
case kViewEffectTrail:
@ -275,9 +275,9 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
pNSprite->pos.X = pTSprite->pos.X + x;
int y = MulScale(nLen, Sin(nAng), 30);
pNSprite->pos.Y = pTSprite->pos.Y + y;
pNSprite->z = pTSprite->z;
pNSprite->pos.Z = pTSprite->pos.Z;
assert(pSector);
FindSector(pNSprite->pos.X, pNSprite->pos.Y, pNSprite->z, &pSector);
FindSector(pNSprite->pos.X, pNSprite->pos.Y, pNSprite->pos.Z, &pSector);
pNSprite->setsector(pSector);
pNSprite->ownerActor = pTSprite->ownerActor;
pNSprite->picnum = pTSprite->picnum;
@ -298,7 +298,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
break;
pNSprite->shade = -128;
pNSprite->z = pTSprite->z;
pNSprite->pos.Z = pTSprite->pos.Z;
pNSprite->picnum = 908;
pNSprite->statnum = kStatDecoration;
pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum)*pTSprite->xrepeat)/64;
@ -312,7 +312,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->z = top;
pNSprite->pos.Z = top;
if (IsDudeSprite(pTSprite))
pNSprite->picnum = 672;
else
@ -331,7 +331,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->z = bottom;
pNSprite->pos.Z = bottom;
if (pTSprite->type >= kDudeBase && pTSprite->type < kDudeMax)
pNSprite->picnum = 672;
else
@ -350,7 +350,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->z = top;
pNSprite->pos.Z = top;
pNSprite->picnum = 2101;
pNSprite->shade = -128;
pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum)*pTSprite->xrepeat)/32;
@ -364,7 +364,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom);
pNSprite->z = bottom;
pNSprite->pos.Z = bottom;
pNSprite->picnum = 2101;
pNSprite->shade = -128;
pNSprite->xrepeat = pNSprite->yrepeat = (tileWidth(pTSprite->picnum)*pTSprite->xrepeat)/32;
@ -378,7 +378,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
if (!pNSprite)
break;
pNSprite->z = getflorzofslopeptr(pTSprite->sector(), pNSprite->pos.X, pNSprite->pos.Y);
pNSprite->pos.Z = getflorzofslopeptr(pTSprite->sector(), pNSprite->pos.X, pNSprite->pos.Y);
pNSprite->shade = 127;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->xrepeat = pTSprite->xrepeat;
@ -387,7 +387,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
pNSprite->pal = 5;
int height = tileHeight(pNSprite->picnum);
int center = height / 2 + tileTopOffset(pNSprite->picnum);
pNSprite->z -= (pNSprite->yrepeat << 2) * (height - center);
pNSprite->pos.Z -= (pNSprite->yrepeat << 2) * (height - center);
}
break;
}
@ -400,7 +400,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
pNSprite->shade = -128;
pNSprite->pal = 2;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->z = pTSprite->z;
pNSprite->pos.Z = pTSprite->pos.Z;
pNSprite->xrepeat = pTSprite->xrepeat;
pNSprite->yrepeat = pTSprite->yrepeat;
pNSprite->picnum = 2427;
@ -415,9 +415,9 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
sectortype *pSector = pTSprite->sector();
pNSprite->pos.X = pTSprite->pos.X;
pNSprite->pos.Y = pTSprite->pos.Y;
pNSprite->z = pSector->ceilingz;
pNSprite->pos.Z = pSector->ceilingz;
pNSprite->picnum = 624;
pNSprite->shade = ((pTSprite->z-pSector->ceilingz)>>8)-64;
pNSprite->shade = ((pTSprite->pos.Z-pSector->ceilingz)>>8)-64;
pNSprite->pal = 2;
pNSprite->xrepeat = pNSprite->yrepeat = 64;
pNSprite->cstat |= CSTAT_SPRITE_ONE_SIDE | CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_YFLIP | CSTAT_SPRITE_TRANSLUCENT;
@ -434,9 +434,9 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
sectortype *pSector = pTSprite->sector();
pNSprite->pos.X = pTSprite->pos.X;
pNSprite->pos.Y = pTSprite->pos.Y;
pNSprite->z = pSector->floorz;
pNSprite->pos.Z = pSector->floorz;
pNSprite->picnum = 624;
uint8_t nShade = (pSector->floorz-pTSprite->z)>>8;
uint8_t nShade = (pSector->floorz-pTSprite->pos.Z)>>8;
pNSprite->shade = nShade-32;
pNSprite->pal = 2;
pNSprite->xrepeat = pNSprite->yrepeat = nShade;
@ -451,7 +451,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
if (!pNSprite)
break;
pNSprite->z = pTSprite->z;
pNSprite->pos.Z = pTSprite->pos.Z;
if (gDetail > 1)
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT | CSTAT_SPRITE_TRANS_FLIP;
pNSprite->shade = ClipLow(pTSprite->shade-32, -128);
@ -473,8 +473,8 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
pNSprite->pos.X = pTSprite->pos.X;
pNSprite->pos.Y = pTSprite->pos.Y;
pNSprite->z = pTSprite->z-(32<<8);
pNSprite->z -= weaponIcon.zOffset<<8; // offset up
pNSprite->pos.Z = pTSprite->pos.Z-(32<<8);
pNSprite->pos.Z -= weaponIcon.zOffset<<8; // offset up
pNSprite->picnum = nTile;
pNSprite->shade = pTSprite->shade;
pNSprite->xrepeat = 32;
@ -811,12 +811,12 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
if (pTSprite->type != kMissileFlareRegular) break;
sectortype *pSector = pTSprite->sector();
int zDiff = (pTSprite->z - pSector->ceilingz) >> 8;
int zDiff = (pTSprite->pos.Z - pSector->ceilingz) >> 8;
if ((pSector->ceilingstat & CSTAT_SECTOR_SKY) == 0 && zDiff < 64) {
viewAddEffect(tsprite, spritesortcnt, nTSprite, kViewEffectCeilGlow);
}
zDiff = (pSector->floorz - pTSprite->z) >> 8;
zDiff = (pSector->floorz - pTSprite->pos.Z) >> 8;
if ((pSector->floorstat & CSTAT_SECTOR_SKY) == 0 && zDiff < 64) {
viewAddEffect(tsprite, spritesortcnt, nTSprite, kViewEffectFloorGlow);
}
@ -865,7 +865,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
POSTURE *pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pNTSprite->pos.X += MulScale(pPosture->zOffset, Cos(pTSprite->ang), 28);
pNTSprite->pos.Y += MulScale(pPosture->zOffset, Sin(pTSprite->ang), 28);
pNTSprite->z = pPlayer->pSprite->z-pPosture->xOffset;
pNTSprite->pos.Z = pPlayer->pSprite->pos.Z-pPosture->xOffset;
}
}

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

@ -58,7 +58,7 @@ void ambProcess(void)
{
int dx = pSprite->pos.X-gMe->pSprite->pos.X;
int dy = pSprite->pos.Y-gMe->pSprite->pos.Y;
int dz = pSprite->z-gMe->pSprite->z;
int dz = pSprite->pos.Z-gMe->pSprite->pos.Z;
dx >>= 4;
dy >>= 4;
dz >>= 8;

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

@ -105,7 +105,7 @@ void fxFlareSpark(DBloodActor* actor, sectortype*) // 3
{
if (!actor) return;
spritetype *pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_28, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_28, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x1aaaa);
@ -119,7 +119,7 @@ void fxFlareSparkLite(DBloodActor* actor, sectortype*) // 4
{
if (!actor) return;
spritetype *pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_28, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_28, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x1aaaa);
@ -161,7 +161,7 @@ void fxBloodSpurt(DBloodActor* actor, sectortype*) // 6
{
if (!actor) return;
spritetype *pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->spr.ang = 0;
@ -177,7 +177,7 @@ void fxArcSpark(DBloodActor* actor, sectortype*) // 7
{
if (!actor) return;
spritetype* pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_15, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_15, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x10000);
@ -197,7 +197,7 @@ void fxDynPuff(DBloodActor* actor, sectortype*) // 8
int nDist = (pSprite->xrepeat*(tileWidth(pSprite->picnum)/2))>>2;
int x = pSprite->pos.X + MulScale(nDist, Cos(pSprite->ang-512), 30);
int y = pSprite->pos.Y + MulScale(nDist, Sin(pSprite->ang-512), 30);
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pFX = gFX.fxSpawnActor(FX_7, pSprite->sector(), x, y, z, 0);
if (pFX)
{
@ -286,7 +286,7 @@ void Respawn(DBloodActor* actor, sectortype*) // 9
pSprite->cstat &= ~CSTAT_SPRITE_INVISIBLE;
}
gFX.fxSpawnActor(FX_29, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
gFX.fxSpawnActor(FX_29, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
sfxPlay3DSound(actor, 350, -1, 0);
break;
}
@ -393,12 +393,12 @@ void fxBloodBits(DBloodActor* actor, sectortype*) // 14
GetZRange(actor, &ceilZ, &ceilColl, &floorZ, &floorColl, pSprite->clipdist, CLIPMASK0);
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
pSprite->z += floorZ-bottom;
pSprite->pos.Z += floorZ-bottom;
int nAngle = Random(2048);
int nDist = Random(16)<<4;
int x = pSprite->pos.X+MulScale(nDist, Cos(nAngle), 28);
int y = pSprite->pos.Y+MulScale(nDist, Sin(nAngle), 28);
gFX.fxSpawnActor(FX_48, pSprite->sector(), x, y, pSprite->z, 0);
gFX.fxSpawnActor(FX_48, pSprite->sector(), x, y, pSprite->pos.Z, 0);
if (pSprite->ang == 1024)
{
int nChannel = 28 + (actor->GetIndex() & 2); // this is a little stupid...
@ -418,7 +418,7 @@ void fxTeslaAlt(DBloodActor* actor, sectortype*) // 15
{
if (!actor) return;
spritetype* pSprite = &actor->s();
auto pFX = gFX.fxSpawnActor(FX_49, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_49, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x1aaaa);
@ -441,7 +441,7 @@ void fxBouncingSleeve(DBloodActor* actor, sectortype*) // 16
GetZRange(actor, &ceilZ, &ceilColl, &floorZ, &floorColl, pSprite->clipdist, CLIPMASK0);
int top, bottom; GetSpriteExtents(pSprite, &top, &bottom);
pSprite->z += floorZ - bottom;
pSprite->pos.Z += floorZ - bottom;
int zv = actor->zvel - pSprite->sector()->velFloor;
@ -527,9 +527,9 @@ void fxPodBloodSpray(DBloodActor* actor, sectortype*) // 18
spritetype* pSprite = &actor->s();
DBloodActor* pFX;
if (pSprite->type == 53)
pFX = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
pFX = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
else
pFX = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
pFX = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pFX)
{
pFX->spr.ang = 0;
@ -550,7 +550,7 @@ void fxPodBloodSplat(DBloodActor* actor, sectortype*) // 19
GetZRange(actor, &ceilZ, &ceilColl, &floorZ, &floorColl, pSprite->clipdist, CLIPMASK0);
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
pSprite->z += floorZ-bottom;
pSprite->pos.Z += floorZ-bottom;
int nAngle = Random(2048);
int nDist = Random(16)<<4;
int x = pSprite->pos.X+MulScale(nDist, Cos(nAngle), 28);
@ -604,7 +604,7 @@ void sub_76A08(DBloodActor *actor, DBloodActor *actor2, PLAYER *pPlayer) // ???
GetSpriteExtents(pSprite, &top, &bottom);
pSprite->pos.X = pSprite2->pos.X;
pSprite->pos.Y = pSprite2->pos.Y;
pSprite->z = pSprite2->sector()->floorz-(bottom-pSprite->z);
pSprite->pos.Z = pSprite2->sector()->floorz-(bottom-pSprite->pos.Z);
pSprite->ang = pSprite2->ang;
ChangeActorSect(actor, pSprite2->sector());
sfxPlay3DSound(actor2, 201, -1, 0);

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

@ -523,7 +523,7 @@ void dbLoadMap(const char* pPath, int* pX, int* pY, int* pZ, short* pAngle, sect
pSprite->clear();
pSprite->pos.X = LittleLong(load.x);
pSprite->pos.Y = LittleLong(load.y);
pSprite->z = LittleLong(load.z);
pSprite->pos.Z = LittleLong(load.z);
pSprite->cstat = ESpriteFlags::FromInt(LittleShort(load.cstat));
pSprite->picnum = LittleShort(load.picnum);
int secno = LittleShort(load.sectnum);

2
source/games/blood/src/db.h
View file

@ -85,7 +85,7 @@ extern const char *gWeaponText[];
template<typename T> void GetSpriteExtents(T const * const pSprite, int *top, int *bottom)
{
*top = *bottom = pSprite->z;
*top = *bottom = pSprite->pos.Z;
if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != CSTAT_SPRITE_ALIGNMENT_FLOOR)
{
int height = tileHeight(pSprite->picnum);

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

@ -203,9 +203,9 @@ void CFX::fxProcess(void)
actAirDrag(actor, pFXData->drag);
pSprite->pos.X += actor->xvel>>12;
pSprite->pos.Y += actor->yvel>>12;
pSprite->z += actor->zvel>>8;
pSprite->pos.Z += actor->zvel>>8;
// Weird...
if (actor->xvel || (actor->yvel && pSprite->z >= pSprite->sector()->floorz))
if (actor->xvel || (actor->yvel && pSprite->pos.Z >= pSprite->sector()->floorz))
{
updatesector(pSprite->pos.X, pSprite->pos.Y, &pSector);
if (pSector == nullptr)
@ -213,7 +213,7 @@ void CFX::fxProcess(void)
remove(actor);
continue;
}
if (getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) <= pSprite->z)
if (getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) <= pSprite->pos.Z)
{
if (pFXData->funcID < 0 || pFXData->funcID >= kCallbackMax)
{
@ -233,12 +233,12 @@ void CFX::fxProcess(void)
{
int32_t floorZ, ceilZ;
getzsofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y, &ceilZ, &floorZ);
if (ceilZ > pSprite->z && !(pSector->ceilingstat & CSTAT_SECTOR_SKY))
if (ceilZ > pSprite->pos.Z && !(pSector->ceilingstat & CSTAT_SECTOR_SKY))
{
remove(actor);
continue;
}
if (floorZ < pSprite->z)
if (floorZ < pSprite->pos.Z)
{
if (pFXData->funcID < 0 || pFXData->funcID >= kCallbackMax)
{
@ -259,11 +259,11 @@ void fxSpawnBlood(DBloodActor *actor, int )
if (!pSprite->insector())
return;
auto pSector = pSprite->sector();
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector))
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector))
return;
if (adult_lockout && gGameOptions.nGameType <= 0)
return;
auto bloodactor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
auto bloodactor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (bloodactor)
{
bloodactor->spr.ang = 1024;
@ -280,15 +280,15 @@ void fxSpawnPodStuff(DBloodActor* actor, int )
if (!pSprite->insector())
return;
auto pSector = pSprite->sector();
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector))
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector))
return;
if (adult_lockout && gGameOptions.nGameType <= 0)
return;
DBloodActor *spawnactor;
if (pSprite->type == kDudePodGreen)
spawnactor = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
spawnactor = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
else
spawnactor = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
spawnactor = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (spawnactor)
{
spawnactor->spr.ang = 1024;

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

@ -112,14 +112,14 @@ bool CheckProximity(DBloodActor *actor, int nX, int nY, int nZ, sectortype* pSec
int oY = abs(nY-pSprite->pos.Y)>>4;
if (oY >= nDist) return 0;
int oZ = abs(nZ-pSprite->z)>>8;
int oZ = abs(nZ-pSprite->pos.Z)>>8;
if (oZ >= nDist) return 0;
if (approxDist(oX, oY) >= nDist) return 0;
int bottom, top;
GetActorExtents(actor, &top, &bottom);
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), nX, nY, nZ, pSector))
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), nX, nY, nZ, pSector))
return 1;
if (cansee(pSprite->pos.X, pSprite->pos.Y, bottom, pSprite->sector(), nX, nY, nZ, pSector))
return 1;
@ -387,7 +387,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
gHitInfo.clearObj();
int x1 = pSprite->pos.X+MulScale(nOffset, Cos(pSprite->ang+512), 30);
int y1 = pSprite->pos.Y+MulScale(nOffset, Sin(pSprite->ang+512), 30);
int z1 = pSprite->z+nZOffset;
int z1 = pSprite->pos.Z+nZOffset;
auto bakCstat = pSprite->cstat;
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
if (nRange)
@ -419,7 +419,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
if (tileWidth(nPicnum) == 0 || tileHeight(nPicnum) == 0)
return 3;
int height = (tileHeight(nPicnum)*pOther->yrepeat)<<2;
int otherZ = pOther->z;
int otherZ = pOther->pos.Z;
if (pOther->cstat & CSTAT_SPRITE_YCENTER)
otherZ += height / 2;
int nOffset = tileTopOffset(nPicnum);
@ -529,7 +529,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
gHitInfo.clearObj();
x1 = gHitInfo.hitpos.X + link->spr.pos.X - actor->spr.pos.X;
y1 = gHitInfo.hitpos.Y + link->spr.pos.Y - actor->spr.pos.Y;
z1 = gHitInfo.hitpos.Z + link->spr.z - actor->spr.z;
z1 = gHitInfo.hitpos.Z + link->spr.pos.Z - actor->spr.pos.Z;
pos = { x1, y1, z1 };
hitscan(pos, link->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
@ -543,7 +543,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
gHitInfo.clearObj();
x1 = gHitInfo.hitpos.X + link->spr.pos.X - actor->spr.pos.X;
y1 = gHitInfo.hitpos.Y + link->spr.pos.Y - actor->spr.pos.Y;
z1 = gHitInfo.hitpos.Z + link->spr.z - actor->spr.z;
z1 = gHitInfo.hitpos.Z + link->spr.pos.Z - actor->spr.pos.Z;
pos = { x1, y1, z1 };
hitscan(pos, link->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
continue;
@ -580,7 +580,7 @@ void GetZRange(DBloodActor *actor, int *ceilZ, Collision *ceilColl, int *floorZ,
auto link = actor->GetOwner();
vec3_t lpos = pSprite->pos + link->spr.pos - actor->spr.pos;
getzrange(lpos, link->spr.sector(), &nTemp1, scratch, (int32_t*)floorZ, *floorColl, nDist, nMask);
*floorZ -= link->spr.z - actor->spr.z;
*floorZ -= link->spr.pos.Z - actor->spr.pos.Z;
}
}
if (ceilColl->type == kHitSector)
@ -594,7 +594,7 @@ void GetZRange(DBloodActor *actor, int *ceilZ, Collision *ceilColl, int *floorZ,
auto link = actor->GetOwner();
vec3_t lpos = pSprite->pos + link->spr.pos - actor->spr.pos;
getzrange(lpos, link->spr.sector(), (int32_t*)ceilZ, *ceilColl, &nTemp1, scratch, nDist, nMask);
*ceilZ -= link->spr.z - actor->spr.z;
*ceilZ -= link->spr.pos.Z - actor->spr.pos.Z;
}
}
pSprite->cstat = bakCstat;
@ -622,7 +622,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);
*floorZ -= link->spr.z - actor->spr.z;
*floorZ -= link->spr.pos.Z - actor->spr.pos.Z;
}
}
if (ceilColl->type == kHitSector)
@ -636,7 +636,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);
*ceilZ -= link->spr.z - actor->spr.z;
*ceilZ -= link->spr.pos.Z - actor->spr.pos.Z;
}
}
}

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

@ -269,7 +269,7 @@ void GibFX(DBloodActor* actor, GIBFX *pGFX, CGibPosition *pPos, CGibVelocity *pV
auto pSector = pSprite->sector();
if (adult_lockout && gGameOptions.nGameType == 0 && pGFX->fxId == FX_13)
return;
CGibPosition gPos(pSprite->pos.X, pSprite->pos.Y, pSprite->z);
CGibPosition gPos(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
if (pPos)
gPos = *pPos;
int32_t ceilZ, floorZ;

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

@ -127,7 +127,7 @@ void InitMirrors(void)
mirror[mirrorcnt].type = 2;
mirror[mirrorcnt].dx = link2->spr.pos.X - link->spr.pos.X;
mirror[mirrorcnt].dy = link2->spr.pos.Y - link->spr.pos.Y;
mirror[mirrorcnt].dz = link2->spr.z - link->spr.z;
mirror[mirrorcnt].dz = link2->spr.pos.Z - link->spr.pos.Z;
mirror[mirrorcnt].wallnum = i;
mirror[mirrorcnt].link = j;
secti->floorpicnum = 4080 + mirrorcnt;
@ -137,7 +137,7 @@ void InitMirrors(void)
mirror[mirrorcnt].type = 1;
mirror[mirrorcnt].dx = link->spr.pos.X - link2->spr.pos.X;
mirror[mirrorcnt].dy = link->spr.pos.Y - link2->spr.pos.Y;
mirror[mirrorcnt].dz = link->spr.z - link2->spr.z;
mirror[mirrorcnt].dz = link->spr.pos.Z - link2->spr.pos.Z;
mirror[mirrorcnt].wallnum = j;
mirror[mirrorcnt].link = i;
sectj->ceilingpicnum = 4080 + mirrorcnt;

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

@ -267,7 +267,7 @@ static DBloodActor* nnExtSpawnDude(DBloodActor* sourceActor, DBloodActor* origin
XSPRITE* pXDude = &pDudeActor->x();
int angle = pOrigin->ang;
int x, y, z = a4 + pOrigin->z;
int x, y, z = a4 + pOrigin->pos.Z;
if (a3 < 0)
{
x = pOrigin->pos.X;
@ -728,8 +728,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 (pSprite->insector() && pXSprite->Touch && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)) {
if (pSprite->z == pSprite->sector()->floorz) pSprite->z--;
else if (pSprite->z == pSprite->sector()->ceilingz) pSprite->z++;
if (pSprite->pos.Z == pSprite->sector()->floorz) pSprite->pos.Z--;
else if (pSprite->pos.Z == pSprite->sector()->ceilingz) pSprite->pos.Z++;
}
// make Proximity flag work not just for dudes and things...
@ -970,7 +970,7 @@ static DBloodActor* randomDropPickupObject(DBloodActor* sourceactor, int prevIte
pXSource->dropMsg = uint8_t(pSprite2->type); // store dropped item type in dropMsg
pSprite2->pos.X = pSource->pos.X;
pSprite2->pos.Y = pSource->pos.Y;
pSprite2->z = pSource->z;
pSprite2->pos.Z = pSource->pos.Z;
if ((pSource->flags & kModernTypeFlag1) && (pXSource->txID > 0 || (pXSource->txID != 3 && pXSource->lockMsg > 0)))
{
@ -1025,7 +1025,7 @@ static void windGenDoVerticalWind(int factor, sectortype* pSector)
auto sp = &actor->s();
if (sp->type == kMarkerOn && sp->statnum != kStatMarker)
{
maxZ = sp->z;
maxZ = sp->pos.Z;
maxZfound = true;
break;
}
@ -1051,9 +1051,9 @@ static void windGenDoVerticalWind(int factor, sectortype* pSector)
continue;
}
if (maxZfound && pSpr->z <= maxZ)
if (maxZfound && pSpr->pos.Z <= maxZ)
{
zdiff = pSpr->z - maxZ;
zdiff = pSpr->pos.Z - maxZ;
if (actor->zvel < 0) actor->zvel += MulScale(actor->zvel >> 4, zdiff, 16);
continue;
@ -1063,7 +1063,7 @@ static void windGenDoVerticalWind(int factor, sectortype* pSector)
if (actor->zvel >= 0) actor->zvel += val;
else actor->zvel = val;
pSpr->z += actor->zvel >> 12;
pSpr->pos.Z += actor->zvel >> 12;
}
@ -1180,7 +1180,7 @@ void nnExtProcessSuperSprites()
int okDist = (pProx->IsDudeActor()) ? 96 : ClipLow(pProxSpr->clipdist * 3, 32);
int x = pProxSpr->pos.X;
int y = pProxSpr->pos.Y;
int z = pProxSpr->z;
int z = pProxSpr->pos.Z;
auto pSect = pProxSpr->sector();
if (!pXProxSpr->DudeLockout)
@ -1238,7 +1238,7 @@ void nnExtProcessSuperSprites()
int x = pSightSpr->pos.X;
int y = pSightSpr->pos.Y;
int z = pSightSpr->z;
int z = pSightSpr->pos.Z;
auto pSightSect = pSightSpr->sector();
int ztop2, zbot2;
@ -1384,8 +1384,8 @@ void nnExtProcessSuperSprites()
int fz = getflorzofslopeptr(pSector, pDebris->pos.X, pDebris->pos.Y);
GetActorExtents(debrisactor, &top, &bottom);
if (fz >= bottom && pSector->lowerLink == nullptr && !(pSector->ceilingstat & CSTAT_SECTOR_SKY)) pDebris->z += ClipLow(cz - top, 0);
if (cz <= top && pSector->upperLink == nullptr && !(pSector->floorstat & CSTAT_SECTOR_SKY)) pDebris->z += ClipHigh(fz - bottom, 0);
if (fz >= bottom && pSector->lowerLink == nullptr && !(pSector->ceilingstat & CSTAT_SECTOR_SKY)) pDebris->pos.Z += ClipLow(cz - top, 0);
if (cz <= top && pSector->upperLink == nullptr && !(pSector->floorstat & CSTAT_SECTOR_SKY)) pDebris->pos.Z += ClipHigh(fz - bottom, 0);
}
}
}
@ -1587,7 +1587,7 @@ void debrisConcuss(DBloodActor* owneractor, int listIndex, int x, int y, int z,
if (actor != nullptr && actor->hasX())
{
spritetype* pSprite = &actor->s();
int dx = pSprite->pos.X - x; int dy = pSprite->pos.Y - y; int dz = (pSprite->z - z) >> 4;
int dx = pSprite->pos.X - x; int dy = pSprite->pos.Y - y; int dz = (pSprite->pos.Z - z) >> 4;
dmg = scale(0x40000, dmg, 0x40000 + dx * dx + dy * dy + dz * dz);
bool thing = (pSprite->type >= kThingBase && pSprite->type < kThingMax);
int size = (tileWidth(pSprite->picnum) * pSprite->xrepeat * tileHeight(pSprite->picnum) * pSprite->yrepeat) >> 1;
@ -1669,8 +1669,8 @@ void debrisMove(int listIndex)
Collision moveHit;
moveHit.setNone();
int floorDist = (bottom - pSprite->z) >> 2;
int ceilDist = (pSprite->z - top) >> 2;
int floorDist = (bottom - pSprite->pos.Z) >> 2;
int ceilDist = (pSprite->pos.Z - top) >> 2;
int clipDist = pSprite->clipdist << 2;
int mass = actor->spriteMass.mass;
@ -1713,7 +1713,7 @@ void debrisMove(int listIndex)
}
}
else if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector))
else if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, &pSector))
{
return;
}
@ -1729,7 +1729,7 @@ void debrisMove(int listIndex)
uwater = pSector->xs().Underwater;
if (actor->zvel)
pSprite->z += actor->zvel >> 8;
pSprite->pos.Z += actor->zvel >> 8;
int ceilZ, floorZ;
Collision ceilColl, floorColl;
@ -1752,14 +1752,14 @@ void debrisMove(int listIndex)
if (vc)
{
pSprite->z += ((vc << 2) >> 1) >> 8;
pSprite->pos.Z += ((vc << 2) >> 1) >> 8;
actor->zvel += vc;
}
}
else if ((pXSprite->physAttr & kPhysGravity) && bottom < floorZ)
{
pSprite->z += 455;
pSprite->pos.Z += 455;
actor->zvel += 58254;
}
@ -1821,7 +1821,7 @@ void debrisMove(int listIndex)
if ((pFX = gFX.fxSpawnActor(FX_10, pSprite->sector(), pSprite->pos.X, pSprite->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.z, 0)) == NULL) continue;
if ((pFX2 = gFX.fxSpawnActor(FX_14, pFX->spr.sector(), pFX->spr.pos.X, pFX->spr.pos.Y, pFX->spr.pos.Z, 0)) == NULL) continue;
pFX2->xvel = Random2(0x6aaaa);
pFX2->yvel = Random2(0x6aaaa);
pFX2->zvel = -(int)Random(0xd5555);
@ -1848,7 +1848,7 @@ void debrisMove(int listIndex)
if (top <= ceilZ)
{
actor->hit.ceilhit = moveHit = ceilColl;
pSprite->z += ClipLow(ceilZ - top, 0);
pSprite->pos.Z += ClipLow(ceilZ - top, 0);
if (actor->zvel <= 0 && (pXSprite->physAttr & kPhysFalling))
actor->zvel = MulScale(-actor->zvel, 0x2000, 16);
@ -3003,7 +3003,7 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
pSprite->pos.X = pSource->pos.X; pSprite->pos.Y = pSource->pos.Y;
int zTop, zBot;
GetActorExtents(sourceactor, &zTop, &zBot);
pSprite->z = zBot;
pSprite->pos.Z = zBot;
clampSprite(actor, 0x01);
@ -3152,7 +3152,7 @@ void useEffectGen(DBloodActor* sourceactor, DBloodActor* actor)
pos = bottom;
break;
case 2: // middle
pos = pSprite->z + (tileHeight(pSprite->picnum) / 2 + tileTopOffset(pSprite->picnum));
pos = pSprite->pos.Z + (tileHeight(pSprite->picnum) / 2 + tileTopOffset(pSprite->picnum));
break;
case 3:
case 4:
@ -3587,21 +3587,21 @@ void useSeqSpawnerGen(DBloodActor* sourceactor, int objType, sectortype* pSector
switch (pXSource->data3)
{
default:
pSpawned->z = pSprite->z;
pSpawned->pos.Z = pSprite->pos.Z;
break;
case 2:
pSpawned->z = bottom;
pSpawned->pos.Z = bottom;
break;
case 3:
pSpawned->z = top;
pSpawned->pos.Z = top;
break;
case 4:
pSpawned->z = pSprite->z + tileHeight(pSprite->picnum) / 2 + tileTopOffset(pSprite->picnum);
pSpawned->pos.Z = pSprite->pos.Z + tileHeight(pSprite->picnum) / 2 + tileTopOffset(pSprite->picnum);
break;
case 5:
case 6:
if (!pSprite->insector()) pSpawned->z = top;
else pSpawned->z = (pXSource->data3 == 5) ? spawned->sector()->floorz : spawned->sector()->ceilingz;
if (!pSprite->insector()) pSpawned->pos.Z = top;
else pSpawned->pos.Z = (pXSource->data3 == 5) ? spawned->sector()->floorz : spawned->sector()->ceilingz;
break;
}
@ -4277,7 +4277,7 @@ bool condCheckDude(DBloodActor* aCond, int cmpOp, bool PUSH)
break;
case 3:
case 4:
var = cansee(pSpr->pos.X, pSpr->pos.Y, pSpr->z, pSpr->sector(), pTrgt->pos.X, pTrgt->pos.Y, pTrgt->z - eyeAboveZ, pTrgt->sector());
var = cansee(pSpr->pos.X, pSpr->pos.Y, pSpr->pos.Z, pSpr->sector(), pTrgt->pos.X, pTrgt->pos.Y, pTrgt->pos.Z - eyeAboveZ, pTrgt->sector());
if (cond == 4 && var > 0)
{
var = ((1024 + getangle(dx, dy) - pSpr->ang) & 2047) - 1024;
@ -4460,15 +4460,15 @@ bool condCheckSprite(DBloodActor* aCond, int cmpOp, bool PUSH)
if ((pPlayer = getPlayerById(pSpr->type)) != NULL)
var = HitScan(objActor, pPlayer->zWeapon, pPlayer->aim.dx, pPlayer->aim.dy, pPlayer->aim.dz, arg1, arg3 << 1);
else if (objActor->IsDudeActor())
var = HitScan(objActor, pSpr->z, bcos(pSpr->ang), bsin(pSpr->ang), (!objActor->hasX()) ? 0 : objActor->dudeSlope, arg1, arg3 << 1);
var = HitScan(objActor, pSpr->pos.Z, bcos(pSpr->ang), bsin(pSpr->ang), (!objActor->hasX()) ? 0 : objActor->dudeSlope, arg1, arg3 << 1);
else if ((var2 & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FLOOR)
{
var3 = (var2 & 0x0008) ? 0x10000 << 1 : -(0x10000 << 1);
var = HitScan(objActor, pSpr->z, Cos(pSpr->ang) >> 16, Sin(pSpr->ang) >> 16, var3, arg1, arg3 << 1);
var = HitScan(objActor, pSpr->pos.Z, Cos(pSpr->ang) >> 16, Sin(pSpr->ang) >> 16, var3, arg1, arg3 << 1);
}
else
{
var = HitScan(objActor, pSpr->z, bcos(pSpr->ang), bsin(pSpr->ang), 0, arg1, arg3 << 1);
var = HitScan(objActor, pSpr->pos.Z, bcos(pSpr->ang), bsin(pSpr->ang), 0, arg1, arg3 << 1);
}
if (var >= 0)
@ -4986,7 +4986,7 @@ bool aiFightDudeCanSeeTarget(DBloodActor* dudeactor, DUDEINFO* pDudeInfo, DBlood
int eyeAboveZ = pDudeInfo->eyeHeight * pDude->yrepeat << 2;
// is there a line of sight to the target?
if (cansee(pDude->pos.X, pDude->pos.Y, pDude->z, pDude->sector(), pTarget->pos.X, pTarget->pos.Y, pTarget->z - eyeAboveZ, pTarget->sector()))
if (cansee(pDude->pos.X, pDude->pos.Y, pDude->pos.Z, pDude->sector(), pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z - eyeAboveZ, pTarget->sector()))
{
/*int nAngle = getangle(dx, dy);
int losAngle = ((1024 + nAngle - pDude->ang) & 2047) - 1024;
@ -5034,7 +5034,7 @@ void aiFightFreeTargets(DBloodActor* actor)
{
if (!targetactor->IsDudeActor() || !targetactor->hasX()) continue;
else if (targetactor->GetTarget() == actor)
aiSetTarget(targetactor, targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.z);
aiSetTarget(targetactor, targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.pos.Z);
}
}
@ -5143,7 +5143,7 @@ void aiFightAlarmDudesInSight(DBloodActor* actor, int max)
continue;
auto pDude = &dudeactor->s();
aiSetTarget(dudeactor, pDude->pos.X, pDude->pos.Y, pDude->z);
aiSetTarget(dudeactor, pDude->pos.X, pDude->pos.Y, pDude->pos.Z);
aiActivateDude(dudeactor);
if (max-- < 1)
break;
@ -6242,9 +6242,9 @@ void useRandomItemGen(DBloodActor* actor)
while (auto iactor = it.Next())
{
spritetype* pItem = &iactor->s();
if ((unsigned int)pItem->type == pXSource->dropMsg && pItem->pos.X == pSource->pos.X && pItem->pos.Y == pSource->pos.Y && pItem->z == pSource->z)
if ((unsigned int)pItem->type == pXSource->dropMsg && pItem->pos.X == pSource->pos.X && pItem->pos.Y == pSource->pos.Y && pItem->pos.Z == pSource->pos.Z)
{
gFX.fxSpawnActor((FX_ID)29, pSource->sector(), pSource->pos.X, pSource->pos.Y, pSource->z, 0);
gFX.fxSpawnActor((FX_ID)29, pSource->sector(), pSource->pos.X, pSource->pos.Y, pSource->pos.Z, 0);
pItem->type = kSpriteDecoration;
actPostSprite(iactor, kStatFree);
break;
@ -6481,7 +6481,7 @@ void sprite2sectorSlope(DBloodActor* actor, sectortype* pSector, char rel, bool
}
spriteSetSlope(pSprite, slope);
if (forcez) pSprite->z = z;
if (forcez) pSprite->pos.Z = z;
}
//---------------------------------------------------------------------------
@ -6522,7 +6522,7 @@ void useSlopeChanger(DBloodActor* sourceactor, int objType, sectortype* pSect, D
{
auto spr = &iactor->s();
if (!(spr->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)) continue;
else if (getflorzofslopeptr(pSect, spr->pos.X, spr->pos.Y) - kSlopeDist <= spr->z)
else if (getflorzofslopeptr(pSect, spr->pos.X, spr->pos.Y) - kSlopeDist <= spr->pos.Z)
{
sprite2sectorSlope(iactor, pSect, 0, true);
@ -6559,7 +6559,7 @@ void useSlopeChanger(DBloodActor* sourceactor, int objType, sectortype* pSect, D
{
auto spr = &iactor->s();
if (!(spr->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR)) continue;
else if (getceilzofslopeptr(pSect, spr->pos.X, spr->pos.Y) + kSlopeDist >= spr->z)
else if (getceilzofslopeptr(pSect, spr->pos.X, spr->pos.Y) + kSlopeDist >= spr->pos.Z)
{
sprite2sectorSlope(iactor, pSect, 1, true);
@ -6617,8 +6617,8 @@ void useSlopeChanger(DBloodActor* sourceactor, int objType, sectortype* pSect, D
case 1: sprite2sectorSlope(objActor, pSpr->sector(), 0, flag2); break;
case 2: sprite2sectorSlope(objActor, pSpr->sector(), 1, flag2); break;
case 3:
if (getflorzofslopeptr(pSpr->sector(), pSpr->pos.X, pSpr->pos.Y) - kSlopeDist <= pSpr->z) sprite2sectorSlope(objActor, pSpr->sector(), 0, flag2);
if (getceilzofslopeptr(pSpr->sector(), pSpr->pos.X, pSpr->pos.Y) + kSlopeDist >= pSpr->z) sprite2sectorSlope(objActor, pSpr->sector(), 1, flag2);
if (getflorzofslopeptr(pSpr->sector(), pSpr->pos.X, pSpr->pos.Y) - kSlopeDist <= pSpr->pos.Z) sprite2sectorSlope(objActor, pSpr->sector(), 0, flag2);
if (getceilzofslopeptr(pSpr->sector(), pSpr->pos.X, pSpr->pos.Y) + kSlopeDist >= pSpr->pos.Z) sprite2sectorSlope(objActor, pSpr->sector(), 1, flag2);
break;
}
break;
@ -6779,14 +6779,14 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
auto actLeech = leechIsDropped(actor);
if (pXSource->data4 == 3)
{
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
aiSetGenIdleState(actor);
if (pSprite->type == kDudeModernCustom && actLeech)
removeLeech(actLeech);
}
else if (pXSource->data4 == 4)
{
aiSetTarget(actor, pPlayer->pos.X, pPlayer->pos.Y, pPlayer->z);
aiSetTarget(actor, pPlayer->pos.X, pPlayer->pos.Y, pPlayer->pos.Z);
if (pSprite->type == kDudeModernCustom && actLeech)
removeLeech(actLeech);
}
@ -6806,7 +6806,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
if (!targetactor->IsDudeActor() || pXTarget->health < 1 || !aiFightDudeCanSeeTarget(actor, pDudeInfo, targetactor))
{
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
}
// dude attack or attacked by target that does not fit by data id?
else if (pXSource->data1 != 666 && pXTarget->data1 != pXSource->data1)
@ -6814,7 +6814,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
if (aiFightDudeIsAffected(targetactor))
{
// force stop attack target
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
if (actor->GetBurnSource() == targetactor)
{
pXSprite->burnTime = 0;
@ -6822,7 +6822,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
}
// force stop attack dude
aiSetTarget(targetactor, pTarget->pos.X, pTarget->pos.Y, pTarget->z);
aiSetTarget(targetactor, pTarget->pos.X, pTarget->pos.Y, pTarget->pos.Z);
if (targetactor->GetBurnSource() == actor)
{
pXTarget->burnTime = 0;
@ -6850,7 +6850,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
// force mate stop attack dude, if he does
if (matetarget == actor)
{
aiSetTarget(mateactor, pMate->pos.X, pMate->pos.Y, pMate->z);
aiSetTarget(mateactor, pMate->pos.X, pMate->pos.Y, pMate->pos.Z);
}
else if (pXSprite->rxID != matetarget->x().rxID)
{
@ -6861,13 +6861,13 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
else
{
// force mate to stop attack another mate
aiSetTarget(mateactor, pMate->pos.X, pMate->pos.Y, pMate->z);
aiSetTarget(mateactor, pMate->pos.X, pMate->pos.Y, pMate->pos.Z);
}
}
// force dude stop attack mate, if target was not changed previously
if (actor == mateactor)
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
}
@ -6894,7 +6894,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
// Make prev target not aim in dude
if (targetactor)
{
aiSetTarget(targetactor, targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.z);
aiSetTarget(targetactor, targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.pos.Z);
if (!isActive(newtargactor))
aiActivateDude(newtargactor);
}
@ -6993,7 +6993,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
spritetype* pMate = &pMateTargetActor->GetTarget()->s();
pXSprite->targetX = pMate->pos.X;
pXSprite->targetY = pMate->pos.Y;
pXSprite->targetZ = pMate->z;
pXSprite->targetZ = pMate->pos.Z;
if (!isActive(actor))
aiActivateDude(actor);
return;
@ -7484,7 +7484,7 @@ bool setDataValueOfObject(int objType, sectortype* sect, walltype* wal, DBloodAc
bool nnExtCanMove(DBloodActor* actor, DBloodActor* target, int nAngle, int nRange)
{
auto pSprite = &actor->s();
int x = pSprite->pos.X, y = pSprite->pos.Y, z = pSprite->z;
int x = pSprite->pos.X, y = pSprite->pos.Y, z = pSprite->pos.Z;
auto pSector = pSprite->sector();
HitScan(actor, z, Cos(nAngle) >> 16, Sin(nAngle) >> 16, 0, CLIPMASK0, nRange);
int nDist = approxDist(x - gHitInfo.hitpos.X, y - gHitInfo.hitpos.Y);
@ -7996,7 +7996,7 @@ void aiPatrolMove(DBloodActor* actor)
int dx = (pTarget->pos.X - pSprite->pos.X);
int dy = (pTarget->pos.Y - pSprite->pos.Y);
int dz = (pTarget->z - (pSprite->z - pDudeInfo->eyeHeight)) * 6;
int dz = (pTarget->pos.Z - (pSprite->pos.Z - pDudeInfo->eyeHeight)) * 6;
int vel = (pXSprite->unused1 & kDudeFlagCrouch) ? kMaxPatrolCrouchVelocity : kMaxPatrolVelocity;
int goalAng = 341;
@ -8078,10 +8078,10 @@ void aiPatrolAlarmLite(DBloodActor* actor, DBloodActor* targetactor)
int eaz2 = (getDudeInfo(pTarget->type)->eyeHeight * pTarget->yrepeat) << 2;
int nDist = approxDist(pDude->pos.X - pSprite->pos.X, pDude->pos.Y - pSprite->pos.Y);
if (nDist >= kPatrolAlarmSeeDist || !cansee(pSprite->pos.X, pSprite->pos.Y, zt1, pSprite->sector(), pDude->pos.X, pDude->pos.Y, pDude->z - eaz2, pDude->sector()))
if (nDist >= kPatrolAlarmSeeDist || !cansee(pSprite->pos.X, pSprite->pos.Y, zt1, pSprite->sector(), pDude->pos.X, pDude->pos.Y, pDude->pos.Z - eaz2, pDude->sector()))
{
nDist = approxDist(pDude->pos.X - pTarget->pos.X, pDude->pos.Y - pTarget->pos.Y);
if (nDist >= kPatrolAlarmSeeDist || !cansee(pTarget->pos.X, pTarget->pos.Y, zt2, pTarget->sector(), pDude->pos.X, pDude->pos.Y, pDude->z - eaz2, pDude->sector()))
if (nDist >= kPatrolAlarmSeeDist || !cansee(pTarget->pos.X, pTarget->pos.Y, zt2, pTarget->sector(), pDude->pos.X, pDude->pos.Y, pDude->pos.Z - eaz2, pDude->sector()))
continue;
}
@ -8113,7 +8113,7 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
return;
int eaz2 = (getDudeInfo(pSprite->type)->eyeHeight * pSprite->yrepeat) << 2;
int x2 = pSprite->pos.X, y2 = pSprite->pos.Y, z2 = pSprite->z - eaz2;
int x2 = pSprite->pos.X, y2 = pSprite->pos.Y, z2 = pSprite->pos.Z - eaz2;
auto pSect2 = pSprite->sector();
@ -8135,7 +8135,7 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
continue;
int eaz1 = (getDudeInfo(pDude->type)->eyeHeight * pDude->yrepeat) << 2;
int x1 = pDude->pos.X, y1 = pDude->pos.Y, z1 = pDude->z - eaz1;
int x1 = pDude->pos.X, y1 = pDude->pos.Y, z1 = pDude->pos.Z - eaz1;
auto pSect1 = pDude->sector();
@ -8152,7 +8152,7 @@ void aiPatrolAlarmFull(DBloodActor* actor, DBloodActor* targetactor, bool chain)
continue;
if (actor->GetTarget() ) aiSetTarget(dudeactor, actor->GetTarget());
else aiSetTarget(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
else aiSetTarget(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
aiActivateDude(dudeactor);
if (chain)
@ -8264,7 +8264,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
newtarget = nullptr;
seeChance = hearChance = 0x0000;
x = pSpr->pos.X, y = pSpr->pos.Y, z = pSpr->z, dx = x - pSprite->pos.X, dy = y - pSprite->pos.Y; nDist = approxDist(dx, dy);
x = pSpr->pos.X, y = pSpr->pos.Y, z = pSpr->pos.Z, dx = x - pSprite->pos.X, dy = y - pSprite->pos.Y; nDist = approxDist(dx, dy);
seeDist = (stealth) ? pDudeInfo->seeDist / 3 : pDudeInfo->seeDist >> 1;
hearDist = pDudeInfo->hearDist; feelDist = hearDist >> 1;
@ -8275,7 +8275,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
{
eyeAboveZ = (pDudeInfo->eyeHeight * pSprite->yrepeat) << 2;
if (nDist < seeDist >> 3) GetActorExtents(pPlayer->actor, &z, &j); //use ztop of the target sprite
if (!cansee(x, y, z, pSpr->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - eyeAboveZ, pSprite->sector()))
if (!cansee(x, y, z, pSpr->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - eyeAboveZ, pSprite->sector()))
continue;
}
else
@ -9109,9 +9109,9 @@ void clampSprite(DBloodActor* actor, int which)
{
GetSpriteExtents(pSprite, &zTop, &zBot);
if (which & 0x01)
pSprite->z += ClipHigh(getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zBot, 0);
pSprite->pos.Z += ClipHigh(getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zBot, 0);
if (which & 0x02)
pSprite->z += ClipLow(getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zTop, 0);
pSprite->pos.Z += ClipLow(getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zTop, 0);
}

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

@ -591,15 +591,15 @@ void playerSetGodMode(PLAYER *pPlayer, bool bGodMode)
void playerResetInertia(PLAYER *pPlayer)
{
POSTURE *pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->pSprite->z-pPosture->eyeAboveZ;
pPlayer->zWeapon = pPlayer->pSprite->z-pPosture->weaponAboveZ;
pPlayer->zView = pPlayer->pSprite->pos.Z-pPosture->eyeAboveZ;
pPlayer->zWeapon = pPlayer->pSprite->pos.Z-pPosture->weaponAboveZ;
viewBackupView(pPlayer->nPlayer);
}
void playerCorrectInertia(PLAYER* pPlayer, vec3_t const *oldpos)
{
pPlayer->zView += pPlayer->pSprite->z-oldpos->Z;
pPlayer->zWeapon += pPlayer->pSprite->z-oldpos->Z;
pPlayer->zView += pPlayer->pSprite->pos.Z-oldpos->Z;
pPlayer->zWeapon += pPlayer->pSprite->pos.Z-oldpos->Z;
viewCorrectViewOffsets(pPlayer->nPlayer, oldpos);
}
@ -674,7 +674,7 @@ void playerStart(int nPlayer, int bNewLevel)
actor->spr.cstat2 |= CSTAT2_SPRITE_MAPPED;
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
pSprite->z -= bottom - pSprite->z;
pSprite->pos.Z -= bottom - pSprite->pos.Z;
pSprite->pal = 11+(pPlayer->teamId&3);
pSprite->ang = pStartZone->ang;
pPlayer->angle.ang = buildang(pSprite->ang);
@ -1091,7 +1091,7 @@ bool PickupItem(PLAYER *pPlayer, DBloodActor* itemactor)
return 1;
}
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, pickupSnd, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pickupSnd, pSprite->sector());
return 1;
}
@ -1204,7 +1204,7 @@ void CheckPickUp(PLAYER *pPlayer)
spritetype *pSprite = pPlayer->pSprite;
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pSector = pSprite->sector();
BloodStatIterator it(kStatItem);
while (auto itemactor = it.Next())
@ -1221,16 +1221,16 @@ void CheckPickUp(PLAYER *pPlayer)
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
int vb = 0;
if (pItem->z < top)
vb = (top-pItem->z)>>8;
else if (pItem->z > bottom)
vb = (pItem->z-bottom)>>8;
if (pItem->pos.Z < top)
vb = (top-pItem->pos.Z)>>8;
else if (pItem->pos.Z > bottom)
vb = (pItem->pos.Z-bottom)>>8;
if (vb > 32)
continue;
if (approxDist(dx,dy) > 48)
continue;
GetSpriteExtents(pItem, &top, &bottom);
if (cansee(x, y, z, pSector, pItem->pos.X, pItem->pos.Y, pItem->z, pItem->sector())
if (cansee(x, y, z, pSector, pItem->pos.X, pItem->pos.Y, pItem->pos.Z, pItem->sector())
|| cansee(x, y, z, pSector, pItem->pos.X, pItem->pos.Y, top, pItem->sector())
|| cansee(x, y, z, pSector, pItem->pos.X, pItem->pos.Y, bottom, pItem->sector()))
PickUp(pPlayer, itemactor);
@ -1668,8 +1668,8 @@ void playerProcess(PLAYER *pPlayer)
powerupProcess(pPlayer);
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
int dzb = (bottom-pSprite->z)/4;
int dzt = (pSprite->z-top)/4;
int dzb = (bottom-pSprite->pos.Z)/4;
int dzt = (pSprite->pos.Z-top)/4;
int dw = pSprite->clipdist<<2;
if (!gNoClip)
{
@ -1690,14 +1690,14 @@ void playerProcess(PLAYER *pPlayer)
ProcessInput(pPlayer);
int nSpeed = approxDist(actor->xvel, actor->yvel);
pPlayer->zViewVel = interpolatedvalue(pPlayer->zViewVel, actor->zvel, 0x7000);
int dz = pPlayer->pSprite->z-pPosture->eyeAboveZ-pPlayer->zView;
int dz = pPlayer->pSprite->pos.Z-pPosture->eyeAboveZ-pPlayer->zView;
if (dz > 0)
pPlayer->zViewVel += MulScale(dz<<8, 0xa000, 16);
else
pPlayer->zViewVel += MulScale(dz<<8, 0x1800, 16);
pPlayer->zView += pPlayer->zViewVel>>8;
pPlayer->zWeaponVel = interpolatedvalue(pPlayer->zWeaponVel, actor->zvel, 0x5000);
dz = pPlayer->pSprite->z-pPosture->weaponAboveZ-pPlayer->zWeapon;
dz = pPlayer->pSprite->pos.Z-pPosture->weaponAboveZ-pPlayer->zWeapon;
if (dz > 0)
pPlayer->zWeaponVel += MulScale(dz<<8, 0x8000, 16);
else
@ -1786,13 +1786,13 @@ void playerProcess(PLAYER *pPlayer)
DBloodActor* playerFireMissile(PLAYER *pPlayer, int a2, int a3, int a4, int a5, int a6)
{
return actFireMissile(pPlayer->actor, a2, pPlayer->zWeapon-pPlayer->pSprite->z, a3, a4, a5, a6);
return actFireMissile(pPlayer->actor, a2, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, a3, a4, a5, a6);
}
DBloodActor* playerFireThing(PLAYER *pPlayer, int a2, int a3, int thingType, int a5)
{
assert(thingType >= kThingBase && thingType < kThingMax);
return actFireThing(pPlayer->actor, a2, pPlayer->zWeapon-pPlayer->pSprite->z, pPlayer->slope+a3, thingType, a5);
return actFireThing(pPlayer->actor, a2, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, pPlayer->slope+a3, thingType, a5);
}
void playerFrag(PLAYER *pKiller, PLAYER *pVictim)
@ -2107,7 +2107,7 @@ void voodooTarget(PLAYER *pPlayer)
{
DBloodActor* actor = pPlayer->actor;
int v4 = pPlayer->aim.dz;
int dz = pPlayer->zWeapon-pPlayer->pSprite->z;
int dz = pPlayer->zWeapon-pPlayer->pSprite->pos.Z;
if (UseAmmo(pPlayer, 9, 0) < 8)
{
pPlayer->voodooTargets = 0;

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

@ -221,10 +221,10 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
GetSpriteExtents(pSprite, &top, &bottom);
int nType = pTarget->type-kDudeBase;
DUDEINFO *pDudeInfo = getDudeInfo(nType+kDudeBase);
int z1 = (top-pSprite->z)-256;
int z1 = (top-pSprite->pos.Z)-256;
int x = pTarget->pos.X;
int y = pTarget->pos.Y;
int z = pTarget->z;
int z = pTarget->pos.Z;
int nDist = approxDist(x - pSprite->pos.X, y - pSprite->pos.Y);
if (nDist != 0 && cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), x, y, z, pTarget->sector()))
{
@ -235,7 +235,7 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
pSprite->ang = getangle(x-pSprite->pos.X, y-pSprite->pos.Y);
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int tz = pTarget->z - (pTarget->yrepeat * pDudeInfo->aimHeight) * 4;
int tz = pTarget->pos.Z - (pTarget->yrepeat * pDudeInfo->aimHeight) * 4;
int dz = DivScale(tz - top - 256, nDist, 10);
int nMissileType = kMissileLifeLeechAltNormal + (pXSprite->data3 ? 1 : 0);
int t2;
@ -477,7 +477,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
spritetype *pPlayerSprite = gPlayer[p].pSprite;
int dx = (pSprite->pos.X - pPlayerSprite->pos.X)>>4;
int dy = (pSprite->pos.Y - pPlayerSprite->pos.Y)>>4;
int dz = (pSprite->z - pPlayerSprite->z)>>8;
int dz = (pSprite->pos.Z - pPlayerSprite->pos.Z)>>8;
int nDist = dx*dx+dy*dy+dz*dz+0x40000;
gPlayer[p].quakeEffect = DivScale(pXSprite->data1, nDist, 16);
}
@ -932,14 +932,14 @@ void ZTranslateSector(sectortype* pSector, XSECTOR *pXSector, int a3, int a4)
if (pSprite->cstat & CSTAT_SPRITE_MOVE_FORWARD)
{
viewBackupSpriteLoc(actor);
pSprite->z += pSector->floorz-oldZ;
pSprite->pos.Z += pSector->floorz-oldZ;
}
else if (pSprite->flags&2)
pSprite->flags |= 4;
else if (oldZ <= bottom && !(pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK))
{
viewBackupSpriteLoc(actor);
pSprite->z += pSector->floorz-oldZ;
pSprite->pos.Z += pSector->floorz-oldZ;
}
}
}
@ -959,7 +959,7 @@ void ZTranslateSector(sectortype* pSector, XSECTOR *pXSector, int a3, int a4)
if (pSprite->cstat & CSTAT_SPRITE_MOVE_REVERSE)
{
viewBackupSpriteLoc(actor);
pSprite->z += pSector->ceilingz-oldZ;
pSprite->pos.Z += pSector->ceilingz-oldZ;
}
}
}
@ -978,9 +978,9 @@ DBloodActor* GetHighestSprite(sectortype* pSector, int nStatus, int *z)
{
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
if (top-pSprite->z > *z)
if (top-pSprite->pos.Z > *z)
{
*z = top-pSprite->z;
*z = top-pSprite->pos.Z;
found = actor;
}
}
@ -1071,7 +1071,7 @@ int VSpriteBusy(sectortype* pSector, unsigned int a2)
if (pSprite->cstat & CSTAT_SPRITE_MOVE_FORWARD)
{
viewBackupSpriteLoc(actor);
pSprite->z = actor->basePoint.Z+MulScale(dz1, GetWaveValue(a2, nWave), 16);
pSprite->pos.Z = actor->basePoint.Z+MulScale(dz1, GetWaveValue(a2, nWave), 16);
}
}
}
@ -1085,7 +1085,7 @@ int VSpriteBusy(sectortype* pSector, unsigned int a2)
if (pSprite->cstat & CSTAT_SPRITE_MOVE_REVERSE)
{
viewBackupSpriteLoc(actor);
pSprite->z = actor->basePoint.Z + MulScale(dz2, GetWaveValue(a2, nWave), 16);
pSprite->pos.Z = actor->basePoint.Z + MulScale(dz2, GetWaveValue(a2, nWave), 16);
}
}
}
@ -1413,7 +1413,7 @@ void OperateTeleport(sectortype* pSector)
}
pSprite->pos.X = pDest->pos.X;
pSprite->pos.Y = pDest->pos.Y;
pSprite->z += pDest->sector()->floorz - pSector->floorz;
pSprite->pos.Z += pDest->sector()->floorz - pSector->floorz;
pSprite->ang = pDest->ang;
ChangeActorSect(actor, pDest->sector());
sfxPlay3DSound(destactor, 201, -1, 0);
@ -1469,8 +1469,8 @@ void OperatePath(sectortype* pSector, EVENT event)
}
pXSector->marker1 = actor;
pXSector->offFloorZ = pSprite2->z;
pXSector->onFloorZ = pSprite->z;
pXSector->offFloorZ = pSprite2->pos.Z;
pXSector->onFloorZ = pSprite->pos.Z;
switch (event.cmd) {
case kCmdOn:
pXSector->state = 0;
@ -1840,7 +1840,7 @@ void ProcessMotion(void)
if (pSprite->cstat & CSTAT_SPRITE_MOVE_MASK)
{
viewBackupSpriteLoc(actor);
pSprite->z += vdi;
pSprite->pos.Z += vdi;
}
}
if (pXSector->bobFloor)
@ -1862,7 +1862,7 @@ void ProcessMotion(void)
if (bottom >= floorZ && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
{
viewBackupSpriteLoc(actor);
pSprite->z += vdi;
pSprite->pos.Z += vdi;
}
}
}
@ -1882,7 +1882,7 @@ void ProcessMotion(void)
if (top <= ceilZ && (pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
{
viewBackupSpriteLoc(actor);
pSprite->z += vdi;
pSprite->pos.Z += vdi;
}
}
}

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

@ -84,7 +84,7 @@ void viewCorrectViewOffsets(int nPlayer, vec3_t const *oldpos)
VIEW *pView = &gPrevView[nPlayer];
pView->x += pPlayer->pSprite->pos.X-oldpos->X;
pView->y += pPlayer->pSprite->pos.Y-oldpos->Y;
pView->viewz += pPlayer->pSprite->z-oldpos->Z;
pView->viewz += pPlayer->pSprite->pos.Z-oldpos->Z;
}
void viewDrawText(FFont* pFont, const char *pString, int x, int y, int nShade, int nPalette, int position, bool shadow)
@ -749,7 +749,7 @@ FString GameInterface::GetCoordString()
FString out;
out.Format("pos= %d, %d, %d - angle = %2.3f",
gMe->pSprite->pos.X, gMe->pSprite->pos.Y, gMe->pSprite->z, gMe->pSprite->ang * BAngToDegree);
gMe->pSprite->pos.X, gMe->pSprite->pos.Y, gMe->pSprite->pos.Z, gMe->pSprite->ang * BAngToDegree);
return out;
}

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

@ -75,7 +75,7 @@ void warpInit(TArray<DBloodActor*>& actors)
ZONE *pZone = &gStartZone[pXSprite->data1];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->z = pSprite->pos.Z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
}
@ -88,7 +88,7 @@ void warpInit(TArray<DBloodActor*>& actors)
ZONE* pZone = &gStartZone[pXSprite->data1];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->z = pSprite->pos.Z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
@ -99,7 +99,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pZone = &gStartZoneTeam1[team1];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->z = pSprite->pos.Z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
team1++;
@ -108,7 +108,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pZone = &gStartZoneTeam2[team2];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->z = pSprite->pos.Z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
team2++;
@ -136,7 +136,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pSprite->sector()->upperLink = actor;
pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
pSprite->z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
pSprite->pos.Z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
break;
case kMarkerLowWater:
case kMarkerLowStack:
@ -144,7 +144,7 @@ void warpInit(TArray<DBloodActor*>& actors)
pSprite->sector()->lowerLink = actor;
pSprite->cstat |= CSTAT_SPRITE_INVISIBLE;
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
pSprite->z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
pSprite->pos.Z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
break;
}
}
@ -199,10 +199,10 @@ int CheckLink(DBloodActor *actor)
spritetype* pUpper = &aUpper->s();
int z;
if (pUpper->type == kMarkerUpLink)
z = pUpper->z;
z = pUpper->pos.Z;
else
z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
if (z <= pSprite->z)
if (z <= pSprite->pos.Z)
{
aLower = aUpper->GetOwner();
assert(aLower);
@ -213,10 +213,10 @@ int CheckLink(DBloodActor *actor)
pSprite->pos.Y += pLower->pos.Y - pUpper->pos.Y;
int z2;
if (pLower->type == kMarkerLowLink)
z2 = pLower->z;
z2 = pLower->pos.Z;
else
z2 = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
pSprite->z += z2-z;
pSprite->pos.Z += z2-z;
actor->interpolated = false;
return pUpper->type;
}
@ -226,10 +226,10 @@ int CheckLink(DBloodActor *actor)
spritetype *pLower = &aLower->s();
int z;
if (pLower->type == kMarkerLowLink)
z = pLower->z;
z = pLower->pos.Z;
else
z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
if (z >= pSprite->z)
if (z >= pSprite->pos.Z)
{
aUpper = aLower->GetOwner();
assert(aUpper);
@ -240,10 +240,10 @@ int CheckLink(DBloodActor *actor)
pSprite->pos.Y += pUpper->pos.Y - pLower->pos.Y;
int z2;
if (pUpper->type == kMarkerUpLink)
z2 = pUpper->z;
z2 = pUpper->pos.Z;
else
z2 = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
pSprite->z += z2-z;
pSprite->pos.Z += z2-z;
actor->interpolated = false;
return pLower->type;
}
@ -260,7 +260,7 @@ int CheckLink(int *x, int *y, int *z, sectortype** pSector)
spritetype *pUpper = &upper->s();
int z1;
if (pUpper->type == kMarkerUpLink)
z1 = pUpper->z;
z1 = pUpper->pos.Z;
else
z1 = getflorzofslopeptr(*pSector, *x, *y);
if (z1 <= *z)
@ -274,7 +274,7 @@ int CheckLink(int *x, int *y, int *z, sectortype** pSector)
*y += pLower->pos.Y - pUpper->pos.Y;
int z2;
if (pUpper->type == kMarkerLowLink)
z2 = pLower->z;
z2 = pLower->pos.Z;
else
z2 = getceilzofslopeptr(*pSector, *x, *y);
*z += z2-z1;
@ -286,7 +286,7 @@ int CheckLink(int *x, int *y, int *z, sectortype** pSector)
spritetype *pLower = &lower->s();
int z1;
if (pLower->type == kMarkerLowLink)
z1 = pLower->z;
z1 = pLower->pos.Z;
else
z1 = getceilzofslopeptr(*pSector, *x, *y);
if (z1 >= *z)
@ -300,7 +300,7 @@ int CheckLink(int *x, int *y, int *z, sectortype** pSector)
*y += pUpper->pos.Y - pLower->pos.Y;
int z2;
if (pLower->type == kMarkerUpLink)
z2 = pUpper->z;
z2 = pUpper->pos.Z;
else
z2 = getflorzofslopeptr(*pSector, *x, *y);
*z += z2-z1;

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

@ -211,7 +211,7 @@ static bool checkAmmo2(const PLAYER *pPlayer, int ammotype, int amount)
void SpawnBulletEject(PLAYER *pPlayer, int a2, int a3)
{
POSTURE *pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->pSprite->z-pPosture->eyeAboveZ;
pPlayer->zView = pPlayer->pSprite->pos.Z-pPosture->eyeAboveZ;
int dz = pPlayer->zWeapon-(pPlayer->zWeapon-pPlayer->zView)/2;
fxSpawnEjectingBrass(pPlayer->actor, dz, a2, a3);
}
@ -219,7 +219,7 @@ void SpawnBulletEject(PLAYER *pPlayer, int a2, int a3)
void SpawnShellEject(PLAYER *pPlayer, int a2, int a3)
{
POSTURE *pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pPlayer->zView = pPlayer->pSprite->z-pPosture->eyeAboveZ;
pPlayer->zView = pPlayer->pSprite->pos.Z-pPosture->eyeAboveZ;
int t = pPlayer->zWeapon - pPlayer->zView;
int dz = pPlayer->zWeapon-t+(t>>2);
fxSpawnEjectingShell(pPlayer->actor, dz, a2, a3);
@ -374,7 +374,7 @@ void UpdateAimVector(PLAYER * pPlayer)
continue;
int x2 = pSprite->pos.X;
int y2 = pSprite->pos.Y;
int z2 = pSprite->z;
int z2 = pSprite->pos.Z;
int nDist = approxDist(x2-x, y2-y);
if (nDist == 0 || nDist > 51200)
continue;
@ -429,7 +429,7 @@ void UpdateAimVector(PLAYER * pPlayer)
continue;
int x2 = pSprite->pos.X;
int y2 = pSprite->pos.Y;
int z2 = pSprite->z;
int z2 = pSprite->pos.Z;
int dx = x2-x;
int dy = y2-y;
int dz = z2-z;
@ -447,7 +447,7 @@ void UpdateAimVector(PLAYER * pPlayer)
int angle = getangle(dx,dy);
if (abs(((angle-pPSprite->ang+1024)&2047)-1024) > pWeaponTrack->thingAngle)
continue;
if (pPlayer->aimTargetsCount < 16 && cansee(x,y,z,pPSprite->sector(),pSprite->pos.X,pSprite->pos.Y,pSprite->z,pSprite->sector()))
if (pPlayer->aimTargetsCount < 16 && cansee(x,y,z,pPSprite->sector(),pSprite->pos.X,pSprite->pos.Y,pSprite->pos.Z,pSprite->sector()))
pPlayer->aimTargets[pPlayer->aimTargetsCount++] = actor;
// Inlined?
int dz2 = (lz-z2)>>8;
@ -456,7 +456,7 @@ void UpdateAimVector(PLAYER * pPlayer)
int nDist2 = ksqrt(dx2*dx2+dy2*dy2+dz2*dz2);
if (nDist2 >= nClosest)
continue;
if (cansee(x, y, z, pPSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector()))
if (cansee(x, y, z, pPSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector()))
{
nClosest = nDist2;
aim.dx = bcos(angle);
@ -1065,7 +1065,7 @@ void FirePitchfork(int, PLAYER *pPlayer)
int r2 = Random2(2000);
int r3 = Random2(2000);
for (int i = 0; i < 4; i++)
actFireVector(actor, (2*i-3)*40, pPlayer->zWeapon-pPlayer->pSprite->z, aim->dx+r1, aim->dy+r2, aim->dz+r3, kVectorTine);
actFireVector(actor, (2*i-3)*40, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, aim->dx+r1, aim->dy+r2, aim->dz+r3, kVectorTine);
}
void FireSpray(int, PLAYER *pPlayer)
@ -1249,7 +1249,7 @@ void FireShotgun(int nTrigger, PLAYER *pPlayer)
r3 = Random3(1500);
nType = kVectorShellAP;
}
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->z, pPlayer->aim.dx+r1, pPlayer->aim.dy+r2, pPlayer->aim.dz+r3, nType);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, pPlayer->aim.dx+r1, pPlayer->aim.dy+r2, pPlayer->aim.dz+r3, nType);
}
UseAmmo(pPlayer, pPlayer->weaponAmmo, nTrigger);
pPlayer->flashEffect = 1;
@ -1273,7 +1273,7 @@ void FireTommy(int nTrigger, PLAYER *pPlayer)
int r1 = Random3(400);
int r2 = Random3(1200);
int r3 = Random3(1200);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->z, aim->dx+r3, aim->dy+r2, aim->dz+r1, kVectorTommyRegular);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, aim->dx+r3, aim->dy+r2, aim->dz+r1, kVectorTommyRegular);
SpawnBulletEject(pPlayer, -15, -45);
pPlayer->visibility = 20;
break;
@ -1283,12 +1283,12 @@ void FireTommy(int nTrigger, PLAYER *pPlayer)
int r1 = Random3(400);
int r2 = Random3(1200);
int r3 = Random3(1200);
actFireVector(actor, -120, pPlayer->zWeapon-pPlayer->pSprite->z, aim->dx+r3, aim->dy+r2, aim->dz+r1, kVectorTommyRegular);
actFireVector(actor, -120, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, aim->dx+r3, aim->dy+r2, aim->dz+r1, kVectorTommyRegular);
SpawnBulletEject(pPlayer, -140, -45);
r1 = Random3(400);
r2 = Random3(1200);
r3 = Random3(1200);
actFireVector(actor, 120, pPlayer->zWeapon-pPlayer->pSprite->z, aim->dx+r3, aim->dy+r2, aim->dz+r1, kVectorTommyRegular);
actFireVector(actor, 120, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, aim->dx+r3, aim->dy+r2, aim->dz+r1, kVectorTommyRegular);
SpawnBulletEject(pPlayer, 140, 45);
pPlayer->visibility = 30;
break;
@ -1313,7 +1313,7 @@ void FireSpread(int nTrigger, PLAYER *pPlayer)
r1 = Random3(300);
r2 = Random3(600);
r3 = Random3(600);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
r1 = Random2(90);
r2 = Random2(30);
SpawnBulletEject(pPlayer, r2, r1);
@ -1335,14 +1335,14 @@ void AltFireSpread(int nTrigger, PLAYER *pPlayer)
r1 = Random3(300);
r2 = Random3(600);
r3 = Random3(600);
actFireVector(actor, -120, pPlayer->zWeapon-pPlayer->pSprite->z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
actFireVector(actor, -120, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
r1 = Random2(45);
r2 = Random2(120);
SpawnBulletEject(pPlayer, r2, r1);
r1 = Random3(300);
r2 = Random3(600);
r3 = Random3(600);
actFireVector(actor, 120, pPlayer->zWeapon-pPlayer->pSprite->z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
actFireVector(actor, 120, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
r1 = Random2(-45);
r2 = Random2(-120);
SpawnBulletEject(pPlayer, r2, r1);
@ -1367,14 +1367,14 @@ void AltFireSpread2(int nTrigger, PLAYER *pPlayer)
r1 = Random3(300);
r2 = Random3(600);
r3 = Random3(600);
actFireVector(actor, -120, pPlayer->zWeapon-pPlayer->pSprite->z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
actFireVector(actor, -120, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
r1 = Random2(45);
r2 = Random2(120);
SpawnBulletEject(pPlayer, r2, r1);
r1 = Random3(300);
r2 = Random3(600);
r3 = Random3(600);
actFireVector(actor, 120, pPlayer->zWeapon-pPlayer->pSprite->z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
actFireVector(actor, 120, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
r1 = Random2(-45);
r2 = Random2(-120);
SpawnBulletEject(pPlayer, r2, r1);
@ -1388,7 +1388,7 @@ void AltFireSpread2(int nTrigger, PLAYER *pPlayer)
r1 = Random3(300);
r2 = Random3(600);
r3 = Random3(600);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, dx+r3, dy+r2, aim->dz+r1, kVectorTommyAP);
r1 = Random2(90);
r2 = Random2(30);
SpawnBulletEject(pPlayer, r2, r1);
@ -1764,7 +1764,7 @@ void FireBeast(int , PLAYER * pPlayer)
int r1 = Random2(2000);
int r2 = Random2(2000);
int r3 = Random2(2000);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->z, pPlayer->aim.dx+r1, pPlayer->aim.dy+r2, pPlayer->aim.dz+r3, kVectorBeastSlash);
actFireVector(actor, 0, pPlayer->zWeapon-pPlayer->pSprite->pos.Z, pPlayer->aim.dx+r1, pPlayer->aim.dy+r2, pPlayer->aim.dz+r3, kVectorBeastSlash);
}
uint8_t gWeaponUpgrade[][13] = {
@ -2663,7 +2663,7 @@ void teslaHit(DBloodActor *missileactor, int a2)
auto pMissile = &missileactor->s();
int x = pMissile->pos.X;
int y = pMissile->pos.Y;
int z = pMissile->z;
int z = pMissile->pos.Z;
int nDist = 300;
auto pSector = pMissile->sector();
auto owneractor = missileactor->GetOwner();

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

@ -213,7 +213,7 @@ static void geometryEffect(int cposx, int cposy, int cposz, binangle cang, fixed
while (auto act = it.Next())
{
ChangeActorSect(act, geosectorwarp[gs]);
SetActor(act, { act->spr.pos.X -= geox[gs], act->spr.pos.Y -= geoy[gs], act->spr.z });
SetActor(act, { act->spr.pos.X -= geox[gs], act->spr.pos.Y -= geoy[gs], act->spr.pos.Z });
}
if (geosector[gs] == sectp)
{
@ -233,7 +233,7 @@ static void geometryEffect(int cposx, int cposy, int cposz, binangle cang, fixed
while (auto act = it.Next())
{
ChangeActorSect(act, geosector[gs]);
SetActor(act, { act->spr.pos.X += geox[gs], act->spr.pos.Y += geoy[gs], act->spr.z });
SetActor(act, { act->spr.pos.X += geox[gs], act->spr.pos.Y += geoy[gs], act->spr.pos.Z });
}
}
fi.animatesprites(pm_tsprite, pm_spritesortcnt, cposx, cposy, cang.asbuild(), smoothratio);
@ -245,7 +245,7 @@ static void geometryEffect(int cposx, int cposy, int cposz, binangle cang, fixed
while (auto act = it.Next())
{
ChangeActorSect(act, geosectorwarp2[gs]);
SetActor(act, { act->spr.pos.X -= geox2[gs], act->spr.pos.Y -= geoy2[gs], act->spr.z });
SetActor(act, { act->spr.pos.X -= geox2[gs], act->spr.pos.Y -= geoy2[gs], act->spr.pos.Z });
}
if (geosector[gs] == sectp)
{
@ -265,7 +265,7 @@ static void geometryEffect(int cposx, int cposy, int cposz, binangle cang, fixed
while (auto act = it.Next())
{
ChangeActorSect(act, geosector[gs]);
SetActor(act, { act->spr.pos.X += geox2[gs], act->spr.pos.Y += geoy2[gs], act->spr.z });
SetActor(act, { act->spr.pos.X += geox2[gs], act->spr.pos.Y += geoy2[gs], act->spr.pos.Z });
}
}
fi.animatesprites(pm_tsprite, pm_spritesortcnt, cposx, cposy, cang.asbuild(), smoothratio);

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

@ -62,7 +62,7 @@ void RANDOMSCRAP(DDukeActor* origin)
int r1 = krand(), r2 = krand(), r3 = krand(), r4 = krand(), r5 = krand(), r6 = krand(), r7 = krand();
int v = isRR() ? 16 : 48;
EGS(origin->spr.sector(),
origin->spr.pos.X + (r7 & 255) - 128, origin->spr.pos.Y + (r6 & 255) - 128, origin->spr.z - (8 << 8) - (r5 & 8191),
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.z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
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);
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.z = act->spr.sector()->ceilingz + (27 << 8);
act->spr.pos.Z = act->spr.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.z = act->spr.sector()->floorz;
if (act->spr.sector()->lotag != 2) act->spr.pos.Z = act->spr.sector()->floorz;
act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
}
}
@ -403,7 +403,7 @@ void moveplayers(void)
{
act->spr.pos.X = p->oposx;
act->spr.pos.Y = p->oposy;
act->spr.z = p->oposz + gs.playerheight;
act->spr.pos.Z = p->oposz + gs.playerheight;
act->spr.backupz();
act->spr.ang = p->angle.oang.asbuild();
SetActor(act, act->spr.pos);
@ -463,7 +463,7 @@ void moveplayers(void)
{
p->pos.X = act->spr.pos.X;
p->pos.Y = act->spr.pos.Y;
p->pos.Z = act->spr.z - (20 << 8);
p->pos.Z = act->spr.pos.Z - (20 << 8);
p->newOwner = nullptr;
@ -499,7 +499,7 @@ void moveplayers(void)
if (act->spr.sector()->lotag != ST_2_UNDERWATER)
makeitfall(act);
if (act->spr.zvel == 0 && act->spr.sector()->lotag == ST_1_ABOVE_WATER)
act->spr.z += (32 << 8);
act->spr.pos.Z += (32 << 8);
}
if (act->spr.extra < 8)
@ -650,7 +650,7 @@ void movecrane(DDukeActor *actor, int crane)
case STAT_STANDABLE:
case STAT_PLAYER:
actor->spr.ang = getangle(cpt.polex - actor->spr.pos.X, cpt.poley - actor->spr.pos.Y);
SetActor(a2, { cpt.polex, cpt.poley, a2->spr.z });
SetActor(a2, { cpt.polex, cpt.poley, a2->spr.pos.Z });
t[0]++;
return;
}
@ -671,19 +671,19 @@ void movecrane(DDukeActor *actor, int crane)
}
else if (t[0] == 2 || t[0] == 7)
{
actor->spr.z += (1024 + 512);
actor->spr.pos.Z += (1024 + 512);
if (t[0] == 2)
{
if ((sectp->floorz - actor->spr.z) < (64 << 8))
if ((sectp->floorz - actor->spr.pos.Z) < (64 << 8))
if (actor->spr.picnum > crane) actor->spr.picnum--;
if ((sectp->floorz - actor->spr.z) < (4096 + 1024))
if ((sectp->floorz - actor->spr.pos.Z) < (4096 + 1024))
t[0]++;
}
if (t[0] == 7)
{
if ((sectp->floorz - actor->spr.z) < (64 << 8))
if ((sectp->floorz - actor->spr.pos.Z) < (64 << 8))
{
if (actor->spr.picnum > crane) actor->spr.picnum--;
else
@ -743,16 +743,16 @@ void movecrane(DDukeActor *actor, int crane)
else if (t[0] == 5 || t[0] == 8)
{
if (t[0] == 8 && actor->spr.picnum < (crane + 2))
if ((sectp->floorz - actor->spr.z) > 8192)
if ((sectp->floorz - actor->spr.pos.Z) > 8192)
actor->spr.picnum++;
if (actor->spr.z < cpt.z)
if (actor->spr.pos.Z < cpt.z)
{
t[0]++;
actor->spr.xvel = 0;
}
else
actor->spr.z -= (1024 + 512);
actor->spr.pos.Z -= (1024 + 512);
}
else if (t[0] == 6)
{
@ -768,7 +768,7 @@ void movecrane(DDukeActor *actor, int crane)
t[0] = 0;
if (cpt.poleactor)
SetActor(cpt.poleactor, { actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (34 << 8) });
SetActor(cpt.poleactor, { actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (34 << 8) });
auto Owner = actor->GetOwner();
if (Owner != nullptr || actor->IsActiveCrane())
@ -802,7 +802,7 @@ void movecrane(DDukeActor *actor, int crane)
ps[p].oposz = ps[p].pos.Z;
ps[p].pos.X = actor->spr.pos.X - bcos(ang, -6);
ps[p].pos.Y = actor->spr.pos.Y - bsin(ang, -6);
ps[p].pos.Z = actor->spr.z + (2 << 8);
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());
}
@ -931,7 +931,7 @@ void detonate(DDukeActor *actor, int explosion)
}
}
actor->spr.z -= (32 << 8);
actor->spr.pos.Z -= (32 << 8);
if ((t[3] == 1 && actor->spr.xrepeat) || actor->spr.lotag == -99)
{
@ -1056,7 +1056,7 @@ void movewaterdrip(DDukeActor *actor, int drip)
}
else
{
actor->spr.z = t[0];
actor->spr.pos.Z = t[0];
actor->spr.backupz();
t[1] = 48 + (krand() & 31);
}
@ -1076,7 +1076,7 @@ void movedoorshock(DDukeActor* actor)
int j = abs(sectp->ceilingz - sectp->floorz) >> 9;
actor->spr.yrepeat = j + 4;
actor->spr.xrepeat = 16;
actor->spr.z = sectp->floorz;
actor->spr.pos.Z = sectp->floorz;
}
//---------------------------------------------------------------------------
@ -1112,9 +1112,9 @@ void movetouchplate(DDukeActor* actor, int plate)
}
else
{
if (x <= actor->spr.z)
if (x <= actor->spr.pos.Z)
{
sectp->floorz = actor->spr.z;
sectp->floorz = actor->spr.pos.Z;
t[1] = 0;
}
else
@ -1279,7 +1279,7 @@ void bounce(DDukeActor* actor)
int daang = getangle(sectp->firstWall()->delta());
int k, l;
if (actor->spr.z < (actor->floorz + actor->ceilingz) >> 1)
if (actor->spr.pos.Z < (actor->floorz + actor->ceilingz) >> 1)
k = sectp->ceilingheinum;
else
k = sectp->floorheinum;
@ -1333,13 +1333,13 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
actor->spr.pos.X = Owner->spr.pos.X;
actor->spr.pos.Y = Owner->spr.pos.Y;
if (Owner->spr.picnum == TILE_APLAYER)
actor->spr.z = Owner->spr.z - (34 << 8);
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(),
actor->spr.pos.X + MulScale(k, bcos(actor->spr.ang), 9),
actor->spr.pos.Y + MulScale(k, bsin(actor->spr.ang), 9),
actor->spr.z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), tongue, -40 + (k << 1),
actor->spr.pos.Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), tongue, -40 + (k << 1),
8, 8, 0, 0, 0, actor, 5);
if (q)
{
@ -1351,7 +1351,7 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
auto spawned = EGS(actor->spr.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.z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), jaw, -40,
actor->spr.pos.Z + ((k * Sgn(actor->spr.zvel)) * abs(actor->spr.zvel / 12)), jaw, -40,
32, 32, 0, 0, 0, actor, 5);
if (spawned)
{
@ -1385,7 +1385,7 @@ void rpgexplode(DDukeActor *actor, int hit, const vec3_t &pos, int EXPLOSION2, i
else
{
explosion->spr.cstat |= CSTAT_SPRITE_YFLIP;
explosion->spr.z += (48 << 8);
explosion->spr.pos.Z += (48 << 8);
}
}
if (newextra > 0) actor->spr.extra = newextra;
@ -1583,9 +1583,9 @@ void forcesphere(DDukeActor* actor, int forcesphere)
{
if (actor->spr.zvel < 6144)
actor->spr.zvel += 192;
actor->spr.z += actor->spr.zvel;
if (actor->spr.z > sectp->floorz)
actor->spr.z = sectp->floorz;
actor->spr.pos.Z += actor->spr.zvel;
if (actor->spr.pos.Z > sectp->floorz)
actor->spr.pos.Z = sectp->floorz;
t[3]--;
if (t[3] == 0)
{
@ -1623,8 +1623,8 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
actor->spr.shade += (sectp->ceilingshade - actor->spr.shade) >> 1;
else actor->spr.shade += (sectp->floorshade - actor->spr.shade) >> 1;
if (actor->spr.z < sectp->ceilingz + (32 << 8))
actor->spr.z = sectp->ceilingz + (32 << 8);
if (actor->spr.pos.Z < sectp->ceilingz + (32 << 8))
actor->spr.pos.Z = sectp->ceilingz + (32 << 8);
if (ud.multimode < 2)
{
@ -1648,14 +1648,14 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
if (t[0] == -1)
{
actor->spr.z += 1024;
actor->spr.pos.Z += 1024;
t[2]++;
if ((t[2] & 3) == 0) spawn(actor, explosion);
getglobalz(actor);
actor->spr.ang += 96;
actor->spr.xvel = 128;
int j = ssp(actor, CLIPMASK0);
if (j != 1 || actor->spr.z > actor->floorz)
if (j != 1 || actor->spr.pos.Z > actor->floorz)
{
for (int l = 0; l < 16; l++)
RANDOMSCRAP(actor);
@ -1669,8 +1669,8 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
}
else
{
if (actor->spr.z > actor->floorz - (48 << 8))
actor->spr.z = actor->floorz - (48 << 8);
if (actor->spr.pos.Z > actor->floorz - (48 << 8))
actor->spr.pos.Z = actor->floorz - (48 << 8);
}
int x;
@ -1690,7 +1690,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
fi.shoot(actor, firelaser);
actor->spr.ang = a;
}
if (t[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (16 << 8), actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (t[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))
{
t[0] = 0;
t[2] = 0;
@ -1706,14 +1706,14 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
if (t[0] == 2)
{
int l = ps[p].pos.Z - actor->spr.z;
int l = ps[p].pos.Z - actor->spr.pos.Z;
if (abs(l) < (48 << 8)) t[0] = 3;
else actor->spr.z += Sgn(ps[p].pos.Z - actor->spr.z) << shift; // The shift here differs between Duke and RR.
else actor->spr.pos.Z += Sgn(ps[p].pos.Z - actor->spr.pos.Z) << shift; // The shift here differs between Duke and RR.
}
else
{
t[2]++;
if (t[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (16 << 8), actor->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (t[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))
{
t[0] = 1;
t[2] = 0;
@ -1786,9 +1786,9 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
t[3] = getincangle(actor->spr.ang, a);
actor->spr.ang += t[3] >> 3;
if (actor->spr.z < Owner->spr.z)
actor->spr.z += 1024;
else actor->spr.z -= 1024;
if (actor->spr.pos.Z < Owner->spr.pos.Z)
actor->spr.pos.Z += 1024;
else actor->spr.pos.Z -= 1024;
}
if (roamsnd >= 0 && S_CheckActorSoundPlaying(actor, roamsnd) < 1)
@ -1816,7 +1816,7 @@ void ooz(DDukeActor *actor)
actor->spr.yrepeat = j;
actor->spr.xrepeat = x;
actor->spr.z = actor->floorz;
actor->spr.pos.Z = actor->floorz;
}
//---------------------------------------------------------------------------
@ -1893,8 +1893,8 @@ void reactor(DDukeActor* const actor, int REACTOR, int REACTOR2, int REACTORBURN
{
t[1]++;
t[4] = actor->spr.z;
actor->spr.z = sectp->floorz - (krand() % (sectp->floorz - sectp->ceilingz));
t[4] = actor->spr.pos.Z;
actor->spr.pos.Z = sectp->floorz - (krand() % (sectp->floorz - sectp->ceilingz));
switch (t[1])
{
@ -1936,7 +1936,7 @@ void reactor(DDukeActor* const actor, int REACTOR, int REACTOR2, int REACTORBURN
for (x = 0; x < 16; x++)
RANDOMSCRAP(actor);
actor->spr.z = t[4];
actor->spr.pos.Z = t[4];
t[4] = 0;
}
@ -2054,7 +2054,7 @@ void forcesphereexplode(DDukeActor *actor)
actor->spr.pos.X = Owner->spr.pos.X;
actor->spr.pos.Y = Owner->spr.pos.Y;
actor->spr.z = Owner->spr.z;
actor->spr.pos.Z = Owner->spr.pos.Z;
actor->spr.ang += Owner->temp_data[0];
if (l > 64) l = 64;
@ -2160,9 +2160,9 @@ bool money(DDukeActor* actor, int BLOODPOOL)
}
int l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.z > l)
if (actor->spr.pos.Z > l)
{
actor->spr.z = l;
actor->spr.pos.Z = l;
insertspriteq(actor);
actor->spr.picnum++;
@ -2229,7 +2229,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
return false;
}
if (actor->spr.z < l - (2 << 8))
if (actor->spr.pos.Z < l - (2 << 8))
{
if (t[1] < 2) t[1]++;
else if (sectp->lotag != 2)
@ -2261,9 +2261,9 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
actor->spr.pos.X += MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14);
actor->spr.pos.Y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.z += actor->spr.zvel;
actor->spr.pos.Z += actor->spr.zvel;
if (floorcheck && actor->spr.z >= actor->spr.sector()->floorz)
if (floorcheck && actor->spr.pos.Z >= actor->spr.sector()->floorz)
{
deletesprite(actor);
return false;
@ -2292,7 +2292,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
}
l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->spr.z = l - (2 << 8);
actor->spr.pos.Z = l - (2 << 8);
actor->spr.xvel = 0;
if (actor->spr.picnum == JIBS6)
@ -2338,7 +2338,7 @@ bool bloodpool(DDukeActor* actor, bool puke, int TIRE)
int x;
int p = findplayer(actor, &x);
actor->spr.z = actor->floorz - (FOURSLEIGHT);
actor->spr.pos.Z = actor->floorz - (FOURSLEIGHT);
if (t[2] < 32)
{
@ -2469,7 +2469,7 @@ void glasspieces(DDukeActor* actor)
return;
}
if (actor->spr.z == actor->floorz - (FOURSLEIGHT) && t[0] < 3)
if (actor->spr.pos.Z == actor->floorz - (FOURSLEIGHT) && t[0] < 3)
{
actor->spr.zvel = -((3 - t[0]) << 8) - (krand() & 511);
if (sectp->lotag == 2)
@ -2518,7 +2518,7 @@ void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
sectp = actor->spr.sector();
}
if (actor->spr.z < sectp->floorz - (2 << 8))
if (actor->spr.pos.Z < sectp->floorz - (2 << 8))
{
if (t[1] < 1) t[1]++;
else
@ -2541,7 +2541,7 @@ void scrap(DDukeActor* actor, int SCRAP1, int SCRAP6)
if (actor->spr.zvel < 4096) actor->spr.zvel += gs.gravity - 50;
actor->spr.pos.X += MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14);
actor->spr.pos.Y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.z += actor->spr.zvel;
actor->spr.pos.Z += actor->spr.zvel;
}
else
{
@ -2573,7 +2573,7 @@ void gutsdir(DDukeActor* actor, int gtype, int n, int p)
sx = sy = 8;
else sx = sy = 32;
int gutz = actor->spr.z - (8 << 8);
int gutz = actor->spr.pos.Z - (8 << 8);
int floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
@ -2631,20 +2631,20 @@ void handle_se00(DDukeActor* actor, int LASERLINE)
}
else actor->tempang = 256;
if (sect->floorz > actor->spr.z) //z's are touching
if (sect->floorz > actor->spr.pos.Z) //z's are touching
{
sect->floorz -= 512;
zchange = -512;
if (sect->floorz < actor->spr.z)
sect->floorz = actor->spr.z;
if (sect->floorz < actor->spr.pos.Z)
sect->floorz = actor->spr.pos.Z;
}
else if (sect->floorz < actor->spr.z) //z's are touching
else if (sect->floorz < actor->spr.pos.Z) //z's are touching
{
sect->floorz += 512;
zchange = 512;
if (sect->floorz > actor->spr.z)
sect->floorz = actor->spr.z;
if (sect->floorz > actor->spr.pos.Z)
sect->floorz = actor->spr.pos.Z;
}
}
else if (actor->spr.extra == 3)
@ -2740,7 +2740,7 @@ void handle_se00(DDukeActor* actor, int LASERLINE)
act2->spr.ang += (l * q);
act2->spr.ang &= 2047;
act2->spr.z += zchange;
act2->spr.pos.Z += zchange;
rotatepoint(Owner->spr.pos.vec2, act2->spr.pos.vec2, (q* l), &act2->spr.pos.vec2);
}
}
@ -3382,7 +3382,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
actor->SetOwner(Owner);
if (!Owner) return; // Undefined case - was not checked.
actor->spr.zvel = Sgn(Owner->spr.z - actor->spr.z) << 4;
actor->spr.zvel = Sgn(Owner->spr.pos.Z - actor->spr.pos.Z) << 4;
}
if (ldist(Owner, actor) < 1024)
@ -3422,7 +3422,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
}
}
actor->spr.z += actor->spr.zvel;
actor->spr.pos.Z += actor->spr.zvel;
sc->ceilingz += actor->spr.zvel;
actor->temp_sect->ceilingz += actor->spr.zvel;
ms(actor);
@ -3883,7 +3883,7 @@ void handle_se17(DDukeActor* actor)
if (act1->spr.statnum != STAT_EFFECTOR)
{
act1->spr.backupz();
act1->spr.z += q;
act1->spr.pos.Z += q;
}
act1->floorz = sc->floorz;
@ -3948,7 +3948,7 @@ void handle_se17(DDukeActor* actor)
{
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.z = act2->spr.sector()->floorz - (sc->floorz - act3->spr.z);
act3->spr.pos.Z = act2->spr.sector()->floorz - (sc->floorz - act3->spr.pos.Z);
act3->spr.backupz();
@ -4000,7 +4000,7 @@ void handle_se18(DDukeActor *actor, bool morecheck)
if (ps[a2->PlayerIndex()].on_ground == 1) ps[a2->PlayerIndex()].pos.Z += sc->extra;
if (a2->spr.zvel == 0 && a2->spr.statnum != STAT_EFFECTOR && a2->spr.statnum != STAT_PROJECTILE)
{
a2->spr.z += sc->extra;
a2->spr.pos.Z += sc->extra;
a2->floorz = sc->floorz;
}
}
@ -4018,9 +4018,9 @@ void handle_se18(DDukeActor *actor, bool morecheck)
if (actor->spr.ang == 512)
{
sc->ceilingz += sc->extra;
if (sc->ceilingz >= actor->spr.z)
if (sc->ceilingz >= actor->spr.pos.Z)
{
sc->ceilingz = actor->spr.z;
sc->ceilingz = actor->spr.pos.Z;
deletesprite(actor);
return;
}
@ -4037,14 +4037,14 @@ void handle_se18(DDukeActor *actor, bool morecheck)
if (ps[a2->PlayerIndex()].on_ground == 1) ps[a2->PlayerIndex()].pos.Z -= sc->extra;
if (a2->spr.zvel == 0 && a2->spr.statnum != STAT_EFFECTOR && a2->spr.statnum != STAT_PROJECTILE)
{
a2->spr.z -= sc->extra;
a2->spr.pos.Z -= sc->extra;
a2->floorz = sc->floorz;
}
}
}
if (sc->floorz <= actor->spr.z)
if (sc->floorz <= actor->spr.pos.Z)
{
sc->floorz = actor->spr.z;
sc->floorz = actor->spr.pos.Z;
deletesprite(actor);
return;
}
@ -4249,7 +4249,7 @@ void handle_se21(DDukeActor* actor)
if (t[0] == 1) //Decide if the sector should go up or down
{
actor->spr.zvel = Sgn(actor->spr.z - *lp) * (actor->spr.yvel << 4);
actor->spr.zvel = Sgn(actor->spr.pos.Z - *lp) * (actor->spr.yvel << 4);
t[0]++;
}
@ -4257,9 +4257,9 @@ void handle_se21(DDukeActor* actor)
{
*lp += actor->spr.zvel;
if (abs(*lp - actor->spr.z) < 1024)
if (abs(*lp - actor->spr.pos.Z) < 1024)
{
*lp = actor->spr.z;
*lp = actor->spr.pos.Z;
deletesprite(actor);
}
}
@ -4318,7 +4318,7 @@ void handle_se26(DDukeActor* actor)
{
a2->spr.pos.X += l;
a2->spr.pos.Y += x;
a2->spr.z += actor->spr.zvel;
a2->spr.pos.Z += actor->spr.zvel;
SetActor(a2, a2->spr.pos);
}
}
@ -4361,14 +4361,14 @@ void handle_se27(DDukeActor* actor)
}
else if (ud.recstat == 2 && ps[p].newOwner == nullptr)
{
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
{
if (x < sh)
{
ud.cameraactor = actor;
t[0] = 999;
actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 3;
actor->spr.yvel = 100 + ((actor->spr.z - ps[p].pos.Z) / 257);
actor->spr.yvel = 100 + ((actor->spr.pos.Z - ps[p].pos.Z) / 257);
}
else if (t[0] == 999)
@ -4443,7 +4443,7 @@ void handle_se24(DDukeActor *actor, const int16_t *list1, const int16_t *list2,
if (!(a2->spr.picnum >= CRANE && a2->spr.picnum <= (CRANE + 3)))
{
if (a2->spr.z > (a2->floorz - (16 << 8)))
if (a2->spr.pos.Z > (a2->floorz - (16 << 8)))
{
a2->spr.pos.X += x >> shift;
a2->spr.pos.Y += l >> shift;
@ -4531,14 +4531,14 @@ void handle_se32(DDukeActor *actor)
{
if (actor->spr.ang != 1536)
{
if (abs(sc->ceilingz - actor->spr.z) < (actor->spr.yvel << 1))
if (abs(sc->ceilingz - actor->spr.pos.Z) < (actor->spr.yvel << 1))
{
sc->ceilingz = actor->spr.z;
sc->ceilingz = actor->spr.pos.Z;
callsound(actor->spr.sector(), actor);
t[2] = 0;
t[0] = 0;
}
else sc->ceilingz += Sgn(actor->spr.z - sc->ceilingz) * actor->spr.yvel;
else sc->ceilingz += Sgn(actor->spr.pos.Z - sc->ceilingz) * actor->spr.yvel;
}
else
{
@ -4556,14 +4556,14 @@ void handle_se32(DDukeActor *actor)
if ((actor->spr.ang & 2047) == 1536)
{
if (abs(sc->ceilingz - actor->spr.z) < (actor->spr.yvel << 1))
if (abs(sc->ceilingz - actor->spr.pos.Z) < (actor->spr.yvel << 1))
{
t[0] = 0;
t[2] = !t[2];
callsound(actor->spr.sector(), actor);
sc->ceilingz = actor->spr.z;
sc->ceilingz = actor->spr.pos.Z;
}
else sc->ceilingz += Sgn(actor->spr.z - sc->ceilingz) * actor->spr.yvel;
else sc->ceilingz += Sgn(actor->spr.pos.Z - sc->ceilingz) * actor->spr.yvel;
}
else
{
@ -4573,7 +4573,7 @@ void handle_se32(DDukeActor *actor)
t[2] = !t[2];
callsound(actor->spr.sector(), actor);
}
else sc->ceilingz -= Sgn(actor->spr.z - t[1]) * actor->spr.yvel;
else sc->ceilingz -= Sgn(actor->spr.pos.Z - t[1]) * actor->spr.yvel;
}
}
@ -4590,7 +4590,7 @@ void handle_se35(DDukeActor *actor, int SMALLSMOKE, int EXPLOSION2)
int* t = &actor->temp_data[0];
auto sc = actor->sector();
if (sc->ceilingz > actor->spr.z)
if (sc->ceilingz > actor->spr.pos.Z)
for (int j = 0; j < 8; j++)
{
actor->spr.ang += krand() & 511;
@ -4611,7 +4611,7 @@ void handle_se35(DDukeActor *actor, int SMALLSMOKE, int EXPLOSION2)
sc->ceilingz += actor->spr.yvel;
if (sc->ceilingz > sc->floorz)
sc->floorz = sc->ceilingz;
if (sc->ceilingz > actor->spr.z + (32 << 8))
if (sc->ceilingz > actor->spr.pos.Z + (32 << 8))
t[0]++;
break;
case 1:
@ -4691,7 +4691,7 @@ void handle_se130(DDukeActor *actor, int countmax, int EXPLOSION2)
if (k)
{
k->spr.xrepeat = k->spr.yrepeat = 2 + (krand() & 7);
k->spr.z = sc->floorz - (krand() % x);
k->spr.pos.Z = sc->floorz - (krand() % x);
k->spr.ang += 256 - (krand() % 511);
k->spr.xvel = krand() & 127;
ssp(k, CLIPMASK0);
@ -4724,9 +4724,9 @@ void handle_se31(DDukeActor* actor, bool choosedir)
{
if (actor->spr.ang != 1536)
{
if (abs(sec->floorz - actor->spr.z) < actor->spr.yvel)
if (abs(sec->floorz - actor->spr.pos.Z) < actor->spr.yvel)
{
sec->floorz = actor->spr.z;
sec->floorz = actor->spr.pos.Z;
t[2] = 0;
t[0] = 0;
if (choosedir) t[3] = actor->spr.hitag;
@ -4734,7 +4734,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
}
else
{
int l = Sgn(actor->spr.z - sec->floorz) * actor->spr.yvel;
int l = Sgn(actor->spr.pos.Z - sec->floorz) * actor->spr.yvel;
sec->floorz += l;
DukeSectIterator it(actor->sector());
@ -4745,7 +4745,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
ps[a2->PlayerIndex()].pos.Z += l;
if (a2->spr.zvel == 0 && a2->spr.statnum != STAT_EFFECTOR && (!choosedir || a2->spr.statnum != STAT_PROJECTILE))
{
a2->spr.z += l;
a2->spr.pos.Z += l;
a2->floorz = sec->floorz;
}
}
@ -4774,7 +4774,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
ps[a2->PlayerIndex()].pos.Z += l;
if (a2->spr.zvel == 0 && a2->spr.statnum != STAT_EFFECTOR && (!choosedir || a2->spr.statnum != STAT_PROJECTILE))
{
a2->spr.z += l;
a2->spr.pos.Z += l;
a2->floorz = sec->floorz;
}
}
@ -4785,7 +4785,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
if ((actor->spr.ang & 2047) == 1536)
{
if (abs(actor->spr.z - sec->floorz) < actor->spr.yvel)
if (abs(actor->spr.pos.Z - sec->floorz) < actor->spr.yvel)
{
callsound(actor->spr.sector(), actor);
t[0] = 0;
@ -4794,7 +4794,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
}
else
{
int l = Sgn(actor->spr.z - sec->floorz) * actor->spr.yvel;
int l = Sgn(actor->spr.pos.Z - sec->floorz) * actor->spr.yvel;
sec->floorz += l;
DukeSectIterator it(actor->sector());
@ -4805,7 +4805,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
ps[a2->PlayerIndex()].pos.Z += l;
if (a2->spr.zvel == 0 && a2->spr.statnum != STAT_EFFECTOR && (!choosedir || a2->spr.statnum != STAT_PROJECTILE))
{
a2->spr.z += l;
a2->spr.pos.Z += l;
a2->floorz = sec->floorz;
}
}
@ -4822,7 +4822,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
}
else
{
int l = Sgn(actor->spr.z - t[1]) * actor->spr.yvel;
int l = Sgn(actor->spr.pos.Z - t[1]) * actor->spr.yvel;
sec->floorz -= l;
DukeSectIterator it(actor->sector());
@ -4833,7 +4833,7 @@ void handle_se31(DDukeActor* actor, bool choosedir)
ps[a2->PlayerIndex()].pos.Z -= l;
if (a2->spr.zvel == 0 && a2->spr.statnum != STAT_EFFECTOR && (!choosedir || a2->spr.statnum != STAT_PROJECTILE))
{
a2->spr.z -= l;
a2->spr.pos.Z -= l;
a2->floorz = sec->floorz;
}
}
@ -4861,7 +4861,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.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->spr.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 )
@ -4924,7 +4924,7 @@ void makeitfall(DDukeActor* actor)
if ((actor->spr.statnum == STAT_ACTOR || actor->spr.statnum == STAT_PLAYER || actor->spr.statnum == STAT_ZOMBIEACTOR || actor->spr.statnum == STAT_STANDABLE))
{
Collision c;
getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (FOURSLEIGHT) }, actor->spr.sector(), &actor->ceilingz, c, &actor->floorz, c, 127, CLIPMASK0);
getzrange({ actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (FOURSLEIGHT) }, actor->spr.sector(), &actor->ceilingz, c, &actor->floorz, c, 127, CLIPMASK0);
}
else
{
@ -4932,18 +4932,18 @@ void makeitfall(DDukeActor* actor)
actor->floorz = actor->spr.sector()->floorz;
}
if( actor->spr.z < actor->floorz-(FOURSLEIGHT) )
if( actor->spr.pos.Z < actor->floorz-(FOURSLEIGHT) )
{
if( actor->spr.sector()->lotag == 2 && actor->spr.zvel > 3122 )
actor->spr.zvel = 3144;
if(actor->spr.zvel < 6144)
actor->spr.zvel += c;
else actor->spr.zvel = 6144;
actor->spr.z += actor->spr.zvel;
actor->spr.pos.Z += actor->spr.zvel;
}
if( actor->spr.z >= actor->floorz-(FOURSLEIGHT) )
if( actor->spr.pos.Z >= actor->floorz-(FOURSLEIGHT) )
{
actor->spr.z = actor->floorz - FOURSLEIGHT;
actor->spr.pos.Z = actor->floorz - FOURSLEIGHT;
actor->spr.zvel = 0;
}
}
@ -5006,7 +5006,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.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->spr.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);
@ -5039,13 +5039,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.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->spr.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.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->spr.sector()))
{
*dax = hit.hitpos.X;
*day = hit.hitpos.Y;
@ -5084,7 +5084,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.z, holoduke->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.sector()))
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()))
actor->SetOwner(holoduke);
else actor->SetOwner(ps[playernum].GetActor());
@ -5166,16 +5166,16 @@ void fall_common(DDukeActor *actor, int playernum, int JIBS6, int DRONE, int BLO
}
else actor->cgg--;
if (actor->spr.z < (actor->floorz - FOURSLEIGHT))
if (actor->spr.pos.Z < (actor->floorz - FOURSLEIGHT))
{
actor->spr.zvel += c;
actor->spr.z += actor->spr.zvel;
actor->spr.pos.Z += actor->spr.zvel;
if (actor->spr.zvel > 6144) actor->spr.zvel = 6144;
}
else
{
actor->spr.z = actor->floorz - FOURSLEIGHT;
actor->spr.pos.Z = actor->floorz - FOURSLEIGHT;
if (badguy(actor) || (actor->spr.picnum == TILE_APLAYER && actor->GetOwner()))
{
@ -5217,7 +5217,7 @@ void fall_common(DDukeActor *actor, int playernum, int JIBS6, int DRONE, int BLO
}
}
if (actor->spr.sector()->lotag == 1)
actor->spr.z += gs.actorinfo[actor->spr.picnum].falladjustz;
actor->spr.pos.Z += gs.actorinfo[actor->spr.picnum].falladjustz;
else actor->spr.zvel = 0;
}
}

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

@ -267,7 +267,7 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
while (auto dasectp = search.GetNext())
{
if (((dasectp->ceilingz - actor->spr.z) >> 8) < r)
if (((dasectp->ceilingz - actor->spr.pos.Z) >> 8) < r)
{
auto wal = dasectp->firstWall();
int d = abs(wal->pos.X - actor->spr.pos.X) + abs(wal->pos.Y - actor->spr.pos.Y);
@ -294,8 +294,8 @@ 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.z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.sector()))
fi.checkhitwall(actor, &wal, wal.pos.X, wal.pos.Y, actor->spr.z, actor->spr.picnum);
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()))
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.z + q, act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z + q, actor->spr.sector()))
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()))
continue;
fi.checkhitsprite(act2, actor);
}
@ -343,11 +343,11 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
continue;
}
if (act2->spr.picnum == APLAYER) act2->spr.z -= gs.playerheight;
if (act2->spr.picnum == APLAYER) act2->spr.pos.Z -= gs.playerheight;
int d = dist(actor, act2);
if (act2->spr.picnum == APLAYER) act2->spr.z += gs.playerheight;
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.z - (8 << 8), act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->spr.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
{
actor->spr.pos.X += (xchange * TICSPERFRAME) >> 2;
actor->spr.pos.Y += (ychange * TICSPERFRAME) >> 2;
actor->spr.z += (zchange * TICSPERFRAME) >> 2;
actor->spr.pos.Z += (zchange * TICSPERFRAME) >> 2;
if (bg)
SetActor(actor, actor->spr.pos);
return result.setNone();
@ -508,9 +508,9 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
if (dasectp != nullptr)
if (dasectp != actor->spr.sector())
ChangeActorSect(actor, dasectp);
int daz = actor->spr.z + ((zchange * TICSPERFRAME) >> 3);
int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
actor->spr.z = daz;
actor->spr.pos.Z = daz;
else if (result.type == kHitNone)
return result.setSector(dasectp);
@ -554,7 +554,7 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
sx = sy = 8;
else sx = sy = 32;
gutz = actor->spr.z - (8 << 8);
gutz = actor->spr.pos.Z - (8 << 8);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
@ -641,13 +641,13 @@ void movefta_d(void)
int r1 = krand();
int r2 = krand();
j = cansee(sx, sy, act->spr.z - (r2 % (52 << 8)), act->spr.sector(), px, py, ps[p].oposz - (r1 % (32 << 8)), ps[p].cursector);
j = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->spr.sector(), px, py, ps[p].oposz - (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.z - ((r2 & 31) << 8), act->spr.sector(), ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursector);
j = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->spr.sector(), ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursector);
}
@ -843,7 +843,7 @@ void movefallers_d(void)
if (act->temp_data[0] == 0)
{
act->spr.z -= (16 << 8);
act->spr.pos.Z -= (16 << 8);
act->temp_data[1] = act->spr.ang;
x = act->spr.extra;
j = fi.ifhitbyweapon(act);
@ -874,7 +874,7 @@ void movefallers_d(void)
}
}
act->spr.ang = act->temp_data[1];
act->spr.z += (16 << 8);
act->spr.pos.Z += (16 << 8);
}
else if (act->temp_data[0] == 1)
{
@ -904,14 +904,14 @@ void movefallers_d(void)
x = gs.gravity;
}
if (act->spr.z < (sectp->floorz - FOURSLEIGHT))
if (act->spr.pos.Z < (sectp->floorz - FOURSLEIGHT))
{
act->spr.zvel += x;
if (act->spr.zvel > 6144)
act->spr.zvel = 6144;
act->spr.z += act->spr.zvel;
act->spr.pos.Z += act->spr.zvel;
}
if ((sectp->floorz - act->spr.z) < (16 << 8))
if ((sectp->floorz - act->spr.pos.Z) < (16 << 8))
{
j = 1 + (krand() & 7);
for (x = 0; x < j; x++) RANDOMSCRAP(act);
@ -1008,7 +1008,7 @@ static void movetripbomb(DDukeActor *actor)
actor->temp_data[3] = actor->spr.pos.X; actor->temp_data[4] = actor->spr.pos.Y;
actor->spr.pos.X += bcos(actor->temp_data[5], -9);
actor->spr.pos.Y += bsin(actor->temp_data[5], -9);
actor->spr.z -= (3 << 8);
actor->spr.pos.Z -= (3 << 8);
// Laser fix from EDuke32.
auto const oldSect = actor->spr.sector();
@ -1034,7 +1034,7 @@ static void movetripbomb(DDukeActor *actor)
{
SetActor(spawned, spawned->spr.pos);
spawned->spr.hitag = actor->spr.hitag;
spawned->temp_data[1] = spawned->spr.z;
spawned->temp_data[1] = spawned->spr.pos.Z;
if (x < 1024)
{
@ -1060,7 +1060,7 @@ static void movetripbomb(DDukeActor *actor)
actor->temp_data[0]++;
actor->spr.pos.X = actor->temp_data[3]; actor->spr.pos.Y = actor->temp_data[4];
actor->spr.z += (3 << 8);
actor->spr.pos.Z += (3 << 8);
ChangeActorSect(actor, oldSect);
actor->temp_data[3] = 0;
if (hit && lTripBombControl & TRIPBOMB_TRIPWIRE)
@ -1078,13 +1078,13 @@ static void movetripbomb(DDukeActor *actor)
actor->temp_data[3] = actor->spr.pos.X; actor->temp_data[4] = actor->spr.pos.Y;
actor->spr.pos.X += bcos(actor->temp_data[5], -9);
actor->spr.pos.Y += bsin(actor->temp_data[5], -9);
actor->spr.z -= (3 << 8);
actor->spr.pos.Z -= (3 << 8);
SetActor(actor, actor->spr.pos);
x = hitasprite(actor, nullptr);
actor->spr.pos.X = actor->temp_data[3]; actor->spr.pos.Y = actor->temp_data[4];
actor->spr.z += (3 << 8);
actor->spr.pos.Z += (3 << 8);
SetActor(actor, actor->spr.pos);
if (actor->lastvx != x && lTripBombControl & TRIPBOMB_TRIPWIRE)
@ -1142,7 +1142,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.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->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);
if(spawned) spawned->spr.pal = 2;
}
@ -1463,7 +1463,7 @@ static bool movefireball(DDukeActor* actor)
FireProj* proj = &trail->fproj;
ball->spr.pos.X = proj->x;
ball->spr.pos.Y = proj->y;
ball->spr.z = proj->z;
ball->spr.pos.Z = proj->z;
ball->spr.xvel = proj->xv;
ball->spr.yvel = proj->yv;
ball->spr.zvel = proj->zv;
@ -1473,7 +1473,7 @@ static bool movefireball(DDukeActor* actor)
ball->spr.cstat = actor->spr.cstat;
ball->spr.extra = 0;
ball->fproj = { ball->spr.pos.X, ball->spr.pos.Y, ball->spr.z, ball->spr.xvel, ball->spr.yvel, ball->spr.zvel };
ball->fproj = { ball->spr.pos.X, ball->spr.pos.Y, ball->spr.pos.Z, ball->spr.xvel, ball->spr.yvel, ball->spr.zvel };
ChangeActorStat(ball, STAT_PROJECTILE);
}
@ -1568,7 +1568,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t &oldpos)
else
{
SetActor(proj, oldpos);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.z, proj->spr.picnum);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.pos.Z, proj->spr.picnum);
if (proj->spr.picnum == FREEZEBLAST)
{
@ -1669,7 +1669,7 @@ static void weaponcommon_d(DDukeActor* proj)
if (proj->picnum != BOSS2 && proj->spr.xrepeat >= 10 && proj->spr.sector()->lotag != 2)
{
auto spawned = spawn(proj, SMALLSMOKE);
if (spawned) spawned->spr.z += (1 << 8);
if (spawned) spawned->spr.pos.Z += (1 << 8);
}
break;
@ -1695,14 +1695,14 @@ static void weaponcommon_d(DDukeActor* proj)
if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
{
if (proj->spr.z < proj->ceilingz)
if (proj->spr.pos.Z < proj->ceilingz)
{
coll.setSector(proj->spr.sector());
proj->spr.zvel = -1;
}
else
if ((proj->spr.z > proj->floorz && proj->spr.sector()->lotag != 1) ||
(proj->spr.z > proj->floorz + (16 << 8) && proj->spr.sector()->lotag == 1))
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))
{
coll.setSector(proj->spr.sector());
if (proj->spr.sector()->lotag != 1)
@ -1717,7 +1717,7 @@ static void weaponcommon_d(DDukeActor* proj)
auto spawned = EGS(proj->spr.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.z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
proj->spr.pos.Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
proj->spr.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
if (spawned)
{
@ -1779,7 +1779,7 @@ static void weaponcommon_d(DDukeActor* proj)
{
if (proj->spr.zvel < 0)
{
k->spr.cstat |= CSTAT_SPRITE_YFLIP; k->spr.z += (72 << 8);
k->spr.cstat |= CSTAT_SPRITE_YFLIP; k->spr.pos.Z += (72 << 8);
}
}
}
@ -1942,7 +1942,7 @@ void movetransports_d(void)
ps[p].bobposx = ps[p].oposx = ps[p].pos.X = Owner->spr.pos.X;
ps[p].bobposy = ps[p].oposy = ps[p].pos.Y = Owner->spr.pos.Y;
ps[p].oposz = ps[p].pos.Z = Owner->spr.z - gs.playerheight;
ps[p].oposz = ps[p].pos.Z = Owner->spr.pos.Z - gs.playerheight;
ChangeActorSect(act2, Owner->sector());
ps[p].setCursector(act2->spr.sector());
@ -1958,7 +1958,7 @@ void movetransports_d(void)
}
else if (!(sectlotag == 1 && ps[p].on_ground == 1)) break;
if (onfloorz == 0 && abs(act->spr.z - ps[p].pos.Z) < 6144)
if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 6144)
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP))) ||
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
{
@ -1966,8 +1966,8 @@ void movetransports_d(void)
ps[p].oposy = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
ps[p].pos.Z = Owner->spr.z - 6144;
else ps[p].pos.Z = Owner->spr.z + 6144;
ps[p].pos.Z = Owner->spr.pos.Z - 6144;
else ps[p].pos.Z = Owner->spr.pos.Z + 6144;
ps[p].oposz = ps[p].pos.Z;
auto pa = ps[p].GetActor();
@ -2035,7 +2035,7 @@ void movetransports_d(void)
for (int l = 0; l < 9; l++)
{
auto q = spawn(ps[p].GetActor(), WATERBUBBLE);
if (q) q->spr.z += krand() & 16383;
if (q) q->spr.pos.Z += krand() & 16383;
}
}
}
@ -2068,13 +2068,13 @@ void movetransports_d(void)
{
warpspriteto = 0;
if (ll && sectlotag == 2 && act2->spr.z < (sectp->ceilingz + ll))
if (ll && sectlotag == 2 && act2->spr.pos.Z < (sectp->ceilingz + ll))
warpspriteto = 1;
if (ll && sectlotag == 1 && act2->spr.z > (sectp->floorz - ll))
if (ll && sectlotag == 1 && act2->spr.pos.Z > (sectp->floorz - ll))
warpspriteto = 1;
if (sectlotag == 0 && (onfloorz || abs(act2->spr.z - act->spr.z) < 4096))
if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 4096))
{
if ((!Owner || Owner->GetOwner() != Owner) && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != STAT_MISC)
{
@ -2134,7 +2134,7 @@ void movetransports_d(void)
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z -= act->spr.z - Owner->sector()->floorz;
act2->spr.pos.Z -= act->spr.pos.Z - Owner->sector()->floorz;
act2->spr.ang = Owner->spr.ang;
act2->spr.backupang();
@ -2161,7 +2161,7 @@ void movetransports_d(void)
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->spr.z + 4096;
act2->spr.pos.Z = Owner->spr.pos.Z + 4096;
act2->spr.backupz();
@ -2171,7 +2171,7 @@ void movetransports_d(void)
case 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);
act2->spr.z = Owner->sector()->ceilingz + ll;
act2->spr.pos.Z = Owner->sector()->ceilingz + ll;
act2->spr.backupz();
@ -2181,7 +2181,7 @@ void movetransports_d(void)
case 2:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->floorz - ll;
act2->spr.pos.Z = Owner->sector()->floorz - ll;
act2->spr.backupz();
@ -2268,7 +2268,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.z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
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);
k->spr.pal = 1;
}
ps[p].actors_killed++;
@ -2306,7 +2306,7 @@ static void greenslime(DDukeActor *actor)
{
for (x = 0; x < 8; x++)
{
auto j = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto j = 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);
j->spr.pal = 6;
}
@ -2325,9 +2325,9 @@ static void greenslime(DDukeActor *actor)
return;
}
actor->spr.z = ps[p].pos.Z + ps[p].pyoff - t[2] + (8 << 8);
actor->spr.pos.Z = ps[p].pos.Z + ps[p].pyoff - t[2] + (8 << 8);
actor->spr.z += -ps[p].horizon.horiz.asq16() >> 12;
actor->spr.pos.Z += -ps[p].horizon.horiz.asq16() >> 12;
if (t[2] > 512)
t[2] -= 128;
@ -2421,7 +2421,7 @@ static void greenslime(DDukeActor *actor)
for (x = 0; x < 8; x++)
{
auto j = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto j = 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);
if (j) j->spr.pal = 6;
}
t[0] = -3;
@ -2460,7 +2460,7 @@ static void greenslime(DDukeActor *actor)
int l = s5->spr.ang;
actor->spr.z = s5->spr.z;
actor->spr.pos.Z = s5->spr.pos.Z;
actor->spr.pos.X = s5->spr.pos.X + bcos(l, -11);
actor->spr.pos.Y = s5->spr.pos.Y + bsin(l, -11);
@ -2491,7 +2491,7 @@ static void greenslime(DDukeActor *actor)
{
if (gs.actorinfo[a2->spr.picnum].flags & SFLAG_GREENSLIMEFOOD)
{
if (ldist(actor, a2) < 768 && (abs(actor->spr.z - a2->spr.z) < 8192)) //Gulp them
if (ldist(actor, a2) < 768 && (abs(actor->spr.pos.Z - a2->spr.pos.Z) < 8192)) //Gulp them
{
actor->temp_actor = a2;
t[0] = -2;
@ -2516,9 +2516,9 @@ static void greenslime(DDukeActor *actor)
actor->spr.zvel = 0;
actor->spr.cstat &= ~CSTAT_SPRITE_YFLIP;
if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 6144) < actor->spr.z)
if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 6144) < actor->spr.pos.Z)
{
actor->spr.z += 2048;
actor->spr.pos.Z += 2048;
t[0] = 3;
return;
}
@ -2566,10 +2566,10 @@ static void greenslime(DDukeActor *actor)
if (actor->spr.xrepeat > 8) actor->spr.xrepeat -= 4;
if (actor->spr.zvel > -(2048 + 1024))
actor->spr.zvel -= 348;
actor->spr.z += actor->spr.zvel;
if (actor->spr.z < actor->ceilingz + 4096)
actor->spr.pos.Z += actor->spr.zvel;
if (actor->spr.pos.Z < actor->ceilingz + 4096)
{
actor->spr.z = actor->ceilingz + 4096;
actor->spr.pos.Z = actor->ceilingz + 4096;
actor->spr.xvel = 0;
t[0] = 2;
}
@ -2581,7 +2581,7 @@ static void greenslime(DDukeActor *actor)
makeitfall(actor);
if (actor->spr.z > actor->floorz - (8 << 8))
if (actor->spr.pos.Z > actor->floorz - (8 << 8))
{
actor->spr.yrepeat -= 4;
actor->spr.xrepeat += 2;
@ -2592,9 +2592,9 @@ static void greenslime(DDukeActor *actor)
if (actor->spr.xrepeat > 8) actor->spr.xrepeat -= 4;
}
if (actor->spr.z > actor->floorz - 2048)
if (actor->spr.pos.Z > actor->floorz - 2048)
{
actor->spr.z = actor->floorz - 2048;
actor->spr.pos.Z = actor->floorz - 2048;
t[0] = 0;
actor->spr.xvel = 0;
}
@ -2624,7 +2624,7 @@ static void flamethrowerflame(DDukeActor *actor)
int dax = actor->spr.pos.X;
int day = actor->spr.pos.Y;
int daz = actor->spr.z;
int daz = actor->spr.pos.Z;
int xvel = actor->spr.xvel;
getglobalz(actor);
@ -2654,13 +2654,13 @@ static void flamethrowerflame(DDukeActor *actor)
if (coll.type != kHitSprite)
{
if (actor->spr.z < actor->ceilingz)
if (actor->spr.pos.Z < actor->ceilingz)
{
coll.setSector(actor->spr.sector());
actor->spr.zvel = -1;
}
else if ((actor->spr.z > actor->floorz && actor->spr.sector()->lotag != 1)
|| (actor->spr.z > actor->floorz + (16 << 8) && actor->spr.sector()->lotag == 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))
{
coll.setSector(actor->spr.sector());
if (actor->spr.sector()->lotag != 1)
@ -2679,7 +2679,7 @@ static void flamethrowerflame(DDukeActor *actor)
else if (coll.type == kHitWall)
{
SetActor(actor, { dax, day, daz });
fi.checkhitwall(actor, coll.hitWall, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.picnum);
fi.checkhitwall(actor, coll.hitWall, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
}
else if (coll.type == kHitSector)
{
@ -2748,7 +2748,7 @@ static void heavyhbomb(DDukeActor *actor)
{
makeitfall(actor);
if (sectp->lotag != 1 && actor->spr.z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
if (sectp->lotag != 1 && actor->spr.pos.Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
{
if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
S_PlayActorSound(PIPEBOMB_BOUNCE, actor);
@ -2757,9 +2757,9 @@ static void heavyhbomb(DDukeActor *actor)
actor->spr.zvel >>= 2;
actor->spr.yvel++;
}
if (actor->spr.z < actor->ceilingz) // && sectp->lotag != 2 )
if (actor->spr.pos.Z < actor->ceilingz) // && sectp->lotag != 2 )
{
actor->spr.z = actor->ceilingz + (3 << 8);
actor->spr.pos.Z = actor->ceilingz + (3 << 8);
actor->spr.zvel = 0;
}
}
@ -2772,7 +2772,7 @@ static void heavyhbomb(DDukeActor *actor)
if (actor->spr.sector()->lotag == 1 && actor->spr.zvel == 0)
{
actor->spr.z += (32 << 8);
actor->spr.pos.Z += (32 << 8);
if (t[5] == 0)
{
t[5] = 1;
@ -2808,7 +2808,7 @@ static void heavyhbomb(DDukeActor *actor)
if (coll.type== kHitWall)
{
auto wal = coll.hitWall;
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.picnum);
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
int k = getangle(wal->delta());
@ -2874,7 +2874,7 @@ DETONATEB:
}
}
else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && t[0] > 7 && actor->spr.xvel == 0)
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.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)
@ -3004,7 +3004,7 @@ void moveactors_d(void)
case HELECOPT:
case DUKECAR:
act->spr.z += act->spr.zvel;
act->spr.pos.Z += act->spr.zvel;
t[0]++;
if (t[0] == 4) S_PlayActorSound(WAR_AMBIENCE2, act);
@ -3130,7 +3130,7 @@ static void fireflyflyingeffect(DDukeActor *actor)
actor->spr.pos.X = (int) (Owner->spr.pos.X - (dx * -10.0));
actor->spr.pos.Y = (int) (Owner->spr.pos.Y - (dy * -10.0));
actor->spr.z = Owner->spr.z + 2048;
actor->spr.pos.Z = Owner->spr.pos.Z + 2048;
if (Owner->spr.extra <= 0)
{
@ -3184,7 +3184,7 @@ void moveexplosions_d(void) // STATNUM 5
case BLOODSPLAT4:
if (t[0] == 7 * 26) continue;
act->spr.z += 16 + (krand() & 15);
act->spr.pos.Z += 16 + (krand() & 15);
t[0]++;
if ((t[0] % 9) == 0) act->spr.yrepeat++;
continue;
@ -3245,7 +3245,7 @@ void moveexplosions_d(void) // STATNUM 5
case MONEY + 1:
case MAIL + 1:
case PAPER + 1:
act->floorz = act->spr.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
act->floorz = act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
break;
case MONEY:
case MAIL:
@ -3306,7 +3306,7 @@ void moveexplosions_d(void) // STATNUM 5
case SHELL:
case SHOTGUNSHELL:
shell(act, (sectp->floorz + (24 << 8)) < act->spr.z);
shell(act, (sectp->floorz + (24 << 8)) < act->spr.pos.Z);
continue;
case GLASSPIECES:
@ -3427,7 +3427,7 @@ static void handle_se28(DDukeActor* actor)
}
else if (t[2] > (t[1] >> 3) && t[2] < (t[1] >> 2))
{
int j = !!cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
if (rnd(192) && (t[2] & 1))
{
@ -3609,7 +3609,7 @@ void moveeffectors_d(void) //STATNUM 3
case SE_29_WAVES:
act->spr.hitag += 64;
l = MulScale(act->spr.yvel, bsin(act->spr.hitag), 12);
sc->floorz = act->spr.z + l;
sc->floorz = act->spr.pos.Z + l;
break;
case SE_31_FLOOR_RISE_FALL: // True Drop Floor
handle_se31(act, true);
@ -3759,16 +3759,16 @@ 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);
if (actor->spr.z > (l - (8 << 8)))
if (actor->spr.pos.Z > (l - (8 << 8)))
{
if (actor->spr.z > (l - (8 << 8))) actor->spr.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);
if ((actor->spr.z - l) < (80 << 8))
if ((actor->spr.pos.Z - l) < (80 << 8))
{
actor->spr.z = l + (80 << 8);
actor->spr.pos.Z = l + (80 << 8);
actor->spr.zvel = 0;
}
}
@ -3777,15 +3777,15 @@ 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);
if (actor->spr.z > (l - (30 << 8)))
actor->spr.z = l - (30 << 8);
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);
if ((actor->spr.z - l) < (50 << 8))
if ((actor->spr.pos.Z - l) < (50 << 8))
{
actor->spr.z = l + (50 << 8);
actor->spr.pos.Z = l + (50 << 8);
actor->spr.zvel = 0;
}
}
@ -3793,22 +3793,22 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
}
else if (actor->spr.picnum != ORGANTIC)
{
if (actor->spr.zvel > 0 && actor->floorz < actor->spr.z)
actor->spr.z = actor->floorz;
if (actor->spr.zvel > 0 && actor->floorz < actor->spr.pos.Z)
actor->spr.pos.Z = actor->floorz;
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (66 << 8))
if ((actor->spr.pos.Z - l) < (66 << 8))
{
actor->spr.z = l + (66 << 8);
actor->spr.pos.Z = l + (66 << 8);
actor->spr.zvel >>= 1;
}
}
}
}
else if (actor->spr.picnum == APLAYER)
if ((actor->spr.z - actor->ceilingz) < (32 << 8))
actor->spr.z = actor->ceilingz + (32 << 8);
if ((actor->spr.pos.Z - actor->ceilingz) < (32 << 8))
actor->spr.pos.Z = actor->ceilingz + (32 << 8);
daxvel = actor->spr.xvel;
angdif = actor->spr.ang;
@ -3834,7 +3834,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
}
else if (actor->spr.picnum != DRONE && actor->spr.picnum != SHARK && actor->spr.picnum != COMMANDER)
{
if (actor->spr.oz != actor->spr.z || (ud.multimode < 2 && ud.player_skill < 2))
if (actor->spr.oz != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
{
if ((t[0] & 1) || ps[playernum].actorsqu == actor) return;
else daxvel <<= 1;

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

@ -518,7 +518,7 @@ void moveminecart(void)
while (auto a2 = it.Next())
{
if (badguy(a2))
SetActor(a2, { cx, cy, a2->spr.z });
SetActor(a2, { cx, cy, a2->spr.pos.Z });
}
}
}

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

@ -225,7 +225,7 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
while (auto dasectp = search.GetNext())
{
if (((dasectp->ceilingz - actor->spr.z) >> 8) < r)
if (((dasectp->ceilingz - actor->spr.pos.Z) >> 8) < r)
{
auto wal = dasectp->firstWall();
int d = abs(wal->pos.X - actor->spr.pos.X) + abs(wal->pos.Y - actor->spr.pos.Y);
@ -252,8 +252,8 @@ 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.z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.sector()))
fi.checkhitwall(actor, &wal, wal.pos.X, wal.pos.Y, actor->spr.z, actor->spr.picnum);
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()))
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.z + q, act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z + q, actor->spr.sector()))
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()))
{
continue;
}
@ -290,11 +290,11 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
continue;
}
if (act2->spr.picnum == APLAYER) act2->spr.z -= gs.playerheight;
if (act2->spr.picnum == APLAYER) act2->spr.pos.Z -= gs.playerheight;
int d = dist(actor, act2);
if (act2->spr.picnum == APLAYER) act2->spr.z += gs.playerheight;
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.z - (8 << 8), act2->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->spr.sector()))
{
if ((isRRRA()) && act2->spr.picnum == MINION && act2->spr.pal == 19)
{
@ -373,7 +373,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
{
actor->spr.pos.X += (xchange * TICSPERFRAME) >> 2;
actor->spr.pos.Y += (ychange * TICSPERFRAME) >> 2;
actor->spr.z += (zchange * TICSPERFRAME) >> 2;
actor->spr.pos.Z += (zchange * TICSPERFRAME) >> 2;
if (bg)
SetActor(actor, actor->spr.pos);
return result.setNone();
@ -419,9 +419,9 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
if (dasectp)
if ((dasectp != actor->spr.sector()))
ChangeActorSect(actor, dasectp);
int daz = actor->spr.z + ((zchange * TICSPERFRAME) >> 3);
int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
actor->spr.z = daz;
actor->spr.pos.Z = daz;
else if (result.type == kHitNone)
return result.setSector(dasectp);
@ -457,7 +457,7 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
sx = sy = 8;
else sx = sy = 32;
gutz = actor->spr.z - (8 << 8);
gutz = actor->spr.pos.Z - (8 << 8);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
@ -545,14 +545,14 @@ void movefta_r(void)
{
int r1 = krand();
int r2 = krand();
j = cansee(sx, sy, act->spr.z - (r2 % (52 << 8)), act->spr.sector(), px, py, ps[p].oposz - (r1 % (32 << 8)), ps[p].cursector);
j = cansee(sx, sy, act->spr.pos.Z - (r2 % (52 << 8)), act->spr.sector(), px, py, ps[p].oposz - (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.z - ((r2 & 31) << 8), act->spr.sector(), ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursector);
j = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - ((r2 & 31) << 8), act->spr.sector(), ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursector);
}
@ -779,7 +779,7 @@ void movefallers_r(void)
if (act->temp_data[0] == 0)
{
act->spr.z -= (16 << 8);
act->spr.pos.Z -= (16 << 8);
act->temp_data[1] = act->spr.ang;
int x = act->spr.extra;
int j = fi.ifhitbyweapon(act);
@ -810,7 +810,7 @@ void movefallers_r(void)
}
}
act->spr.ang = act->temp_data[1];
act->spr.z += (16 << 8);
act->spr.pos.Z += (16 << 8);
}
else if (act->temp_data[0] == 1)
{
@ -838,14 +838,14 @@ void movefallers_r(void)
x = gs.gravity;
}
if (act->spr.z < (sectp->floorz - FOURSLEIGHT))
if (act->spr.pos.Z < (sectp->floorz - FOURSLEIGHT))
{
act->spr.zvel += x;
if (act->spr.zvel > 6144)
act->spr.zvel = 6144;
act->spr.z += act->spr.zvel;
act->spr.pos.Z += act->spr.zvel;
}
if ((sectp->floorz - act->spr.z) < (16 << 8))
if ((sectp->floorz - act->spr.pos.Z) < (16 << 8))
{
int j = 1 + (krand() & 7);
for (x = 0; x < j; x++) RANDOMSCRAP(act);
@ -1072,7 +1072,7 @@ static void chickenarrow(DDukeActor* actor)
if (actor->picnum != BOSS2 && actor->spr.xrepeat >= 10 && actor->spr.sector()->lotag != 2)
{
auto spawned = spawn(actor, SMALLSMOKE);
if (spawned) spawned->spr.z += (1 << 8);
if (spawned) spawned->spr.pos.Z += (1 << 8);
if ((krand() & 15) == 2)
{
spawn(actor, MONEY);
@ -1210,7 +1210,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t& oldpos)
else
{
SetActor(proj, oldpos);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.z, proj->spr.picnum);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.pos.Z, proj->spr.picnum);
if (!isRRRA() && proj->spr.picnum == FREEZEBLAST)
{
@ -1351,7 +1351,7 @@ static void weaponcommon_r(DDukeActor *proj)
case RPG:
if (proj->picnum != BOSS2 && proj->spr.xrepeat >= 10 && proj->spr.sector()->lotag != 2)
{
spawn(proj, SMALLSMOKE)->spr.z += (1 << 8);
spawn(proj, SMALLSMOKE)->spr.pos.Z += (1 << 8);
}
break;
case RPG2:
@ -1370,7 +1370,7 @@ static void weaponcommon_r(DDukeActor *proj)
makeitfall(proj);
if (proj->spr.xrepeat >= 10 && proj->spr.sector()->lotag != 2)
{
spawn(proj, SMALLSMOKE)->spr.z += (1 << 8);
spawn(proj, SMALLSMOKE)->spr.pos.Z += (1 << 8);
}
break;
}
@ -1392,13 +1392,13 @@ static void weaponcommon_r(DDukeActor *proj)
if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
{
if (proj->spr.z < proj->ceilingz)
if (proj->spr.pos.Z < proj->ceilingz)
{
coll.setSector(proj->spr.sector());
proj->spr.zvel = -1;
}
else
if (proj->spr.z > proj->floorz)
if (proj->spr.pos.Z > proj->floorz)
{
coll.setSector(proj->spr.sector());
if (proj->spr.sector()->lotag != 1)
@ -1413,7 +1413,7 @@ static void weaponcommon_r(DDukeActor *proj)
auto x = EGS(proj->spr.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.z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
proj->spr.pos.Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
proj->spr.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
if (x)
@ -1457,7 +1457,7 @@ static void weaponcommon_r(DDukeActor *proj)
if (proj->spr.zvel < 0)
{
k->spr.cstat |= CSTAT_SPRITE_YFLIP;
k->spr.z += (72 << 8);
k->spr.pos.Z += (72 << 8);
}
}
}
@ -1606,7 +1606,7 @@ void movetransports_r(void)
ps[p].bobposx = ps[p].oposx = ps[p].pos.X = Owner->spr.pos.X;
ps[p].bobposy = ps[p].oposy = ps[p].pos.Y = Owner->spr.pos.Y;
ps[p].oposz = ps[p].pos.Z = Owner->spr.z - (gs.playerheight - (4 << 8));
ps[p].oposz = ps[p].pos.Z = Owner->spr.pos.Z - (gs.playerheight - (4 << 8));
ChangeActorSect(act2, Owner->sector());
ps[p].setCursector(act2->spr.sector());
@ -1619,7 +1619,7 @@ void movetransports_r(void)
}
else break;
if (onfloorz == 0 && abs(act->spr.z - ps[p].pos.Z) < 6144)
if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 6144)
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && PlayerInput(p, SB_JUMP)) ||
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
{
@ -1627,8 +1627,8 @@ void movetransports_r(void)
ps[p].oposy = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
ps[p].pos.Z = Owner->spr.z - 6144;
else ps[p].pos.Z = Owner->spr.z + 6144;
ps[p].pos.Z = Owner->spr.pos.Z - 6144;
else ps[p].pos.Z = Owner->spr.pos.Z + 6144;
ps[p].oposz = ps[p].pos.Z;
ChangeActorSect(act2, Owner->sector());
@ -1735,38 +1735,38 @@ void movetransports_r(void)
{
warpspriteto = 0;
if (ll && sectlotag == ST_2_UNDERWATER && act2->spr.z < (sectp->ceilingz + ll))
if (ll && sectlotag == ST_2_UNDERWATER && act2->spr.pos.Z < (sectp->ceilingz + ll))
warpspriteto = 1;
if (ll && sectlotag == ST_1_ABOVE_WATER && act2->spr.z > (sectp->floorz - ll))
if (ll && sectlotag == ST_1_ABOVE_WATER && act2->spr.pos.Z > (sectp->floorz - ll))
if (!isRRRA() || (act2->spr.picnum != CHEERBOAT && act2->spr.picnum != HULKBOAT && act2->spr.picnum != MINIONBOAT))
warpspriteto = 1;
if (isRRRA())
{
if (ll && sectlotag == 161 && act2->spr.z < (sectp->ceilingz + ll) && warpdir == 1)
if (ll && sectlotag == 161 && act2->spr.pos.Z < (sectp->ceilingz + ll) && warpdir == 1)
{
warpspriteto = 1;
ll2 = ll - abs(act2->spr.z - sectp->ceilingz);
ll2 = ll - abs(act2->spr.pos.Z - sectp->ceilingz);
}
else if (sectlotag == 161 && act2->spr.z < (sectp->ceilingz + 1000) && warpdir == 1)
else if (sectlotag == 161 && act2->spr.pos.Z < (sectp->ceilingz + 1000) && warpdir == 1)
{
warpspriteto = 1;
ll2 = 1;
}
if (ll && sectlotag == 160 && act2->spr.z > (sectp->floorz - ll) && warpdir == 2)
if (ll && sectlotag == 160 && act2->spr.pos.Z > (sectp->floorz - ll) && warpdir == 2)
{
warpspriteto = 1;
ll2 = ll - abs(sectp->floorz - act2->spr.z);
ll2 = ll - abs(sectp->floorz - act2->spr.pos.Z);
}
else if (sectlotag == 160 && act2->spr.z > (sectp->floorz - 1000) && warpdir == 2)
else if (sectlotag == 160 && act2->spr.pos.Z > (sectp->floorz - 1000) && warpdir == 2)
{
warpspriteto = 1;
ll2 = 1;
}
}
if (sectlotag == 0 && (onfloorz || abs(act2->spr.z - act->spr.z) < 4096))
if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 4096))
{
if (Owner->GetOwner() != Owner && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != 5)
{
@ -1822,7 +1822,7 @@ void movetransports_r(void)
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z -= act->spr.z - Owner->sector()->floorz;
act2->spr.pos.Z -= act->spr.pos.Z - Owner->sector()->floorz;
act2->spr.ang = Owner->spr.ang;
act2->spr.backupang();
@ -1846,7 +1846,7 @@ void movetransports_r(void)
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->spr.z + 4096;
act2->spr.pos.Z = Owner->spr.pos.Z + 4096;
act2->spr.backupz();
@ -1856,7 +1856,7 @@ void movetransports_r(void)
case ST_1_ABOVE_WATER:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->ceilingz + ll;
act2->spr.pos.Z = Owner->sector()->ceilingz + ll;
act2->spr.backupz();
@ -1866,7 +1866,7 @@ void movetransports_r(void)
case ST_2_UNDERWATER:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->floorz - ll;
act2->spr.pos.Z = Owner->sector()->floorz - ll;
act2->spr.backupz();
@ -1878,7 +1878,7 @@ void movetransports_r(void)
if (!isRRRA()) break;
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->ceilingz + ll2;
act2->spr.pos.Z = Owner->sector()->ceilingz + ll2;
act2->spr.backupz();
@ -1892,7 +1892,7 @@ void movetransports_r(void)
if (!isRRRA()) break;
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->floorz - ll2;
act2->spr.pos.Z = Owner->sector()->floorz - ll2;
act2->spr.backupz();
@ -2064,7 +2064,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.z)
if (act->spr.sector()->ceilingz + (4 << 8) > act->spr.pos.Z)
{
act->spr.picnum = 0;
act->spr.extra = 100;
@ -2295,9 +2295,9 @@ void rr_specialstats()
{
if (act->spr.hitag == 100)
{
act->spr.z += (4 << 8);
if (act->spr.z >= act->spr.sector()->floorz + 15168)
act->spr.z = act->spr.sector()->floorz + 15168;
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.picnum == LUMBERBLADE)
@ -2306,7 +2306,7 @@ void rr_specialstats()
if (act->spr.extra == 192)
{
act->spr.hitag = 0;
act->spr.z = act->spr.sector()->floorz - 15168;
act->spr.pos.Z = act->spr.sector()->floorz - 15168;
act->spr.extra = 0;
act->spr.picnum = RRTILE3410;
DukeStatIterator it2(STAT_DEFAULT);
@ -2451,7 +2451,7 @@ void rr_specialstats()
ps[p].angle.ang = buildang(act2->spr.ang);
ps[p].bobposx = ps[p].oposx = ps[p].pos.X = act2->spr.pos.X;
ps[p].bobposy = ps[p].oposy = ps[p].pos.Y = act2->spr.pos.Y;
ps[p].oposz = ps[p].pos.Z = act2->spr.z - (36 << 8);
ps[p].oposz = ps[p].pos.Z = act2->spr.pos.Z - (36 << 8);
auto pact = ps[p].GetActor();
ChangeActorSect(pact, act2->sector());
ps[p].setCursector(pact->sector());
@ -2509,7 +2509,7 @@ static void heavyhbomb(DDukeActor *actor)
makeitfall(actor);
if (sectp->lotag != 1 && (!isRRRA() || sectp->lotag != 160) && actor->spr.z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
if (sectp->lotag != 1 && (!isRRRA() || sectp->lotag != 160) && actor->spr.pos.Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
{
if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
{
@ -2528,9 +2528,9 @@ static void heavyhbomb(DDukeActor *actor)
actor->spr.zvel >>= 2;
actor->spr.yvel++;
}
if (actor->spr.picnum != CHEERBOMB && actor->spr.z < actor->ceilingz + (16 << 8) && sectp->lotag != 2)
if (actor->spr.picnum != CHEERBOMB && actor->spr.pos.Z < actor->ceilingz + (16 << 8) && sectp->lotag != 2)
{
actor->spr.z = actor->ceilingz + (16 << 8);
actor->spr.pos.Z = actor->ceilingz + (16 << 8);
actor->spr.zvel = 0;
}
@ -2542,7 +2542,7 @@ static void heavyhbomb(DDukeActor *actor)
if (actor->spr.sector()->lotag == 1 && actor->spr.zvel == 0)
{
actor->spr.z += (32 << 8);
actor->spr.pos.Z += (32 << 8);
if (t[5] == 0)
{
t[5] = 1;
@ -2589,7 +2589,7 @@ static void heavyhbomb(DDukeActor *actor)
if (coll.type == kHitWall)
{
auto wal = coll.hitWall;
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.picnum);
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
int k = getangle(wal->delta());
@ -2655,7 +2655,7 @@ DETONATEB:
}
}
else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && t[0] > 7 && actor->spr.xvel == 0)
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.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)
{
@ -2852,7 +2852,7 @@ void moveactors_r(void)
act->spr.picnum = RRTILE3192;
break;
case 903:
if (act->spr.z >= sectp->floorz - (8<<8))
if (act->spr.pos.Z >= sectp->floorz - (8<<8))
{
deletesprite(act);
continue;
@ -2891,7 +2891,7 @@ void moveactors_r(void)
}
if (sectp->lotag == 903)
{
if (act->spr.z >= sectp->floorz - (4<<8))
if (act->spr.pos.Z >= sectp->floorz - (4<<8))
{
deletesprite(act);
continue;
@ -2915,12 +2915,12 @@ void moveactors_r(void)
MulScale(act->spr.xvel, bcos(act->spr.ang), 14),
MulScale(act->spr.xvel, bsin(act->spr.ang), 14),
act->spr.zvel,CLIPMASK0, coll);
if (act->spr.z >= sectp->floorz - (8<<8))
if (act->spr.pos.Z >= sectp->floorz - (8<<8))
{
if (sectp->lotag == 1)
{
auto j = spawn(act, WATERSPLASH2);
if (j) j->spr.z = j->sector()->floorz;
if (j) j->spr.pos.Z = j->sector()->floorz;
}
deletesprite(act);
continue;
@ -3089,7 +3089,7 @@ void moveexplosions_r(void) // STATNUM 5
{
case SHOTGUNSPRITE:
if (act->spr.sector()->lotag == 800)
if (act->spr.z >= act->spr.sector()->floorz - (8 << 8))
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3112,7 +3112,7 @@ void moveexplosions_r(void) // STATNUM 5
case BLOODSPLAT4:
if (t[0] == 7 * 26) continue;
act->spr.z += 16 + (krand() & 15);
act->spr.pos.Z += 16 + (krand() & 15);
t[0]++;
if ((t[0] % 9) == 0) act->spr.yrepeat++;
continue;
@ -3178,7 +3178,7 @@ void moveexplosions_r(void) // STATNUM 5
deletesprite(act);
continue;
case FEATHER + 1: // feather
act->floorz = act->spr.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
act->floorz = act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.sector()->lotag == 800)
{
deletesprite(act);
@ -3189,7 +3189,7 @@ void moveexplosions_r(void) // STATNUM 5
if (!money(act, BLOODPOOL)) continue;
if (act->spr.sector()->lotag == 800)
if (act->spr.z >= act->spr.sector()->floorz - (8 << 8))
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3244,7 +3244,7 @@ void moveexplosions_r(void) // STATNUM 5
isRRRA() && (act->spr.picnum == RRTILE2465 || act->spr.picnum == RRTILE2560))) continue;
if (act->spr.sector()->lotag == 800)
if (act->spr.z >= act->spr.sector()->floorz - (8 << 8))
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3256,7 +3256,7 @@ void moveexplosions_r(void) // STATNUM 5
if (!bloodpool(act, false, TIRE)) continue;
if (act->spr.sector()->lotag == 800)
if (act->spr.z >= act->spr.sector()->floorz - (8 << 8))
if (act->spr.pos.Z >= act->spr.sector()->floorz - (8 << 8))
{
deletesprite(act);
}
@ -3329,7 +3329,7 @@ void handle_se06_r(DDukeActor *actor)
auto ns = spawn(actor, HULK);
if (ns)
{
ns->spr.z = ns->sector()->ceilingz;
ns->spr.pos.Z = ns->sector()->ceilingz;
ns->spr.pal = 33;
}
if (!hulkspawn)
@ -3347,7 +3347,7 @@ void handle_se06_r(DDukeActor *actor)
{
ns->spr.cstat = 0;
ns->spr.cstat |= CSTAT_SPRITE_INVISIBLE;
ns->spr.z = actor->spr.sector()->floorz - 6144;
ns->spr.pos.Z = actor->spr.sector()->floorz - 6144;
}
deletesprite(actor);
return;
@ -3387,7 +3387,7 @@ void handle_se06_r(DDukeActor *actor)
}
else pn = UFO1_RRRA;
auto ns = spawn(actor, pn);
if (ns) ns->spr.z = ns->sector()->ceilingz;
if (ns) ns->spr.pos.Z = ns->sector()->ceilingz;
}
}
}
@ -3567,7 +3567,7 @@ void moveeffectors_r(void) //STATNUM 3
case SE_29_WAVES:
act->spr.hitag += 64;
l = MulScale(act->spr.yvel, bsin(act->spr.hitag), 12);
sc->floorz = act->spr.z + l;
sc->floorz = act->spr.pos.Z + l;
break;
case SE_31_FLOOR_RISE_FALL: // True Drop Floor
@ -3815,40 +3815,40 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (isRRRA())
{
if (actor->spr.z > (l - (28 << 8)))
actor->spr.z = l - (28 << 8);
if (actor->spr.pos.Z > (l - (28 << 8)))
actor->spr.pos.Z = l - (28 << 8);
}
else
{
if (actor->spr.z > (l - (30 << 8)))
actor->spr.z = l - (30 << 8);
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);
if ((actor->spr.z - l) < (50 << 8))
if ((actor->spr.pos.Z - l) < (50 << 8))
{
actor->spr.z = l + (50 << 8);
actor->spr.pos.Z = l + (50 << 8);
actor->spr.zvel = 0;
}
}
}
if (actor->spr.zvel > 0 && actor->floorz < actor->spr.z)
actor->spr.z = actor->floorz;
if (actor->spr.zvel > 0 && actor->floorz < actor->spr.pos.Z)
actor->spr.pos.Z = actor->floorz;
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (66 << 8))
if ((actor->spr.pos.Z - l) < (66 << 8))
{
actor->spr.z = l + (66 << 8);
actor->spr.pos.Z = l + (66 << 8);
actor->spr.zvel >>= 1;
}
}
}
else if (actor->spr.picnum == APLAYER)
if ((actor->spr.z - actor->ceilingz) < (32 << 8))
actor->spr.z = actor->ceilingz + (32 << 8);
if ((actor->spr.pos.Z - actor->ceilingz) < (32 << 8))
actor->spr.pos.Z = actor->ceilingz + (32 << 8);
daxvel = actor->spr.xvel;
angdif = actor->spr.ang;
@ -3876,7 +3876,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
(!isRRRA() && actor->spr.picnum != DRONE && actor->spr.picnum != SHARK && actor->spr.picnum != UFO1_RR
&& actor->spr.picnum != UFO2 && actor->spr.picnum != UFO3 && actor->spr.picnum != UFO4 && actor->spr.picnum != UFO5))
{
if (actor->spr.oz != actor->spr.z || (ud.multimode < 2 && ud.player_skill < 2))
if (actor->spr.oz != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
{
if ((t[0] & 1) || ps[pnum].actorsqu == actor) return;
else daxvel <<= 1;
@ -3986,7 +3986,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
}
else if (actor->spr.sector()->lotag == 802)
{
if (actor->spr.picnum != APLAYER && badguy(actor) && actor->spr.z == actor->floorz - FOURSLEIGHT)
if (actor->spr.picnum != APLAYER && badguy(actor) && actor->spr.pos.Z == actor->floorz - FOURSLEIGHT)
{
fi.guts(actor, JIBS6, 5, playernum);
S_PlayActorSound(SQUISHED, actor);
@ -4010,7 +4010,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
}
if (actor->spr.picnum != APLAYER && (badguy(actor) || actor->spr.picnum == HEN || actor->spr.picnum == COW || actor->spr.picnum == PIG || actor->spr.picnum == DOGRUN || actor->spr.picnum == RABBIT) && (!isRRRA() || actor->spriteextra < 128))
{
actor->spr.z = actor->floorz - FOURSLEIGHT;
actor->spr.pos.Z = actor->floorz - FOURSLEIGHT;
actor->spr.zvel = 8000;
actor->spr.extra = 0;
actor->spriteextra++;

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

@ -167,8 +167,8 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
{
t->pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].oposx, 16);
t->pos.Y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].oposy, 16);
t->z = interpolatedvalue(ps[h->spr.yvel].oposz, ps[h->spr.yvel].pos.Z, smoothratio);
t->z += PHEIGHT_DUKE;
t->pos.Z = interpolatedvalue(ps[h->spr.yvel].oposz, ps[h->spr.yvel].pos.Z, smoothratio);
t->pos.Z += PHEIGHT_DUKE;
}
else if (h->spr.picnum != CRANEPOLE)
{
@ -183,7 +183,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
switch (h->spr.picnum)
{
case DUKELYINGDEAD:
t->z += (24 << 8);
t->pos.Z += (24 << 8);
break;
case BLOODPOOL:
case FOOTPRINTS:
@ -237,7 +237,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case ATOMICHEALTH:
t->z -= (4 << 8);
t->pos.Z -= (4 << 8);
break;
case CRYSTALAMMO:
t->shade = bsin(PlayClock << 4, -10);
@ -309,7 +309,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
p = h->spr.yvel;
if (t->pal == 1) t->z -= (18 << 8);
if (t->pal == 1) t->pos.Z -= (18 << 8);
if (ps[p].over_shoulder_on > 0 && ps[p].newOwner == nullptr)
{
@ -359,8 +359,8 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
}
if (h->GetOwner())
newtspr->z = ps[p].pos.Z - (12 << 8);
else newtspr->z = h->spr.z - (51 << 8);
newtspr->pos.Z = ps[p].pos.Z - (12 << 8);
else newtspr->pos.Z = h->spr.pos.Z - (51 << 8);
if (ps[p].curr_weapon == HANDBOMB_WEAPON)
{
newtspr->xrepeat = 10;
@ -393,7 +393,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
}
if (t->sector()->lotag == 2) k += 1795 - 1405;
else if ((h->floorz - h->spr.z) > (64 << 8)) k += 60;
else if ((h->floorz - h->spr.pos.Z) > (64 << 8)) k += 60;
t->picnum += k;
t->pal = ps[p].palookup;
@ -403,7 +403,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
if (ps[p].on_crane == nullptr && (h->spr.sector()->lotag & 0x7ff) != 1)
{
l = h->spr.z - ps[p].GetActor()->floorz + (3 << 8);
l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
h->spr.yoffset = (int8_t)(l / (h->spr.yrepeat << 2));
else h->spr.yoffset = 0;
@ -432,8 +432,8 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
if (!h->GetOwner()) continue;
if (t->z > h->floorz && t->xrepeat < 32)
t->z = h->floorz;
if (t->pos.Z > h->floorz && t->xrepeat < 32)
t->pos.Z = h->floorz;
break;
@ -583,7 +583,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
daz = h->floorz;
if ((h->spr.z - daz) < (8 << 8) && ps[screenpeek].pos.Z < daz)
if ((h->spr.pos.Z - daz) < (8 << 8) && ps[screenpeek].pos.Z < daz)
{
auto shadowspr = &tsprite[spritesortcnt++];
*shadowspr = *t;
@ -595,7 +595,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
shadowspr->shade = 127;
shadowspr->cstat |= CSTAT_SPRITE_TRANSLUCENT;
shadowspr->z = daz;
shadowspr->pos.Z = daz;
shadowspr->pal = 4;
if (hw_models && md_tilehasmodel(t->picnum, t->pal) >= 0)
@ -629,7 +629,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
case LASERLINE:
if (!OwnerAc) break;
if (t->sector()->lotag == 2) t->pal = 8;
t->z = OwnerAc->spr.z - (3 << 8);
t->pos.Z = OwnerAc->spr.pos.Z - (3 << 8);
if (gs.lasermode == 2 && ps[screenpeek].heat_on == 0)
t->yrepeat = 0;
[[fallthrough]];
@ -659,7 +659,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
case BURNING2:
if (!OwnerAc) break;
if (OwnerAc->spr.picnum != TREE1 && OwnerAc->spr.picnum != TREE2)
t->z = t->sector()->floorz;
t->pos.Z = t->sector()->floorz;
t->shade = -127;
break;
case COOLEXPLOSION1:

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

@ -148,8 +148,8 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
{
t->pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].oposx, 16);
t->pos.Y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].oposy, 16);
t->z = interpolatedvalue(ps[h->spr.yvel].oposz, ps[h->spr.yvel].pos.Z, smoothratio);
t->z += PHEIGHT_RR;
t->pos.Z = interpolatedvalue(ps[h->spr.yvel].oposz, ps[h->spr.yvel].pos.Z, smoothratio);
t->pos.Z += PHEIGHT_RR;
h->spr.xrepeat = 24;
h->spr.yrepeat = 17;
}
@ -182,7 +182,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
h->spr.xrepeat = 24;
h->spr.yrepeat = 17;
if (h->spr.extra > 0)
t->z += (6 << 8);
t->pos.Z += (6 << 8);
break;
case BLOODPOOL:
case FOOTPRINTS:
@ -230,7 +230,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case ATOMICHEALTH:
t->z -= (4 << 8);
t->pos.Z -= (4 << 8);
break;
case CRYSTALAMMO:
t->shade = bsin(PlayClock << 4, -10);
@ -350,7 +350,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
p = h->spr.yvel;
if (t->pal == 1) t->z -= (18 << 8);
if (t->pal == 1) t->pos.Z -= (18 << 8);
if (ps[p].over_shoulder_on > 0 && ps[p].newOwner == nullptr)
{
@ -398,8 +398,8 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
}
if (h->GetOwner())
newtspr->z = ps[p].pos.Z - (12 << 8);
else newtspr->z = h->spr.z - (51 << 8);
newtspr->pos.Z = ps[p].pos.Z - (12 << 8);
else newtspr->pos.Z = h->spr.pos.Z - (51 << 8);
if (ps[p].curr_weapon == HANDBOMB_WEAPON)
{
newtspr->xrepeat = 10;
@ -436,7 +436,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
}
if (t->sector()->lotag == 2) k += 1795 - 1405;
else if ((h->floorz - h->spr.z) > (64 << 8)) k += 60;
else if ((h->floorz - h->spr.pos.Z) > (64 << 8)) k += 60;
t->picnum += k;
t->pal = ps[p].palookup;
@ -446,7 +446,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
if (ps[p].on_crane == nullptr && (h->spr.sector()->lotag & 0x7ff) != 1)
{
l = h->spr.z - ps[p].GetActor()->floorz + (3 << 8);
l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
h->spr.yoffset = (int8_t)(l / (h->spr.yrepeat << 2));
else h->spr.yoffset = 0;
@ -475,8 +475,8 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
if (!h->GetOwner()) continue;
if (t->z > h->floorz && t->xrepeat < 32)
t->z = h->floorz;
if (t->pos.Z > h->floorz && t->xrepeat < 32)
t->pos.Z = h->floorz;
if (ps[p].OnMotorcycle && p == screenpeek)
{
@ -737,7 +737,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
else
daz = h->floorz;
if ((h->spr.z - daz) < (8 << 8))
if ((h->spr.pos.Z - daz) < (8 << 8))
if (ps[screenpeek].pos.Z < daz)
{
auto shadowspr = &tsprite[spritesortcnt++];
@ -750,7 +750,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
shadowspr->shade = 127;
shadowspr->cstat |= CSTAT_SPRITE_TRANSLUCENT;
shadowspr->z = daz;
shadowspr->pos.Z = daz;
shadowspr->pal = 4;
if (hw_models && md_tilehasmodel(t->picnum, t->pal) >= 0)
@ -814,7 +814,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
case FIRE:
case BURNING:
if (OwnerAc && OwnerAc->spr.picnum != TREE1 && OwnerAc->spr.picnum != TREE2)
t->z = t->sector()->floorz;
t->pos.Z = t->sector()->floorz;
t->shade = -127;
break;
case WALLLIGHT3:

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

@ -1187,8 +1187,8 @@ void DoActor(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor,
else SetGameVarID(lVar2, act->spr.pos.Y, sActor, sPlayer);
break;
case ACTOR_Z:
if (bSet) act->spr.z = lValue;
else SetGameVarID(lVar2, act->spr.z, sActor, sPlayer);
if (bSet) act->spr.pos.Z = lValue;
else SetGameVarID(lVar2, act->spr.pos.Z, sActor, sPlayer);
break;
case ACTOR_CSTAT:
if (bSet) act->spr.cstat = ESpriteFlags::FromInt(lValue);
@ -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.z - (krand() & ((32 << 8) - 1)), actor->spr.sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.z, tosee->sector());
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());
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.z - (krand() & ((47 << 8))), actor->spr.sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.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->spr.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.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->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());
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.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->spr.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;
@ -2001,7 +2001,7 @@ int ParseState::parse(void)
case concmd_larrybird:
insptr++;
ps[g_p].pos.Z = ps[g_p].GetActor()->sector()->ceilingz;
ps[g_p].GetActor()->spr.z = ps[g_p].pos.Z;
ps[g_p].GetActor()->spr.pos.Z = ps[g_p].pos.Z;
break;
case concmd_destroyit:
insptr++;
@ -2190,7 +2190,7 @@ int ParseState::parse(void)
else s = (krand()%3);
auto l = EGS(g_ac->spr.sector(),
g_ac->spr.pos.X + (krand() & 255) - 128, g_ac->spr.pos.Y + (krand() & 255) - 128, g_ac->spr.z - (8 << 8) - (krand() & 8191),
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);
if (l)
@ -2247,7 +2247,7 @@ int ParseState::parse(void)
pickrandomspot(g_p);
g_ac->spr.pos.X = ps[g_p].bobposx = ps[g_p].oposx = ps[g_p].pos.X;
g_ac->spr.pos.Y = ps[g_p].bobposy = ps[g_p].oposy = ps[g_p].pos.Y;
g_ac->spr.z = ps[g_p].oposz = ps[g_p].pos.Z;
g_ac->spr.pos.Z = ps[g_p].oposz = ps[g_p].pos.Z;
g_ac->spr.backuppos();
updatesector(ps[g_p].pos.X, ps[g_p].pos.Y, &ps[g_p].cursector);
SetActor(ps[g_p].GetActor(), { ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z + gs.playerheight });
@ -2299,10 +2299,10 @@ int ParseState::parse(void)
parseifelse(ud.coop || numplayers > 2);
break;
case concmd_ifonmud:
parseifelse(abs(g_ac->spr.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->spr.sector()->floorz) < (32 << 8) && g_ac->spr.sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
break;
case concmd_ifonwater:
parseifelse( abs(g_ac->spr.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->spr.sector()->floorz) < (32<<8) && g_ac->spr.sector()->lotag == ST_1_ABOVE_WATER);
break;
case concmd_ifmotofast:
parseifelse(ps[g_p].MotoSpeed > 60);
@ -2424,7 +2424,7 @@ int ParseState::parse(void)
j = 1;
else if( (l& prunning) && s >= 8 && PlayerInput(g_p, SB_RUN) )
j = 1;
else if( (l& phigher) && ps[g_p].pos.Z < (g_ac->spr.z-(48<<8)) )
else if( (l& phigher) && ps[g_p].pos.Z < (g_ac->spr.pos.Z-(48<<8)) )
j = 1;
else if( (l& pwalkingback) && s <= -8 && !(PlayerInput(g_p, SB_RUN)) )
j = 1;
@ -2506,7 +2506,7 @@ int ParseState::parse(void)
if( g_ac->spr.sector()->lotag == 0 )
{
HitInfo hit{};
neartag({ g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.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->spr.sector(), g_ac->spr.ang, hit, 768, 1);
auto sectp = hit.hitSector;
if (sectp)
{
@ -2558,11 +2558,11 @@ int ParseState::parse(void)
break;
case concmd_iffloordistl:
insptr++;
parseifelse( (g_ac->floorz - g_ac->spr.z) <= ((*insptr)<<8));
parseifelse( (g_ac->floorz - g_ac->spr.pos.Z) <= ((*insptr)<<8));
break;
case concmd_ifceilingdistl:
insptr++;
parseifelse( ( g_ac->spr.z - g_ac->ceilingz ) <= ((*insptr)<<8));
parseifelse( ( g_ac->spr.pos.Z - g_ac->ceilingz ) <= ((*insptr)<<8));
break;
case concmd_palfrom:
insptr++;
@ -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.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->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()) )
{
ps[g_p].knee_incs = 1;
if(ps[g_p].weapon_pos == 0)

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

@ -101,7 +101,7 @@ inline int dist(DDukeActor* s1, DDukeActor* s2)
int vx, vy, vz;
vx = s1->spr.pos.X - s2->spr.pos.X;
vy = s1->spr.pos.Y - s2->spr.pos.Y;
vz = s1->spr.z - s2->spr.z;
vz = s1->spr.pos.Z - s2->spr.pos.Z;
return(FindDistance3D(vx, vy, vz));
}

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

@ -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.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->spr.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))
@ -327,10 +327,10 @@ DDukeActor* aim(DDukeActor* actor, int aang)
if (sdist > 512 && sdist < smax)
{
if (actor->spr.picnum == TILE_APLAYER)
a = (abs(Scale(act->spr.z - actor->spr.z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
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.z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (32 << 8), actor->spr.sector());
if (a && cans)
{
@ -542,7 +542,7 @@ void playerisdead(int snum, int psectlotag, int fz, int cz)
{
SetPlayerPal(p, PalEntry(63, 63, 0, 0));
p->pos.Z -= (16 << 8);
actor->spr.z -= (16 << 8);
actor->spr.pos.Z -= (16 << 8);
}
#if 0
if (ud.recstat == 1 && ud.multimode < 2)
@ -594,7 +594,7 @@ void playerisdead(int snum, int psectlotag, int fz, int cz)
}
else
{
actor->spr.z -= 512;
actor->spr.pos.Z -= 512;
actor->spr.zvel = -348;
}
@ -1030,7 +1030,7 @@ void shootbloodsplat(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
spawned->spr.ang = getangle(-delta.X, -delta.Y) + 512; // note the '-' sign here!
spawned->spr.pos.X = hit.hitpos.X;
spawned->spr.pos.Y = hit.hitpos.Y;
spawned->spr.z = hit.hitpos.Z;
spawned->spr.pos.Z = hit.hitpos.Z;
spawned->spr.cstat |= randomXFlip();
ssp(spawned, CLIPMASK0);
SetActor(spawned, spawned->spr.pos);

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

@ -200,7 +200,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.z = sz - 256;
spawned->spr.pos.Z = sz - 256;
spawned->spr.setsector(actor->spr.sector());
spawned->spr.cstat = CSTAT_SPRITE_YCENTER;
spawned->spr.ang = sa;
@ -244,7 +244,7 @@ static void shootknee(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
{
int x;
auto pactor = ps[findplayer(actor, &x)].GetActor();
zvel = ((pactor->spr.z - sz) << 8) / (x + 1);
zvel = ((pactor->spr.pos.Z - sz) << 8) / (x + 1);
sa = getangle(pactor->spr.pos.X - sx, pactor->spr.pos.Y - sy);
}
@ -264,7 +264,7 @@ static void shootknee(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
if (p >= 0)
{
auto k = spawn(knee, SMALLSMOKE);
if (k) k->spr.z -= (8 << 8);
if (k) k->spr.pos.Z -= (8 << 8);
S_PlayActorSound(KICK_HIT, knee);
}
@ -350,7 +350,7 @@ static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa
dal -= (8 << 8);
break;
}
zvel = ((aimed->spr.z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
@ -443,7 +443,7 @@ static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa
auto jib = spawn(spark, JIBS6);
if (jib)
{
jib->spr.z += (4 << 8);
jib->spr.pos.Z += (4 << 8);
jib->spr.xvel = 16;
jib->spr.xrepeat = jib->spr.yrepeat = 24;
jib->spr.ang += 64 - (krand() & 127);
@ -595,7 +595,7 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
@ -693,7 +693,7 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
if (aimed->spr.picnum != RECON)
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
@ -937,7 +937,7 @@ static void shootgrowspark(DDukeActor* actor, int p, int sx, int sy, int sz, int
dal -= (8 << 8);
break;
}
zvel = ((aimed->spr.z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
@ -1036,7 +1036,7 @@ void shoot_d(DDukeActor* actor, int atwith)
sa = actor->spr.ang;
sx = actor->spr.pos.X;
sy = actor->spr.pos.Y;
sz = actor->spr.z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
sz = actor->spr.pos.Z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
if (actor->spr.picnum != ROTATEGUN)
{
sz -= (7 << 8);
@ -1068,7 +1068,7 @@ void shoot_d(DDukeActor* actor, int atwith)
k->spr.setsector(sect);
k->spr.pos.X = sx;
k->spr.pos.Y = sy;
k->spr.z = sz;
k->spr.pos.Z = sz;
k->spr.ang = sa;
k->spr.xvel = 500;
k->spr.zvel = 0;
@ -1148,7 +1148,7 @@ void shoot_d(DDukeActor* actor, int atwith)
if (aimed)
{
dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1);
zvel = ((aimed->spr.z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
zvel = ((aimed->spr.pos.Z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@ -1998,7 +1998,7 @@ static void underwater(int snum, ESyncBits actions, int fz, int cz)
j->spr.pos.Y += bsin(p->angle.ang.asbuild() + 64 - (global_random & 128), -6);
j->spr.xrepeat = 3;
j->spr.yrepeat = 2;
j->spr.z = p->pos.Z + (8 << 8);
j->spr.pos.Z = p->pos.Z + (8 << 8);
}
}
}
@ -2031,7 +2031,7 @@ int operateTripbomb(int snum)
while ((act = it.Next()))
{
if (act->spr.picnum == TRIPBOMB &&
abs(act->spr.z - hit.hitpos.Z) < (12 << 8) && ((act->spr.pos.X - hit.hitpos.X) * (act->spr.pos.X - hit.hitpos.X) + (act->spr.pos.Y - hit.hitpos.Y) * (act->spr.pos.Y - hit.hitpos.Y)) < (290 * 290))
abs(act->spr.pos.Z - hit.hitpos.Z) < (12 << 8) && ((act->spr.pos.X - hit.hitpos.X) * (act->spr.pos.X - hit.hitpos.X) + (act->spr.pos.Y - hit.hitpos.Y) * (act->spr.pos.Y - hit.hitpos.Y)) < (290 * 290))
return 0;
}
@ -2217,7 +2217,7 @@ static void operateweapon(int snum, ESyncBits actions)
if (k == 15)
{
spawned->spr.yvel = 3;
spawned->spr.z += (8 << 8);
spawned->spr.pos.Z += (8 << 8);
}
k = hits(pact);
@ -2382,7 +2382,7 @@ static void operateweapon(int snum, ESyncBits actions)
j->spr.ang += 1024;
j->spr.ang &= 2047;
j->spr.xvel += 32;
j->spr.z += (3 << 8);
j->spr.pos.Z += (3 << 8);
ssp(j, CLIPMASK0);
}
}
@ -2780,7 +2780,7 @@ void processinput_d(int snum)
p->footprintcount = 0;
p->spritebridge = 1;
}
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.z - clz.actor()->spr.z) < (84 << 8))
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.pos.Z - clz.actor()->spr.pos.Z) < (84 << 8))
{
j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
p->posxv -= bcos(j, 4);

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

@ -99,7 +99,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
{
int x;
auto pspr = ps[findplayer(actor, &x)].GetActor();
zvel = ((pspr->spr.z - sz) << 8) / (x + 1);
zvel = ((pspr->spr.pos.Z - sz) << 8) / (x + 1);
sa = getangle(pspr->spr.pos.X - sx, pspr->spr.pos.Y - sy);
}
@ -153,7 +153,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
if (p >= 0)
{
auto k = spawn(wpn, SMALLSMOKE);
if (k) k->spr.z -= (8 << 8);
if (k) k->spr.pos.Z -= (8 << 8);
if (atwith == KNEE) S_PlayActorSound(KICK_HIT, wpn);
else if (isRRRA() && atwith == SLINGBLADE) S_PlayActorSound(260, wpn);
}
@ -216,7 +216,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (5 << 8);
zvel = ((aimed->spr.z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
@ -335,7 +335,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
spark->spr.xrepeat = spark->spr.yrepeat = 0;
if (l)
{
l->spr.z += (4 << 8);
l->spr.pos.Z += (4 << 8);
l->spr.xvel = 16;
l->spr.xrepeat = l->spr.yrepeat = 24;
l->spr.ang += 64 - (krand() & 127);
@ -509,7 +509,7 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
@ -624,7 +624,7 @@ static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
act90 = aimed;
}
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
if (aimed->spr.picnum != RECON)
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
@ -778,7 +778,7 @@ static void shootwhip(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
@ -850,7 +850,7 @@ void shoot_r(DDukeActor* actor, int atwith)
sa = actor->spr.ang;
sx = actor->spr.pos.X;
sy = actor->spr.pos.Y;
sz = actor->spr.z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
sz = actor->spr.pos.Z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
sz -= (7 << 8);
if (badguy(actor))
{
@ -897,7 +897,7 @@ void shoot_r(DDukeActor* actor, int atwith)
{
j->spr.xvel = 32;
j->spr.ang = actor->spr.ang;
j->spr.z -= (5 << 8);
j->spr.pos.Z -= (5 << 8);
}
break;
}
@ -908,7 +908,7 @@ void shoot_r(DDukeActor* actor, int atwith)
{
j->spr.xvel = 250;
j->spr.ang = actor->spr.ang;
j->spr.z -= (15 << 8);
j->spr.pos.Z -= (15 << 8);
}
break;
}
@ -2351,7 +2351,7 @@ static void underwater(int snum, ESyncBits actions, int fz, int cz)
j->spr.pos.Y += bsin(p->angle.ang.asbuild() + 64 - (global_random & 128) + 128, -6);
j->spr.xrepeat = 3;
j->spr.yrepeat = 2;
j->spr.z = p->pos.Z + (8 << 8);
j->spr.pos.Z = p->pos.Z + (8 << 8);
j->spr.cstat = CSTAT_SPRITE_TRANS_FLIP | CSTAT_SPRITE_TRANSLUCENT;
}
}
@ -2753,7 +2753,7 @@ static void operateweapon(int snum, ESyncBits actions, sectortype* psectp)
if (k == 15)
{
spawned->spr.yvel = 3;
spawned->spr.z += (8 << 8);
spawned->spr.pos.Z += (8 << 8);
}
k = hits(p->GetActor());
@ -2978,7 +2978,7 @@ static void operateweapon(int snum, ESyncBits actions, sectortype* psectp)
j->spr.ang += 1024;
j->spr.ang &= 2047;
j->spr.xvel += 32;
j->spr.z += (3 << 8);
j->spr.pos.Z += (3 << 8);
ssp(j, CLIPMASK0);
}
}
@ -3378,7 +3378,7 @@ void processinput_r(int snum)
while (auto act2 = it.Next())
{
if (act2->spr.picnum == RRTILE380)
if (act2->spr.z - (8 << 8) < p->pos.Z)
if (act2->spr.pos.Z - (8 << 8) < p->pos.Z)
psectlotag = 2;
}
}
@ -3471,7 +3471,7 @@ void processinput_r(int snum)
p->MotoSpeed -= p->MotoSpeed / 16.;
}
}
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.z - clz.actor()->spr.z) < (84 << 8))
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.pos.Z - clz.actor()->spr.pos.Z) < (84 << 8))
{
int j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
p->posxv -= bcos(j, 4);
@ -3484,9 +3484,9 @@ void processinput_r(int snum)
p->stairs = 10;
if ((actions & SB_CROUCH) && !p->OnMotorcycle)
{
cz = clz.actor()->spr.z;
cz = clz.actor()->spr.pos.Z;
chz.setNone();
fz = clz.actor()->spr.z + (4 << 8);
fz = clz.actor()->spr.pos.Z + (4 << 8);
}
}
else

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

@ -128,7 +128,7 @@ void DoSpawn(struct player_struct *p, int snum)
j->spr.ang += 1024;
j->spr.ang &= 2047;
j->spr.xvel += 32;
j->spr.z += (3<<8);
j->spr.pos.Z += (3<<8);
ssp(j,CLIPMASK0);
}
@ -361,7 +361,7 @@ void operateweapon_ww(int snum, ESyncBits actions)
if (k == 15)
{
j->spr.yvel = 3;
j->spr.z += (8 << 8);
j->spr.pos.Z += (8 << 8);
}
k = hits(p->GetActor());

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

@ -583,7 +583,7 @@ void resetpspritevars(int g)
po[numplayersprites].ox = act->spr.pos.X;
po[numplayersprites].oy = act->spr.pos.Y;
po[numplayersprites].oz = act->spr.z;
po[numplayersprites].oz = act->spr.pos.Z;
po[numplayersprites].oa = act->spr.ang;
po[numplayersprites].os = act->spr.sector();
@ -627,7 +627,7 @@ void resetpspritevars(int g)
ps[j].bobposx = ps[j].oposx = ps[j].pos.X = act->spr.pos.X;
ps[j].bobposy = ps[j].oposy = ps[j].pos.Y = act->spr.pos.Y;
ps[j].oposz = ps[j].pos.Z = act->spr.z;
ps[j].oposz = ps[j].pos.Z = act->spr.pos.Z;
act->spr.backuppos();
ps[j].angle.oang = ps[j].angle.ang = buildang(act->spr.ang);

4
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->pos.X, camera->pos.Y, camera->z, ang.asq16(), IntToFixed(camera->shade), camera->sector(), false); // why 'shade'...?
renderDrawRoomsQ16(camera->pos.X, camera->pos.Y, camera->pos.Z, ang.asq16(), IntToFixed(camera->shade), camera->sector(), false); // why 'shade'...?
fi.animatesprites(pm_tsprite, pm_spritesortcnt, camera->pos.X, camera->pos.Y, ang.asbuild(), (int)smoothratio);
renderDrawMasks();
}
@ -290,7 +290,7 @@ void displayrooms(int snum, double smoothratio)
cang = buildang(interpolatedangle(ud.cameraactor->tempang, s->ang, smoothratio));
auto bh = buildhoriz(s->yvel);
renderView(s, s->sector(), s->pos.X, s->pos.Y, s->z - (4 << 8), cang, bh, buildang(0), (int)smoothratio);
renderView(s, s->sector(), s->pos.X, s->pos.Y, s->pos.Z - (4 << 8), cang, bh, buildang(0), (int)smoothratio);
}
else
{

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

@ -360,7 +360,7 @@ void doanimations(void)
if (act->spr.statnum != STAT_EFFECTOR)
{
act->spr.backupz();
act->spr.z += v;
act->spr.pos.Z += v;
act->floorz = dasectp->floorz + v;
}
}
@ -607,7 +607,7 @@ static void handle_st15(sectortype* sptr, DDukeActor* actor)
}
else
{
if (sptr->floorz > a2->spr.z)
if (sptr->floorz > a2->spr.pos.Z)
activatewarpelevators(a2, -1);
else
activatewarpelevators(a2, 1);
@ -720,7 +720,7 @@ REDODOOR:
{
if (a2->spr.statnum == 3 && a2->spr.lotag == 9)
{
j = a2->spr.z;
j = a2->spr.pos.Z;
break;
}
}

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

@ -199,7 +199,7 @@ void operaterespawns_d(int low)
auto star = spawn(act, TRANSPORTERSTAR);
if (star)
{
star->spr.z -= (32 << 8);
star->spr.pos.Z -= (32 << 8);
act->spr.extra = 66 - 12; // Just a way to killit
}
@ -1110,7 +1110,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
case HEAVYHBOMB:
for (k = 0; k < 64; k++)
{
auto j = EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
auto j = 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);
j->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.z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
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);
S_PlayActorSound(GLASS_HEAVYBREAK, targ);
deletesprite(targ);
break;
@ -1244,7 +1244,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
if (targ->spr.cstat & CSTAT_SPRITE_BLOCK)
{
S_PlayActorSound(GLASS_BREAKING, targ);
targ->spr.z += 16 << 8;
targ->spr.pos.Z += 16 << 8;
targ->spr.cstat = 0;
lotsofglass(targ, nullptr, 5);
}
@ -1311,7 +1311,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
}
{
auto j = spawn(targ, STEAM);
if (j) j->spr.z = targ->spr.sector()->floorz - (32 << 8);
if (j) j->spr.pos.Z = targ->spr.sector()->floorz - (32 << 8);
}
break;
@ -1397,7 +1397,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
{
if (proj->spr.pal == 6)
spawned->spr.pal = 6;
spawned->spr.z += (4 << 8);
spawned->spr.pos.Z += (4 << 8);
spawned->spr.xvel = 16;
spawned->spr.xrepeat = spawned->spr.yrepeat = 24;
spawned->spr.ang += 32 - (krand() & 63);

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

@ -313,7 +313,7 @@ void operaterespawns_r(int low)
if (badguypic(act->spr.hitag) && ud.monsters_off) break;
auto star = spawn(act, TRANSPORTERSTAR);
if (star) star->spr.z -= (32 << 8);
if (star) star->spr.pos.Z -= (32 << 8);
act->spr.extra = 66 - 12; // Just a way to killit
break;
@ -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.z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
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);
}
return;
}
@ -967,7 +967,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
{
z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.z - (32 << 8) + (krand() & ((64 << 8) - 1));
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);
}
@ -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.z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
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);
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 j = EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
auto j = 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);
j->spr.pal = 8;
}
@ -2323,7 +2323,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
}
{
auto j = spawn(targ, STEAM);
if (j) j->spr.z = targ->spr.sector()->floorz - (32 << 8);
if (j) j->spr.pos.Z = targ->spr.sector()->floorz - (32 << 8);
}
break;
@ -2369,7 +2369,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
{
if (proj->spr.pal == 6)
spawned->spr.pal = 6;
spawned->spr.z += (4 << 8);
spawned->spr.pos.Z += (4 << 8);
spawned->spr.xvel = 16;
spawned->spr.xrepeat = spawned->spr.yrepeat = 24;
spawned->spr.ang += 32 - (krand() & 63);

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

@ -276,7 +276,7 @@ static int GetPositionInfo(DDukeActor* actor, int soundNum, sectortype* sect,
sndist += dist_adjust;
if (sndist < 0) sndist = 0;
if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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->spr.sector()))
sndist += sndist >> (isRR() ? 2 : 5);
// Here the sound distance was clamped to a minimum of 144*4.

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

@ -61,7 +61,7 @@ DDukeActor* EGS(sectortype* whatsectp, int s_x, int s_y, int s_z, int s_pn, int8
act->spr.pos.X = s_x;
act->spr.pos.Y = s_y;
act->spr.z = s_z;
act->spr.pos.Z = s_z;
act->spr.cstat = 0;
act->spr.picnum = s_pn;
act->spr.shade = s_s;
@ -219,7 +219,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.z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
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);
if (spawned)
{
spawned->picnum = actj->spr.picnum;
@ -304,7 +304,7 @@ void spawntransporter(DDukeActor *actj, DDukeActor* act, bool beam)
{
act->spr.xrepeat = 31;
act->spr.yrepeat = 1;
act->spr.z = actj->spr.sector()->floorz - (isRR() ? PHEIGHT_RR : PHEIGHT_DUKE);
act->spr.pos.Z = actj->spr.sector()->floorz - (isRR() ? PHEIGHT_RR : PHEIGHT_DUKE);
}
else
{
@ -318,7 +318,7 @@ void spawntransporter(DDukeActor *actj, DDukeActor* act, bool beam)
act->spr.xrepeat = 48;
act->spr.yrepeat = 64;
if (actj->spr.statnum == 10 || badguy(actj))
act->spr.z -= (32 << 8);
act->spr.pos.Z -= (32 << 8);
}
}
@ -410,7 +410,7 @@ void initfootprint(DDukeActor* actj, DDukeActor* act)
act->spr.ang = actj->spr.ang;
}
act->spr.z = sect->floorz;
act->spr.pos.Z = sect->floorz;
if (sect->lotag != 1 && sect->lotag != 2)
act->spr.xrepeat = act->spr.yrepeat = 32;
@ -437,13 +437,13 @@ void initshell(DDukeActor* actj, DDukeActor* act, bool isshell)
a = ps[snum].angle.ang.asbuild() - (krand() & 63) + 8; //Fine tune
t[0] = krand() & 1;
act->spr.z = (3 << 8) + ps[snum].pyoff + ps[snum].pos.Z - (ps[snum].horizon.sum().asq16() >> 12) + (!isshell ? (3 << 8) : 0);
act->spr.pos.Z = (3 << 8) + ps[snum].pyoff + ps[snum].pos.Z - (ps[snum].horizon.sum().asq16() >> 12) + (!isshell ? (3 << 8) : 0);
act->spr.zvel = -(krand() & 255);
}
else
{
a = act->spr.ang;
act->spr.z = actj->spr.z - gs.playerheight + (3 << 8);
act->spr.pos.Z = actj->spr.pos.Z - gs.playerheight + (3 << 8);
}
act->spr.pos.X = actj->spr.pos.X + bcos(a, -7);
@ -482,13 +482,13 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
act->spr.cstat |= CSTAT_SPRITE_BLOCK_ALL | CSTAT_SPRITE_ONE_SIDE;
act->spr.picnum += 2;
act->spr.z = sect->ceilingz + (48 << 8);
act->spr.pos.Z = sect->ceilingz + (48 << 8);
t[4] = cranes.Reserve(1);
auto& apt = cranes[t[4]];
apt.x = act->spr.pos.X;
apt.y = act->spr.pos.Y;
apt.z = act->spr.z;
apt.z = act->spr.pos.Z;
apt.poleactor = nullptr;
DukeStatIterator it(STAT_DEFAULT);
@ -508,7 +508,7 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
act->spr.pos.X = act->spr.pos.X;
act->spr.pos.Y = act->spr.pos.Y;
act->spr.z = act->spr.z;
act->spr.pos.Z = act->spr.pos.Z;
act->spr.shade = act->spr.shade;
SetActor(act, act->spr.pos);
@ -536,17 +536,17 @@ void initwaterdrip(DDukeActor* actj, DDukeActor* actor)
if (actj->spr.pal != 1)
{
actor->spr.pal = 2;
actor->spr.z -= (18 << 8);
actor->spr.pos.Z -= (18 << 8);
}
else actor->spr.z -= (13 << 8);
else actor->spr.pos.Z -= (13 << 8);
actor->spr.ang = getangle(ps[connecthead].pos.X - actor->spr.pos.X, ps[connecthead].pos.Y - actor->spr.pos.Y);
actor->spr.xvel = 48 - (krand() & 31);
ssp(actor, CLIPMASK0);
}
else if (!actj)
{
actor->spr.z += (4 << 8);
t[0] = actor->spr.z;
actor->spr.pos.Z += (4 << 8);
t[0] = actor->spr.pos.Z;
if (!isRR()) t[1] = krand() & 127;
}
actor->spr.xrepeat = 24;
@ -638,7 +638,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
}
else actor->SetOwner(actor);
t[4] = sectp->floorz == actor->spr.z;
t[4] = sectp->floorz == actor->spr.pos.Z;
actor->spr.cstat = 0;
ChangeActorStat(actor, STAT_TRANSPORT);
return;
@ -652,13 +652,13 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
{
t[1] = sectp->ceilingz;
if (actor->spr.pal)
sectp->ceilingz = actor->spr.z;
sectp->ceilingz = actor->spr.pos.Z;
}
else
{
t[1] = sectp->floorz;
if (actor->spr.pal)
sectp->floorz = actor->spr.z;
sectp->floorz = actor->spr.pos.Z;
}
actor->spr.hitag <<= 2;
@ -676,11 +676,11 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
else
t[4] = sectp->ceilingz;
sectp->ceilingz = actor->spr.z;
sectp->ceilingz = actor->spr.pos.Z;
StartInterpolation(sectp, Interp_Sect_Ceilingz);
break;
case SE_35:
sectp->ceilingz = actor->spr.z;
sectp->ceilingz = actor->spr.pos.Z;
break;
case SE_27_DEMO_CAM:
if (ud.recstat == 1)
@ -704,18 +704,18 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
t[0] = sectp->ceilingz;
t[1] = sectp->floorz;
bool ceiling = (abs(t[0] - actor->spr.z) < abs(t[1] - actor->spr.z));
bool ceiling = (abs(t[0] - actor->spr.pos.Z) < abs(t[1] - actor->spr.pos.Z));
actor->spriteextra = ceiling;
if (actor->spr.ang == 512)
{
if (ceiling)
sectp->ceilingz = actor->spr.z;
sectp->ceilingz = actor->spr.pos.Z;
else
sectp->floorz = actor->spr.z;
sectp->floorz = actor->spr.pos.Z;
}
else
sectp->ceilingz = sectp->floorz = actor->spr.z;
sectp->ceilingz = sectp->floorz = actor->spr.pos.Z;
if (sectp->ceilingstat & CSTAT_SECTOR_SKY)
{
@ -840,7 +840,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_31_FLOOR_RISE_FALL:
t[1] = sectp->floorz;
// t[2] = actor->spr.hitag;
if (actor->spr.ang != 1536) sectp->floorz = actor->spr.z;
if (actor->spr.ang != 1536) sectp->floorz = actor->spr.pos.Z;
for (auto& wal : wallsofsector(sectp))
if (wal.hitag == 0) wal.hitag = 9999;
@ -851,7 +851,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_32_CEILING_RISE_FALL:
t[1] = sectp->ceilingz;
t[2] = actor->spr.hitag;
if (actor->spr.ang != 1536) sectp->ceilingz = actor->spr.z;
if (actor->spr.ang != 1536) sectp->ceilingz = actor->spr.pos.Z;
for (auto& wal : wallsofsector(sectp))
if (wal.hitag == 0) wal.hitag = 9999;
@ -874,7 +874,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_9_DOWN_OPEN_DOOR_LIGHTS:
if (sectp->lotag &&
labs(sectp->ceilingz - actor->spr.z) > 1024)
labs(sectp->ceilingz - actor->spr.pos.Z) > 1024)
sectp->lotag |= 32768; //If its open
[[fallthrough]];
case SE_8_UP_OPEN_DOOR_LIGHTS:
@ -1082,7 +1082,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.z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
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);
}
return;
}
@ -1105,7 +1105,7 @@ void lotsofglass(DDukeActor *actor, walltype* wal, int n)
{
z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.z - (32 << 8) + (krand() & ((64 << 8) - 1));
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);
}
@ -1123,7 +1123,7 @@ void spriteglass(DDukeActor* actor, int n)
for (int j = n; j > 0; j--)
{
int a = krand() & 2047;
int z = actor->spr.z - ((krand() & 16) << 8);
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);
if (k) k->spr.pal = actor->spr.pal;
}
@ -1175,7 +1175,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.z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
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);
if (k) k->spr.pal = krand() & 15;
}
return;
@ -1194,7 +1194,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
updatesector(x1, y1, &sect);
z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.z - (32 << 8) + (krand() & ((64 << 8) - 1));
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);
if (k) k->spr.pal = krand() & 7;

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

@ -161,11 +161,11 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
{
if (actj->spr.sector()->lotag == 2)
{
act->spr.z = getceilzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8);
act->spr.pos.Z = getceilzofslopeptr(act->spr.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.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -206,7 +206,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case TONGUE:
if (actj)
act->spr.ang = actj->spr.ang;
act->spr.z -= PHEIGHT_DUKE;
act->spr.pos.Z -= PHEIGHT_DUKE;
act->spr.zvel = 256 - (krand() & 511);
act->spr.xvel = 64 - (krand() & 127);
ChangeActorStat(act, 4);
@ -266,7 +266,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case BLOOD:
act->spr.xrepeat = act->spr.yrepeat = 16;
act->spr.z -= (26 << 8);
act->spr.pos.Z -= (26 << 8);
if (actj && actj->spr.pal == 6)
act->spr.pal = 6;
ChangeActorStat(act, STAT_MISC);
@ -299,9 +299,9 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (act->spr.picnum == LAVAPOOL) // Twentieth Anniversary World Tour
{
int fz = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
if (fz != act->spr.z)
act->spr.z = fz;
act->spr.z -= 200;
if (fz != act->spr.pos.Z)
act->spr.pos.Z = fz;
act->spr.pos.Z -= 200;
}
[[fallthrough]];
@ -318,7 +318,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_ALIGNMENT_WALL;
act->spr.xrepeat = 7 + (krand() & 7);
act->spr.yrepeat = 7 + (krand() & 7);
act->spr.z -= (16 << 8);
act->spr.pos.Z -= (16 << 8);
if (actj && actj->spr.pal == 6)
act->spr.pal = 6;
insertspriteq(act);
@ -531,7 +531,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (act->spr.picnum == RESPAWNMARKERRED)
{
act->spr.xrepeat = act->spr.yrepeat = 24;
if (actj) act->spr.z = actj->floorz; // -(1<<4);
if (actj) act->spr.pos.Z = actj->floorz; // -(1<<4);
}
else
{
@ -643,15 +643,15 @@ 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);
if (act->spr.z > x - (12 << 8))
act->spr.z = x - (12 << 8);
if (act->spr.pos.Z > x - (12 << 8))
act->spr.pos.Z = x - (12 << 8);
}
if (act->spr.picnum == ONFIRE)
{
act->spr.pos.X += krand() % 256 - 128;
act->spr.pos.Y += krand() % 256 - 128;
act->spr.z -= krand() % 10240;
act->spr.pos.Z -= krand() % 10240;
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
}
@ -685,7 +685,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
}
case WATERBUBBLE:
if (actj && actj->spr.picnum == APLAYER)
act->spr.z -= (16 << 8);
act->spr.pos.Z -= (16 << 8);
if (act->spr.picnum == WATERBUBBLE)
{
if (actj)
@ -726,7 +726,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case TOUCHPLATE:
t[2] = sectp->floorz;
if (sectp->lotag != 1 && sectp->lotag != 2)
sectp->floorz = act->spr.z;
sectp->floorz = act->spr.pos.Z;
if (!isWorldTour())
{
if (act->spr.pal && ud.multimode > 1)
@ -1006,7 +1006,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
act->spr.lotag = 0;
act->spr.z -= (32 << 8);
act->spr.pos.Z -= (32 << 8);
act->spr.zvel = -1024;
ssp(act, CLIPMASK0);
if (krand() & 4) act->spr.cstat |= CSTAT_SPRITE_XFLIP;

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

@ -213,11 +213,11 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
{
if (actj->spr.sector()->lotag == 2)
{
act->spr.z = getceilzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8);
act->spr.pos.Z = getceilzofslopeptr(act->spr.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.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
act->spr.pos.Z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -285,7 +285,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case TONGUE:
if (actj)
act->spr.ang = actj->spr.ang;
act->spr.z -= PHEIGHT_RR;
act->spr.pos.Z -= PHEIGHT_RR;
act->spr.zvel = 256 - (krand() & 511);
act->spr.xvel = 64 - (krand() & 127);
ChangeActorStat(act, 4);
@ -325,7 +325,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case BLOOD:
act->spr.xrepeat = act->spr.yrepeat = 4;
act->spr.z -= (26 << 8);
act->spr.pos.Z -= (26 << 8);
ChangeActorStat(act, STAT_MISC);
break;
case BLOODPOOL:
@ -354,7 +354,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_ALIGNMENT_WALL;
act->spr.xrepeat = 7 + (krand() & 7);
act->spr.yrepeat = 7 + (krand() & 7);
act->spr.z -= (16 << 8);
act->spr.pos.Z -= (16 << 8);
if (actj && actj->spr.pal == 6)
act->spr.pal = 6;
insertspriteq(act);
@ -555,7 +555,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (act->spr.picnum == RESPAWNMARKERRED)
{
act->spr.xrepeat = act->spr.yrepeat = 8;
if (actj) act->spr.z = actj->floorz;
if (actj) act->spr.pos.Z = actj->floorz;
}
else
{
@ -651,8 +651,8 @@ 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);
if (act->spr.z > x - (12 << 8))
act->spr.z = x - (12 << 8);
if (act->spr.pos.Z > x - (12 << 8))
act->spr.pos.Z = x - (12 << 8);
}
ChangeActorStat(act, STAT_MISC);
@ -685,7 +685,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
}
case WATERBUBBLE:
if (actj && actj->spr.picnum == APLAYER)
act->spr.z -= (16 << 8);
act->spr.pos.Z -= (16 << 8);
if (act->spr.picnum == WATERBUBBLE)
{
if (actj)
@ -718,7 +718,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case TOUCHPLATE:
t[2] = sectp->floorz;
if (sectp->lotag != 1 && sectp->lotag != 2)
sectp->floorz = act->spr.z;
sectp->floorz = act->spr.pos.Z;
if (act->spr.pal && ud.multimode > 1)
{
act->spr.xrepeat = act->spr.yrepeat = 0;
@ -908,7 +908,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_TRANS_FLIP;
act->spr.pos.X += (krand() & 2047) - 1024;
act->spr.pos.Y += (krand() & 2047) - 1024;
act->spr.z += (krand() & 2047) - 1024;
act->spr.pos.Z += (krand() & 2047) - 1024;
break;
case MAMA:
if (act->spr.pal == 30)
@ -1158,7 +1158,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.lotag = 0;
if (act->spr.picnum != BOWLINGBALLSPRITE)
{
act->spr.z -= (32 << 8);
act->spr.pos.Z -= (32 << 8);
act->spr.zvel = -(4 << 8);
}
else

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

@ -70,7 +70,7 @@ DExhumedActor* BuildAnim(DExhumedActor* pActor, int val, int val2, int x, int y,
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = 0;
if (nFlag & 4)
@ -144,7 +144,7 @@ void AIAnim::Tick(RunListEvent* ev)
auto pSpriteB = &pIgniter->s();
pSprite->pos.X = pSpriteB->pos.X;
pSprite->pos.Y = pSpriteB->pos.Y;
pSprite->z = pSpriteB->z;
pSprite->pos.Z = pSpriteB->pos.Z;
if (pSpriteB->sector() != pSprite->sector())
{
@ -246,12 +246,12 @@ void BuildExplosion(DExhumedActor* pActor)
{
edx = 75;
}
else if (pSprite->z == pSprite->sector()->floorz)
else if (pSprite->pos.Z == pSprite->sector()->floorz)
{
edx = 34;
}
BuildAnim(nullptr, edx, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->xrepeat, 4);
BuildAnim(nullptr, edx, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), pSprite->xrepeat, 4);
}
void BuildSplash(DExhumedActor* actor, sectortype* pSector)

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

@ -64,7 +64,7 @@ void BuildAnubis(DExhumedActor* ap, int x, int y, int z, sectortype* pSector, in
sp->pos.X = x;
sp->pos.Y = y;
sp->z = z;
sp->pos.Z = z;
sp->cstat = CSTAT_SPRITE_BLOCK_ALL;
sp->xoffset = 0;
sp->shade = -12;
@ -221,8 +221,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(sp->pos.X, sp->pos.Y, sp->z - GetActorHeight(ap), sp->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.z - GetActorHeight(pTarget), pTarget->spr.sector()))
if (cansee(sp->pos.X, sp->pos.Y, sp->pos.Z - GetActorHeight(ap), sp->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->spr.sector()))
{
sp->xvel = 0;
sp->yvel = 0;
@ -407,7 +407,7 @@ void AIAnubis::Damage(RunListEvent* ev)
pDrumSprite->pos.X = sp->pos.X;
pDrumSprite->pos.Y = sp->pos.Y;
pDrumSprite->z = pDrumSprite->sector()->floorz;
pDrumSprite->pos.Z = pDrumSprite->sector()->floorz;
pDrumSprite->xrepeat = 40;
pDrumSprite->yrepeat = 40;
pDrumSprite->shade = -64;
@ -431,7 +431,7 @@ void AIAnubis::Damage(RunListEvent* ev)
sp->xvel = 0;
sp->yvel = 0;
sp->zvel = 0;
sp->z = sp->sector()->floorz;
sp->pos.Z = sp->sector()->floorz;
sp->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
ap->nHealth = 0;

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

@ -91,11 +91,11 @@ void AIBubble::Tick(RunListEvent* ev)
pActor->nFrame = 0;
}
pSprite->z += pSprite->zvel;
pSprite->pos.Z += pSprite->zvel;
auto pSector = pSprite->sector();
if (pSprite->z <= pSector->ceilingz)
if (pSprite->pos.Z <= pSector->ceilingz)
{
auto pSectAbove = pSector->pAbove;

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

@ -168,7 +168,7 @@ void IgniteSprite(DExhumedActor* pActor)
pSprite->hitag += 2;
auto pAnimActor = BuildAnim(nullptr, 38, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 40, 20);
auto pAnimActor = BuildAnim(nullptr, 38, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), 40, 20);
if (pAnimActor)
{
@ -323,7 +323,7 @@ int MoveBullet(int nBullet)
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z; // ebx
int z = pSprite->pos.Z; // ebx
int nSectFlag = pSprite->sector()->Flag;
int x2, y2, z2;
@ -364,7 +364,7 @@ int MoveBullet(int nBullet)
pSprite->xrepeat = 40;
pSprite->yrepeat = 40;
pSprite->shade = 0;
pSprite->z += 512;
pSprite->pos.Z += 512;
}
}
else
@ -382,7 +382,7 @@ MOVEEND:
nVal = 1;
x2 = pSprite->pos.X;
y2 = pSprite->pos.Y;
z2 = pSprite->z;
z2 = pSprite->pos.Z;
pHitSect = pSprite->sector();
#if 0
@ -432,7 +432,7 @@ MOVEEND:
if (nVal == 0 && nType != 15 && nType != 3)
{
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 0);
if (pSprite->pal != 5) {
pSprite->pal = 1;
@ -449,7 +449,7 @@ MOVEEND:
auto hitsprite = &hitactor->s();
x2 = hitsprite->pos.X;
y2 = hitsprite->pos.Y;
z2 = hitsprite->z - (GetActorHeight(hitactor) >> 1);
z2 = hitsprite->pos.Z - (GetActorHeight(hitactor) >> 1);
pHitSect = hitsprite->sector();
}
else
@ -519,7 +519,7 @@ HITSPRITE:
{
pSprite->pos.X = x2;
pSprite->pos.Y = y2;
pSprite->z = z2;
pSprite->pos.Z = z2;
BuildSplash(pActor, pHitSect);
}
else
@ -549,7 +549,7 @@ HITSPRITE:
{
pSprite->pos.X = x2;
pSprite->pos.Y = y2;
pSprite->z = z2;
pSprite->pos.Z = z2;
ChangeActorSect(pActor, pHitSect);
}
@ -562,7 +562,7 @@ HITSPRITE:
nRadialBullet = -1;
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 128);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 128);
}
}
}
@ -605,7 +605,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
assert(pTargetSprite->sector());
BulletHitsSprite(&sBullet, pActor, pTarget, pTargetSprite->pos.X, pTargetSprite->pos.Y, pTargetSprite->z - (nHeight >> 1), pTargetSprite->sector());
BulletHitsSprite(&sBullet, pActor, pTarget, pTargetSprite->pos.X, pTargetSprite->pos.Y, pTargetSprite->pos.Z - (nHeight >> 1), pTargetSprite->sector());
DeleteActor(sBullet.pActor);
return nullptr;
}
@ -643,7 +643,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
pBulletSprite->pos.X = pSprite->pos.X;
pBulletSprite->pos.Y = pSprite->pos.Y;
pBulletSprite->z = pSprite->z;
pBulletSprite->pos.Z = pSprite->pos.Z;
Bullet *pBullet = &BulletList[nBullet];
@ -713,18 +713,18 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
pBullet->nRunRec = runlist_AddRunRec(pBulletSprite->lotag - 1, nBullet, 0xB0000);
pBullet->nRunRec2 = runlist_AddRunRec(NewRun, nBullet, 0xB0000);
pBullet->nDoubleDamage = nDoubleDamage;
pBulletSprite->z += nZOffset;
pBulletSprite->pos.Z += nZOffset;
pBulletSprite->backuppos();
int var_18 = 0;
pSector = pBulletSprite->sector();
while (pBulletSprite->z < pSector->ceilingz)
while (pBulletSprite->pos.Z < pSector->ceilingz)
{
if (pSector->pAbove == nullptr)
{
pBulletSprite->z = pSector->ceilingz;
pBulletSprite->pos.Z = pSector->ceilingz;
break;
}
@ -757,7 +757,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
nHeight -= nHeight >> 1;
}
int var_20 = pTargetSprite->z - nHeight;
int var_20 = pTargetSprite->pos.Z - nHeight;
int x, y;
@ -797,7 +797,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
int nSqrt = lsqrt(y*y + x*x);
if ((unsigned int)nSqrt > 0)
{
var_18 = ((var_20 - pBulletSprite->z) * pBulletInfo->field_4) / nSqrt;
var_18 = ((var_20 - pBulletSprite->pos.Z) * pBulletInfo->field_4) / nSqrt;
}
else
{
@ -842,7 +842,7 @@ void AIBullet::Tick(RunListEvent* ev)
if (nFlag & 0x80)
{
BuildAnim(nullptr, 45, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->xrepeat, 0);
BuildAnim(nullptr, 45, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), pSprite->xrepeat, 0);
}
BulletList[nBullet].nFrame++;

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

@ -208,8 +208,8 @@ void DoRedAlert(int nVal)
if (nVal)
{
auto spri = &ac->s();
PlayFXAtXYZ(StaticSound[kSoundAlarm], spri->pos.X, spri->pos.Y, spri->z);
AddFlash(spri->sector(), spri->pos.X, spri->pos.Y, spri->z, 192);
PlayFXAtXYZ(StaticSound[kSoundAlarm], spri->pos.X, spri->pos.Y, spri->pos.Z);
AddFlash(spri->sector(), spri->pos.X, spri->pos.Y, spri->pos.Z, 192);
}
}
}

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

@ -52,7 +52,7 @@ void BuildFishLimb(DExhumedActor* pActor, int anim)
pSprite2->pos.X = pSprite->pos.X;
pSprite2->pos.Y = pSprite->pos.Y;
pSprite2->z = pSprite->z;
pSprite2->pos.Z = pSprite->pos.Z;
pSprite2->cstat = 0;
pSprite2->shade = -12;
pSprite2->pal = 0;
@ -101,17 +101,17 @@ void AIFishLimb::Tick(RunListEvent* ev)
{
pActor->nFrame = 0;
if (RandomBit()) {
BuildBlood(pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector());
BuildBlood(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector());
}
}
int FloorZ = pSprite->sector()->floorz;
if (FloorZ <= pSprite->z)
if (FloorZ <= pSprite->pos.Z)
{
pSprite->z += 256;
pSprite->pos.Z += 256;
if ((pSprite->z - FloorZ) > 25600)
if ((pSprite->pos.Z - FloorZ) > 25600)
{
pSprite->zvel = 0;
runlist_DoSubRunRec(pSprite->owner);
@ -119,7 +119,7 @@ void AIFishLimb::Tick(RunListEvent* ev)
runlist_SubRunRec(pSprite->hitag);
DeleteActor(pActor);
}
else if ((pSprite->z - FloorZ) > 0)
else if ((pSprite->pos.Z - FloorZ) > 0)
{
pSprite->zvel = 1024;
}
@ -159,14 +159,14 @@ void BuildFish(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->pos.Y;
z = pSprite->z;
z = pSprite->pos.Z;
nAngle = pSprite->ang;
ChangeActorStat(pActor, 103);
}
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
pSprite->clipdist = 80;
@ -293,7 +293,7 @@ void AIFish::Damage(RunListEvent* ev)
BuildFishLimb(pActor, i);
}
PlayFXAtXYZ(StaticSound[kSound40], pSprite->pos.X, pSprite->pos.Y, pSprite->z);
PlayFXAtXYZ(StaticSound[kSound40], pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z);
DestroyFish(pActor);
}
else
@ -361,7 +361,7 @@ void AIFish::Tick(RunListEvent* ev)
pActor->nAction = 2;
pActor->nFrame = 0;
int nAngle = GetMyAngle(pTargetActor->spr.pos.X - pSprite->pos.X, pTargetActor->spr.z - pSprite->z);
int nAngle = GetMyAngle(pTargetActor->spr.pos.X - pSprite->pos.X, pTargetActor->spr.pos.Z - pSprite->pos.Z);
pSprite->zvel = bsin(nAngle, -5);
pActor->nCount = RandomSize(6) + 90;
@ -392,7 +392,7 @@ void AIFish::Tick(RunListEvent* ev)
PlotCourseToSprite(pActor, pTargetActor);
int nHeight = GetActorHeight(pActor) >> 1;
int z = abs(pTargetActor->spr.z - pSprite->z);
int z = abs(pTargetActor->spr.pos.Z - pSprite->pos.Z);
if (z <= nHeight)
{
@ -405,7 +405,7 @@ void AIFish::Tick(RunListEvent* ev)
pSprite->yvel = 0;
}
pSprite->zvel = (pTargetActor->spr.z - pSprite->z) >> 3;
pSprite->zvel = (pTargetActor->spr.pos.Z - pSprite->pos.Z) >> 3;
}
break;
}
@ -436,7 +436,7 @@ void AIFish::Tick(RunListEvent* ev)
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pSector =pSprite->sector();
// loc_2EF54
@ -447,7 +447,7 @@ void AIFish::Tick(RunListEvent* ev)
ChangeActorSect(pActor, pSector);
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
IdleFish(pActor, 0);
return;

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

@ -63,7 +63,7 @@ void ThrowGrenade(int nPlayer, int, int, int ecx, int push1)
pGrenadeSprite->pos.X = pPlayerSprite->pos.X;
pGrenadeSprite->pos.Y = pPlayerSprite->pos.Y;
pGrenadeSprite->z = pPlayerSprite->z;
pGrenadeSprite->pos.Z = pPlayerSprite->pos.Z;
if (nAngle < 0) {
nAngle = pPlayerSprite->ang;
@ -109,7 +109,7 @@ void BuildGrenade(int nPlayer)
pSprite->pos.X = pPlayerSprite->pos.X;
pSprite->pos.Y = pPlayerSprite->pos.Y;
pSprite->z = pPlayerSprite->z - 3840;
pSprite->pos.Z = pPlayerSprite->pos.Z - 3840;
pSprite->shade = -64;
pSprite->xrepeat = 20;
pSprite->yrepeat = 20;
@ -160,7 +160,7 @@ void ExplodeGrenade(DExhumedActor* pActor)
}
else
{
if (pGrenadeSprite->z < pGrenadeSect->floorz)
if (pGrenadeSprite->pos.Z < pGrenadeSect->floorz)
{
var_20 = 200;
var_28 = 36;
@ -182,7 +182,7 @@ void ExplodeGrenade(DExhumedActor* pActor)
auto pPlayerSprite = &pPlayerActor->s();
int nAngle = pPlayerSprite->ang;
pGrenadeSprite->z = pPlayerSprite->z;
pGrenadeSprite->pos.Z = pPlayerSprite->pos.Z;
pGrenadeSprite->pos.X = bcos(nAngle, -5) + pPlayerSprite->pos.X;
pGrenadeSprite->pos.Y = bsin(nAngle, -5) + pPlayerSprite->pos.Y;
@ -201,8 +201,8 @@ void ExplodeGrenade(DExhumedActor* pActor)
runlist_RadialDamageEnemy(pActor, nDamage, BulletInfo[kWeaponGrenade].nRadius);
BuildAnim(nullptr, var_28, 0, pGrenadeSprite->pos.X, pGrenadeSprite->pos.Y, pGrenadeSprite->z, pGrenadeSprite->sector(), var_20, 4);
AddFlash(pGrenadeSprite->sector(), pGrenadeSprite->pos.X, pGrenadeSprite->pos.Y, pGrenadeSprite->z, 128);
BuildAnim(nullptr, var_28, 0, pGrenadeSprite->pos.X, pGrenadeSprite->pos.Y, pGrenadeSprite->pos.Z, pGrenadeSprite->sector(), var_20, 4);
AddFlash(pGrenadeSprite->sector(), pGrenadeSprite->pos.X, pGrenadeSprite->pos.Y, pGrenadeSprite->pos.Z, 128);
DestroyGrenade(pActor);
}

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

@ -617,7 +617,7 @@ loc_flag:
pPlayerSprite->sector(),
pPlayerSprite->pos.X,
pPlayerSprite->pos.Y,
pPlayerSprite->z,
pPlayerSprite->pos.Z,
0);
}
@ -651,7 +651,7 @@ loc_flag:
int nAngle = pPlayerSprite->ang;
int theX = pPlayerSprite->pos.X;
int theY = pPlayerSprite->pos.Y;
int theZ = pPlayerSprite->z;
int theZ = pPlayerSprite->pos.Z;
int ebp = bcos(nAngle) * (pPlayerSprite->clipdist << 3);
int ebx = bsin(nAngle) * (pPlayerSprite->clipdist << 3);

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

@ -765,7 +765,7 @@ void ExamineSprites(TArray<DExhumedActor*>& actors)
pSprite->pos.X = initx;
pSprite->pos.Y = inity;
pSprite->z = initz;
pSprite->pos.Z = initz;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
nNetStartSprite[nNetStartSprites] = pActor;
nNetStartSprites++;

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

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

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

@ -46,7 +46,7 @@ DExhumedActor* BuildLavaLimb(DExhumedActor* pActor, int move, int ebx)
pLimbSprite->pos.X = pSprite->pos.X;
pLimbSprite->pos.Y = pSprite->pos.Y;
pLimbSprite->z = pSprite->z - RandomLong() % ebx;
pLimbSprite->pos.Z = pSprite->pos.Z - RandomLong() % ebx;
pLimbSprite->cstat = 0;
pLimbSprite->shade = -127;
pLimbSprite->pal = 1;
@ -124,7 +124,7 @@ void BuildLava(DExhumedActor* pActor, int x, int y, int, sectortype* pSector, in
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = pSector->floorz;
pSprite->pos.Z = pSector->floorz;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite->xrepeat = 200;
pSprite->yrepeat = 200;
@ -294,7 +294,7 @@ void AILavaDude::Tick(RunListEvent* ev)
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pSector =pSprite->sector();
auto coll = movesprite(pActor, pSprite->xvel << 8, pSprite->yvel << 8, 0, 0, 0, CLIPMASK0);
@ -304,7 +304,7 @@ void AILavaDude::Tick(RunListEvent* ev)
ChangeActorSect(pActor, pSector);
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->ang = (pSprite->ang + ((RandomWord() & 0x3FF) + 1024)) & kAngleMask;
pSprite->xvel = bcos(pSprite->ang);

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

@ -61,7 +61,7 @@ void BuildLion(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->clipdist = 60;
pSprite->shade = -12;
@ -391,7 +391,7 @@ void AILion::Tick(RunListEvent* ev)
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z - (GetActorHeight(pActor) >> 1);
int z = pSprite->pos.Z - (GetActorHeight(pActor) >> 1);
int nCheckDist = 0x7FFFFFFF;

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

@ -60,7 +60,7 @@ void DrawMap(double const smoothratio)
template<typename T> void GetSpriteExtents(T const* const pSprite, int* top, int* bottom)
{
*top = *bottom = pSprite->z;
*top = *bottom = pSprite->pos.Z;
if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) != CSTAT_SPRITE_ALIGNMENT_FLOOR)
{
int height = tileHeight(pSprite->picnum);

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

@ -241,13 +241,13 @@ int BelowNear(DExhumedActor* pActor, int x, int y, int walldist)
{
auto pSprite = &pActor->s();
auto pSector = pSprite->sector();
int z = pSprite->z;
int z = pSprite->pos.Z;
int z2;
if (loHit.type == kHitSprite)
{
z2 = loHit.actor()->spr.z;
z2 = loHit.actor()->spr.pos.Z;
}
else
{
@ -293,9 +293,9 @@ int BelowNear(DExhumedActor* pActor, int x, int y, int walldist)
}
if (z2 < pSprite->z)
if (z2 < pSprite->pos.Z)
{
pSprite->z = z2;
pSprite->pos.Z = z2;
overridesect = pSector;
pSprite->zvel = 0;
@ -332,7 +332,7 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
z >>= 1;
}
int spriteZ = pSprite->z;
int spriteZ = pSprite->pos.Z;
int floorZ = pSector->floorz;
int ebp = spriteZ + z;
@ -350,7 +350,7 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
if (pSect2 != pSector)
{
pSprite->z = ebp;
pSprite->pos.Z = ebp;
if (pSect2->Flag & kSectUnderwater)
{
@ -448,7 +448,7 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
// loc_1543B:
ebp = mySprfloor;
pSprite->z = mySprfloor;
pSprite->pos.Z = mySprfloor;
}
else
{
@ -468,7 +468,7 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
}
pSprite->cstat = cstat; // restore cstat
pSprite->z = ebp;
pSprite->pos.Z = ebp;
if (pSprite->statnum == 100)
{
@ -496,7 +496,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
int nSpriteHeight = GetActorHeight(pActor);
@ -524,7 +524,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
int varA = 0;
int varB = 0;
CheckSectorFloor(overridesect, pSprite->z, &varB, &varA);
CheckSectorFloor(overridesect, pSprite->pos.Z, &varB, &varA);
if (varB || varA)
{
@ -537,7 +537,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
}
else
{
CheckSectorFloor(overridesect, pSprite->z, &dx, &dy);
CheckSectorFloor(overridesect, pSprite->pos.Z, &dx, &dy);
}
Collision coll;
@ -630,7 +630,7 @@ Collision MoveCreatureWithCaution(DExhumedActor* pActor)
auto pSprite = &pActor->s();
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pSectorPre = pSprite->sector();
auto ecx = MoveCreature(pActor);
@ -648,7 +648,7 @@ Collision MoveCreatureWithCaution(DExhumedActor* pActor)
{
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
ChangeActorSect(pActor, pSectorPre);
@ -713,7 +713,7 @@ DExhumedActor* FindPlayer(DExhumedActor* pActor, int nDistance, bool dontengage)
int y = pSprite->pos.Y;
auto pSector =pSprite->sector();
int z = pSprite->z - GetActorHeight(pActor);
int z = pSprite->pos.Z - GetActorHeight(pActor);
nDistance <<= 8;
@ -736,7 +736,7 @@ DExhumedActor* FindPlayer(DExhumedActor* pActor, int nDistance, bool dontengage)
{
int v10 = abs(pPlayerSprite->pos.Y - y);
if (v10 < nDistance && cansee(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z - 7680, pPlayerSprite->sector(), x, y, z, pSector))
if (v10 < nDistance && cansee(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->pos.Z - 7680, pPlayerSprite->sector(), x, y, z, pSector))
{
break;
}
@ -783,8 +783,8 @@ int GetUpAngle(DExhumedActor* pActor1, int nVal, DExhumedActor* pActor2, int ecx
int x = pSprite2->pos.X - pSprite1->pos.X;
int y = pSprite2->pos.Y - pSprite1->pos.Y;
int ebx = (pSprite2->z + ecx) - (pSprite1->z + nVal);
int edx = (pSprite2->z + ecx) - (pSprite1->z + nVal);
int ebx = (pSprite2->pos.Z + ecx) - (pSprite1->pos.Z + nVal);
int edx = (pSprite2->pos.Z + ecx) - (pSprite1->pos.Z + nVal);
ebx >>= 4;
edx >>= 8;
@ -839,7 +839,7 @@ void CreatePushBlock(sectortype* pSector)
pSprite->pos.X = xAvg;
pSprite->pos.Y = yAvg;
pSprite->z = pSector->floorz - 256;
pSprite->pos.Z = pSector->floorz - 256;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
int var_28 = 0;
@ -1004,7 +1004,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
}
else
{
pos.Z = sp->z;
pos.Z = sp->pos.Z;
if ((nSectFlag & kSectUnderwater) || pos.Z != nZVal || sp->cstat & CSTAT_SPRITE_INVISIBLE)
{
@ -1039,7 +1039,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
if (pSectorB != pNextSector && (pSectorB == pSector || pNextSector == pSector))
{
if (pSectorB != pSector || nFloorZ >= pSprite->z)
if (pSectorB != pSector || nFloorZ >= pSprite->pos.Z)
{
if (pSectorB) {
ChangeActorSect(pActor, pSectorB);
@ -1075,7 +1075,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
while (auto pActor = it.Next())
{
auto pSprite = &pActor->s();
if (pSprite->statnum >= 99 && nZVal == pSprite->z && !(pSprite->cstat & CSTAT_SPRITE_INVISIBLE))
if (pSprite->statnum >= 99 && nZVal == pSprite->pos.Z && !(pSprite->cstat & CSTAT_SPRITE_INVISIBLE))
{
pSectorB = pSector;
Collision scratch;
@ -1104,7 +1104,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
auto pSprite = &pActor->s();
initx = pSprite->pos.X;
inity = pSprite->pos.Y;
initz = pSprite->z;
initz = pSprite->pos.Z;
inita = pSprite->ang;
initsectp = pSprite->sector();
}
@ -1200,7 +1200,7 @@ Collision AngleChase(DExhumedActor* pActor, DExhumedActor* pActor2, int ebx, int
int nSqrt = ksqrt(sqrtNum);
int var_18 = GetMyAngle(nSqrt, ((pSprite2->z - nHeight) - pSprite->z) >> 8);
int var_18 = GetMyAngle(nSqrt, ((pSprite2->pos.Z - nHeight) - pSprite->pos.Z) >> 8);
int nAngDelta = AngleDelta(pSprite->ang, nMyAngle, 1024);
int nAngDelta2 = abs(nAngDelta);
@ -1399,7 +1399,7 @@ DExhumedActor* BuildCreatureChunk(DExhumedActor* pSrc, int nPic, bool bSpecial)
pSprite->pos.X = pSrcSpr->pos.X;
pSprite->pos.Y = pSrcSpr->pos.Y;
pSprite->z = pSrcSpr->z;
pSprite->pos.Z = pSrcSpr->pos.Z;
ChangeActorSect(actor, pSrcSpr->sector());
@ -1448,7 +1448,7 @@ void AICreatureChunk::Tick(RunListEvent* ev)
auto nVal = movesprite(pActor, pSprite->xvel << 10, pSprite->yvel << 10, pSprite->zvel, 2560, -2560, CLIPMASK1);
if (pSprite->z >= pSector->floorz)
if (pSprite->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 = pSprite->sector();
@ -1456,7 +1456,7 @@ void AICreatureChunk::Tick(RunListEvent* ev)
pSprite->xvel = 0;
pSprite->yvel = 0;
pSprite->zvel = 0;
pSprite->z = pSector->floorz;
pSprite->pos.Z = pSector->floorz;
}
else
{

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

@ -50,7 +50,7 @@ void BuildMummy(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->pos.Y;
z = pSprite->z;
z = pSprite->pos.Z;
nAngle = pSprite->ang;
ChangeActorStat(pActor, 102);
@ -58,7 +58,7 @@ void BuildMummy(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
pSprite->clipdist = 32;
@ -111,8 +111,8 @@ void CheckMummyRevive(DExhumedActor* pActor)
if (x <= 20 && y <= 20)
{
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->z - 8192, pSprite->sector(),
pSprite2->pos.X, pSprite2->pos.Y, pSprite2->z - 8192, pSprite2->sector()))
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - 8192, pSprite->sector(),
pSprite2->pos.X, pSprite2->pos.Y, pSprite2->pos.Z - 8192, pSprite2->sector()))
{
pSprite2->cstat = 0;
pOther->nAction = 6;
@ -216,8 +216,8 @@ void AIMummy::Tick(RunListEvent* ev)
{
if (RandomBit() && pTarget)
{
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->z - GetActorHeight(pActor), pSprite->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.z - GetActorHeight(pTarget), pTarget->spr.sector()))
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - GetActorHeight(pActor), pSprite->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->spr.sector()))
{
pActor->nAction = 3;
pActor->nFrame = 0;
@ -459,7 +459,7 @@ void AIMummy::Damage(RunListEvent* ev)
pSprite->xvel = 0;
pSprite->yvel = 0;
pSprite->zvel = 0;
pSprite->z = pSprite->sector()->floorz;
pSprite->pos.Z = pSprite->sector()->floorz;
}
else
{

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

@ -395,7 +395,7 @@ DExhumedActor* BuildWallSprite(sectortype* pSector)
auto pSprite = &pActor->s();
pSprite->pos.vec2 = wal->center();
pSprite->z = (pSector->floorz + pSector->ceilingz) / 2;
pSprite->pos.Z = (pSector->floorz + pSector->ceilingz) / 2;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
return pActor;
@ -463,7 +463,7 @@ DExhumedActor* FindWallSprites(sectortype* pSector)
pSprite->pos.X = (var_24 + esi) / 2;
pSprite->pos.Y = (ecx + edi) / 2;
pSprite->z = pSector->floorz;
pSprite->pos.Z = pSector->floorz;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite->owner = -1;
pSprite->lotag = 0;
@ -615,7 +615,7 @@ int CheckSectorSprites(sectortype* pSector, int nVal)
PlayFXAtXYZ(StaticSound[kSoundJonFDie],
pSprite->pos.X,
pSprite->pos.Y,
pSprite->z,
pSprite->pos.Z,
CHANF_NONE, 0x4000);
}
}
@ -647,10 +647,10 @@ void MoveSectorSprites(sectortype* pSector, int z)
while (auto pActor = it.Next())
{
auto pSprite = &pActor->s();
int z = pSprite->z;
int z = pSprite->pos.Z;
if ((pSprite->statnum != 200 && z >= minz && z <= maxz) || pSprite->statnum >= 900)
{
pSprite->z = newz;
pSprite->pos.Z = newz;
}
}
}
@ -843,7 +843,7 @@ void AIElev::Tick(RunListEvent* ev)
}
auto sp = &pElevSpr->s();
PlayFXAtXYZ(StaticSound[kSound26], sp->pos.X, sp->pos.Y, sp->z);
PlayFXAtXYZ(StaticSound[kSound26], sp->pos.X, sp->pos.Y, sp->pos.Z);
}
if (var_18 & 0x4)
@ -869,7 +869,7 @@ void AIElev::Tick(RunListEvent* ev)
// maybe this doesn't go here?
while (pElevSpr)
{
pElevSpr->spr.z += ebp;
pElevSpr->spr.pos.Z += ebp;
pElevSpr = pElevSpr->pTarget;
}
}
@ -1030,7 +1030,7 @@ int BuildSlide(int nChannel, walltype* pStartWall, walltype* pWall1, walltype* p
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite->pos.X = pStartWall->pos.X;
pSprite->pos.Y = pStartWall->pos.Y;
pSprite->z = pSector->floorz;
pSprite->pos.Z = pSector->floorz;
pSprite->backuppos();
SlideData[nSlide].nRunC = 0;
@ -1415,7 +1415,7 @@ DExhumedActor* BuildSpark(DExhumedActor* pActor, int nVal)
spr->picnum = kTile985 + nVal;
}
spr->z = pSprite->z;
spr->pos.Z = pSprite->pos.Z;
spr->lotag = runlist_HeadRun() + 1;
spr->clipdist = 1;
spr->hitag = 0;
@ -1599,10 +1599,10 @@ DExhumedActor* BuildEnergyBlock(sectortype* pSector)
// GrabTimeSlot(3);
spr->z = pSector->firstWall()->nextSector()->floorz;
spr->pos.Z = pSector->firstWall()->nextSector()->floorz;
// CHECKME - name of this variable?
int nRepeat = (spr->z - pSector->floorz) >> 8;
int nRepeat = (spr->pos.Z - pSector->floorz) >> 8;
if (nRepeat > 255) {
nRepeat = 255;
}
@ -1679,9 +1679,9 @@ void ExplodeEnergyBlock(DExhumedActor* pActor)
pSector->floorshade = 50;
pSector->extra = -1;
pSector->floorz = pSprite->z;
pSector->floorz = pSprite->pos.Z;
pSprite->z = (pSprite->z + pSector->floorz) / 2;
pSprite->pos.Z = (pSprite->pos.Z + pSector->floorz) / 2;
BuildSpark(pActor, 3);
@ -1765,7 +1765,7 @@ void AIEnergyBlock::Damage(RunListEvent* ev)
pSprite2->ang = ev->nParam;
pSprite2->pos.X = lasthitx;
pSprite2->pos.Y = lasthity;
pSprite2->z = lasthitz;
pSprite2->pos.Z = lasthitz;
BuildSpark(pActor2, 0); // shoot out blue orb when damaged
DeleteActor(pActor2);
@ -1791,14 +1791,14 @@ void AIEnergyBlock::RadialDamage(RunListEvent* ev)
int nFloorZ = pSector->floorz;
pSector->floorz = spr->z;
spr->z -= 256;
pSector->floorz = spr->pos.Z;
spr->pos.Z -= 256;
ev->nDamage = runlist_CheckRadialDamage(pActor);
// restore previous values
pSector->floorz = nFloorZ;
spr->z += 256;
spr->pos.Z += 256;
if (ev->nDamage <= 0) {
return;
@ -1855,7 +1855,7 @@ DExhumedActor* BuildObject(DExhumedActor* pActor, int nOjectType, int nHitag)
pSprite2->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite2->pos.X = spr->pos.X;
pSprite2->pos.Y = spr->pos.Y;
pSprite2->z = spr->z;
pSprite2->pos.Z = spr->pos.Z;
}
else
{
@ -1878,7 +1878,7 @@ DExhumedActor* BuildObject(DExhumedActor* pActor, int nOjectType, int nHitag)
void ExplodeScreen(DExhumedActor* pActor)
{
auto pSprite = &pActor->s();
pSprite->z -= GetActorHeight(pActor) / 2;
pSprite->pos.Z -= GetActorHeight(pActor) / 2;
for (int i = 0; i < 30; i++) {
BuildSpark(pActor, 0); // shoot out blue orbs
@ -1952,7 +1952,7 @@ void AIObject::Tick(RunListEvent* ev)
int var_18;
// red branch
if ((nStat == kStatExplodeTarget) || (pSprite->z < pSprite->sector()->floorz))
if ((nStat == kStatExplodeTarget) || (pSprite->pos.Z < pSprite->sector()->floorz))
{
var_18 = 36;
}
@ -1961,7 +1961,7 @@ void AIObject::Tick(RunListEvent* ev)
var_18 = 34;
}
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 128);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 128);
BuildAnim(nullptr, var_18, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->sector()->floorz, pSprite->sector(), 240, 4);
// int edi = nSprite | 0x4000;
@ -1997,7 +1997,7 @@ void AIObject::Tick(RunListEvent* ev)
auto pTargSpr = &pActor->pTarget->s();
pSprite->pos.X = pTargSpr->pos.X;
pSprite->pos.Y = pTargSpr->pos.Y;
pSprite->z = pTargSpr->z;
pSprite->pos.Z = pTargSpr->pos.Z;
ChangeActorSect(pActor, pTargSpr->sector());
return;

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

@ -40,7 +40,7 @@ void GameInterface::WarpToCoords(int x, int y, int z, int ang, int horz)
pSprite->ox = pSprite->pos.X = x;
pSprite->oy = pSprite->pos.Y = y;
pSprite->oz = pSprite->z = z;
pSprite->oz = pSprite->pos.Z = z;
if (ang != INT_MIN)
{

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

@ -135,7 +135,7 @@ void feebtag(int x, int y, int z, sectortype* pSector, DExhumedActor **nSprite,
{
uint32_t xDiff = abs(pSprite->pos.X - x);
uint32_t yDiff = abs(pSprite->pos.Y - y);
int zDiff = pSprite->z - z;
int zDiff = pSprite->pos.Z - z;
if (zDiff < 5120 && zDiff > -25600)
{
@ -269,7 +269,7 @@ void RestartPlayer(int nPlayer)
nSpr->pos.X = nstspr->pos.X;
nSpr->pos.Y = nstspr->pos.Y;
nSpr->z = nstspr->z;
nSpr->pos.Z = nstspr->pos.Z;
ChangeActorSect(pActor, nstspr->sector());
plr->angle.ang = buildang(nstspr->ang&kAngleMask);
nSpr->ang = plr->angle.ang.asbuild();
@ -279,7 +279,7 @@ void RestartPlayer(int nPlayer)
fspr->pos.X = nSpr->pos.X;
fspr->pos.Y = nSpr->pos.Y;
fspr->z = nSpr->z;
fspr->pos.Z = nSpr->pos.Z;
fspr->yrepeat = 64;
fspr->xrepeat = 64;
fspr->cstat = CSTAT_SPRITE_ALIGNMENT_FLOOR;
@ -289,7 +289,7 @@ void RestartPlayer(int nPlayer)
{
nSpr->pos.X = plr->sPlayerSave.x;
nSpr->pos.Y = plr->sPlayerSave.y;
nSpr->z = plr->sPlayerSave.pSector->floorz;
nSpr->pos.Z = plr->sPlayerSave.pSector->floorz;
plr->angle.ang = buildang(plr->sPlayerSave.nAngle&kAngleMask);
nSpr->ang = plr->angle.ang.asbuild();
@ -325,7 +325,7 @@ void RestartPlayer(int nPlayer)
auto nDSpr = &pDActor->s();
nDSpr->pos.X = nSpr->pos.X;
nDSpr->pos.Y = nSpr->pos.Y;
nDSpr->z = nSpr->z;
nDSpr->pos.Z = nSpr->pos.Z;
nDSpr->xrepeat = nSpr->xrepeat;
nDSpr->yrepeat = nSpr->yrepeat;
nDSpr->xoffset = 0;
@ -472,7 +472,7 @@ void StartDeathSeq(int nPlayer, int nVal)
pGunSprite->pos.X = pSprite->pos.X;
pGunSprite->pos.Y = pSprite->pos.Y;
pGunSprite->z = pSector->floorz - 512;
pGunSprite->pos.Z = pSector->floorz - 512;
ChangeActorStat(pGunActor, nGunLotag[nWeapon] + 900);
@ -798,7 +798,7 @@ void AIPlayer::Tick(RunListEvent* ev)
AddFlash(pPlayerSprite->sector(),
pPlayerSprite->pos.X,
pPlayerSprite->pos.Y,
pPlayerSprite->z, 0);
pPlayerSprite->pos.Z, 0);
}
}
}
@ -888,7 +888,7 @@ void AIPlayer::Tick(RunListEvent* ev)
int spr_x = pPlayerSprite->pos.X;
int spr_y = pPlayerSprite->pos.Y;
int spr_z = pPlayerSprite->z;
int spr_z = pPlayerSprite->pos.Z;
auto spr_sect = pPlayerSprite->sector();
// TODO
@ -903,10 +903,10 @@ void AIPlayer::Tick(RunListEvent* ev)
pPlayerSprite->pos.X += (x >> 14);
pPlayerSprite->pos.Y += (y >> 14);
vec3_t pos = { pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z };
vec3_t pos = { pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->pos.Z };
SetActor(pPlayerActor, &pos);
pPlayerSprite->z = pPlayerSprite->sector()->floorz;
pPlayerSprite->pos.Z = pPlayerSprite->sector()->floorz;
}
else
{
@ -1013,7 +1013,7 @@ void AIPlayer::Tick(RunListEvent* ev)
pPlayerSprite->yvel = 0;
StopActorSound(pPlayerActor);
PlayFXAtXYZ(StaticSound[kSoundJonFDie], pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z, CHANF_NONE, 1); // CHECKME
PlayFXAtXYZ(StaticSound[kSoundJonFDie], pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->pos.Z, CHANF_NONE, 1); // CHECKME
}
else
{
@ -1071,7 +1071,7 @@ void AIPlayer::Tick(RunListEvent* ev)
{
pPlayerSprite->pos.X = spr_x;
pPlayerSprite->pos.Y = spr_y;
pPlayerSprite->z = spr_z;
pPlayerSprite->pos.Z = spr_z;
ChangeActorSect(pPlayerActor, spr_sect);
}
@ -1098,7 +1098,7 @@ void AIPlayer::Tick(RunListEvent* ev)
sectdone:
if (!PlayerList[nPlayer].bPlayerPan && !PlayerList[nPlayer].bLockPan)
{
PlayerList[nPlayer].nDestVertPan = q16horiz(clamp((spr_z - pPlayerSprite->z) << 9, gi->playerHorizMin(), gi->playerHorizMax()));
PlayerList[nPlayer].nDestVertPan = q16horiz(clamp((spr_z - pPlayerSprite->pos.Z) << 9, gi->playerHorizMin(), gi->playerHorizMax()));
}
playerX -= pPlayerSprite->pos.X;
@ -1117,7 +1117,7 @@ sectdone:
auto pViewSect = pPlayerSprite->sector();
int EyeZ = PlayerList[nPlayer].eyelevel + pPlayerSprite->z + nQuake[nPlayer];
int EyeZ = PlayerList[nPlayer].eyelevel + pPlayerSprite->pos.Z + nQuake[nPlayer];
while (1)
{
@ -1141,7 +1141,7 @@ sectdone:
{
int var_C4 = pPlayerSprite->pos.X;
int var_D4 = pPlayerSprite->pos.Y;
int var_C8 = pPlayerSprite->z;
int var_C8 = pPlayerSprite->pos.Z;
ChangeActorSect(pPlayerActor, pViewSect);
@ -1150,7 +1150,7 @@ sectdone:
int var_FC = pViewSect->floorz + (-5120);
pPlayerSprite->z = var_FC;
pPlayerSprite->pos.Z = var_FC;
auto coll = movesprite(pPlayerActor, x, y, 0, 5120, 0, CLIPMASK0);
if (coll.type == kHitWall)
@ -1159,11 +1159,11 @@ sectdone:
pPlayerSprite->pos.X = var_C4;
pPlayerSprite->pos.Y = var_D4;
pPlayerSprite->z = var_C8;
pPlayerSprite->pos.Z = var_C8;
}
else
{
pPlayerSprite->z = var_FC - 256;
pPlayerSprite->pos.Z = var_FC - 256;
D3PlayFX(StaticSound[kSound42], pPlayerActor);
}
}
@ -1256,7 +1256,7 @@ sectdone:
{
auto pTmpSect = pPlayerSprite->sector();
if (PlayerList[nPlayer].totalvel > 25 && pPlayerSprite->z > pTmpSect->floorz)
if (PlayerList[nPlayer].totalvel > 25 && pPlayerSprite->pos.Z > pTmpSect->floorz)
{
if (pTmpSect->Depth && !pTmpSect->Speed && !pTmpSect->Damage)
{
@ -1301,7 +1301,7 @@ sectdone:
ChangeActorSect(pFloorActor, pPlayerSprite->sector());
}
pFloorSprite->z = pPlayerSprite->sector()->floorz;
pFloorSprite->pos.Z = pPlayerSprite->sector()->floorz;
}
int var_30 = 0;
@ -1323,7 +1323,7 @@ sectdone:
neartag(pPlayerSprite->pos, pPlayerSprite->sector(), pPlayerSprite->ang, near, 1024, 2);
DExhumedActor* pActorB;
feebtag(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z, pPlayerSprite->sector(), &pActorB, var_30, 768);
feebtag(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->pos.Z, pPlayerSprite->sector(), &pActorB, var_30, 768);
// Item pickup code
if (pActorB != nullptr && pActorB->spr.statnum >= 900)
@ -2219,7 +2219,7 @@ sectdone:
ChangeActorStat(pActorB, 899);
}
SetSavePoint(nPlayer, pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z, pPlayerSprite->sector(), pPlayerSprite->ang);
SetSavePoint(nPlayer, pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->pos.Z, pPlayerSprite->sector(), pPlayerSprite->ang);
break;
}
@ -2489,7 +2489,7 @@ sectdone:
{
pPlayerSprite->picnum = seq_GetSeqPicnum(kSeqJoe, 120, 0);
pPlayerSprite->cstat = 0;
pPlayerSprite->z = pPlayerSprite->sector()->floorz;
pPlayerSprite->pos.Z = pPlayerSprite->sector()->floorz;
}
// will invalidate nPlayerSprite
@ -2537,8 +2537,8 @@ sectdone:
case 16:
PlayerList[nPlayer].nSeqSize = SeqSize[var_AC] - 1;
if (pPlayerSprite->z < pPlayerSprite->sector()->floorz) {
pPlayerSprite->z += 256;
if (pPlayerSprite->pos.Z < pPlayerSprite->sector()->floorz) {
pPlayerSprite->pos.Z += 256;
}
if (!RandomSize(5))
@ -2547,7 +2547,7 @@ sectdone:
sectortype* mouthSect;
WheresMyMouth(nPlayer, &pos, &mouthSect);
BuildAnim(nullptr, 71, 0, pos.X, pos.Y, pPlayerSprite->z + 3840, mouthSect, 75, 128);
BuildAnim(nullptr, 71, 0, pos.X, pos.Y, pPlayerSprite->pos.Z + 3840, mouthSect, 75, 128);
}
break;
case 17:
@ -2565,7 +2565,7 @@ sectdone:
{
initx = pPlayerSprite->pos.X;
inity = pPlayerSprite->pos.Y;
initz = pPlayerSprite->z;
initz = pPlayerSprite->pos.Z;
initsectp = pPlayerSprite->sector();
inita = pPlayerSprite->ang;
}

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

@ -250,7 +250,7 @@ void DestroyEgg(int nEgg)
if (QueenEgg[nEgg].nAction != 4)
{
BuildAnim(nullptr, 34, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->xrepeat, 4);
BuildAnim(nullptr, 34, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), pSprite->xrepeat, 4);
}
else
{
@ -307,7 +307,7 @@ Collision QueenAngleChase(DExhumedActor* pActor, DExhumedActor* pActor2, int val
int nMyAngle = GetMyAngle(pSprite2->pos.X - pSprite->pos.X, pSprite2->pos.Y - pSprite->pos.Y);
int edx = ((pSprite2->z - nTileY) - pSprite->z) >> 8;
int edx = ((pSprite2->pos.Z - nTileY) - pSprite->pos.Z) >> 8;
uint32_t xDiff = abs(pSprite2->pos.X - pSprite->pos.X);
uint32_t yDiff = abs(pSprite2->pos.Y - pSprite->pos.Y);
@ -423,7 +423,7 @@ void BuildTail()
pTailSprite->pal = pTailSprite->sector()->ceilingpal;
pTailSprite->xoffset = 0;
pTailSprite->yoffset = 0;
pTailSprite->z = z;
pTailSprite->pos.Z = z;
pTailSprite->extra = -1;
}
@ -462,7 +462,7 @@ void BuildQueenEgg(int nQueen, int nVal)
pSprite2->pos.X = x;
pSprite2->pos.Y = y;
pSprite2->z = nFloorZ;
pSprite2->pos.Z = nFloorZ;
pSprite2->pal = 0;
pSprite2->clipdist = 50;
pSprite2->xoffset = 0;
@ -662,8 +662,8 @@ void AIQueenEgg::Tick(RunListEvent* ev)
pEgg->nCounter--;
if (pEgg->nCounter <= 0)
{
auto pWaspSprite = BuildWasp(nullptr, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->ang, true);
pSprite->z = pWaspSprite->spr.z;
auto pWaspSprite = BuildWasp(nullptr, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), pSprite->ang, true);
pSprite->pos.Z = pWaspSprite->spr.pos.Z;
DestroyEgg(nEgg);
}
@ -727,7 +727,7 @@ void BuildQueenHead(int nQueen)
pSprite2->pos.X = x;
pSprite2->pos.Y = y;
pSprite2->z = z;
pSprite2->pos.Z = z;
pSprite2->clipdist = 70;
pSprite2->xrepeat = 80;
pSprite2->yrepeat = 80;
@ -880,14 +880,14 @@ void AIQueenHead::Tick(RunListEvent* ev)
[[fallthrough]];
case 1:
if ((pTarget->spr.z - 51200) > pSprite->z)
if ((pTarget->spr.pos.Z - 51200) > pSprite->pos.Z)
{
QueenHead.nAction = 4;
QueenHead.nFrame = 0;
}
else
{
pSprite->z -= 2048;
pSprite->pos.Z -= 2048;
goto __MOVEQS;
}
break;
@ -938,7 +938,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
__MOVEQS:
MoveQX[nQHead] = pSprite->pos.X;
MoveQY[nQHead] = pSprite->pos.Y;
MoveQZ[nQHead] = pSprite->z;
MoveQZ[nQHead] = pSprite->pos.Z;
assert(pSprite->sector());
MoveQS[nQHead] = pSprite->sector();
MoveQA[nQHead] = pSprite->ang;
@ -966,7 +966,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
pTSprite->pos.X = MoveQX[nHd];
pTSprite->pos.Y = MoveQY[nHd];
pTSprite->z = MoveQZ[nHd];
pTSprite->pos.Z = MoveQZ[nHd];
pTSprite->ang = MoveQA[nHd];
}
}
@ -991,7 +991,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
{
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
auto pSector =pSprite->sector();
int nAngle = RandomSize(11) & kAngleMask;
@ -1015,7 +1015,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
if (QueenHead.nIndex2 < 10) {
for (int i = (10 - QueenHead.nIndex2) * 2; i > 0; i--)
@ -1149,7 +1149,7 @@ void BuildQueen(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->pal = 0;
pSprite->shade = -12;
@ -1435,7 +1435,7 @@ void AIQueen::Tick(RunListEvent* ev)
StaticSound[kSound40],
pSprite->pos.X,
pSprite->pos.Y,
pSprite->z);
pSprite->pos.Z);
BuildQueenHead(nQueen);
@ -1501,7 +1501,7 @@ void AIQueen::Damage(RunListEvent* ev)
QueenList[nQueen].nHealth = 4000;
QueenList[nQueen].nAction = 7;
BuildAnim(nullptr, 36, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z - 7680, pSprite->sector(), pSprite->xrepeat, 4);
BuildAnim(nullptr, 36, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - 7680, pSprite->sector(), pSprite->xrepeat, 4);
break;
case 2:
QueenList[nQueen].nHealth = 4000;

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

@ -171,7 +171,7 @@ void MoveRaToEnemy(int nPlayer)
pSprite->pos.X = pTargSprite->pos.X;
pSprite->pos.Y = pTargSprite->pos.Y;
pSprite->z = pTargSprite->z - GetActorHeight(pTarget);
pSprite->pos.Z = pTargSprite->pos.Z - GetActorHeight(pTarget);
if (pSprite->sector() != pTargSprite->sector()) {
ChangeActorSect(pActor, pTargSprite->sector());

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

@ -426,7 +426,7 @@ void DoSpiritHead()
if (nCount < (15 * nPixels) / 16) {
SoundBigEntrance();
AddGlow(pSpiritSpr->sector(), 20);
AddFlash(pSpiritSpr->sector(), pSpiritSpr->pos.X, pSpiritSpr->pos.Y, pSpiritSpr->z, 128);
AddFlash(pSpiritSpr->sector(), pSpiritSpr->pos.X, pSpiritSpr->pos.Y, pSpiritSpr->pos.Z, 128);
nHeadStage = 3;
TintPalette(255, 255, 255);
CopyHeadToWorkTile(kTileRamsesNormal);

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

@ -86,7 +86,7 @@ void BuildRat(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->pos.Y;
z = pSprite->z;
z = pSprite->pos.Z;
nAngle = pSprite->ang;
ChangeActorStat(pActor, 108);
@ -132,7 +132,7 @@ DExhumedActor* FindFood(DExhumedActor* pActor)
auto pSector = pSprite->sector();
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
int z2 = (z + pSector->ceilingz) / 2;
@ -142,7 +142,7 @@ DExhumedActor* FindFood(DExhumedActor* pActor)
if (pActor2 != nullptr)
{
auto pSprite2 = &pActor2->s();
if (cansee(x, y, z2, pSector, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->z, pSprite2->sector())) {
if (cansee(x, y, z2, pSector, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->pos.Z, pSprite2->sector())) {
return pActor2;
}
}
@ -158,7 +158,7 @@ DExhumedActor* FindFood(DExhumedActor* pActor)
auto pSprite2 = &pActor2->s();
if (nPlayerPic == pSprite2->picnum)
{
if (cansee(x, y, z, pSector, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->z, pSprite2->sector())) {
if (cansee(x, y, z, pSector, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->pos.Z, pSprite2->sector())) {
return pActor2;
}
}

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

@ -58,7 +58,7 @@ void BuildRex(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->clipdist = 80;
pSprite->shade = -12;

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

@ -55,7 +55,7 @@ void BuildRoach(int nType, DExhumedActor* pActor, int x, int y, int z, sectortyp
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
pSprite->xoffset = 0;

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

@ -1609,7 +1609,7 @@ int runlist_CheckRadialDamage(DExhumedActor* pActor)
int x = (pSprite->pos.X - pRadialSpr->pos.X) >> 8;
int y = (pSprite->pos.Y - pRadialSpr->pos.Y) >> 8;
int z = (pSprite->z - pRadialSpr->z) >> 12;
int z = (pSprite->pos.Z - pRadialSpr->pos.Z) >> 12;
if (abs(x) > nDamageRadius) {
return 0;
@ -1646,11 +1646,11 @@ int runlist_CheckRadialDamage(DExhumedActor* pActor)
if (((kStatExplodeTarget - pSprite->statnum) <= 1) ||
cansee(pRadialSpr->pos.X,
pRadialSpr->pos.Y,
pRadialSpr->z - 512,
pRadialSpr->pos.Z - 512,
pRadialSpr->sector(),
pSprite->pos.X,
pSprite->pos.Y,
pSprite->z - 8192,
pSprite->pos.Z - 8192,
pSprite->sector()))
{
edi = (nRadialDamage * (nDamageRadius - nDist)) / nDamageRadius;

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

@ -60,7 +60,7 @@ void BuildScorp(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->clipdist = 70;
pSprite->shade = -12;
@ -379,7 +379,7 @@ void AIScorp::Tick(RunListEvent* ev)
return;
}
auto pSpiderActor = BuildSpider(nullptr, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->ang);
auto pSpiderActor = BuildSpider(nullptr, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), pSprite->ang);
if (pSpiderActor)
{
auto pSpiderSprite = &pSpiderActor->s();
@ -440,8 +440,8 @@ void AIScorp::Effect(RunListEvent* ev, DExhumedActor* pTarget, int mode)
{
pActor->nCount = 45;
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->z - GetActorHeight(pActor), pSprite->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.z - GetActorHeight(pTarget), pTarget->spr.sector()))
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z - GetActorHeight(pActor), pSprite->sector(),
pTarget->spr.pos.X, pTarget->spr.pos.Y, pTarget->spr.pos.Z - GetActorHeight(pTarget), pTarget->spr.sector()))
{
pSprite->xvel = 0;
pSprite->yvel = 0;

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

@ -575,7 +575,7 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
tspriteptr_t tsp = &mytsprite[(*myspritesortcnt)++];
tsp->pos.X = pTSprite->pos.X;
tsp->pos.Y = pTSprite->pos.Y;
tsp->z = pTSprite->z;
tsp->pos.Z = pTSprite->pos.Z;
tsp->shade = shade;
tsp->pal = pTSprite->pal;
tsp->xrepeat = pTSprite->xrepeat;
@ -619,13 +619,13 @@ int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
{
pTSprite->picnum = nShadowPic;
int edx = ((tileWidth(nPict) << 5) / nShadowWidth) - ((nFloorZ - pTSprite->z) >> 10);
int edx = ((tileWidth(nPict) << 5) / nShadowWidth) - ((nFloorZ - pTSprite->pos.Z) >> 10);
if (edx < 1) {
edx = 1;
}
pTSprite->cstat = CSTAT_SPRITE_ALIGNMENT_FLOOR | CSTAT_SPRITE_TRANSLUCENT;
pTSprite->z = nFloorZ;
pTSprite->pos.Z = nFloorZ;
pTSprite->yrepeat = (uint8_t)edx;
pTSprite->xrepeat = (uint8_t)edx;
pTSprite->statnum = -3;

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

@ -59,7 +59,7 @@ void BuildSet(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
pSprite->pos.X = x;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->pos.Z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
pSprite->clipdist = 110;
@ -120,7 +120,7 @@ void BuildSoul(DExhumedActor* pSet)
pSprite->pos.X = pSetSprite->pos.X;
pSprite->pos.Y = pSetSprite->pos.Y;
pSprite->z = (RandomSize(8) << 8) + 8192 + pSprite->sector()->ceilingz - GetActorHeight(pActor);
pSprite->pos.Z = (RandomSize(8) << 8) + 8192 + pSprite->sector()->ceilingz - GetActorHeight(pActor);
//pSprite->hitag = nSet;
pActor->pTarget = pSet;
@ -165,7 +165,7 @@ void AISoul::Tick(RunListEvent* ev)
pSprite->xrepeat = 1;
pSprite->pos.X = pSetSprite->pos.X;
pSprite->pos.Y = pSetSprite->pos.Y;
pSprite->z = pSetSprite->z - (GetActorHeight(pSet) >> 1);
pSprite->pos.Z = pSetSprite->pos.Z - (GetActorHeight(pSet) >> 1);
ChangeActorSect(pActor, pSetSprite->sector());
return;
}
@ -423,9 +423,9 @@ void AISet::Tick(RunListEvent* ev)
if (pSector)
{
if ((pSprite->z - pSector->floorz) < 55000)
if ((pSprite->pos.Z - pSector->floorz) < 55000)
{
if (pSprite->z > pSector->ceilingz)
if (pSprite->pos.Z > pSector->ceilingz)
{
pActor->nIndex = 1;
pActor->nAction = 7;
@ -589,9 +589,9 @@ void AISet::Tick(RunListEvent* ev)
{
if (nFlag & 0x80)
{
pSprite->z -= GetActorHeight(pActor);
pSprite->pos.Z -= GetActorHeight(pActor);
BuildCreatureChunk(pActor, seq_GetSeqPicnum(kSeqSet, 76, 0));
pSprite->z += GetActorHeight(pActor);
pSprite->pos.Z += GetActorHeight(pActor);
}
if (bVal)

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

@ -119,9 +119,9 @@ void ExplodeSnakeSprite(DExhumedActor* pActor, int nPlayer)
pActor->pTarget = nOwner;
BuildAnim(nullptr, 23, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 40, 4);
BuildAnim(nullptr, 23, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, pSprite->sector(), 40, 4);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 128);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.Z, 128);
StopActorSound(pActor);
}
@ -138,7 +138,7 @@ void BuildSnake(int nPlayer, int zVal)
int x = pPlayerSprite->pos.X;
int y = pPlayerSprite->pos.Y;
int z = (pPlayerSprite->z + zVal) - 2560;
int z = (pPlayerSprite->pos.Z + zVal) - 2560;
int nAngle = pPlayerSprite->ang;
HitInfo hit{};
@ -164,7 +164,7 @@ void BuildSnake(int nPlayer, int zVal)
auto pSprite = &pActor->s();
pSprite->pos.X = hit.hitpos.X;
pSprite->pos.Y = hit.hitpos.Y;
pSprite->z = hit.hitpos.Z;
pSprite->pos.Z = hit.hitpos.Z;
ExplodeSnakeSprite(pActor, nPlayer);
DeleteActor(pActor);
@ -202,7 +202,7 @@ void BuildSnake(int nPlayer, int zVal)
{
pSprite->pos.X = pPlayerSprite->pos.X;
pSprite->pos.Y = pPlayerSprite->pos.Y;
pSprite->z = pPlayerSprite->z + zVal;
pSprite->pos.Z = pPlayerSprite->pos.Z + zVal;
pSprite->xrepeat = 32;
pSprite->yrepeat = 32;
pViewSect = pSprite->sector();
@ -212,7 +212,7 @@ void BuildSnake(int nPlayer, int zVal)
{
pSprite->pos.X = sprt->spr.pos.X;
pSprite->pos.Y = sprt->spr.pos.Y;
pSprite->z = sprt->spr.z;
pSprite->pos.Z = sprt->spr.pos.Z;
pSprite->xrepeat = 40 - 3 * i;
pSprite->yrepeat = 40 - 3 * i;
}
@ -351,11 +351,11 @@ void AISnake::Tick(RunListEvent* ev)
goto SEARCH_ENEMY;
}
zVal = pSprite->z;
zVal = pSprite->pos.Z;
nMov = AngleChase(pActor, pEnemySprite, 1200, SnakeList[nSnake].nAngle, 32);
zVal = pSprite->z - zVal;
zVal = pSprite->pos.Z - zVal;
}
if (nMov.type || nMov.exbits)
@ -383,7 +383,7 @@ void AISnake::Tick(RunListEvent* ev)
int x = pSprite->pos.X;
int y = pSprite->pos.Y;
int z = pSprite->z;
int z = pSprite->pos.Z;
for (int i = 7; i > 0; i--)
{
@ -394,7 +394,7 @@ void AISnake::Tick(RunListEvent* ev)
pSprite2->ang = nAngle;
pSprite2->pos.X = x;
pSprite2->pos.Y = y;
pSprite2->z = z;
pSprite2->pos.Z = z;
ChangeActorSect(pActor2, pSector);

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

@ -565,7 +565,7 @@ void PlayFX2(int nSound, DExhumedActor* pActor, int sectf, EChanFlags chanflags,
hiprio = (sprflags & 0x4000) != 0;
soundx = pActor->spr.pos.X;
soundy = pActor->spr.pos.Y;
soundz = pActor->spr.z;
soundz = pActor->spr.pos.Z;
}
int nVolume = 255;
@ -730,7 +730,7 @@ void UpdateCreepySounds()
if (totalmoves & 2)
vax = -vax;
vec3_t sp = { pSprite->pos.X + vdx, pSprite->pos.Y + vax, pSprite->z };
vec3_t sp = { pSprite->pos.X + vdx, pSprite->pos.Y + vax, pSprite->pos.Z };
creepy = GetSoundPos(&sp);
if ((vsi & 0x1ff) >= kMaxSounds || !soundEngine->isValidSoundId((vsi & 0x1ff) + 1))

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