zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-04-07 16:31:26 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Duke: renamed all spr.pos

Browse source 
This was pure search&replace with no other code edits.
This commit is contained in:
Christoph Oelckers 2022-01-31 19:21:49 +01:00
parent f629ec1916
commit 204d6018f4
24 changed files with 618 additions and 618 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

File diff suppressed because it is too large Load diff

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

@ -267,16 +267,16 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
while (auto dasectp = search.GetNext())
{
if (((dasectp->ceilingz - actor->spr.pos.Z) >> 8) < r)
if (((dasectp->ceilingz - actor->int_pos().Z) >> 8) < r)
{
auto wal = dasectp->firstWall();
int d = abs(wal->wall_int_pos().X - actor->spr.pos.X) + abs(wal->wall_int_pos().Y - actor->spr.pos.Y);
int d = abs(wal->wall_int_pos().X - actor->int_pos().X) + abs(wal->wall_int_pos().Y - actor->int_pos().Y);
if (d < r)
fi.checkhitceiling(dasectp);
else
{
auto thirdpoint = wal->point2Wall()->point2Wall();
d = abs(thirdpoint->wall_int_pos().X - actor->spr.pos.X) + abs(thirdpoint->wall_int_pos().Y - actor->spr.pos.Y);
d = abs(thirdpoint->wall_int_pos().X - actor->int_pos().X) + abs(thirdpoint->wall_int_pos().Y - actor->int_pos().Y);
if (d < r)
fi.checkhitceiling(dasectp);
}
@ -284,18 +284,18 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
for (auto& wal : wallsofsector(dasectp))
{
if ((abs(wal.wall_int_pos().X - actor->spr.pos.X) + abs(wal.wall_int_pos().Y - actor->spr.pos.Y)) < r)
if ((abs(wal.wall_int_pos().X - actor->int_pos().X) + abs(wal.wall_int_pos().Y - actor->int_pos().Y)) < r)
{
if (wal.twoSided())
{
search.Add(wal.nextSector());
}
int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->spr.pos.X) >> 1;
int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->spr.pos.Y) >> 1;
int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->int_pos().X) >> 1;
int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->int_pos().Y) >> 1;
sectortype* sect = wal.sectorp();
updatesector(x1, y1, &sect);
if (sect && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->spr.pos.Z, actor->spr.picnum);
if (sect && cansee(x1, y1, actor->int_pos().Z, sect, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector()))
fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
}
}
}
@ -327,7 +327,7 @@ void hitradius_d(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (actor->spr.picnum != SHRINKSPARK || (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL))
if (dist(actor, act2) < r)
{
if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->sector()))
if (badguy(act2) && !cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z + q, act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z + q, actor->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->add_int_z(gs.playerheight);
if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->sector()))
if (d < r && cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z - (8 << 8), act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (12 << 8), actor->sector()))
{
act2->hitang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
act2->hitang = getangle(act2->int_pos().X - actor->int_pos().X, act2->int_pos().Y - actor->int_pos().Y);
if (actor->spr.picnum == RPG && act2->spr.extra > 0)
act2->attackertype = RPG;
@ -443,13 +443,13 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
{
actor->add_int_pos({ (xchange * TICSPERFRAME) >> 2, (ychange * TICSPERFRAME) >> 2, (zchange * TICSPERFRAME) >> 2 });
if (bg)
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
return result.setNone();
}
auto dasectp = actor->sector();
vec3_t pos = actor->spr.pos;
vec3_t pos = actor->int_pos();
pos.Z -= ((tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 1);
if (bg)
@ -481,7 +481,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
actor->spr.ang = (krand()&2047);
else if ((actor->temp_data[0]&3) == 1 && actor->spr.picnum != COMMANDER)
actor->spr.ang = (krand()&2047);
SetActor(actor,actor->spr.pos);
SetActor(actor,actor->int_pos());
if (dasectp == nullptr) dasectp = &sector[0];
return result.setSector(dasectp);
}
@ -499,7 +499,7 @@ int movesprite_ex_d(DDukeActor* actor, int xchange, int ychange, int zchange, un
if (dasectp != nullptr)
if (dasectp != actor->sector())
ChangeActorSect(actor, dasectp);
int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
int daz = actor->int_pos().Z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
actor->set_int_z(daz);
else if (result.type == kHitNone)
@ -545,8 +545,8 @@ void guts_d(DDukeActor* actor, int gtype, int n, int p)
sx = sy = 8;
else sx = sy = 32;
gutz = actor->spr.pos.Z - (8 << 8);
floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
gutz = actor->int_pos().Z - (8 << 8);
floorz = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -570,7 +570,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->sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx, sy, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
auto spawned = EGS(actor->sector(), actor->int_pos().X + (r5 & 255) - 128, actor->int_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)
@ -770,14 +770,14 @@ void movefallers_d(void)
x = gs.gravity;
}
if (act->spr.pos.Z < (sectp->floorz - FOURSLEIGHT))
if (act->int_pos().Z < (sectp->floorz - FOURSLEIGHT))
{
act->spr.zvel += x;
if (act->spr.zvel > 6144)
act->spr.zvel = 6144;
act->add_int_z(act->spr.zvel);
}
if ((sectp->floorz - act->spr.pos.Z) < (16 << 8))
if ((sectp->floorz - act->int_pos().Z) < (16 << 8))
{
j = 1 + (krand() & 7);
for (x = 0; x < j; x++) RANDOMSCRAP(act);
@ -871,14 +871,14 @@ 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.pos.Y;
actor->temp_data[3] = actor->int_pos().X; actor->temp_data[4] = actor->int_pos().Y;
actor->add_int_pos({ bcos(actor->temp_data[5], -9), bsin(actor->temp_data[5], -9), -(3 << 8) });
// Laser fix from EDuke32.
auto const oldSect = actor->sector();
auto curSect = actor->sector();
updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
updatesectorneighbor(actor->int_pos().X, actor->int_pos().Y, &curSect, 2048);
ChangeActorSect(actor, curSect);
DDukeActor* hit;
@ -896,9 +896,9 @@ static void movetripbomb(DDukeActor *actor)
auto spawned = spawn(actor, LASERLINE);
if (spawned)
{
SetActor(spawned, spawned->spr.pos);
SetActor(spawned, spawned->int_pos());
spawned->spr.hitag = actor->spr.hitag;
spawned->temp_data[1] = spawned->spr.pos.Z;
spawned->temp_data[1] = spawned->int_pos().Z;
if (x < 1024)
{
@ -908,7 +908,7 @@ static void movetripbomb(DDukeActor *actor)
x -= 1024;
actor->add_int_pos({ bcos(actor->temp_data[5], -4), bsin(actor->temp_data[5], -4), 0 });
updatesectorneighbor(actor->spr.pos.X, actor->spr.pos.Y, &curSect, 2048);
updatesectorneighbor(actor->int_pos().X, actor->int_pos().Y, &curSect, 2048);
if (curSect == nullptr)
break;
@ -938,16 +938,16 @@ static void movetripbomb(DDukeActor *actor)
actor->temp_data[1]++;
actor->temp_data[3] = actor->spr.pos.X;
actor->temp_data[4] = actor->spr.pos.Y;
actor->temp_data[3] = actor->int_pos().X;
actor->temp_data[4] = actor->int_pos().Y;
actor->add_int_pos({ bcos(actor->temp_data[5], -9), bsin(actor->temp_data[5], -9), -(3 << 8) });
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
x = hitasprite(actor, nullptr);
actor->set_int_xy(actor->temp_data[3], actor->temp_data[4]);
actor->add_int_z(3 << 8);
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
if (actor->ovel.X != x && lTripBombControl & TRIPBOMB_TRIPWIRE)
{
@ -1003,7 +1003,7 @@ static void movefireext(DDukeActor* actor)
for (int k = 0; k < 16; k++)
{
auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto spawned = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
if(spawned) spawned->spr.pal = 2;
}
@ -1330,7 +1330,7 @@ static bool movefireball(DDukeActor* actor)
ball->spr.cstat = actor->spr.cstat;
ball->spr.extra = 0;
ball->fproj = { ball->spr.pos, { ball->spr.xvel, ball->spr.yvel, ball->spr.zvel } };
ball->fproj = { ball->int_pos(), { ball->spr.xvel, ball->spr.yvel, ball->spr.zvel } };
ChangeActorStat(ball, STAT_PROJECTILE);
}
@ -1425,7 +1425,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t &oldpos)
else
{
SetActor(proj, oldpos);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.pos.Z, proj->spr.picnum);
fi.checkhitwall(proj, wal, proj->int_pos().X, proj->int_pos().Y, proj->int_pos().Z, proj->spr.picnum);
if (proj->spr.picnum == FREEZEBLAST)
{
@ -1505,7 +1505,7 @@ static void weaponcommon_d(DDukeActor* proj)
S_PlayActorSound(WIERDSHOT_FLY, proj);
int k, ll;
vec3_t oldpos = proj->spr.pos;
vec3_t oldpos = proj->int_pos();
if (proj->spr.picnum == RPG && proj->sector()->lotag == 2)
{
@ -1541,7 +1541,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.vec2 - proj->temp_actor->spr.pos.vec2) < 256)
if (FindDistance2D(proj->int_pos().vec2 - proj->temp_actor->int_pos().vec2) < 256)
coll.setSprite(proj->temp_actor);
if (!proj->insector())
@ -1552,14 +1552,14 @@ static void weaponcommon_d(DDukeActor* proj)
if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
{
if (proj->spr.pos.Z < proj->ceilingz)
if (proj->int_pos().Z < proj->ceilingz)
{
coll.setSector(proj->sector());
proj->spr.zvel = -1;
}
else
if ((proj->spr.pos.Z > proj->floorz && proj->sector()->lotag != 1) ||
(proj->spr.pos.Z > proj->floorz + (16 << 8) && proj->sector()->lotag == 1))
if ((proj->int_pos().Z > proj->floorz && proj->sector()->lotag != 1) ||
(proj->int_pos().Z > proj->floorz + (16 << 8) && proj->sector()->lotag == 1))
{
coll.setSector(proj->sector());
if (proj->sector()->lotag != 1)
@ -1578,9 +1578,9 @@ static void weaponcommon_d(DDukeActor* proj)
};
auto spawned = EGS(proj->sector(),
proj->spr.pos.X + offset.X,
proj->spr.pos.Y + offset.Y,
proj->spr.pos.Z + offset.Z, FIRELASER, -40 + (k << 2),
proj->int_pos().X + offset.X,
proj->int_pos().Y + offset.Y,
proj->int_pos().Z + offset.Z, FIRELASER, -40 + (k << 2),
proj->spr.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
if (spawned)
@ -1806,9 +1806,9 @@ void movetransports_d(void)
ps[p].transporter_hold = 13;
}
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->spr.pos.X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->spr.pos.Y;
ps[p].opos.Z = ps[p].pos.Z = Owner->spr.pos.Z - gs.playerheight;
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->int_pos().X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->int_pos().Y;
ps[p].opos.Z = ps[p].pos.Z = Owner->int_pos().Z - gs.playerheight;
ChangeActorSect(act2, Owner->sector());
ps[p].setCursector(act2->sector());
@ -1824,16 +1824,16 @@ void movetransports_d(void)
}
else if (!(sectlotag == 1 && ps[p].on_ground == 1)) break;
if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 6144)
if (onfloorz == 0 && abs(act->int_pos().Z - ps[p].pos.Z) < 6144)
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP))) ||
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
{
ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
ps[p].pos.Z = Owner->spr.pos.Z - 6144;
else ps[p].pos.Z = Owner->spr.pos.Z + 6144;
ps[p].pos.Z = Owner->int_pos().Z - 6144;
else ps[p].pos.Z = Owner->int_pos().Z + 6144;
ps[p].opos.Z = ps[p].pos.Z;
auto pa = ps[p].GetActor();
@ -1884,8 +1884,8 @@ void movetransports_d(void)
if (k == 1)
{
ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
if (!Owner || Owner->GetOwner() != Owner)
ps[p].transporter_hold = -2;
@ -1934,13 +1934,13 @@ void movetransports_d(void)
{
warpspriteto = 0;
if (ll && sectlotag == 2 && act2->spr.pos.Z < (sectp->ceilingz + ll))
if (ll && sectlotag == 2 && act2->int_pos().Z < (sectp->ceilingz + ll))
warpspriteto = 1;
if (ll && sectlotag == 1 && act2->spr.pos.Z > (sectp->floorz - ll))
if (ll && sectlotag == 1 && act2->int_pos().Z > (sectp->floorz - ll))
warpspriteto = 1;
if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 4096))
if (sectlotag == 0 && (onfloorz || abs(act2->int_pos().Z - act->int_pos().Z) < 4096))
{
if ((!Owner || Owner->GetOwner() != Owner) && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != STAT_MISC)
{
@ -1989,7 +1989,7 @@ void movetransports_d(void)
{
if (act2->spr.statnum == STAT_PROJECTILE || (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1))
{
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X),(Owner->spr.pos.Y - act->spr.pos.Y), -(act->spr.pos.Z - Owner->sector()->floorz) });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X),(Owner->int_pos().Y - act->int_pos().Y), -(act->int_pos().Z - Owner->sector()->floorz) });
act2->spr.ang = Owner->spr.ang;
act2->backupang();
@ -2014,20 +2014,20 @@ void movetransports_d(void)
}
else
{
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->set_int_z(Owner->spr.pos.Z + 4096);
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->int_pos().Z + 4096);
act2->backupz();
ChangeActorSect(act2, Owner->sector());
}
break;
case ST_1_ABOVE_WATER:
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->sector()->ceilingz + ll);
act2->backupz();
ChangeActorSect(act2, Owner->sector());
break;
case ST_2_UNDERWATER:
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->sector()->floorz - ll);
act2->backupz();
ChangeActorSect(act2, Owner->sector());
@ -2112,7 +2112,7 @@ static void greenslime(DDukeActor *actor)
return;
for (j = 16; j >= 0; j--)
{
auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
auto k = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, GLASSPIECES + (j % 3), -32, 36, 36, krand() & 2047, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
k->spr.pal = 1;
}
ps[p].actors_killed++;
@ -2121,7 +2121,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.pos.Y - ps[p].pos.Y));
j = getincangle(ps[p].angle.ang.asbuild(), getangle(actor->int_pos().X - ps[p].pos.X, actor->int_pos().Y - ps[p].pos.Y));
if (j > -128 && j < 128)
ps[p].quick_kick = 14;
}
@ -2141,7 +2141,7 @@ static void greenslime(DDukeActor *actor)
return;
}
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
actor->spr.ang = ps[p].angle.ang.asbuild();
@ -2150,7 +2150,7 @@ static void greenslime(DDukeActor *actor)
{
for (x = 0; x < 8; x++)
{
auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto spawned = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
spawned->spr.pal = 6;
}
@ -2260,7 +2260,7 @@ static void greenslime(DDukeActor *actor)
for (x = 0; x < 8; x++)
{
auto spawned = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
auto spawned = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (actor->spr.zvel >> 2), actor, 5);
if (spawned) spawned->spr.pal = 6;
}
actor->temp_data[0] = -3;
@ -2299,7 +2299,7 @@ static void greenslime(DDukeActor *actor)
int l = s5->spr.ang;
actor->set_int_pos({ s5->spr.pos.X + bcos(l, -11), s5->spr.pos.Y + bsin(l, -11), s5->spr.pos.Z });
actor->set_int_pos({ s5->int_pos().X + bcos(l, -11), s5->int_pos().Y + bsin(l, -11), s5->int_pos().Z });
actor->spr.picnum = GREENSLIME + 2 + (global_random & 1);
@ -2328,7 +2328,7 @@ static void greenslime(DDukeActor *actor)
{
if (actorflag(a2, SFLAG_GREENSLIMEFOOD))
{
if (ldist(actor, a2) < 768 && (abs(actor->spr.pos.Z - a2->spr.pos.Z) < 8192)) //Gulp them
if (ldist(actor, a2) < 768 && (abs(actor->int_pos().Z - a2->int_pos().Z) < 8192)) //Gulp them
{
actor->temp_actor = a2;
actor->temp_data[0] = -2;
@ -2353,7 +2353,7 @@ static void greenslime(DDukeActor *actor)
actor->spr.zvel = 0;
actor->spr.cstat &= ~CSTAT_SPRITE_YFLIP;
if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 6144) < actor->spr.pos.Z)
if ((sectp->ceilingstat & CSTAT_SECTOR_SKY) || (actor->ceilingz + 6144) < actor->int_pos().Z)
{
actor->add_int_z(2048);
actor->temp_data[0] = 3;
@ -2379,7 +2379,7 @@ static void greenslime(DDukeActor *actor)
actor->spr.xvel = 64 - bcos(actor->temp_data[1], -9);
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;
getangle(ps[p].pos.X - actor->int_pos().X, ps[p].pos.Y - actor->int_pos().Y)) >> 3;
// TJR
}
@ -2404,7 +2404,7 @@ static void greenslime(DDukeActor *actor)
if (actor->spr.zvel > -(2048 + 1024))
actor->spr.zvel -= 348;
actor->add_int_z(actor->spr.zvel);
if (actor->spr.pos.Z < actor->ceilingz + 4096)
if (actor->int_pos().Z < actor->ceilingz + 4096)
{
actor->set_int_z(actor->ceilingz + 4096);
actor->spr.xvel = 0;
@ -2418,7 +2418,7 @@ static void greenslime(DDukeActor *actor)
makeitfall(actor);
if (actor->spr.pos.Z > actor->floorz - (8 << 8))
if (actor->int_pos().Z > actor->floorz - (8 << 8))
{
actor->spr.yrepeat -= 4;
actor->spr.xrepeat += 2;
@ -2429,7 +2429,7 @@ static void greenslime(DDukeActor *actor)
if (actor->spr.xrepeat > 8) actor->spr.xrepeat -= 4;
}
if (actor->spr.pos.Z > actor->floorz - 2048)
if (actor->int_pos().Z > actor->floorz - 2048)
{
actor->set_int_z(actor->floorz - 2048);
actor->temp_data[0] = 0;
@ -2458,9 +2458,9 @@ static void flamethrowerflame(DDukeActor *actor)
return;
}
int dax = actor->spr.pos.X;
int day = actor->spr.pos.Y;
int daz = actor->spr.pos.Z;
int dax = actor->int_pos().X;
int day = actor->int_pos().Y;
int daz = actor->int_pos().Z;
int xvel = actor->spr.xvel;
getglobalz(actor);
@ -2490,13 +2490,13 @@ static void flamethrowerflame(DDukeActor *actor)
if (coll.type != kHitSprite)
{
if (actor->spr.pos.Z < actor->ceilingz)
if (actor->int_pos().Z < actor->ceilingz)
{
coll.setSector(actor->sector());
actor->spr.zvel = -1;
}
else if ((actor->spr.pos.Z > actor->floorz && actor->sector()->lotag != 1)
|| (actor->spr.pos.Z > actor->floorz + (16 << 8) && actor->sector()->lotag == 1))
else if ((actor->int_pos().Z > actor->floorz && actor->sector()->lotag != 1)
|| (actor->int_pos().Z > actor->floorz + (16 << 8) && actor->sector()->lotag == 1))
{
coll.setSector(actor->sector());
if (actor->sector()->lotag != 1)
@ -2515,7 +2515,7 @@ static void flamethrowerflame(DDukeActor *actor)
else if (coll.type == kHitWall)
{
SetActor(actor, { dax, day, daz });
fi.checkhitwall(actor, coll.hitWall, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
fi.checkhitwall(actor, coll.hitWall, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
}
else if (coll.type == kHitSector)
{
@ -2583,7 +2583,7 @@ static void heavyhbomb(DDukeActor *actor)
{
makeitfall(actor);
if (sectp->lotag != 1 && actor->spr.pos.Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
if (sectp->lotag != 1 && actor->int_pos().Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
{
if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
S_PlayActorSound(PIPEBOMB_BOUNCE, actor);
@ -2592,7 +2592,7 @@ static void heavyhbomb(DDukeActor *actor)
actor->spr.zvel >>= 2;
actor->spr.yvel++;
}
if (actor->spr.pos.Z < actor->ceilingz) // && sectp->lotag != 2 )
if (actor->int_pos().Z < actor->ceilingz) // && sectp->lotag != 2 )
{
actor->set_int_z(actor->ceilingz + (3 << 8));
actor->spr.zvel = 0;
@ -2643,7 +2643,7 @@ static void heavyhbomb(DDukeActor *actor)
if (coll.type== kHitWall)
{
auto wal = coll.hitWall;
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
fi.checkhitwall(actor, wal, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
int k = getangle(wal->delta());
@ -2709,7 +2709,7 @@ DETONATEB:
}
}
else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && actor->temp_data[0] > 7 && actor->spr.xvel == 0)
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (ps[p].ammo_amount[HANDBOMB_WEAPON] < gs.max_ammo_amount[HANDBOMB_WEAPON])
{
if (ud.coop >= 1 && Owner == actor)
@ -2954,8 +2954,8 @@ static void fireflyflyingeffect(DDukeActor *actor)
else
actor->spr.cstat &= ~CSTAT_SPRITE_INVISIBLE;
double dx = Owner->spr.pos.X - ps[p].GetActor()->spr.pos.X;
double dy = Owner->spr.pos.Y - ps[p].GetActor()->spr.pos.Y;
double dx = Owner->int_pos().X - ps[p].GetActor()->int_pos().X;
double dy = Owner->int_pos().Y - ps[p].GetActor()->int_pos().Y;
double dist = sqrt(dx * dx + dy * dy);
if (dist != 0.0)
{
@ -2963,7 +2963,7 @@ static void fireflyflyingeffect(DDukeActor *actor)
dy /= dist;
}
actor->set_int_pos({ (int)(Owner->spr.pos.X - (dx * -10.0)), (int)(Owner->spr.pos.Y - (dy * -10.0)), Owner->spr.pos.Z + 2048 });
actor->set_int_pos({ (int)(Owner->int_pos().X - (dx * -10.0)), (int)(Owner->int_pos().Y - (dy * -10.0)), Owner->int_pos().Z + 2048 });
if (Owner->spr.extra <= 0)
{
@ -3077,7 +3077,7 @@ void moveexplosions_d(void) // STATNUM 5
case MONEY + 1:
case MAIL + 1:
case PAPER + 1:
act->floorz = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
act->floorz = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
act->set_int_z(act->floorz);
break;
case MONEY:
@ -3139,7 +3139,7 @@ void moveexplosions_d(void) // STATNUM 5
case SHELL:
case SHOTGUNSHELL:
shell(act, (sectp->floorz + (24 << 8)) < act->spr.pos.Z);
shell(act, (sectp->floorz + (24 << 8)) < act->int_pos().Z);
continue;
case GLASSPIECES:
@ -3256,7 +3256,7 @@ static void handle_se28(DDukeActor* actor)
}
else if (actor->temp_data[2] > (actor->temp_data[1] >> 3) && actor->temp_data[2] < (actor->temp_data[1] >> 2))
{
int j = !!cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
int j = !!cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector(), ps[screenpeek].pos.X, ps[screenpeek].pos.Y, ps[screenpeek].pos.Z, ps[screenpeek].cursector);
if (rnd(192) && (actor->temp_data[2] & 1))
{
@ -3436,7 +3436,7 @@ void moveeffectors_d(void) //STATNUM 3
case SE_29_WAVES:
act->spr.hitag += 64;
l = MulScale(act->spr.yvel, bsin(act->spr.hitag), 12);
sc->setfloorz(act->spr.pos.Z + l);
sc->setfloorz(act->int_pos().Z + l);
break;
case SE_31_FLOOR_RISE_FALL: // True Drop Floor
handle_se31(act, true);
@ -3508,8 +3508,8 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (a & face_player)
{
if (ps[playernum].newOwner != nullptr)
goalang = getangle(ps[playernum].opos.X - actor->spr.pos.X, ps[playernum].opos.Y - actor->spr.pos.Y);
else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
goalang = getangle(ps[playernum].opos.X - actor->int_pos().X, ps[playernum].opos.Y - actor->int_pos().Y);
else goalang = getangle(ps[playernum].pos.X - actor->int_pos().X, ps[playernum].pos.Y - actor->int_pos().Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3521,8 +3521,8 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (a & face_player_slow)
{
if (ps[playernum].newOwner != nullptr)
goalang = getangle(ps[playernum].opos.X - actor->spr.pos.X, ps[playernum].opos.Y - actor->spr.pos.Y);
else goalang = getangle(ps[playernum].pos.X - actor->spr.pos.X, ps[playernum].pos.Y - actor->spr.pos.Y);
goalang = getangle(ps[playernum].opos.X - actor->int_pos().X, ps[playernum].opos.Y - actor->int_pos().Y);
else goalang = getangle(ps[playernum].pos.X - actor->int_pos().X, ps[playernum].pos.Y - actor->int_pos().Y);
angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
@ -3545,7 +3545,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
newx = ps[playernum].pos.X + (ps[playernum].vel.X / 768);
newy = ps[playernum].pos.Y + (ps[playernum].vel.Y / 768);
goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.pos.Y);
goalang = getangle(newx - actor->int_pos().X, newy - actor->int_pos().Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3553,10 +3553,10 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
if (actor->temp_data[1] == 0 || a == 0)
{
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->spr.pos.X) || (actor->opos.Y != actor->spr.pos.Y))
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->int_pos().X) || (actor->opos.Y != actor->int_pos().Y))
{
actor->backupvec2();
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
}
return;
}
@ -3584,15 +3584,15 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (actor->spr.picnum == COMMANDER)
{
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.pos.Z > (l - (8 << 8)))
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if (actor->int_pos().Z > (l - (8 << 8)))
{
if (actor->spr.pos.Z > (l - (8 << 8))) actor->set_int_z(l - (8 << 8));
if (actor->int_pos().Z > (l - (8 << 8))) actor->set_int_z(l - (8 << 8));
actor->spr.zvel = 0;
}
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (80 << 8))
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if ((actor->int_pos().Z - l) < (80 << 8))
{
actor->set_int_z(l + (80 << 8));
actor->spr.zvel = 0;
@ -3602,14 +3602,14 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (actor->spr.zvel > 0)
{
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if (actor->spr.pos.Z > (l - (30 << 8)))
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if (actor->int_pos().Z > (l - (30 << 8)))
actor->set_int_z(l - (30 << 8));
}
else
{
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (50 << 8))
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if ((actor->int_pos().Z - l) < (50 << 8))
{
actor->set_int_z(l + (50 << 8));
actor->spr.zvel = 0;
@ -3619,12 +3619,12 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
}
else if (actor->spr.picnum != ORGANTIC)
{
if (actor->spr.zvel > 0 && actor->floorz < actor->spr.pos.Z)
if (actor->spr.zvel > 0 && actor->floorz < actor->int_pos().Z)
actor->set_int_z(actor->floorz);
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (66 << 8))
l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if ((actor->int_pos().Z - l) < (66 << 8))
{
actor->set_int_z(l + (66 << 8));
actor->spr.zvel >>= 1;
@ -3633,7 +3633,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
}
}
else if (actor->spr.picnum == APLAYER)
if ((actor->spr.pos.Z - actor->ceilingz) < (32 << 8))
if ((actor->int_pos().Z - actor->ceilingz) < (32 << 8))
actor->set_int_z(actor->ceilingz + (32 << 8));
daxvel = actor->spr.xvel;
@ -3645,7 +3645,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.pos.Y);
angdif = getangle(ps[playernum].pos.X - actor->int_pos().X, ps[playernum].pos.Y - actor->int_pos().Y);
if (xvel < 512)
{
@ -3662,7 +3662,7 @@ void move_d(DDukeActor *actor, int playernum, int xvel)
{
if (!*(moveptr + 1))
{
if (actor->opos.Z != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
if (actor->opos.Z != actor->int_pos().Z || (ud.multimode < 2 && ud.player_skill < 2))
{
if ((actor->temp_data[0] & 1) || ps[playernum].actorsqu == actor) return;
else daxvel <<= 1;

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

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

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

@ -225,16 +225,16 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
while (auto dasectp = search.GetNext())
{
if (((dasectp->ceilingz - actor->spr.pos.Z) >> 8) < r)
if (((dasectp->ceilingz - actor->int_pos().Z) >> 8) < r)
{
auto wal = dasectp->firstWall();
int d = abs(wal->wall_int_pos().X - actor->spr.pos.X) + abs(wal->wall_int_pos().Y - actor->spr.pos.Y);
int d = abs(wal->wall_int_pos().X - actor->int_pos().X) + abs(wal->wall_int_pos().Y - actor->int_pos().Y);
if (d < r)
fi.checkhitceiling(dasectp);
else
{
auto thirdpoint = wal->point2Wall()->point2Wall();
d = abs(thirdpoint->wall_int_pos().X - actor->spr.pos.X) + abs(thirdpoint->wall_int_pos().Y - actor->spr.pos.Y);
d = abs(thirdpoint->wall_int_pos().X - actor->int_pos().X) + abs(thirdpoint->wall_int_pos().Y - actor->int_pos().Y);
if (d < r)
fi.checkhitceiling(dasectp);
}
@ -242,18 +242,18 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
for (auto& wal : wallsofsector(dasectp))
{
if ((abs(wal.wall_int_pos().X - actor->spr.pos.X) + abs(wal.wall_int_pos().Y - actor->spr.pos.Y)) < r)
if ((abs(wal.wall_int_pos().X - actor->int_pos().X) + abs(wal.wall_int_pos().Y - actor->int_pos().Y)) < r)
{
if (wal.twoSided())
{
search.Add(wal.nextSector());
}
int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->spr.pos.X) >> 1;
int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->spr.pos.Y) >> 1;
int x1 = (((wal.wall_int_pos().X + wal.point2Wall()->wall_int_pos().X) >> 1) + actor->int_pos().X) >> 1;
int y1 = (((wal.wall_int_pos().Y + wal.point2Wall()->wall_int_pos().Y) >> 1) + actor->int_pos().Y) >> 1;
auto sect = wal.sectorp();
updatesector(x1, y1, &sect);
if (sect != nullptr && cansee(x1, y1, actor->spr.pos.Z, sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->sector()))
fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->spr.pos.Z, actor->spr.picnum);
if (sect != nullptr && cansee(x1, y1, actor->int_pos().Z, sect, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->sector()))
fi.checkhitwall(actor, &wal, wal.wall_int_pos().X, wal.wall_int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
}
}
}
@ -272,7 +272,7 @@ void hitradius_r(DDukeActor* actor, int r, int hp1, int hp2, int hp3, int h
if (act2->spr.cstat & CSTAT_SPRITE_BLOCK_ALL)
if (dist(actor, act2) < r)
{
if (badguy(act2) && !cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z + q, act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z + q, actor->sector()))
if (badguy(act2) && !cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z + q, act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z + q, actor->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->add_int_z(gs.playerheight);
if (d < r && cansee(act2->spr.pos.X, act2->spr.pos.Y, act2->spr.pos.Z - (8 << 8), act2->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (12 << 8), actor->sector()))
if (d < r && cansee(act2->int_pos().X, act2->int_pos().Y, act2->int_pos().Z - (8 << 8), act2->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (12 << 8), actor->sector()))
{
if ((isRRRA()) && act2->spr.picnum == MINION && act2->spr.pal == 19)
{
continue;
}
act2->hitang = getangle(act2->spr.pos.X - actor->spr.pos.X, act2->spr.pos.Y - actor->spr.pos.Y);
act2->hitang = getangle(act2->int_pos().X - actor->int_pos().X, act2->int_pos().Y - actor->int_pos().Y);
if (actor->spr.picnum == RPG && act2->spr.extra > 0)
act2->attackertype = RPG;
@ -372,13 +372,13 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
{
actor->add_int_pos({ (xchange * TICSPERFRAME) >> 2, (ychange * TICSPERFRAME) >> 2, (zchange * TICSPERFRAME) >> 2 });
if (bg)
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
return result.setNone();
}
auto dasectp = actor->sector();
vec3_t pos = actor->spr.pos;
vec3_t pos = actor->int_pos();
pos.Z -= ((tileHeight(actor->spr.picnum) * actor->spr.yrepeat) << 1);
if (bg)
@ -397,7 +397,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
actor->spr.ang = (krand() & 2047);
else if ((actor->temp_data[0] & 3) == 1)
actor->spr.ang = (krand() & 2047);
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
if (dasectp == nullptr) dasectp = &sector[0];
return result.setSector(dasectp);
}
@ -415,7 +415,7 @@ int movesprite_ex_r(DDukeActor* actor, int xchange, int ychange, int zchange, un
if (dasectp)
if ((dasectp != actor->sector()))
ChangeActorSect(actor, dasectp);
int daz = actor->spr.pos.Z + ((zchange * TICSPERFRAME) >> 3);
int daz = actor->int_pos().Z + ((zchange * TICSPERFRAME) >> 3);
if ((daz > actor->ceilingz) && (daz <= actor->floorz))
actor->set_int_z(daz);
else if (result.type == kHitNone)
@ -453,8 +453,8 @@ void guts_r(DDukeActor* actor, int gtype, int n, int p)
sx = sy = 8;
else sx = sy = 32;
gutz = actor->spr.pos.Z - (8 << 8);
floorz = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
gutz = actor->int_pos().Z - (8 << 8);
floorz = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if (gutz > (floorz - (8 << 8)))
gutz = floorz - (8 << 8);
@ -482,7 +482,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->sector(), actor->spr.pos.X + (r5 & 255) - 128, actor->spr.pos.Y + (r4 & 255) - 128, gutz - (r3 & 8191), gtype, -32, sx >> 1, sy >> 1, a, 48 + (r2 & 31), -512 - (r1 & 2047), ps[p].GetActor(), 5);
auto spawned = EGS(actor->sector(), actor->int_pos().X + (r5 & 255) - 128, actor->int_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;
}
@ -689,14 +689,14 @@ void movefallers_r(void)
x = gs.gravity;
}
if (act->spr.pos.Z < (sectp->floorz - FOURSLEIGHT))
if (act->int_pos().Z < (sectp->floorz - FOURSLEIGHT))
{
act->spr.zvel += x;
if (act->spr.zvel > 6144)
act->spr.zvel = 6144;
act->add_int_z(act->spr.zvel);
}
if ((sectp->floorz - act->spr.pos.Z) < (16 << 8))
if ((sectp->floorz - act->int_pos().Z) < (16 << 8))
{
int j = 1 + (krand() & 7);
for (x = 0; x < j; x++) RANDOMSCRAP(act);
@ -935,7 +935,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.pos.Y - actor->spr.pos.Y);
ang = getangle(ts->int_pos().X - actor->int_pos().X, ts->int_pos().Y - actor->int_pos().Y);
ang2 = ang - actor->spr.ang;
ang3 = abs(ang2);
if (ang2 < 100)
@ -1061,7 +1061,7 @@ static bool weaponhitwall(DDukeActor *proj, walltype* wal, const vec3_t& oldpos)
else
{
SetActor(proj, oldpos);
fi.checkhitwall(proj, wal, proj->spr.pos.X, proj->spr.pos.Y, proj->spr.pos.Z, proj->spr.picnum);
fi.checkhitwall(proj, wal, proj->int_pos().X, proj->int_pos().Y, proj->int_pos().Z, proj->spr.picnum);
if (!isRRRA() && proj->spr.picnum == FREEZEBLAST)
{
@ -1192,7 +1192,7 @@ static void weaponcommon_r(DDukeActor *proj)
ll = proj->spr.zvel;
}
auto oldpos = proj->spr.pos;
auto oldpos = proj->int_pos();
getglobalz(proj);
@ -1233,7 +1233,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.vec2 - proj->temp_actor->spr.pos.vec2) < 256)
if (FindDistance2D(proj->int_pos().vec2 - proj->temp_actor->int_pos().vec2) < 256)
coll.setSprite(proj->temp_actor);
if (!proj->insector()) // || (isRR() && proj->sector()->filler == 800))
@ -1244,13 +1244,13 @@ static void weaponcommon_r(DDukeActor *proj)
if (coll.type != kHitSprite && proj->spr.picnum != FREEZEBLAST)
{
if (proj->spr.pos.Z < proj->ceilingz)
if (proj->int_pos().Z < proj->ceilingz)
{
coll.setSector(proj->sector());
proj->spr.zvel = -1;
}
else
if (proj->spr.pos.Z > proj->floorz)
if (proj->int_pos().Z > proj->floorz)
{
coll.setSector(proj->sector());
if (proj->sector()->lotag != 1)
@ -1263,9 +1263,9 @@ static void weaponcommon_r(DDukeActor *proj)
for (k = -3; k < 2; k++)
{
auto x = EGS(proj->sector(),
proj->spr.pos.X + MulScale(k, bcos(proj->spr.ang), 9),
proj->spr.pos.Y + MulScale(k, bsin(proj->spr.ang), 9),
proj->spr.pos.Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
proj->int_pos().X + MulScale(k, bcos(proj->spr.ang), 9),
proj->int_pos().Y + MulScale(k, bsin(proj->spr.ang), 9),
proj->int_pos().Z + ((k * Sgn(proj->spr.zvel)) * abs(proj->spr.zvel / 24)), FIRELASER, -40 + (k << 2),
proj->spr.xrepeat, proj->spr.yrepeat, 0, 0, 0, proj->GetOwner(), 5);
if (x)
@ -1456,9 +1456,9 @@ void movetransports_r(void)
ps[p].transporter_hold = 13;
}
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->spr.pos.X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->spr.pos.Y;
ps[p].opos.Z = ps[p].pos.Z = Owner->spr.pos.Z - (gs.playerheight - (4 << 8));
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = Owner->int_pos().X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = Owner->int_pos().Y;
ps[p].opos.Z = ps[p].pos.Z = Owner->int_pos().Z - (gs.playerheight - (4 << 8));
ChangeActorSect(act2, Owner->sector());
ps[p].setCursector(act2->sector());
@ -1471,16 +1471,16 @@ void movetransports_r(void)
}
else break;
if (onfloorz == 0 && abs(act->spr.pos.Z - ps[p].pos.Z) < 6144)
if (onfloorz == 0 && abs(act->int_pos().Z - ps[p].pos.Z) < 6144)
if ((ps[p].jetpack_on == 0) || (ps[p].jetpack_on && PlayerInput(p, SB_JUMP)) ||
(ps[p].jetpack_on && PlayerInput(p, SB_CROUCH)))
{
ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
if (ps[p].jetpack_on && (PlayerInput(p, SB_JUMP) || ps[p].jetpack_on < 11))
ps[p].pos.Z = Owner->spr.pos.Z - 6144;
else ps[p].pos.Z = Owner->spr.pos.Z + 6144;
ps[p].pos.Z = Owner->int_pos().Z - 6144;
else ps[p].pos.Z = Owner->int_pos().Z + 6144;
ps[p].opos.Z = ps[p].pos.Z;
ChangeActorSect(act2, Owner->sector());
@ -1541,8 +1541,8 @@ void movetransports_r(void)
if (k == 1)
{
ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
if (Owner->GetOwner() != Owner)
ps[p].transporter_hold = -2;
@ -1555,8 +1555,8 @@ void movetransports_r(void)
}
else if (isRRRA() && k == 2)
{
ps[p].opos.X = ps[p].pos.X += Owner->spr.pos.X - act->spr.pos.X;
ps[p].opos.Y = ps[p].pos.Y += Owner->spr.pos.Y - act->spr.pos.Y;
ps[p].opos.X = ps[p].pos.X += Owner->int_pos().X - act->int_pos().X;
ps[p].opos.Y = ps[p].pos.Y += Owner->int_pos().Y - act->int_pos().Y;
if (Owner->GetOwner() != Owner)
ps[p].transporter_hold = -2;
@ -1587,38 +1587,38 @@ void movetransports_r(void)
{
warpspriteto = 0;
if (ll && sectlotag == ST_2_UNDERWATER && act2->spr.pos.Z < (sectp->ceilingz + ll))
if (ll && sectlotag == ST_2_UNDERWATER && act2->int_pos().Z < (sectp->ceilingz + ll))
warpspriteto = 1;
if (ll && sectlotag == ST_1_ABOVE_WATER && act2->spr.pos.Z > (sectp->floorz - ll))
if (ll && sectlotag == ST_1_ABOVE_WATER && act2->int_pos().Z > (sectp->floorz - ll))
if (!isRRRA() || (act2->spr.picnum != CHEERBOAT && act2->spr.picnum != HULKBOAT && act2->spr.picnum != MINIONBOAT))
warpspriteto = 1;
if (isRRRA())
{
if (ll && sectlotag == 161 && act2->spr.pos.Z < (sectp->ceilingz + ll) && warpdir == 1)
if (ll && sectlotag == 161 && act2->int_pos().Z < (sectp->ceilingz + ll) && warpdir == 1)
{
warpspriteto = 1;
ll2 = ll - abs(act2->spr.pos.Z - sectp->ceilingz);
ll2 = ll - abs(act2->int_pos().Z - sectp->ceilingz);
}
else if (sectlotag == 161 && act2->spr.pos.Z < (sectp->ceilingz + 1000) && warpdir == 1)
else if (sectlotag == 161 && act2->int_pos().Z < (sectp->ceilingz + 1000) && warpdir == 1)
{
warpspriteto = 1;
ll2 = 1;
}
if (ll && sectlotag == 160 && act2->spr.pos.Z > (sectp->floorz - ll) && warpdir == 2)
if (ll && sectlotag == 160 && act2->int_pos().Z > (sectp->floorz - ll) && warpdir == 2)
{
warpspriteto = 1;
ll2 = ll - abs(sectp->floorz - act2->spr.pos.Z);
ll2 = ll - abs(sectp->floorz - act2->int_pos().Z);
}
else if (sectlotag == 160 && act2->spr.pos.Z > (sectp->floorz - 1000) && warpdir == 2)
else if (sectlotag == 160 && act2->int_pos().Z > (sectp->floorz - 1000) && warpdir == 2)
{
warpspriteto = 1;
ll2 = 1;
}
}
if (sectlotag == 0 && (onfloorz || abs(act2->spr.pos.Z - act->spr.pos.Z) < 4096))
if (sectlotag == 0 && (onfloorz || abs(act2->int_pos().Z - act->int_pos().Z) < 4096))
{
if (Owner->GetOwner() != Owner && onfloorz && act->temp_data[0] > 0 && act2->spr.statnum != 5)
{
@ -1667,7 +1667,7 @@ void movetransports_r(void)
{
if (checkcursectnums(act->sector()) == -1 && checkcursectnums(Owner->sector()) == -1)
{
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), -(act->spr.pos.Z - Owner->sector()->floorz) });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), -(act->int_pos().Z - Owner->sector()->floorz) });
act2->spr.ang = Owner->spr.ang;
act2->backupang();
@ -1689,15 +1689,15 @@ void movetransports_r(void)
}
else
{
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->set_int_z(Owner->spr.pos.Z + 4096);
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->int_pos().Z + 4096);
act2->backupz();
ChangeActorSect(act2, Owner->sector());
}
break;
case ST_1_ABOVE_WATER:
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->sector()->ceilingz + ll);
act2->backupz();
@ -1705,7 +1705,7 @@ void movetransports_r(void)
break;
case ST_2_UNDERWATER:
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->sector()->floorz - ll);
act2->backupz();
@ -1715,7 +1715,7 @@ void movetransports_r(void)
case 160:
if (!isRRRA()) break;
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->sector()->ceilingz + ll2);
act2->backupz();
@ -1727,7 +1727,7 @@ void movetransports_r(void)
break;
case 161:
if (!isRRRA()) break;
act2->add_int_pos({ (Owner->spr.pos.X - act->spr.pos.X), (Owner->spr.pos.Y - act->spr.pos.Y), 0 });
act2->add_int_pos({ (Owner->int_pos().X - act->int_pos().X), (Owner->int_pos().Y - act->int_pos().Y), 0 });
act2->set_int_z(Owner->sector()->floorz - ll);
act2->backupz();
@ -1900,7 +1900,7 @@ static void rrra_specialstats()
act->spr.extra = 1;
}
movesprite_ex(act, 0, 0, -300, CLIPMASK0, coll);
if (act->sector()->ceilingz + (4 << 8) > act->spr.pos.Z)
if (act->sector()->ceilingz + (4 << 8) > act->int_pos().Z)
{
act->spr.picnum = 0;
act->spr.extra = 100;
@ -1908,7 +1908,7 @@ static void rrra_specialstats()
}
else if (act->spr.extra == 200)
{
SetActor(act, { act->spr.pos.X, act->spr.pos.Y, act->sector()->floorz - 10 });
SetActor(act, { act->int_pos().X, act->int_pos().Y, act->sector()->floorz - 10 });
act->spr.extra = 1;
act->spr.picnum = PIG + 11;
spawn(act, TRANSPORTERSTAR);
@ -2132,7 +2132,7 @@ void rr_specialstats()
if (act->spr.hitag == 100)
{
act->add_int_z(4 << 8);
if (act->spr.pos.Z >= act->sector()->floorz + 15168)
if (act->int_pos().Z >= act->sector()->floorz + 15168)
act->set_int_z(act->sector()->floorz + 15168);
}
@ -2285,9 +2285,9 @@ void rr_specialstats()
if (act2->spr.picnum == RRTILE297)
{
ps[p].angle.ang = buildang(act2->spr.ang);
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = act2->spr.pos.X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = act2->spr.pos.Y;
ps[p].opos.Z = ps[p].pos.Z = act2->spr.pos.Z - (36 << 8);
ps[p].bobpos.X = ps[p].opos.X = ps[p].pos.X = act2->int_pos().X;
ps[p].bobpos.Y = ps[p].opos.Y = ps[p].pos.Y = act2->int_pos().Y;
ps[p].opos.Z = ps[p].pos.Z = act2->int_pos().Z - (36 << 8);
auto pact = ps[p].GetActor();
ChangeActorSect(pact, act2->sector());
ps[p].setCursector(pact->sector());
@ -2344,7 +2344,7 @@ static void heavyhbomb(DDukeActor *actor)
makeitfall(actor);
if (sectp->lotag != 1 && (!isRRRA() || sectp->lotag != 160) && actor->spr.pos.Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
if (sectp->lotag != 1 && (!isRRRA() || sectp->lotag != 160) && actor->int_pos().Z >= actor->floorz - (FOURSLEIGHT) && actor->spr.yvel < 3)
{
if (actor->spr.yvel > 0 || (actor->spr.yvel == 0 && actor->floorz == sectp->floorz))
{
@ -2363,7 +2363,7 @@ static void heavyhbomb(DDukeActor *actor)
actor->spr.zvel >>= 2;
actor->spr.yvel++;
}
if (actor->spr.picnum != CHEERBOMB && actor->spr.pos.Z < actor->ceilingz + (16 << 8) && sectp->lotag != 2)
if (actor->spr.picnum != CHEERBOMB && actor->int_pos().Z < actor->ceilingz + (16 << 8) && sectp->lotag != 2)
{
actor->set_int_z(actor->ceilingz + (16 << 8));
actor->spr.zvel = 0;
@ -2424,7 +2424,7 @@ static void heavyhbomb(DDukeActor *actor)
if (coll.type == kHitWall)
{
auto wal = coll.hitWall;
fi.checkhitwall(actor, wal, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, actor->spr.picnum);
fi.checkhitwall(actor, wal, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, actor->spr.picnum);
int k = getangle(wal->delta());
@ -2490,7 +2490,7 @@ DETONATEB:
}
}
else if (actor->spr.picnum == HEAVYHBOMB && x < 788 && actor->temp_data[0] > 7 && actor->spr.xvel == 0)
if (cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (8 << 8), actor->sector(), ps[p].pos.X, ps[p].pos.Y, ps[p].pos.Z, ps[p].cursector))
if (ps[p].ammo_amount[DYNAMITE_WEAPON] < gs.max_ammo_amount[DYNAMITE_WEAPON])
if (actor->spr.pal == 0)
{
@ -2687,7 +2687,7 @@ void moveactors_r(void)
act->spr.picnum = RRTILE3192;
break;
case 903:
if (act->spr.pos.Z >= sectp->floorz - (8<<8))
if (act->int_pos().Z >= sectp->floorz - (8<<8))
{
deletesprite(act);
continue;
@ -2726,7 +2726,7 @@ void moveactors_r(void)
}
if (sectp->lotag == 903)
{
if (act->spr.pos.Z >= sectp->floorz - (4<<8))
if (act->int_pos().Z >= sectp->floorz - (4<<8))
{
deletesprite(act);
continue;
@ -2750,7 +2750,7 @@ void moveactors_r(void)
MulScale(act->spr.xvel, bcos(act->spr.ang), 14),
MulScale(act->spr.xvel, bsin(act->spr.ang), 14),
act->spr.zvel,CLIPMASK0, coll);
if (act->spr.pos.Z >= sectp->floorz - (8<<8))
if (act->int_pos().Z >= sectp->floorz - (8<<8))
{
if (sectp->lotag == 1)
{
@ -2831,7 +2831,7 @@ void moveactors_r(void)
getglobalz(act);
if (sectp->lotag == 1)
{
SetActor(act, { act->spr.pos.X,act->spr.pos.Y,act->floorz + (16 << 8) });
SetActor(act, { act->int_pos().X,act->int_pos().Y,act->floorz + (16 << 8) });
}
break;
@ -2924,7 +2924,7 @@ void moveexplosions_r(void) // STATNUM 5
{
case SHOTGUNSPRITE:
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3013,7 +3013,7 @@ void moveexplosions_r(void) // STATNUM 5
deletesprite(act);
continue;
case FEATHER + 1: // feather
act->floorz = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
act->floorz = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
act->set_int_z(act->floorz);
if (act->sector()->lotag == 800)
{
@ -3025,7 +3025,7 @@ void moveexplosions_r(void) // STATNUM 5
if (!money(act, BLOODPOOL)) continue;
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3080,7 +3080,7 @@ void moveexplosions_r(void) // STATNUM 5
isRRRA() && (act->spr.picnum == RRTILE2465 || act->spr.picnum == RRTILE2560))) continue;
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
continue;
@ -3092,7 +3092,7 @@ void moveexplosions_r(void) // STATNUM 5
if (!bloodpool(act, false)) continue;
if (act->sector()->lotag == 800)
if (act->spr.pos.Z >= act->sector()->floorz - (8 << 8))
if (act->int_pos().Z >= act->sector()->floorz - (8 << 8))
{
deletesprite(act);
}
@ -3168,7 +3168,7 @@ void handle_se06_r(DDukeActor *actor)
}
if (!hulkspawn)
{
ns = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
ns = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->sector()->ceilingz + 119428, 3677, -8, 16, 16, 0, 0, 0, actor, 5);
if (ns)
{
ns->spr.cstat = CSTAT_SPRITE_TRANS_FLIP | CSTAT_SPRITE_TRANSLUCENT;
@ -3397,7 +3397,7 @@ void moveeffectors_r(void) //STATNUM 3
case SE_29_WAVES:
act->spr.hitag += 64;
l = MulScale(act->spr.yvel, bsin(act->spr.hitag), 12);
sc->setfloorz(act->spr.pos.Z + l);
sc->setfloorz(act->int_pos().Z + l);
break;
case SE_31_FLOOR_RISE_FALL: // True Drop Floor
@ -3486,8 +3486,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a & face_player)
{
if (ps[pnum].newOwner != nullptr)
goalang = getangle(ps[pnum].opos.X - actor->spr.pos.X, ps[pnum].opos.Y - actor->spr.pos.Y);
else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
goalang = getangle(ps[pnum].opos.X - actor->int_pos().X, ps[pnum].opos.Y - actor->int_pos().Y);
else goalang = getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3499,8 +3499,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a & face_player_slow)
{
if (ps[pnum].newOwner != nullptr)
goalang = getangle(ps[pnum].opos.X - actor->spr.pos.X, ps[pnum].opos.Y - actor->spr.pos.Y);
else goalang = getangle(ps[pnum].pos.X - actor->spr.pos.X, ps[pnum].pos.Y - actor->spr.pos.Y);
goalang = getangle(ps[pnum].opos.X - actor->int_pos().X, ps[pnum].opos.Y - actor->int_pos().Y);
else goalang = getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y);
angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
@ -3515,8 +3515,8 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (a & antifaceplayerslow)
{
if (ps[pnum].newOwner != nullptr)
goalang = (getangle(ps[pnum].opos.X - actor->spr.pos.X, ps[pnum].opos.Y - 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;
goalang = (getangle(ps[pnum].opos.X - actor->int_pos().X, ps[pnum].opos.Y - actor->int_pos().Y) + 1024) & 2047;
else goalang = (getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y) + 1024) & 2047;
angdif = Sgn(getincangle(actor->spr.ang, goalang)) << 5;
if (angdif > -32 && angdif < 0)
{
@ -3584,7 +3584,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
newx = ps[pnum].pos.X + (ps[pnum].vel.X / 768);
newy = ps[pnum].pos.Y + (ps[pnum].vel.Y / 768);
goalang = getangle(newx - actor->spr.pos.X, newy - actor->spr.pos.Y);
goalang = getangle(newx - actor->int_pos().X, newy - actor->int_pos().Y);
angdif = getincangle(actor->spr.ang, goalang) >> 2;
if (angdif > -8 && angdif < 0) angdif = 0;
actor->spr.ang += angdif;
@ -3592,10 +3592,10 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
if (actor->temp_data[1] == 0 || a == 0)
{
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->spr.pos.X) || (actor->opos.Y != actor->spr.pos.Y))
if ((badguy(actor) && actor->spr.extra <= 0) || (actor->opos.X != actor->int_pos().X) || (actor->opos.Y != actor->int_pos().Y))
{
actor->backupvec2();
SetActor(actor, actor->spr.pos);
SetActor(actor, actor->int_pos());
}
if (badguy(actor) && actor->spr.extra <= 0)
{
@ -3641,34 +3641,34 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
{
if (actor->spr.zvel > 0)
{
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
actor->floorz = l = getflorzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if (isRRRA())
{
if (actor->spr.pos.Z > (l - (28 << 8)))
if (actor->int_pos().Z > (l - (28 << 8)))
actor->set_int_z(l - (28 << 8));
}
else
{
if (actor->spr.pos.Z > (l - (30 << 8)))
if (actor->int_pos().Z > (l - (30 << 8)))
actor->set_int_z(l - (30 << 8));
}
}
else
{
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (50 << 8))
actor->ceilingz = l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if ((actor->int_pos().Z - l) < (50 << 8))
{
actor->set_int_z(l + (50 << 8));
actor->spr.zvel = 0;
}
}
}
if (actor->spr.zvel > 0 && actor->floorz < actor->spr.pos.Z)
if (actor->spr.zvel > 0 && actor->floorz < actor->int_pos().Z)
actor->set_int_z(actor->floorz);
if (actor->spr.zvel < 0)
{
l = getceilzofslopeptr(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y);
if ((actor->spr.pos.Z - l) < (66 << 8))
l = getceilzofslopeptr(actor->sector(), actor->int_pos().X, actor->int_pos().Y);
if ((actor->int_pos().Z - l) < (66 << 8))
{
actor->set_int_z(l + (66 << 8));
actor->spr.zvel >>= 1;
@ -3676,7 +3676,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
}
}
else if (actor->spr.picnum == APLAYER)
if ((actor->spr.pos.Z - actor->ceilingz) < (32 << 8))
if ((actor->int_pos().Z - actor->ceilingz) < (32 << 8))
actor->set_int_z(actor->ceilingz + (32 << 8));
daxvel = actor->spr.xvel;
@ -3688,7 +3688,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.pos.Y);
angdif = getangle(ps[pnum].pos.X - actor->int_pos().X, ps[pnum].pos.Y - actor->int_pos().Y);
if (xvel < 512)
{
@ -3707,7 +3707,7 @@ void move_r(DDukeActor *actor, int pnum, int xvel)
{
if (!*(moveptr + 1))
{
if (actor->opos.Z != actor->spr.pos.Z || (ud.multimode < 2 && ud.player_skill < 2))
if (actor->opos.Z != actor->int_pos().Z || (ud.multimode < 2 && ud.player_skill < 2))
{
if ((actor->temp_data[0] & 1) || ps[pnum].actorsqu == actor) return;
else daxvel <<= 1;
@ -3818,7 +3818,7 @@ static int fallspecial(DDukeActor *actor, int playernum)
}
else if (actor->sector()->lotag == 802)
{
if (actor->spr.picnum != APLAYER && badguy(actor) && actor->spr.pos.Z == actor->floorz - FOURSLEIGHT)
if (actor->spr.picnum != APLAYER && badguy(actor) && actor->int_pos().Z == actor->floorz - FOURSLEIGHT)
{
fi.guts(actor, JIBS6, 5, playernum);
S_PlayActorSound(SQUISHED, actor);

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

@ -205,12 +205,12 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
{
int sqa =
getangle(
OwnerAc->spr.pos.X - ps[screenpeek].pos.X,
OwnerAc->spr.pos.Y - ps[screenpeek].pos.Y);
OwnerAc->int_pos().X - ps[screenpeek].pos.X,
OwnerAc->int_pos().Y - ps[screenpeek].pos.Y);
int sqb =
getangle(
OwnerAc->spr.pos.X - t->pos.X,
OwnerAc->spr.pos.Y - t->pos.Y);
OwnerAc->int_pos().X - t->pos.X,
OwnerAc->int_pos().Y - t->pos.Y);
if (abs(getincangle(sqa, sqb)) > 512)
if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@ -226,8 +226,8 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else
{
t->ang = getangle(x - t->pos.X, y - t->pos.Y);
t->pos.X = OwnerAc->spr.pos.X;
t->pos.Y = OwnerAc->spr.pos.Y;
t->pos.X = OwnerAc->int_pos().X;
t->pos.Y = OwnerAc->int_pos().Y;
t->pos.X += bcos(t->ang, -10);
t->pos.Y += bsin(t->ang, -10);
}
@ -268,7 +268,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
}
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -286,7 +286,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
}
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_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);
@ -358,7 +358,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (h->GetOwner())
newtspr->pos.Z = ps[p].pos.Z - (12 << 8);
else newtspr->pos.Z = h->spr.pos.Z - (51 << 8);
else newtspr->pos.Z = h->int_pos().Z - (51 << 8);
if (ps[p].curr_weapon == HANDBOMB_WEAPON)
{
newtspr->xrepeat = 10;
@ -391,7 +391,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
}
if (t->sectp->lotag == 2) k += 1795 - 1405;
else if ((h->floorz - h->spr.pos.Z) > (64 << 8)) k += 60;
else if ((h->floorz - h->int_pos().Z) > (64 << 8)) k += 60;
t->picnum += k;
t->pal = ps[p].palookup;
@ -401,7 +401,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (ps[p].on_crane == nullptr && (h->sector()->lotag & 0x7ff) != 1)
{
l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
l = h->int_pos().Z - ps[p].GetActor()->floorz + (3 << 8);
if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
h->spr.yoffset = (int8_t)(l / (h->spr.yrepeat << 2));
else h->spr.yoffset = 0;
@ -519,7 +519,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
case 5:
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -529,7 +529,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else t->cstat &= ~CSTAT_SPRITE_XFLIP;
break;
case 7:
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -578,7 +578,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
daz = h->floorz;
if ((h->spr.pos.Z - daz) < (8 << 8) && ps[screenpeek].pos.Z < daz)
if ((h->int_pos().Z - daz) < (8 << 8) && ps[screenpeek].pos.Z < daz)
{
auto shadowspr = tsprites.newTSprite();
*shadowspr = *t;
@ -625,7 +625,7 @@ void animatesprites_d(tspriteArray& tsprites, int x, int y, int a, int smoothrat
case LASERLINE:
if (!OwnerAc) break;
if (t->sectp->lotag == 2) t->pal = 8;
t->pos.Z = OwnerAc->spr.pos.Z - (3 << 8);
t->pos.Z = OwnerAc->int_pos().Z - (3 << 8);
if (gs.lasermode == 2 && ps[screenpeek].heat_on == 0)
t->yrepeat = 0;
t->shade = -127;

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

@ -200,12 +200,12 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
{
int sqa =
getangle(
OwnerAc->spr.pos.X - ps[screenpeek].pos.X,
OwnerAc->spr.pos.Y - ps[screenpeek].pos.Y);
OwnerAc->int_pos().X - ps[screenpeek].pos.X,
OwnerAc->int_pos().Y - ps[screenpeek].pos.Y);
int sqb =
getangle(
OwnerAc->spr.pos.X - t->pos.X,
OwnerAc->spr.pos.Y - t->pos.Y);
OwnerAc->int_pos().X - t->pos.X,
OwnerAc->int_pos().Y - t->pos.Y);
if (abs(getincangle(sqa, sqb)) > 512)
if (ldist(OwnerAc, t) < ldist(ps[screenpeek].GetActor(), OwnerAc))
@ -220,8 +220,8 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else
{
t->ang = getangle(x - t->pos.X, y - t->pos.Y);
t->pos.X = OwnerAc->spr.pos.X;
t->pos.Y = OwnerAc->spr.pos.Y;
t->pos.X = OwnerAc->int_pos().X;
t->pos.Y = OwnerAc->int_pos().Y;
t->pos.X += bcos(t->ang, -10);
t->pos.Y += bsin(t->ang, -10);
}
@ -262,7 +262,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
}
else if (OwnerAc->spr.picnum == MAMA)
{
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -280,7 +280,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
case EMPTYBIKE:
if (!isRRRA()) goto default_case;
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -292,7 +292,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
case EMPTYBOAT:
if (!isRRRA()) goto default_case;
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -303,7 +303,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
t->picnum = EMPTYBOAT + k;
break;
case RPG:
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -315,7 +315,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
case RPG2:
if (!isRRRA()) goto default_case;
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -328,7 +328,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
case RECON:
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_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);
@ -398,7 +398,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (h->GetOwner())
newtspr->pos.Z = ps[p].pos.Z - (12 << 8);
else newtspr->pos.Z = h->spr.pos.Z - (51 << 8);
else newtspr->pos.Z = h->int_pos().Z - (51 << 8);
if (ps[p].curr_weapon == HANDBOMB_WEAPON)
{
newtspr->xrepeat = 10;
@ -435,7 +435,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
}
if (t->sectp->lotag == 2) k += 1795 - 1405;
else if ((h->floorz - h->spr.pos.Z) > (64 << 8)) k += 60;
else if ((h->floorz - h->int_pos().Z) > (64 << 8)) k += 60;
t->picnum += k;
t->pal = ps[p].palookup;
@ -445,7 +445,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
if (ps[p].on_crane == nullptr && (h->sector()->lotag & 0x7ff) != 1)
{
l = h->spr.pos.Z - ps[p].GetActor()->floorz + (3 << 8);
l = h->int_pos().Z - ps[p].GetActor()->floorz + (3 << 8);
if (l > 1024 && h->spr.yrepeat > 32 && h->spr.extra > 0)
h->spr.yoffset = (int8_t)(l / (h->spr.yrepeat << 2));
else h->spr.yoffset = 0;
@ -651,7 +651,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
break;
case 5:
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -661,7 +661,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else t->cstat &= ~CSTAT_SPRITE_XFLIP;
break;
case 7:
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) / 170);
if (k > 6)
{
@ -678,7 +678,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
bg = badguy(h);
if (bg && h->spr.statnum == 2 && h->spr.extra > 0)
{
k = getangle(h->spr.pos.X - x, h->spr.pos.Y - y);
k = getangle(h->int_pos().X - x, h->int_pos().Y - y);
k = (((h->spr.ang + 3072 + 128 - k) & 2047) >> 8) & 7;
if (k > 4)
{
@ -733,7 +733,7 @@ void animatesprites_r(tspriteArray& tsprites, int x, int y, int a, int smoothrat
else
daz = h->floorz;
if ((h->spr.pos.Z - daz) < (8 << 8))
if ((h->int_pos().Z - daz) < (8 << 8))
if (ps[screenpeek].pos.Z < daz)
{
auto shadowspr = tsprites.newTSprite();

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

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

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

@ -1172,16 +1172,16 @@ void DoActor(bool bSet, int lVar1, int lLabelID, int lVar2, DDukeActor* sActor,
switch (lLabelID)
{
case ACTOR_X:
/*if (bSet) act->spr.pos.X = lValue;
else*/ SetGameVarID(lVar2, act->spr.pos.X, sActor, sPlayer);
/*if (bSet) act->int_pos().X = lValue;
else*/ SetGameVarID(lVar2, act->int_pos().X, sActor, sPlayer);
break;
case ACTOR_Y:
/*if (bSet) act->spr.pos.Y = lValue;
else*/ SetGameVarID(lVar2, act->spr.pos.Y, sActor, sPlayer);
/*if (bSet) act->int_pos().Y = lValue;
else*/ SetGameVarID(lVar2, act->int_pos().Y, sActor, sPlayer);
break;
case ACTOR_Z:
/*if (bSet) act->spr.pos.Z = lValue;
else*/ SetGameVarID(lVar2, act->spr.pos.Z, sActor, sPlayer);
/*if (bSet) act->int_pos().Z = lValue;
else*/ SetGameVarID(lVar2, act->int_pos().Z, sActor, sPlayer);
break;
case ACTOR_CSTAT:
if (bSet) act->spr.cstat = ESpriteFlags::FromInt(lValue);
@ -1471,7 +1471,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
if (ps[pnum].holoduke_on != nullptr && !isRR())
{
tosee = ps[pnum].holoduke_on;
j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((32 << 8) - 1)), actor->sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z, tosee->sector());
j = cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & ((32 << 8) - 1)), actor->sector(), tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().Z, tosee->sector());
if (j == 0)
{
@ -1483,7 +1483,7 @@ static bool ifcansee(DDukeActor* actor, int pnum)
else tosee = ps[pnum].GetActor(); // holoduke not on. look for player
// can they see player, (or player's holoduke)
j = cansee(actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & ((47 << 8))), actor->sector(), tosee->spr.pos.X, tosee->spr.pos.Y, tosee->spr.pos.Z - ((isRR()? 28 : 24) << 8), tosee->sector());
j = cansee(actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & ((47 << 8))), actor->sector(), tosee->int_pos().X, tosee->int_pos().Y, tosee->int_pos().Z - ((isRR()? 28 : 24) << 8), tosee->sector());
if (j == 0)
{
@ -1495,8 +1495,8 @@ static bool ifcansee(DDukeActor* actor, int pnum)
{
// else, they did see it.
// save where we were looking..
actor->ovel.X = tosee->spr.pos.X;
actor->ovel.Y = tosee->spr.pos.Y;
actor->ovel.X = tosee->int_pos().X;
actor->ovel.Y = tosee->int_pos().Y;
}
if (j == 1 && (actor->spr.statnum == STAT_ACTOR || actor->spr.statnum == STAT_STANDABLE))
@ -1534,12 +1534,12 @@ int ParseState::parse(void)
parseifelse(ifcanshoottarget(g_ac, g_p, g_x));
break;
case concmd_ifcanseetarget:
j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - ((krand() & 41) << 8), g_ac->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->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z - ((krand() & 41) << 8), g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z/*-((krand()&41)<<8)*/, ps[g_p].GetActor()->sector());
parseifelse(j);
if (j) g_ac->timetosleep = SLEEPTIME;
break;
case concmd_ifnocover:
j = cansee(g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z, g_ac->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->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z, g_ac->sector(), ps[g_p].pos.X, ps[g_p].pos.Y, ps[g_p].pos.Z, ps[g_p].GetActor()->sector());
parseifelse(j);
if (j) g_ac->timetosleep = SLEEPTIME;
break;
@ -2183,7 +2183,7 @@ int ParseState::parse(void)
else s = (krand()%3);
auto spawned = EGS(g_ac->sector(),
g_ac->spr.pos.X + (krand() & 255) - 128, g_ac->spr.pos.Y + (krand() & 255) - 128, g_ac->spr.pos.Z - (8 << 8) - (krand() & 8191),
g_ac->int_pos().X + (krand() & 255) - 128, g_ac->int_pos().Y + (krand() & 255) - 128, g_ac->int_pos().Z - (8 << 8) - (krand() & 8191),
dnum + s, g_ac->spr.shade, 32 + (krand() & 15), 32 + (krand() & 15),
krand() & 2047, (krand() & 127) + 32, -(krand() & 2047), g_ac, 5);
if (spawned)
@ -2290,10 +2290,10 @@ int ParseState::parse(void)
parseifelse(ud.coop || numplayers > 2);
break;
case concmd_ifonmud:
parseifelse(abs(g_ac->spr.pos.Z - g_ac->sector()->floorz) < (32 << 8) && g_ac->sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
parseifelse(abs(g_ac->int_pos().Z - g_ac->sector()->floorz) < (32 << 8) && g_ac->sector()->floorpicnum == 3073); // eew, hard coded tile numbers.. :?
break;
case concmd_ifonwater:
parseifelse( abs(g_ac->spr.pos.Z-g_ac->sector()->floorz) < (32<<8) && g_ac->sector()->lotag == ST_1_ABOVE_WATER);
parseifelse( abs(g_ac->int_pos().Z-g_ac->sector()->floorz) < (32<<8) && g_ac->sector()->lotag == ST_1_ABOVE_WATER);
break;
case concmd_ifmotofast:
parseifelse(ps[g_p].MotoSpeed > 60);
@ -2415,7 +2415,7 @@ int ParseState::parse(void)
j = 1;
else if( (l& prunning) && s >= 8 && PlayerInput(g_p, SB_RUN) )
j = 1;
else if( (l& phigher) && ps[g_p].pos.Z < (g_ac->spr.pos.Z-(48<<8)) )
else if( (l& phigher) && ps[g_p].pos.Z < (g_ac->int_pos().Z-(48<<8)) )
j = 1;
else if( (l& pwalkingback) && s <= -8 && !(PlayerInput(g_p, SB_RUN)) )
j = 1;
@ -2440,7 +2440,7 @@ int ParseState::parse(void)
if (g_ac->isPlayer() && 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.pos.Y - ps[g_p].pos.Y));
j = getincangle(ps[g_p].angle.ang.asbuild(), getangle(g_ac->int_pos().X - ps[g_p].pos.X, g_ac->int_pos().Y - ps[g_p].pos.Y));
if( j > -128 && j < 128 )
j = 1;
@ -2497,7 +2497,7 @@ int ParseState::parse(void)
if( g_ac->sector()->lotag == 0 )
{
HitInfo hit{};
neartag({ g_ac->spr.pos.X, g_ac->spr.pos.Y, g_ac->spr.pos.Z - (32 << 8) }, g_ac->sector(), g_ac->spr.ang, hit, 768, 1);
neartag({ g_ac->int_pos().X, g_ac->int_pos().Y, g_ac->int_pos().Z - (32 << 8) }, g_ac->sector(), g_ac->spr.ang, hit, 768, 1);
auto sectp = hit.hitSector;
if (sectp)
{
@ -2549,11 +2549,11 @@ int ParseState::parse(void)
break;
case concmd_iffloordistl:
insptr++;
parseifelse( (g_ac->floorz - g_ac->spr.pos.Z) <= ((*insptr)<<8));
parseifelse( (g_ac->floorz - g_ac->int_pos().Z) <= ((*insptr)<<8));
break;
case concmd_ifceilingdistl:
insptr++;
parseifelse( ( g_ac->spr.pos.Z - g_ac->ceilingz ) <= ((*insptr)<<8));
parseifelse( ( g_ac->int_pos().Z - g_ac->ceilingz ) <= ((*insptr)<<8));
break;
case concmd_palfrom:
insptr++;
@ -2804,7 +2804,7 @@ int ParseState::parse(void)
case concmd_pstomp:
insptr++;
if( ps[g_p].knee_incs == 0 && ps[g_p].GetActor()->spr.xrepeat >= (isRR()? 9: 40) )
if( cansee(g_ac->spr.pos.X,g_ac->spr.pos.Y,g_ac->spr.pos.Z-(4<<8),g_ac->sector(),ps[g_p].pos.X,ps[g_p].pos.Y,ps[g_p].pos.Z+(16<<8),ps[g_p].GetActor()->sector()) )
if( cansee(g_ac->int_pos().X,g_ac->int_pos().Y,g_ac->int_pos().Z-(4<<8),g_ac->sector(),ps[g_p].pos.X,ps[g_p].pos.Y,ps[g_p].pos.Z+(16<<8),ps[g_p].GetActor()->sector()) )
{
ps[g_p].knee_incs = 1;
if(ps[g_p].weapon_pos == 0)
@ -2818,16 +2818,16 @@ int ParseState::parse(void)
j = 0;
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y + 108, &s1);
updatesector(g_ac->int_pos().X + 108, g_ac->int_pos().Y + 108, &s1);
if (s1 == g_ac->sector())
{
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y - 108, &s1);
updatesector(g_ac->int_pos().X - 108, g_ac->int_pos().Y - 108, &s1);
if (s1 == g_ac->sector())
{
updatesector(g_ac->spr.pos.X + 108, g_ac->spr.pos.Y - 108, &s1);
updatesector(g_ac->int_pos().X + 108, g_ac->int_pos().Y - 108, &s1);
if (s1 == g_ac->sector())
{
updatesector(g_ac->spr.pos.X - 108, g_ac->spr.pos.Y + 108, &s1);
updatesector(g_ac->int_pos().X - 108, g_ac->int_pos().Y + 108, &s1);
if (s1 == g_ac->sector())
j = 1;
}
@ -3142,7 +3142,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->ovel.X - g_ac->spr.pos.X, g_ac->ovel.Y - g_ac->spr.pos.Y);
ang = getangle(g_ac->ovel.X - g_ac->int_pos().X, g_ac->ovel.Y - g_ac->int_pos().Y);
SetGameVarID(i, ang, g_ac, g_p);
break;
}

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

@ -97,24 +97,24 @@ inline int checkcursectnums(sectortype* se)
inline int ldist(DDukeActor* s1, DDukeActor* s2)
{
int vx, vy;
vx = s1->spr.pos.X - s2->spr.pos.X;
vy = s1->spr.pos.Y - s2->spr.pos.Y;
vx = s1->int_pos().X - s2->int_pos().X;
vy = s1->int_pos().Y - s2->int_pos().Y;
return(FindDistance2D(vx, vy) + 1);
}
inline int ldist(const DDukeActor* s1, const tspritetype* s2)
{
int vx, vy;
vx = s1->spr.pos.X - s2->pos.X;
vy = s1->spr.pos.Y - s2->pos.Y;
vx = s1->int_pos().X - s2->pos.X;
vy = s1->int_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.pos.Y - s2->spr.pos.Y;
vz = s1->spr.pos.Z - s2->spr.pos.Z;
vx = s1->int_pos().X - s2->int_pos().X;
vy = s1->int_pos().Y - s2->int_pos().Y;
vz = s1->int_pos().Z - s2->int_pos().Z;
return(FindDistance3D(vx, vy, vz));
}

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

@ -52,8 +52,8 @@ 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.pos.Y && p->noise.Y + radius > actor->spr.pos.Y)
if (p->noise.X - radius < actor->int_pos().X && p->noise.X + radius > actor->int_pos().X
&& p->noise.Y - radius < actor->int_pos().Y && p->noise.Y + radius > actor->int_pos().Y)
return 1;
return 0;
}

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

@ -174,9 +174,9 @@ int hits(DDukeActor* actor)
if (actor->isPlayer()) zoff = isRR() ? PHEIGHT_RR : PHEIGHT_DUKE;
else zoff = 0;
auto pos = actor->spr.pos;
auto pos = actor->int_pos();
hitscan(pos.withZOffset(-zoff), actor->sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
return (FindDistance2D(hit.hitpos.vec2 - actor->spr.pos.vec2));
return (FindDistance2D(hit.hitpos.vec2 - actor->int_pos().vec2));
}
//---------------------------------------------------------------------------
@ -195,14 +195,14 @@ int hitasprite(DDukeActor* actor, DDukeActor** hitsp)
else if (actor->spr.picnum == TILE_APLAYER) zoff = isRR() ? PHEIGHT_RR : PHEIGHT_DUKE;
else zoff = 0;
auto pos = actor->spr.pos;
auto pos = actor->int_pos();
hitscan(pos.withZOffset(-zoff), actor->sector(), { bcos(actor->spr.ang), bsin(actor->spr.ang), 0 }, hit, CLIPMASK1);
if (hitsp) *hitsp = hit.actor();
if (hit.hitWall != nullptr && (hit.hitWall->cstat & CSTAT_WALL_MASKED) && badguy(actor))
return((1 << 30));
return (FindDistance2D(hit.hitpos.vec2 - actor->spr.pos.vec2));
return (FindDistance2D(hit.hitpos.vec2 - actor->int_pos().vec2));
}
//---------------------------------------------------------------------------
@ -335,8 +335,8 @@ DDukeActor* aim(DDukeActor* actor, int aang)
if (gotfreezer && act->spr.pal == 1) continue;
}
xv = (act->spr.pos.X - actor->spr.pos.X);
yv = (act->spr.pos.Y - actor->spr.pos.Y);
xv = (act->int_pos().X - actor->int_pos().X);
yv = (act->int_pos().Y - actor->int_pos().Y);
if ((dy1 * xv) <= (dx1 * yv))
if ((dy2 * xv) >= (dx2 * yv))
@ -345,10 +345,10 @@ DDukeActor* aim(DDukeActor* actor, int aang)
if (sdist > 512 && sdist < smax)
{
if (actor->isPlayer())
a = (abs(Scale(act->spr.pos.Z - actor->spr.pos.Z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
a = (abs(Scale(act->int_pos().Z - actor->int_pos().Z, 10, sdist) - ps[actor->spr.yvel].horizon.sum().asbuild()) < 100);
else a = 1;
cans = cansee(act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (32 << 8), actor->sector());
cans = cansee(act->int_pos().X, act->int_pos().Y, act->int_pos().Z - (32 << 8) + gs.actorinfo[act->spr.picnum].aimoffset, act->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (32 << 8), actor->sector());
if (a && cans)
{
@ -507,8 +507,8 @@ void footprints(int snum)
while (auto act = it.Next())
{
if (act->spr.picnum == TILE_FOOTPRINTS || act->spr.picnum == TILE_FOOTPRINTS2 || act->spr.picnum == TILE_FOOTPRINTS3 || act->spr.picnum == TILE_FOOTPRINTS4)
if (abs(act->spr.pos.X - p->pos.X) < 384)
if (abs(act->spr.pos.Y - p->pos.Y) < 384)
if (abs(act->int_pos().X - p->pos.X) < 384)
if (abs(act->int_pos().Y - p->pos.Y) < 384)
{
j = 1;
break;
@ -1059,7 +1059,7 @@ void shootbloodsplat(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
spawned->set_int_pos(hit.hitpos);
spawned->spr.cstat |= randomXFlip();
ssp(spawned, CLIPMASK0);
SetActor(spawned, spawned->spr.pos);
SetActor(spawned, spawned->int_pos());
if (actor->spr.picnum == OOZFILTER || actor->spr.picnum == NEWBEAST)
spawned->spr.pal = 6;
}

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

@ -241,8 +241,8 @@ 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.pos.Z - sz) << 8) / (x + 1);
sa = getangle(pactor->spr.pos.X - sx, pactor->spr.pos.Y - sy);
zvel = ((pactor->int_pos().Z - sz) << 8) / (x + 1);
sa = getangle(pactor->int_pos().X - sx, pactor->int_pos().Y - sy);
}
hitscan({ sx, sy, sz }, sectp, { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
@ -346,8 +346,8 @@ static void shootweapon(DDukeActor *actor, int p, int sx, int sy, int sz, int sa
dal -= (8 << 8);
break;
}
zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
if (isWW2GI())
@ -592,8 +592,8 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else
zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@ -690,9 +690,9 @@ static void shootrpg(DDukeActor *actor, int p, int sx, int sy, int sz, int sa, i
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
if (aimed->spr.picnum != RECON)
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 81, 16);
if (atwith == RPG)
@ -930,8 +930,8 @@ static void shootgrowspark(DDukeActor* actor, int p, int sx, int sy, int sz, int
dal -= (8 << 8);
break;
}
zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal) << 8) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else
{
@ -1027,9 +1027,9 @@ void shoot_d(DDukeActor* actor, int atwith)
else
{
sa = actor->spr.ang;
sx = actor->spr.pos.X;
sy = actor->spr.pos.Y;
sz = actor->spr.pos.Z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
sx = actor->int_pos().X;
sy = actor->int_pos().Y;
sz = actor->int_pos().Z - (actor->spr.yrepeat * tileHeight(actor->spr.picnum) << 1) + (4 << 8);
if (actor->spr.picnum != ROTATEGUN)
{
sz -= (7 << 8);
@ -1139,8 +1139,8 @@ void shoot_d(DDukeActor* actor, int atwith)
if (aimed)
{
dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1);
zvel = ((aimed->spr.pos.Z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal - (4 << 8)) * 768) / (ldist(ps[p].GetActor(), aimed));
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
}
@ -2026,7 +2026,7 @@ int operateTripbomb(int snum)
while ((act = it.Next()))
{
if (!actorflag(act, SFLAG_BLOCK_TRIPBOMB) &&
abs(act->spr.pos.Z - hit.hitpos.Z) < (12 << 8) && ((act->spr.pos.X - hit.hitpos.X) * (act->spr.pos.X - hit.hitpos.X) + (act->spr.pos.Y - hit.hitpos.Y) * (act->spr.pos.Y - hit.hitpos.Y)) < (290 * 290))
abs(act->int_pos().Z - hit.hitpos.Z) < (12 << 8) && ((act->int_pos().X - hit.hitpos.X) * (act->int_pos().X - hit.hitpos.X) + (act->int_pos().Y - hit.hitpos.Y) * (act->int_pos().Y - hit.hitpos.Y)) < (290 * 290))
return 0;
}
@ -2773,9 +2773,9 @@ void processinput_d(int snum)
p->footprintcount = 0;
p->spritebridge = 1;
}
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.pos.Z - clz.actor()->spr.pos.Z) < (84 << 8))
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->int_pos().Z - clz.actor()->int_pos().Z) < (84 << 8))
{
j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
j = getangle(clz.actor()->int_pos().X - p->pos.X, clz.actor()->int_pos().Y - p->pos.Y);
p->vel.X -= bcos(j, 4);
p->vel.Y -= bsin(j, 4);
}

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

@ -99,8 +99,8 @@ 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.pos.Z - sz) << 8) / (x + 1);
sa = getangle(pspr->spr.pos.X - sx, pspr->spr.pos.Y - sy);
zvel = ((pspr->int_pos().Z - sz) << 8) / (x + 1);
sa = getangle(pspr->int_pos().X - sx, pspr->int_pos().Y - sy);
}
hitscan({ sx, sy, sz }, sectp, { bcos(sa), bsin(sa), zvel << 6 }, hit, CLIPMASK1);
@ -115,8 +115,8 @@ static void shootmelee(DDukeActor *actor, int p, int sx, int sy, int sz, int sa,
&& effector->spr.lotag == SE_7_TELEPORT)
{
int nx, ny, nz;
nx = hit.hitpos.X + (effector->GetOwner()->spr.pos.X - effector->spr.pos.X);
ny = hit.hitpos.Y + (effector->GetOwner()->spr.pos.Y - effector->spr.pos.Y);
nx = hit.hitpos.X + (effector->GetOwner()->int_pos().X - effector->int_pos().X);
ny = hit.hitpos.Y + (effector->GetOwner()->int_pos().Y - effector->int_pos().Y);
if (hit.hitSector->lotag == 161)
{
nz = effector->GetOwner()->sector()->floorz;
@ -215,8 +215,8 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (5 << 8);
zvel = ((aimed->spr.pos.Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal) << 8) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
if (atwith == SHOTSPARK1)
@ -270,8 +270,8 @@ static void shootweapon(DDukeActor* actor, int p, int sx, int sy, int sz, int sa
&& effector->spr.lotag == SE_7_TELEPORT)
{
int nx, ny, nz;
nx = hit.hitpos.X + (effector->GetOwner()->spr.pos.X - effector->spr.pos.X);
ny = hit.hitpos.Y + (effector->GetOwner()->spr.pos.Y - effector->spr.pos.Y);
nx = hit.hitpos.X + (effector->GetOwner()->int_pos().X - effector->int_pos().X);
ny = hit.hitpos.Y + (effector->GetOwner()->int_pos().Y - effector->int_pos().Y);
if (hit.hitSector->lotag == 161)
{
nz = effector->GetOwner()->sector()->floorz;
@ -509,8 +509,8 @@ static void shootstuff(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else
{
@ -624,9 +624,9 @@ static void shootrpg(DDukeActor* actor, int p, int sx, int sy, int sz, int sa, i
act90 = aimed;
}
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) + (8 << 8);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
if (aimed->spr.picnum != RECON)
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else zvel = -MulScale(ps[p].horizon.sum().asq16(), 81, 16);
if (atwith == RPG)
@ -776,8 +776,8 @@ static void shootwhip(DDukeActor* actor, int p, int sx, int sy, int sz, int sa,
if (aimed)
{
int dal = ((aimed->spr.xrepeat * tileHeight(aimed->spr.picnum)) << 1) - (12 << 8);
zvel = ((aimed->spr.pos.Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->spr.pos.X - sx, aimed->spr.pos.Y - sy);
zvel = ((aimed->int_pos().Z - sz - dal) * vel) / ldist(ps[p].GetActor(), aimed);
sa = getangle(aimed->int_pos().X - sx, aimed->int_pos().Y - sy);
}
else
zvel = -MulScale(ps[p].horizon.sum().asq16(), 98, 16);
@ -846,9 +846,9 @@ void shoot_r(DDukeActor* actor, int atwith)
{
p = -1;
sa = actor->spr.ang;
sx = actor->spr.pos.X;
sy = actor->spr.pos.Y;
sz = actor->spr.pos.Z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
sx = actor->int_pos().X;
sy = actor->int_pos().Y;
sz = actor->int_pos().Z - ((actor->spr.yrepeat * tileHeight(actor->spr.picnum)) << 1) + (4 << 8);
sz -= (7 << 8);
if (badguy(actor))
{
@ -3380,7 +3380,7 @@ void processinput_r(int snum)
while (auto act2 = it.Next())
{
if (act2->spr.picnum == RRTILE380)
if (act2->spr.pos.Z - (8 << 8) < p->pos.Z)
if (act2->int_pos().Z - (8 << 8) < p->pos.Z)
psectlotag = 2;
}
}
@ -3473,9 +3473,9 @@ void processinput_r(int snum)
{
doVehicleHit();
}
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->spr.pos.Z - clz.actor()->spr.pos.Z) < (84 << 8))
else if (badguy(clz.actor()) && clz.actor()->spr.xrepeat > 24 && abs(pact->int_pos().Z - clz.actor()->int_pos().Z) < (84 << 8))
{
int j = getangle(clz.actor()->spr.pos.X - p->pos.X, clz.actor()->spr.pos.Y - p->pos.Y);
int j = getangle(clz.actor()->int_pos().X - p->pos.X, clz.actor()->int_pos().Y - p->pos.Y);
p->vel.X -= bcos(j, 4);
p->vel.Y -= bsin(j, 4);
}
@ -3486,9 +3486,9 @@ void processinput_r(int snum)
p->stairs = 10;
if ((actions & SB_CROUCH) && !p->OnMotorcycle)
{
cz = clz.actor()->spr.pos.Z;
cz = clz.actor()->int_pos().Z;
chz.setNone();
fz = clz.actor()->spr.pos.Z + (4 << 8);
fz = clz.actor()->int_pos().Z + (4 << 8);
}
}
else
@ -4047,8 +4047,8 @@ void OnMotorcycle(struct player_struct *p, DDukeActor* motosprite)
{
if (motosprite)
{
p->pos.X = motosprite->spr.pos.X;
p->pos.Y = motosprite->spr.pos.Y;
p->pos.X = motosprite->int_pos().X;
p->pos.Y = motosprite->int_pos().Y;
p->angle.ang = buildang(motosprite->spr.ang);
p->ammo_amount[MOTORCYCLE_WEAPON] = motosprite->saved_ammo;
deletesprite(motosprite);
@ -4127,8 +4127,8 @@ void OnBoat(struct player_struct *p, DDukeActor* boat)
{
if (boat)
{
p->pos.X = boat->spr.pos.X;
p->pos.Y = boat->spr.pos.Y;
p->pos.X = boat->int_pos().X;
p->pos.Y = boat->int_pos().Y;
p->angle.ang = buildang(boat->spr.ang);
p->ammo_amount[BOAT_WEAPON] = boat->saved_ammo;
deletesprite(boat);

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

@ -615,9 +615,9 @@ void resetpspritevars(int g)
firsty = ps[0].pos.Y;
}
po[numplayersprites].opos.X = act->spr.pos.X;
po[numplayersprites].opos.Y = act->spr.pos.Y;
po[numplayersprites].opos.Z = act->spr.pos.Z;
po[numplayersprites].opos.X = act->int_pos().X;
po[numplayersprites].opos.Y = act->int_pos().Y;
po[numplayersprites].opos.Z = act->int_pos().Z;
po[numplayersprites].oa = act->spr.ang;
po[numplayersprites].os = act->sector();
@ -659,13 +659,13 @@ void resetpspritevars(int g)
ps[j].frag_ps = j;
act->SetOwner(act);
ps[j].bobpos.X = ps[j].opos.X = ps[j].pos.X = act->spr.pos.X;
ps[j].bobpos.Y = ps[j].opos.Y = ps[j].pos.Y = act->spr.pos.Y;
ps[j].opos.Z = ps[j].pos.Z = act->spr.pos.Z;
ps[j].bobpos.X = ps[j].opos.X = ps[j].pos.X = act->int_pos().X;
ps[j].bobpos.Y = ps[j].opos.Y = ps[j].pos.Y = act->int_pos().Y;
ps[j].opos.Z = ps[j].pos.Z = act->int_pos().Z;
act->backuppos();
ps[j].angle.oang = ps[j].angle.ang = buildang(act->spr.ang);
updatesector(act->spr.pos.X, act->spr.pos.Y, &ps[j].cursector);
updatesector(act->int_pos().X, act->int_pos().Y, &ps[j].cursector);
j = connectpoint2[j];
@ -879,8 +879,8 @@ static void SpawnPortals()
sectortype* s1 = act->sector(), *s2 = act2->sector();
s1->portalflags = PORTAL_SECTOR_FLOOR;
s2->portalflags = PORTAL_SECTOR_CEILING;
s1->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);
s1->portalnum = portalAdd(PORTAL_SECTOR_FLOOR, sectnum(s2), act2->int_pos().X - act->int_pos().X, act2->int_pos().Y - act->int_pos().Y, act->spr.hitag);
s2->portalnum = portalAdd(PORTAL_SECTOR_CEILING, sectnum(s1), act->int_pos().X - act2->int_pos().X, act->int_pos().Y - act2->int_pos().Y, act->spr.hitag);
processedTags.Push(act->spr.hitag);
}
else

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

@ -282,8 +282,8 @@ void prelevel_d(int g, TArray<DDukeActor*>& actors)
if (ac->spr.lotag == -1 && (ac->spr.cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
{
ps[0].exit.X = ac->spr.pos.X;
ps[0].exit.Y = ac->spr.pos.Y;
ps[0].exit.X = ac->int_pos().X;
ps[0].exit.Y = ac->int_pos().Y;
}
else
premapcontroller(ac);

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

@ -535,8 +535,8 @@ void prelevel_r(int g, TArray<DDukeActor*>& actors)
if (ac->spr.lotag == -1 && (ac->spr.cstat & CSTAT_SPRITE_ALIGNMENT_WALL))
{
ps[0].exit.X = ac->spr.pos.X;
ps[0].exit.Y = ac->spr.pos.Y;
ps[0].exit.X = ac->int_pos().X;
ps[0].exit.Y = ac->int_pos().Y;
}
else switch (ac->spr.picnum)
{

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

@ -96,7 +96,7 @@ void GameInterface::UpdateCameras(double smoothratio)
display_mirror = 1; // should really be 'display external view'.
auto cstat = camera->spr.cstat;
camera->spr.cstat = CSTAT_SPRITE_INVISIBLE;
render_camtex(camera, camera->spr.pos, camera->sector(), ang, buildhoriz(camera->spr.shade), buildang(0), tex, rect, smoothratio);
render_camtex(camera, camera->int_pos(), camera->sector(), ang, buildhoriz(camera->spr.shade), buildang(0), tex, rect, smoothratio);
camera->spr.cstat = cstat;
display_mirror = 0;
});
@ -264,7 +264,7 @@ void displayrooms(int snum, double smoothratio, bool sceneonly)
auto bh = buildhoriz(act->spr.yvel);
auto cstat = act->spr.cstat;
act->spr.cstat = CSTAT_SPRITE_INVISIBLE;
renderView(act, act->sector(), act->spr.pos.X, act->spr.pos.Y, act->spr.pos.Z - (4 << 8), cang, bh, buildang(0), smoothratio, sceneonly, fov);
renderView(act, act->sector(), act->int_pos().X, act->int_pos().Y, act->int_pos().Z - (4 << 8), cang, bh, buildang(0), smoothratio, sceneonly, fov);
act->spr.cstat = cstat;
}
@ -329,9 +329,9 @@ void displayrooms(int snum, double smoothratio, bool sceneonly)
auto act = p->newOwner;
cang = buildang(act->interpolatedang(smoothratio));
choriz = buildhoriz(act->spr.shade);
cposx = act->spr.pos.X;
cposy = act->spr.pos.Y;
cposz = act->spr.pos.Z;
cposx = act->int_pos().X;
cposy = act->int_pos().Y;
cposz = act->int_pos().Z;
sect = act->sector();
rotscrnang = buildang(0);
smoothratio = MaxSmoothRatio;

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

@ -216,7 +216,7 @@ int findplayer(const DDukeActor* actor, int* d)
{
int j, closest_player;
int x, closest;
const auto s = actor->spr.pos;
const auto s = actor->int_pos();
if (ud.multimode < 2)
{
@ -640,7 +640,7 @@ static void handle_st15(sectortype* sptr, DDukeActor* actor)
}
else
{
if (sptr->floorz > a2->spr.pos.Z)
if (sptr->floorz > a2->int_pos().Z)
activatewarpelevators(a2, -1);
else
activatewarpelevators(a2, 1);
@ -753,7 +753,7 @@ REDODOOR:
{
if (a2->spr.statnum == 3 && a2->spr.lotag == 9)
{
j = a2->spr.pos.Z;
j = a2->int_pos().Z;
break;
}
}

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

@ -240,8 +240,8 @@ bool checkhitswitch_d(int snum, walltype* wwal, DDukeActor *act)
lotag = act->spr.lotag;
if (lotag == 0) return 0;
hitag = act->spr.hitag;
sx = act->spr.pos.X;
sy = act->spr.pos.Y;
sx = act->int_pos().X;
sy = act->int_pos().Y;
picnum = act->spr.picnum;
switchpal = act->spr.pal;
}
@ -1050,7 +1050,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.pos.Y - proj->spr.pos.Y) - 512;
targ->spr.ang = getangle(targ->int_pos().X - proj->int_pos().X, targ->int_pos().Y - proj->int_pos().Y) - 512;
if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
S_PlayActorSound(POOLBALLHIT, targ);
}
@ -1089,7 +1089,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
{
for (k = 0; k < 64; k++)
{
auto spawned = EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
auto spawned = EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (krand() % (48 << 8)), SCRAP3 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
spawned->spr.pal = 8;
}
@ -1102,7 +1102,7 @@ void checkhitsprite_d(DDukeActor* targ, DDukeActor* proj)
case HANGLIGHT:
case GENERICPOLE2:
for (k = 0; k < 6; k++)
EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (8 << 8), SCRAP1 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
S_PlayActorSound(GLASS_HEAVYBREAK, targ);
deletesprite(targ);
break;
@ -1132,7 +1132,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->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
spawn(targ, EXPLOSION2);
deletesprite(targ);

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

@ -359,8 +359,8 @@ bool checkhitswitch_r(int snum, walltype* wwal, DDukeActor* act)
lotag = act->spr.lotag;
if (lotag == 0) return 0;
hitag = act->spr.hitag;
sx = act->spr.pos.X;
sy = act->spr.pos.Y;
sx = act->int_pos().X;
sy = act->int_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->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
}
return;
}
@ -967,7 +967,7 @@ static void lotsofpopcorn(DDukeActor *actor, walltype* wal, int n)
{
z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
z = actor->int_pos().Z - (32 << 8) + (krand() & ((64 << 8) - 1));
a = actor->spr.ang - 1024;
EGS(actor->sector(), x1, y1, z, POPCORN, -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
}
@ -2059,7 +2059,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
lotsofglass(targ, nullptr, 10);
targ->spr.picnum++;
for (k = 0; k < 6; k++)
EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (8 << 8), SCRAP6 + (krand() & 15), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
break;
case BOWLINGBALL:
proj->spr.xvel = (targ->spr.xvel >> 1) + (targ->spr.xvel >> 2);
@ -2077,7 +2077,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.pos.Y - proj->spr.pos.Y) - 512;
targ->spr.ang = getangle(targ->int_pos().X - proj->int_pos().X, targ->int_pos().Y - proj->int_pos().Y) - 512;
if (S_CheckSoundPlaying(POOLBALLHIT) < 2)
S_PlayActorSound(POOLBALLHIT, targ);
}
@ -2126,7 +2126,7 @@ void checkhitsprite_r(DDukeActor* targ, DDukeActor* proj)
{
for (k = 0; k < 64; k++)
{
auto spawned = EGS(targ->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->spr.pos.Z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
auto spawned = EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->int_pos().Z - (krand() % (48 << 8)), SCRAP6 + (krand() & 3), -8, 48, 48, krand() & 2047, (krand() & 63) + 64, -(krand() & 4095) - (targ->spr.zvel >> 2), targ, 5);
if (spawned) spawned->spr.pal = 8;
}
@ -2158,7 +2158,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->sector(), targ->spr.pos.X, targ->spr.pos.Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
EGS(targ->sector(), targ->int_pos().X, targ->int_pos().Y, targ->sector()->floorz - (12 << 8) - (j << 9), SCRAP1 + (krand() & 15), -8, 64, 64,
krand() & 2047, (krand() & 127) + 64, -(krand() & 511) - 256, targ, 5);
spawn(targ, EXPLOSION2);
deletesprite(targ);

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

@ -276,7 +276,7 @@ static int GetPositionInfo(DDukeActor* actor, int soundNum, sectortype* sect,
sndist += dist_adjust;
if (sndist < 0) sndist = 0;
if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (24 << 8), actor->sector()))
if (sect!= nullptr && sndist && actor->spr.picnum != MUSICANDSFX && !cansee(cam->X, cam->Y, cam->Z - (24 << 8), sect, actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (24 << 8), actor->sector()))
sndist += sndist >> (isRR() ? 2 : 5);
// Here the sound distance was clamped to a minimum of 144*4.
@ -321,7 +321,7 @@ void S_GetCamera(vec3_t* c, int32_t* ca, sectortype** cs)
}
else
{
if (c) *c = ud.cameraactor->spr.pos;
if (c) *c = ud.cameraactor->int_pos();
if (cs) *cs = ud.cameraactor->sector();
if (ca) *ca = ud.cameraactor->spr.ang;
}
@ -356,7 +356,7 @@ void DukeSoundEngine::CalcPosVel(int type, const void* source, const float pt[3]
auto aactor = (DDukeActor*)source;
if (aactor != nullptr)
{
GetPositionInfo(aactor, chanSound - 1, camsect, &campos, aactor->spr.pos, nullptr, pos);
GetPositionInfo(aactor, chanSound - 1, camsect, &campos, aactor->int_pos(), nullptr, pos);
/*
if (vel) // DN3D does not properly maintain this.
{
@ -536,7 +536,7 @@ int S_PlaySound(int sndnum, int channel, EChanFlags flags, float vol)
int S_PlayActorSound(int soundNum, DDukeActor* actor, int channel, EChanFlags flags)
{
return (actor == nullptr ? S_PlaySound(soundNum, channel, flags) :
S_PlaySound3D(soundNum, actor, actor->spr.pos, channel, flags));
S_PlaySound3D(soundNum, actor, actor->int_pos(), channel, flags));
}
void S_StopSound(int sndNum, DDukeActor* actor, int channel)

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

@ -216,7 +216,7 @@ DDukeActor* spawn(DDukeActor* actj, int pn)
{
if (actj)
{
auto spawned = EGS(actj->sector(), actj->spr.pos.X, actj->spr.pos.Y, actj->spr.pos.Z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
auto spawned = EGS(actj->sector(), actj->int_pos().X, actj->int_pos().Y, actj->int_pos().Z, pn, 0, 0, 0, 0, 0, 0, actj, 0);
if (spawned)
{
spawned->attackertype = actj->spr.picnum;
@ -326,7 +326,7 @@ void spawntransporter(DDukeActor *actj, DDukeActor* act, bool beam)
act->spr.xvel = 128;
ChangeActorStat(act, STAT_MISC);
ssp(act, CLIPMASK0);
SetActor(act, act->spr.pos);
SetActor(act, act->int_pos());
}
//---------------------------------------------------------------------------
@ -339,16 +339,16 @@ int spawnbloodpoolpart1(DDukeActor* act)
{
auto s1 = act->sector();
updatesector(act->spr.pos.X + 108, act->spr.pos.Y + 108, &s1);
updatesector(act->int_pos().X + 108, act->int_pos().Y + 108, &s1);
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 108, act->spr.pos.Y - 108, &s1);
updatesector(act->int_pos().X - 108, act->int_pos().Y - 108, &s1);
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X + 108, act->spr.pos.Y - 108, &s1);
updatesector(act->int_pos().X + 108, act->int_pos().Y - 108, &s1);
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 108, act->spr.pos.Y + 108, &s1);
updatesector(act->int_pos().X - 108, act->int_pos().Y + 108, &s1);
if (s1 && s1->floorz != act->sector()->floorz)
{
act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return true;
@ -381,16 +381,16 @@ void initfootprint(DDukeActor* actj, DDukeActor* act)
{
auto s1 = act->sector();
updatesector(act->spr.pos.X + 84, act->spr.pos.Y + 84, &s1);
updatesector(act->int_pos().X + 84, act->int_pos().Y + 84, &s1);
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 84, act->spr.pos.Y - 84, &s1);
updatesector(act->int_pos().X - 84, act->int_pos().Y - 84, &s1);
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X + 84, act->spr.pos.Y - 84, &s1);
updatesector(act->int_pos().X + 84, act->int_pos().Y - 84, &s1);
if (s1 && s1->floorz == act->sector()->floorz)
{
updatesector(act->spr.pos.X - 84, act->spr.pos.Y + 84, &s1);
updatesector(act->int_pos().X - 84, act->int_pos().Y + 84, &s1);
if (s1 && s1->floorz != act->sector()->floorz)
{
act->spr.xrepeat = act->spr.yrepeat = 0; ChangeActorStat(act, STAT_MISC); return;
@ -439,10 +439,10 @@ void initshell(DDukeActor* actj, DDukeActor* act, bool isshell)
else
{
a = act->spr.ang;
act->set_int_z(actj->spr.pos.Z - gs.playerheight + (3 << 8));
act->set_int_z(actj->int_pos().Z - gs.playerheight + (3 << 8));
}
act->set_int_xy(actj->spr.pos.X + bcos(a, -7), actj->spr.pos.Y + bsin(a, -7));
act->set_int_xy(actj->int_pos().X + bcos(a, -7), actj->int_pos().Y + bsin(a, -7));
act->spr.shade = -8;
@ -480,7 +480,7 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
act->temp_data[4] = cranes.Reserve(1);
auto& apt = cranes[act->temp_data[4]];
apt.pos = act->spr.pos;
apt.pos = act->int_pos();
apt.poleactor = nullptr;
DukeStatIterator it(STAT_DEFAULT);
@ -495,13 +495,13 @@ void initcrane(DDukeActor* actj, DDukeActor* act, int CRANEPOLE)
actk->spr.xrepeat = 48;
actk->spr.yrepeat = 128;
apt.pole.X = actk->spr.pos.X;
apt.pole.Y = actk->spr.pos.Y;
apt.pole.X = actk->int_pos().X;
apt.pole.Y = actk->int_pos().Y;
actk->set_int_pos(act->spr.pos);
actk->set_int_pos(act->int_pos());
actk->spr.shade = act->spr.shade;
SetActor(actk, actk->spr.pos);
SetActor(actk, actk->int_pos());
break;
}
}
@ -528,14 +528,14 @@ void initwaterdrip(DDukeActor* actj, DDukeActor* actor)
actor->add_int_z(-(18 << 8));
}
else actor->add_int_z(-(13 << 8));
actor->spr.ang = getangle(ps[connecthead].pos.X - actor->spr.pos.X, ps[connecthead].pos.Y - actor->spr.pos.Y);
actor->spr.ang = getangle(ps[connecthead].pos.X - actor->int_pos().X, ps[connecthead].pos.Y - actor->int_pos().Y);
actor->spr.xvel = 48 - (krand() & 31);
ssp(actor, CLIPMASK0);
}
else if (!actj)
{
actor->add_int_z(4 << 8);
actor->temp_data[0] = actor->spr.pos.Z;
actor->temp_data[0] = actor->int_pos().Z;
if (!isRR()) actor->temp_data[1] = krand() & 127;
}
actor->spr.xrepeat = 24;
@ -626,7 +626,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
}
else actor->SetOwner(actor);
actor->temp_data[4] = sectp->floorz == actor->spr.pos.Z;
actor->temp_data[4] = sectp->floorz == actor->int_pos().Z;
actor->spr.cstat = 0;
ChangeActorStat(actor, STAT_TRANSPORT);
return;
@ -640,13 +640,13 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
{
actor->temp_data[1] = sectp->ceilingz;
if (actor->spr.pal)
sectp->setceilingz(actor->spr.pos.Z);
sectp->setceilingz(actor->int_pos().Z);
}
else
{
actor->temp_data[1] = sectp->floorz;
if (actor->spr.pal)
sectp->setfloorz(actor->spr.pos.Z);
sectp->setfloorz(actor->int_pos().Z);
}
actor->spr.hitag <<= 2;
@ -664,11 +664,11 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
else
actor->temp_data[4] = sectp->ceilingz;
sectp->setceilingz(actor->spr.pos.Z);
sectp->setceilingz(actor->int_pos().Z);
StartInterpolation(sectp, Interp_Sect_Ceilingz);
break;
case SE_35:
sectp->setceilingz(actor->spr.pos.Z);
sectp->setceilingz(actor->int_pos().Z);
break;
case SE_27_DEMO_CAM:
if (ud.recstat == 1)
@ -692,20 +692,20 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
actor->temp_data[0] = sectp->ceilingz;
actor->temp_data[1] = sectp->floorz;
bool ceiling = (abs(actor->temp_data[0] - actor->spr.pos.Z) < abs(actor->temp_data[1] - actor->spr.pos.Z));
bool ceiling = (abs(actor->temp_data[0] - actor->int_pos().Z) < abs(actor->temp_data[1] - actor->int_pos().Z));
actor->spriteextra = ceiling;
if (actor->spr.ang == 512)
{
if (ceiling)
sectp->setceilingz(actor->spr.pos.Z);
sectp->setceilingz(actor->int_pos().Z);
else
sectp->setfloorz(actor->spr.pos.Z);
sectp->setfloorz(actor->int_pos().Z);
}
else
{
sectp->setceilingz(actor->spr.pos.Z);
sectp->setfloorz(actor->spr.pos.Z);
sectp->setceilingz(actor->int_pos().Z);
sectp->setfloorz(actor->int_pos().Z);
}
if (sectp->ceilingstat & CSTAT_SECTOR_SKY)
@ -779,7 +779,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
for (auto& wal : wallsofsector(sectp))
{
d = FindDistance2D(actor->spr.pos.vec2 - wal.wall_int_pos());
d = FindDistance2D(actor->int_pos().vec2 - wal.wall_int_pos());
if (d < q)
{
q = d;
@ -793,7 +793,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
for (auto& wal : wallsofsector(sectp))
{
d = FindDistance2D(actor->spr.pos.vec2 - wal.wall_int_pos());
d = FindDistance2D(actor->int_pos().vec2 - wal.wall_int_pos());
if (d < q && &wal != actor->temp_walls[0])
{
q = d;
@ -831,7 +831,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_31_FLOOR_RISE_FALL:
actor->temp_data[1] = sectp->floorz;
// actor->temp_data[2] = actor->spr.hitag;
if (actor->spr.ang != 1536) sectp->setfloorz(actor->spr.pos.Z);
if (actor->spr.ang != 1536) sectp->setfloorz(actor->int_pos().Z);
for (auto& wal : wallsofsector(sectp))
if (wal.hitag == 0) wal.hitag = 9999;
@ -842,7 +842,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_32_CEILING_RISE_FALL:
actor->temp_data[1] = sectp->ceilingz;
actor->temp_data[2] = actor->spr.hitag;
if (actor->spr.ang != 1536) sectp->setceilingz(actor->spr.pos.Z);
if (actor->spr.ang != 1536) sectp->setceilingz(actor->int_pos().Z);
for (auto& wal : wallsofsector(sectp))
if (wal.hitag == 0) wal.hitag = 9999;
@ -865,7 +865,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
case SE_9_DOWN_OPEN_DOOR_LIGHTS:
if (sectp->lotag &&
labs(sectp->ceilingz - actor->spr.pos.Z) > 1024)
labs(sectp->ceilingz - actor->int_pos().Z) > 1024)
sectp->lotag |= 32768; //If its open
[[fallthrough]];
case SE_8_UP_OPEN_DOOR_LIGHTS:
@ -931,7 +931,7 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
{
if (actor->spr.ang == 512)
{
actor->set_int_xy(act2->spr.pos.X, act2->spr.pos.Y);
actor->set_int_xy(act2->int_pos().X, act2->int_pos().Y);
}
found = true;
actor->SetOwner(act2);
@ -944,7 +944,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.pos.Y);
Printf("Found lonely Sector Effector (lotag 0) at (%d,%d)\n", actor->int_pos().X, actor->int_pos().Y);
return;
}
}
@ -952,8 +952,8 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
actor->temp_data[1] = tempwallptr;
for (auto& wal : wallsofsector(sectp))
{
msx[tempwallptr] = wal.wall_int_pos().X - actor->spr.pos.X;
msy[tempwallptr] = wal.wall_int_pos().Y - actor->spr.pos.Y;
msx[tempwallptr] = wal.wall_int_pos().X - actor->int_pos().X;
msy[tempwallptr] = wal.wall_int_pos().Y - actor->int_pos().Y;
tempwallptr++;
if (tempwallptr > 2047)
{
@ -983,7 +983,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.pos.Y);
I_Error("Subway found no zero'd sectors with locators\nat (%d,%d).\n", actor->int_pos().X, actor->int_pos().Y);
}
actor->SetOwner(nullptr);
@ -998,8 +998,8 @@ void spawneffector(DDukeActor* actor, TArray<DDukeActor*>* actors)
else if (actor->spr.lotag == SE_26)
{
actor->temp_data[3] = actor->spr.pos.X;
actor->temp_data[4] = actor->spr.pos.Y;
actor->temp_data[3] = actor->int_pos().X;
actor->temp_data[4] = actor->int_pos().Y;
if (actor->spr.shade == sectp->floorshade) //UP
actor->spr.zvel = -256;
else
@ -1087,7 +1087,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->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 1023), actor, 5);
}
return;
}
@ -1110,7 +1110,7 @@ void lotsofglass(DDukeActor *actor, walltype* wal, int n)
{
z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
z = actor->int_pos().Z - (32 << 8) + (krand() & ((64 << 8) - 1));
a = actor->spr.ang - 1024;
EGS(actor->sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 1023), actor, 5);
}
@ -1128,8 +1128,8 @@ void spriteglass(DDukeActor* actor, int n)
for (int j = n; j > 0; j--)
{
int a = krand() & 2047;
int z = actor->spr.pos.Z - ((krand() & 16) << 8);
auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, z, TILE_GLASSPIECES + (j % 3), krand() & 15, 36, 36, a, 32 + (krand() & 63), -512 - (krand() & 2047), actor, 5);
int z = actor->int_pos().Z - ((krand() & 16) << 8);
auto k = EGS(actor->sector(), actor->int_pos().X, actor->int_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;
}
}
@ -1180,7 +1180,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
for (j = n - 1; j >= 0; j--)
{
a = krand() & 2047;
auto k = EGS(actor->sector(), actor->spr.pos.X, actor->spr.pos.Y, actor->spr.pos.Z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
auto k = EGS(actor->sector(), actor->int_pos().X, actor->int_pos().Y, actor->int_pos().Z - (krand() & (63 << 8)), TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), 1024 - (krand() & 2047), actor, 5);
if (k) k->spr.pal = krand() & 15;
}
return;
@ -1199,7 +1199,7 @@ void lotsofcolourglass(DDukeActor* actor, walltype* wal, int n)
updatesector(x1, y1, &sect);
z = sect->floorz - (krand() & (abs(sect->ceilingz - sect->floorz)));
if (z < -(32 << 8) || z >(32 << 8))
z = actor->spr.pos.Z - (32 << 8) + (krand() & ((64 << 8) - 1));
z = actor->int_pos().Z - (32 << 8) + (krand() & ((64 << 8) - 1));
a = actor->spr.ang - 1024;
auto k = EGS(actor->sector(), x1, y1, z, TILE_GLASSPIECES + (j % 3), -32, 36, 36, a, 32 + (krand() & 63), -(krand() & 2047), actor, 5);
if (k) k->spr.pal = krand() & 7;

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

@ -146,7 +146,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case WATERSPLASH2:
if (actj)
{
SetActor(act, actj->spr.pos);
SetActor(act, actj->int_pos());
act->spr.xrepeat = act->spr.yrepeat = 8 + (krand() & 7);
}
else act->spr.xrepeat = act->spr.yrepeat = 16 + (krand() & 15);
@ -157,11 +157,11 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
{
if (actj->sector()->lotag == 2)
{
act->set_int_z(getceilzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8));
act->set_int_z(getceilzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y) + (16 << 8));
act->spr.cstat |= CSTAT_SPRITE_YFLIP;
}
else if (actj->sector()->lotag == 1)
act->set_int_z(getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y));
act->set_int_z(getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y));
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -294,8 +294,8 @@ 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->sector(), act->spr.pos.X, act->spr.pos.Y);
if (fz != act->spr.pos.Z)
int fz = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
if (fz != act->int_pos().Z)
act->set_int_z(fz);
act->add_int_z(-200);
}
@ -544,8 +544,8 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
break;
case SPOTLITE:
act->temp_data[0] = act->spr.pos.X;
act->temp_data[1] = act->spr.pos.Y;
act->temp_data[0] = act->int_pos().X;
act->temp_data[1] = act->int_pos().Y;
break;
case BULLETHOLE:
act->spr.xrepeat = act->spr.yrepeat = 3;
@ -638,8 +638,8 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
int x = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.pos.Z > x - (12 << 8))
int x = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
if (act->int_pos().Z > x - (12 << 8))
act->set_int_z(x - (12 << 8));
}
@ -720,7 +720,7 @@ DDukeActor* spawninit_d(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case TOUCHPLATE:
act->temp_data[2] = sectp->floorz;
if (sectp->lotag != 1 && sectp->lotag != 2)
sectp->setfloorz(act->spr.pos.Z);
sectp->setfloorz(act->int_pos().Z);
if (!isWorldTour())
{
if (act->spr.pal && ud.multimode > 1)
@ -744,7 +744,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.pos.Y);
Printf(TEXTCOLOR_YELLOW "WARNING: WATERBUBBLEMAKER %d @ %d,%d with hitag!=0. Applying fixup.\n", act->GetIndex(), act->int_pos().X, act->int_pos().Y);
act->spr.hitag = 0;
}
act->spr.cstat |= CSTAT_SPRITE_INVISIBLE;

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

@ -201,7 +201,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case MUD:
if (actj)
{
SetActor(act, actj->spr.pos);
SetActor(act, actj->int_pos());
act->spr.xrepeat = act->spr.yrepeat = 8 + (krand() & 7);
}
else act->spr.xrepeat = act->spr.yrepeat = 16 + (krand() & 15);
@ -212,11 +212,11 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
{
if (actj->sector()->lotag == 2)
{
act->set_int_z(getceilzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y) + (16 << 8));
act->set_int_z(getceilzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y) + (16 << 8));
act->spr.cstat |= CSTAT_SPRITE_YFLIP;
}
else if (actj->sector()->lotag == 1)
act->set_int_z(getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y));
act->set_int_z(getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y));
}
if (sectp->floorpicnum == FLOORSLIME ||
@ -569,8 +569,8 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
break;
case SPOTLITE:
act->temp_data[0] = act->spr.pos.X;
act->temp_data[1] = act->spr.pos.Y;
act->temp_data[0] = act->int_pos().X;
act->temp_data[1] = act->int_pos().Y;
break;
case BULLETHOLE:
act->spr.xrepeat = act->spr.yrepeat = 3;
@ -649,8 +649,8 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
if (actj)
{
int x = getflorzofslopeptr(act->sector(), act->spr.pos.X, act->spr.pos.Y);
if (act->spr.pos.Z > x - (12 << 8))
int x = getflorzofslopeptr(act->sector(), act->int_pos().X, act->int_pos().Y);
if (act->int_pos().Z > x - (12 << 8))
act->set_int_z(x - (12 << 8));
}
@ -717,7 +717,7 @@ DDukeActor* spawninit_r(DDukeActor* actj, DDukeActor* act, TArray<DDukeActor*>*
case TOUCHPLATE:
act->temp_data[2] = sectp->floorz;
if (sectp->lotag != 1 && sectp->lotag != 2)
sectp->setfloorz(act->spr.pos.Z);
sectp->setfloorz(act->int_pos().Z);
if (act->spr.pal && ud.multimode > 1)
{
act->spr.xrepeat = act->spr.yrepeat = 0;