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

- Replace spritetypebase y with pos.Y calls.

Browse source
This commit is contained in:
Mitchell Richters 2021-12-22 22:17:17 +11:00 • committed by Christoph Oelckers
parent 33ca55023f
commit cecb8dc48e
143 changed files with 1651 additions and 1651 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -139,7 +139,7 @@ static int32_t spriteGetZOfSlope(const spritetype* spr, int32_t dax, int32_t day
if (heinum == 0)
return spr->z;
int const j = DMulScale(bsin(spr->ang + 1024), day - spr->y, -bsin(spr->ang + 512), dax - spr->pos.X, 4);
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);
}
@ -739,7 +739,7 @@ CollisionBase clipmove_(vec3_t * const pos, int * const sectnum, int32_t xvect,
if (jj2 > (centery << 8) || jj2 < ((centery - rspany) << 8))
continue;
int32_t x1 = spr->pos.X + MulScale(sinang, centerx, 16) + MulScale(jj, cosang, 24);
int32_t y1 = spr->y - MulScale(cosang, centerx, 16) + MulScale(jj, sinang, 24);
int32_t y1 = spr->pos.Y - MulScale(cosang, centerx, 16) + MulScale(jj, sinang, 24);
int32_t x2 = x1 - MulScale(sinang, rspanx, 16);
int32_t y2 = y1 + MulScale(cosang, rspanx, 16);
@ -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->y; z1 = spr->z;
x1 = spr->pos.X; y1 = spr->pos.Y; z1 = spr->z;
switch (cstat&CSTAT_SPRITE_ALIGNMENT_MASK)
{
case 0:
@ -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->y, -day, sv->X - spr->pos.X, 15);
int32_t i = ((spr->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);

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

@ -1090,7 +1090,7 @@ void md3_vox_calcmat_common(tspriteptr_t tspr, const FVector3 *a0, float f, floa
auto& sext = tspr->ownerActor->sx();
k0 = ((float)(tspr->pos.X+sext.position_offset.X-globalposx))*f*(1.f/1024.f);
k1 = ((float)(tspr->y+sext.position_offset.Y-globalposy))*f*(1.f/1024.f);
k1 = ((float)(tspr->pos.Y+sext.position_offset.Y-globalposy))*f*(1.f/1024.f);
k4 = -bsinf(tspr->ang+sext.angoff, -14);
k5 = bcosf(tspr->ang+sext.angoff, -14);
k2 = k0*(1-k4)+k1*k5;
@ -1205,7 +1205,7 @@ static int32_t polymost_md3draw(md3model_t *m, tspriteptr_t tspr)
m0.Z *= f; m1.Z *= f; a0.Z *= f;
// floor aligned
k1 = (float)tspr->y+sext->position_offset.Y;
k1 = (float)tspr->pos.Y+sext->position_offset.Y;
if ((globalorientation & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FLOOR)
{
m0.Z = -m0.Z; m1.Z = -m1.Z; a0.Z = -a0.Z;

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

@ -1880,7 +1880,7 @@ void polymost_scansector(int32_t sectnum)
if ((spr->cstat & CSTAT_SPRITE_INVISIBLE) || spr->xrepeat == 0 || spr->yrepeat == 0)
continue;
vec2_t const s = { spr->pos.X-globalposx, spr->y-globalposy };
vec2_t const s = { spr->pos.X-globalposx, spr->pos.Y-globalposy };
if ((spr->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) ||
(hw_models && tile2model[spr->picnum].modelid>=0) ||
@ -2580,7 +2580,7 @@ static inline int32_t polymost_findwall(tspritetype const * const tspr, vec2_t c
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))
{
int const dst = abs(tspr->pos.X - n.X) + abs(tspr->y - n.Y);
int const dst = abs(tspr->pos.X - n.X) + abs(tspr->pos.Y - n.Y);
if (dst <= dist)
{
@ -2641,7 +2641,7 @@ static inline float tspriteGetZOfSlopeFloat(tspriteptr_t const tspr, float dax,
if (heinum == 0)
return float(tspr->z);
float const f = bsin(tspr->ang + 1024) * (day - tspr->y) - bsin(tspr->ang + 512) * (dax - tspr->pos.X);
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);
}
@ -2764,14 +2764,14 @@ void polymost_drawsprite(int32_t snum)
// NOTE: yoff not negated not for y flipping, unlike wall and floor
// aligned sprites.
int const ang = (getangle(tspr->pos.X - globalposx, tspr->y - globalposy) + 1024) & 2047;
int const ang = (getangle(tspr->pos.X - globalposx, tspr->pos.Y - globalposy) + 1024) & 2047;
float foffs = TSPR_OFFSET(tspr);
FVector2 const offs = { float(bcosf(ang, -6) * foffs), float(bsinf(ang, -6) * foffs) };
FVector2 s0 = { (float)(tspr->pos.X - globalposx) + offs.X,
(float)(tspr->y - globalposy) + offs.Y};
(float)(tspr->pos.Y - globalposy) + offs.Y};
FVector2 p0 = { s0.Y * gcosang - s0.X * gsinang, s0.X * gcosang2 + s0.Y * gsinang2 };
@ -3058,7 +3058,7 @@ void polymost_drawsprite(int32_t snum)
// Project 3D to 2D
for (intptr_t j = 0; j < 4; j++)
{
FVector2 s0 = { (float)(tspr->pos.X - globalposx), (float)(tspr->y - globalposy) };
FVector2 s0 = { (float)(tspr->pos.X - globalposx), (float)(tspr->pos.Y - globalposy) };
if ((j + 0) & 2)
{
@ -3147,7 +3147,7 @@ void polymost_drawsprite(int32_t snum)
otex.d = -ghoriz * ytex.d;
// copied&modified from relative alignment
FVector2 const vv = { (float)tspr->pos.X + s * p1.X + c * p1.Y, (float)tspr->y + s * p1.Y - c * p1.X };
FVector2 const vv = { (float)tspr->pos.X + s * p1.X + c * p1.Y, (float)tspr->pos.Y + s * p1.Y - c * p1.X };
FVector2 ff = { -(p0.X + p1.X) * s, (p0.X + p1.X) * c };
float f = 1.f / sqrtf(ff.X * ff.X + ff.Y * ff.Y);
@ -3380,7 +3380,7 @@ static inline int comparetsprites(int const k, int const l)
if (!tspriteptr[k]->ownerActor || !tspriteptr[l]->ownerActor) return 0; // why are these getting dragged into here?
if (tspriteptr[k]->pos.X == tspriteptr[l]->pos.X &&
tspriteptr[k]->y == tspriteptr[l]->y &&
tspriteptr[k]->pos.Y == tspriteptr[l]->pos.Y &&
tspriteptr[k]->z == tspriteptr[l]->z &&
(tspriteptr[k]->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == (tspriteptr[l]->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) &&
tspriteptr[k]->ownerActor != tspriteptr[l]->ownerActor)
@ -3501,7 +3501,7 @@ void renderDrawMasks(void)
for (i = numSprites - 1; i >= 0; --i)
{
const int32_t xs = tspriteptr[i]->pos.X - globalposx, ys = tspriteptr[i]->y - globalposy;
const int32_t xs = tspriteptr[i]->pos.X - globalposx, ys = tspriteptr[i]->pos.Y - globalposy;
const int32_t yp = DMulScale(xs, cosviewingrangeglobalang, ys, sinviewingrangeglobalang, 6);
const int32_t modelp = spriteIsModelOrVoxel(tspriteptr[i]);
@ -3657,7 +3657,7 @@ void renderDrawMasks(void)
auto const tspr = tspriteptr[i];
spr.X = (float)tspr->pos.X;
spr.Y = (float)tspr->y;
spr.Y = (float)tspr->pos.Y;
if (!sameside(&maskeq, &spr, &pos))
{
@ -3845,7 +3845,7 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
int const shadowHack = !!(tspr->clipdist & TSPR_FLAGS_MDHACK);
m0.Y *= f; a0.Y = (((float)(tspr->pos.X + tspr->ownerActor->sx().position_offset.X - globalposx)) * (1.f / 1024.f) + a0.Y) * f;
m0.X *= -f; a0.X = (((float)(tspr->y + tspr->ownerActor->sx().position_offset.Y - globalposy)) * -(1.f / 1024.f) + a0.X) * -f;
m0.X *= -f; a0.X = (((float)(tspr->pos.Y + tspr->ownerActor->sx().position_offset.Y - globalposy)) * -(1.f / 1024.f) + a0.X) * -f;
m0.Z *= g; a0.Z = (((float)(k0 - globalposz - shadowHack)) * -(1.f / 16384.f) + a0.Z) * g;
float mat[16];

2
source/core/gamefuncs.cpp
View file

@ -323,7 +323,7 @@ void TGetFlatSpritePosition(const spritetypebase* spr, vec2_t pos, vec2_t* out,
{
for (int i = 0; i < 4; i++)
{
int spos = DMulScale(-sinang, out[i].Y - spr->y, -cosang, out[i].X - spr->pos.X, 4);
int spos = DMulScale(-sinang, out[i].Y - spr->pos.Y, -cosang, out[i].X - spr->pos.X, 4);
outz[i] = MulScale(heinum, spos, 18);
}
}

4
source/core/gamefuncs.h
View file

@ -206,7 +206,7 @@ inline double SpriteX(spritetype* spr)
inline double SpriteY(spritetype* spr)
{
return spr->y * (1 / -16.);
return spr->pos.Y * (1 / -16.);
}
inline DVector2 SpritePos(spritetype* spr)
@ -276,7 +276,7 @@ inline int32_t tspriteGetZOfSlope(const tspritetype* tspr, int dax, int day)
int heinum = tspriteGetSlope(tspr);
if (heinum == 0) return tspr->z;
int const j = DMulScale(bsin(tspr->ang + 1024), day - tspr->y, -bsin(tspr->ang + 512), dax - tspr->pos.X, 4);
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);
}

10
source/core/maploader.cpp
View file

@ -259,23 +259,23 @@ void validateSprite(spritetype& spr, int sectnum, int index)
bool bugged = false;
if ((unsigned)spr.statnum >= MAXSTATUS)
{
Printf("Sprite #%d (%d,%d) has invalid statnum %d.\n", index, spr.pos.X, spr.y, spr.statnum);
Printf("Sprite #%d (%d,%d) has invalid statnum %d.\n", index, spr.pos.X, spr.pos.Y, spr.statnum);
bugged = true;
}
else if ((unsigned)spr.picnum >= MAXTILES)
{
Printf("Sprite #%d (%d,%d) has invalid picnum %d.\n", index, spr.pos.X, spr.y, spr.picnum);
Printf("Sprite #%d (%d,%d) has invalid picnum %d.\n", index, spr.pos.X, spr.pos.Y, spr.picnum);
bugged = true;
}
else if (!validSectorIndex(sectnum))
{
sectnum = -1;
updatesector(spr.pos.X, spr.y, &sectnum);
updatesector(spr.pos.X, spr.pos.Y, &sectnum);
bugged = sectnum < 0;
if (!DPrintf(DMSG_WARNING, "Sprite #%d (%d,%d) with invalid sector %d was corrected to sector %d\n", index, spr.pos.X, spr.y, sectnum, sectnum))
if (!DPrintf(DMSG_WARNING, "Sprite #%d (%d,%d) with invalid sector %d was corrected to sector %d\n", index, spr.pos.X, spr.pos.Y, sectnum, sectnum))
{
if (bugged) Printf("Sprite #%d (%d,%d) with invalid sector %d\n", index, spr.pos.X, spr.y, sectnum);
if (bugged) Printf("Sprite #%d (%d,%d) with invalid sector %d\n", index, spr.pos.X, spr.pos.Y, sectnum);
}
}
if (bugged)

4
source/core/maptypes.h
View file

@ -382,7 +382,7 @@ struct spritetypebase
{
// todo: get rid of the single variables!
union {
struct { int32_t BLAHBLAHX, y, z; };
struct { int32_t BLAHBLAHX, BLAHBLAHY, z; };
vec3_t pos;
};
union {
@ -431,7 +431,7 @@ struct spritetypebase
int32_t interpolatedy(double const smoothratio, int const scale = 16)
{
return interpolatedvalue(oy, y, smoothratio, scale);
return interpolatedvalue(oy, pos.Y, smoothratio, scale);
}
int32_t interpolatedz(double const smoothratio, int const scale = 16)

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

@ -607,7 +607,7 @@ void BunchDrawer::ProcessSection(int sectionnum, bool portal)
if ((spr->cstat & CSTAT_SPRITE_INVISIBLE) || spr->xrepeat == 0 || spr->yrepeat == 0) // skip invisible sprites
continue;
int sx = spr->pos.X - iview.X, sy = spr->y - int(iview.Y);
int sx = spr->pos.X - iview.X, sy = spr->pos.Y - int(iview.Y);
// this checks if the sprite is it behind the camera, which will not work if the pitch is high enough to necessitate a FOV of more than 180°.
//if ((spr->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) || (hw_models && tile2model[spr->picnum].modelid >= 0) || ((sx * gcosang) + (sy * gsinang) > 0))

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

@ -670,7 +670,7 @@ bool HWLineToSpritePortal::Setup(HWDrawInfo* di, FRenderState& rstate, Clipper*
di->mClipPortal = this;
auto srccenter = (WallStart(origin) + WallEnd(origin)) / 2;
DVector2 destcenter ={ camera->pos.X / 16.f, camera->y / -16.f };
DVector2 destcenter ={ camera->pos.X / 16.f, camera->pos.Y / -16.f };
DVector2 npos = vp.Pos - srccenter + destcenter;
int origx = vp.Pos.X * 16;

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

@ -333,7 +333,7 @@ void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int
x = spr->pos.X * (1 / 16.f);
z = spr->z * (1 / -256.f);
y = spr->y * (1 / -16.f);
y = spr->pos.Y * (1 / -16.f);
auto vp = di->Viewpoint;
if ((vp.Pos.XY() - DVector2(x, y)).LengthSquared() < 0.125) return;
@ -395,7 +395,7 @@ void HWSprite::Process(HWDrawInfo* di, tspritetype* spr, sectortype* sector, int
float viewvecY = vp.ViewVector.Y;
x = spr->pos.X * (1 / 16.f);
y = spr->y * (1 / -16.f);
y = spr->pos.Y * (1 / -16.f);
z = spr->z * (1 / -256.f);
x1 = x - viewvecY * (xoff - (width * 0.5f));
@ -510,7 +510,7 @@ bool HWSprite::ProcessVoxel(HWDrawInfo* di, voxmodel_t* vox, tspritetype* spr, s
x = (spr->pos.X + sprext->position_offset.X) * (1 / 16.f);
z = zpos * (1 / -256.f);
y = (spr->y + sprext->position_offset.Y) * (1 / -16.f);
y = (spr->pos.Y + sprext->position_offset.Y) * (1 / -16.f);
float zoff = voxel->siz.Z * .5f;
if (!(spr->cstat & CSTAT_SPRITE_YCENTER))

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

@ -120,7 +120,7 @@ static int IsOnWall(tspritetype* tspr, int height)
if ((wal.nextsector == -1 || ((wal.nextSector()->ceilingz > topz) ||
wal.nextSector()->floorz < tspr->z)) && !GetClosestPointOnWall(tspr, &wal, &n))
{
int const dst = abs(tspr->pos.X - n.X) + abs(tspr->y - n.Y);
int const dst = abs(tspr->pos.X - n.X) + abs(tspr->pos.Y - n.Y);
if (dst <= dist)
{

2
source/core/savegamehelp.cpp
View file

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

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

@ -19,7 +19,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
int zCeil, zFloor;
getzsofslopeptr(&sector[nSector], pSprite->pos.X, pSprite->y, &zCeil, &zFloor);
getzsofslopeptr(&sector[nSector], pSprite->pos.X, pSprite->pos.Y, &zCeil, &zFloor);
if (pSprite->statnum == kStatDude && (top < zCeil || bottom > zFloor))
{
int j = i;
@ -37,7 +37,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
pTSprite->type = pSprite->type;
pTSprite->setsector(nSector2);
pTSprite->pos.X = pSprite->pos.X + dx;
pTSprite->y = pSprite->y + dy;
pTSprite->pos.Y = pSprite->pos.Y + dy;
pTSprite->z = pSprite->z + dz;
pTSprite->ang = pSprite->ang;
pTSprite->picnum = pSprite->picnum;
@ -52,7 +52,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
pTSprite->ownerActor = actor;
pTSprite->flags = pSprite->hitag | 0x200;
pTSprite->pos.X = dx + interpolatedvalue(pSprite->ox, pSprite->pos.X, interpolation);
pTSprite->y = dy + interpolatedvalue(pSprite->oy, pSprite->y, interpolation);
pTSprite->pos.Y = dy + interpolatedvalue(pSprite->oy, pSprite->pos.Y, interpolation);
pTSprite->z = dz + interpolatedvalue(pSprite->oz, pSprite->z, interpolation);
pTSprite->ang = pSprite->interpolatedang(interpolation);
@ -62,7 +62,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
case 1:
{
int dX = x - pTSprite->pos.X;
int dY = y - pTSprite->y;
int dY = y - pTSprite->pos.Y;
RotateVector(&dX, &dY, 128 - pTSprite->ang);
nAnim = GetOctant(dX, dY);
if (nAnim <= 4)
@ -79,7 +79,7 @@ void collectTSpritesForPortal(int x, int y, int i, int interpolation)
case 2:
{
int dX = x - pTSprite->pos.X;
int dY = y - pTSprite->y;
int dY = y - pTSprite->pos.Y;
RotateVector(&dX, &dY, 128 - pTSprite->ang);
nAnim = GetOctant(dX, dY);
break;

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

@ -2549,7 +2549,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->y - y;
int dy = pSprite->pos.Y - y;
int dz = (pSprite->z - z) >> 4;
int dist2 = 0x40000 + dx * dx + dy * dy + dz * dz;
assert(dist2 > 0);
@ -2666,7 +2666,7 @@ void actRadiusDamage(DBloodActor* source, int x, int y, int z, sectortype* pSect
if (!CheckProximity(act2, x, y, z, pSector, nDist)) continue;
int dx = abs(x - pSprite2->pos.X);
int dy = abs(y - pSprite2->y);
int dy = abs(y - pSprite2->pos.Y);
int dz = abs(z - pSprite2->z) >> 4;
int dist = ksqrt(dx * dx + dy * dy + dz * dz);
if (dist > nDist) continue;
@ -2696,7 +2696,7 @@ void actRadiusDamage(DBloodActor* source, int x, int y, int z, sectortype* pSect
if (pXSprite2->locked) continue;
int dx = abs(x - pSprite2->pos.X);
int dy = abs(y - pSprite2->y);
int dy = abs(y - pSprite2->pos.Y);
int dist = ksqrt(dx * dx + dy * dy);
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->y, pSprite->z, pSprite->sector(), 128, 0, 60, kDamageExplode, 15, 120);
actRadiusDamage(pOwner, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 128, 0, 60, kDamageExplode, 15, 120);
if (pXSprite->data4 > 1)
{
@ -2763,7 +2763,7 @@ static DBloodActor* actSpawnFloor(DBloodActor* actor)
auto pSprite = &actor->s();
auto pSector = pSprite->sector();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
updatesector(x, y, &pSector);
int zFloor = getflorzofslopeptr(pSector, x, y);
auto spawned = actSpawnSprite(pSector, x, y, zFloor, 3, 0);
@ -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->y, pSprite->z, 780, pSprite->sector());
if (actor->IsPlayerActor()) sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, pSprite->ang);
DBloodActor* pEffectA = gFX.fxSpawnActor((FX_ID)52, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->ang);
if (pEffectA != nullptr)
{
auto pEffect = &pEffectA->s();
@ -3011,7 +3011,7 @@ static bool actKillModernDude(DBloodActor* actor, DAMAGE_TYPE damageType)
int top, bottom;
GetActorExtents(actor, &top, &bottom);
CGibPosition gibPos(pSprite->pos.X, pSprite->y, top);
CGibPosition gibPos(pSprite->pos.X, pSprite->pos.Y, top);
CGibVelocity gibVel(actor->xvel >> 1, actor->yvel >> 1, -0xccccc);
GibSprite(actor, nGibType, &gibPos, &gibVel);
}
@ -3256,7 +3256,7 @@ static void spawnGibs(DBloodActor* actor, int type, int velz)
{
int top, bottom;
GetActorExtents(actor, &top, &bottom);
CGibPosition gibPos(actor->spr.pos.X, actor->spr.y, top);
CGibPosition gibPos(actor->spr.pos.X, actor->spr.pos.Y, top);
CGibVelocity gibVel(actor->xvel >> 1, actor->yvel >> 1, velz);
GibSprite(actor, GIBTYPE_27, &gibPos, &gibVel);
}
@ -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->y, pSprite->z, 312, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pMissile->z, 0);
auto pFX = gFX.fxSpawnActor(FX_52, pMissile->sector(), pMissile->pos.X, pMissile->pos.Y, pMissile->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->y, pMissile->z, 306, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->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->y, pMissile->z, 306, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->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->y, pMissile->z, pMissile->sector(), 16, 20, 10, kDamageBullet, 6, 480);
actRadiusDamage(missileOwner, pMissile->pos.X, pMissile->pos.Y, pMissile->z, pMissile->sector(), 16, 20, 10, kDamageBullet, 6, 480);
// by NoOne: allow additional bullet damage for Flare Gun
if (gGameOptions.weaponsV10x && !VanillaMode())
@ -4026,7 +4026,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
pMissile->picnum = 2123;
missileActor->SetTarget(actorHit);
pXMissile->targetZ = pMissile->z - pSpriteHit->z;
pXMissile->goalAng = getangle(pMissile->pos.X - pSpriteHit->pos.X, pMissile->y - pSpriteHit->y) - pSpriteHit->ang;
pXMissile->goalAng = getangle(pMissile->pos.X - pSpriteHit->pos.X, pMissile->pos.Y - pSpriteHit->pos.Y) - pSpriteHit->ang;
pXMissile->state = 1;
actPostSprite(missileActor, kStatFlare);
pMissile->cstat &= ~CSTAT_SPRITE_BLOCK_ALL;
@ -4081,7 +4081,7 @@ static void actImpactMissile(DBloodActor* missileActor, int hitCode)
case kMissileEctoSkull:
sfxKill3DSound(missileActor, -1, -1);
sfxPlay3DSound(pMissile->pos.X, pMissile->y, pMissile->z, 522, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->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->y, pMissile->z, 518, pMissile->sector());
sfxPlay3DSound(pMissile->pos.X, pMissile->pos.Y, pMissile->z, 518, pMissile->sector());
GibSprite(missileActor, (hitCode == 2) ? GIBTYPE_23 : GIBTYPE_22, NULL, NULL);
evKillActor(missileActor);
seqKill(missileActor);
@ -4226,13 +4226,13 @@ static void checkCeilHit(DBloodActor* actor)
if (pThingInfo->flags & 2) pSprite2->flags |= 4;
// Inlined ?
actor2->xvel += MulScale(4, pSprite2->pos.X - pSprite->pos.X, 2);
actor2->yvel += MulScale(4, pSprite2->y - pSprite->y, 2);
actor2->yvel += MulScale(4, pSprite2->pos.Y - pSprite->pos.Y, 2);
}
else
{
pSprite2->flags |= 5;
actor2->xvel += MulScale(4, pSprite2->pos.X - pSprite->pos.X, 2);
actor2->yvel += MulScale(4, pSprite2->y - pSprite->y, 2);
actor2->yvel += MulScale(4, pSprite2->pos.Y - pSprite->pos.Y, 2);
#ifdef NOONE_EXTENSIONS
// add size shroom abilities
@ -4357,7 +4357,7 @@ static void checkHit(DBloodActor* actor)
break;
case kThingZombieHead:
sfxPlay3DSound(pSprite->pos.X, pSprite->y, pSprite->z, 357, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 357, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 357, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, 357, pSprite->sector());
actDamageSprite(nullptr, actor2, kDamageFall, 80);
break;
case kTrapSawCircular:
@ -4647,7 +4647,7 @@ static Collision MoveThing(DBloodActor* actor)
else
{
assert(pSector);
FindSector(pSprite->pos.X, pSprite->y, pSprite->z, &pSector);
FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector);
}
pSprite->z += actor->zvel >> 8;
@ -4663,7 +4663,7 @@ static Collision MoveThing(DBloodActor* actor)
actor->zvel += 58254;
if (pSprite->type == kThingZombieHead)
{
auto* fxActor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 0);
auto* fxActor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (fxActor)
{
int v34 = (PlayClock * 3) & 2047;
@ -4782,7 +4782,7 @@ static Collision MoveThing(DBloodActor* actor)
if ((hitSpr->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FACING)
{
actor->xvel += MulScale(4, pSprite->pos.X - hitSpr->pos.X, 2);
actor->yvel += MulScale(4, pSprite->y - hitSpr->y, 2);
actor->yvel += MulScale(4, pSprite->pos.Y - hitSpr->pos.Y, 2);
lhit = actor->hit.hit;
}
}
@ -4832,8 +4832,8 @@ void MoveDude(DBloodActor* actor)
if (pPlayer && gNoClip)
{
pSprite->pos.X += actor->xvel >> 12;
pSprite->y += actor->yvel >> 12;
if (!FindSector(pSprite->pos.X, pSprite->y, &pSector))
pSprite->pos.Y += actor->yvel >> 12;
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, &pSector))
pSector = pSprite->sector();
}
else
@ -4919,7 +4919,7 @@ void MoveDude(DBloodActor* actor)
else
{
assert(pSector);
FindSector(pSprite->pos.X, pSprite->y, pSprite->z, &pSector);
FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector);
}
XSECTOR* pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
@ -4969,7 +4969,7 @@ void MoveDude(DBloodActor* actor)
{
if (bUnderwater)
{
int cz = getceilzofslopeptr(pSector, pSprite->pos.X, pSprite->y);
int cz = getceilzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
if (cz > top)
vc += ((bottom - cz) * -80099) / (bottom - top);
else
@ -4977,7 +4977,7 @@ void MoveDude(DBloodActor* actor)
}
else
{
int fz = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->y);
int fz = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
if (fz < bottom)
vc += ((bottom - fz) * -80099) / (bottom - top);
}
@ -5212,17 +5212,17 @@ void MoveDude(DBloodActor* actor)
switch (tileGetSurfType(floorColl))
{
case kSurfWater:
gFX.fxSpawnActor(FX_9, pSprite->sector(), pSprite->pos.X, pSprite->y, floorZ, 0);
gFX.fxSpawnActor(FX_9, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, floorZ, 0);
break;
case kSurfLava:
{
auto pFX = gFX.fxSpawnActor(FX_10, pSprite->sector(), pSprite->pos.X, pSprite->y, floorZ, 0);
auto pFX = gFX.fxSpawnActor(FX_10, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, floorZ, 0);
if (pFX)
{
auto pFXs = &pFX->s();
for (int i = 0; i < 7; i++)
{
auto pFX2 = gFX.fxSpawnActor(FX_14, pFXs->sector(), pFXs->pos.X, pFXs->y, pFXs->z, 0);
auto pFX2 = gFX.fxSpawnActor(FX_14, pFXs->sector(), pFXs->pos.X, pFXs->pos.Y, pFXs->z, 0);
if (pFX2)
{
pFX2->xvel = Random2(0x6aaaa);
@ -5268,7 +5268,7 @@ void MoveDude(DBloodActor* actor)
if ((hitAct->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == CSTAT_SPRITE_ALIGNMENT_FACING)
{
actor->xvel += MulScale(4, pSprite->pos.X - hitAct->spr.pos.X, 2);
actor->yvel += MulScale(4, pSprite->y - hitAct->spr.y, 2);
actor->yvel += MulScale(4, pSprite->pos.Y - hitAct->spr.pos.Y, 2);
return;
}
}
@ -5317,7 +5317,7 @@ int MoveMissile(DBloodActor* actor)
if (pTarget->statnum == kStatDude && pXTarget && pXTarget->health > 0)
{
int nTargetAngle = getangle(-(pTarget->y - pSprite->y), pTarget->pos.X - pSprite->pos.X);
int nTargetAngle = getangle(-(pTarget->pos.Y - pSprite->pos.Y), pTarget->pos.X - pSprite->pos.X);
int vx = missileInfo[pSprite->type - kMissileBase].velocity;
int vy = 0;
RotatePoint(&vx, &vy, (nTargetAngle + 1536) & 2047, 0, 0);
@ -5434,7 +5434,7 @@ int MoveMissile(DBloodActor* actor)
CheckLink(actor);
gHitInfo.hitSector = pSprite->sector();
gHitInfo.hitpos.X = pSprite->pos.X;
gHitInfo.hitpos.Y = pSprite->y;
gHitInfo.hitpos.Y = pSprite->pos.Y;
gHitInfo.hitpos.Z = pSprite->z;
break;
}
@ -5519,7 +5519,7 @@ void actExplodeSprite(DBloodActor* actor)
case kThingTNTBarrel:
{
auto spawned = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 0, 1);
auto spawned = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, sound, pSprite->sector());
if (sound > 0) sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, pSprite->sector(), proxyDist))
if (CheckProximity(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), proxyDist))
{
switch (pSprite->type)
{
@ -5772,7 +5772,7 @@ static void actCheckThings()
{
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->y) <= bottom)
if (getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y) <= bottom)
{
int angle = pXSector->panAngle;
int speed = 0;
@ -5825,7 +5825,7 @@ static void actCheckThings()
case kThingPodGreenBall:
if (hit.type == kHitSector)
{
actRadiusDamage(actor->GetOwner(), pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector(), 200, 1, 20, kDamageExplode, 6, 0);
actRadiusDamage(actor->GetOwner(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 200, 1, 20, kDamageExplode, 6, 0);
evPostActor(actor, 0, kCallbackFXPodBloodSplat);
}
else if (hit.type == kHitSprite)
@ -5892,7 +5892,7 @@ static void actCheckExplosion()
assert(nType >= 0 && nType < kExplodeMax);
const EXPLOSION* pExplodeInfo = &explodeInfo[nType];
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
auto pSector = pSprite->sector();
int radius = pExplodeInfo->radius;
@ -5976,7 +5976,7 @@ static void actCheckExplosion()
{
spritetype* pSprite2 = gPlayer[p].pSprite;
int dx = (x - pSprite2->pos.X) >> 4;
int dy = (y - pSprite2->y) >> 4;
int dy = (y - pSprite2->pos.Y) >> 4;
int dz = (z - pSprite2->z) >> 8;
int nDist = dx * dx + dy * dy + dz * dz + 0x40000;
int t = DivScale(pXSprite->data2, nDist, 16);
@ -6063,7 +6063,7 @@ static void actCheckTraps()
if (pXSprite->state && seqGetStatus(actor) < 0)
{
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
int t = (pXSprite->data1 << 23) / 120;
int dx = MulScale(t, Cos(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->y, pSprite->z, pSprite->sector(), 128))
if (CheckProximity(actor2, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 128))
trTriggerSprite(actor, kCmdSpriteProximity);
}
}
@ -6220,7 +6220,7 @@ static void actCheckDudes()
{
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->y) <= bottom)
if (getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y) <= bottom)
{
int angle = pXSector->panAngle;
int speed = 0;
@ -6275,7 +6275,7 @@ void actCheckFlares()
if (pXTarget && pXTarget->health > 0)
{
int x = pTarget->pos.X + mulscale30r(Cos(pXSprite->goalAng + pTarget->ang), pTarget->clipdist * 2);
int y = pTarget->y + mulscale30r(Sin(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;
vec3_t pos = { x, y, z };
SetActor(actor, &pos);
@ -6351,7 +6351,7 @@ DBloodActor* actSpawnSprite(DBloodActor* source, int nStat)
spritetype* pSprite = &actor->s();
pSprite->pos.X = pSource->pos.X;
pSprite->y = pSource->y;
pSprite->pos.Y = pSource->pos.Y;
pSprite->z = pSource->z;
actor->xvel = source->xvel;
actor->yvel = source->yvel;
@ -6385,12 +6385,12 @@ DBloodActor* actSpawnDude(DBloodActor* source, int nType, int a3, int a4)
if (a3 < 0)
{
x = pSource->pos.X;
y = pSource->y;
y = pSource->pos.Y;
}
else
{
x = pSource->pos.X + mulscale30r(Cos(angle), a3);
y = pSource->y + mulscale30r(Sin(angle), a3);
y = pSource->pos.Y + mulscale30r(Sin(angle), a3);
}
pSprite2->type = nType;
pSprite2->ang = angle;
@ -6544,11 +6544,11 @@ DBloodActor* actFireThing(DBloodActor* actor, int a2, int a3, int a4, int thingT
auto pSprite = &actor->s();
assert(thingType >= kThingBase && thingType < kThingMax);
int x = pSprite->pos.X + MulScale(a2, Cos(pSprite->ang + 512), 30);
int y = pSprite->y + MulScale(a2, Sin(pSprite->ang + 512), 30);
int y = pSprite->pos.Y + MulScale(a2, Sin(pSprite->ang + 512), 30);
int z = pSprite->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->y, 0, CLIPMASK0, pSprite->clipdist) != -1)
if (HitScan(actor, z, x - pSprite->pos.X, y - pSprite->pos.Y, 0, CLIPMASK0, pSprite->clipdist) != -1)
{
x = gHitInfo.hitpos.X - MulScale(pSprite->clipdist << 1, Cos(pSprite->ang), 28);
y = gHitInfo.hitpos.Y - MulScale(pSprite->clipdist << 1, Sin(pSprite->ang), 28);
@ -6659,12 +6659,12 @@ DBloodActor* actFireMissile(DBloodActor* actor, int a2, int a3, int a4, int a5,
auto pSprite = &actor->s();
const MissileType* pMissileInfo = &missileInfo[nType - kMissileBase];
int x = pSprite->pos.X + MulScale(a2, Cos(pSprite->ang + 512), 30);
int y = pSprite->y + MulScale(a2, Sin(pSprite->ang + 512), 30);
int y = pSprite->pos.Y + MulScale(a2, Sin(pSprite->ang + 512), 30);
int z = pSprite->z + a3;
int clipdist = pMissileInfo->clipDist + pSprite->clipdist;
x += MulScale(clipdist, Cos(pSprite->ang), 28);
y += MulScale(clipdist, Sin(pSprite->ang), 28);
int hit = HitScan(actor, z, x - pSprite->pos.X, y - pSprite->y, 0, CLIPMASK0, clipdist);
int hit = HitScan(actor, z, x - pSprite->pos.X, y - pSprite->pos.Y, 0, CLIPMASK0, clipdist);
if (hit != -1)
{
if (hit == 3 || hit == 0)
@ -6853,7 +6853,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->y;
gHitInfo.hitpos.Y = pShooter->pos.Y;
gHitInfo.hitpos.Z = pShooter->z;
}
}
@ -6863,7 +6863,7 @@ void actFireVector(DBloodActor* shooter, int a2, int a3, int a4, int a5, int a6,
int z = gHitInfo.hitpos.Z - MulScale(a6, 256, 14);
auto pSector = gHitInfo.hitSector;
uint8_t nSurf = kSurfNone;
if (nRange == 0 || approxDist(gHitInfo.hitpos.X - pShooter->pos.X, gHitInfo.hitpos.Y - pShooter->y) < nRange)
if (nRange == 0 || approxDist(gHitInfo.hitpos.X - pShooter->pos.X, gHitInfo.hitpos.Y - pShooter->pos.Y) < nRange)
{
switch (hit)
{
@ -6984,7 +6984,7 @@ void actFireVector(DBloodActor* shooter, int a2, int a3, int a4, int a5, int a6,
a6 += Random3(4000);
if (HitScan(actor, gHitInfo.hitpos.Z, a4, a5, a6, CLIPMASK1, t) == 0)
{
if (approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->y) <= t)
if (approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->pos.Y) <= t)
{
auto pWall = gHitInfo.hitWall;
auto pSector = gHitInfo.hitSector;
@ -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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_11, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_12, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_32, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_33, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (pFX)
{
pFX->xvel = actor->xvel;

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

@ -136,7 +136,7 @@ bool CanMove(DBloodActor* actor, DBloodActor* target, int nAngle, int nRange)
int top, bottom;
GetActorExtents(actor, &top, &bottom);
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
HitScan(actor, z, bcos(nAngle), bsin(nAngle), 0, CLIPMASK0, nRange);
int nDist = approxDist(x - gHitInfo.hitpos.X, y - gHitInfo.hitpos.Y);
@ -379,7 +379,7 @@ void aiActivateDude(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
if (!pXSprite->state)
{
aiChooseDirection(actor, getangle(pXSprite->targetX - pSprite->pos.X, pXSprite->targetY - pSprite->y));
aiChooseDirection(actor, getangle(pXSprite->targetX - pSprite->pos.X, pXSprite->targetY - pSprite->pos.Y));
pXSprite->state = 1;
}
switch (pSprite->type)
@ -953,7 +953,7 @@ void aiSetTarget(DBloodActor* actor, DBloodActor* target)
actor->SetTarget(target);
DUDEINFO* pDudeInfo = getDudeInfo(pTarget->type);
pXSprite->targetX = pTarget->pos.X;
pXSprite->targetY = pTarget->y;
pXSprite->targetY = pTarget->pos.Y;
pXSprite->targetZ = pTarget->z - ((pDudeInfo->eyeHeight * pTarget->yrepeat) << 2);
}
}
@ -1534,15 +1534,15 @@ void aiThinkTarget(DBloodActor* actor)
if (actor->GetOwner() == pPlayer->actor || pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
continue;
int nDeltaAngle = ((getangle(dx, dy) + 1024 - pSprite->ang) & 2047) - 1024;
@ -1582,15 +1582,15 @@ void aiLookForTarget(DBloodActor* actor)
if (actor->GetOwner() == pPlayer->actor || pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -1609,14 +1609,14 @@ void aiLookForTarget(DBloodActor* actor)
if (pXSprite->state)
{
const bool newSectCheckMethod = !cl_bloodvanillaenemies && !VanillaMode(); // use new sector checking logic
GetClosestSpriteSectors(pSprite->sector(), pSprite->pos.X, pSprite->y, 400, nullptr, newSectCheckMethod);
GetClosestSpriteSectors(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, 400, nullptr, newSectCheckMethod);
BloodStatIterator it(kStatDude);
while (DBloodActor* actor2 = it.Next())
{
spritetype* pSprite2 = &actor2->s();
int dx = pSprite2->pos.X - pSprite->pos.X;
int dy = pSprite2->y - pSprite->y;
int dy = pSprite2->pos.Y - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (pSprite2->type == kDudeInnocent)
{

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

@ -99,15 +99,15 @@ static void batThinkTarget(DBloodActor* actor)
if (pPlayer->actor->xspr.health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->actor->spr.pos.X;
int y = pPlayer->actor->spr.y;
int y = pPlayer->actor->spr.pos.Y;
int z = pPlayer->actor->spr.z;
auto pSector = pPlayer->actor->spr.sector();
int dx = x - actor->spr.pos.X;
int dy = y - actor->spr.y;
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.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.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)
@ -138,7 +138,7 @@ static void batThinkGoto(DBloodActor* actor)
assert(actor->spr.type >= kDudeBase && actor->spr.type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(actor->spr.type);
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.y;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -159,7 +159,7 @@ static void batThinkPonder(DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto pTarget = actor->GetTarget();
int dx = pTarget->spr.pos.X - actor->spr.pos.X;
int dy = pTarget->spr.y - actor->spr.y;
int dy = pTarget->spr.pos.Y - actor->spr.pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pTarget->xspr.health == 0)
{
@ -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.y, pTarget->spr.z, pTarget->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z - height, actor->spr.sector()))
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()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < 0x3000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -260,7 +260,7 @@ static void batThinkChase(DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
auto pTarget = actor->GetTarget();
int dx = pTarget->spr.pos.X - actor->spr.pos.X;
int dy = pTarget->spr.y - actor->spr.y;
int dy = pTarget->spr.pos.Y - actor->spr.pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pTarget->xspr.health == 0)
{
@ -281,12 +281,12 @@ static void batThinkChase(DBloodActor* actor)
int height2 = (pDudeInfo->eyeHeight * pTarget->spr.yrepeat) << 2;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->spr.pos.X, pTarget->spr.y, pTarget->spr.z, pTarget->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z - height, actor->spr.sector()))
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 (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
int floorZ = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (height2 - height < 0x2000 && nDist < 0x200 && abs(nDeltaAngle) < 85)
aiNewState(actor, &batBite);
else if ((height2 - height > 0x5000 || floorZ - bottom > 0x5000) && nDist < 0x1400 && nDist > 0x800 && abs(nDeltaAngle) < 85)
@ -320,7 +320,7 @@ static void batMoveForward(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
actor->spr.ang = (actor->spr.ang + 256) & 2047;
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.y;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x200)
return;
@ -352,7 +352,7 @@ static void batMoveSwoop(DBloodActor* actor)
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.y;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x200)
return;
@ -382,7 +382,7 @@ static void batMoveFly(DBloodActor* actor)
return;
}
int dx = actor->xspr.targetX - actor->spr.pos.X;
int dy = actor->xspr.targetY - actor->spr.y;
int dy = actor->xspr.targetY - actor->spr.pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x200)
return;
@ -401,7 +401,7 @@ static void batMoveFly(DBloodActor* actor)
void batMoveToCeil(DBloodActor* actor)
{
int x = actor->spr.pos.X;
int y = actor->spr.y;
int y = actor->spr.pos.Y;
int z = actor->spr.z;
if (z - actor->xspr.targetZ < 0x1000)
{

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

@ -85,7 +85,7 @@ void StompSeqCallback(int, DBloodActor* actor1)
int dx = bcos(pSprite->ang);
int dy = bsin(pSprite->ang);
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
int vc = 400;
auto pSector = pSprite->sector();
@ -117,7 +117,7 @@ void StompSeqCallback(int, DBloodActor* actor1)
if (abs(bottom - pSector->floorz) == 0)
{
int dx = abs(pSprite->pos.X - pSprite2->pos.X);
int dy = abs(pSprite->y - pSprite2->y);
int dy = abs(pSprite->pos.Y - pSprite2->pos.Y);
int nDist2 = ksqrt(dx * dx + dy * dy);
if (nDist2 <= vc)
{
@ -147,7 +147,7 @@ void StompSeqCallback(int, DBloodActor* actor1)
if (pXSprite->locked)
continue;
int dx = abs(pSprite->pos.X - pSprite2->pos.X);
int dy = abs(pSprite->y - pSprite2->y);
int dy = abs(pSprite->pos.Y - pSprite2->pos.Y);
int nDist2 = ksqrt(dx * dx + dy * dy);
if (nDist2 <= vc)
{
@ -189,7 +189,7 @@ static void beastThinkGoto(DBloodActor* actor)
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -223,7 +223,7 @@ static void beastThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
auto pSector = pSprite->sector();
@ -250,7 +250,7 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -343,7 +343,7 @@ static void beastThinkSwimGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -366,7 +366,7 @@ static void beastThinkSwimChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -385,7 +385,7 @@ static void beastThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + pSprite->z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -419,7 +419,7 @@ static void beastMoveForward(DBloodActor* actor)
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x400 && Random(64) < 32)
return;
@ -442,7 +442,7 @@ static void sub_628A0(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
@ -480,7 +480,7 @@ static void sub_62AE0(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -517,7 +517,7 @@ static void sub_62D7C(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -115,15 +115,15 @@ static void eelThinkTarget(DBloodActor* actor)
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -159,7 +159,7 @@ static void eelThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -181,7 +181,7 @@ static void eelThinkPonder(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
aiSetTarget(actor, actor->GetTarget());
if (height2 - height < -0x2000 && nDist < 0x1800 && nDist > 0xc00 && abs(nDeltaAngle) < 85)
@ -287,7 +287,7 @@ static void eelThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -345,7 +345,7 @@ static void eelMoveForward(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (nDist <= 0x399)
return;
@ -376,7 +376,7 @@ static void eelMoveSwoop(DBloodActor* actor)
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x8000) && nDist <= 0x399)
return;
@ -405,7 +405,7 @@ static void eelMoveAscend(DBloodActor* actor)
if (abs(nAng) > 341)
return;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x399)
return;
@ -426,7 +426,7 @@ void eelMoveToCeil(DBloodActor* actor)
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
if (z - pXSprite->targetZ < 0x1000)
{

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

@ -88,7 +88,7 @@ static void burnThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -162,7 +162,7 @@ static void burnThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -99,7 +99,7 @@ static void calebThinkGoto(DBloodActor* actor)
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -132,7 +132,7 @@ static void calebThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -158,7 +158,7 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -220,7 +220,7 @@ static void calebThinkSwimGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -242,7 +242,7 @@ static void calebThinkSwimChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -261,7 +261,7 @@ static void calebThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + pSprite->z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -293,7 +293,7 @@ static void sub_65D04(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
@ -332,7 +332,7 @@ static void sub_65F44(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -370,7 +370,7 @@ static void sub_661E0(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -81,7 +81,7 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
if (!actor->ValidateTarget(__FUNCTION__)) return;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = height; // ???
TARGETTRACK tt1 = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
@ -96,7 +96,7 @@ void cerberusBurnSeqCallback(int, DBloodActor* actor)
if (pSprite == pSprite2 || !(pSprite2->flags & 8))
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->y;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
@ -158,7 +158,7 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
int height = pDudeInfo->eyeHeight * pSprite->yrepeat;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = height; // ???
TARGETTRACK tt1 = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
@ -175,7 +175,7 @@ void cerberusBurnSeqCallback2(int, DBloodActor* actor)
if (pSprite == pSprite2 || !(pSprite2->flags & 8))
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->y;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
@ -270,15 +270,15 @@ static void cerberusThinkTarget(DBloodActor* actor)
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -311,7 +311,7 @@ static void cerberusThinkGoto(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -356,7 +356,7 @@ static void cerberusThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0) {
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

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

@ -135,7 +135,7 @@ void cultThrowSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
@ -169,7 +169,7 @@ void sub_68230(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int nDist = approxDist(dx, dy);
int nDist2 = nDist / 540;
@ -202,7 +202,7 @@ static void cultThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -245,7 +245,7 @@ static void cultThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -284,7 +284,7 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -110,7 +110,7 @@ void BlastSSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
int height = (pSprite->yrepeat * getDudeInfo(pSprite->type)->eyeHeight) << 2;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
@ -125,7 +125,7 @@ void BlastSSeqCallback(int, DBloodActor* actor)
if (pSprite == pSprite2 || !(pSprite2->flags & 8))
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->y;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
@ -227,15 +227,15 @@ static void gargThinkTarget(DBloodActor* actor)
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -275,7 +275,7 @@ static void gargThinkGoto(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -361,7 +361,7 @@ static void gargThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -382,12 +382,12 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
int floorZ = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
switch (pSprite->type)
{
case kDudeGargoyleFlesh:
@ -556,7 +556,7 @@ static void gargMoveForward(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
return;
@ -594,7 +594,7 @@ static void gargMoveSlow(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -638,7 +638,7 @@ static void gargMoveSwoop(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -681,7 +681,7 @@ static void gargMoveFly(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;

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

@ -96,7 +96,7 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
int height = (pSprite->yrepeat * getDudeInfo(pSprite->type)->eyeHeight) << 2;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x1aaaaa };
Aim aim;
@ -111,7 +111,7 @@ void ghostBlastSeqCallback(int, DBloodActor* actor)
if (pSprite == pSprite2 || !(pSprite2->flags & 8))
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->y;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
@ -207,15 +207,15 @@ static void ghostThinkTarget(DBloodActor* actor)
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -254,7 +254,7 @@ static void ghostThinkGoto(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -341,7 +341,7 @@ static void ghostThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -362,12 +362,12 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
aiSetTarget(actor, actor->GetTarget());
int floorZ = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
int floorZ = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
switch (pSprite->type) {
case kDudePhantasm:
if (nDist < 0x2000 && nDist > 0x1000 && abs(nDeltaAngle) < 85) {
@ -451,7 +451,7 @@ static void ghostMoveForward(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
return;
@ -489,7 +489,7 @@ static void ghostMoveSlow(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -530,7 +530,7 @@ static void ghostMoveSwoop(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
return;
@ -570,7 +570,7 @@ static void ghostMoveFly(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)
return;

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

@ -90,7 +90,7 @@ static void gillThinkGoto(DBloodActor* actor)
auto pXSector = pSector->hasX() ? &pSector->xs() : nullptr;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -124,7 +124,7 @@ static void gillThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -147,7 +147,7 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -208,7 +208,7 @@ static void gillThinkSwimGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -231,7 +231,7 @@ static void gillThinkSwimChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -250,7 +250,7 @@ static void gillThinkSwimChase(DBloodActor* actor)
int height = pDudeInfo->eyeHeight + pSprite->z;
int top, bottom;
GetActorExtents(actor, &top, &bottom);
if (cansee(pTarget->pos.X, pTarget->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -288,7 +288,7 @@ static void sub_6CB00(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if (Random(64) < 32 && nDist <= 0x400)
return;
@ -326,7 +326,7 @@ static void sub_6CD74(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dz = z2 - z;
int nDist = approxDist(dx, dy);
if (Chance(0x600) && nDist <= 0x400)
@ -363,7 +363,7 @@ static void sub_6D03C(DBloodActor* actor)
return;
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int dz = (z2 - z) << 3;
int nDist = approxDist(dx, dy);
if (Chance(0x4000) && nDist <= 0x400)

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

@ -70,7 +70,7 @@ static void handThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -93,7 +93,7 @@ static void handThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -89,7 +89,7 @@ static void houndThinkGoto(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -115,7 +115,7 @@ static void houndThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -55,7 +55,7 @@ static void innocThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -79,7 +79,7 @@ static void innocThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -69,7 +69,7 @@ void podAttack(int, DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int x = pTarget->pos.X - pSprite->pos.X;
int y = pTarget->y - pSprite->y;
int y = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
x += Random2(1000);
y += Random2(1000);
@ -125,7 +125,7 @@ void sub_70284(int, DBloodActor* actor)
nDist = 75;
break;
}
actRadiusDamage(actor, pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
actRadiusDamage(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), nDist, 1, 5 * (1 + gGameOptions.nDifficulty), dmgType, 2, nBurn);
}
static void aiPodSearch(DBloodActor* actor)
@ -147,7 +147,7 @@ static void aiPodMove(DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -191,7 +191,7 @@ static void aiPodChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0) {
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -67,7 +67,7 @@ static void ratThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -89,7 +89,7 @@ static void ratThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -143,7 +143,7 @@ void SpidBirthSeqCallback(int, DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
DUDEEXTRA_STATS* pDudeExtraE = &actor->dudeExtra.stats;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
@ -181,7 +181,7 @@ static void spidThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -203,7 +203,7 @@ static void spidThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector())) {
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector())) {
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery) {
aiSetTarget(actor, actor->GetTarget());

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

@ -63,7 +63,7 @@ void sub_71BD4(int, DBloodActor* actor)
int height = pSprite->yrepeat * pDudeInfo->eyeHeight;
if (!actor->ValidateTarget(__FUNCTION__)) return;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x100000 };
Aim aim;
@ -78,7 +78,7 @@ void sub_71BD4(int, DBloodActor* actor)
if (pSprite == pSprite2 || !(pSprite2->flags & 8))
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->y;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
@ -136,7 +136,7 @@ void sub_720AC(int, DBloodActor* actor)
ax = bcos(pSprite->ang);
ay = bsin(pSprite->ang);
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = height;
TARGETTRACK tt = { 0x10000, 0x10000, 0x100, 0x55, 0x100000 };
Aim aim;
@ -152,7 +152,7 @@ void sub_720AC(int, DBloodActor* actor)
if (pSprite == pSprite2 || !(pSprite2->flags & 8))
continue;
int x2 = pSprite2->pos.X;
int y2 = pSprite2->y;
int y2 = pSprite2->pos.Y;
int z2 = pSprite2->z;
int nDist = approxDist(x2 - x, y2 - y);
if (nDist == 0 || nDist > 0x2800)
@ -235,15 +235,15 @@ static void sub_725A4(DBloodActor* actor)
if (pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -276,7 +276,7 @@ static void sub_72850(DBloodActor* actor)
}
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -303,7 +303,7 @@ static void sub_72934(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (nDist < pDudeInfo->seeDist && abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -326,7 +326,7 @@ static void ThrowThing(DBloodActor* actor, bool impact)
int zThrow = 14500;
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dz = pTarget->z - pSprite->z;
int dist = approxDist(dx, dy);
@ -440,7 +440,7 @@ static void unicultThinkGoto(DBloodActor* actor)
}
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
aiChooseDirection(actor,nAngle);
@ -506,7 +506,7 @@ static void unicultThinkChase(DBloodActor* actor)
// check target
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
int dist = ClipLow((int)approxDist(dx, dy), 1);
// quick hack to prevent spinning around or changing attacker's sprite angle on high movement speeds
@ -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->y, pTarget->z, pTarget->sector(),
pSprite->pos.X, pSprite->y, pSprite->z - eyeAboveZ, pSprite->sector()))
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 (spriteIsUnderwater(actor, false)) aiGenDudeNewState(actor, &genDudeSearchW);
else aiGenDudeNewState(actor, &genDudeSearchL);
@ -606,8 +606,8 @@ static void unicultThinkChase(DBloodActor* actor)
}
int ldist = aiFightGetTargetDist(targetactor, pDudeInfo, actLeech);
if (ldist > 3 || !cansee(pTarget->pos.X, pTarget->y, pTarget->z, pTarget->sector(),
pLeech->pos.X, pLeech->y, pLeech->z, pLeech->sector()) || actLeech->GetTarget() == nullptr)
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)
{
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->y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pTarget->z, pTarget->sector(), pExpl->radius >> 1))
if (CheckProximity(actor, pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pExpl->radius >> 1))
{
actor->xvel = actor->yvel = actor->zvel = 0;
if (doExplosion(actor, nType) && pXSprite->health > 0)
@ -776,7 +776,7 @@ static void unicultThinkChase(DBloodActor* actor)
if (hit >= 0)
{
targetDist = dist - (pTarget->clipdist << 2);
objDist = approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->y);
objDist = approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->pos.Y);
}
if (actor != gHitInfo.actor() && targetDist > objDist)
@ -894,7 +894,7 @@ static void unicultThinkChase(DBloodActor* actor)
bool immune = nnExtIsImmune(hitactor, gVectorData[curWeapon].dmgType);
if (!(pXHSprite != NULL && (!immune || (immune && pHSprite->statnum == kStatThing && pXHSprite->Vector)) && !pXHSprite->locked))
{
if ((approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->y) <= 1500 && !blck)
if ((approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->pos.Y) <= 1500 && !blck)
|| (dist <= (int)(pExtra->fireDist / ClipLow(Random(4), 1))))
{
//viewSetSystemMessage("GO CHASE");
@ -969,8 +969,8 @@ static void unicultThinkChase(DBloodActor* actor)
case kMissileFireballTchernobog:
{
// allow attack if dude is far from object, but target is close to it
int dudeDist = approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->y);
int targetDist = approxDist(gHitInfo.hitpos.X - pTarget->pos.X, gHitInfo.hitpos.Y - pTarget->y);
int dudeDist = approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->pos.Y);
int targetDist = approxDist(gHitInfo.hitpos.X - pTarget->pos.X, gHitInfo.hitpos.Y - pTarget->pos.Y);
if (dudeDist < mdist)
{
//viewSetSystemMessage("DUDE CLOSE TO OBJ: %d, MDIST: %d", dudeDist, mdist);
@ -1156,7 +1156,7 @@ void aiGenDudeMoveForward(DBloodActor* actor)
if (actor->GetTarget() == nullptr)
pSprite->ang = (pSprite->ang + 256) & 2047;
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nDist = approxDist(dx, dy);
if ((unsigned int)Random(64) < 32 && nDist <= 0x400)
return;
@ -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->y, pLeech->z, pLeech->ang);
auto effectactor = gFX.fxSpawnActor((FX_ID)52, pLeech->sector(), pLeech->pos.X, pLeech->pos.Y, pLeech->z, pLeech->ang);
if (effectactor != NULL)
{
spritetype* pEffect = &effectactor->s();
@ -1842,16 +1842,16 @@ void dudeLeechOperate(DBloodActor* actor, const EVENT& event)
int nType = pTarget->type - kDudeBase;
DUDEINFO* pDudeInfo = &dudeInfo[nType];
int z1 = (top - pSprite->z) - 256;
int x = pTarget->pos.X; int y = pTarget->y; int z = pTarget->z;
int nDist = approxDist(x - pSprite->pos.X, y - pSprite->y);
int x = pTarget->pos.X; int y = pTarget->pos.Y; int z = pTarget->z;
int nDist = approxDist(x - pSprite->pos.X, y - pSprite->pos.Y);
if (nDist != 0 && cansee(pSprite->pos.X, pSprite->y, top, pSprite->sector(), x, y, z, pTarget->sector()))
if (nDist != 0 && cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), x, y, z, pTarget->sector()))
{
int t = DivScale(nDist, 0x1aaaaa, 12);
x += (actTarget->xvel * t) >> 12;
y += (actTarget->yvel * t) >> 12;
int angBak = pSprite->ang;
pSprite->ang = getangle(x - pSprite->pos.X, y - pSprite->y);
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;
@ -1887,7 +1887,7 @@ bool doExplosion(DBloodActor* actor, int nType)
{
auto const pSprite = &actor->s();
auto actExplosion = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, kStatExplosion, true);
auto actExplosion = actSpawnSprite(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, kStatExplosion, true);
auto const pExplosion = &actExplosion->s();
auto const pXExplosion = &actExplosion->x();
if (!actExplosion->hasX())
@ -1943,13 +1943,13 @@ DBloodActor* genDudeSpawn(DBloodActor* source, DBloodActor* actor, int nDist)
{
x = pSprite->pos.X + mulscale30r(Cos(nAngle), nDist);
y = pSprite->y + mulscale30r(Sin(nAngle), nDist);
y = pSprite->pos.Y + mulscale30r(Sin(nAngle), nDist);
}
else
{
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
}
@ -2124,7 +2124,7 @@ void genDudeTransform(DBloodActor* actor)
aiInitSprite(actor);
// try to restore target
if (target == nullptr) aiSetTarget(actor, pSprite->pos.X, pSprite->y, pSprite->z);
if (target == nullptr) aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z);
aiSetTarget(slave[i], pSprite->pos.X, pSprite->pos.Y, pSprite->z);
}
else
{
aiSetTarget(slave[i], pSprite->pos.X, pSprite->y, pSprite->z); // try return to master
aiSetTarget(slave[i], pSprite->pos.X, pSprite->pos.Y, pSprite->z); // try return to master
}
}
}

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

@ -67,7 +67,7 @@ void HackSeqCallback(int, DBloodActor* actor)
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
DUDEINFO* pDudeInfoT = getDudeInfo(pTarget->type);
int tx = pXSprite->targetX - pSprite->pos.X;
int ty = pXSprite->targetY - pSprite->y;
int ty = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(tx, ty);
int height = (pSprite->yrepeat * pDudeInfo->eyeHeight) << 2;
int height2 = (pTarget->yrepeat * pDudeInfoT->eyeHeight) << 2;
@ -97,7 +97,7 @@ static void zombaThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -120,7 +120,7 @@ static void zombaThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -171,7 +171,7 @@ static void zombaThinkPonder(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{
@ -221,15 +221,15 @@ static void myThinkTarget(DBloodActor* actor)
if (owneractor == nullptr || owneractor == pPlayer->actor || pPlayer->pXSprite->health == 0 || powerupCheck(pPlayer, kPwUpShadowCloak) > 0)
continue;
int x = pPlayer->pSprite->pos.X;
int y = pPlayer->pSprite->y;
int y = pPlayer->pSprite->pos.Y;
int z = pPlayer->pSprite->z;
auto pSector = pPlayer->pSprite->sector();
int dx = x - pSprite->pos.X;
int dy = y - pSprite->y;
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->y, pSprite->z - ((pDudeInfo->eyeHeight * pSprite->yrepeat) << 2), pSprite->sector()))
if (!cansee(x, y, z, pSector, pSprite->pos.X, pSprite->pos.Y, pSprite->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)
@ -278,7 +278,7 @@ static void entryEStand(DBloodActor* actor)
auto pXSprite = &actor->x();
auto pSprite = &actor->s();
sfxPlay3DSound(actor, 1100, -1, 0);
pSprite->ang = getangle(pXSprite->targetX - pSprite->pos.X, pXSprite->targetY - pSprite->y);
pSprite->ang = getangle(pXSprite->targetX - pSprite->pos.X, pXSprite->targetY - pSprite->pos.Y);
}
END_BLD_NS

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

@ -70,7 +70,7 @@ void PukeSeqCallback(int, DBloodActor* actor)
int height = (pDudeInfo->eyeHeight * pSprite->yrepeat);
int height2 = (pDudeInfoT->eyeHeight * pTarget->yrepeat);
int tx = pXSprite->targetX - pSprite->pos.X;
int ty = pXSprite->targetY - pSprite->y;
int ty = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(tx, ty);
int dx = bcos(nAngle);
int dy = bsin(nAngle);
@ -98,7 +98,7 @@ static void zombfThinkGoto(DBloodActor* actor)
assert(pSprite->type >= kDudeBase && pSprite->type < kDudeMax);
DUDEINFO* pDudeInfo = getDudeInfo(pSprite->type);
int dx = pXSprite->targetX - pSprite->pos.X;
int dy = pXSprite->targetY - pSprite->y;
int dy = pXSprite->targetY - pSprite->pos.Y;
int nAngle = getangle(dx, dy);
int nDist = approxDist(dx, dy);
aiChooseDirection(actor, nAngle);
@ -121,7 +121,7 @@ static void zombfThinkChase(DBloodActor* actor)
spritetype* pTarget = &actor->GetTarget()->s();
XSPRITE* pXTarget = &actor->GetTarget()->x();
int dx = pTarget->pos.X - pSprite->pos.X;
int dy = pTarget->y - pSprite->y;
int dy = pTarget->pos.Y - pSprite->pos.Y;
aiChooseDirection(actor, getangle(dx, dy));
if (pXTarget->health == 0)
{
@ -138,7 +138,7 @@ 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->y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->y, pSprite->z - height, pSprite->sector()))
if (cansee(pTarget->pos.X, pTarget->pos.Y, pTarget->z, pTarget->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - height, pSprite->sector()))
{
if (abs(nDeltaAngle) <= pDudeInfo->periphery)
{

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

@ -90,7 +90,7 @@ tspritetype* viewInsertTSprite(tspritetype* tsprite, int& spritesortcnt, sectort
pTSprite->ang = parentTSprite->ang;
}
pTSprite->pos.X += Cos(gCameraAng)>>25;
pTSprite->y += Sin(gCameraAng)>>25;
pTSprite->pos.Y += Sin(gCameraAng)>>25;
return pTSprite;
}
@ -172,7 +172,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
RotateYZ(&x, &y, &z, nRand1);
RotateXZ(&x, &y, &z, nRand2);
pNSprite->pos.X = pTSprite->pos.X + x;
pNSprite->y = pTSprite->y + y;
pNSprite->pos.Y = pTSprite->pos.Y + y;
pNSprite->z = pTSprite->z + (z<<4);
pNSprite->picnum = 1720;
pNSprite->shade = -128;
@ -274,10 +274,10 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
int x = MulScale(nLen, Cos(nAng), 30);
pNSprite->pos.X = pTSprite->pos.X + x;
int y = MulScale(nLen, Sin(nAng), 30);
pNSprite->y = pTSprite->y + y;
pNSprite->pos.Y = pTSprite->pos.Y + y;
pNSprite->z = pTSprite->z;
assert(pSector);
FindSector(pNSprite->pos.X, pNSprite->y, pNSprite->z, &pSector);
FindSector(pNSprite->pos.X, pNSprite->pos.Y, pNSprite->z, &pSector);
pNSprite->setsector(pSector);
pNSprite->ownerActor = pTSprite->ownerActor;
pNSprite->picnum = pTSprite->picnum;
@ -378,7 +378,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
if (!pNSprite)
break;
pNSprite->z = getflorzofslopeptr(pTSprite->sector(), pNSprite->pos.X, pNSprite->y);
pNSprite->z = getflorzofslopeptr(pTSprite->sector(), pNSprite->pos.X, pNSprite->pos.Y);
pNSprite->shade = 127;
pNSprite->cstat |= CSTAT_SPRITE_TRANSLUCENT;
pNSprite->xrepeat = pTSprite->xrepeat;
@ -414,7 +414,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
sectortype *pSector = pTSprite->sector();
pNSprite->pos.X = pTSprite->pos.X;
pNSprite->y = pTSprite->y;
pNSprite->pos.Y = pTSprite->pos.Y;
pNSprite->z = pSector->ceilingz;
pNSprite->picnum = 624;
pNSprite->shade = ((pTSprite->z-pSector->ceilingz)>>8)-64;
@ -433,7 +433,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
sectortype *pSector = pTSprite->sector();
pNSprite->pos.X = pTSprite->pos.X;
pNSprite->y = pTSprite->y;
pNSprite->pos.Y = pTSprite->pos.Y;
pNSprite->z = pSector->floorz;
pNSprite->picnum = 624;
uint8_t nShade = (pSector->floorz-pTSprite->z)>>8;
@ -472,7 +472,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
break;
pNSprite->pos.X = pTSprite->pos.X;
pNSprite->y = pTSprite->y;
pNSprite->pos.Y = pTSprite->pos.Y;
pNSprite->z = pTSprite->z-(32<<8);
pNSprite->z -= weaponIcon.zOffset<<8; // offset up
pNSprite->picnum = nTile;
@ -489,7 +489,7 @@ static tspritetype *viewAddEffect(tspritetype* tsprite, int& spritesortcnt, int
if (pPlayer->curWeapon == kWeapLifeLeech) // position lifeleech behind player
{
pNSprite->pos.X += MulScale(128, Cos(gView->pSprite->ang), 30);
pNSprite->y += MulScale(128, Sin(gView->pSprite->ang), 30);
pNSprite->pos.Y += MulScale(128, Sin(gView->pSprite->ang), 30);
}
if ((pPlayer->curWeapon == kWeapLifeLeech) || (pPlayer->curWeapon == kWeapVoodooDoll)) // make lifeleech/voodoo doll always face viewer like sprite
pNSprite->ang = (pNSprite->ang + 512) & 2047; // offset angle 90 degrees
@ -572,7 +572,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
break;
}
int dX = cX - pTSprite->pos.X;
int dY = cY - pTSprite->y;
int dY = cY - pTSprite->pos.Y;
RotateVector(&dX, &dY, 128-pTSprite->ang);
nAnim = GetOctant(dX, dY);
if (nAnim <= 4)
@ -594,7 +594,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
break;
}
int dX = cX - pTSprite->pos.X;
int dY = cY - pTSprite->y;
int dY = cY - pTSprite->pos.Y;
RotateVector(&dX, &dY, 128-pTSprite->ang);
nAnim = GetOctant(dX, dY);
break;
@ -610,7 +610,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
{
int top, bottom;
GetSpriteExtents(pTSprite, &top, &bottom);
if (getflorzofslopeptr(pTSprite->sector(), pTSprite->pos.X, pTSprite->y) > bottom)
if (getflorzofslopeptr(pTSprite->sector(), pTSprite->pos.X, pTSprite->pos.Y) > bottom)
nAnim = 1;
}
break;
@ -864,7 +864,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
if (pNTSprite) {
POSTURE *pPosture = &pPlayer->pPosture[pPlayer->lifeMode][pPlayer->posture];
pNTSprite->pos.X += MulScale(pPosture->zOffset, Cos(pTSprite->ang), 28);
pNTSprite->y += MulScale(pPosture->zOffset, Sin(pTSprite->ang), 28);
pNTSprite->pos.Y += MulScale(pPosture->zOffset, Sin(pTSprite->ang), 28);
pNTSprite->z = pPlayer->pSprite->z-pPosture->xOffset;
}
}
@ -890,7 +890,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
}
if (pTSprite->ownerActor != gView->actor || gViewPos != VIEWPOS_0) {
if (getflorzofslopeptr(pTSprite->sector(), pTSprite->pos.X, pTSprite->y) >= cZ)
if (getflorzofslopeptr(pTSprite->sector(), pTSprite->pos.X, pTSprite->pos.Y) >= cZ)
{
viewAddEffect(tsprite, spritesortcnt, nTSprite, kViewEffectShadow);
}
@ -922,7 +922,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
if (pTSprite->type < kThingBase || pTSprite->type >= kThingMax || owneractor->hit.florhit.type == kHitNone)
{
if ((pTSprite->flags & kPhysMove) && getflorzofslopeptr(pTSprite->sector(), pTSprite->pos.X, pTSprite->y) >= cZ)
if ((pTSprite->flags & kPhysMove) && getflorzofslopeptr(pTSprite->sector(), pTSprite->pos.X, pTSprite->pos.Y) >= cZ)
viewAddEffect(tsprite, spritesortcnt, nTSprite, kViewEffectShadow);
}
}
@ -939,7 +939,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
case 1:
{
int dX = cX - pTSprite->pos.X;
int dY = cY - pTSprite->y;
int dY = cY - pTSprite->pos.Y;
RotateVector(&dX, &dY, 128-pTSprite->ang);
nAnim = GetOctant(dX, dY);
if (nAnim <= 4)
@ -956,7 +956,7 @@ void viewProcessSprites(tspritetype* tsprite, int& spritesortcnt, int32_t cX, in
case 2:
{
int dX = cX - pTSprite->pos.X;
int dY = cY - pTSprite->y;
int dY = cY - pTSprite->pos.Y;
RotateVector(&dX, &dY, 128-pTSprite->ang);
nAnim = GetOctant(dX, dY);
break;

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

@ -57,7 +57,7 @@ void ambProcess(void)
if (pXSprite->state)
{
int dx = pSprite->pos.X-gMe->pSprite->pos.X;
int dy = pSprite->y-gMe->pSprite->y;
int dy = pSprite->pos.Y-gMe->pSprite->pos.Y;
int dz = pSprite->z-gMe->pSprite->z;
dx >>= 4;
dy >>= 4;

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

@ -44,7 +44,7 @@ void fxFlameLick(DBloodActor* actor, sectortype*) // 0
int dx = MulScale(nDist, Cos(nAngle), 30);
int dy = MulScale(nDist, Sin(nAngle), 30);
int x = pSprite->pos.X + dx;
int y = pSprite->y + dy;
int y = pSprite->pos.Y + dy;
int z = bottom-Random(bottom-top);
auto pFX = gFX.fxSpawnActor(FX_32, pSprite->sector(), x, y, z, 0);
if (pFX)
@ -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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_28, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_28, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x1aaaa);
@ -137,7 +137,7 @@ void fxZombieBloodSpurt(DBloodActor* actor, sectortype*) // 5
XSPRITE *pXSprite = &actor->x();
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
auto pFX = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->y, top, 0);
auto pFX = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, top, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x11111);
@ -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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_15, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x10000);
@ -196,7 +196,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->y + MulScale(nDist, Sin(pSprite->ang-512), 30);
int y = pSprite->pos.Y + MulScale(nDist, Sin(pSprite->ang-512), 30);
int z = pSprite->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->y, pSprite->z, 0);
gFX.fxSpawnActor(FX_29, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
sfxPlay3DSound(actor, 350, -1, 0);
break;
}
@ -310,7 +310,7 @@ void PlayerBubble(DBloodActor* actor, sectortype*) // 10
int nDist = (pSprite->xrepeat*(tileWidth(pSprite->picnum)/2))>>2;
int nAngle = Random(2048);
int x = pSprite->pos.X + MulScale(nDist, Cos(nAngle), 30);
int y = pSprite->y + MulScale(nDist, Sin(nAngle), 30);
int y = pSprite->pos.Y + MulScale(nDist, Sin(nAngle), 30);
int z = bottom-Random(bottom-top);
auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23+Random(3)), pSprite->sector(), x, y, z, 0);
if (pFX)
@ -335,7 +335,7 @@ void EnemyBubble(DBloodActor* actor, sectortype*) // 11
int nDist = (pSprite->xrepeat*(tileWidth(pSprite->picnum)/2))>>2;
int nAngle = Random(2048);
int x = pSprite->pos.X + MulScale(nDist, Cos(nAngle), 30);
int y = pSprite->y + MulScale(nDist, Sin(nAngle), 30);
int y = pSprite->pos.Y + MulScale(nDist, Sin(nAngle), 30);
int z = bottom-Random(bottom-top);
auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23+Random(3)), pSprite->sector(), x, y, z, 0);
if (pFX)
@ -397,7 +397,7 @@ void fxBloodBits(DBloodActor* actor, sectortype*) // 14
int nAngle = Random(2048);
int nDist = Random(16)<<4;
int x = pSprite->pos.X+MulScale(nDist, Cos(nAngle), 28);
int y = pSprite->y+MulScale(nDist, Sin(nAngle), 28);
int y = pSprite->pos.Y+MulScale(nDist, Sin(nAngle), 28);
gFX.fxSpawnActor(FX_48, pSprite->sector(), x, y, pSprite->z, 0);
if (pSprite->ang == 1024)
{
@ -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->y, pSprite->z, 0);
auto pFX = gFX.fxSpawnActor(FX_49, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (pFX)
{
pFX->xvel = actor->xvel + Random2(0x1aaaa);
@ -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->y, pSprite->z, 0);
pFX = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
else
pFX = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 0);
pFX = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (pFX)
{
pFX->spr.ang = 0;
@ -554,7 +554,7 @@ void fxPodBloodSplat(DBloodActor* actor, sectortype*) // 19
int nAngle = Random(2048);
int nDist = Random(16)<<4;
int x = pSprite->pos.X+MulScale(nDist, Cos(nAngle), 28);
int y = pSprite->y+MulScale(nDist, Sin(nAngle), 28);
int y = pSprite->pos.Y+MulScale(nDist, Sin(nAngle), 28);
if (pSprite->ang == 1024)
{
int nChannel = 28 + (actor->GetIndex() & 2);
@ -603,7 +603,7 @@ void sub_76A08(DBloodActor *actor, DBloodActor *actor2, PLAYER *pPlayer) // ???
auto pSprite2 = &actor2->s();
GetSpriteExtents(pSprite, &top, &bottom);
pSprite->pos.X = pSprite2->pos.X;
pSprite->y = pSprite2->y;
pSprite->pos.Y = pSprite2->pos.Y;
pSprite->z = pSprite2->sector()->floorz-(bottom-pSprite->z);
pSprite->ang = pSprite2->ang;
ChangeActorSect(actor, pSprite2->sector());
@ -638,7 +638,7 @@ void DropVoodooCb(DBloodActor* actor, sectortype*) // unused
evPostActor(actor, 0, kCallbackRemove);
return;
}
pSprite->ang = getangle(pOwner->pos.X-pSprite->pos.X, pOwner->y-pSprite->y);
pSprite->ang = getangle(pOwner->pos.X-pSprite->pos.X, pOwner->pos.Y-pSprite->pos.Y);
if (actor->hasX())
{
XSPRITE *pXSprite = &actor->x();

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

@ -522,7 +522,7 @@ void dbLoadMap(const char* pPath, int* pX, int* pY, int* pZ, short* pAngle, sect
auto pSprite = &sprites.sprites[i];
pSprite->clear();
pSprite->pos.X = LittleLong(load.x);
pSprite->y = LittleLong(load.y);
pSprite->pos.Y = LittleLong(load.y);
pSprite->z = LittleLong(load.z);
pSprite->cstat = ESpriteFlags::FromInt(LittleShort(load.cstat));
pSprite->picnum = LittleShort(load.picnum);

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

@ -202,18 +202,18 @@ void CFX::fxProcess(void)
FXDATA *pFXData = &gFXData[pSprite->type];
actAirDrag(actor, pFXData->drag);
pSprite->pos.X += actor->xvel>>12;
pSprite->y += actor->yvel>>12;
pSprite->pos.Y += actor->yvel>>12;
pSprite->z += actor->zvel>>8;
// Weird...
if (actor->xvel || (actor->yvel && pSprite->z >= pSprite->sector()->floorz))
{
updatesector(pSprite->pos.X, pSprite->y, &pSector);
updatesector(pSprite->pos.X, pSprite->pos.Y, &pSector);
if (pSector == nullptr)
{
remove(actor);
continue;
}
if (getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y) <= pSprite->z)
if (getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) <= pSprite->z)
{
if (pFXData->funcID < 0 || pFXData->funcID >= kCallbackMax)
{
@ -232,7 +232,7 @@ void CFX::fxProcess(void)
if (actor->xvel || actor->yvel || actor->zvel)
{
int32_t floorZ, ceilZ;
getzsofslopeptr(pSector, pSprite->pos.X, pSprite->y, &ceilZ, &floorZ);
getzsofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y, &ceilZ, &floorZ);
if (ceilZ > pSprite->z && !(pSector->ceilingstat & CSTAT_SECTOR_SKY))
{
remove(actor);
@ -259,11 +259,11 @@ void fxSpawnBlood(DBloodActor *actor, int )
if (!pSprite->insector())
return;
auto pSector = pSprite->sector();
if (!FindSector(pSprite->pos.X, pSprite->y, pSprite->z, &pSector))
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector))
return;
if (adult_lockout && gGameOptions.nGameType <= 0)
return;
auto bloodactor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 0);
auto bloodactor = gFX.fxSpawnActor(FX_27, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, &pSector))
if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z, 0);
spawnactor = gFX.fxSpawnActor(FX_53, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
else
spawnactor = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 0);
spawnactor = gFX.fxSpawnActor(FX_54, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (spawnactor)
{
spawnactor->spr.ang = 1024;
@ -303,7 +303,7 @@ void fxSpawnEjectingBrass(DBloodActor* actor, int z, int a3, int a4)
{
auto pSprite = &actor->s();
int x = pSprite->pos.X + MulScale(pSprite->clipdist - 4, Cos(pSprite->ang), 28);
int y = pSprite->y + MulScale(pSprite->clipdist - 4, Sin(pSprite->ang), 28);
int y = pSprite->pos.Y + MulScale(pSprite->clipdist - 4, Sin(pSprite->ang), 28);
x += MulScale(a3, Cos(pSprite->ang + 512), 30);
y += MulScale(a3, Sin(pSprite->ang + 512), 30);
auto pBrass = gFX.fxSpawnActor((FX_ID)(FX_37 + Random(3)), pSprite->sector(), x, y, z, 0);
@ -323,7 +323,7 @@ void fxSpawnEjectingShell(DBloodActor* actor, int z, int a3, int a4)
{
auto pSprite = &actor->s();
int x = pSprite->pos.X + MulScale(pSprite->clipdist - 4, Cos(pSprite->ang), 28);
int y = pSprite->y + MulScale(pSprite->clipdist - 4, Sin(pSprite->ang), 28);
int y = pSprite->pos.Y + MulScale(pSprite->clipdist - 4, Sin(pSprite->ang), 28);
x += MulScale(a3, Cos(pSprite->ang + 512), 30);
y += MulScale(a3, Sin(pSprite->ang + 512), 30);
auto pShell = gFX.fxSpawnActor((FX_ID)(FX_40 + Random(3)), pSprite->sector(), x, y, z, 0);

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

@ -109,7 +109,7 @@ bool CheckProximity(DBloodActor *actor, int nX, int nY, int nZ, sectortype* pSec
int oX = abs(nX-pSprite->pos.X)>>4;
if (oX >= nDist) return 0;
int oY = abs(nY-pSprite->y)>>4;
int oY = abs(nY-pSprite->pos.Y)>>4;
if (oY >= nDist) return 0;
int oZ = abs(nZ-pSprite->z)>>8;
@ -119,11 +119,11 @@ bool CheckProximity(DBloodActor *actor, int nX, int nY, int nZ, sectortype* pSec
int bottom, top;
GetActorExtents(actor, &top, &bottom);
if (cansee(pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector(), nX, nY, nZ, pSector))
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), nX, nY, nZ, pSector))
return 1;
if (cansee(pSprite->pos.X, pSprite->y, bottom, pSprite->sector(), nX, nY, nZ, pSector))
if (cansee(pSprite->pos.X, pSprite->pos.Y, bottom, pSprite->sector(), nX, nY, nZ, pSector))
return 1;
if (cansee(pSprite->pos.X, pSprite->y, top, pSprite->sector(), nX, nY, nZ, pSector))
if (cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), nX, nY, nZ, pSector))
return 1;
return 0;
}
@ -342,7 +342,7 @@ int HitScan(DBloodActor *actor, int z, int dx, int dy, int dz, unsigned int nMas
assert(dx != 0 || dy != 0);
gHitInfo.clearObj();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
auto bakCstat = pSprite->cstat;
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
if (nRange)
@ -386,7 +386,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
assert(pSprite != NULL);
gHitInfo.clearObj();
int x1 = pSprite->pos.X+MulScale(nOffset, Cos(pSprite->ang+512), 30);
int y1 = pSprite->y+MulScale(nOffset, Sin(pSprite->ang+512), 30);
int y1 = pSprite->pos.Y+MulScale(nOffset, Sin(pSprite->ang+512), 30);
int z1 = pSprite->z+nZOffset;
auto bakCstat = pSprite->cstat;
pSprite->cstat &= ~CSTAT_SPRITE_BLOCK_HITSCAN;
@ -406,7 +406,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
pSprite->cstat = bakCstat;
while (nNum--)
{
if (nRange && approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->y) > nRange)
if (nRange && approxDist(gHitInfo.hitpos.X - pSprite->pos.X, gHitInfo.hitpos.Y - pSprite->pos.Y) > nRange)
return -1;
if (gHitInfo.actor() != nullptr)
{
@ -433,7 +433,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
{
int width = (tileWidth(nPicnum)*pOther->xrepeat)>>2;
width = (width*3)/4;
int check1 = ((y1 - pOther->y)*dx - (x1 - pOther->pos.X)*dy) / ksqrt(dx*dx+dy*dy);
int check1 = ((y1 - pOther->pos.Y)*dx - (x1 - pOther->pos.X)*dy) / ksqrt(dx*dx+dy*dy);
assert(width > 0);
int width2 = scale(check1, tileWidth(nPicnum), width);
int nOffset = tileLeftOffset(nPicnum);
@ -528,7 +528,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
auto link = actor->GetOwner();
gHitInfo.clearObj();
x1 = gHitInfo.hitpos.X + link->spr.pos.X - actor->spr.pos.X;
y1 = gHitInfo.hitpos.Y + link->spr.y - actor->spr.y;
y1 = gHitInfo.hitpos.Y + link->spr.pos.Y - actor->spr.pos.Y;
z1 = gHitInfo.hitpos.Z + link->spr.z - actor->spr.z;
pos = { x1, y1, z1 };
hitscan(pos, link->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);
@ -542,7 +542,7 @@ int VectorScan(DBloodActor *actor, int nOffset, int nZOffset, int dx, int dy, in
auto link = actor->GetOwner();
gHitInfo.clearObj();
x1 = gHitInfo.hitpos.X + link->spr.pos.X - actor->spr.pos.X;
y1 = gHitInfo.hitpos.Y + link->spr.y - actor->spr.y;
y1 = gHitInfo.hitpos.Y + link->spr.pos.Y - actor->spr.pos.Y;
z1 = gHitInfo.hitpos.Z + link->spr.z - actor->spr.z;
pos = { x1, y1, z1 };
hitscan(pos, link->spr.sector(), { dx, dy, dz << 4 }, gHitInfo, CLIPMASK1);

6
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->y, pSprite->z);
CGibPosition gPos(pSprite->pos.X, pSprite->pos.Y, pSprite->z);
if (pPos)
gPos = *pPos;
int32_t ceilZ, floorZ;
@ -285,7 +285,7 @@ void GibFX(DBloodActor* actor, GIBFX *pGFX, CGibPosition *pPos, CGibVelocity *pV
{
int nAngle = Random(2048);
gPos.x = pSprite->pos.X+MulScale(pSprite->clipdist<<2, Cos(nAngle), 30);
gPos.y = pSprite->y+MulScale(pSprite->clipdist<<2, Sin(nAngle), 30);
gPos.y = pSprite->pos.Y+MulScale(pSprite->clipdist<<2, Sin(nAngle), 30);
gPos.z = bottom-Random(bottom-top);
}
auto pFX = gFX.fxSpawnActor(pGFX->fxId, pSector, gPos.x, gPos.y, gPos.z, 0);
@ -351,7 +351,7 @@ void GibThing(DBloodActor* actor, GIBTHING *pGThing, CGibPosition *pPos, CGibVel
{
int nAngle = Random(2048);
x = pSprite->pos.X+MulScale(pSprite->clipdist<<2, Cos(nAngle), 30);
y = pSprite->y+MulScale(pSprite->clipdist<<2, Sin(nAngle), 30);
y = pSprite->pos.Y+MulScale(pSprite->clipdist<<2, Sin(nAngle), 30);
z = bottom-Random(bottom-top);
}
else

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

@ -126,7 +126,7 @@ void InitMirrors(void)
I_Error("Lower link sector %d doesn't have mirror picnum\n", j);
mirror[mirrorcnt].type = 2;
mirror[mirrorcnt].dx = link2->spr.pos.X - link->spr.pos.X;
mirror[mirrorcnt].dy = link2->spr.y - link->spr.y;
mirror[mirrorcnt].dy = link2->spr.pos.Y - link->spr.pos.Y;
mirror[mirrorcnt].dz = link2->spr.z - link->spr.z;
mirror[mirrorcnt].wallnum = i;
mirror[mirrorcnt].link = j;
@ -136,7 +136,7 @@ void InitMirrors(void)
mirrorcnt++;
mirror[mirrorcnt].type = 1;
mirror[mirrorcnt].dx = link->spr.pos.X - link2->spr.pos.X;
mirror[mirrorcnt].dy = link->spr.y - link2->spr.y;
mirror[mirrorcnt].dy = link->spr.pos.Y - link2->spr.pos.Y;
mirror[mirrorcnt].dz = link->spr.z - link2->spr.z;
mirror[mirrorcnt].wallnum = j;
mirror[mirrorcnt].link = i;

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

@ -271,12 +271,12 @@ static DBloodActor* nnExtSpawnDude(DBloodActor* sourceActor, DBloodActor* origin
if (a3 < 0)
{
x = pOrigin->pos.X;
y = pOrigin->y;
y = pOrigin->pos.Y;
}
else
{
x = pOrigin->pos.X + mulscale30r(Cos(angle), a3);
y = pOrigin->y + mulscale30r(Sin(angle), a3);
y = pOrigin->pos.Y + mulscale30r(Sin(angle), a3);
}
vec3_t pos = { x, y, z };
@ -969,7 +969,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->y = pSource->y;
pSprite2->pos.Y = pSource->pos.Y;
pSprite2->z = pSource->z;
if ((pSource->flags & kModernTypeFlag1) && (pXSource->txID > 0 || (pXSource->txID != 3 && pXSource->lockMsg > 0)))
@ -1179,7 +1179,7 @@ void nnExtProcessSuperSprites()
int okDist = (pProx->IsDudeActor()) ? 96 : ClipLow(pProxSpr->clipdist * 3, 32);
int x = pProxSpr->pos.X;
int y = pProxSpr->y;
int y = pProxSpr->pos.Y;
int z = pProxSpr->z;
auto pSect = pProxSpr->sector();
@ -1237,7 +1237,7 @@ void nnExtProcessSuperSprites()
}
int x = pSightSpr->pos.X;
int y = pSightSpr->y;
int y = pSightSpr->pos.Y;
int z = pSightSpr->z;
auto pSightSect = pSightSpr->sector();
int ztop2, zbot2;
@ -1250,7 +1250,7 @@ void nnExtProcessSuperSprites()
spritetype* pPlaySprite = pPlayer->pSprite;
GetSpriteExtents(pPlaySprite, &ztop2, &zbot2);
if (cansee(x, y, z, pSightSect, pPlaySprite->pos.X, pPlaySprite->y, ztop2, pPlaySprite->sector()))
if (cansee(x, y, z, pSightSect, pPlaySprite->pos.X, pPlaySprite->pos.Y, ztop2, pPlaySprite->sector()))
{
if (pXSightSpr->Sight)
{
@ -1315,7 +1315,7 @@ void nnExtProcessSuperSprites()
if (pXSector != nullptr)
{
if ((uwater = pXSector->Underwater) != 0) airVel <<= 6;
if (pXSector->panVel != 0 && getflorzofslopeptr(pDebris->sector(), pDebris->pos.X, pDebris->y) <= bottom)
if (pXSector->panVel != 0 && getflorzofslopeptr(pDebris->sector(), pDebris->pos.X, pDebris->pos.Y) <= bottom)
{
int angle = pXSector->panAngle; int speed = 0;
if (pXSector->panAlways || pXSector->state || pXSector->busy)
@ -1380,8 +1380,8 @@ void nnExtProcessSuperSprites()
else if (ang > pXDebris->goalAng) pDebris->ang = ClipLow(ang - angStep, pXDebris->goalAng);
auto pSector = pDebris->sector();
int cz = getceilzofslopeptr(pSector, pDebris->pos.X, pDebris->y);
int fz = getflorzofslopeptr(pSector, pDebris->pos.X, pDebris->y);
int cz = getceilzofslopeptr(pSector, pDebris->pos.X, pDebris->pos.Y);
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);
@ -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->y - y; int dz = (pSprite->z - z) >> 4;
int dx = pSprite->pos.X - x; int dy = pSprite->pos.Y - y; int dz = (pSprite->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;
@ -1630,7 +1630,7 @@ void debrisBubble(DBloodActor* actor)
int nDist = (pSprite->xrepeat * (tileWidth(pSprite->picnum) >> 1)) >> 2;
int nAngle = Random(2048);
int x = pSprite->pos.X + MulScale(nDist, Cos(nAngle), 30);
int y = pSprite->y + MulScale(nDist, Sin(nAngle), 30);
int y = pSprite->pos.Y + MulScale(nDist, Sin(nAngle), 30);
int z = bottom - Random(bottom - top);
auto pFX = gFX.fxSpawnActor((FX_ID)(FX_23 + Random(3)), pSprite->sector(), x, y, z, 0);
if (pFX) {
@ -1713,7 +1713,7 @@ void debrisMove(int listIndex)
}
}
else if (!FindSector(pSprite->pos.X, pSprite->y, pSprite->z, &pSector))
else if (!FindSector(pSprite->pos.X, pSprite->pos.Y, pSprite->z, &pSector))
{
return;
}
@ -1739,8 +1739,8 @@ void debrisMove(int listIndex)
if ((pXSprite->physAttr & kPhysDebrisSwim) && uwater)
{
int vc = 0;
int cz = getceilzofslopeptr(pSector, pSprite->pos.X, pSprite->y);
int fz = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->y);
int cz = getceilzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
int fz = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
int div = ClipLow(bottom - top, 1);
if (pSector->lowerLink) cz += (cz < 0) ? 0x500 : -0x500;
@ -1818,17 +1818,17 @@ void debrisMove(int listIndex)
switch (tileGetSurfType(floorColl))
{
case kSurfLava:
if ((pFX = gFX.fxSpawnActor(FX_10, pSprite->sector(), pSprite->pos.X, pSprite->y, floorZ, 0)) == NULL) break;
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.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.z, 0)) == NULL) continue;
pFX2->xvel = Random2(0x6aaaa);
pFX2->yvel = Random2(0x6aaaa);
pFX2->zvel = -(int)Random(0xd5555);
}
break;
case kSurfWater:
gFX.fxSpawnActor(FX_9, pSprite->sector(), pSprite->pos.X, pSprite->y, floorZ, 0);
gFX.fxSpawnActor(FX_9, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, floorZ, 0);
break;
}
@ -1873,7 +1873,7 @@ void debrisMove(int listIndex)
if ((floorColl.actor()->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK) == 0)
{
actor->xvel += MulScale(4, pSprite->pos.X - floorColl.actor()->spr.pos.X, 2);
actor->yvel += MulScale(4, pSprite->y - floorColl.actor()->spr.y, 2);
actor->yvel += MulScale(4, pSprite->pos.Y - floorColl.actor()->spr.pos.Y, 2);
return;
}
}
@ -3000,7 +3000,7 @@ void useTeleportTarget(DBloodActor* sourceactor, DBloodActor* actor)
if (pSprite->sector() != pSource->sector())
ChangeActorSect(actor, pSource->sector());
pSprite->pos.X = pSource->pos.X; pSprite->y = pSource->y;
pSprite->pos.X = pSource->pos.X; pSprite->pos.Y = pSource->pos.Y;
int zTop, zBot;
GetActorExtents(sourceactor, &zTop, &zBot);
pSprite->z = zBot;
@ -3164,7 +3164,7 @@ void useEffectGen(DBloodActor* sourceactor, DBloodActor* actor)
break;
}
if ((pEffect = gFX.fxSpawnActor((FX_ID)fxId, pSprite->sector(), pSprite->pos.X, pSprite->y, pos, 0)) != NULL)
if ((pEffect = gFX.fxSpawnActor((FX_ID)fxId, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pos, 0)) != NULL)
{
auto pEffectSpr = &pEffect->s();
pEffect->SetOwner(sourceactor);
@ -3583,7 +3583,7 @@ void useSeqSpawnerGen(DBloodActor* sourceactor, int objType, sectortype* pSector
auto pSpawned = &spawned->s();
int top, bottom; GetActorExtents(spawned, &top, &bottom);
pSpawned->pos.X = pSprite->pos.X;
pSpawned->y = pSprite->y;
pSpawned->pos.Y = pSprite->pos.Y;
switch (pXSource->data3)
{
default:
@ -4268,7 +4268,7 @@ bool condCheckDude(DBloodActor* aCond, int cmpOp, bool PUSH)
DUDEINFO* pInfo = getDudeInfo(pSpr->type);
int eyeAboveZ = pInfo->eyeHeight * pSpr->yrepeat << 2;
int dx = pTrgt->pos.X - pSpr->pos.X;
int dy = pTrgt->y - pSpr->y;
int dy = pTrgt->pos.Y - pSpr->pos.Y;
switch (cond)
{
@ -4277,7 +4277,7 @@ bool condCheckDude(DBloodActor* aCond, int cmpOp, bool PUSH)
break;
case 3:
case 4:
var = cansee(pSpr->pos.X, pSpr->y, pSpr->z, pSpr->sector(), pTrgt->pos.X, pTrgt->y, pTrgt->z - eyeAboveZ, pTrgt->sector());
var = cansee(pSpr->pos.X, pSpr->pos.Y, pSpr->z, pSpr->sector(), pTrgt->pos.X, pTrgt->pos.Y, pTrgt->z - eyeAboveZ, pTrgt->sector());
if (cond == 4 && var > 0)
{
var = ((1024 + getangle(dx, dy) - pSpr->ang) & 2047) - 1024;
@ -4978,7 +4978,7 @@ bool aiFightDudeCanSeeTarget(DBloodActor* dudeactor, DUDEINFO* pDudeInfo, DBlood
auto pDude = &dudeactor->s();
auto pTarget = &targetactor->s();
int dx = pTarget->pos.X - pDude->pos.X; int dy = pTarget->y - pDude->y;
int dx = pTarget->pos.X - pDude->pos.X; int dy = pTarget->pos.Y - pDude->pos.Y;
// check target
if (approxDist(dx, dy) < pDudeInfo->seeDist)
@ -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->y, pDude->z, pDude->sector(), pTarget->pos.X, pTarget->y, pTarget->z - eyeAboveZ, pTarget->sector()))
if (cansee(pDude->pos.X, pDude->pos.Y, pDude->z, pDude->sector(), pTarget->pos.X, pTarget->pos.Y, pTarget->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.y, targetactor->spr.z);
aiSetTarget(targetactor, targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.z);
}
}
@ -5143,7 +5143,7 @@ void aiFightAlarmDudesInSight(DBloodActor* actor, int max)
continue;
auto pDude = &dudeactor->s();
aiSetTarget(dudeactor, pDude->pos.X, pDude->y, pDude->z);
aiSetTarget(dudeactor, pDude->pos.X, pDude->pos.Y, pDude->z);
aiActivateDude(dudeactor);
if (max-- < 1)
break;
@ -5177,7 +5177,7 @@ bool aiFightIsMeleeUnit(DBloodActor* dude)
int aiFightGetTargetDist(DBloodActor* actor, DUDEINFO* pDudeInfo, DBloodActor* target)
{
int dx = target->spr.pos.X - actor->spr.pos.X;
int dy = target->spr.y - actor->spr.y;
int dy = target->spr.pos.Y - actor->spr.pos.Y;
int dist = approxDist(dx, dy);
if (dist <= pDudeInfo->meleeDist) return 0;
@ -5205,7 +5205,7 @@ int aiFightGetTargetDist(DBloodActor* actor, DUDEINFO* pDudeInfo, DBloodActor* t
int aiFightGetFineTargetDist(DBloodActor* actor, DBloodActor* target)
{
int dx = target->spr.pos.X - actor->spr.pos.X;
int dy = target->spr.y - actor->spr.y;
int dy = target->spr.pos.Y - actor->spr.pos.Y;
int dist = approxDist(dx, dy);
return dist;
@ -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->y == pSource->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->z == pSource->z)
{
gFX.fxSpawnActor((FX_ID)29, pSource->sector(), pSource->pos.X, pSource->y, pSource->z, 0);
gFX.fxSpawnActor((FX_ID)29, pSource->sector(), pSource->pos.X, pSource->pos.Y, pSource->z, 0);
pItem->type = kSpriteDecoration;
actPostSprite(iactor, kStatFree);
break;
@ -6469,12 +6469,12 @@ void sprite2sectorSlope(DBloodActor* actor, sectortype* pSector, char rel, bool
int slope = 0, z = 0;
switch (rel) {
default:
z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) && actor->hasX() && actor->x().Touch) z--;
slope = pSector->floorheinum;
break;
case 1:
z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
if ((pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_FLOOR) && actor->hasX() && actor->x().Touch) z++;
slope = pSector->ceilingheinum;
break;
@ -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->y) - kSlopeDist <= spr->z)
else if (getflorzofslopeptr(pSect, spr->pos.X, spr->pos.Y) - kSlopeDist <= spr->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->y) + kSlopeDist >= spr->z)
else if (getceilzofslopeptr(pSect, spr->pos.X, spr->pos.Y) + kSlopeDist >= spr->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->y) - kSlopeDist <= pSpr->z) sprite2sectorSlope(objActor, pSpr->sector(), 0, flag2);
if (getceilzofslopeptr(pSpr->sector(), pSpr->pos.X, pSpr->y) + kSlopeDist >= pSpr->z) sprite2sectorSlope(objActor, pSpr->sector(), 1, flag2);
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);
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->y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiSetGenIdleState(actor);
if (pSprite->type == kDudeModernCustom && actLeech)
removeLeech(actLeech);
}
else if (pXSource->data4 == 4)
{
aiSetTarget(actor, pPlayer->pos.X, pPlayer->y, pPlayer->z);
aiSetTarget(actor, pPlayer->pos.X, pPlayer->pos.Y, pPlayer->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->y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pTarget->z);
aiSetTarget(targetactor, pTarget->pos.X, pTarget->pos.Y, pTarget->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->y, pMate->z);
aiSetTarget(mateactor, pMate->pos.X, pMate->pos.Y, pMate->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->y, pMate->z);
aiSetTarget(mateactor, pMate->pos.X, pMate->pos.Y, pMate->z);
}
}
// force dude stop attack mate, if target was not changed previously
if (actor == mateactor)
aiSetTarget(actor, pSprite->pos.X, pSprite->y, pSprite->z);
aiSetTarget(actor, pSprite->pos.X, pSprite->pos.Y, pSprite->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.y, targetactor->spr.z);
aiSetTarget(targetactor, targetactor->spr.pos.X, targetactor->spr.pos.Y, targetactor->spr.z);
if (!isActive(newtargactor))
aiActivateDude(newtargactor);
}
@ -6992,7 +6992,7 @@ void useTargetChanger(DBloodActor* sourceactor, DBloodActor* actor)
actor->SetTarget(pMateTargetActor);
spritetype* pMate = &pMateTargetActor->GetTarget()->s();
pXSprite->targetX = pMate->pos.X;
pXSprite->targetY = pMate->y;
pXSprite->targetY = pMate->pos.Y;
pXSprite->targetZ = pMate->z;
if (!isActive(actor))
aiActivateDude(actor);
@ -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->y, z = pSprite->z;
int x = pSprite->pos.X, y = pSprite->pos.Y, z = pSprite->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);
@ -7692,7 +7692,7 @@ bool aiPatrolMarkerReached(DBloodActor* actor)
spritetype* pMarker = &markeractor->s();
int okDist = ClipLow(pMarker->clipdist << 1, 4);
int oX = abs(pMarker->pos.X - pSprite->pos.X) >> 4;
int oY = abs(pMarker->y - pSprite->y) >> 4;
int oY = abs(pMarker->pos.Y - pSprite->pos.Y) >> 4;
if (approxDist(oX, oY) <= okDist)
{
@ -7794,11 +7794,11 @@ void aiPatrolSetMarker(DBloodActor* actor)
auto pNext = &nextactor->s();
auto pXNext = &nextactor->x();
if (pXNext->locked || pXNext->isTriggered || pXNext->DudeLockout || (dist = approxDist(pNext->pos.X - pSprite->pos.X, pNext->y - pSprite->y)) > closest)
if (pXNext->locked || pXNext->isTriggered || pXNext->DudeLockout || (dist = approxDist(pNext->pos.X - pSprite->pos.X, pNext->pos.Y - pSprite->pos.Y)) > closest)
continue;
GetActorExtents(nextactor, &zt1, &zb1);
if (cansee(pNext->pos.X, pNext->y, zt1, pNext->sector(), pSprite->pos.X, pSprite->y, zt2, pSprite->sector()))
if (cansee(pNext->pos.X, pNext->pos.Y, zt1, pNext->sector(), pSprite->pos.X, pSprite->pos.Y, zt2, pSprite->sector()))
{
closest = dist;
selected = nextactor;
@ -7995,7 +7995,7 @@ void aiPatrolMove(DBloodActor* actor)
const DUDEINFO_EXTRA* pExtra = &gDudeInfoExtra[dudeIdx];
int dx = (pTarget->pos.X - pSprite->pos.X);
int dy = (pTarget->y - pSprite->y);
int dy = (pTarget->pos.Y - pSprite->pos.Y);
int dz = (pTarget->z - (pSprite->z - pDudeInfo->eyeHeight)) * 6;
int vel = (pXSprite->unused1 & kDudeFlagCrouch) ? kMaxPatrolCrouchVelocity : kMaxPatrolVelocity;
int goalAng = 341;
@ -8077,11 +8077,11 @@ void aiPatrolAlarmLite(DBloodActor* actor, DBloodActor* targetactor)
continue;
int eaz2 = (getDudeInfo(pTarget->type)->eyeHeight * pTarget->yrepeat) << 2;
int nDist = approxDist(pDude->pos.X - pSprite->pos.X, pDude->y - pSprite->y);
if (nDist >= kPatrolAlarmSeeDist || !cansee(pSprite->pos.X, pSprite->y, zt1, pSprite->sector(), pDude->pos.X, pDude->y, pDude->z - eaz2, pDude->sector()))
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()))
{
nDist = approxDist(pDude->pos.X - pTarget->pos.X, pDude->y - pTarget->y);
if (nDist >= kPatrolAlarmSeeDist || !cansee(pTarget->pos.X, pTarget->y, zt2, pTarget->sector(), pDude->pos.X, pDude->y, pDude->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()))
continue;
}
@ -8113,13 +8113,13 @@ 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->y, z2 = pSprite->z - eaz2;
int x2 = pSprite->pos.X, y2 = pSprite->pos.Y, z2 = pSprite->z - eaz2;
auto pSect2 = pSprite->sector();
int tzt, tzb;
GetActorExtents(targetactor, &tzt, &tzb);
int x3 = pTarget->pos.X, y3 = pTarget->y, z3 = tzt;
int x3 = pTarget->pos.X, y3 = pTarget->pos.Y, z3 = tzt;
auto pSect3 = pTarget->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->y, z1 = pDude->z - eaz1;
int x1 = pDude->pos.X, y1 = pDude->pos.Y, z1 = pDude->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->y, pSprite->z);
else aiSetTarget(dudeactor, pSprite->pos.X, pSprite->pos.Y, pSprite->z);
aiActivateDude(dudeactor);
if (chain)
@ -8215,7 +8215,7 @@ bool readyForCrit(DBloodActor* hunter, DBloodActor* victim)
int dx, dy;
dx = pVictim->pos.X - pHunter->pos.X;
dy = pVictim->y - pHunter->y;
dy = pVictim->pos.Y - pHunter->pos.Y;
if (approxDist(dx, dy) >= (7000 / ClipLow(gGameOptions.nDifficulty >> 1, 1)))
return false;
@ -8264,7 +8264,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
newtarget = nullptr;
seeChance = hearChance = 0x0000;
x = pSpr->pos.X, y = pSpr->y, z = pSpr->z, dx = x - pSprite->pos.X, dy = y - pSprite->y; nDist = approxDist(dx, dy);
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);
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->y, pSprite->z - eyeAboveZ, pSprite->sector()))
if (!cansee(x, y, z, pSpr->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z - eyeAboveZ, pSprite->sector()))
continue;
}
else
@ -8302,7 +8302,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
auto emitterActor = (DBloodActor*)chan->Source;
if (emitterActor == nullptr) return false; // not a valid source.
sndx = emitterActor->spr.pos.X;
sndy = emitterActor->spr.y;
sndy = emitterActor->spr.pos.Y;
// sound attached to the sprite
if (pPlayer->actor != emitterActor && emitterActor->GetOwner() != actor)
@ -8320,7 +8320,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
searchsect = &sector[chan->UserData];
}
if (searchsect == nullptr) return false;
int nDist = approxDist(sndx - pSprite->pos.X, sndy - pSprite->y);
int nDist = approxDist(sndx - pSprite->pos.X, sndy - pSprite->pos.Y);
if (nDist > hearDist) return false;
@ -8457,7 +8457,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
if (pXSteal->data1 > 0)
{
if (approxDist(abs(pSteal->pos.X - pSpr->pos.X) >> 4, abs(pSteal->y - pSpr->y) >> 4) >= pXSteal->data1)
if (approxDist(abs(pSteal->pos.X - pSpr->pos.X) >> 4, abs(pSteal->pos.Y - pSpr->pos.Y) >> 4) >= pXSteal->data1)
continue;
}
@ -8472,7 +8472,7 @@ DBloodActor* aiPatrolSearchTargets(DBloodActor* actor)
{
if (pXSteal->data1 > 0)
{
if (approxDist(abs(pSteal->pos.X - pSprite->pos.X) >> 4, abs(pSteal->y - pSprite->y) >> 4) >= pXSteal->data1)
if (approxDist(abs(pSteal->pos.X - pSprite->pos.X) >> 4, abs(pSteal->pos.Y - pSprite->pos.Y) >> 4) >= pXSteal->data1)
continue;
}
@ -8814,7 +8814,7 @@ void aiPatrolThink(DBloodActor* actor)
}
}
nnExtAiSetDirection(actor, getangle(pMarker->pos.X - pSprite->pos.X, pMarker->y - pSprite->y));
nnExtAiSetDirection(actor, getangle(pMarker->pos.X - pSprite->pos.X, pMarker->pos.Y - pSprite->pos.Y));
if (aiPatrolMoving(pXSprite->aiState) && !reached) return;
else if (uwater) aiPatrolState(actor, kAiStatePatrolMoveW);
@ -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->y) - zBot, 0);
pSprite->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->y) - zTop, 0);
pSprite->z += ClipLow(getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) - zTop, 0);
}

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

@ -37,7 +37,7 @@ void GameInterface::WarpToCoords(int x, int y, int z, int ang, int horz)
VIEW* pView = &gPrevView[myconnectindex];
pPlayer->pSprite->pos.X = pView->x = gView->pSprite->pos.X = x;
pPlayer->pSprite->y = pView->y = gView->pSprite->y = y;
pPlayer->pSprite->pos.Y = pView->y = gView->pSprite->pos.Y = y;
pPlayer->zView = pView->viewz = gView->zView = z;
if (ang != INT_MIN)

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

@ -641,7 +641,7 @@ void playerStart(int nPlayer, int bNewLevel)
while (auto act = it.Next())
{
spritetype* pSprite = &act->s();
if (pStartZone->x == pSprite->pos.X && pStartZone->y == pSprite->y && IsPlayerSprite(pSprite)) {
if (pStartZone->x == pSprite->pos.X && pStartZone->y == pSprite->pos.Y && IsPlayerSprite(pSprite)) {
pStartZone = NULL;
break;
}
@ -1091,7 +1091,7 @@ bool PickupItem(PLAYER *pPlayer, DBloodActor* itemactor)
return 1;
}
sfxPlay3DSound(pSprite->pos.X, pSprite->y, pSprite->z, pickupSnd, pSprite->sector());
sfxPlay3DSound(pSprite->pos.X, pSprite->pos.Y, pSprite->z, pickupSnd, pSprite->sector());
return 1;
}
@ -1203,7 +1203,7 @@ void CheckPickUp(PLAYER *pPlayer)
{
spritetype *pSprite = pPlayer->pSprite;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
auto pSector = pSprite->sector();
BloodStatIterator it(kStatItem);
@ -1215,7 +1215,7 @@ void CheckPickUp(PLAYER *pPlayer)
int dx = abs(x-pItem->pos.X)>>4;
if (dx > 48)
continue;
int dy = abs(y-pItem->y)>>4;
int dy = abs(y-pItem->pos.Y)>>4;
if (dy > 48)
continue;
int top, bottom;
@ -1230,9 +1230,9 @@ void CheckPickUp(PLAYER *pPlayer)
if (approxDist(dx,dy) > 48)
continue;
GetSpriteExtents(pItem, &top, &bottom);
if (cansee(x, y, z, pSector, pItem->pos.X, pItem->y, pItem->z, pItem->sector())
|| cansee(x, y, z, pSector, pItem->pos.X, pItem->y, top, pItem->sector())
|| cansee(x, y, z, pSector, pItem->pos.X, pItem->y, bottom, pItem->sector()))
if (cansee(x, y, z, pSector, pItem->pos.X, pItem->pos.Y, pItem->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);
}
}
@ -1245,7 +1245,7 @@ int ActionScan(PLAYER *pPlayer, HitInfo* out)
int y = bsin(pSprite->ang);
int z = pPlayer->slope;
int hit = HitScan(pPlayer->actor, pPlayer->zView, x, y, z, 0x10000040, 128);
int hitDist = approxDist(pSprite->pos.X-gHitInfo.hitpos.X, pSprite->y-gHitInfo.hitpos.Y)>>4;
int hitDist = approxDist(pSprite->pos.X-gHitInfo.hitpos.X, pSprite->pos.Y-gHitInfo.hitpos.Y)>>4;
if (hitDist < 64)
{
switch (hit)
@ -1377,7 +1377,7 @@ void ProcessInput(PLAYER *pPlayer)
DBloodActor* fragger = pPlayer->fragger;
if (fragger)
{
pPlayer->angle.addadjustment(getincanglebam(pPlayer->angle.ang, bvectangbam(fragger->spr.pos.X - pSprite->pos.X, fragger->spr.y - pSprite->y)));
pPlayer->angle.addadjustment(getincanglebam(pPlayer->angle.ang, bvectangbam(fragger->spr.pos.X - pSprite->pos.X, fragger->spr.pos.Y - pSprite->pos.Y)));
}
pPlayer->deathTime += 4;
if (!bSeqStat)
@ -1755,7 +1755,7 @@ void playerProcess(PLAYER *pPlayer)
auto link = pSprite->sector()->lowerLink;
if (link && (link->spr.type == kMarkerLowGoo || link->spr.type == kMarkerLowWater))
{
if (getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y) > pPlayer->zView)
if (getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y) > pPlayer->zView)
pPlayer->isUnderwater = 0;
}
}
@ -1964,7 +1964,7 @@ int playerDamageSprite(DBloodActor* source, PLAYER *pPlayer, DAMAGE_TYPE nDamage
{
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
CGibPosition gibPos(pSprite->pos.X, pSprite->y, top);
CGibPosition gibPos(pSprite->pos.X, pSprite->pos.Y, top);
CGibVelocity gibVel(pActor->xvel >> 1, pActor->yvel >> 1, -0xccccc);
GibSprite(pActor, GIBTYPE_27, &gibPos, &gibVel);
GibSprite(pActor, GIBTYPE_7, NULL, NULL);

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

@ -223,16 +223,16 @@ void LifeLeechOperate(DBloodActor* actor, EVENT event)
DUDEINFO *pDudeInfo = getDudeInfo(nType+kDudeBase);
int z1 = (top-pSprite->z)-256;
int x = pTarget->pos.X;
int y = pTarget->y;
int y = pTarget->pos.Y;
int z = pTarget->z;
int nDist = approxDist(x - pSprite->pos.X, y - pSprite->y);
if (nDist != 0 && cansee(pSprite->pos.X, pSprite->y, top, pSprite->sector(), x, y, z, pTarget->sector()))
int nDist = approxDist(x - pSprite->pos.X, y - pSprite->pos.Y);
if (nDist != 0 && cansee(pSprite->pos.X, pSprite->pos.Y, top, pSprite->sector(), x, y, z, pTarget->sector()))
{
int t = DivScale(nDist, 0x1aaaaa, 12);
x += (target->xvel*t)>>12;
y += (target->yvel*t)>>12;
int angBak = pSprite->ang;
pSprite->ang = getangle(x-pSprite->pos.X, y-pSprite->y);
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;
@ -476,7 +476,7 @@ void OperateSprite(DBloodActor* actor, EVENT event)
for (int p = connecthead; p >= 0; p = connectpoint2[p]) {
spritetype *pPlayerSprite = gPlayer[p].pSprite;
int dx = (pSprite->pos.X - pPlayerSprite->pos.X)>>4;
int dy = (pSprite->y - pPlayerSprite->y)>>4;
int dy = (pSprite->pos.Y - pPlayerSprite->pos.Y)>>4;
int dz = (pSprite->z - pPlayerSprite->z)>>8;
int nDist = dx*dx+dy*dy+dz*dz+0x40000;
gPlayer[p].quakeEffect = DivScale(pXSprite->data1, nDist, 16);
@ -882,7 +882,7 @@ void TranslateSector(sectortype* pSector, int a2, int a3, int a4, int a5, int a6
viewBackupSpriteLoc(actor);
pSprite->ang = (pSprite->ang+v14)&2047;
pSprite->pos.X = x+vc-a4;
pSprite->y = y+v8-a5;
pSprite->pos.Y = y+v8-a5;
}
else if (pSprite->cstat & CSTAT_SPRITE_MOVE_REVERSE)
{
@ -891,21 +891,21 @@ void TranslateSector(sectortype* pSector, int a2, int a3, int a4, int a5, int a6
viewBackupSpriteLoc(actor);
pSprite->ang = (pSprite->ang-v14)&2047;
pSprite->pos.X = x-(vc-a4);
pSprite->y = y-(v8-a5);
pSprite->pos.Y = y-(v8-a5);
}
else if (pXSector->Drag)
{
int top, bottom;
GetSpriteExtents(pSprite, &top, &bottom);
int floorZ = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->y);
int floorZ = getflorzofslopeptr(pSector, pSprite->pos.X, pSprite->pos.Y);
if (!(pSprite->cstat & CSTAT_SPRITE_ALIGNMENT_MASK) && floorZ <= bottom)
{
if (v14)
RotatePoint((int*)&pSprite->pos.X, (int*)&pSprite->y, v14, v20, v24);
RotatePoint((int*)&pSprite->pos.X, (int*)&pSprite->pos.Y, v14, v20, v24);
viewBackupSpriteLoc(actor);
pSprite->ang = (pSprite->ang+v14)&2047;
pSprite->pos.X += v28;
pSprite->y += v2c;
pSprite->pos.Y += v2c;
}
}
}
@ -1208,7 +1208,7 @@ int HDoorBusy(sectortype* pSector, unsigned int a2)
if (!pXSector->marker0 || !pXSector->marker1) return 0;
spritetype *pSprite1 = &pXSector->marker0->s();
spritetype *pSprite2 = &pXSector->marker1->s();
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite1->pos.X, pSprite1->y, pSprite1->pos.X, pSprite1->y, pSprite1->ang, pSprite2->pos.X, pSprite2->y, pSprite2->ang, pSector->type == kSectorSlide);
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite1->pos.X, pSprite1->pos.Y, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->ang, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->ang, pSector->type == kSectorSlide);
ZTranslateSector(pSector, pXSector, a2, nWave);
pXSector->busy = a2;
if (pXSector->command == kCmdLink && pXSector->txID)
@ -1233,7 +1233,7 @@ int RDoorBusy(sectortype* pSector, unsigned int a2)
nWave = pXSector->busyWaveB;
if (!pXSector->marker0) return 0;
spritetype* pSprite = &pXSector->marker0->s();
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->y, pSprite->pos.X, pSprite->y, 0, pSprite->pos.X, pSprite->y, pSprite->ang, pSector->type == kSectorRotate);
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.X, pSprite->pos.Y, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->ang, pSector->type == kSectorRotate);
ZTranslateSector(pSector, pXSector, a2, nWave);
pXSector->busy = a2;
if (pXSector->command == kCmdLink && pXSector->txID)
@ -1258,13 +1258,13 @@ int StepRotateBusy(sectortype* pSector, unsigned int a2)
{
vbp = pXSector->data+pSprite->ang;
int nWave = pXSector->busyWaveA;
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->y, pSprite->pos.X, pSprite->y, pXSector->data, pSprite->pos.X, pSprite->y, vbp, 1);
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.X, pSprite->pos.Y, pXSector->data, pSprite->pos.X, pSprite->pos.Y, vbp, 1);
}
else
{
vbp = pXSector->data-pSprite->ang;
int nWave = pXSector->busyWaveB;
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->y, pSprite->pos.X, pSprite->y, vbp, pSprite->pos.X, pSprite->y, pXSector->data, 1);
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->pos.Y, pSprite->pos.X, pSprite->pos.Y, vbp, pSprite->pos.X, pSprite->pos.Y, pXSector->data, 1);
}
pXSector->busy = a2;
if (pXSector->command == kCmdLink && pXSector->txID)
@ -1308,7 +1308,7 @@ int PathBusy(sectortype* pSector, unsigned int a2)
XSPRITE *pXSprite2 = &pXSector->marker1->x();
int nWave = pXSprite1->wave;
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->y, pSprite1->pos.X, pSprite1->y, pSprite1->ang, pSprite2->pos.X, pSprite2->y, pSprite2->ang, 1);
TranslateSector(pSector, GetWaveValue(pXSector->busy, nWave), GetWaveValue(a2, nWave), pSprite->pos.X, pSprite->pos.Y, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->ang, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->ang, 1);
ZTranslateSector(pSector, pXSector, a2, nWave);
pXSector->busy = a2;
if ((a2&0xffff) == 0)
@ -1412,7 +1412,7 @@ void OperateTeleport(sectortype* pSector)
TeleFrag(pXSector->actordata, pDest->sector());
}
pSprite->pos.X = pDest->pos.X;
pSprite->y = pDest->y;
pSprite->pos.Y = pDest->pos.Y;
pSprite->z += pDest->sector()->floorz - pSector->floorz;
pSprite->ang = pDest->ang;
ChangeActorSect(actor, pDest->sector());
@ -2016,7 +2016,7 @@ void trInit(TArray<DBloodActor*>& actors)
{
spritetype* pSprite1 = &pXSector->marker0->s();
spritetype* pSprite2 = &pXSector->marker1->s();
TranslateSector(pSector, 0, -65536, pSprite1->pos.X, pSprite1->y, pSprite1->pos.X, pSprite1->y, pSprite1->ang, pSprite2->pos.X, pSprite2->y, pSprite2->ang, pSector->type == kSectorSlide);
TranslateSector(pSector, 0, -65536, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->ang, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->ang, pSector->type == kSectorSlide);
for(auto& wal : wallsofsector(pSector))
{
wal.baseWall.X = wal.pos.X;
@ -2027,7 +2027,7 @@ void trInit(TArray<DBloodActor*>& actors)
{
actor->basePoint = actor->spr.pos;
}
TranslateSector(pSector, 0, pXSector->busy, pSprite1->pos.X, pSprite1->y, pSprite1->pos.X, pSprite1->y, pSprite1->ang, pSprite2->pos.X, pSprite2->y, pSprite2->ang, pSector->type == kSectorSlide);
TranslateSector(pSector, 0, pXSector->busy, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->ang, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->ang, pSector->type == kSectorSlide);
ZTranslateSector(pSector, pXSector, pXSector->busy, 1);
break;
}
@ -2035,7 +2035,7 @@ void trInit(TArray<DBloodActor*>& actors)
case kSectorRotate:
{
spritetype* pSprite1 = &pXSector->marker0->s();
TranslateSector(pSector, 0, -65536, pSprite1->pos.X, pSprite1->y, pSprite1->pos.X, pSprite1->y, 0, pSprite1->pos.X, pSprite1->y, pSprite1->ang, pSector->type == kSectorRotate);
TranslateSector(pSector, 0, -65536, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->pos.X, pSprite1->pos.Y, 0, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->ang, pSector->type == kSectorRotate);
for (auto& wal : wallsofsector(pSector))
{
wal.baseWall.X = wal.pos.X;
@ -2046,7 +2046,7 @@ void trInit(TArray<DBloodActor*>& actors)
{
actor->basePoint = actor->spr.pos;
}
TranslateSector(pSector, 0, pXSector->busy, pSprite1->pos.X, pSprite1->y, pSprite1->pos.X, pSprite1->y, 0, pSprite1->pos.X, pSprite1->y, pSprite1->ang, pSector->type == kSectorRotate);
TranslateSector(pSector, 0, pXSector->busy, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->pos.X, pSprite1->pos.Y, 0, pSprite1->pos.X, pSprite1->pos.Y, pSprite1->ang, pSector->type == kSectorRotate);
ZTranslateSector(pSector, pXSector, pXSector->busy, 1);
break;
}
@ -2162,7 +2162,7 @@ void ActivateGenerator(DBloodActor* actor)
case kGenDripBlood: {
int top, bottom;
GetActorExtents(actor, &top, &bottom);
actSpawnThing(pSprite->sector(), pSprite->pos.X, pSprite->y, bottom, (pSprite->type == kGenDripWater) ? kThingDripWater : kThingDripBlood);
actSpawnThing(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, bottom, (pSprite->type == kGenDripWater) ? kThingDripWater : kThingDripBlood);
break;
}
case kGenSound:
@ -2187,7 +2187,7 @@ void ActivateGenerator(DBloodActor* actor)
case kGenBubbleMulti: {
int top, bottom;
GetActorExtents(actor, &top, &bottom);
gFX.fxSpawnActor((pSprite->type == kGenBubble) ? FX_23 : FX_26, pSprite->sector(), pSprite->pos.X, pSprite->y, top, 0);
gFX.fxSpawnActor((pSprite->type == kGenBubble) ? FX_23 : FX_26, pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, top, 0);
break;
}
}

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

@ -62,7 +62,7 @@ void viewBackupView(int nPlayer)
VIEW *pView = &gPrevView[nPlayer];
pView->angle = pPlayer->angle.ang;
pView->x = pPlayer->pSprite->pos.X;
pView->y = pPlayer->pSprite->y;
pView->y = pPlayer->pSprite->pos.Y;
pView->viewz = pPlayer->zView;
pView->weaponZ = pPlayer->zWeapon-pPlayer->zView-0xc00;
pView->horiz = pPlayer->horizon.horiz;
@ -83,7 +83,7 @@ void viewCorrectViewOffsets(int nPlayer, vec3_t const *oldpos)
PLAYER *pPlayer = &gPlayer[nPlayer];
VIEW *pView = &gPrevView[nPlayer];
pView->x += pPlayer->pSprite->pos.X-oldpos->X;
pView->y += pPlayer->pSprite->y-oldpos->Y;
pView->y += pPlayer->pSprite->pos.Y-oldpos->Y;
pView->viewz += pPlayer->pSprite->z-oldpos->Z;
}
@ -391,7 +391,7 @@ static void DrawMap(spritetype* pSprite)
}
VIEW* pView = &gPrevView[gViewIndex];
int x = interpolatedvalue(pView->x, pSprite->pos.X, gInterpolate);
int y = interpolatedvalue(pView->y, pSprite->y, gInterpolate);
int y = interpolatedvalue(pView->y, pSprite->pos.Y, gInterpolate);
int ang = (!SyncInput() ? gView->angle.sum() : gView->angle.interpolatedsum(gInterpolate)).asbuild();
DrawOverheadMap(x, y, ang, gInterpolate);
if (tm)
@ -434,7 +434,7 @@ void SetupView(int &cX, int& cY, int& cZ, binangle& cA, fixedhoriz& cH, sectorty
{
VIEW* pView = &gPrevView[gViewIndex];
cX = interpolatedvalue(pView->x, gView->pSprite->pos.X, gInterpolate);
cY = interpolatedvalue(pView->y, gView->pSprite->y, gInterpolate);
cY = interpolatedvalue(pView->y, gView->pSprite->pos.Y, gInterpolate);
cZ = interpolatedvalue(pView->viewz, gView->zView, gInterpolate);
zDelta = interpolatedvaluef(pView->weaponZ, gView->zWeapon - gView->zView - (12 << 8), gInterpolate);
bobWidth = interpolatedvalue(pView->bobWidth, gView->bobWidth, gInterpolate);
@ -749,7 +749,7 @@ FString GameInterface::GetCoordString()
FString out;
out.Format("pos= %d, %d, %d - angle = %2.3f",
gMe->pSprite->pos.X, gMe->pSprite->y, gMe->pSprite->z, gMe->pSprite->ang * BAngToDegree);
gMe->pSprite->pos.X, gMe->pSprite->pos.Y, gMe->pSprite->z, gMe->pSprite->ang * BAngToDegree);
return out;
}

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

@ -74,7 +74,7 @@ void warpInit(TArray<DBloodActor*>& actors)
if (gGameOptions.nGameType < 2 && pXSprite->data1 >= 0 && pXSprite->data1 < kMaxPlayers) {
ZONE *pZone = &gStartZone[pXSprite->data1];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->y;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
@ -87,7 +87,7 @@ void warpInit(TArray<DBloodActor*>& actors)
// default if BB or teams without data2 specified
ZONE* pZone = &gStartZone[pXSprite->data1];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->y;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
@ -98,7 +98,7 @@ void warpInit(TArray<DBloodActor*>& actors)
if (pXSprite->data2 == 1) {
pZone = &gStartZoneTeam1[team1];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->y;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
@ -107,7 +107,7 @@ void warpInit(TArray<DBloodActor*>& actors)
} else if (pXSprite->data2 == 2) {
pZone = &gStartZoneTeam2[team2];
pZone->x = pSprite->pos.X;
pZone->y = pSprite->y;
pZone->y = pSprite->pos.Y;
pZone->z = pSprite->z;
pZone->sector = pSprite->sector();
pZone->ang = pSprite->ang;
@ -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->y);
pSprite->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->y);
pSprite->z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
break;
}
}
@ -201,7 +201,7 @@ int CheckLink(DBloodActor *actor)
if (pUpper->type == kMarkerUpLink)
z = pUpper->z;
else
z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
z = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
if (z <= pSprite->z)
{
aLower = aUpper->GetOwner();
@ -210,12 +210,12 @@ int CheckLink(DBloodActor *actor)
assert(pLower->insector());
ChangeActorSect(actor, pLower->sector());
pSprite->pos.X += pLower->pos.X - pUpper->pos.X;
pSprite->y += pLower->y-pUpper->y;
pSprite->pos.Y += pLower->pos.Y - pUpper->pos.Y;
int z2;
if (pLower->type == kMarkerLowLink)
z2 = pLower->z;
else
z2 = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
z2 = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
pSprite->z += z2-z;
actor->interpolated = false;
return pUpper->type;
@ -228,7 +228,7 @@ int CheckLink(DBloodActor *actor)
if (pLower->type == kMarkerLowLink)
z = pLower->z;
else
z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
z = getceilzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
if (z >= pSprite->z)
{
aUpper = aLower->GetOwner();
@ -237,12 +237,12 @@ int CheckLink(DBloodActor *actor)
assert(pUpper->insector());
ChangeActorSect(actor, pUpper->sector());
pSprite->pos.X += pUpper->pos.X - pLower->pos.X;
pSprite->y += pUpper->y-pLower->y;
pSprite->pos.Y += pUpper->pos.Y - pLower->pos.Y;
int z2;
if (pUpper->type == kMarkerUpLink)
z2 = pUpper->z;
else
z2 = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->y);
z2 = getflorzofslopeptr(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y);
pSprite->z += z2-z;
actor->interpolated = false;
return pLower->type;
@ -271,7 +271,7 @@ int CheckLink(int *x, int *y, int *z, sectortype** pSector)
assert(pLower->insector());
*pSector = pLower->sector();
*x += pLower->pos.X - pUpper->pos.X;
*y += pLower->y-pUpper->y;
*y += pLower->pos.Y - pUpper->pos.Y;
int z2;
if (pUpper->type == kMarkerLowLink)
z2 = pLower->z;
@ -297,7 +297,7 @@ int CheckLink(int *x, int *y, int *z, sectortype** pSector)
assert(pUpper);
*pSector = pUpper->sector();
*x += pUpper->pos.X - pLower->pos.X;
*y += pUpper->y-pLower->y;
*y += pUpper->pos.Y - pLower->pos.Y;
int z2;
if (pLower->type == kMarkerUpLink)
z2 = pUpper->z;

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

@ -347,7 +347,7 @@ void UpdateAimVector(PLAYER * pPlayer)
assert(pPlayer != NULL);
spritetype *pPSprite = pPlayer->pSprite;
int x = pPSprite->pos.X;
int y = pPSprite->y;
int y = pPSprite->pos.Y;
int z = pPlayer->zWeapon;
Aim aim;
aim.dx = bcos(pPSprite->ang);
@ -373,7 +373,7 @@ void UpdateAimVector(PLAYER * pPlayer)
if (!(pSprite->flags&8))
continue;
int x2 = pSprite->pos.X;
int y2 = pSprite->y;
int y2 = pSprite->pos.Y;
int z2 = pSprite->z;
int nDist = approxDist(x2-x, y2-y);
if (nDist == 0 || nDist > 51200)
@ -428,7 +428,7 @@ void UpdateAimVector(PLAYER * pPlayer)
if (!(pSprite->flags&8))
continue;
int x2 = pSprite->pos.X;
int y2 = pSprite->y;
int y2 = pSprite->pos.Y;
int z2 = pSprite->z;
int dx = x2-x;
int dy = y2-y;
@ -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->y,pSprite->z,pSprite->sector()))
if (pPlayer->aimTargetsCount < 16 && cansee(x,y,z,pPSprite->sector(),pSprite->pos.X,pSprite->pos.Y,pSprite->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->y, pSprite->z, pSprite->sector()))
if (cansee(x, y, z, pPSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector()))
{
nClosest = nDist2;
aim.dx = bcos(angle);
@ -1521,7 +1521,7 @@ void AltFireVoodoo(int nTrigger, PLAYER *pPlayer)
spritetype* pTarget = &targetactor->s();
if (!gGameOptions.bFriendlyFire && IsTargetTeammate(pPlayer, pTarget))
continue;
int nDist = approxDist(pTarget->pos.X - pPlayer->pSprite->pos.X, pTarget->y - pPlayer->pSprite->y);
int nDist = approxDist(pTarget->pos.X - pPlayer->pSprite->pos.X, pTarget->pos.Y - pPlayer->pSprite->pos.Y);
if (nDist > 0 && nDist < 51200)
{
int vc = pPlayer->ammoCount[9] >> 3;
@ -1560,7 +1560,7 @@ void AltFireVoodoo(int nTrigger, PLAYER *pPlayer)
continue;
if (v4 > 0)
v4--;
int nDist = approxDist(pTarget->pos.X - pPlayer->pSprite->pos.X, pTarget->y - pPlayer->pSprite->y);
int nDist = approxDist(pTarget->pos.X - pPlayer->pSprite->pos.X, pTarget->pos.Y - pPlayer->pSprite->pos.Y);
if (nDist > 0 && nDist < 51200)
{
int vc = pPlayer->ammoCount[9] >> 3;
@ -2662,7 +2662,7 @@ void teslaHit(DBloodActor *missileactor, int a2)
{
auto pMissile = &missileactor->s();
int x = pMissile->pos.X;
int y = pMissile->y;
int y = pMissile->pos.Y;
int z = pMissile->z;
int nDist = 300;
auto pSector = pMissile->sector();
@ -2685,7 +2685,7 @@ void teslaHit(DBloodActor *missileactor, int a2)
if (CheckSector(sectorMap, pHitSprite) && CheckProximity(hitactor, x, y, z, pSector, nDist))
{
int dx = pMissile->pos.X - pHitSprite->pos.X;
int dy = pMissile->y-pHitSprite->y;
int dy = pMissile->pos.Y - pHitSprite->pos.Y;
int nDamage = ClipLow((nDist-(ksqrt(dx*dx+dy*dy)>>4)+20)>>1, 10);
if (hitactor == owneractor)
nDamage /= 2;
@ -2705,7 +2705,7 @@ void teslaHit(DBloodActor *missileactor, int a2)
if (!pXSprite->locked)
{
int dx = pMissile->pos.X - pHitSprite->pos.X;
int dy = pMissile->y-pHitSprite->y;
int dy = pMissile->pos.Y - pHitSprite->pos.Y;
int nDamage = ClipLow(nDist-(ksqrt(dx*dx+dy*dy)>>4)+20, 20);
actDamageSprite(owneractor, hitactor, kDamageTesla, nDamage << 4);
}

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

@ -86,10 +86,10 @@ void SE40_Draw(int tag, spritetype *spr, int x, int y, int z, binangle a, fixedh
}
offx = x - floor1->pos.X;
offy = y - floor1->y;
offy = y - floor1->pos.Y;
renderDrawRoomsQ16(floor2->pos.X + offx, floor2->y + offy, z, a.asq16(), h.asq16(), floor2->sector(), false);
fi.animatesprites(pm_tsprite, pm_spritesortcnt, offx + floor2->pos.X, offy + floor2->y, a.asbuild(), smoothratio);
renderDrawRoomsQ16(floor2->pos.X + offx, floor2->pos.Y + offy, z, a.asq16(), h.asq16(), floor2->sector(), false);
fi.animatesprites(pm_tsprite, pm_spritesortcnt, offx + floor2->pos.X, offy + floor2->pos.Y, a.asbuild(), smoothratio);
renderDrawMasks();
it.Reset(STAT_RAROR);
@ -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.y -= geoy[gs], act->spr.z });
SetActor(act, { act->spr.pos.X -= geox[gs], act->spr.pos.Y -= geoy[gs], act->spr.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.y += geoy[gs], act->spr.z });
SetActor(act, { act->spr.pos.X += geox[gs], act->spr.pos.Y += geoy[gs], act->spr.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.y -= geoy2[gs], act->spr.z });
SetActor(act, { act->spr.pos.X -= geox2[gs], act->spr.pos.Y -= geoy2[gs], act->spr.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.y += geoy2[gs], act->spr.z });
SetActor(act, { act->spr.pos.X += geox2[gs], act->spr.pos.Y += geoy2[gs], act->spr.z });
}
}
fi.animatesprites(pm_tsprite, pm_spritesortcnt, cposx, cposy, cang.asbuild(), smoothratio);

156
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.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.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.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.z - (r2 % (47 << 8)), spawntype, -32, 8, 8, r1 & 2047, 0, 0, actor, 5);
if (j) j->spr.cstat = randomFlip();
}
}
@ -281,7 +281,7 @@ void ms(DDukeActor* const actor)
//T1,T2 and T3 are used for all the sector moving stuff!!!
actor->spr.pos.X += MulScale(actor->spr.xvel, bcos(actor->spr.ang), 14);
actor->spr.y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.pos.Y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
int j = actor->temp_data[1];
int k = actor->temp_data[2];
@ -291,7 +291,7 @@ void ms(DDukeActor* const actor)
vec2_t t;
rotatepoint({ 0, 0 }, { msx[j], msy[j] }, k & 2047, &t);
dragpoint(&wal, actor->spr.pos.X + t.X, actor->spr.y + t.Y);
dragpoint(&wal, actor->spr.pos.X + t.X, actor->spr.pos.Y + t.Y);
j++;
}
}
@ -376,7 +376,7 @@ void movedummyplayers(void)
}
act->spr.pos.X += (ps[p].pos.X - ps[p].oposx);
act->spr.y += (ps[p].pos.Y - ps[p].oposy);
act->spr.pos.Y += (ps[p].pos.Y - ps[p].oposy);
SetActor(act, act->spr.pos);
}
}
@ -402,7 +402,7 @@ void moveplayers(void)
if (p->newOwner != nullptr) //Looking thru the camera
{
act->spr.pos.X = p->oposx;
act->spr.y = p->oposy;
act->spr.pos.Y = p->oposy;
act->spr.z = p->oposz + gs.playerheight;
act->spr.backupz();
act->spr.ang = p->angle.oang.asbuild();
@ -446,7 +446,7 @@ void moveplayers(void)
if (p->actorsqu != nullptr)
{
p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->actorsqu->spr.pos.X - p->pos.X, p->actorsqu->spr.y - p->pos.Y)) >> 2);
p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->actorsqu->spr.pos.X - p->pos.X, p->actorsqu->spr.pos.Y - p->pos.Y)) >> 2);
}
if (act->spr.extra > 0)
@ -462,14 +462,14 @@ void moveplayers(void)
else
{
p->pos.X = act->spr.pos.X;
p->pos.Y = act->spr.y;
p->pos.Y = act->spr.pos.Y;
p->pos.Z = act->spr.z - (20 << 8);
p->newOwner = nullptr;
if (p->wackedbyactor != nullptr && p->wackedbyactor->spr.statnum < MAXSTATUS)
{
p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->wackedbyactor->spr.pos.X - p->pos.X, p->wackedbyactor->spr.y - p->pos.Y)) >> 1);
p->angle.addadjustment(getincanglebam(p->angle.ang, bvectangbam(p->wackedbyactor->spr.pos.X - p->pos.X, p->wackedbyactor->spr.pos.Y - p->pos.Y)) >> 1);
}
}
act->spr.ang = p->angle.ang.asbuild();
@ -649,7 +649,7 @@ void movecrane(DDukeActor *actor, int crane)
case STAT_ZOMBIEACTOR:
case STAT_STANDABLE:
case STAT_PLAYER:
actor->spr.ang = getangle(cpt.polex - actor->spr.pos.X, cpt.poley - actor->spr.y);
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 });
t[0]++;
return;
@ -758,9 +758,9 @@ void movecrane(DDukeActor *actor, int crane)
{
if (actor->spr.xvel < 192)
actor->spr.xvel += 8;
actor->spr.ang = getangle(cpt.x - actor->spr.pos.X, cpt.y - actor->spr.y);
actor->spr.ang = getangle(cpt.x - actor->spr.pos.X, cpt.y - actor->spr.pos.Y);
ssp(actor, CLIPMASK0);
if (((actor->spr.pos.X - cpt.x) * (actor->spr.pos.X - cpt.x) + (actor->spr.y - cpt.y) * (actor->spr.y - cpt.y)) < (128 * 128))
if (((actor->spr.pos.X - cpt.x) * (actor->spr.pos.X - cpt.x) + (actor->spr.pos.Y - cpt.y) * (actor->spr.pos.Y - cpt.y)) < (128 * 128))
t[0]++;
}
@ -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.y, actor->spr.z - (34 << 8) });
SetActor(cpt.poleactor, { actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z - (34 << 8) });
auto Owner = actor->GetOwner();
if (Owner != nullptr || actor->IsActiveCrane())
@ -801,7 +801,7 @@ void movecrane(DDukeActor *actor, int crane)
ps[p].oposy = ps[p].pos.Y;
ps[p].oposz = ps[p].pos.Z;
ps[p].pos.X = actor->spr.pos.X - bcos(ang, -6);
ps[p].pos.Y = actor->spr.y - bsin(ang, -6);
ps[p].pos.Y = actor->spr.pos.Y - bsin(ang, -6);
ps[p].pos.Z = actor->spr.z + (2 << 8);
SetActor(ps[p].GetActor(), ps[p].pos);
ps[p].setCursector(ps[p].GetActor()->spr.sector());
@ -1331,14 +1331,14 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
actor->spr.ang = Owner->spr.ang;
actor->spr.pos.X = Owner->spr.pos.X;
actor->spr.y = Owner->spr.y;
actor->spr.pos.Y = Owner->spr.pos.Y;
if (Owner->spr.picnum == TILE_APLAYER)
actor->spr.z = Owner->spr.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.y + MulScale(k, bsin(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),
8, 8, 0, 0, 0, actor, 5);
if (q)
@ -1350,7 +1350,7 @@ void movetongue(DDukeActor *actor, int tongue, int jaw)
int k = actor->temp_data[0]; // do not depend on the above loop counter.
auto spawned = EGS(actor->spr.sector(),
actor->spr.pos.X + MulScale(k, bcos(actor->spr.ang), 9),
actor->spr.y + MulScale(k, bsin(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,
32, 32, 0, 0, 0, actor, 5);
if (spawned)
@ -1510,7 +1510,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
{
// if(actor->spr.pal == 12)
{
int j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.y - ps[p].pos.Y));
int j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y));
if (j > -64 && j < 64 && PlayerInput(p, SB_OPEN))
if (ps[p].toggle_key_flag == 1)
{
@ -1520,7 +1520,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
{
if (act2->spr.picnum == queball || act2->spr.picnum == stripeball)
{
j = getincangle(ps[p].angle.ang.asbuild(), getangle(act2->spr.pos.X - ps[p].pos.X, act2->spr.y - ps[p].pos.Y));
j = getincangle(ps[p].angle.ang.asbuild(), getangle(act2->spr.pos.X - ps[p].pos.X, act2->spr.pos.Y - ps[p].pos.Y));
if (j > -64 && j < 64)
{
int l;
@ -1542,7 +1542,7 @@ bool queball(DDukeActor *actor, int pocket, int queball, int stripeball)
}
if (x < 512 && actor->spr.sector() == ps[p].cursector)
{
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.y - ps[p].pos.Y);
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
actor->spr.xvel = 48;
}
}
@ -1690,13 +1690,13 @@ 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.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.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;
}
else actor->tempang +=
getincangle(actor->tempang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.y)) / 3;
getincangle(actor->tempang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) / 3;
}
else if (t[0] == 2 || t[0] == 3)
{
@ -1713,7 +1713,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
else
{
t[2]++;
if (t[2] > (26 * 3) || !cansee(actor->spr.pos.X, actor->spr.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.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;
@ -1724,7 +1724,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
fi.shoot(actor, firelaser);
}
}
actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.y)) >> 2;
actor->spr.ang += getincangle(actor->spr.ang, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 2;
}
if (t[0] != 2 && t[0] != 3 && Owner)
@ -1735,7 +1735,7 @@ void recon(DDukeActor *actor, int explosion, int firelaser, int attacksnd, int p
a = actor->spr.ang;
actor->spr.xvel >>= 1;
}
else a = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.y - actor->spr.y);
else a = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
if (t[0] == 1 || t[0] == 4) // Found a locator and going with it
{
@ -2053,7 +2053,7 @@ void forcesphereexplode(DDukeActor *actor)
}
actor->spr.pos.X = Owner->spr.pos.X;
actor->spr.y = Owner->spr.y;
actor->spr.pos.Y = Owner->spr.pos.Y;
actor->spr.z = Owner->spr.z;
actor->spr.ang += Owner->temp_data[0];
@ -2158,7 +2158,7 @@ bool money(DDukeActor* actor, int BLOODPOOL)
deletesprite(actor);
return false;
}
int l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
int l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.z > l)
{
@ -2221,8 +2221,8 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
return false;
}
int l = getflorzofslopeptr(sectp, actor->spr.pos.X, actor->spr.y);
int x = getceilzofslopeptr(sectp, actor->spr.pos.X, actor->spr.y);
int l = getflorzofslopeptr(sectp, actor->spr.pos.X, actor->spr.pos.Y);
int x = getceilzofslopeptr(sectp, actor->spr.pos.X, actor->spr.pos.Y);
if (x == l)
{
deletesprite(actor);
@ -2260,7 +2260,7 @@ 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.y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.pos.Y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.z += actor->spr.zvel;
if (floorcheck && actor->spr.z >= actor->spr.sector()->floorz)
@ -2290,7 +2290,7 @@ bool jibs(DDukeActor *actor, int JIBS6, bool timeout, bool callsetsprite, bool f
}
t[2]++;
}
l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->spr.z = l - (2 << 8);
actor->spr.xvel = 0;
@ -2540,7 +2540,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.y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.pos.Y += MulScale(actor->spr.xvel, bsin(actor->spr.ang), 14);
actor->spr.z += actor->spr.zvel;
}
else
@ -2574,7 +2574,7 @@ void gutsdir(DDukeActor* actor, int gtype, int n, int p)
else sx = sy = 32;
int gutz = actor->spr.z - (8 << 8);
int floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.y);
int floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -2587,7 +2587,7 @@ void gutsdir(DDukeActor* actor, int gtype, int n, int p)
int r1 = krand();
int r2 = krand();
// TRANSITIONAL: owned by a player???
EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, gutz, gtype, -32, sx, sy, a, 256 + (r2 & 127), -512 - (r1 & 2047), ps[p].GetActor(), 5);
}
}
@ -2695,7 +2695,7 @@ void handle_se00(DDukeActor* actor, int LASERLINE)
t[3] = ldist(actor, Owner);
actor->spr.xvel = t[3];
actor->spr.pos.X = Owner->spr.pos.X;
actor->spr.y = Owner->spr.y;
actor->spr.pos.Y = Owner->spr.pos.Y;
actor->spr.ang += (l * q);
t[2] += (l * q);
}
@ -2819,7 +2819,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
Owner = actor->GetOwner();
if (actor->spr.xvel)
{
int x = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.y - actor->spr.y);
int x = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
int q = getincangle(actor->spr.ang, x) >> 3;
t[2] += q;
@ -2839,7 +2839,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
if (x < 20480)
{
j = actor->spr.ang;
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.y - ps[p].pos.Y);
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
fi.shoot(actor, RPG);
actor->spr.ang = j;
}
@ -2862,7 +2862,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
{
ps[p].pos.X = actor->spr.pos.X;
ps[p].pos.Y = actor->spr.y;
ps[p].pos.Y = actor->spr.pos.Y;
ps[p].setCursector(actor->spr.sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
@ -2906,7 +2906,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
if (psp->spr.extra <= 0)
{
psp->spr.pos.X = ps[p].pos.X;
psp->spr.y = ps[p].pos.Y;
psp->spr.pos.Y = ps[p].pos.Y;
}
}
}
@ -2919,7 +2919,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
rotatepoint(actor->spr.pos.vec2, a2->spr.pos.vec2, q, &a2->spr.pos.vec2);
a2->spr.pos.X += m;
a2->spr.y += x;
a2->spr.pos.Y += x;
a2->spr.ang += q;
@ -2945,7 +2945,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
{
ps[p].oposx = ps[p].pos.X = actor->spr.pos.X;
ps[p].oposy = ps[p].pos.Y = actor->spr.y;
ps[p].oposy = ps[p].pos.Y = actor->spr.pos.Y;
ps[p].setCursector(actor->spr.sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
@ -2963,7 +2963,7 @@ void handle_se14(DDukeActor* actor, bool checkstat, int RPG, int JIBS6)
if (a2->spr.statnum == 1 && badguy(a2) && a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
{
auto k = a2->spr.sector();
updatesector(a2->spr.pos.X, a2->spr.y, &k);
updatesector(a2->spr.pos.X, a2->spr.pos.Y, &k);
if (a2->spr.extra >= 0 && k == actor->spr.sector())
{
gutsdir(a2, JIBS6, 72, myconnectindex);
@ -3011,7 +3011,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
}
if (t[4] == 2)
{
int l = FindDistance2D(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.y - actor->spr.y);
int l = FindDistance2D(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
if (l <= 128)
actor->spr.xvel = 0;
@ -3047,7 +3047,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
{
ps[p].pos.X = actor->spr.pos.X;
ps[p].pos.Y = actor->spr.y;
ps[p].pos.Y = actor->spr.pos.Y;
ps[p].setCursector(actor->spr.sector());
SetActor(ps[p].GetActor(), actor->spr.pos);
@ -3086,7 +3086,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
if (a2->spr.picnum != SECTOREFFECTOR && a2->spr.picnum != LOCATORS)
{
a2->spr.pos.X += l;
a2->spr.y += x;
a2->spr.pos.Y += x;
if (numplayers > 1)
{
@ -3109,7 +3109,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
if ((k == nullptr && ud.clipping == 0) || (k == actor->spr.sector() && ps[p].cursector != actor->spr.sector()))
{
ps[p].pos.X = actor->spr.pos.X;
ps[p].pos.Y = actor->spr.y;
ps[p].pos.Y = actor->spr.pos.Y;
ps[p].oposx = ps[p].pos.X;
ps[p].oposy = ps[p].pos.Y;
@ -3131,7 +3131,7 @@ void handle_se30(DDukeActor *actor, int JIBS6)
// if(a2->spr.sector != actor->spr.sector)
{
auto k = a2->spr.sector();
updatesector(a2->spr.pos.X, a2->spr.y, &k);
updatesector(a2->spr.pos.X, a2->spr.pos.Y, &k);
if (a2->spr.extra >= 0 && k == actor->spr.sector())
{
gutsdir(a2, JIBS6, 24, myconnectindex);
@ -3211,7 +3211,7 @@ void handle_se02(DDukeActor* actor)
if (a2->spr.picnum != SECTOREFFECTOR)
{
a2->spr.pos.X += m;
a2->spr.y += x;
a2->spr.pos.Y += x;
SetActor(a2, a2->spr.pos);
}
}
@ -3354,7 +3354,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
if (x < 8192)
{
j = actor->spr.ang;
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.y - ps[p].pos.Y);
actor->spr.ang = getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y);
fi.shoot(actor, FIRELASER);
actor->spr.ang = j;
}
@ -3388,7 +3388,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
if (ldist(Owner, actor) < 1024)
{
auto ta = actor->spr.ang;
actor->spr.ang = getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.y);
actor->spr.ang = getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y);
actor->spr.ang = ta;
actor->SetOwner(nullptr);
return;
@ -3396,7 +3396,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
}
else actor->spr.xvel = 256;
x = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.y - actor->spr.y);
x = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
int q = getincangle(actor->spr.ang, x) >> 3;
actor->spr.ang += q;
@ -3408,7 +3408,7 @@ void handle_se05(DDukeActor* actor, int FIRELASER)
else
{
t[2] +=
getincangle(t[2] + 512, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.y)) >> 2;
getincangle(t[2] + 512, getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 2;
sc->ceilingshade = 0;
}
j = fi.ifhitbyweapon(actor);
@ -3577,7 +3577,7 @@ void handle_se11(DDukeActor *actor)
DukeStatIterator it(STAT_ACTOR);
while (auto ac = it.Next())
{
if (ac->spr.extra > 0 && badguy(ac) && clipinsidebox(ac->spr.pos.X, ac->spr.y, wallnum(&wal), 256) == 1)
if (ac->spr.extra > 0 && badguy(ac) && clipinsidebox(ac->spr.pos.X, ac->spr.pos.Y, wallnum(&wal), 256) == 1)
return;
}
}
@ -3593,7 +3593,7 @@ void handle_se11(DDukeActor *actor)
DukeStatIterator it(STAT_PLAYER);
while (auto ac = it.Next())
{
if (ac->GetOwner() && clipinsidebox(ac->spr.pos.X, ac->spr.y, wallnum(&wal), 144) == 1)
if (ac->GetOwner() && clipinsidebox(ac->spr.pos.X, ac->spr.pos.Y, wallnum(&wal), 144) == 1)
{
t[5] = 8; // Delay
t[2] -= k;
@ -3927,7 +3927,7 @@ void handle_se17(DDukeActor* actor)
int p = act3->spr.yvel;
ps[p].pos.X += act2->spr.pos.X - actor->spr.pos.X;
ps[p].pos.Y += act2->spr.y - actor->spr.y;
ps[p].pos.Y += act2->spr.pos.Y - actor->spr.pos.Y;
ps[p].pos.Z = act2->spr.sector()->floorz - (sc->floorz - ps[p].pos.Z);
act3->floorz = act2->spr.sector()->floorz;
@ -3947,7 +3947,7 @@ void handle_se17(DDukeActor* actor)
else if (act3->spr.statnum != STAT_EFFECTOR)
{
act3->spr.pos.X += act2->spr.pos.X - actor->spr.pos.X;
act3->spr.y += act2->spr.y - actor->spr.y;
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.backupz();
@ -4179,12 +4179,12 @@ void handle_se20(DDukeActor* actor)
t[3] += actor->spr.xvel;
actor->spr.pos.X += x;
actor->spr.y += l;
actor->spr.pos.Y += l;
if (t[3] <= 0 || (t[3] >> 6) >= (actor->spr.yvel >> 6))
{
actor->spr.pos.X -= x;
actor->spr.y -= l;
actor->spr.pos.Y -= l;
t[0] = 0;
callsound(actor->spr.sector(), actor);
return;
@ -4196,7 +4196,7 @@ void handle_se20(DDukeActor* actor)
if (a2->spr.statnum != 3 && a2->spr.zvel == 0)
{
a2->spr.pos.X += x;
a2->spr.y += l;
a2->spr.pos.Y += l;
SetActor(a2, a2->spr.pos);
if (a2->sector()->floorstat & CSTAT_SECTOR_SLOPE)
if (a2->spr.statnum == 2)
@ -4304,7 +4304,7 @@ void handle_se26(DDukeActor* actor)
if (actor->spr.shade > 7)
{
actor->spr.pos.X = t[3];
actor->spr.y = t[4];
actor->spr.pos.Y = t[4];
sc->floorz -= ((actor->spr.zvel * actor->spr.shade) - actor->spr.zvel);
actor->spr.shade = 0;
}
@ -4317,7 +4317,7 @@ void handle_se26(DDukeActor* actor)
if (a2->spr.statnum != 3 && a2->spr.statnum != 10)
{
a2->spr.pos.X += l;
a2->spr.y += x;
a2->spr.pos.Y += x;
a2->spr.z += actor->spr.zvel;
SetActor(a2, a2->spr.pos);
}
@ -4361,13 +4361,13 @@ void handle_se27(DDukeActor* actor)
}
else if (ud.recstat == 2 && ps[p].newOwner == nullptr)
{
if (cansee(actor->spr.pos.X, actor->spr.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.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.y)) >> 3;
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);
}
@ -4382,7 +4382,7 @@ void handle_se27(DDukeActor* actor)
}
else
{
actor->spr.ang = getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.y);
actor->spr.ang = getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y);
if (t[0] == 999)
{
@ -4446,7 +4446,7 @@ void handle_se24(DDukeActor *actor, const int16_t *list1, const int16_t *list2,
if (a2->spr.z > (a2->floorz - (16 << 8)))
{
a2->spr.pos.X += x >> shift;
a2->spr.y += l >> shift;
a2->spr.pos.Y += l >> shift;
SetActor(a2, a2->spr.pos);
@ -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.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.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.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.z - (FOURSLEIGHT) }, actor->spr.sector(), &actor->ceilingz, c, &actor->floorz, c, 127, CLIPMASK0);
}
else
{
@ -4959,7 +4959,7 @@ int dodge(DDukeActor* actor)
int bx, by, mx, my, bxvect, byvect, d;
mx = actor->spr.pos.X;
my = actor->spr.y;
my = actor->spr.pos.Y;
DukeStatIterator it(STAT_PROJECTILE);
while (auto ac = it.Next())
@ -4968,7 +4968,7 @@ int dodge(DDukeActor* actor)
continue;
bx = ac->spr.pos.X - mx;
by = ac->spr.y - my;
by = ac->spr.pos.Y - my;
bxvect = bcos(ac->spr.ang);
byvect = bsin(ac->spr.ang);
@ -5006,9 +5006,9 @@ int furthestangle(DDukeActor *actor, int angs)
for (j = actor->spr.ang; j < (2048 + actor->spr.ang); j += angincs)
{
hitscan({ actor->spr.pos.X, actor->spr.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.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.y);
d = abs(hit.hitpos.X - actor->spr.pos.X) + abs(hit.hitpos.Y - actor->spr.pos.Y);
if (d > greatestd)
{
@ -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.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.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.y);
da = abs(hit.hitpos.X - actor->spr.pos.X) + abs(hit.hitpos.Y - actor->spr.y);
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.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.z - (16 << 8), actor->spr.sector()))
{
*dax = hit.hitpos.X;
*day = hit.hitpos.Y;
@ -5084,15 +5084,15 @@ void alterang(int ang, DDukeActor* actor, int playernum)
// NOTE: looks like 'Owner' is set to target sprite ID...
if (holoduke && cansee(holoduke->spr.pos.X, holoduke->spr.y, holoduke->spr.z, holoduke->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z, actor->spr.sector()))
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()))
actor->SetOwner(holoduke);
else actor->SetOwner(ps[playernum].GetActor());
auto Owner = actor->GetOwner();
if (Owner->spr.picnum == TILE_APLAYER)
goalang = getangle(actor->lastvx - actor->spr.pos.X, actor->lastvy - actor->spr.y);
goalang = getangle(actor->lastvx - actor->spr.pos.X, actor->lastvy - actor->spr.pos.Y);
else
goalang = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.y - actor->spr.y);
goalang = getangle(Owner->spr.pos.X - actor->spr.pos.X, Owner->spr.pos.Y - actor->spr.pos.Y);
if (actor->spr.xvel && actor->spr.picnum != TILE_DRONE)
{

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

@ -270,13 +270,13 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (((dasectp->ceilingz - actor->spr.z) >> 8) < r)
{
auto wal = dasectp->firstWall();
int d = abs(wal->pos.X - actor->spr.pos.X) + abs(wal->pos.Y - actor->spr.y);
int d = abs(wal->pos.X - actor->spr.pos.X) + abs(wal->pos.Y - actor->spr.pos.Y);
if (d < r)
fi.checkhitceiling(dasectp);
else
{
auto thirdpoint = wal->point2Wall()->point2Wall();
d = abs(thirdpoint->pos.X - actor->spr.pos.X) + abs(thirdpoint->pos.Y - actor->spr.y);
d = abs(thirdpoint->pos.X - actor->spr.pos.X) + abs(thirdpoint->pos.Y - actor->spr.pos.Y);
if (d < r)
fi.checkhitceiling(dasectp);
}
@ -284,17 +284,17 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
for (auto& wal : wallsofsector(dasectp))
{
if ((abs(wal.pos.X - actor->spr.pos.X) + abs(wal.pos.Y - actor->spr.y)) < r)
if ((abs(wal.pos.X - actor->spr.pos.X) + abs(wal.pos.Y - actor->spr.pos.Y)) < r)
{
if (wal.twoSided())
{
search.Add(wal.nextSector());
}
int x1 = (((wal.pos.X + wal.point2Wall()->pos.X) >> 1) + actor->spr.pos.X) >> 1;
int y1 = (((wal.pos.Y + wal.point2Wall()->pos.Y) >> 1) + actor->spr.y) >> 1;
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.y, actor->spr.z, actor->spr.sector()))
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);
}
}
@ -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.y, act2->spr.z + q, act2->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z + q, actor->spr.sector()))
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()))
continue;
fi.checkhitsprite(act2, actor);
}
@ -347,9 +347,9 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
int d = dist(actor, act2);
if (act2->spr.picnum == APLAYER) act2->spr.z += gs.playerheight;
if (d < r && cansee(act2->spr.pos.X, act2->spr.y, act2->spr.z - (8 << 8), act2->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z - (12 << 8), actor->spr.sector()))
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()))
{
act2->ang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.y - actor->spr.y);
act2->ang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
if (actor->spr.picnum == RPG && act2->spr.extra > 0)
act2->picnum = RPG;
@ -448,7 +448,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
if (actor->spr.statnum == 5 || (bg && actor->spr.xrepeat < 4))
{
actor->spr.pos.X += (xchange * TICSPERFRAME) >> 2;
actor->spr.y += (ychange * TICSPERFRAME) >> 2;
actor->spr.pos.Y += (ychange * TICSPERFRAME) >> 2;
actor->spr.z += (zchange * TICSPERFRAME) >> 2;
if (bg)
SetActor(actor, actor->spr.pos);
@ -503,7 +503,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
clipmove(pos, &dasectp, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), (int)(actor->spr.clipdist << 2), (4 << 8), (4 << 8), cliptype, result);
}
actor->spr.pos.X = pos.X;
actor->spr.y = pos.Y;
actor->spr.pos.Y = pos.Y;
if (dasectp != nullptr)
if (dasectp != actor->spr.sector())
@ -555,7 +555,7 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
else sx = sy = 32;
gutz = actor->spr.z - (8 << 8);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -579,7 +579,7 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
int r4 = krand();
int r5 = krand();
// TRANSITIONAL: owned by a player???
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
if (spawned)
{
if (spawned->spr.picnum == JIBS2)
@ -632,7 +632,7 @@ void movefta_d(void)
continue;
}
sx = act->spr.pos.X + 64 - (krand() & 127);
sy = act->spr.y + 64 - (krand() & 127);
sy = act->spr.pos.Y + 64 - (krand() & 127);
updatesector(px, py, &ssect);
if (ssect == nullptr)
{
@ -647,7 +647,7 @@ void movefta_d(void)
{
int r1 = krand();
int r2 = krand();
j = cansee(act->spr.pos.X, act->spr.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.z - ((r2 & 31) << 8), act->spr.sector(), ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursector);
}
@ -1005,16 +1005,16 @@ static void movetripbomb(DDukeActor *actor)
int16_t l = actor->spr.ang;
actor->spr.ang = actor->temp_data[5];
actor->temp_data[3] = actor->spr.pos.X; actor->temp_data[4] = actor->spr.y;
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.y += bsin(actor->temp_data[5], -9);
actor->spr.pos.Y += bsin(actor->temp_data[5], -9);
actor->spr.z -= (3 << 8);
// Laser fix from EDuke32.
auto const oldSect = actor->spr.sector();
auto curSect = actor->spr.sector();
updatesectorneighbor(actor->spr.pos.X, actor->spr.y, &curSect, 2048);
updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
ChangeActorSect(actor, curSect);
DDukeActor* hit;
@ -1044,8 +1044,8 @@ static void movetripbomb(DDukeActor *actor)
x -= 1024;
actor->spr.pos.X += bcos(actor->temp_data[5], -4);
actor->spr.y += bsin(actor->temp_data[5], -4);
updatesectorneighbor(actor->spr.pos.X, actor->spr.y, &curSect, 2048);
actor->spr.pos.Y += bsin(actor->temp_data[5], -4);
updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
if (curSect == nullptr)
break;
@ -1059,7 +1059,7 @@ static void movetripbomb(DDukeActor *actor)
}
actor->temp_data[0]++;
actor->spr.pos.X = actor->temp_data[3]; actor->spr.y = actor->temp_data[4];
actor->spr.pos.X = actor->temp_data[3]; actor->spr.pos.Y = actor->temp_data[4];
actor->spr.z += (3 << 8);
ChangeActorSect(actor, oldSect);
actor->temp_data[3] = 0;
@ -1075,15 +1075,15 @@ static void movetripbomb(DDukeActor *actor)
actor->temp_data[1]++;
actor->temp_data[3] = actor->spr.pos.X; actor->temp_data[4] = actor->spr.y;
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.y += bsin(actor->temp_data[5], -9);
actor->spr.pos.Y += bsin(actor->temp_data[5], -9);
actor->spr.z -= (3 << 8);
SetActor(actor, actor->spr.pos);
x = hitasprite(actor, nullptr);
actor->spr.pos.X = actor->temp_data[3]; actor->spr.y = actor->temp_data[4];
actor->spr.pos.X = actor->temp_data[3]; actor->spr.pos.Y = actor->temp_data[4];
actor->spr.z += (3 << 8);
SetActor(actor, actor->spr.pos);
@ -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.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.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;
}
@ -1462,7 +1462,7 @@ static bool movefireball(DDukeActor* actor)
{
FireProj* proj = &trail->fproj;
ball->spr.pos.X = proj->x;
ball->spr.y = proj->y;
ball->spr.pos.Y = proj->y;
ball->spr.z = proj->z;
ball->spr.xvel = proj->xv;
ball->spr.yvel = proj->yv;
@ -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.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.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.y, proj->spr.z, proj->spr.picnum);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.z, proj->spr.picnum);
if (proj->spr.picnum == FREEZEBLAST)
{
@ -1684,7 +1684,7 @@ static void weaponcommon_d(DDukeActor* proj)
MulScale(k, bsin(proj->spr.ang), 14), ll, CLIPMASK1, coll);
if (proj->spr.picnum == RPG && proj->temp_actor != nullptr)
if (FindDistance2D(proj->spr.pos.X - proj->temp_actor->spr.pos.X, proj->spr.y - proj->temp_actor->spr.y) < 256)
if (FindDistance2D(proj->spr.pos.X - proj->temp_actor->spr.pos.X, proj->spr.pos.Y - proj->temp_actor->spr.pos.Y) < 256)
coll.setSprite(proj->temp_actor);
if (!proj->spr.insector())
@ -1716,7 +1716,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.y + MulScale(k, bsin(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.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
if (spawned)
@ -1941,7 +1941,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.y;
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;
ChangeActorSect(act2, Owner->sector());
@ -1963,7 +1963,7 @@ void movetransports_d(void)
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
{
ps[p].oposx = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].oposy = ps[p].pos.Y += Owner->spr.y - act->spr.y;
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;
@ -2019,7 +2019,7 @@ void movetransports_d(void)
if (k == 1)
{
ps[p].oposx = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].oposy = ps[p].pos.Y += Owner->spr.y - act->spr.y;
ps[p].oposy = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
if (!Owner || Owner->GetOwner() != Owner)
ps[p].transporter_hold = -2;
@ -2133,7 +2133,7 @@ void movetransports_d(void)
if (act2->spr.statnum == STAT_PROJECTILE || (checkcursectnums(act->spr.sector()) == -1 && checkcursectnums(Owner->spr.sector()) == -1))
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z -= act->spr.z - Owner->sector()->floorz;
act2->spr.ang = Owner->spr.ang;
@ -2160,7 +2160,7 @@ void movetransports_d(void)
else
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->spr.z + 4096;
act2->spr.backupz();
@ -2170,7 +2170,7 @@ void movetransports_d(void)
break;
case 1:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->ceilingz + ll;
act2->spr.backupz();
@ -2180,7 +2180,7 @@ void movetransports_d(void)
break;
case 2:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.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.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.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++;
@ -2277,7 +2277,7 @@ static void greenslime(DDukeActor *actor)
}
else if (x < 1024 && ps[p].quick_kick == 0)
{
j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.y - ps[p].pos.Y));
j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->spr.pos.X - ps[p].pos.X, actor->spr.pos.Y - ps[p].pos.Y));
if (j > -128 && j < 128)
ps[p].quick_kick = 14;
}
@ -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.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.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;
}
@ -2380,7 +2380,7 @@ static void greenslime(DDukeActor *actor)
actor->spr.yrepeat = 15 + bsin(t[1], -13);
actor->spr.pos.X = ps[p].pos.X + ps[p].angle.ang.bcos(-7);
actor->spr.y = ps[p].pos.Y + ps[p].angle.ang.bsin(-7);
actor->spr.pos.Y = ps[p].pos.Y + ps[p].angle.ang.bsin(-7);
return;
}
@ -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.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.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;
@ -2462,7 +2462,7 @@ static void greenslime(DDukeActor *actor)
actor->spr.z = s5->spr.z;
actor->spr.pos.X = s5->spr.pos.X + bcos(l, -11);
actor->spr.y = s5->spr.y + bsin(l, -11);
actor->spr.pos.Y = s5->spr.pos.Y + bsin(l, -11);
actor->spr.picnum = GREENSLIME + 2 + (global_random & 1);
@ -2542,7 +2542,7 @@ static void greenslime(DDukeActor *actor)
actor->spr.xvel = 64 - bcos(t[1], -9);
actor->spr.ang += getincangle(actor->spr.ang,
getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.y)) >> 3;
getangle(ps[p].pos.X - actor->spr.pos.X, ps[p].pos.Y - actor->spr.pos.Y)) >> 3;
// TJR
}
@ -2623,7 +2623,7 @@ static void flamethrowerflame(DDukeActor *actor)
}
int dax = actor->spr.pos.X;
int day = actor->spr.y;
int day = actor->spr.pos.Y;
int daz = actor->spr.z;
int xvel = actor->spr.xvel;
@ -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.y, actor->spr.z, actor->spr.picnum);
fi.checkhitwall(actor, coll.hitWall, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.z, actor->spr.picnum);
}
else if (coll.type == kHitSector)
{
@ -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.y, actor->spr.z, actor->spr.picnum);
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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.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.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)
@ -3120,7 +3120,7 @@ static void fireflyflyingeffect(DDukeActor *actor)
actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
double dx = Owner->spr.pos.X - ps[p].GetActor()->spr.pos.X;
double dy = Owner->spr.y - ps[p].GetActor()->spr.y;
double dy = Owner->spr.pos.Y - ps[p].GetActor()->spr.pos.Y;
double dist = sqrt(dx * dx + dy * dy);
if (dist != 0.0)
{
@ -3129,7 +3129,7 @@ static void fireflyflyingeffect(DDukeActor *actor)
}
actor->spr.pos.X = (int) (Owner->spr.pos.X - (dx * -10.0));
actor->spr.y = (int) (Owner->spr.y - (dy * -10.0));
actor->spr.pos.Y = (int) (Owner->spr.pos.Y - (dy * -10.0));
actor->spr.z = Owner->spr.z + 2048;
if (Owner->spr.extra <= 0)
@ -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.y);
act->floorz = act->spr.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
break;
case MONEY:
case MAIL:
@ -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.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.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))
{
@ -3682,8 +3682,8 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (a & face_player)
{
if (ps[playernum].newOwner != nullptr)
goalang = getangle(ps[playernum].oposx - actor->spr.pos.X, ps[playernum].oposy - actor->spr.y);
else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.y);
goalang = getangle(ps[playernum].oposx - actor->spr.pos.X, ps[playernum].oposy - actor->spr.pos.Y);
else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3695,8 +3695,8 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (a & face_player_slow)
{
if (ps[playernum].newOwner != nullptr)
goalang = getangle(ps[playernum].oposx - actor->spr.pos.X, ps[playernum].oposy - actor->spr.y);
else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.y);
goalang = getangle(ps[playernum].oposx - actor->spr.pos.X, ps[playernum].oposy - actor->spr.pos.Y);
else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
@ -3719,7 +3719,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
newx = ps[playernum].pos.X + (ps[playernum].posxv / 768);
newy = ps[playernum].pos.Y + (ps[playernum].posyv / 768);
goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.y);
goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.pos.Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3727,7 +3727,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (t[1] == 0 || a == 0)
{
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->spr.ox != actor->spr.pos.X) || (actor->spr.oy != actor->spr.y))
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->spr.ox != actor->spr.pos.X) || (actor->spr.oy != actor->spr.pos.Y))
{
actor->spr.backupvec2();
SetActor(actor, actor->spr.pos);
@ -3758,14 +3758,14 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (actor->spr.picnum == COMMANDER)
{
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
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.z > (l - (8 << 8))) actor->spr.z = l - (8 << 8);
actor->spr.zvel = 0;
}
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (80 << 8))
{
actor->spr.z = l + (80 << 8);
@ -3776,13 +3776,13 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (actor->spr.zvel > 0)
{
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
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);
}
else
{
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (50 << 8))
{
actor->spr.z = l + (50 << 8);
@ -3797,7 +3797,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
actor->spr.z = actor->floorz;
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (66 << 8))
{
actor->spr.z = l + (66 << 8);
@ -3819,7 +3819,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
daxvel = -(1024 - xvel);
angdif = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.y);
angdif = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
if (xvel < 512)
{

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

@ -228,13 +228,13 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (((dasectp->ceilingz - actor->spr.z) >> 8) < r)
{
auto wal = dasectp->firstWall();
int d = abs(wal->pos.X - actor->spr.pos.X) + abs(wal->pos.Y - actor->spr.y);
int d = abs(wal->pos.X - actor->spr.pos.X) + abs(wal->pos.Y - actor->spr.pos.Y);
if (d < r)
fi.checkhitceiling(dasectp);
else
{
auto thirdpoint = wal->point2Wall()->point2Wall();
d = abs(thirdpoint->pos.X - actor->spr.pos.X) + abs(thirdpoint->pos.Y - actor->spr.y);
d = abs(thirdpoint->pos.X - actor->spr.pos.X) + abs(thirdpoint->pos.Y - actor->spr.pos.Y);
if (d < r)
fi.checkhitceiling(dasectp);
}
@ -242,17 +242,17 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
for (auto& wal : wallsofsector(dasectp))
{
if ((abs(wal.pos.X - actor->spr.pos.X) + abs(wal.pos.Y - actor->spr.y)) < r)
if ((abs(wal.pos.X - actor->spr.pos.X) + abs(wal.pos.Y - actor->spr.pos.Y)) < r)
{
if (wal.twoSided())
{
search.Add(wal.nextSector());
}
int x1 = (((wal.pos.X + wal.point2Wall()->pos.X) >> 1) + actor->spr.pos.X) >> 1;
int y1 = (((wal.pos.Y + wal.point2Wall()->pos.Y) >> 1) + actor->spr.y) >> 1;
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.y, actor->spr.z, actor->spr.sector()))
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);
}
}
@ -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.y, act2->spr.z + q, act2->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z + q, actor->spr.sector()))
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()))
{
continue;
}
@ -294,14 +294,14 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
int d = dist(actor, act2);
if (act2->spr.picnum == APLAYER) act2->spr.z += gs.playerheight;
if (d < r && cansee(act2->spr.pos.X, act2->spr.y, act2->spr.z - (8 << 8), act2->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z - (12 << 8), actor->spr.sector()))
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 ((isRRRA()) && act2->spr.picnum == MINION && act2->spr.pal == 19)
{
continue;
}
act2->ang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.y - actor->spr.y);
act2->ang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
if (actor->spr.picnum == RPG && act2->spr.extra > 0)
act2->picnum = RPG;
@ -372,7 +372,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
if (actor->spr.statnum == 5 || (bg && actor->spr.xrepeat < 4))
{
actor->spr.pos.X += (xchange * TICSPERFRAME) >> 2;
actor->spr.y += (ychange * TICSPERFRAME) >> 2;
actor->spr.pos.Y += (ychange * TICSPERFRAME) >> 2;
actor->spr.z += (zchange * TICSPERFRAME) >> 2;
if (bg)
SetActor(actor, actor->spr.pos);
@ -414,7 +414,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
clipmove(pos, &dasectp, ((xchange * TICSPERFRAME) << 11), ((ychange * TICSPERFRAME) << 11), 128, (4 << 8), (4 << 8), cliptype, result);
}
actor->spr.pos.X = pos.X;
actor->spr.y = pos.Y;
actor->spr.pos.Y = pos.Y;
if (dasectp)
if ((dasectp != actor->spr.sector()))
@ -458,7 +458,7 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
else sx = sy = 32;
gutz = actor->spr.z - (8 << 8);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
floorz = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -486,7 +486,7 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
int r4 = krand();
int r5 = krand();
// TRANSITIONAL: owned by a player???
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
auto spawned = EGS(actor->spr.sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
if (spawned && pal != 0)
spawned->spr.pal = pal;
}
@ -530,7 +530,7 @@ void movefta_r(void)
continue;
}
sx = act->spr.pos.X + 64 - (krand() & 127);
sy = act->spr.y + 64 - (krand() & 127);
sy = act->spr.pos.Y + 64 - (krand() & 127);
updatesector(px, py, &ssect);
if (ssect == nullptr)
{
@ -552,7 +552,7 @@ void movefta_r(void)
{
int r1 = krand();
int r2 = krand();
j = cansee(act->spr.pos.X, act->spr.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.z - ((r2 & 31) << 8), act->spr.sector(), ps[p].oposx, ps[p].oposy, ps[p].oposz - ((r1 & 31) << 8), ps[p].cursector);
}
@ -1086,7 +1086,7 @@ static void chickenarrow(DDukeActor* actor)
if (actor->seek_actor && actor->spr.hitag > 5)
{
int ang, ang2, ang3;
ang = getangle(ts->spr.pos.X - actor->spr.pos.X, ts->spr.y - actor->spr.y);
ang = getangle(ts->spr.pos.X - actor->spr.pos.X, ts->spr.pos.Y - actor->spr.pos.Y);
ang2 = ang - actor->spr.ang;
ang3 = abs(ang2);
if (ang2 < 100)
@ -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.y, proj->spr.z, proj->spr.picnum);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.z, proj->spr.picnum);
if (!isRRRA() && proj->spr.picnum == FREEZEBLAST)
{
@ -1237,7 +1237,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t& oldpos)
if (proj->spr.extra <= 0)
{
proj->spr.pos.X += bcos(proj->spr.ang, -7);
proj->spr.y += bsin(proj->spr.ang, -7);
proj->spr.pos.Y += bsin(proj->spr.ang, -7);
auto Owner = proj->GetOwner();
if (!isRRRA() || !Owner || (Owner->spr.picnum != CHEER && Owner->spr.picnum != CHEERSTAYPUT))
{
@ -1381,7 +1381,7 @@ static void weaponcommon_r(DDukeActor *proj)
MulScale(k, bsin(proj->spr.ang), 14), ll, CLIPMASK1, coll);
if ((proj->spr.picnum == RPG || (isRRRA() && isIn(proj->spr.picnum, RPG2, RRTILE1790))) && proj->temp_actor != nullptr)
if (FindDistance2D(proj->spr.pos.X - proj->temp_actor->spr.pos.X, proj->spr.y - proj->temp_actor->spr.y) < 256)
if (FindDistance2D(proj->spr.pos.X - proj->temp_actor->spr.pos.X, proj->spr.pos.Y - proj->temp_actor->spr.pos.Y) < 256)
coll.setSprite(proj->temp_actor);
if (!proj->spr.insector()) // || (isRR() && proj->spr.sector()->filler == 800))
@ -1412,7 +1412,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.y + MulScale(k, bsin(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.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
@ -1605,7 +1605,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.y;
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));
ChangeActorSect(act2, Owner->sector());
@ -1624,7 +1624,7 @@ void movetransports_r(void)
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
{
ps[p].oposx = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].oposy = ps[p].pos.Y += Owner->spr.y - act->spr.y;
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;
@ -1690,7 +1690,7 @@ void movetransports_r(void)
if (k == 1)
{
ps[p].oposx = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].oposy = ps[p].pos.Y += Owner->spr.y - act->spr.y;
ps[p].oposy = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
if (Owner->GetOwner() != Owner)
ps[p].transporter_hold = -2;
@ -1704,7 +1704,7 @@ void movetransports_r(void)
else if (isRRRA() && k == 2)
{
ps[p].oposx = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].oposy = ps[p].pos.Y += Owner->spr.y - act->spr.y;
ps[p].oposy = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
if (Owner->GetOwner() != Owner)
ps[p].transporter_hold = -2;
@ -1821,7 +1821,7 @@ void movetransports_r(void)
if (checkcursectnums(act->spr.sector()) == -1 && checkcursectnums(Owner->spr.sector()) == -1)
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z -= act->spr.z - Owner->sector()->floorz;
act2->spr.ang = Owner->spr.ang;
@ -1845,7 +1845,7 @@ void movetransports_r(void)
else
{
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->spr.z + 4096;
act2->spr.backupz();
@ -1855,7 +1855,7 @@ void movetransports_r(void)
break;
case ST_1_ABOVE_WATER:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->ceilingz + ll;
act2->spr.backupz();
@ -1865,7 +1865,7 @@ void movetransports_r(void)
break;
case ST_2_UNDERWATER:
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->floorz - ll;
act2->spr.backupz();
@ -1877,7 +1877,7 @@ void movetransports_r(void)
case 160:
if (!isRRRA()) break;
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->ceilingz + ll2;
act2->spr.backupz();
@ -1891,7 +1891,7 @@ void movetransports_r(void)
case 161:
if (!isRRRA()) break;
act2->spr.pos.X += (Owner->spr.pos.X - act->spr.pos.X);
act2->spr.y += (Owner->spr.y - act->spr.y);
act2->spr.pos.Y += (Owner->spr.pos.Y - act->spr.pos.Y);
act2->spr.z = Owner->sector()->floorz - ll2;
act2->spr.backupz();
@ -2072,7 +2072,7 @@ static void rrra_specialstats()
}
else if (act->spr.extra == 200)
{
SetActor(act, { act->spr.pos.X, act->spr.y, act->spr.sector()->floorz - 10 });
SetActor(act, { act->spr.pos.X, act->spr.pos.Y, act->spr.sector()->floorz - 10 });
act->spr.extra = 1;
act->spr.picnum = PIG + 11;
spawn(act, TRANSPORTERSTAR);
@ -2450,7 +2450,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.y;
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);
auto pact = ps[p].GetActor();
ChangeActorSect(pact, act2->sector());
@ -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.y, actor->spr.z, actor->spr.picnum);
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.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.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.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)
{
@ -2996,7 +2996,7 @@ void moveactors_r(void)
getglobalz(act);
if (sectp->lotag == 1)
{
SetActor(act, { act->spr.pos.X,act->spr.y,act->floorz + (16 << 8) });
SetActor(act, { act->spr.pos.X,act->spr.pos.Y,act->floorz + (16 << 8) });
}
break;
@ -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.y);
act->floorz = act->spr.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.sector()->lotag == 800)
{
deletesprite(act);
@ -3334,7 +3334,7 @@ void handle_se06_r(DDukeActor *actor)
}
if (!hulkspawn)
{
ns = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
ns = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
if (ns)
{
ns->spr.cstat = CSTAT_SPRITE_TRANS_FLIP | CSTAT_SPRITE_TRANSLUCENT;
@ -3657,8 +3657,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a & face_player)
{
if (ps[pnum].newOwner != nullptr)
goalang = getangle(ps[pnum].oposx - actor->spr.pos.X, ps[pnum].oposy - actor->spr.y);
else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.y);
goalang = getangle(ps[pnum].oposx - actor->spr.pos.X, ps[pnum].oposy - actor->spr.pos.Y);
else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3670,8 +3670,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a & face_player_slow)
{
if (ps[pnum].newOwner != nullptr)
goalang = getangle(ps[pnum].oposx - actor->spr.pos.X, ps[pnum].oposy - actor->spr.y);
else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.y);
goalang = getangle(ps[pnum].oposx - actor->spr.pos.X, ps[pnum].oposy - actor->spr.pos.Y);
else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
@ -3686,8 +3686,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a & antifaceplayerslow)
{
if (ps[pnum].newOwner != nullptr)
goalang = (getangle(ps[pnum].oposx - actor->spr.pos.X, ps[pnum].oposy - actor->spr.y) + 1024) & 2047;
else goalang = (getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.y) + 1024) & 2047;
goalang = (getangle(ps[pnum].oposx - actor->spr.pos.X, ps[pnum].oposy - actor->spr.pos.Y) + 1024) & 2047;
else goalang = (getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y) + 1024) & 2047;
angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
@ -3755,7 +3755,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
newx = ps[pnum].pos.X + (ps[pnum].posxv / 768);
newy = ps[pnum].pos.Y + (ps[pnum].posyv / 768);
goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.y);
goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.pos.Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3763,7 +3763,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (t[1] == 0 || a == 0)
{
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->spr.ox != actor->spr.pos.X) || (actor->spr.oy != actor->spr.y))
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->spr.ox != actor->spr.pos.X) || (actor->spr.oy != actor->spr.pos.Y))
{
actor->spr.backupvec2();
SetActor(actor, actor->spr.pos);
@ -3812,7 +3812,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
{
if (actor->spr.zvel > 0)
{
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
actor->floorz = l = getflorzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (isRRRA())
{
if (actor->spr.z > (l - (28 << 8)))
@ -3826,7 +3826,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
}
else
{
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
actor->ceilingz = l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (50 << 8))
{
actor->spr.z = l + (50 << 8);
@ -3838,7 +3838,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
actor->spr.z = actor->floorz;
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.y);
l = getceilzofslopeptr(actor->spr.sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.z - l) < (66 << 8))
{
actor->spr.z = l + (66 << 8);
@ -3859,7 +3859,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
{
daxvel = -(1024 - xvel);
angdif = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.y);
angdif = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
if (xvel < 512)
{

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

@ -166,7 +166,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
if (h->spr.statnum != STAT_ACTOR && h->spr.picnum == APLAYER && ps[h->spr.yvel].newOwner == nullptr && h->GetOwner())
{
t->pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].oposx, 16);
t->y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].oposy, 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;
}
@ -208,11 +208,11 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
int sqa =
getangle(
OwnerAc->spr.pos.X - ps[screenpeek].pos.X,
OwnerAc->spr.y - ps[screenpeek].pos.Y);
OwnerAc->spr.pos.Y - ps[screenpeek].pos.Y);
int sqb =
getangle(
OwnerAc->spr.pos.X - t->pos.X,
OwnerAc->spr.y - t->y);
OwnerAc->spr.pos.Y - t->pos.Y);
if (abs(getincangle(sqa, sqb)) > 512)
if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@ -227,11 +227,11 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
t->xrepeat = 0;
else
{
t->ang = getangle(x - t->pos.X, y - t->y);
t->ang = getangle(x - t->pos.X, y - t->pos.Y);
t->pos.X = OwnerAc->spr.pos.X;
t->y = OwnerAc->spr.y;
t->pos.Y = OwnerAc->spr.pos.Y;
t->pos.X += bcos(t->ang, -10);
t->y += bsin(t->ang, -10);
t->pos.Y += bsin(t->ang, -10);
}
}
break;
@ -270,7 +270,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
}
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -288,7 +288,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
}
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
if (h->temp_data[0] < 4)
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
else k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
@ -521,7 +521,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case 5:
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -531,7 +531,7 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
else t->cstat &= ~CSTAT_SPRITE_XFLIP;
break;
case 7:
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -609,9 +609,9 @@ void animatesprites_d(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
else
{
// Alter the shadow's position so that it appears behind the sprite itself.
int look = getangle(shadowspr->pos.X - ps[screenpeek].pos.X, shadowspr->y - ps[screenpeek].pos.Y);
int look = getangle(shadowspr->pos.X - ps[screenpeek].pos.X, shadowspr->pos.Y - ps[screenpeek].pos.Y);
shadowspr->pos.X += bcos(look, -9);
shadowspr->y += bsin(look, -9);
shadowspr->pos.Y += bsin(look, -9);
}
}
}

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

@ -147,7 +147,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
if (h->spr.statnum != STAT_ACTOR && h->spr.picnum == APLAYER && ps[h->spr.yvel].newOwner == nullptr && h->GetOwner())
{
t->pos.X -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.X - ps[h->spr.yvel].oposx, 16);
t->y -= MulScale(MaxSmoothRatio - smoothratio, ps[h->spr.yvel].pos.Y - ps[h->spr.yvel].oposy, 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;
h->spr.xrepeat = 24;
@ -202,11 +202,11 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
int sqa =
getangle(
OwnerAc->spr.pos.X - ps[screenpeek].pos.X,
OwnerAc->spr.y - ps[screenpeek].pos.Y);
OwnerAc->spr.pos.Y - ps[screenpeek].pos.Y);
int sqb =
getangle(
OwnerAc->spr.pos.X - t->pos.X,
OwnerAc->spr.y - t->y);
OwnerAc->spr.pos.Y - t->pos.Y);
if (abs(getincangle(sqa, sqb)) > 512)
if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@ -220,11 +220,11 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
t->xrepeat = 0;
else
{
t->ang = getangle(x - t->pos.X, y - t->y);
t->ang = getangle(x - t->pos.X, y - t->pos.Y);
t->pos.X = OwnerAc->spr.pos.X;
t->y = OwnerAc->spr.y;
t->pos.Y = OwnerAc->spr.pos.Y;
t->pos.X += bcos(t->ang, -10);
t->y += bsin(t->ang, -10);
t->pos.Y += bsin(t->ang, -10);
}
}
break;
@ -263,7 +263,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
}
else if (OwnerAc->spr.picnum == MAMA)
{
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -281,7 +281,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case EMPTYBIKE:
if (!isRRRA()) goto default_case;
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -293,7 +293,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case EMPTYBOAT:
if (!isRRRA()) goto default_case;
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -304,7 +304,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
t->picnum = EMPTYBOAT + k;
break;
case RPG:
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -316,7 +316,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case RPG2:
if (!isRRRA()) goto default_case;
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -329,7 +329,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
case RECON:
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
if (h->temp_data[0] < 4)
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
else k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
@ -652,7 +652,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
break;
case 5:
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -662,7 +662,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
else t->cstat &= ~CSTAT_SPRITE_XFLIP;
break;
case 7:
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -679,7 +679,7 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
bg = badguy(h);
if (bg && h->spr.statnum == 2 && h->spr.extra > 0)
{
k = getangle(h->spr.pos.X - x, h->spr.y - y);
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -764,9 +764,9 @@ void animatesprites_r(tspritetype* tsprite, int& spritesortcnt, int x, int y, in
else
{
// Alter the shadow's position so that it appears behind the sprite itself.
int look = getangle(shadowspr->pos.X - ps[screenpeek].pos.X, shadowspr->y - ps[screenpeek].pos.Y);
int look = getangle(shadowspr->pos.X - ps[screenpeek].pos.X, shadowspr->pos.Y - ps[screenpeek].pos.Y);
shadowspr->pos.X += bcos(look, -9);
shadowspr->y += bsin(look, -9);
shadowspr->pos.Y += bsin(look, -9);
}
}
}

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

@ -409,7 +409,7 @@ bool GameInterface::DrawAutomapPlayer(int mx, int my, int cposx, int cposy, int
if (act->spr.cstat & CSTAT_SPRITE_BLOCK) col = PalEntry(170, 0, 170);
sprx = act->spr.pos.X;
spry = act->spr.y;
spry = act->spr.pos.Y;
if ((act->spr.cstat & CSTAT_SPRITE_BLOCK_ALL) != 0) switch (act->spr.cstat & CSTAT_SPRITE_ALIGNMENT_MASK)
{

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

@ -1183,8 +1183,8 @@ void DoActor(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor,
else SetGameVarID(lVar2, act->spr.pos.X, sActor, sPlayer);
break;
case ACTOR_Y:
if (bSet) act->spr.y = lValue;
else SetGameVarID(lVar2, act->spr.y, sActor, sPlayer);
if (bSet) act->spr.pos.Y = lValue;
else SetGameVarID(lVar2, act->spr.pos.Y, sActor, sPlayer);
break;
case ACTOR_Z:
if (bSet) act->spr.z = 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.y, actor->spr.z - (krand() & ((32 << 8) - 1)), actor->spr.sector(), tosee->spr.pos.X, tosee->spr.y, tosee->spr.z, tosee->sector());
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());
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.y, actor->spr.z - (krand() & ((47 << 8))), actor->spr.sector(), tosee->spr.pos.X, tosee->spr.y, tosee->spr.z - ((isRR()? 28 : 24) << 8), tosee->sector());
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());
if (j == 0)
{
@ -1503,7 +1503,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
// else, they did see it.
// save where we were looking..
actor->lastvx = tosee->spr.pos.X;
actor->lastvy = tosee->spr.y;
actor->lastvy = tosee->spr.pos.Y;
}
if (j == 1 && (actor->spr.statnum == STAT_ACTOR || actor->spr.statnum == STAT_STANDABLE))
@ -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.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.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.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.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;
@ -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.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.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)
@ -2246,7 +2246,7 @@ int ParseState::parse(void)
// I am not convinced this is even remotely smart to be executed from here..
pickrandomspot(g_p);
g_ac->spr.pos.X = ps[g_p].bobposx = ps[g_p].oposx = ps[g_p].pos.X;
g_ac->spr.y = ps[g_p].bobposy = ps[g_p].oposy = ps[g_p].pos.Y;
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.backuppos();
updatesector(ps[g_p].pos.X, ps[g_p].pos.Y, &ps[g_p].cursector);
@ -2449,7 +2449,7 @@ int ParseState::parse(void)
if (g_ac->spr.picnum == TILE_APLAYER && ud.multimode > 1)
j = getincangle(ps[otherp].angle.ang.asbuild(), getangle(ps[g_p].pos.X - ps[otherp].pos.X, ps[g_p].pos.Y - ps[otherp].pos.Y));
else
j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_ac->spr.pos.X - ps[g_p].pos.X, g_ac->spr.y - ps[g_p].pos.Y));
j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_ac->spr.pos.X - ps[g_p].pos.X, g_ac->spr.pos.Y - ps[g_p].pos.Y));
if( j > -128 && j < 128 )
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.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.z - (32 << 8) }, g_ac->spr.sector(), g_ac->spr.ang, hit, 768, 1);
auto sectp = hit.hitSector;
if (sectp)
{
@ -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.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.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)
@ -2827,16 +2827,16 @@ int ParseState::parse(void)
j = 0;
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.y + 108, &s1);
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y + 108, &s1);
if (s1 == g_ac->spr.sector())
{
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.y - 108, &s1);
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y - 108, &s1);
if (s1 == g_ac->spr.sector())
{
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.y - 108, &s1);
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y - 108, &s1);
if (s1 == g_ac->spr.sector())
{
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.y + 108, &s1);
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y + 108, &s1);
if (s1 == g_ac->spr.sector())
j = 1;
}
@ -3151,7 +3151,7 @@ int ParseState::parse(void)
i = *(insptr++); // ID of def
// g_ac->lastvx and lastvy are last known location of target.
ang = getangle(g_ac->lastvx - g_ac->spr.pos.X, g_ac->lastvy - g_ac->spr.y);
ang = getangle(g_ac->lastvx - g_ac->spr.pos.X, g_ac->lastvy - g_ac->spr.pos.Y);
SetGameVarID(i, ang, g_ac, g_p);
break;
}

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

@ -85,7 +85,7 @@ inline int ldist(DDukeActor* s1, DDukeActor* s2)
{
int vx, vy;
vx = s1->spr.pos.X - s2->spr.pos.X;
vy = s1->spr.y - s2->spr.y;
vy = s1->spr.pos.Y - s2->spr.pos.Y;
return(FindDistance2D(vx, vy) + 1);
}
@ -93,14 +93,14 @@ inline int ldist(const DDukeActor* s1, const tspritetype* s2)
{
int vx, vy;
vx = s1->spr.pos.X - s2->pos.X;
vy = s1->spr.y - s2->y;
vy = s1->spr.pos.Y - s2->pos.Y;
return(FindDistance2D(vx, vy) + 1);
}
inline int dist(DDukeActor* s1, DDukeActor* s2)
{
int vx, vy, vz;
vx = s1->spr.pos.X - s2->spr.pos.X;
vy = s1->spr.y - s2->spr.y;
vy = s1->spr.pos.Y - s2->spr.pos.Y;
vz = s1->spr.z - s2->spr.z;
return(FindDistance3D(vx, vy, vz));
}

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

@ -53,7 +53,7 @@ int wakeup(DDukeActor* actor, int snum)
radius = p->noise_radius;
if (p->noise_x - radius < actor->spr.pos.X && p->noise_x + radius > actor->spr.pos.X
&& p->noise_y - radius < actor->spr.y && p->noise_y + radius > actor->spr.y)
&& p->noise_y - radius < actor->spr.pos.Y && p->noise_y + radius > actor->spr.pos.Y)
return 1;
return 0;
}

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

@ -175,7 +175,7 @@ int hits(DDukeActor* actor)
else zoff = 0;
hitscan(actor->spr.pos, actor->spr.sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
return (FindDistance2D(hit.hitpos.X - actor->spr.pos.X, hit.hitpos.Y - actor->spr.y));
return (FindDistance2D(hit.hitpos.X - actor->spr.pos.X, hit.hitpos.Y - actor->spr.pos.Y));
}
//---------------------------------------------------------------------------
@ -194,13 +194,13 @@ 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.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.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))
return((1 << 30));
return (FindDistance2D(hit.hitpos.X - actor->spr.pos.X, hit.hitpos.Y - actor->spr.y));
return (FindDistance2D(hit.hitpos.X - actor->spr.pos.X, hit.hitpos.Y - actor->spr.pos.Y));
}
//---------------------------------------------------------------------------
@ -318,7 +318,7 @@ DDukeActor* aim(DDukeActor* actor, int aang)
}
xv = (act->spr.pos.X - actor->spr.pos.X);
yv = (act->spr.y - actor->spr.y);
yv = (act->spr.pos.Y - actor->spr.pos.Y);
if ((dy1 * xv) <= (dx1 * yv))
if ((dy2 * xv) >= (dx2 * yv))
@ -330,7 +330,7 @@ DDukeActor* aim(DDukeActor* actor, int aang)
a = (abs(Scale(act->spr.z - actor->spr.z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
else a = 1;
cans = cansee(act->spr.pos.X, act->spr.y, act->spr.z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->spr.sector(), actor->spr.pos.X, actor->spr.y, actor->spr.z - (32 << 8), actor->spr.sector());
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());
if (a && cans)
{
@ -489,7 +489,7 @@ void footprints(int snum)
{
if (act->spr.picnum == TILE_FOOTPRINTS || act->spr.picnum == TILE_FOOTPRINTS2 || act->spr.picnum == TILE_FOOTPRINTS3 || act->spr.picnum == TILE_FOOTPRINTS4)
if (abs(act->spr.pos.X - p->pos.X) < 384)
if (abs(act->spr.y - p->pos.Y) < 384)
if (abs(act->spr.pos.Y - p->pos.Y) < 384)
{
j = 1;
break;
@ -1029,7 +1029,7 @@ void shootbloodsplat(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
auto delta = hit.hitWall->delta();
spawned->spr.ang = getangle(-delta.X, -delta.Y) + 512; // note the '-' sign here!
spawned->spr.pos.X = hit.hitpos.X;
spawned->spr.y = hit.hitpos.Y;
spawned->spr.pos.Y = hit.hitpos.Y;
spawned->spr.z = hit.hitpos.Z;
spawned->spr.cstat |= randomXFlip();
ssp(spawned, CLIPMASK0);

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

@ -199,7 +199,7 @@ static void shootflamethrowerflame(DDukeActor* actor, int p, int sx, int sy, int
}
spawned->spr.pos.X = sx + bsin(sa + 630) / 448;
spawned->spr.y = sy + bsin(sa + 112) / 448;
spawned->spr.pos.Y = sy + bsin(sa + 112) / 448;
spawned->spr.z = sz - 256;
spawned->spr.setsector(actor->spr.sector());
spawned->spr.cstat = CSTAT_SPRITE_YCENTER;
@ -215,7 +215,7 @@ static void shootflamethrowerflame(DDukeActor* actor, int p, int sx, int sy, int
if (actor->spr.picnum == BOSS5)
{
spawned->spr.pos.X -= bsin(sa) / 56;
spawned->spr.y += bcos(sa) / 56;
spawned->spr.pos.Y += bcos(sa) / 56;
spawned->spr.xrepeat = 10;
spawned->spr.yrepeat = 10;
}
@ -245,7 +245,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);
sa = getangle(pactor->spr.pos.X - sx, pactor->spr.y - sy);
sa = getangle(pactor->spr.pos.X - sx, pactor->spr.pos.Y - sy);
}
hitscan({ sx, sy, sz }, sectp, { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
@ -297,7 +297,7 @@ static void shootknee(DDukeActor* actor, int p, int sx, int sy, int sz, int sa)
if (splash)
{
splash->spr.pos.X = hit.hitpos.X;
splash->spr.y = hit.hitpos.Y;
splash->spr.pos.Y = hit.hitpos.Y;
splash->spr.ang = ps[p].angle.ang.asbuild(); // Total tweek
splash->spr.xvel = 32;
ssp(actor, CLIPMASK0);
@ -351,7 +351,7 @@ static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa
break;
}
zvel = ((aimed->spr.z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
if (isWW2GI())
@ -596,7 +596,7 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@ -695,7 +695,7 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
if (aimed->spr.picnum != RECON)
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 81, 16);
if (atwith == RPG)
@ -773,7 +773,7 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
}
spawned->spr.pos.X += xoffs;
spawned->spr.y += yoffs;
spawned->spr.pos.Y += yoffs;
spawned->spr.ang += aoffs;
spawned->spr.xrepeat = 42;
@ -793,7 +793,7 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
}
spawned->spr.pos.X -= xoffs;
spawned->spr.y -= yoffs;
spawned->spr.pos.Y -= yoffs;
spawned->spr.ang -= aoffs;
spawned->spr.xrepeat = 24;
@ -815,12 +815,12 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
if (ps[p].hbomb_hold_delay)
{
spawned->spr.pos.X -= bsin(sa) / 644;
spawned->spr.y += bcos(sa) / 644;
spawned->spr.pos.Y += bcos(sa) / 644;
}
else
{
spawned->spr.pos.X += bsin(sa, -8);
spawned->spr.y -= bcos(sa, -8);
spawned->spr.pos.Y -= bcos(sa, -8);
}
spawned->spr.xrepeat >>= 1;
spawned->spr.yrepeat >>= 1;
@ -938,7 +938,7 @@ static void shootgrowspark(DDukeActor* actor, int p, int sx, int sy, int sz, int
break;
}
zvel = ((aimed->spr.z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
{
@ -1035,7 +1035,7 @@ void shoot_d(DDukeActor* actor, int atwith)
{
sa = actor->spr.ang;
sx = actor->spr.pos.X;
sy = actor->spr.y;
sy = actor->spr.pos.Y;
sz = actor->spr.z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
if (actor->spr.picnum != ROTATEGUN)
{
@ -1067,7 +1067,7 @@ void shoot_d(DDukeActor* actor, int atwith)
{
k->spr.setsector(sect);
k->spr.pos.X = sx;
k->spr.y = sy;
k->spr.pos.Y = sy;
k->spr.z = sz;
k->spr.ang = sa;
k->spr.xvel = 500;
@ -1149,7 +1149,7 @@ void shoot_d(DDukeActor* actor, int atwith)
{
dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1);
zvel = ((aimed->spr.z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
}
@ -1995,7 +1995,7 @@ static void underwater(int snum, ESyncBits actions, int fz, int cz)
if (j)
{
j->spr.pos.X += bcos(p->angle.ang.asbuild() + 64 - (global_random & 128), -6);
j->spr.y += bsin(p->angle.ang.asbuild() + 64 - (global_random & 128), -6);
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);
@ -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.y - hit.hitpos.Y) * (act->spr.y - hit.hitpos.Y)) < (290 * 290))
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))
return 0;
}
@ -2782,7 +2782,7 @@ void processinput_d(int snum)
}
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.z - clz.actor()->spr.z) < (84 << 8))
{
j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.y - p->pos.Y);
j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
p->posxv -= bcos(j, 4);
p->posyv -= bsin(j, 4);
}

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

@ -100,7 +100,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);
sa = getangle(pspr->spr.pos.X - sx, pspr->spr.y - sy);
sa = getangle(pspr->spr.pos.X - sx, pspr->spr.pos.Y - sy);
}
hitscan({ sx, sy, sz }, sectp, { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
@ -116,7 +116,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
{
int nx, ny, nz;
nx = hit.hitpos.X + (effector->GetOwner()->spr.pos.X - effector->spr.pos.X);
ny = hit.hitpos.Y + (effector->GetOwner()->spr.y - effector->spr.y);
ny = hit.hitpos.Y + (effector->GetOwner()->spr.pos.Y - effector->spr.pos.Y);
if (hit.hitSector->lotag == 161)
{
nz = effector->GetOwner()->sector()->floorz;
@ -186,7 +186,7 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
if (splash)
{
splash->spr.pos.X = hit.hitpos.X;
splash->spr.y = hit.hitpos.Y;
splash->spr.pos.Y = hit.hitpos.Y;
splash->spr.ang = ps[p].angle.ang.asbuild(); // Total tweek
splash->spr.xvel = 32;
ssp(actor, 0);
@ -217,7 +217,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (5 << 8);
zvel = ((aimed->spr.z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
if (atwith == SHOTSPARK1)
@ -272,7 +272,7 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
{
int nx, ny, nz;
nx = hit.hitpos.X + (effector->GetOwner()->spr.pos.X - effector->spr.pos.X);
ny = hit.hitpos.Y + (effector->GetOwner()->spr.y - effector->spr.y);
ny = hit.hitpos.Y + (effector->GetOwner()->spr.pos.Y - effector->spr.pos.Y);
if (hit.hitSector->lotag == 161)
{
nz = effector->GetOwner()->sector()->floorz;
@ -510,7 +510,7 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
{
@ -626,7 +626,7 @@ static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
if (aimed->spr.picnum != RECON)
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 81, 16);
if (atwith == RPG)
@ -723,12 +723,12 @@ static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
if (ps[p].hbomb_hold_delay)
{
spawned->spr.pos.X -= bsin(sa) / 644;
spawned->spr.y += bcos(sa) / 644;
spawned->spr.pos.Y += bcos(sa) / 644;
}
else
{
spawned->spr.pos.X += bsin(sa, -8);
spawned->spr.y -= bcos(sa, -8);
spawned->spr.pos.Y -= bcos(sa, -8);
}
spawned->spr.xrepeat >>= 1;
spawned->spr.yrepeat >>= 1;
@ -779,7 +779,7 @@ static void shootwhip(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.y - sy);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
}
else
zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@ -849,7 +849,7 @@ void shoot_r(DDukeActor* actor, int atwith)
p = -1;
sa = actor->spr.ang;
sx = actor->spr.pos.X;
sy = actor->spr.y;
sy = actor->spr.pos.Y;
sz = actor->spr.z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
sz -= (7 << 8);
if (badguy(actor))
@ -2348,7 +2348,7 @@ static void underwater(int snum, ESyncBits actions, int fz, int cz)
if (j)
{
j->spr.pos.X += bcos(p->angle.ang.asbuild() + 64 - (global_random & 128) + 128, -6);
j->spr.y += bsin(p->angle.ang.asbuild() + 64 - (global_random & 128) + 128, -6);
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);
@ -3473,7 +3473,7 @@ void processinput_r(int snum)
}
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.z - clz.actor()->spr.z) < (84 << 8))
{
int j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.y - p->pos.Y);
int j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
p->posxv -= bcos(j, 4);
p->posyv -= bsin(j, 4);
}
@ -4028,7 +4028,7 @@ void OnMotorcycle(struct player_struct *p, DDukeActor* motosprite)
if (motosprite)
{
p->pos.X = motosprite->spr.pos.X;
p->pos.Y = motosprite->spr.y;
p->pos.Y = motosprite->spr.pos.Y;
p->angle.ang = buildang(motosprite->spr.ang);
p->ammo_amount[MOTORCYCLE_WEAPON] = motosprite->saved_ammo;
deletesprite(motosprite);
@ -4108,7 +4108,7 @@ void OnBoat(struct player_struct *p, DDukeActor* boat)
if (boat)
{
p->pos.X = boat->spr.pos.X;
p->pos.Y = boat->spr.y;
p->pos.Y = boat->spr.pos.Y;
p->angle.ang = buildang(boat->spr.ang);
p->ammo_amount[BOAT_WEAPON] = boat->saved_ammo;
deletesprite(boat);

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

@ -582,7 +582,7 @@ void resetpspritevars(int g)
}
po[numplayersprites].ox = act->spr.pos.X;
po[numplayersprites].oy = act->spr.y;
po[numplayersprites].oy = act->spr.pos.Y;
po[numplayersprites].oz = act->spr.z;
po[numplayersprites].oa = act->spr.ang;
po[numplayersprites].os = act->spr.sector();
@ -626,12 +626,12 @@ void resetpspritevars(int g)
act->SetOwner(act);
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.y;
ps[j].bobposy = ps[j].oposy = ps[j].pos.Y = act->spr.pos.Y;
ps[j].oposz = ps[j].pos.Z = act->spr.z;
act->spr.backuppos();
ps[j].angle.oang = ps[j].angle.ang = buildang(act->spr.ang);
updatesector(act->spr.pos.X, act->spr.y, &ps[j].cursector);
updatesector(act->spr.pos.X, act->spr.pos.Y, &ps[j].cursector);
j = connectpoint2[j];
@ -845,8 +845,8 @@ static void SpawnPortals()
sectortype* s1 = act->spr.sector(), *s2 = act2->spr.sector();
s1->portalflags = PORTAL_SECTOR_FLOOR;
s1->portalflags = PORTAL_SECTOR_CEILING;
s2->portalnum = portalAdd(PORTAL_SECTOR_FLOOR, sectnum(s2), act2->spr.pos.X - act->spr.pos.X, act2->spr.y - act->spr.y, act->spr.hitag);
s2->portalnum = portalAdd(PORTAL_SECTOR_CEILING, sectnum(s1), act->spr.pos.X - act2->spr.pos.X, act->spr.y - act2->spr.y, act->spr.hitag);
s2->portalnum = portalAdd(PORTAL_SECTOR_FLOOR, sectnum(s2), act2->spr.pos.X - act->spr.pos.X, act2->spr.pos.Y - act->spr.pos.Y, act->spr.hitag);
s2->portalnum = portalAdd(PORTAL_SECTOR_CEILING, sectnum(s1), act->spr.pos.X - act2->spr.pos.X, act->spr.pos.Y - act2->spr.pos.Y, act->spr.hitag);
processedTags.Push(act->spr.hitag);
}
else

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

@ -290,7 +290,7 @@ void prelevel_d(int g, TArray<DDukeActor*>& actors)
if (ac->spr.lotag == -1 && (ac->spr.cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
{
ps[0].exitx = ac->spr.pos.X;
ps[0].exity = ac->spr.y;
ps[0].exity = ac->spr.pos.Y;
}
else switch (ac->spr.picnum)
{

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

@ -534,7 +534,7 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
if (ac->spr.lotag == -1 && (ac->spr.cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
{
ps[0].exitx = ac->spr.pos.X;
ps[0].exity = ac->spr.y;
ps[0].exity = ac->spr.pos.Y;
}
else switch (ac->spr.picnum)
{
@ -613,14 +613,14 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
{
geosectorwarp[geocnt] = actor2->spr.sector();
geox[geocnt] = actor->spr.pos.X - actor2->spr.pos.X;
geoy[geocnt] = actor->spr.y - actor2->spr.y;
geoy[geocnt] = actor->spr.pos.Y - actor2->spr.pos.Y;
//geoz[geocnt] = actor->spr.z - actor2->spr.z;
}
if (actor2->spr.hitag == 2)
{
geosectorwarp2[geocnt] = actor2->spr.sector();
geox2[geocnt] = actor->spr.pos.X - actor2->spr.pos.X;
geoy2[geocnt] = actor->spr.y - actor2->spr.y;
geoy2[geocnt] = actor->spr.pos.Y - actor2->spr.pos.Y;
//geoz2[geocnt] = actor->spr.z - actor2->spr.z;
}
}

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

@ -115,8 +115,8 @@ 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->y, camera->z, ang.asq16(), IntToFixed(camera->shade), camera->sector(), false); // why 'shade'...?
fi.animatesprites(pm_tsprite, pm_spritesortcnt, camera->pos.X, camera->y, ang.asbuild(), (int)smoothratio);
renderDrawRoomsQ16(camera->pos.X, camera->pos.Y, camera->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();
}
else
@ -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->y, s->z - (4 << 8), cang, bh, buildang(0), (int)smoothratio);
renderView(s, s->sector(), s->pos.X, s->pos.Y, s->z - (4 << 8), cang, bh, buildang(0), (int)smoothratio);
}
else
{

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

@ -241,7 +241,7 @@ bool checkhitswitch_d(int snum, walltype* wwal, DDukeActor *act)
if (lotag == 0) return 0;
hitag = act->spr.hitag;
sx = act->spr.pos.X;
sy = act->spr.y;
sy = act->spr.pos.Y;
picnum = act->spr.picnum;
switchpal = act->spr.pal;
}
@ -1060,7 +1060,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
{
proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
proj->spr.ang -= (targ->spr.ang << 1) + 1024;
targ->spr.ang = getangle(targ->spr.pos.X - proj->spr.pos.X, targ->spr.y - proj->spr.y) - 512;
targ->spr.ang = getangle(targ->spr.pos.X - proj->spr.pos.X, targ->spr.pos.Y - proj->spr.pos.Y) - 512;
if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
S_PlayActorSound(POOLBALLHIT, targ);
}
@ -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.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.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.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.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;
@ -1155,7 +1155,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
if (gs.actorinfo[SHOTSPARK1].scriptaddress && proj->spr.extra != ScriptCode[gs.actorinfo[SHOTSPARK1].scriptaddress])
{
for (j = 0; j < 15; j++)
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.y, targ->spr.sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
spawn(targ, EXPLOSION2);
deletesprite(targ);

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

@ -360,7 +360,7 @@ bool checkhitswitch_r(int snum, walltype* wwal, DDukeActor* act)
if (lotag == 0) return 0;
hitag = act->spr.hitag;
sx = act->spr.pos.X;
sy = act->spr.y;
sy = act->spr.pos.Y;
picnum = act->spr.picnum;
switchpal = act->spr.pal;
}
@ -939,7 +939,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
for (j = n - 1; j >= 0; j--)
{
a = actor->spr.ang - 256 + (krand() & 511) + 1024;
EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.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.z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
}
return;
}
@ -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.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.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);
@ -2090,7 +2090,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
{
proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
proj->spr.ang -= (targ->spr.ang << 1) + 1024;
targ->spr.ang = getangle(targ->spr.pos.X - proj->spr.pos.X, targ->spr.y - proj->spr.y) - 512;
targ->spr.ang = getangle(targ->spr.pos.X - proj->spr.pos.X, targ->spr.pos.Y - proj->spr.pos.Y) - 512;
if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
S_PlayActorSound(POOLBALLHIT, targ);
}
@ -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.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.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;
}
@ -2197,7 +2197,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
if (gs.actorinfo[SHOTSPARK1].scriptaddress && proj->spr.extra != ScriptCode[gs.actorinfo[SHOTSPARK1].scriptaddress])
{
for (j = 0; j < 15; j++)
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.y, targ->spr.sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
EGS(targ->spr.sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
spawn(targ, EXPLOSION2);
deletesprite(targ);

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.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.z - (24 << 8), actor->spr.sector()))
sndist += sndist >> (isRR() ? 2 : 5);
// Here the sound distance was clamped to a minimum of 144*4.

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

@ -60,7 +60,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.y = s_y;
act->spr.pos.Y = s_y;
act->spr.z = s_z;
act->spr.cstat = 0;
act->spr.picnum = s_pn;
@ -219,7 +219,7 @@ DDukeActor* spawn(DDukeActor* actj, int pn)
{
if (actj)
{
auto spawned = EGS(actj->spr.sector(), actj->spr.pos.X, actj->spr.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.z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
if (spawned)
{
spawned->picnum = actj->spr.picnum;
@ -342,16 +342,16 @@ int spawnbloodpoolpart1(DDukeActor* act)
{
auto s1 = act->spr.sector();
updatesector(act->spr.pos.X + 108, act->spr.y + 108, &s1);
updatesector(act->spr.pos.X + 108, act->spr.pos.Y + 108, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
{
updatesector(act->spr.pos.X - 108, act->spr.y - 108, &s1);
updatesector(act->spr.pos.X - 108, act->spr.pos.Y - 108, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
{
updatesector(act->spr.pos.X + 108, act->spr.y - 108, &s1);
updatesector(act->spr.pos.X + 108, act->spr.pos.Y - 108, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
{
updatesector(act->spr.pos.X - 108, act->spr.y + 108, &s1);
updatesector(act->spr.pos.X - 108, act->spr.pos.Y + 108, &s1);
if (s1 && s1->floorz != act->spr.sector()->floorz)
{
act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return true;
@ -384,16 +384,16 @@ void initfootprint(DDukeActor* actj, DDukeActor* act)
{
auto s1 = act->spr.sector();
updatesector(act->spr.pos.X + 84, act->spr.y + 84, &s1);
updatesector(act->spr.pos.X + 84, act->spr.pos.Y + 84, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
{
updatesector(act->spr.pos.X - 84, act->spr.y - 84, &s1);
updatesector(act->spr.pos.X - 84, act->spr.pos.Y - 84, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
{
updatesector(act->spr.pos.X + 84, act->spr.y - 84, &s1);
updatesector(act->spr.pos.X + 84, act->spr.pos.Y - 84, &s1);
if (s1 && s1->floorz == act->spr.sector()->floorz)
{
updatesector(act->spr.pos.X - 84, act->spr.y + 84, &s1);
updatesector(act->spr.pos.X - 84, act->spr.pos.Y + 84, &s1);
if (s1 && s1->floorz != act->spr.sector()->floorz)
{
act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return;
@ -447,7 +447,7 @@ void initshell(DDukeActor* actj, DDukeActor* act, bool isshell)
}
act->spr.pos.X = actj->spr.pos.X + bcos(a, -7);
act->spr.y = actj->spr.y + bsin(a, -7);
act->spr.pos.Y = actj->spr.pos.Y + bsin(a, -7);
act->spr.shade = -8;
@ -487,7 +487,7 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
auto& apt = cranes[t[4]];
apt.x = act->spr.pos.X;
apt.y = act->spr.y;
apt.y = act->spr.pos.Y;
apt.z = act->spr.z;
apt.poleactor = nullptr;
@ -504,10 +504,10 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
act->spr.yrepeat = 128;
apt.polex = act->spr.pos.X;
apt.poley = act->spr.y;
apt.poley = act->spr.pos.Y;
act->spr.pos.X = act->spr.pos.X;
act->spr.y = act->spr.y;
act->spr.pos.Y = act->spr.pos.Y;
act->spr.z = act->spr.z;
act->spr.shade = act->spr.shade;
@ -539,7 +539,7 @@ void initwaterdrip(DDukeActor* actj, DDukeActor* actor)
actor->spr.z -= (18 << 8);
}
else actor->spr.z -= (13 << 8);
actor->spr.ang = getangle(ps[connecthead].pos.X - actor->spr.pos.X, ps[connecthead].pos.Y - actor->spr.y);
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);
}
@ -788,7 +788,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
for (auto& wal : wallsofsector(sectp))
{
d = FindDistance2D(actor->spr.pos.X - wal.pos.X, actor->spr.y - wal.pos.Y);
d = FindDistance2D(actor->spr.pos.X - wal.pos.X, actor->spr.pos.Y - wal.pos.Y);
if (d < q)
{
q = d;
@ -802,7 +802,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
for (auto& wal : wallsofsector(sectp))
{
d = FindDistance2D(actor->spr.pos.X - wal.pos.X, actor->spr.y - wal.pos.Y);
d = FindDistance2D(actor->spr.pos.X - wal.pos.X, actor->spr.pos.Y - wal.pos.Y);
if (d < q && &wal != actor->temp_walls[0])
{
q = d;
@ -941,7 +941,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
if (actor->spr.ang == 512)
{
actor->spr.pos.X = act2->spr.pos.X;
actor->spr.y = act2->spr.y;
actor->spr.pos.Y = act2->spr.pos.Y;
}
found = true;
actor->SetOwner(act2);
@ -954,7 +954,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
actor->spr.cstat2 = CSTAT2_SPRITE_NOFIND;
actor->spr.cstat = CSTAT_SPRITE_INVISIBLE;
ChangeActorStat(actor, STAT_REMOVED);
Printf("Found lonely Sector Effector (lotag 0) at (%d,%d)\n", actor->spr.pos.X, actor->spr.y);
Printf("Found lonely Sector Effector (lotag 0) at (%d,%d)\n", actor->spr.pos.X, actor->spr.pos.Y);
return;
}
}
@ -963,7 +963,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
for (auto& wal : wallsofsector(sectp))
{
msx[tempwallptr] = wal.pos.X - actor->spr.pos.X;
msy[tempwallptr] = wal.pos.Y - actor->spr.y;
msy[tempwallptr] = wal.pos.Y - actor->spr.pos.Y;
tempwallptr++;
if (tempwallptr > 2047)
{
@ -993,7 +993,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
if (s == nullptr)
{
I_Error("Subway found no zero'd sectors with locators\nat (%d,%d).\n", actor->spr.pos.X, actor->spr.y);
I_Error("Subway found no zero'd sectors with locators\nat (%d,%d).\n", actor->spr.pos.X, actor->spr.pos.Y);
}
actor->SetOwner(nullptr);
@ -1009,7 +1009,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
else if (actor->spr.lotag == SE_26)
{
t[3] = actor->spr.pos.X;
t[4] = actor->spr.y;
t[4] = actor->spr.pos.Y;
if (actor->spr.shade == sectp->floorshade) //UP
actor->spr.zvel = -256;
else
@ -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.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.z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
}
return;
}
@ -1124,7 +1124,7 @@ void spriteglass(DDukeActor* actor, int n)
{
int a = krand() & 2047;
int z = actor->spr.z - ((krand() & 16) << 8);
auto k = EGS(actor->spr.sector(), actor->spr.pos.X, actor->spr.y, z, TILE_GLASSPIECES + (j % 3), krand() & 15, 36, 36, a, 32 + (krand() & 63), -512 - (krand() & 2047), actor, 5);
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.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.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;

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

@ -119,14 +119,14 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->SetOwner(actj);
ChangeActorStat(act, STAT_MISC);
act->spr.pos.X += krand() % 512 - 256;
act->spr.y += krand() % 512 - 256;
act->spr.pos.Y += krand() % 512 - 256;
act->spr.xrepeat = 16;
act->spr.yrepeat = 16;
return act;
case WHISPYSMOKE:
ChangeActorStat(act, STAT_MISC);
act->spr.pos.X += krand() % 256 - 128;
act->spr.y += krand() % 256 - 128;
act->spr.pos.Y += krand() % 256 - 128;
act->spr.xrepeat = 20;
act->spr.yrepeat = 20;
return act;
@ -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.y) + (16 << 8);
act->spr.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.y);
act->spr.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -298,7 +298,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat |= CSTAT_SPRITE_ALIGNMENT_FLOOR;
if (act->spr.picnum == LAVAPOOL) // Twentieth Anniversary World Tour
{
int fz = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.y);
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;
@ -549,7 +549,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case SPOTLITE:
t[0] = act->spr.pos.X;
t[1] = act->spr.y;
t[1] = act->spr.pos.Y;
break;
case BULLETHOLE:
act->spr.xrepeat = act->spr.yrepeat = 3;
@ -642,7 +642,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
int x = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.y);
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);
}
@ -650,7 +650,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (act->spr.picnum == ONFIRE)
{
act->spr.pos.X += krand() % 256 - 128;
act->spr.y += krand() % 256 - 128;
act->spr.pos.Y += krand() % 256 - 128;
act->spr.z -= krand() % 10240;
act->spr.cstat |= CSTAT_SPRITE_YCENTER;
}
@ -750,7 +750,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case WATERBUBBLEMAKER:
if (act->spr.hitag && act->spr.picnum == WATERBUBBLEMAKER)
{ // JBF 20030913: Pisses off move(), eg. in bobsp2
Printf(TEXTCOLOR_YELLOW "WARNING: WATERBUBBLEMAKER %d @ %d,%d with hitag!=0. Applying fixup.\n", act->GetIndex(), act->spr.pos.X, act->spr.y);
Printf(TEXTCOLOR_YELLOW "WARNING: WATERBUBBLEMAKER %d @ %d,%d with hitag!=0. Applying fixup.\n", act->GetIndex(), act->spr.pos.X, act->spr.pos.Y);
act->spr.hitag = 0;
}
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;

10
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.y) + (16 << 8);
act->spr.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.y);
act->spr.z = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.pos.Y);
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -571,7 +571,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case SPOTLITE:
t[0] = act->spr.pos.X;
t[1] = act->spr.y;
t[1] = act->spr.pos.Y;
break;
case BULLETHOLE:
act->spr.xrepeat = act->spr.yrepeat = 3;
@ -650,7 +650,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
int x = getflorzofslopeptr(act->spr.sector(), act->spr.pos.X, act->spr.y);
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);
}
@ -907,7 +907,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
act->spr.cstat = CSTAT_SPRITE_TRANSLUCENT;
act->spr.cstat |= CSTAT_SPRITE_TRANS_FLIP;
act->spr.pos.X += (krand() & 2047) - 1024;
act->spr.y += (krand() & 2047) - 1024;
act->spr.pos.Y += (krand() & 2047) - 1024;
act->spr.z += (krand() & 2047) - 1024;
break;
case MAMA:

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

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

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

@ -57,13 +57,13 @@ void BuildAnubis(DExhumedActor* ap, int x, int y, int z, sectortype* pSector, in
sp = &ap->s();
x = sp->pos.X;
y = sp->y;
y = sp->pos.Y;
z = sp->sector()->floorz;
nAngle = sp->ang;
}
sp->pos.X = x;
sp->y = y;
sp->pos.Y = y;
sp->z = z;
sp->cstat = CSTAT_SPRITE_BLOCK_ALL;
sp->xoffset = 0;
@ -188,7 +188,7 @@ void AIAnubis::Tick(RunListEvent* ev)
{
if (move.actor() == pTarget)
{
int nAng = getangle(pTarget->spr.pos.X - sp->pos.X, pTarget->spr.y - sp->y);
int nAng = getangle(pTarget->spr.pos.X - sp->pos.X, pTarget->spr.pos.Y - sp->pos.Y);
int nAngDiff = AngleDiff(sp->ang, nAng);
if (nAngDiff < 64)
@ -221,12 +221,12 @@ 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->y, sp->z - GetActorHeight(ap), sp->sector(),
pTarget->spr.pos.X, pTarget->spr.y, pTarget->spr.z - GetActorHeight(pTarget), pTarget->spr.sector()))
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()))
{
sp->xvel = 0;
sp->yvel = 0;
sp->ang = GetMyAngle(pTarget->spr.pos.X - sp->pos.X, pTarget->spr.y - sp->y);
sp->ang = GetMyAngle(pTarget->spr.pos.X - sp->pos.X, pTarget->spr.pos.Y - sp->pos.Y);
ap->nAction = 3;
ap->nFrame = 0;
@ -406,7 +406,7 @@ void AIAnubis::Damage(RunListEvent* ev)
auto pDrumSprite = &pDrumActor->s();
pDrumSprite->pos.X = sp->pos.X;
pDrumSprite->y = sp->y;
pDrumSprite->pos.Y = sp->pos.Y;
pDrumSprite->z = pDrumSprite->sector()->floorz;
pDrumSprite->xrepeat = 40;
pDrumSprite->yrepeat = 40;

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

@ -100,7 +100,7 @@ void AIBubble::Tick(RunListEvent* ev)
auto pSectAbove = pSector->pAbove;
if (pSprite->hitag > -1 && pSectAbove != nullptr) {
BuildAnim(nullptr, 70, 0, pSprite->pos.X, pSprite->y, pSectAbove->floorz, pSectAbove, 64, 0);
BuildAnim(nullptr, 70, 0, pSprite->pos.X, pSprite->pos.Y, pSectAbove->floorz, pSectAbove, 64, 0);
}
DestroyBubble(pActor);

28
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->y, pSprite->z, pSprite->sector(), 40, 20);
auto pAnimActor = BuildAnim(nullptr, 38, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 40, 20);
if (pAnimActor)
{
@ -322,7 +322,7 @@ int MoveBullet(int nBullet)
spritetype *pSprite = &pActor->s();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z; // ebx
int nSectFlag = pSprite->sector()->Flag;
@ -381,7 +381,7 @@ MOVEEND:
{
nVal = 1;
x2 = pSprite->pos.X;
y2 = pSprite->y;
y2 = pSprite->pos.Y;
z2 = pSprite->z;
pHitSect = pSprite->sector();
@ -432,7 +432,7 @@ MOVEEND:
if (nVal == 0 && nType != 15 && nType != 3)
{
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 0);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 0);
if (pSprite->pal != 5) {
pSprite->pal = 1;
@ -448,7 +448,7 @@ MOVEEND:
hitactor = BulletList[nBullet].pEnemy;
auto hitsprite = &hitactor->s();
x2 = hitsprite->pos.X;
y2 = hitsprite->y;
y2 = hitsprite->pos.Y;
z2 = hitsprite->z - (GetActorHeight(hitactor) >> 1);
pHitSect = hitsprite->sector();
}
@ -518,7 +518,7 @@ HITSPRITE:
if ((pHitSect->pBelow != nullptr && (pHitSect->pBelow->Flag & kSectUnderwater)) || pHitSect->Depth)
{
pSprite->pos.X = x2;
pSprite->y = y2;
pSprite->pos.Y = y2;
pSprite->z = z2;
BuildSplash(pActor, pHitSect);
}
@ -548,7 +548,7 @@ HITSPRITE:
else
{
pSprite->pos.X = x2;
pSprite->y = y2;
pSprite->pos.Y = y2;
pSprite->z = z2;
ChangeActorSect(pActor, pHitSect);
@ -562,7 +562,7 @@ HITSPRITE:
nRadialBullet = -1;
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 128);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, pTargetSprite->z - (nHeight >> 1), pTargetSprite->sector());
BulletHitsSprite(&sBullet, pActor, pTarget, pTargetSprite->pos.X, pTargetSprite->pos.Y, pTargetSprite->z - (nHeight >> 1), pTargetSprite->sector());
DeleteActor(sBullet.pActor);
return nullptr;
}
@ -642,7 +642,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
}
pBulletSprite->pos.X = pSprite->pos.X;
pBulletSprite->y = pSprite->y;
pBulletSprite->pos.Y = pSprite->pos.Y;
pBulletSprite->z = pSprite->z;
Bullet *pBullet = &BulletList[nBullet];
@ -764,7 +764,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
if (pActor != nullptr && pSprite->statnum != 100)
{
x = pTargetSprite->pos.X;
y = pTargetSprite->y;
y = pTargetSprite->pos.Y;
if (pTargetSprite->statnum != 100)
{
@ -782,7 +782,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
}
x -= pBulletSprite->pos.X;
y -= pBulletSprite->y;
y -= pBulletSprite->pos.Y;
nAngle = GetMyAngle(x, y);
pSprite->ang = nAngle;
@ -791,7 +791,7 @@ DExhumedActor* BuildBullet(DExhumedActor* pActor, int nType, int nZOffset, int n
{
// loc_2ABA3:
x = pTargetSprite->pos.X - pBulletSprite->pos.X;
y = pTargetSprite->y - pBulletSprite->y;
y = pTargetSprite->pos.Y - pBulletSprite->pos.Y;
}
int nSqrt = lsqrt(y*y + x*x);
@ -842,7 +842,7 @@ void AIBullet::Tick(RunListEvent* ev)
if (nFlag & 0x80)
{
BuildAnim(nullptr, 45, 0, pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector(), pSprite->xrepeat, 0);
BuildAnim(nullptr, 45, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->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->y, spri->z);
AddFlash(spri->sector(), spri->pos.X, spri->y, spri->z, 192);
PlayFXAtXYZ(StaticSound[kSoundAlarm], spri->pos.X, spri->pos.Y, spri->z);
AddFlash(spri->sector(), spri->pos.X, spri->pos.Y, spri->z, 192);
}
}
}

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

@ -51,7 +51,7 @@ void BuildFishLimb(DExhumedActor* pActor, int anim)
pChunkActor->nFrame = RandomSize(3) % SeqSize[SeqOffsets[kSeqFish] + anim + 40];
pSprite2->pos.X = pSprite->pos.X;
pSprite2->y = pSprite->y;
pSprite2->pos.Y = pSprite->pos.Y;
pSprite2->z = pSprite->z;
pSprite2->cstat = 0;
pSprite2->shade = -12;
@ -101,7 +101,7 @@ void AIFishLimb::Tick(RunListEvent* ev)
{
pActor->nFrame = 0;
if (RandomBit()) {
BuildBlood(pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector());
BuildBlood(pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector());
}
}
@ -158,14 +158,14 @@ void BuildFish(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
{
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->z;
nAngle = pSprite->ang;
ChangeActorStat(pActor, 103);
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
@ -293,7 +293,7 @@ void AIFish::Damage(RunListEvent* ev)
BuildFishLimb(pActor, i);
}
PlayFXAtXYZ(StaticSound[kSound40], pSprite->pos.X, pSprite->y, pSprite->z);
PlayFXAtXYZ(StaticSound[kSound40], pSprite->pos.X, pSprite->pos.Y, pSprite->z);
DestroyFish(pActor);
}
else
@ -435,7 +435,7 @@ void AIFish::Tick(RunListEvent* ev)
}
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
auto pSector =pSprite->sector();
@ -446,7 +446,7 @@ void AIFish::Tick(RunListEvent* ev)
{
ChangeActorSect(pActor, pSector);
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
IdleFish(pActor, 0);
@ -481,7 +481,7 @@ void AIFish::Tick(RunListEvent* ev)
if (pHitSpr->statnum == 100)
{
pActor->pTarget = coll.actor();
pSprite->ang = GetMyAngle(pHitSpr->pos.X - pSprite->pos.X, pHitSpr->y - pSprite->y);
pSprite->ang = GetMyAngle(pHitSpr->pos.X - pSprite->pos.X, pHitSpr->pos.Y - pSprite->pos.Y);
if (nAction != 3)
{

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

@ -62,7 +62,7 @@ void ThrowGrenade(int nPlayer, int, int, int ecx, int push1)
ChangeActorSect(pActor, PlayerList[nPlayer].pPlayerViewSect);
pGrenadeSprite->pos.X = pPlayerSprite->pos.X;
pGrenadeSprite->y = pPlayerSprite->y;
pGrenadeSprite->pos.Y = pPlayerSprite->pos.Y;
pGrenadeSprite->z = pPlayerSprite->z;
if (nAngle < 0) {
@ -108,7 +108,7 @@ void BuildGrenade(int nPlayer)
auto pPlayerSprite = &PlayerList[nPlayer].Actor()->s();
pSprite->pos.X = pPlayerSprite->pos.X;
pSprite->y = pPlayerSprite->y;
pSprite->pos.Y = pPlayerSprite->pos.Y;
pSprite->z = pPlayerSprite->z - 3840;
pSprite->shade = -64;
pSprite->xrepeat = 20;
@ -184,7 +184,7 @@ void ExplodeGrenade(DExhumedActor* pActor)
pGrenadeSprite->z = pPlayerSprite->z;
pGrenadeSprite->pos.X = bcos(nAngle, -5) + pPlayerSprite->pos.X;
pGrenadeSprite->y = bsin(nAngle, -5) + pPlayerSprite->y;
pGrenadeSprite->pos.Y = bsin(nAngle, -5) + pPlayerSprite->pos.Y;
ChangeActorSect(pActor, pPlayerSprite->sector());
@ -201,8 +201,8 @@ void ExplodeGrenade(DExhumedActor* pActor)
runlist_RadialDamageEnemy(pActor, nDamage, BulletInfo[kWeaponGrenade].nRadius);
BuildAnim(nullptr, var_28, 0, pGrenadeSprite->pos.X, pGrenadeSprite->y, pGrenadeSprite->z, pGrenadeSprite->sector(), var_20, 4);
AddFlash(pGrenadeSprite->sector(), pGrenadeSprite->pos.X, pGrenadeSprite->y, pGrenadeSprite->z, 128);
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);
DestroyGrenade(pActor);
}

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

@ -616,7 +616,7 @@ loc_flag:
AddFlash(
pPlayerSprite->sector(),
pPlayerSprite->pos.X,
pPlayerSprite->y,
pPlayerSprite->pos.Y,
pPlayerSprite->z,
0);
}
@ -650,7 +650,7 @@ loc_flag:
int nAmmoType = WeaponInfo[nWeapon].nAmmoType;
int nAngle = pPlayerSprite->ang;
int theX = pPlayerSprite->pos.X;
int theY = pPlayerSprite->y;
int theY = pPlayerSprite->pos.Y;
int theZ = pPlayerSprite->z;
int ebp = bcos(nAngle) * (pPlayerSprite->clipdist << 3);
@ -811,7 +811,7 @@ loc_flag:
// only autoaim if target is in front of the player.
auto pTargetSprite = &t->s();
assert(pTargetSprite->sector());
int angletotarget = bvectangbam(pTargetSprite->pos.X - pPlayerSprite->pos.X, pTargetSprite->y - pPlayerSprite->y).asbuild();
int angletotarget = bvectangbam(pTargetSprite->pos.X - pPlayerSprite->pos.X, pTargetSprite->pos.Y - pPlayerSprite->pos.Y).asbuild();
int anglediff = (pPlayerSprite->ang - angletotarget) & 2047;
if (anglediff < 512 || anglediff > 1536)
{

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

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

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->y, pSprite->z, pSprite->sector(), nItemAnimInfo[nItem].repeat, 20);
auto pAnimActor = BuildAnim(pActor, 41, nItemAnimInfo[nItem].a, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), nItemAnimInfo[nItem].repeat, 20);
if (nItem == 44) {
pAnimActor->spr.cstat |= CSTAT_SPRITE_TRANSLUCENT;
@ -344,7 +344,7 @@ void DropMagic(DExhumedActor* pActor)
64,
0,
pSprite->pos.X,
pSprite->y,
pSprite->pos.Y,
pSprite->z,
pSprite->sector(),
48,
@ -352,7 +352,7 @@ void DropMagic(DExhumedActor* pActor)
if (pAnimActor)
{
AddFlash(pAnimActor->spr.sector(), pAnimActor->spr.pos.X, pAnimActor->spr.y, pAnimActor->spr.z, 128);
AddFlash(pAnimActor->spr.sector(), pAnimActor->spr.pos.X, pAnimActor->spr.pos.Y, pAnimActor->spr.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->y, pSprite->z, pSprite->sector(), 64, 4);
BuildAnim(nullptr, 38, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), 64, 4);
D3PlayFX(StaticSound[kSoundTorchOn], pActor);
}
else {

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

@ -45,7 +45,7 @@ DExhumedActor* BuildLavaLimb(DExhumedActor* pActor, int move, int ebx)
auto pLimbSprite = &pLimbActor->s();
pLimbSprite->pos.X = pSprite->pos.X;
pLimbSprite->y = pSprite->y;
pLimbSprite->pos.Y = pSprite->pos.Y;
pLimbSprite->z = pSprite->z - RandomLong() % ebx;
pLimbSprite->cstat = 0;
pLimbSprite->shade = -127;
@ -117,13 +117,13 @@ void BuildLava(DExhumedActor* pActor, int x, int y, int, sectortype* pSector, in
pSector = pSprite->sector();
nAngle = pSprite->ang;
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
ChangeActorStat(pActor, 118);
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = pSector->floorz;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite->xrepeat = 200;
@ -293,7 +293,7 @@ void AILavaDude::Tick(RunListEvent* ev)
}
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
auto pSector =pSprite->sector();
@ -303,7 +303,7 @@ void AILavaDude::Tick(RunListEvent* ev)
{
ChangeActorSect(pActor, pSector);
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->ang = (pSprite->ang + ((RandomWord() & 0x3FF) + 1024)) & kAngleMask;
@ -327,7 +327,7 @@ void AILavaDude::Tick(RunListEvent* ev)
{
if (coll.actor() == pTarget)
{
int nAng = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
int nAng = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
if (AngleDiff(pSprite->ang, nAng) < 64)
{
pActor->nAction = 2;

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

@ -386,7 +386,7 @@ void AddFlash(sectortype* pSector, int x, int y, int z, int val)
xDiff = -xDiff;
}
int yDiff = y - pSprite->y;
int yDiff = y - pSprite->pos.Y;
if (yDiff < 0) {
yDiff = -yDiff;
}

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

@ -54,13 +54,13 @@ void BuildLion(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
ChangeActorStat(pActor, 104);
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->sector()->floorz;
nAngle = pSprite->ang;
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->clipdist = 60;
@ -318,7 +318,7 @@ void AILion::Tick(RunListEvent* ev)
}
else
{
int nAng = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
int nAng = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
if (AngleDiff(pSprite->ang, nAng) < 64)
{
@ -390,7 +390,7 @@ void AILion::Tick(RunListEvent* ev)
pActor->nCount = 0;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z - (GetActorHeight(pActor) >> 1);
int nCheckDist = 0x7FFFFFFF;
@ -451,7 +451,7 @@ void AILion::Tick(RunListEvent* ev)
{
if (nMov.actor() == pTarget)
{
int nAng = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
int nAng = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
if (AngleDiff(pSprite->ang, nAng) < 64)
{
pActor->nAction = 3;

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

@ -472,7 +472,7 @@ Collision movespritez(DExhumedActor* pActor, int z, int height, int, int clipdis
if (pSprite->statnum == 100)
{
nRet.exbits |= BelowNear(pActor, pSprite->pos.X, pSprite->y, clipdist + (clipdist / 2));
nRet.exbits |= BelowNear(pActor, pSprite->pos.X, pSprite->pos.Y, clipdist + (clipdist / 2));
}
return nRet;
@ -495,7 +495,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
bTouchFloor = false;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
int nSpriteHeight = GetActorHeight(pActor);
@ -557,7 +557,7 @@ Collision movesprite(DExhumedActor* pActor, int dx, int dy, int dz, int ceildist
if ((pSector->floorz - z) < (dz + flordist))
{
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
}
else
{
@ -629,7 +629,7 @@ Collision MoveCreatureWithCaution(DExhumedActor* pActor)
{
auto pSprite = &pActor->s();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
auto pSectorPre = pSprite->sector();
@ -647,7 +647,7 @@ Collision MoveCreatureWithCaution(DExhumedActor* pActor)
if (zDiff > 15360 || (pSector->Flag & kSectUnderwater) || (pSector->pBelow != nullptr && pSector->pBelow->Flag) || pSector->Damage)
{
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
ChangeActorSect(pActor, pSectorPre);
@ -672,7 +672,7 @@ int GetAngleToSprite(DExhumedActor* a1, DExhumedActor* a2)
auto pSprite1 = &a1->s();
auto pSprite2 = &a2->s();
return GetMyAngle(pSprite2->pos.X - pSprite1->pos.X, pSprite2->y - pSprite1->y);
return GetMyAngle(pSprite2->pos.X - pSprite1->pos.X, pSprite2->pos.Y - pSprite1->pos.Y);
}
int PlotCourseToSprite(DExhumedActor* pActor1, DExhumedActor* pActor2)
@ -683,7 +683,7 @@ int PlotCourseToSprite(DExhumedActor* pActor1, DExhumedActor* pActor2)
auto pSprite1 = &pActor1->s();
auto pSprite2 = &pActor2->s();
int x = pSprite2->pos.X - pSprite1->pos.X;
int y = pSprite2->y - pSprite1->y;
int y = pSprite2->pos.Y - pSprite1->pos.Y;
pSprite1->ang = GetMyAngle(x, y);
@ -710,7 +710,7 @@ DExhumedActor* FindPlayer(DExhumedActor* pActor, int nDistance, bool dontengage)
nDistance = 100;
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
auto pSector =pSprite->sector();
int z = pSprite->z - GetActorHeight(pActor);
@ -734,9 +734,9 @@ DExhumedActor* FindPlayer(DExhumedActor* pActor, int nDistance, bool dontengage)
if (v9 < nDistance)
{
int v10 = abs(pPlayerSprite->y - y);
int v10 = abs(pPlayerSprite->pos.Y - y);
if (v10 < nDistance && cansee(pPlayerSprite->pos.X, pPlayerSprite->y, pPlayerSprite->z - 7680, pPlayerSprite->sector(), x, y, z, pSector))
if (v10 < nDistance && cansee(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z - 7680, pPlayerSprite->sector(), x, y, z, pSector))
{
break;
}
@ -781,7 +781,7 @@ int GetUpAngle(DExhumedActor* pActor1, int nVal, DExhumedActor* pActor2, int ecx
auto pSprite1 = &pActor1->s();
auto pSprite2 = &pActor2->s();
int x = pSprite2->pos.X - pSprite1->pos.X;
int y = pSprite2->y - pSprite1->y;
int y = pSprite2->pos.Y - pSprite1->pos.Y;
int ebx = (pSprite2->z + ecx) - (pSprite1->z + nVal);
int edx = (pSprite2->z + ecx) - (pSprite1->z + nVal);
@ -838,7 +838,7 @@ void CreatePushBlock(sectortype* pSector)
sBlockInfo[nBlock].pActor = pActor;
pSprite->pos.X = xAvg;
pSprite->y = yAvg;
pSprite->pos.Y = yAvg;
pSprite->z = pSector->floorz - 256;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
@ -1000,7 +1000,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
if (sp->statnum < 99)
{
sp->pos.X += xvect;
sp->y += yvect;
sp->pos.Y += yvect;
}
else
{
@ -1009,7 +1009,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
if ((nSectFlag & kSectUnderwater) || pos.Z != nZVal || sp->cstat & CSTAT_SPRITE_INVISIBLE)
{
pos.X = sp->pos.X;
pos.Y = sp->y;
pos.Y = sp->pos.Y;
pSectorB = pSector;
Collision scratch;
@ -1103,7 +1103,7 @@ void MoveSector(sectortype* pSector, int nAngle, int *nXVel, int *nYVel)
auto pActor = PlayerList[nLocalPlayer].Actor();
auto pSprite = &pActor->s();
initx = pSprite->pos.X;
inity = pSprite->y;
inity = pSprite->pos.Y;
initz = pSprite->z;
inita = pSprite->ang;
initsectp = pSprite->sector();
@ -1113,7 +1113,7 @@ void SetQuake(DExhumedActor* pActor, int nVal)
{
auto pSprite = &pActor->s();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
nVal *= 256;
@ -1123,7 +1123,7 @@ void SetQuake(DExhumedActor* pActor, int nVal)
uint32_t xDiff = abs((int32_t)((pPlayerActor->spr.pos.X - x) >> 8));
uint32_t yDiff = abs((int32_t)((pPlayerActor->spr.y - y) >> 8));
uint32_t yDiff = abs((int32_t)((pPlayerActor->spr.pos.Y - y) >> 8));
uint32_t sqrtNum = xDiff * xDiff + yDiff * yDiff;
@ -1185,10 +1185,10 @@ Collision AngleChase(DExhumedActor* pActor, DExhumedActor* pActor2, int ebx, int
int nHeight = tileHeight(pSprite2->picnum) * pSprite2->yrepeat * 2;
int nMyAngle = GetMyAngle(pSprite2->pos.X - pSprite->pos.X, pSprite2->y - pSprite->y);
int nMyAngle = GetMyAngle(pSprite2->pos.X - pSprite->pos.X, pSprite2->pos.Y - pSprite->pos.Y);
uint32_t xDiff = abs(pSprite2->pos.X - pSprite->pos.X);
uint32_t yDiff = abs(pSprite2->y - pSprite->y);
uint32_t yDiff = abs(pSprite2->pos.Y - pSprite->pos.Y);
uint32_t sqrtNum = xDiff * xDiff + yDiff * yDiff;
@ -1398,7 +1398,7 @@ DExhumedActor* BuildCreatureChunk(DExhumedActor* pSrc, int nPic, bool bSpecial)
auto pSrcSpr = &pSrc->s();
pSprite->pos.X = pSrcSpr->pos.X;
pSprite->y = pSrcSpr->y;
pSprite->pos.Y = pSrcSpr->pos.Y;
pSprite->z = pSrcSpr->z;
ChangeActorSect(actor, pSrcSpr->sector());

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

@ -49,7 +49,7 @@ void BuildMummy(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
{
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->z;
nAngle = pSprite->ang;
@ -57,7 +57,7 @@ void BuildMummy(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
@ -107,12 +107,12 @@ void CheckMummyRevive(DExhumedActor* pActor)
auto pSprite2 = &pOther->s();
int x = abs(pSprite2->pos.X - pSprite->pos.X) >> 8;
int y = abs(pSprite2->y - pSprite->y) >> 8;
int y = abs(pSprite2->pos.Y - pSprite->pos.Y) >> 8;
if (x <= 20 && y <= 20)
{
if (cansee(pSprite->pos.X, pSprite->y, pSprite->z - 8192, pSprite->sector(),
pSprite2->pos.X, pSprite2->y, pSprite2->z - 8192, pSprite2->sector()))
if (cansee(pSprite->pos.X, pSprite->pos.Y, pSprite->z - 8192, pSprite->sector(),
pSprite2->pos.X, pSprite2->pos.Y, pSprite2->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->y, pSprite->z - GetActorHeight(pActor), pSprite->sector(),
pTarget->spr.pos.X, pTarget->spr.y, pTarget->spr.z - GetActorHeight(pTarget), pTarget->spr.sector()))
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()))
{
pActor->nAction = 3;
pActor->nFrame = 0;
@ -284,7 +284,7 @@ void AIMummy::Tick(RunListEvent* ev)
{
if (nMov.actor() == pTarget)
{
int nAngle = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
int nAngle = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
if (AngleDiff(pSprite->ang, nAngle) < 64)
{
pActor->nAction = 2;

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

@ -445,7 +445,7 @@ DExhumedActor* FindWallSprites(sectortype* pSector)
if ((spr->cstat & (CSTAT_SPRITE_ALIGNMENT_WALL | CSTAT_SPRITE_ONE_SIDE)) == (CSTAT_SPRITE_ALIGNMENT_WALL | CSTAT_SPRITE_ONE_SIDE))
{
int var_28 = spr->pos.X;
int ebx = spr->y;
int ebx = spr->pos.Y;
if ((var_28 >= var_24) && (esi >= var_28) && (ebx >= ecx) && (ebx <= edi))
{
@ -462,7 +462,7 @@ DExhumedActor* FindWallSprites(sectortype* pSector)
auto pSprite = &pAct->s();
pSprite->pos.X = (var_24 + esi) / 2;
pSprite->y = (ecx + edi) / 2;
pSprite->pos.Y = (ecx + edi) / 2;
pSprite->z = pSector->floorz;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite->owner = -1;
@ -614,7 +614,7 @@ int CheckSectorSprites(sectortype* pSector, int nVal)
{
PlayFXAtXYZ(StaticSound[kSoundJonFDie],
pSprite->pos.X,
pSprite->y,
pSprite->pos.Y,
pSprite->z,
CHANF_NONE, 0x4000);
}
@ -843,7 +843,7 @@ void AIElev::Tick(RunListEvent* ev)
}
auto sp = &pElevSpr->s();
PlayFXAtXYZ(StaticSound[kSound26], sp->pos.X, sp->y, sp->z);
PlayFXAtXYZ(StaticSound[kSound26], sp->pos.X, sp->pos.Y, sp->z);
}
if (var_18 & 0x4)
@ -1029,7 +1029,7 @@ int BuildSlide(int nChannel, walltype* pStartWall, walltype* pWall1, walltype* p
SlideData[nSlide].pActor = pActor;
pSprite->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite->pos.X = pStartWall->pos.X;
pSprite->y = pStartWall->pos.Y;
pSprite->pos.Y = pStartWall->pos.Y;
pSprite->z = pSector->floorz;
pSprite->backuppos();
@ -1371,7 +1371,7 @@ DExhumedActor* BuildSpark(DExhumedActor* pActor, int nVal)
auto spr = &pSpark->s();
spr->pos.X = pSprite->pos.X;
spr->y = pSprite->y;
spr->pos.Y = pSprite->pos.Y;
spr->cstat = 0;
spr->shade = -127;
spr->pal = 1;
@ -1593,7 +1593,7 @@ DExhumedActor* BuildEnergyBlock(sectortype* pSector)
auto spr = &pActor->s();
spr->pos.X = xAvg;
spr->y = yAvg;
spr->pos.Y = yAvg;
pSector->extra = (int16_t)EnergyBlocks.Push(pActor);
@ -1764,7 +1764,7 @@ void AIEnergyBlock::Damage(RunListEvent* ev)
pSprite2->ang = ev->nParam;
pSprite2->pos.X = lasthitx;
pSprite2->y = lasthity;
pSprite2->pos.Y = lasthity;
pSprite2->z = lasthitz;
BuildSpark(pActor2, 0); // shoot out blue orb when damaged
@ -1854,7 +1854,7 @@ DExhumedActor* BuildObject(DExhumedActor* pActor, int nOjectType, int nHitag)
pSprite2->cstat = CSTAT_SPRITE_INVISIBLE;
pSprite2->pos.X = spr->pos.X;
pSprite2->y = spr->y;
pSprite2->pos.Y = spr->pos.Y;
pSprite2->z = spr->z;
}
else
@ -1961,8 +1961,8 @@ void AIObject::Tick(RunListEvent* ev)
var_18 = 34;
}
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->y, pSprite->z, 128);
BuildAnim(nullptr, var_18, 0, pSprite->pos.X, pSprite->y, pSprite->sector()->floorz, pSprite->sector(), 240, 4);
AddFlash(pSprite->sector(), pSprite->pos.X, pSprite->pos.Y, pSprite->z, 128);
BuildAnim(nullptr, var_18, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->sector()->floorz, pSprite->sector(), 240, 4);
// int edi = nSprite | 0x4000;
@ -1996,7 +1996,7 @@ void AIObject::Tick(RunListEvent* ev)
auto pTargSpr = &pActor->pTarget->s();
pSprite->pos.X = pTargSpr->pos.X;
pSprite->y = pTargSpr->y;
pSprite->pos.Y = pTargSpr->pos.Y;
pSprite->z = pTargSpr->z;
ChangeActorSect(pActor, pTargSpr->sector());
@ -2254,7 +2254,7 @@ void ProcessTrailSprite(DExhumedActor* pActor, int nLotag, int nHitag)
auto nPoint = sTrailPoint.Reserve(1);
sTrailPoint[nPoint].x = pSprite->pos.X;
sTrailPoint[nPoint].y = pSprite->y;
sTrailPoint[nPoint].y = pSprite->pos.Y;
int nTrail = FindTrail(nHitag);

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

@ -39,7 +39,7 @@ void GameInterface::WarpToCoords(int x, int y, int z, int ang, int horz)
spritetype *pSprite = &nPlayer->Actor()->s();
pSprite->ox = pSprite->pos.X = x;
pSprite->oy = pSprite->y = y;
pSprite->oy = pSprite->pos.Y = y;
pSprite->oz = pSprite->z = z;
if (ang != INT_MIN)

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

@ -134,7 +134,7 @@ void feebtag(int x, int y, int z, sectortype* pSector, DExhumedActor **nSprite,
if (nStat >= 900 && !(pSprite->cstat & CSTAT_SPRITE_INVISIBLE))
{
uint32_t xDiff = abs(pSprite->pos.X - x);
uint32_t yDiff = abs(pSprite->y - y);
uint32_t yDiff = abs(pSprite->pos.Y - y);
int zDiff = pSprite->z - z;
if (zDiff < 5120 && zDiff > -25600)
@ -268,7 +268,7 @@ void RestartPlayer(int nPlayer)
}
nSpr->pos.X = nstspr->pos.X;
nSpr->y = nstspr->y;
nSpr->pos.Y = nstspr->pos.Y;
nSpr->z = nstspr->z;
ChangeActorSect(pActor, nstspr->sector());
plr->angle.ang = buildang(nstspr->ang&kAngleMask);
@ -278,7 +278,7 @@ void RestartPlayer(int nPlayer)
auto fspr = &floorsprt->s();
fspr->pos.X = nSpr->pos.X;
fspr->y = nSpr->y;
fspr->pos.Y = nSpr->pos.Y;
fspr->z = nSpr->z;
fspr->yrepeat = 64;
fspr->xrepeat = 64;
@ -288,7 +288,7 @@ void RestartPlayer(int nPlayer)
else
{
nSpr->pos.X = plr->sPlayerSave.x;
nSpr->y = plr->sPlayerSave.y;
nSpr->pos.Y = plr->sPlayerSave.y;
nSpr->z = plr->sPlayerSave.pSector->floorz;
plr->angle.ang = buildang(plr->sPlayerSave.nAngle&kAngleMask);
nSpr->ang = plr->angle.ang.asbuild();
@ -324,7 +324,7 @@ void RestartPlayer(int nPlayer)
auto nDSpr = &pDActor->s();
nDSpr->pos.X = nSpr->pos.X;
nDSpr->y = nSpr->y;
nDSpr->pos.Y = nSpr->pos.Y;
nDSpr->z = nSpr->z;
nDSpr->xrepeat = nSpr->xrepeat;
nDSpr->yrepeat = nSpr->yrepeat;
@ -471,7 +471,7 @@ void StartDeathSeq(int nPlayer, int nVal)
auto pGunSprite = &pGunActor->s();
pGunSprite->pos.X = pSprite->pos.X;
pGunSprite->y = pSprite->y;
pGunSprite->pos.Y = pSprite->pos.Y;
pGunSprite->z = pSector->floorz - 512;
ChangeActorStat(pGunActor, nGunLotag[nWeapon] + 900);
@ -797,7 +797,7 @@ void AIPlayer::Tick(RunListEvent* ev)
nFlashDepth = 5;
AddFlash(pPlayerSprite->sector(),
pPlayerSprite->pos.X,
pPlayerSprite->y,
pPlayerSprite->pos.Y,
pPlayerSprite->z, 0);
}
}
@ -871,7 +871,7 @@ void AIPlayer::Tick(RunListEvent* ev)
int nSectFlag = PlayerList[nPlayer].pPlayerViewSect->Flag;
int playerX = pPlayerSprite->pos.X;
int playerY = pPlayerSprite->y;
int playerY = pPlayerSprite->pos.Y;
int x = (sPlayerInput[nPlayer].xVel * 4) >> 2;
int y = (sPlayerInput[nPlayer].yVel * 4) >> 2;
@ -887,7 +887,7 @@ void AIPlayer::Tick(RunListEvent* ev)
}
int spr_x = pPlayerSprite->pos.X;
int spr_y = pPlayerSprite->y;
int spr_y = pPlayerSprite->pos.Y;
int spr_z = pPlayerSprite->z;
auto spr_sect = pPlayerSprite->sector();
@ -901,9 +901,9 @@ void AIPlayer::Tick(RunListEvent* ev)
if (bSlipMode)
{
pPlayerSprite->pos.X += (x >> 14);
pPlayerSprite->y += (y >> 14);
pPlayerSprite->pos.Y += (y >> 14);
vec3_t pos = { pPlayerSprite->pos.X, pPlayerSprite->y, pPlayerSprite->z };
vec3_t pos = { pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z };
SetActor(pPlayerActor, &pos);
pPlayerSprite->z = pPlayerSprite->sector()->floorz;
@ -921,12 +921,12 @@ void AIPlayer::Tick(RunListEvent* ev)
}
// loc_1A6E4
if (inside(pPlayerSprite->pos.X, pPlayerSprite->y, pPlayerSprite->sector()) != 1)
if (inside(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->sector()) != 1)
{
ChangeActorSect(pPlayerActor, spr_sect);
pPlayerSprite->pos.X = spr_x;
pPlayerSprite->y = spr_y;
pPlayerSprite->pos.Y = spr_y;
if (zVel < pPlayerSprite->zvel) {
pPlayerSprite->zvel = zVel;
@ -1013,7 +1013,7 @@ void AIPlayer::Tick(RunListEvent* ev)
pPlayerSprite->yvel = 0;
StopActorSound(pPlayerActor);
PlayFXAtXYZ(StaticSound[kSoundJonFDie], pPlayerSprite->pos.X, pPlayerSprite->y, pPlayerSprite->z, CHANF_NONE, 1); // CHECKME
PlayFXAtXYZ(StaticSound[kSoundJonFDie], pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z, CHANF_NONE, 1); // CHECKME
}
else
{
@ -1070,7 +1070,7 @@ void AIPlayer::Tick(RunListEvent* ev)
else
{
pPlayerSprite->pos.X = spr_x;
pPlayerSprite->y = spr_y;
pPlayerSprite->pos.Y = spr_y;
pPlayerSprite->z = spr_z;
ChangeActorSect(pPlayerActor, spr_sect);
@ -1102,7 +1102,7 @@ sectdone:
}
playerX -= pPlayerSprite->pos.X;
playerY -= pPlayerSprite->y;
playerY -= pPlayerSprite->pos.Y;
uint32_t sqrtNum = playerX * playerX + playerY * playerY;
@ -1140,13 +1140,13 @@ sectdone:
if (nMove.type == kHitWall)
{
int var_C4 = pPlayerSprite->pos.X;
int var_D4 = pPlayerSprite->y;
int var_D4 = pPlayerSprite->pos.Y;
int var_C8 = pPlayerSprite->z;
ChangeActorSect(pPlayerActor, pViewSect);
pPlayerSprite->pos.X = spr_x;
pPlayerSprite->y = spr_y;
pPlayerSprite->pos.Y = spr_y;
int var_FC = pViewSect->floorz + (-5120);
@ -1158,7 +1158,7 @@ sectdone:
ChangeActorSect(pPlayerActor, pPlayerSprite->sector());
pPlayerSprite->pos.X = var_C4;
pPlayerSprite->y = var_D4;
pPlayerSprite->pos.Y = var_D4;
pPlayerSprite->z = var_C8;
}
else
@ -1174,7 +1174,7 @@ sectdone:
PlayerList[nPlayer].pPlayerViewSect = pViewSect;
PlayerList[nPlayer].nPlayerDX = pPlayerSprite->pos.X - spr_x;
PlayerList[nPlayer].nPlayerDY = pPlayerSprite->y - spr_y;
PlayerList[nPlayer].nPlayerDY = pPlayerSprite->pos.Y - spr_y;
int var_5C = pViewSect->Flag & kSectUnderwater;
@ -1294,7 +1294,7 @@ sectdone:
auto pFloorSprite = &pFloorActor->s();
pFloorSprite->pos.X = pPlayerSprite->pos.X;
pFloorSprite->y = pPlayerSprite->y;
pFloorSprite->pos.Y = pPlayerSprite->pos.Y;
if (pFloorSprite->sector() != pPlayerSprite->sector())
{
@ -1323,7 +1323,7 @@ sectdone:
neartag(pPlayerSprite->pos, pPlayerSprite->sector(), pPlayerSprite->ang, near, 1024, 2);
DExhumedActor* pActorB;
feebtag(pPlayerSprite->pos.X, pPlayerSprite->y, pPlayerSprite->z, pPlayerSprite->sector(), &pActorB, var_30, 768);
feebtag(pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->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->y, pPlayerSprite->z, pPlayerSprite->sector(), pPlayerSprite->ang);
SetSavePoint(nPlayer, pPlayerSprite->pos.X, pPlayerSprite->pos.Y, pPlayerSprite->z, pPlayerSprite->sector(), pPlayerSprite->ang);
break;
}
@ -2564,7 +2564,7 @@ sectdone:
if (nPlayer == nLocalPlayer)
{
initx = pPlayerSprite->pos.X;
inity = pPlayerSprite->y;
inity = pPlayerSprite->pos.Y;
initz = pPlayerSprite->z;
initsectp = pPlayerSprite->sector();
inita = pPlayerSprite->ang;

34
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->y, pSprite->z, pSprite->sector(), pSprite->xrepeat, 4);
BuildAnim(nullptr, 34, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->xrepeat, 4);
}
else
{
@ -305,12 +305,12 @@ Collision QueenAngleChase(DExhumedActor* pActor, DExhumedActor* pActor2, int val
spritetype* pSprite2 = &pActor2->s();
int nTileY = (tileHeight(pSprite2->picnum) * pSprite2->yrepeat) * 2;
int nMyAngle = GetMyAngle(pSprite2->pos.X - pSprite->pos.X, pSprite2->y - pSprite->y);
int nMyAngle = GetMyAngle(pSprite2->pos.X - pSprite->pos.X, pSprite2->pos.Y - pSprite->pos.Y);
int edx = ((pSprite2->z - nTileY) - pSprite->z) >> 8;
uint32_t xDiff = abs(pSprite2->pos.X - pSprite->pos.X);
uint32_t yDiff = abs(pSprite2->y - pSprite->y);
uint32_t yDiff = abs(pSprite2->pos.Y - pSprite->pos.Y);
uint32_t sqrtVal = xDiff * xDiff + yDiff * yDiff;
@ -413,7 +413,7 @@ void BuildTail()
pTailSprite->owner = runlist_AddRunRec(pTailSprite->lotag - 1, (i + 1), 0x1B0000);
pTailSprite->shade = -12;
pTailSprite->pos.X = x;
pTailSprite->y = y;
pTailSprite->pos.Y = y;
pTailSprite->hitag = 0;
pTailSprite->cstat = 0;
pTailSprite->clipdist = 100;
@ -452,7 +452,7 @@ void BuildQueenEgg(int nQueen, int nVal)
auto pSprite = &pActor->s();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
auto pSector =pSprite->sector();
int nFloorZ = pSector->floorz;
int nAngle = pSprite->ang;
@ -461,7 +461,7 @@ void BuildQueenEgg(int nQueen, int nVal)
auto pSprite2 = &pActor2->s();
pSprite2->pos.X = x;
pSprite2->y = y;
pSprite2->pos.Y = y;
pSprite2->z = nFloorZ;
pSprite2->pal = 0;
pSprite2->clipdist = 50;
@ -662,7 +662,7 @@ void AIQueenEgg::Tick(RunListEvent* ev)
pEgg->nCounter--;
if (pEgg->nCounter <= 0)
{
auto pWaspSprite = BuildWasp(nullptr, pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector(), pSprite->ang, true);
auto pWaspSprite = BuildWasp(nullptr, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->ang, true);
pSprite->z = pWaspSprite->spr.z;
DestroyEgg(nEgg);
@ -717,7 +717,7 @@ void BuildQueenHead(int nQueen)
auto pSprite = &pActor->s();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int nAngle = pSprite->ang;
auto pSector = pSprite->sector();
int z = pSector->floorz;
@ -726,7 +726,7 @@ void BuildQueenHead(int nQueen)
auto pSprite2 = &pActor2->s();
pSprite2->pos.X = x;
pSprite2->y = y;
pSprite2->pos.Y = y;
pSprite2->z = z;
pSprite2->clipdist = 70;
pSprite2->xrepeat = 80;
@ -937,7 +937,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
// switch break. MoveQS stuff?
__MOVEQS:
MoveQX[nQHead] = pSprite->pos.X;
MoveQY[nQHead] = pSprite->y;
MoveQY[nQHead] = pSprite->pos.Y;
MoveQZ[nQHead] = pSprite->z;
assert(pSprite->sector());
MoveQS[nQHead] = pSprite->sector();
@ -965,7 +965,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
}
pTSprite->pos.X = MoveQX[nHd];
pTSprite->y = MoveQY[nHd];
pTSprite->pos.Y = MoveQY[nHd];
pTSprite->z = MoveQZ[nHd];
pTSprite->ang = MoveQA[nHd];
}
@ -990,7 +990,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
if (QueenHead.nIndex2 >= 15 || QueenHead.nIndex2 < 10)
{
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->z;
auto pSector =pSprite->sector();
int nAngle = RandomSize(11) & kAngleMask;
@ -1014,7 +1014,7 @@ void AIQueenHead::Tick(RunListEvent* ev)
ChangeActorSect(pActor, pSector);
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
if (QueenHead.nIndex2 < 10) {
@ -1142,13 +1142,13 @@ void BuildQueen(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
ChangeActorStat(pActor, 121);
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->sector()->floorz;
nAngle = pSprite->ang;
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->pal = 0;
@ -1434,7 +1434,7 @@ void AIQueen::Tick(RunListEvent* ev)
PlayFXAtXYZ(
StaticSound[kSound40],
pSprite->pos.X,
pSprite->y,
pSprite->pos.Y,
pSprite->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->y, pSprite->z - 7680, pSprite->sector(), pSprite->xrepeat, 4);
BuildAnim(nullptr, 36, 0, pSprite->pos.X, pSprite->pos.Y, pSprite->z - 7680, pSprite->sector(), pSprite->xrepeat, 4);
break;
case 2:
QueenList[nQueen].nHealth = 4000;

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

@ -170,7 +170,7 @@ void MoveRaToEnemy(int nPlayer)
auto pTargSprite = &pTarget->s();
pSprite->pos.X = pTargSprite->pos.X;
pSprite->y = pTargSprite->y;
pSprite->pos.Y = pTargSprite->pos.Y;
pSprite->z = pTargSprite->z - GetActorHeight(pTarget);
if (pSprite->sector() != 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->y, pSpiritSpr->z, 128);
AddFlash(pSpiritSpr->sector(), pSpiritSpr->pos.X, pSpiritSpr->pos.Y, pSpiritSpr->z, 128);
nHeadStage = 3;
TintPalette(255, 255, 255);
CopyHeadToWorkTile(kTileRamsesNormal);

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

@ -85,7 +85,7 @@ void BuildRat(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
{
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->z;
nAngle = pSprite->ang;
@ -131,7 +131,7 @@ DExhumedActor* FindFood(DExhumedActor* pActor)
auto pSprite = &pActor->s();
auto pSector = pSprite->sector();
int x = pSprite->pos.X;
int y = pSprite->y;
int y = pSprite->pos.Y;
int z = pSprite->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->y, pSprite2->z, pSprite2->sector())) {
if (cansee(x, y, z2, pSector, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->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->y, pSprite2->z, pSprite2->sector())) {
if (cansee(x, y, z, pSector, pSprite2->pos.X, pSprite2->pos.Y, pSprite2->z, pSprite2->sector())) {
return pActor2;
}
}
@ -241,7 +241,7 @@ void AIRat::Tick(RunListEvent* ev)
}
int xVal = abs(pSprite->pos.X - pTarget->spr.pos.X);
int yVal = abs(pSprite->y - pTarget->spr.y);
int yVal = abs(pSprite->pos.Y - pTarget->spr.pos.Y);
if (xVal > 50 || yVal > 50)
{
@ -294,7 +294,7 @@ void AIRat::Tick(RunListEvent* ev)
MoveCreature(pActor);
int xVal = abs(pSprite->pos.X - pTarget->spr.pos.X);
int yVal = abs(pSprite->y - pTarget->spr.y);
int yVal = abs(pSprite->pos.Y - pTarget->spr.pos.Y);
if (xVal >= 50 || yVal >= 50)
{

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

@ -49,7 +49,7 @@ void BuildRex(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
{
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->sector()->floorz;
nAngle = pSprite->ang;
@ -57,7 +57,7 @@ void BuildRex(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector, i
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->clipdist = 80;

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

@ -48,13 +48,13 @@ void BuildRoach(int nType, DExhumedActor* pActor, int x, int y, int z, sectortyp
ChangeActorStat(pActor, 105);
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->sector()->floorz;
angle = pSprite->ang;
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->shade = -12;
@ -282,7 +282,7 @@ void AIRoach::Tick(RunListEvent* ev)
pSprite->xvel = 0;
pSprite->yvel = 0;
pSprite->ang = GetMyAngle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
pSprite->ang = GetMyAngle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
pActor->nFrame = 0;
}
@ -311,7 +311,7 @@ void AIRoach::Tick(RunListEvent* ev)
pSprite->xvel = 0;
pSprite->yvel = 0;
pSprite->ang = GetMyAngle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
pSprite->ang = GetMyAngle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
pActor->nFrame = 0;
}

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

@ -1608,7 +1608,7 @@ int runlist_CheckRadialDamage(DExhumedActor* pActor)
}
int x = (pSprite->pos.X - pRadialSpr->pos.X) >> 8;
int y = (pSprite->y - pRadialSpr->y) >> 8;
int y = (pSprite->pos.Y - pRadialSpr->pos.Y) >> 8;
int z = (pSprite->z - pRadialSpr->z) >> 12;
if (abs(x) > nDamageRadius) {
@ -1645,11 +1645,11 @@ int runlist_CheckRadialDamage(DExhumedActor* pActor)
if (((kStatExplodeTarget - pSprite->statnum) <= 1) ||
cansee(pRadialSpr->pos.X,
pRadialSpr->y,
pRadialSpr->pos.Y,
pRadialSpr->z - 512,
pRadialSpr->sector(),
pSprite->pos.X,
pSprite->y,
pSprite->pos.Y,
pSprite->z - 8192,
pSprite->sector()))
{

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

@ -53,13 +53,13 @@ void BuildScorp(DExhumedActor* pActor, int x, int y, int z, sectortype* pSector,
pSprite = &pActor->s();
x = pSprite->pos.X;
y = pSprite->y;
y = pSprite->pos.Y;
z = pSprite->sector()->floorz;
nAngle = pSprite->ang;
}
pSprite->pos.X = x;
pSprite->y = y;
pSprite->pos.Y = y;
pSprite->z = z;
pSprite->cstat = CSTAT_SPRITE_BLOCK_ALL;
pSprite->clipdist = 70;
@ -260,7 +260,7 @@ void AIScorp::Tick(RunListEvent* ev)
{
if (pTarget == nMov.actor())
{
int nAngle = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
int nAngle = getangle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
if (AngleDiff(pSprite->ang, nAngle) < 64)
{
pActor->nAction = 2;
@ -379,7 +379,7 @@ void AIScorp::Tick(RunListEvent* ev)
return;
}
auto pSpiderActor = BuildSpider(nullptr, pSprite->pos.X, pSprite->y, pSprite->z, pSprite->sector(), pSprite->ang);
auto pSpiderActor = BuildSpider(nullptr, pSprite->pos.X, pSprite->pos.Y, pSprite->z, pSprite->sector(), pSprite->ang);
if (pSpiderActor)
{
auto pSpiderSprite = &pSpiderActor->s();
@ -440,12 +440,12 @@ void AIScorp::Effect(RunListEvent* ev, DExhumedActor* pTarget, int mode)
{
pActor->nCount = 45;
if (cansee(pSprite->pos.X, pSprite->y, pSprite->z - GetActorHeight(pActor), pSprite->sector(),
pTarget->spr.pos.X, pTarget->spr.y, pTarget->spr.z - GetActorHeight(pTarget), pTarget->spr.sector()))
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()))
{
pSprite->xvel = 0;
pSprite->yvel = 0;
pSprite->ang = GetMyAngle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.y - pSprite->y);
pSprite->ang = GetMyAngle(pTarget->spr.pos.X - pSprite->pos.X, pTarget->spr.pos.Y - pSprite->pos.Y);
pActor->nIndex = RandomSize(2) + RandomSize(3);

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

@ -472,7 +472,7 @@ int seq_GetSeqPicnum(int16_t nSeq, int16_t edx, int16_t ebx)
int seq_PlotArrowSequence(int nSprite, int16_t nSeq, int nVal)
{
tspriteptr_t pTSprite = &mytsprite[nSprite];
int nAngle = GetMyAngle(nCamerax - pTSprite->pos.X, nCameray - pTSprite->y);
int nAngle = GetMyAngle(nCamerax - pTSprite->pos.X, nCameray - pTSprite->pos.Y);
int nSeqOffset = ((((pTSprite->ang + 512) - nAngle) + 128) & kAngleMask) >> 8;
@ -520,7 +520,7 @@ int seq_PlotArrowSequence(int nSprite, int16_t nSeq, int nVal)
int seq_PlotSequence(int nSprite, int16_t edx, int16_t nFrame, int16_t ecx)
{
tspriteptr_t pTSprite = &mytsprite[nSprite];
int nAngle = GetMyAngle(nCamerax - pTSprite->pos.X, nCameray - pTSprite->y);
int nAngle = GetMyAngle(nCamerax - pTSprite->pos.X, nCameray - pTSprite->pos.Y);
int val;
@ -574,7 +574,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->y = pTSprite->y;
tsp->pos.Y = pTSprite->pos.Y;
tsp->z = pTSprite->z;
tsp->shade = shade;
tsp->pal = pTSprite->pal;

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